Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
block_tree_node_t
bmrm_ll
bmrm_return_value_T
CAccuracyMeasureClass AccuracyMeasure used to measure accuracy of 2-class classifier
CAlphabetThe class Alphabet implements an alphabet and alphabet utility functions
CANOVAKernelANOVA (ANalysis Of VAriances) kernel
CAsciiFileA Ascii File access class
CAttenuatedEuclideanDistanceClass AttenuatedEuclideanDistance
CAttributeFeaturesImplements attributed features, that is in the simplest case a number of (attribute, value) pairs
CAUCKernelThe AUC kernel can be used to maximize the area under the receiver operator characteristic curve (AUC) instead of margin in SVM training
CAveragedPerceptronClass Averaged Perceptron implements the standard linear (online) algorithm. Averaged perceptron is the simple extension of Perceptron
CAvgDiagKernelNormalizerNormalize the kernel by either a constant or the average value of the diagonal elements (depending on argument c of the constructor)
CBalancedConditionalProbabilityTree
CBALMeasureClass BALMeasure used to measure balanced error of 2-class classifier
CBaseMulticlassMachine
CBesselKernelClass Bessel kernel
CBinaryClassEvaluationThe class TwoClassEvaluation, a base class used to evaluate binary classification labels
CBinaryFileA Binary file access class
CBinaryLabelsBinary Labels for binary classification
CBinaryStream< T >Memory mapped emulation via binary streams (files)
CBinnedDotFeaturesThe class BinnedDotFeatures contains a 0-1 conversion of features into bins
CBitStringString class embedding a string in a compact bit representation
CBrayCurtisDistanceClass Bray-Curtis distance
CCache< T >Template class Cache implements a simple cache
CCanberraMetricClass CanberraMetric
CCanberraWordDistanceClass CanberraWordDistance
CCauchyKernelCauchy kernel
CChebyshewMetricClass ChebyshewMetric
CChi2KernelThe Chi2 kernel operating on realvalued vectors computes the chi-squared distance between sets of histograms
CChiSquareDistanceClass ChiSquareDistance
CCircularKernelCircular kernel
CClusteringAccuracyClustering accuracy
CClusteringEvaluationThe base class used to evaluate clustering
CClusteringMutualInformationClustering (normalized) mutual information
CCombinedDotFeaturesFeatures that allow stacking of a number of DotFeatures
CCombinedFeaturesThe class CombinedFeatures is used to combine a number of of feature objects into a single CombinedFeatures object
CCombinedKernelThe Combined kernel is used to combine a number of kernels into a single CombinedKernel object by linear combination
CCommUlongStringKernelThe CommUlongString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 64bit integers
CCommWordStringKernelThe CommWordString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 16bit integers
CCompressorCompression library for compressing and decompressing buffers using one of the standard compression algorithms, LZO, GZIP, BZIP2 or LZMA
CConditionalProbabilityTree
CConjugateIndexConjugate index classifier. Described in:
CConstKernelThe Constant Kernel returns a constant for all elements
CContingencyTableEvaluationThe class ContingencyTableEvaluation a base class used to evaluate 2-class classification with TP, FP, TN, FN rates
CConverterClass Converter used to convert data
CCosineDistanceClass CosineDistance
CCplexClass CCplex to encapsulate access to the commercial cplex general purpose optimizer
CCPLEXSVMCplexSVM a SVM solver implementation based on cplex (unfinished)
CCrossCorrelationMeasureClass CrossCorrelationMeasure used to measure cross correlation coefficient of 2-class classifier
CCrossValidationBase class for cross-validation evaluation. Given a learning machine, a splitting strategy, an evaluation criterium, features and correspnding labels, this provides an interface for cross-validation. Results may be retrieved using the evaluate method. A number of repetitions may be specified for obtaining more accurate results. The arithmetic mean of different runs is returned along with confidence intervals, if a p-value is specified. Default number of runs is one, confidence interval combutation is disabled
CCrossValidationMKLStorageClass for storing MKL weights in every fold of cross-validation
CCrossValidationMulticlassStorageClass for storing multiclass evaluation information in every fold of cross-validation
CCrossValidationOutputClass for managing individual folds in cross-validation
CCrossValidationPrintOutputClass for outputting cross-validation intermediate results to the standard output. Simply prints all messages it gets
CCrossValidationResultType to encapsulate the results of an evaluation run. May contain confidence interval (if conf_int_alpha!=0). m_conf_int_alpha is the probability for an error, i.e. the value does not lie in the confidence interval
CCrossValidationSplittingImplementation of normal cross-validation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference)
CCustomDistanceThe Custom Distance allows for custom user provided distance matrices
CCustomKernelThe Custom Kernel allows for custom user provided kernel matrices
CDataDummy data holder
CDataGeneratorClass that is able to generate various data samples, which may be used for examples in SHOGUN
CDecompressString< ST >Preprocessor that decompresses compressed strings
CDenseDistance< ST >Template class DenseDistance
CDenseFeatures< ST >The class DenseFeatures implements dense feature matrices
CDenseLabelsDense integer or floating point labels
CDensePreprocessor< ST >Template class DensePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CDenseFeatures (i.e. rectangular dense matrices)
CDenseSubsetFeatures< ST >
CDiagKernelThe Diagonal Kernel returns a constant for the diagonal and zero otherwise
CDiceKernelNormalizerDiceKernelNormalizer performs kernel normalization inspired by the Dice coefficient (see http://en.wikipedia.org/wiki/Dice's_coefficient)
CDifferentiableFunctionDifferentiableFunction
CDiffusionMapsClass DiffusionMaps (part of the Efficient Dimensionality Reduction Toolkit) used to preprocess given data using Diffusion Maps dimensionality reduction technique as described in
CDimensionReductionPreprocessorClass DimensionReductionPreprocessor, a base class for preprocessors used to lower the dimensionality of given simple features (dense matrices)
CDistanceClass Distance, a base class for all the distances used in the Shogun toolbox
CDistanceKernelThe Distance kernel takes a distance as input
CDistanceMachineA generic DistanceMachine interface
CDistantSegmentsKernelThe distant segments kernel is a string kernel, which counts the number of substrings, so-called segments, at a certain distance from each other
CDistributionBase class Distribution from which all methods implementing a distribution are derived
CDixonQTestRejectionStrategySimplified version of Dixon's Q test outlier based rejection strategy. Statistic values are taken from http://www.vias.org/tmdatanaleng/cc_outlier_tests_dixon.html
CDomainAdaptationMulticlassLibLinearDomain adaptation multiclass LibLinear wrapper Source domain is assumed to b
CDomainAdaptationSVMClass DomainAdaptationSVM
CDomainAdaptationSVMLinearClass DomainAdaptationSVMLinear
CDotFeaturesFeatures that support dot products among other operations
CDotKernelTemplate class DotKernel is the base class for kernels working on DotFeatures
CDualLibQPBMSOSVMClass DualLibQPBMSOSVM that uses Bundle Methods for Regularized Risk Minimization algorithms for structured output (SO) problems [1] presented in [2]
CDummyFeaturesThe class DummyFeatures implements features that only know the number of feature objects (but don't actually contain any)
CDynamicArray< T >Template Dynamic array class that creates an array that can be used like a list or an array
CDynamicObjectArrayDynamic array class for CSGObject pointers that creates an array that can be used like a list or an array
CDynInt< T, sz >Integer type of dynamic size
CDynProgDynamic Programming Class
CECOCAEDDecoder
CECOCDecoder
CECOCDiscriminantEncoder
CECOCEDDecoder
CECOCEncoderECOCEncoder produce an ECOC codebook
CECOCForestEncoder
CECOCHDDecoder
CECOCIHDDecoder
CECOCLLBDecoder
CECOCOVOEncoder
CECOCOVREncoder
CECOCRandomDenseEncoder
CECOCRandomSparseEncoder
CECOCSimpleDecoder
CECOCStrategy
CECOCUtil
CEmbeddingConverterClass EmbeddingConverter (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of features, e.g. construct dense numeric embedding of string features
CErrorRateMeasureClass ErrorRateMeasure used to measure error rate of 2-class classifier
CEuclideanDistanceClass EuclideanDistance
CEvaluationClass Evaluation, a base class for other classes used to evaluate labels, e.g. accuracy of classification or mean squared error of regression
CEvaluationResultEvaluationResult is the abstract class that contains the result generated by the MachineEvaluation class
CExactInferenceMethodThe Gaussian Exact Form Inference Method
CExplicitSpecFeaturesFeatures that compute the Spectrum Kernel feature space explicitly
CExponentialKernelThe Exponential Kernel, closely related to the Gaussian Kernel computed on CDotFeatures
CF1MeasureClass F1Measure used to measure F1 score of 2-class classifier
CFeatureBlockLogisticRegressionClass FeatureBlockLogisticRegression, a linear binary logistic loss classifier for problems with complex feature relations. Currently two feature relations are supported - feature group (done via CIndexBlockGroup) and feature tree (done via CIndexTree). Handling of feature relations is done via L1/Lq (for groups) and L1/L2 (for trees) regularization
CFeaturesThe class Features is the base class of all feature objects
CFileA File access base class
CFirstElementKernelNormalizerNormalize the kernel by a constant obtained from the first element of the kernel matrix, i.e. $ c=k({\bf x},{\bf x})$
CFITCInferenceMethodThe Fully Independent Conditional Training Inference Method
CFixedDegreeStringKernelThe FixedDegree String kernel takes as input two strings of same size and counts the number of matches of length d
CFKFeaturesThe class FKFeatures implements Fischer kernel features obtained from two Hidden Markov models
CGaussianGaussian distribution interface
CGaussianARDKernelGaussian Kernel with Automatic Relevance Detection
CGaussianKernelThe well known Gaussian kernel (swiss army knife for SVMs) computed on CDotFeatures
CGaussianLikelihoodThis is the class that models a Gaussian Likelihood
CGaussianMatchStringKernelThe class GaussianMatchStringKernel computes a variant of the Gaussian kernel on strings of same length
CGaussianNaiveBayesClass GaussianNaiveBayes, a Gaussian Naive Bayes classifier
CGaussianProcessRegressionClass GaussianProcessRegression implements Gaussian Process Regression.vInstead of a distribution over weights, the GP specifies a distribution over functions
CGaussianShiftKernelAn experimental kernel inspired by the WeightedDegreePositionStringKernel and the Gaussian kernel
CGaussianShortRealKernelThe well known Gaussian kernel (swiss army knife for SVMs) on dense short-real valued features
CGCArray< T >Template class GCArray implements a garbage collecting static array
CGeodesicMetricClass GeodesicMetric
CGHMMClass GHMM - this class is non-functional and was meant to implement a Generalize Hidden Markov Model (aka Semi Hidden Markov HMM)
CGMMGaussian Mixture Model interface
CGMNPLibClass GMNPLib Library of solvers for Generalized Minimal Norm Problem (GMNP)
CGMNPSVMClass GMNPSVM implements a one vs. rest MultiClass SVM
CGNPPLibClass GNPPLib, a Library of solvers for Generalized Nearest Point Problem (GNPP)
CGNPPSVMClass GNPPSVM
CGPBTSVMClass GPBTSVM
CGradientCriterionCGradientCriterion Simple class which specifies the direction of gradient search. Does not provide any label evaluation measure, however
CGradientEvaluationGradientEvaluation evaluates a machine using its associated differentiable function for the function value and its gradient with respect to parameters
CGradientModelSelectionModel selection class which searches for the best model by a gradient- search
CGradientResultGradientResult is a container class that returns results from GradientEvaluation. It contains the function value as well as its gradient
CGridSearchModelSelectionModel selection class which searches for the best model by a grid- search. See CModelSelection for details
CGUIClassifierUI classifier
CGUIConverterUI converter
CGUIDistanceUI distance
CGUIFeaturesUI features
CGUIHMMUI HMM (Hidden Markov Model)
CGUIKernelUI kernel
CGUILabelsUI labels
CGUIMathUI math
CGUIPluginEstimateUI estimate
CGUIPreprocessorUI preprocessor
CGUIStructureUI structure
CGUITimeUI time
CHammingWordDistanceClass HammingWordDistance
CHashCollection of Hashing Functions
CHashedWDFeaturesFeatures that compute the Weighted Degreee Kernel feature space explicitly
CHashedWDFeaturesTransposedFeatures that compute the Weighted Degreee Kernel feature space explicitly
CHessianLocallyLinearEmbeddingClass HessianLocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to preprocess data using Hessian Locally Linear Embedding algorithm as described in
CHierarchicalAgglomerative hierarchical single linkage clustering
CHingeLossCHingeLoss implements the hinge loss function
CHistogramClass Histogram computes a histogram over all 16bit unsigned integers in the features
CHistogramIntersectionKernelThe HistogramIntersection kernel operating on realvalued vectors computes the histogram intersection distance between sets of histograms. Note: the current implementation assumes positive values for the histograms, and input vectors should sum to 1
CHistogramWordStringKernelThe HistogramWordString computes the TOP kernel on inhomogeneous Markov Chains
CHMMHidden Markov Model
CHMSVMLabelsClass CHMSVMLabels to be used in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HM-SVM). Each of the labels is represented by a sequence of integers. Each label is of type CSequence and all of them are stored in a CDynamicObjectArray
CHMSVMModelClass CHMSVMModel that represents the application specific model and contains the application dependent logic to solve Hidden Markov Support Vector Machines (HM-SVM) type of problems within a generic SO framework
CHomogeneousKernelMapPreprocessor HomogeneousKernelMap performs homogeneous kernel maps as described in
CHSICThis class implements the Hilbert Schmidtd Independence Criterion based independence test as described in [1]
CIdentityKernelNormalizerIdentity Kernel Normalization, i.e. no normalization is applied
CImplicitWeightedSpecFeaturesFeatures that compute the Weighted Spectrum Kernel feature space explicitly
CIndexBlockClass IndexBlock used to represent contiguous indices of one group (e.g. block of related features)
CIndexBlockGroupClass IndexBlockGroup used to represent group-based feature relation
CIndexBlockRelationClass IndexBlockRelation
CIndexBlockTreeClass IndexBlockTree used to represent tree guided feature relation
CIndirectObject< T, P >Array class that accesses elements indirectly via an index array
CInferenceMethodThe Inference Method base class
CInputParser< T >Class CInputParser is a templated class used to maintain the reading/parsing/providing of examples
CIntronListClass IntronList
CInverseMultiQuadricKernelInverseMultiQuadricKernel
CIOBufferAn I/O buffer class
CIsomapClass Isomap (part of the Efficient Dimension Reduction Toolkit) used to embed data using Isomap algorithm as described in
CJensenMetricClass JensenMetric
CJensenShannonKernelThe Jensen-Shannon kernel operating on real-valued vectors computes the Jensen-Shannon distance between the features. Often used in computer vision
CJLCoverTreePointClass Point to use with John Langford's CoverTree. This class must have some assoficated functions defined (distance, parse_points and print, see below) so it can be used with the CoverTree implementation
CKernelThe Kernel base class
CKernelDistanceThe Kernel distance takes a distance as input
CKernelIndependenceTestStatisticIndependence test base class. Provides an interface for performing an independence test. Given samples $Z=\{(x_i,y_i)\}_{i=1}^m$ from the joint distribution $\textbf{P}_x\textbf{P}_y$, does the joint distribution factorize as $\textbf{P}_{xy}=\textbf{P}_x\textbf{P}_y$? The null- hypothesis says yes, i.e. no independence, the alternative hypothesis says yes
CKernelLocallyLinearEmbeddingClass KernelLocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using kernel formulation of Locally Linear Embedding algorithm as described in
CKernelLocalTangentSpaceAlignmentClass LocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using kernel extension of the Local Tangent Space Alignment (LTSA) algorithm
CKernelMachineA generic KernelMachine interface
CKernelMeanMatchingKernel Mean Matching
CKernelMulticlassMachineGeneric kernel multiclass
CKernelNormalizerThe class Kernel Normalizer defines a function to post-process kernel values
CKernelPCAPreprocessor KernelPCA performs kernel principal component analysis
CKernelRidgeRegressionClass KernelRidgeRegression implements Kernel Ridge Regression - a regularized least square method for classification and regression
CKernelStructuredOutputMachine
CKernelTwoSampleTestStatisticTwo sample test base class. Provides an interface for performing a two-sample test, i.e. Given samples from two distributions $p$ and $q$, the null-hypothesis is: $H_0: p=q$, the alternative hypothesis: $H_1: p\neq q$
CKMeansKMeans clustering, partitions the data into k (a-priori specified) clusters
CKNNClass KNN, an implementation of the standard k-nearest neigbor classifier
CLabelsThe class Labels models labels, i.e. class assignments of objects
CLaplacianEigenmapsClass LaplacianEigenmaps (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using Laplacian Eigenmaps algorithm as described in:
CLaplacianInferenceMethodThe Laplace Approximation Inference Method
CLaRankLaRank multiclass SVM machine
CLatentFeaturesLatent Features class The class if for representing features for latent learning, e.g. LatentSVM. It's basically a very generic way of storing features of any (user-defined) form based on CData
CLatentLabelsAbstract class for latent labels As latent labels always depends on the given application, this class only defines the API that the user has to implement for latent labels
CLatentModelAbstract class CLatentModel It represents the application specific model and contains most of the application dependent logic to solve latent variable based problems
CLatentSOSVMClass Latent Structured Output SVM, an structured output based machine for classification problems with latent variables
CLatentSVMLatentSVM class Latent SVM implementation based on [1]. For optimization this implementation uses SVMOcas
CLBPPyrDotFeaturesImplement DotFeatures for the polynomial kernel
CLDAClass LDA implements regularized Linear Discriminant Analysis
CLeastAngleRegressionClass for Least Angle Regression, can be used to solve LASSO
CLeastSquaresRegressionClass to perform Least Squares Regression
CLibLinearClass to implement LibLinear
CLibLinearMTLClass to implement LibLinear
CLibLinearRegressionLibLinear for regression
CLibSVMLibSVM
CLibSVMOneClassClass LibSVMOneClass
CLibSVRClass LibSVR, performs support vector regression using LibSVM
CLikelihoodModelThe Likelihood Model base class
CLinearARDKernelLinear Kernel with Automatic Relevance Detection
CLinearHMMThe class LinearHMM is for learning Higher Order Markov chains
CLinearKernelComputes the standard linear kernel on CDotFeatures
CLinearLatentMachineAbstract implementaion of Linear Machine with latent variable This is the base implementation of all linear machines with latent variable
CLinearLocalTangentSpaceAlignmentClass LinearLocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) converter used to construct embeddings as described in:
CLinearMachineClass LinearMachine is a generic interface for all kinds of linear machines like classifiers
CLinearMulticlassMachineGeneric linear multiclass machine
CLinearRidgeRegressionClass LinearRidgeRegression implements Ridge Regression - a regularized least square method for classification and regression
CLinearStringKernelComputes the standard linear kernel on dense char valued features
CLinearStructuredOutputMachine
CLinearTimeMMDThis class implements the linear time Maximum Mean Statistic as described in [1]. This statistic is in particular suitable for streaming data. Therefore, only streaming features may be passed. To process other feature types, construct streaming features from these (see constructor documentations). A blocksize has to be specified that determines how many examples are processed at once. This should be set as large as available memory allows to ensure faster computations
CListClass List implements a doubly connected list for low-level-objects
CListElementClass ListElement, defines how an element of the the list looks like
CLocalAlignmentStringKernelThe LocalAlignmentString kernel compares two sequences through all possible local alignments between the two sequences
CLocalityImprovedStringKernelThe LocalityImprovedString kernel is inspired by the polynomial kernel. Comparing neighboring characters it puts emphasize on local features
CLocalityPreservingProjectionsClass LocalityPreservingProjections (part of the Efficient Dimensionality Reduction Toolkit) used to compute embeddings of data using Locality Preserving Projections method as described in
CLocallyLinearEmbeddingClass LocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using Locally Linear Embedding algorithm described in
CLocalTangentSpaceAlignmentClass LocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using Local Tangent Space Alignment (LTSA) algorithm as described in:
CLogKernelLog kernel
CLogLossCLogLoss implements the logarithmic loss function
CLogLossMarginClass CLogLossMargin implements a margin-based log-likelihood loss function
CLogPlusOnePreprocessor LogPlusOne does what the name says, it adds one to a dense real valued vector and takes the logarithm of each component of it
CLossClass which collects generic mathematical functions
CLossFunctionClass CLossFunction is the base class of all loss functions
CLPBoostClass LPBoost trains a linear classifier called Linear Programming Machine, i.e. a SVM using a $\ell_1$ norm regularizer
CLPMClass LPM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a $\ell_1$ norm regularizer
CMachineA generic learning machine interface
CMachineEvaluationMachine Evaluation is an abstract class that evaluates a machine according to some criterion
CMahalanobisDistanceClass MahalanobisDistance
CManhattanMetricClass ManhattanMetric
CManhattanWordDistanceClass ManhattanWordDistance
CMap< K, T >Class CMap, a map based on the hash-table. w: http://en.wikipedia.org/wiki/Hash_table
CMatchWordStringKernelThe class MatchWordStringKernel computes a variant of the polynomial kernel on strings of same length converted to a word alphabet
CMathClass which collects generic mathematical functions
CMatrixFeatures< ST >Class CMatrixFeatures used to represent data whose feature vectors are better represented with matrices rather than with unidimensional arrays or vectors. Optionally, it can be restricted that all the feature vectors have the same number of features. Set the attribute num_features different to zero to use this restriction. Allow feature vectors with different number of features by setting num_features equal to zero (default behaviour)
CMeanAbsoluteErrorClass MeanAbsoluteError used to compute an error of regression model
CMeanFunctionMean Function base class
CMeanShiftDataGenerator< T >Class to generate dense features data via the streaming features interface. The core are pairs of methods to a) set the data model and parameters, and b) to generate a data vector using these model parameters Both methods are automatically called when calling get_next_example() This allows to treat generated data as a stream via the standard streaming features interface
CMeanSquaredErrorClass MeanSquaredError used to compute an error of regression model
CMeanSquaredLogErrorClass CMeanSquaredLogError used to compute an error of regression model
CMemoryMappedFile< T >Memory mapped file
CMinkowskiMetricClass MinkowskiMetric
CMKLMultiple Kernel Learning
CMKLClassificationMultiple Kernel Learning for two-class-classification
CMKLMulticlassMKLMulticlass is a class for L1-norm multiclass MKL
CMKLOneClassMultiple Kernel Learning for one-class-classification
CMKLRegressionMultiple Kernel Learning for regression
CModelSelectionAbstract base class for model selection. Takes a parameter tree which specifies parameters for model selection, and a cross-validation instance and searches for the best combination of parameters in the abstract method select_model(), which has to be implemented in concrete sub-classes
CModelSelectionParametersClass to select parameters and their ranges for model selection. The structure is organized as a tree with different kinds of nodes, depending on the values of its member variables of name and CSGObject
CMPDSVMClass MPDSVM
CMulticlassAccuracyThe class MulticlassAccuracy used to compute accuracy of multiclass classification
CMulticlassLabelsMulticlass Labels for multi-class classification
CMulticlassLibLinearMulticlass LibLinear wrapper. Uses Crammer-Singer formulation and gradient descent optimization algorithm implemented in the LibLinear library. Regularized bias support is added using stacking bias 'feature' to hyperplanes normal vectors
CMulticlassLibSVMClass LibSVMMultiClass. Does one vs one classification
CMulticlassLogisticRegressionMulticlass logistic regression
CMulticlassMachineExperimental abstract generic multiclass machine class
CMulticlassModelClass CMulticlassModel that represents the application specific model and contains the application dependent logic to solve multiclass classification within a generic SO framework
CMulticlassMultipleOutputLabelsMulticlass Labels for multi-class classification with multiple labels
CMulticlassOCASMulticlass OCAS wrapper
CMulticlassOneVsOneStrategyMulticlass one vs one strategy used to train generic multiclass machines for K-class problems with building voting-based ensemble of K*(K-1) binary classifiers
CMulticlassOneVsRestStrategyMulticlass one vs rest strategy used to train generic multiclass machines for K-class problems with building ensemble of K binary classifiers
CMulticlassOVREvaluationThe class MulticlassOVREvaluation used to compute evaluation parameters of multiclass classification via binary OvR decomposition and given binary evaluation technique
CMulticlassSOLabelsClass CMulticlassSOLabels to be used in the application of Structured Output (SO) learning to multiclass classification. Each of the labels is represented by a real number and it is required that the values of the labels are in the set {0, 1, ..., num_classes-1}. Each label is of type CRealNumber and all of them are stored in a CDynamicObjectArray
CMulticlassStrategyClass MulticlassStrategy used to construct generic multiclass classifiers with ensembles of binary classifiers
CMulticlassSVMClass MultiClassSVM
CMulticlassTreeGuidedLogisticRegressionMulticlass tree guided logistic regression
CMultidimensionalScalingClass Multidimensionalscaling (part of the Efficient Dimensionality Reduction Toolkit) is used to perform multidimensional scaling (capable of landmark approximation if requested)
CMultiquadricKernelMultiquadricKernel
CMultitaskClusteredLogisticRegressionClass MultitaskClusteredLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library. Assumes task in group are related with a clustered structure
CMultitaskCompositeMachineClass MultitaskCompositeMachine used to solve multitask binary classification problems with separate training of given binary classifier on each task
CMultitaskKernelMaskNormalizerThe MultitaskKernel allows Multitask Learning via a modified kernel function
CMultitaskKernelMaskPairNormalizerThe MultitaskKernel allows Multitask Learning via a modified kernel function
CMultitaskKernelMklNormalizerBase-class for parameterized Kernel Normalizers
CMultitaskKernelNormalizerThe MultitaskKernel allows Multitask Learning via a modified kernel function
CMultitaskKernelPlifNormalizerThe MultitaskKernel allows learning a piece-wise linear function (PLIF) via MKL
CMultitaskKernelTreeNormalizerThe MultitaskKernel allows Multitask Learning via a modified kernel function based on taxonomy
CMultitaskL12LogisticRegressionClass MultitaskL12LogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library
CMultitaskLeastSquaresRegressionClass Multitask Least Squares Regression, a machine to solve regression problems with a few tasks related via group or tree. Based on L1/Lq regression for groups and L1/L2 for trees
CMultitaskLinearMachineClass MultitaskLinearMachine, a base class for linear multitask classifiers
CMultitaskLogisticRegressionClass Multitask Logistic Regression used to solve classification problems with a few tasks related via group or tree. Based on L1/Lq regression for groups and L1/L2 for trees
CMultitaskROCEvaluationClass MultitaskROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) of each task separately
CMultitaskTraceLogisticRegressionClass MultitaskTraceLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library
CNativeMulticlassMachineExperimental abstract native multiclass machine class
CNearestCentroidClass NearestCentroid, an implementation of Nearest Shrunk Centroid classifier
CNeighborhoodPreservingEmbeddingNeighborhoodPreservingEmbedding (part of the Efficient Dimensionality Reduction Toolkit) converter used to construct embeddings as described in:
CNewtonSVMNewtonSVM, In this Implementation linear SVM is trained in its primal form using Newton-like iterations. This Implementation is ported from the Olivier Chapelles fast newton based SVM solver, Which could be found here :http://mloss.org/software/view/30/ For further information on this implementation of SVM refer to this paper: http://www.kyb.mpg.de/publications/attachments/neco_%5B0%5D.pdf
CNodeA CNode is an element of a CTaxonomy, which is used to describe hierarchical structure between tasks
CNormOnePreprocessor NormOne, normalizes vectors to have norm 1
COligoStringKernelThis class offers access to the Oligo Kernel introduced by Meinicke et al. in 2004
ConditionalProbabilityTreeNodeDataStruct to store data of node of conditional probability tree
COnlineLibLinearClass implementing a purely online version of LibLinear, using the L2R_L1LOSS_SVC_DUAL solver only
COnlineLinearMachineClass OnlineLinearMachine is a generic interface for linear machines like classifiers which work through online algorithms
COnlineSVMSGDClass OnlineSVMSGD
CoverTree< Point >
CParameterCombinationClass that holds ONE combination of parameters for a learning machine. The structure is organized as a tree. Every node may hold a name or an instance of a Parameter class. Nodes may have children. The nodes are organized in such way, that every parameter of a model for model selection has one node and sub-parameters are stored in sub-nodes. Using a tree of this class, parameters of models may easily be set. There are these types of nodes:
CParseBuffer< T >Class CParseBuffer implements a ring of examples of a defined size. The ring stores objects of the Example type
CPCAPreprocessor PCACut performs principial component analysis on the input vectors and keeps only the n eigenvectors with eigenvalues above a certain threshold
CPerceptronClass Perceptron implements the standard linear (online) perceptron
CPlifClass Plif
CPlifArrayClass PlifArray
CPlifBaseClass PlifBase
CPlifMatrixStore plif arrays for all transitions in the model
CPluginEstimateClass PluginEstimate
CPNormPreprocessor PNorm, normalizes vectors to have p-norm
CPolyFeaturesImplement DotFeatures for the polynomial kernel
CPolyKernelComputes the standard polynomial kernel on CDotFeatures
CPolyMatchStringKernelThe class PolyMatchStringKernel computes a variant of the polynomial kernel on strings of same length
CPolyMatchWordStringKernelThe class PolyMatchWordStringKernel computes a variant of the polynomial kernel on word-features
CPositionalPWMPositional PWM
CPowerKernelPower kernel
CPRCEvaluationClass PRCEvaluation used to evaluate PRC (Precision Recall Curve) and an area under PRC curve (auPRC)
CPrecisionMeasureClass PrecisionMeasure used to measure precision of 2-class classifier
CPreprocessorClass Preprocessor defines a preprocessor interface
CProductKernelThe Product kernel is used to combine a number of kernels into a single ProductKernel object by element multiplication
CPruneVarSubMeanPreprocessor PruneVarSubMean will substract the mean and remove features that have zero variance
CPyramidChi2Pyramid Kernel over Chi2 matched histograms
CQDAClass QDA implements Quadratic Discriminant Analysis
CQPBSVMLibClass QPBSVMLib
CQuadraticTimeMMDThis class implements the quadratic time Maximum Mean Statistic as described in [1]. The MMD is the distance of two probability distributions $p$ and $q$ in a RKHS

\[ \text{MMD}}[\mathcal{F},p,q]^2=\textbf{E}_{x,x'}\left[ k(x,x')\right]- 2\textbf{E}_{x,y}\left[ k(x,y)\right] +\textbf{E}_{y,y'}\left[ k(y,y')\right]=||\mu_p - \mu_q||^2_\mathcal{F} \]

CRandomConditionalProbabilityTree
CRandomFourierGaussPreprocPreprocessor CRandomFourierGaussPreproc implements Random Fourier Features for the Gauss kernel a la Ali Rahimi and Ben Recht Nips2007 after preprocessing the features using them in a linear kernel approximates a gaussian kernel
CRandomSearchModelSelectionModel selection class which searches for the best model by a random search. See CModelSelection for details
CRationalQuadraticKernelRational Quadratic kernel
CRealDistanceClass RealDistance
CRealFileFeaturesThe class RealFileFeatures implements a dense double-precision floating point matrix from a file
CRealNumberClass CRealNumber to be used in the application of Structured Output (SO) learning to multiclass classification. Even though it is likely that it does not make sense to consider real numbers as structured data, it has been made in this way because the basic type to use in structured labels needs to inherit from CStructuredData
CRecallMeasureClass RecallMeasure used to measure recall of 2-class classifier
CRegressionLabelsReal Labels are real-valued labels
CRegulatoryModulesStringKernelThe Regulaty Modules kernel, based on the WD kernel, as published in Schultheiss et al., Bioinformatics (2009) on regulatory sequences
CRejectionStrategyBase rejection strategy class
CRelaxedTree
CResultSet
CRidgeKernelNormalizerNormalize the kernel by adding a constant term to its diagonal. This aids kernels to become positive definite (even though they are not - often caused by numerical problems)
CROCEvaluationClass ROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC)
CSalzbergWordStringKernelThe SalzbergWordString kernel implements the Salzberg kernel
CScatterKernelNormalizerScatter kernel normalizer
CScatterSVMScatterSVM - Multiclass SVM
CSegmentLossClass IntronList
CSequenceClass CSequence to be used in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HM-SVM)
CSerializableAsciiFileSerializable ascii file
CSerializableFileSerializable file
CSet< T >Class CSet, a set based on the hash-table. w: http://en.wikipedia.org/wiki/Hash_table
CSGDQNClass SGDQN
CSGObjectClass SGObject is the base class of all shogun objects
CShareBoost
CSigmoidKernelThe standard Sigmoid kernel computed on dense real valued features
CSignalClass Signal implements signal handling to e.g. allow ctrl+c to cancel a long running process
CSimpleFile< T >Template class SimpleFile to read and write from files
CSimpleLocalityImprovedStringKernelSimpleLocalityImprovedString kernel, is a ``simplified'' and better performing version of the Locality improved kernel
CSmoothHingeLossCSmoothHingeLoss implements the smooth hinge loss function
CSNPFeaturesFeatures that compute the Weighted Degreee Kernel feature space explicitly
CSNPStringKernelThe class SNPStringKernel computes a variant of the polynomial kernel on strings of same length
CSortUlongStringPreprocessor SortUlongString, sorts the indivual strings in ascending order
CSortWordStringPreprocessor SortWordString, sorts the indivual strings in ascending order
CSparseDistance< ST >Template class SparseDistance
CSparseEuclideanDistanceClass SparseEucldeanDistance
CSparseFeatures< ST >Template class SparseFeatures implements sparse matrices
CSparseInverseCovarianceUsed to estimate inverse covariance matrix using graphical lasso
CSparseKernel< ST >Template class SparseKernel, is the base class of kernels working on sparse features
CSparsePolyFeaturesImplement DotFeatures for the polynomial kernel
CSparsePreprocessor< ST >Template class SparsePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CSparseFeatures
CSparseSpatialSampleStringKernelSparse Spatial Sample String Kernel by Pavel Kuksa <pkuksa@cs.rutgers.edu> and Vladimir Pavlovic <vladimir@cs.rutgers.edu>
CSpecificityMeasureClass SpecificityMeasure used to measure specificity of 2-class classifier
CSpectrumMismatchRBFKernelSpectrum mismatch rbf kernel
CSpectrumRBFKernelSpectrum rbf kernel
CSphericalKernelSpherical kernel
CSplineKernelComputes the Spline Kernel function which is the cubic polynomial
CSplittingStrategyAbstract base class for all splitting types. Takes a CLabels instance and generates a desired number of subsets which are being accessed by their indices via the method generate_subset_indices(...)
CSqrtDiagKernelNormalizerSqrtDiagKernelNormalizer divides by the Square Root of the product of the diagonal elements
CSquaredHingeLossClass CSquaredHingeLoss implements a squared hinge loss function
CSquaredLossCSquaredLoss implements the squared loss function
CStateModelClass CStateModel base, abstract class for the internal state representation used in the CHMSVMModel
CStatisticsClass that contains certain functions related to statistics, such as probability/cumulative distribution functions, different statistics, etc
CStochasticProximityEmbeddingClass StochasticProximityEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using the Stochastic Proximity algorithm
CStratifiedCrossValidationSplittingImplementation of stratified cross-validation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference) in which the label ratio is equal (at most one difference) to the label ratio of the specified labels. Do not use for regression since it may be impossible to distribute nice in that case
CStreamingAsciiFileClass StreamingAsciiFile to read vector-by-vector from ASCII files
CStreamingDenseFeatures< T >This class implements streaming features with dense feature vectors
CStreamingDotFeaturesStreaming features that support dot products among other operations
CStreamingFeaturesStreaming features are features which are used for online algorithms
CStreamingFileA Streaming File access class
CStreamingFileFromDenseFeatures< T >Class CStreamingFileFromDenseFeatures is a derived class of CStreamingFile which creates an input source for the online framework from a CDenseFeatures object
CStreamingFileFromFeaturesClass StreamingFileFromFeatures to read vector-by-vector from a CFeatures object
CStreamingFileFromSparseFeatures< T >Class CStreamingFileFromSparseFeatures is derived from CStreamingFile and provides an input source for the online framework. It uses an existing CSparseFeatures object to generate online examples
CStreamingFileFromStringFeatures< T >Class CStreamingFileFromStringFeatures is derived from CStreamingFile and provides an input source for the online framework from a CStringFeatures object
CStreamingSparseFeatures< T >This class implements streaming features with sparse feature vectors. The vector is represented as an SGSparseVector<T>. Each entry is of type SGSparseVectorEntry<T> with members `feat_index' and `entry'
CStreamingStringFeatures< T >This class implements streaming features as strings
CStreamingVwCacheFileClass StreamingVwCacheFile to read vector-by-vector from VW cache files
CStreamingVwFeaturesThis class implements streaming features for use with VW
CStreamingVwFileClass StreamingVwFile to read vector-by-vector from Vowpal Wabbit data files. It reads the example and label into one object of VwExample type
CStringDistance< ST >Template class StringDistance
CStringFeatures< ST >Template class StringFeatures implements a list of strings
CStringFileFeatures< ST >File based string features
CStringKernel< ST >Template class StringKernel, is the base class of all String Kernels
CStringPreprocessor< ST >Template class StringPreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CStringFeatures (i.e. strings of variable length)
CStructuredAccuracyClass CStructuredAccuracy used to compute accuracy of structured classification
CStructuredDataBase class of the components of StructuredLabels
CStructuredLabelsBase class of the labels used in Structured Output (SO) problems
CStructuredModelClass CStructuredModel that represents the application specific model and contains most of the application dependent logic to solve structured output (SO) problems. The idea of this class is to be instantiated giving pointers to the functions that are dependent on the application, i.e. the combined feature representation $\Psi(\bold{x},\bold{y})$ and the argmax function $ {\arg\max} _{\bold{y} \neq \bold{y}_i} \left \langle { \bold{w}, \Psi(\bold{x}_i,\bold{y}) } \right \rangle $. See: MulticlassModel.h and .cpp for an example of these functions implemented
CStructuredOutputMachine
CStudentsTLikelihoodThis is the class that models a likelihood model with a Student's T Distribution. The parameters include degrees of freedom as well as a sigma scale parameter
CSubGradientLPMClass SubGradientSVM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a $\ell_1$ norm regularizer
CSubGradientSVMClass SubGradientSVM
CSubsetWrapper class for an index subset which is used by SubsetStack
CSubsetStackClass to add subset support to another class. A CSubsetStackStack instance should be added and wrapper methods to all interfaces should be added
CSumOnePreprocessor SumOne, normalizes vectors to have sum 1
CSVMA generic Support Vector Machine Interface
CSVMLightClass SVMlight
CSVMLightOneClassTrains a one class C SVM
CSVMLinClass SVMLin
CSVMOcasClass SVMOcas
CSVMSGDClass SVMSGD
CSVRLightClass SVRLight, performs support vector regression using SVMLight
CSyntaxHighLightSyntax highlight
CTanimotoDistanceClass Tanimoto coefficient
CTanimotoKernelNormalizerTanimotoKernelNormalizer performs kernel normalization inspired by the Tanimoto coefficient (see http://en.wikipedia.org/wiki/Jaccard_index )
CTaskClass Task used to represent tasks in multitask learning. Essentially it represent a set of feature vector indices
CTaskGroupClass TaskGroup used to represent a group of tasks. Tasks in group do not overlap
CTaskRelationUsed to represent tasks in multitask learning
CTaskTreeClass TaskTree used to represent a tree of tasks. Tree is constructed via task with subtasks (and subtasks of subtasks ..) passed to the TaskTree
CTaxonomyCTaxonomy is used to describe hierarchical structure between tasks
CTensorProductPairKernelComputes the Tensor Product Pair Kernel (TPPK)
CTestStatisticTest statistic base class. Provides an interface for statistical tests via three methods: compute_statistic(), compute_p_value() and compute_threshold(). The second computes a p-value for the statistic computed by the first method. The p-value represents the position of the statistic in the null-distribution, i.e. the distribution of the statistic population given the null-hypothesis is true. (1-position = p-value). The third method, compute_threshold(), computes a threshold for a given test level which is needed to reject the null-hypothesis
CThresholdRejectionStrategyThreshold based rejection strategy
CTimeClass Time that implements a stopwatch based on either cpu time or wall clock time
CTOPFeaturesThe class TOPFeatures implements TOP kernel features obtained from two Hidden Markov models
CTreeMachine< T >Class TreeMachine, a base class for tree based multiclass classifiers
CTreeMachineNode< T >
CTrie< Trie >Template class Trie implements a suffix trie, i.e. a tree in which all suffixes up to a certain length are stored
CTronClass Tron
CTStudentKernelGeneralized T-Student kernel
CTwoDistributionsTestStatisticProvides an interface for performing statistical tests on two sets of samples from two distributions. Instances of these tests are the classical two-sample test and the independence test. This class may be used as base class for both
CTwoStateModelClass CTwoStateModel class for the internal two-state representation used in the CHMSVMModel
CVarianceKernelNormalizerVarianceKernelNormalizer divides by the ``variance''
CVowpalWabbitClass CVowpalWabbit is the implementation of the online learning algorithm used in Vowpal Wabbit
CVwAdaptiveLearnerVwAdaptiveLearner uses an adaptive subgradient technique to update weights
CVwCacheReaderBase class from which all cache readers for VW should be derived
CVwCacheWriterCVwCacheWriter is the base class for all VW cache creating classes
CVwConditionalProbabilityTree
CVwEnvironmentClass CVwEnvironment is the environment used by VW
CVwLearnerBase class for all VW learners
CVwNativeCacheReaderClass CVwNativeCacheReader reads from a cache exactly as that which has been produced by VW's default cache format
CVwNativeCacheWriterClass CVwNativeCacheWriter writes a cache exactly as that which would be produced by VW's default cache format
CVwNonAdaptiveLearnerVwNonAdaptiveLearner uses a standard gradient descent weight update rule
CVwParserCVwParser is the object which provides the functions to parse examples from buffered input
CVwRegressorRegressor used by VW
CWaveKernelWave kernel
CWaveletKernelClass WaveletKernel
CWDFeaturesFeatures that compute the Weighted Degreee Kernel feature space explicitly
CWDSVMOcasClass WDSVMOcas
CWeightedCommWordStringKernelThe WeightedCommWordString kernel may be used to compute the weighted spectrum kernel (i.e. a spectrum kernel for 1 to K-mers, where each k-mer length is weighted by some coefficient $\beta_k$) from strings that have been mapped into unsigned 16bit integers
CWeightedDegreePositionStringKernelThe Weighted Degree Position String kernel (Weighted Degree kernel with shifts)
CWeightedDegreeRBFKernelWeighted degree RBF kernel
CWeightedDegreeStringKernelThe Weighted Degree String kernel
CWRACCMeasureClass WRACCMeasure used to measure weighted relative accuracy of 2-class classifier
CZeroMeanZero Mean Function
CZeroMeanCenterKernelNormalizerZeroMeanCenterKernelNormalizer centers the kernel in feature space
d_node< P >
ds_node< P >
DynArray< T >Template Dynamic array class that creates an array that can be used like a list or an array
EntryComparator
Example< T >Class Example is the container type for the vector+label combination
func_wrapper
SGVector< T >::IndexSorter
lbfgs_parameter_t
MappedSparseMatrixMapped sparse matrix for representing graph relations of tasks
MKLMulticlassGLPKMKLMulticlassGLPK is a helper class for MKLMulticlass
MKLMulticlassGradientMKLMulticlassGradient is a helper class for MKLMulticlass
MKLMulticlassOptimizationBaseMKLMulticlassOptimizationBase is a helper class for MKLMulticlass
mocas_data
ModelClass Model
MunkresMunkres
CGradientModelSelection::nlopt_packageStruct used for nlopt callback function
node< P >
ParallelClass Parallel provides helper functions for multithreading
ParameterParameter class
ParameterMapImplements a map of ParameterMapElement instances Maps one key to a set of values
ParameterMapElementClass to hold instances of a parameter map. Each element contains a key and a set of values, which each are of type SGParamInfo. May be compared to each other based on their keys
Psi_line
refcount_t
RelaxedTreeNodeData
RelaxedTreeUtil
SerializableAsciiReader00Serializable ascii reader
SGIOClass SGIO, used to do input output operations throughout shogun
SGMatrix< T >Shogun matrix
SGMatrixList< T >Shogun matrix list
SGNDArray< T >Shogun n-dimensional array
SGParamInfoClass that holds informations about a certain parameter of an CSGObject. Contains name, type, etc. This is used for mapping types that have changed in different versions of shogun. Instances of this class may be compared to each other. Ordering is based on name, equalness is based on all attributes
SGReferencedDataShogun reference count managed data
SGSparseMatrix< T >Template class SGSparseMatrix
SGSparseVector< T >Template class SGSparseVector The assumtion is that the stored SGSparseVectorEntry<T>* vector is ordered by SGSparseVectorEntry.feat_index in non-decreasing order. This has to be assured by the user of the class
SGSparseVectorEntry< T >Template class SGSparseVectorEntry
SGString< T >Shogun string
SGStringList< T >Template class SGStringList
SGVector< T >Shogun vector
ShareBoostOptimizer
ShogunExceptionClass ShogunException defines an exception which is thrown whenever an error inside of shogun occurs
SPE_COVERTREE_POINT
SSKFeaturesSSKFeatures
substringStruct Substring, specified by start position and end position
tag_callback_data
tag_iteration_data
task_tree_node_t
TMultipleCPinfo
TParameterParameter struct
tree_node_t
CSerializableFile::TSerializableReaderSerializable reader
TSGDataTypeDatatypes that shogun supports
v_array< T >Class v_array taken directly from JL's implementation
VersionClass Version provides version information
VwConditionalProbabilityTreeNodeData
VwExampleExample class for VW
VwFeatureOne feature in VW
VwLabelClass VwLabel holds a label object used by VW
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation