SHOGUN
v2.0.0
|
block_tree_node_t | |
bmrm_ll | |
bmrm_return_value_T | |
CDynInt< T, sz > | Integer type of dynamic size |
CECOCUtil | |
CIndirectObject< T, P > | Array class that accesses elements indirectly via an index array |
CInputParser< T > | Class CInputParser is a templated class used to maintain the reading/parsing/providing of examples |
CJLCoverTreePoint | Class 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 |
CLoss | Class which collects generic mathematical functions |
ConditionalProbabilityTreeNodeData | Struct to store data of node of conditional probability tree |
CoverTree< Point > | |
CSGObject | Class SGObject is the base class of all shogun objects |
CCache< float64_t > | |
CTreeMachineNode< ConditionalProbabilityTreeNodeData > | |
CTreeMachineNode< RelaxedTreeNodeData > | |
CTreeMachineNode< VwConditionalProbabilityTreeNodeData > | |
CAlphabet | The class Alphabet implements an alphabet and alphabet utility functions |
CBinaryStream< T > | Memory mapped emulation via binary streams (files) |
CBitString | String class embedding a string in a compact bit representation |
CCache< T > | Template class Cache implements a simple cache |
CCompressor | Compression library for compressing and decompressing buffers using one of the standard compression algorithms, LZO, GZIP, BZIP2 or LZMA |
CConverter | Class Converter used to convert data |
CEmbeddingConverter | Class EmbeddingConverter (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of features, e.g. construct dense numeric embedding of string features |
CDiffusionMaps | Class DiffusionMaps (part of the Efficient Dimensionality Reduction Toolkit) used to preprocess given data using Diffusion Maps dimensionality reduction technique as described in |
CLaplacianEigenmaps | Class LaplacianEigenmaps (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using Laplacian Eigenmaps algorithm as described in: |
CLocalityPreservingProjections | Class LocalityPreservingProjections (part of the Efficient Dimensionality Reduction Toolkit) used to compute embeddings of data using Locality Preserving Projections method as described in |
CLocallyLinearEmbedding | Class LocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using Locally Linear Embedding algorithm described in |
CHessianLocallyLinearEmbedding | Class HessianLocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to preprocess data using Hessian Locally Linear Embedding algorithm as described in |
CKernelLocallyLinearEmbedding | Class 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 |
CKernelLocalTangentSpaceAlignment | Class LocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using kernel extension of the Local Tangent Space Alignment (LTSA) algorithm |
CLocalTangentSpaceAlignment | Class LocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using Local Tangent Space Alignment (LTSA) algorithm as described in: |
CLinearLocalTangentSpaceAlignment | Class LinearLocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) converter used to construct embeddings as described in: |
CNeighborhoodPreservingEmbedding | NeighborhoodPreservingEmbedding (part of the Efficient Dimensionality Reduction Toolkit) converter used to construct embeddings as described in: |
CMultidimensionalScaling | Class Multidimensionalscaling (part of the Efficient Dimensionality Reduction Toolkit) is used to perform multidimensional scaling (capable of landmark approximation if requested) |
CIsomap | Class Isomap (part of the Efficient Dimension Reduction Toolkit) used to embed data using Isomap algorithm as described in |
CStochasticProximityEmbedding | Class StochasticProximityEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using the Stochastic Proximity algorithm |
CCplex | Class CCplex to encapsulate access to the commercial cplex general purpose optimizer |
CCrossValidationOutput | Class for managing individual folds in cross-validation |
CCrossValidationMKLStorage | Class for storing MKL weights in every fold of cross-validation |
CCrossValidationMulticlassStorage | Class for storing multiclass evaluation information in every fold of cross-validation |
CCrossValidationPrintOutput | Class for outputting cross-validation intermediate results to the standard output. Simply prints all messages it gets |
CData | Dummy data holder |
CDataGenerator | Class that is able to generate various data samples, which may be used for examples in SHOGUN |
CDifferentiableFunction | DifferentiableFunction |
CInferenceMethod | The Inference Method base class |
CExactInferenceMethod | The Gaussian Exact Form Inference Method |
CFITCInferenceMethod | The Fully Independent Conditional Training Inference Method |
CLaplacianInferenceMethod | The Laplace Approximation Inference Method |
CDistance | Class Distance, a base class for all the distances used in the Shogun toolbox |
CDenseDistance< float64_t > | |
CBrayCurtisDistance | Class Bray-Curtis distance |
CCanberraMetric | Class CanberraMetric |
CChebyshewMetric | Class ChebyshewMetric |
CChiSquareDistance | Class ChiSquareDistance |
CCosineDistance | Class CosineDistance |
CGeodesicMetric | Class GeodesicMetric |
CJensenMetric | Class JensenMetric |
CManhattanMetric | Class ManhattanMetric |
CMinkowskiMetric | Class MinkowskiMetric |
CRealDistance | Class RealDistance |
CAttenuatedEuclideanDistance | Class AttenuatedEuclideanDistance |
CEuclideanDistance | Class EuclideanDistance |
CMahalanobisDistance | Class MahalanobisDistance |
CTanimotoDistance | Class Tanimoto coefficient |
CSparseDistance< float64_t > | |
CSparseEuclideanDistance | Class SparseEucldeanDistance |
CStringDistance< uint16_t > | |
CCanberraWordDistance | Class CanberraWordDistance |
CHammingWordDistance | Class HammingWordDistance |
CManhattanWordDistance | Class ManhattanWordDistance |
CCustomDistance | The Custom Distance allows for custom user provided distance matrices |
CDenseDistance< ST > | Template class DenseDistance |
CKernelDistance | The Kernel distance takes a distance as input |
CSparseDistance< ST > | Template class SparseDistance |
CStringDistance< ST > | Template class StringDistance |
CDistribution | Base class Distribution from which all methods implementing a distribution are derived |
CGaussian | Gaussian distribution interface |
CGHMM | Class GHMM - this class is non-functional and was meant to implement a Generalize Hidden Markov Model (aka Semi Hidden Markov HMM) |
CGMM | Gaussian Mixture Model interface |
CHistogram | Class Histogram computes a histogram over all 16bit unsigned integers in the features |
CHMM | Hidden Markov Model |
CLinearHMM | The class LinearHMM is for learning Higher Order Markov chains |
CPositionalPWM | Positional PWM |
CDynamicArray< T > | Template Dynamic array class that creates an array that can be used like a list or an array |
CDynamicObjectArray | Dynamic array class for CSGObject pointers that creates an array that can be used like a list or an array |
CDynProg | Dynamic Programming Class |
CECOCDecoder | |
CECOCIHDDecoder | |
CECOCSimpleDecoder | |
CECOCAEDDecoder | |
CECOCEDDecoder | |
CECOCHDDecoder | |
CECOCLLBDecoder | |
CECOCEncoder | ECOCEncoder produce an ECOC codebook |
CECOCDiscriminantEncoder | |
CECOCForestEncoder | |
CECOCOVOEncoder | |
CECOCOVREncoder | |
CECOCRandomDenseEncoder | |
CECOCRandomSparseEncoder | |
CEvaluation | Class Evaluation, a base class for other classes used to evaluate labels, e.g. accuracy of classification or mean squared error of regression |
CBinaryClassEvaluation | The class TwoClassEvaluation, a base class used to evaluate binary classification labels |
CContingencyTableEvaluation | The class ContingencyTableEvaluation a base class used to evaluate 2-class classification with TP, FP, TN, FN rates |
CAccuracyMeasure | Class AccuracyMeasure used to measure accuracy of 2-class classifier |
CBALMeasure | Class BALMeasure used to measure balanced error of 2-class classifier |
CCrossCorrelationMeasure | Class CrossCorrelationMeasure used to measure cross correlation coefficient of 2-class classifier |
CErrorRateMeasure | Class ErrorRateMeasure used to measure error rate of 2-class classifier |
CF1Measure | Class F1Measure used to measure F1 score of 2-class classifier |
CPrecisionMeasure | Class PrecisionMeasure used to measure precision of 2-class classifier |
CRecallMeasure | Class RecallMeasure used to measure recall of 2-class classifier |
CSpecificityMeasure | Class SpecificityMeasure used to measure specificity of 2-class classifier |
CWRACCMeasure | Class WRACCMeasure used to measure weighted relative accuracy of 2-class classifier |
CPRCEvaluation | Class PRCEvaluation used to evaluate PRC (Precision Recall Curve) and an area under PRC curve (auPRC) |
CROCEvaluation | Class ROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) |
CMultitaskROCEvaluation | Class MultitaskROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) of each task separately |
CClusteringEvaluation | The base class used to evaluate clustering |
CClusteringAccuracy | Clustering accuracy |
CClusteringMutualInformation | Clustering (normalized) mutual information |
CGradientCriterion | CGradientCriterion Simple class which specifies the direction of gradient search. Does not provide any label evaluation measure, however |
CMeanAbsoluteError | Class MeanAbsoluteError used to compute an error of regression model |
CMeanSquaredError | Class MeanSquaredError used to compute an error of regression model |
CMeanSquaredLogError | Class CMeanSquaredLogError used to compute an error of regression model |
CMulticlassAccuracy | The class MulticlassAccuracy used to compute accuracy of multiclass classification |
CMulticlassOVREvaluation | The class MulticlassOVREvaluation used to compute evaluation parameters of multiclass classification via binary OvR decomposition and given binary evaluation technique |
CStructuredAccuracy | Class CStructuredAccuracy used to compute accuracy of structured classification |
CEvaluationResult | EvaluationResult is the abstract class that contains the result generated by the MachineEvaluation class |
CCrossValidationResult | Type 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 |
CGradientResult | GradientResult is a container class that returns results from GradientEvaluation. It contains the function value as well as its gradient |
CFeatures | The class Features is the base class of all feature objects |
CAttributeFeatures | Implements attributed features, that is in the simplest case a number of (attribute, value) pairs |
CCombinedFeatures | The class CombinedFeatures is used to combine a number of of feature objects into a single CombinedFeatures object |
CDotFeatures | Features that support dot products among other operations |
CDenseFeatures< float64_t > | |
CFKFeatures | The class FKFeatures implements Fischer kernel features obtained from two Hidden Markov models |
CRealFileFeatures | The class RealFileFeatures implements a dense double-precision floating point matrix from a file |
CTOPFeatures | The class TOPFeatures implements TOP kernel features obtained from two Hidden Markov models |
CBinnedDotFeatures | The class BinnedDotFeatures contains a 0-1 conversion of features into bins |
CCombinedDotFeatures | Features that allow stacking of a number of DotFeatures |
CDenseFeatures< ST > | The class DenseFeatures implements dense feature matrices |
CDenseSubsetFeatures< ST > | |
CExplicitSpecFeatures | Features that compute the Spectrum Kernel feature space explicitly |
CHashedWDFeatures | Features that compute the Weighted Degreee Kernel feature space explicitly |
CHashedWDFeaturesTransposed | Features that compute the Weighted Degreee Kernel feature space explicitly |
CImplicitWeightedSpecFeatures | Features that compute the Weighted Spectrum Kernel feature space explicitly |
CLBPPyrDotFeatures | Implement DotFeatures for the polynomial kernel |
CPolyFeatures | Implement DotFeatures for the polynomial kernel |
CSNPFeatures | Features that compute the Weighted Degreee Kernel feature space explicitly |
CSparseFeatures< ST > | Template class SparseFeatures implements sparse matrices |
CSparsePolyFeatures | Implement DotFeatures for the polynomial kernel |
CWDFeatures | Features that compute the Weighted Degreee Kernel feature space explicitly |
CDummyFeatures | The class DummyFeatures implements features that only know the number of feature objects (but don't actually contain any) |
CLatentFeatures | Latent 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 |
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) |
CStreamingFeatures | Streaming features are features which are used for online algorithms |
CStreamingDotFeatures | Streaming features that support dot products among other operations |
CStreamingDenseFeatures< T > | This class implements streaming features with dense feature vectors |
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' |
CStreamingVwFeatures | This class implements streaming features for use with VW |
CStreamingStringFeatures< T > | This class implements streaming features as strings |
CStringFeatures< ST > | Template class StringFeatures implements a list of strings |
CStringFileFeatures< ST > | File based string features |
CFile | A File access base class |
CAsciiFile | A Ascii File access class |
CBinaryFile | A Binary file access class |
CGCArray< T > | Template class GCArray implements a garbage collecting static array |
CGMNPLib | Class GMNPLib Library of solvers for Generalized Minimal Norm Problem (GMNP) |
CGNPPLib | Class GNPPLib, a Library of solvers for Generalized Nearest Point Problem (GNPP) |
CGUIClassifier | UI classifier |
CGUIConverter | UI converter |
CGUIDistance | UI distance |
CGUIFeatures | UI features |
CGUIHMM | UI HMM (Hidden Markov Model) |
CGUIKernel | UI kernel |
CGUILabels | UI labels |
CGUIMath | UI math |
CGUIPluginEstimate | UI estimate |
CGUIPreprocessor | UI preprocessor |
CGUIStructure | UI structure |
CGUITime | UI time |
CHash | Collection of Hashing Functions |
CIndexBlock | Class IndexBlock used to represent contiguous indices of one group (e.g. block of related features) |
CIndexBlockRelation | Class IndexBlockRelation |
CIndexBlockGroup | Class IndexBlockGroup used to represent group-based feature relation |
CIndexBlockTree | Class IndexBlockTree used to represent tree guided feature relation |
CIntronList | Class IntronList |
CIOBuffer | An I/O buffer class |
CKernel | The Kernel base class |
CStringKernel< char > | |
CDistantSegmentsKernel | The distant segments kernel is a string kernel, which counts the number of substrings, so-called segments, at a certain distance from each other |
CFixedDegreeStringKernel | The FixedDegree String kernel takes as input two strings of same size and counts the number of matches of length d |
CGaussianMatchStringKernel | The class GaussianMatchStringKernel computes a variant of the Gaussian kernel on strings of same length |
CLinearStringKernel | Computes the standard linear kernel on dense char valued features |
CLocalAlignmentStringKernel | The LocalAlignmentString kernel compares two sequences through all possible local alignments between the two sequences |
CLocalityImprovedStringKernel | The LocalityImprovedString kernel is inspired by the polynomial kernel. Comparing neighboring characters it puts emphasize on local features |
COligoStringKernel | This class offers access to the Oligo Kernel introduced by Meinicke et al. in 2004 |
CPolyMatchStringKernel | The class PolyMatchStringKernel computes a variant of the polynomial kernel on strings of same length |
CRegulatoryModulesStringKernel | The Regulaty Modules kernel, based on the WD kernel, as published in Schultheiss et al., Bioinformatics (2009) on regulatory sequences |
CSimpleLocalityImprovedStringKernel | SimpleLocalityImprovedString kernel, is a ``simplified'' and better performing version of the Locality improved kernel |
CSNPStringKernel | The class SNPStringKernel computes a variant of the polynomial kernel on strings of same length |
CSparseSpatialSampleStringKernel | Sparse Spatial Sample String Kernel by Pavel Kuksa pkuks.nosp@m.a@cs.nosp@m..rutg.nosp@m.ers..nosp@m.edu and Vladimir Pavlovic vladi.nosp@m.mir@.nosp@m.cs.ru.nosp@m.tger.nosp@m.s.edu |
CSpectrumMismatchRBFKernel | Spectrum mismatch rbf kernel |
CSpectrumRBFKernel | Spectrum rbf kernel |
CWeightedDegreePositionStringKernel | The Weighted Degree Position String kernel (Weighted Degree kernel with shifts) |
CWeightedDegreeStringKernel | The Weighted Degree String kernel |
CStringKernel< uint16_t > | |
CCommWordStringKernel | The CommWordString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 16bit integers |
CWeightedCommWordStringKernel | The 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 ) from strings that have been mapped into unsigned 16bit integers |
CHistogramWordStringKernel | The HistogramWordString computes the TOP kernel on inhomogeneous Markov Chains |
CMatchWordStringKernel | The class MatchWordStringKernel computes a variant of the polynomial kernel on strings of same length converted to a word alphabet |
CPolyMatchWordStringKernel | The class PolyMatchWordStringKernel computes a variant of the polynomial kernel on word-features |
CSalzbergWordStringKernel | The SalzbergWordString kernel implements the Salzberg kernel |
CStringKernel< uint64_t > | |
CCommUlongStringKernel | The CommUlongString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 64bit integers |
CCauchyKernel | Cauchy kernel |
CCircularKernel | Circular kernel |
CCombinedKernel | The Combined kernel is used to combine a number of kernels into a single CombinedKernel object by linear combination |
CConstKernel | The Constant Kernel returns a constant for all elements |
CCustomKernel | The Custom Kernel allows for custom user provided kernel matrices |
CDiagKernel | The Diagonal Kernel returns a constant for the diagonal and zero otherwise |
CDistanceKernel | The Distance kernel takes a distance as input |
CBesselKernel | Class Bessel kernel |
CDotKernel | Template class DotKernel is the base class for kernels working on DotFeatures |
CANOVAKernel | ANOVA (ANalysis Of VAriances) kernel |
CAUCKernel | The AUC kernel can be used to maximize the area under the receiver operator characteristic curve (AUC) instead of margin in SVM training |
CChi2Kernel | The Chi2 kernel operating on realvalued vectors computes the chi-squared distance between sets of histograms |
CExponentialKernel | The Exponential Kernel, closely related to the Gaussian Kernel computed on CDotFeatures |
CGaussianKernel | The well known Gaussian kernel (swiss army knife for SVMs) computed on CDotFeatures |
CGaussianShiftKernel | An experimental kernel inspired by the WeightedDegreePositionStringKernel and the Gaussian kernel |
CGaussianShortRealKernel | The well known Gaussian kernel (swiss army knife for SVMs) on dense short-real valued features |
CHistogramIntersectionKernel | The 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 |
CJensenShannonKernel | The Jensen-Shannon kernel operating on real-valued vectors computes the Jensen-Shannon distance between the features. Often used in computer vision |
CLinearARDKernel | Linear Kernel with Automatic Relevance Detection |
CGaussianARDKernel | Gaussian Kernel with Automatic Relevance Detection |
CLinearKernel | Computes the standard linear kernel on CDotFeatures |
CPolyKernel | Computes the standard polynomial kernel on CDotFeatures |
CPyramidChi2 | Pyramid Kernel over Chi2 matched histograms |
CSigmoidKernel | The standard Sigmoid kernel computed on dense real valued features |
CSplineKernel | Computes the Spline Kernel function which is the cubic polynomial |
CTensorProductPairKernel | Computes the Tensor Product Pair Kernel (TPPK) |
CWaveletKernel | Class WaveletKernel |
CWeightedDegreeRBFKernel | Weighted degree RBF kernel |
CInverseMultiQuadricKernel | InverseMultiQuadricKernel |
CLogKernel | Log kernel |
CMultiquadricKernel | MultiquadricKernel |
CPowerKernel | Power kernel |
CProductKernel | The Product kernel is used to combine a number of kernels into a single ProductKernel object by element multiplication |
CRationalQuadraticKernel | Rational Quadratic kernel |
CSparseKernel< ST > | Template class SparseKernel, is the base class of kernels working on sparse features |
CSphericalKernel | Spherical kernel |
CStringKernel< ST > | Template class StringKernel, is the base class of all String Kernels |
CTStudentKernel | Generalized T-Student kernel |
CWaveKernel | Wave kernel |
CKernelMeanMatching | Kernel Mean Matching |
CKernelNormalizer | The class Kernel Normalizer defines a function to post-process kernel values |
CAvgDiagKernelNormalizer | Normalize the kernel by either a constant or the average value of the diagonal elements (depending on argument c of the constructor) |
CDiceKernelNormalizer | DiceKernelNormalizer performs kernel normalization inspired by the Dice coefficient (see http://en.wikipedia.org/wiki/Dice's_coefficient) |
CFirstElementKernelNormalizer | Normalize the kernel by a constant obtained from the first element of the kernel matrix, i.e. |
CIdentityKernelNormalizer | Identity Kernel Normalization, i.e. no normalization is applied |
CMultitaskKernelMaskNormalizer | The MultitaskKernel allows Multitask Learning via a modified kernel function |
CMultitaskKernelMaskPairNormalizer | The MultitaskKernel allows Multitask Learning via a modified kernel function |
CMultitaskKernelMklNormalizer | Base-class for parameterized Kernel Normalizers |
CMultitaskKernelPlifNormalizer | The MultitaskKernel allows learning a piece-wise linear function (PLIF) via MKL |
CMultitaskKernelTreeNormalizer | The MultitaskKernel allows Multitask Learning via a modified kernel function based on taxonomy |
CMultitaskKernelNormalizer | The MultitaskKernel allows Multitask Learning via a modified kernel function |
CRidgeKernelNormalizer | Normalize 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) |
CScatterKernelNormalizer | Scatter kernel normalizer |
CSqrtDiagKernelNormalizer | SqrtDiagKernelNormalizer divides by the Square Root of the product of the diagonal elements |
CTanimotoKernelNormalizer | TanimotoKernelNormalizer performs kernel normalization inspired by the Tanimoto coefficient (see http://en.wikipedia.org/wiki/Jaccard_index ) |
CVarianceKernelNormalizer | VarianceKernelNormalizer divides by the ``variance'' |
CZeroMeanCenterKernelNormalizer | ZeroMeanCenterKernelNormalizer centers the kernel in feature space |
CLabels | The class Labels models labels, i.e. class assignments of objects |
CDenseLabels | Dense integer or floating point labels |
CBinaryLabels | Binary Labels for binary classification |
CMulticlassLabels | Multiclass Labels for multi-class classification |
CRegressionLabels | Real Labels are real-valued labels |
CLatentLabels | Abstract 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 |
CMulticlassMultipleOutputLabels | Multiclass Labels for multi-class classification with multiple labels |
CStructuredLabels | Base class of the labels used in Structured Output (SO) problems |
CHMSVMLabels | Class 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 |
CMulticlassSOLabels | Class 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 |
CLatentModel | Abstract class CLatentModel It represents the application specific model and contains most of the application dependent logic to solve latent variable based problems |
CLikelihoodModel | The Likelihood Model base class |
CGaussianLikelihood | This is the class that models a Gaussian Likelihood |
CStudentsTLikelihood | This 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 |
CList | Class List implements a doubly connected list for low-level-objects |
CListElement | Class ListElement, defines how an element of the the list looks like |
CLossFunction | Class CLossFunction is the base class of all loss functions |
CHingeLoss | CHingeLoss implements the hinge loss function |
CLogLoss | CLogLoss implements the logarithmic loss function |
CLogLossMargin | Class CLogLossMargin implements a margin-based log-likelihood loss function |
CSmoothHingeLoss | CSmoothHingeLoss implements the smooth hinge loss function |
CSquaredHingeLoss | Class CSquaredHingeLoss implements a squared hinge loss function |
CSquaredLoss | CSquaredLoss implements the squared loss function |
CMachine | A generic learning machine interface |
CBaseMulticlassMachine | |
CTreeMachine< ConditionalProbabilityTreeNodeData > | |
CConditionalProbabilityTree | |
CBalancedConditionalProbabilityTree | |
CRandomConditionalProbabilityTree | |
CTreeMachine< RelaxedTreeNodeData > | |
CRelaxedTree | |
CTreeMachine< VwConditionalProbabilityTreeNodeData > | |
CVwConditionalProbabilityTree | |
CMulticlassMachine | Experimental abstract generic multiclass machine class |
CKernelMulticlassMachine | Generic kernel multiclass |
CMulticlassSVM | Class MultiClassSVM |
CGMNPSVM | Class GMNPSVM implements a one vs. rest MultiClass SVM |
CLaRank | LaRank multiclass SVM machine |
CMKLMulticlass | MKLMulticlass is a class for L1-norm multiclass MKL |
CMulticlassLibSVM | Class LibSVMMultiClass. Does one vs one classification |
CScatterSVM | ScatterSVM - Multiclass SVM |
CLinearMulticlassMachine | Generic linear multiclass machine |
CMulticlassLibLinear | Multiclass 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 |
CDomainAdaptationMulticlassLibLinear | Domain adaptation multiclass LibLinear wrapper Source domain is assumed to b |
CMulticlassOCAS | Multiclass OCAS wrapper |
CMulticlassTreeGuidedLogisticRegression | Multiclass tree guided logistic regression |
CShareBoost | |
CNativeMulticlassMachine | Experimental abstract native multiclass machine class |
CGaussianNaiveBayes | Class GaussianNaiveBayes, a Gaussian Naive Bayes classifier |
CQDA | Class QDA implements Quadratic Discriminant Analysis |
CTreeMachine< T > | Class TreeMachine, a base class for tree based multiclass classifiers |
CConjugateIndex | Conjugate index classifier. Described in: |
CDistanceMachine | A generic DistanceMachine interface |
CHierarchical | Agglomerative hierarchical single linkage clustering |
CKMeans | KMeans clustering, partitions the data into k (a-priori specified) clusters |
CKNN | Class KNN, an implementation of the standard k-nearest neigbor classifier |
CNearestCentroid | Class NearestCentroid, an implementation of Nearest Shrunk Centroid classifier |
CGaussianProcessRegression | Class GaussianProcessRegression implements Gaussian Process Regression.vInstead of a distribution over weights, the GP specifies a distribution over functions |
CKernelMachine | A generic KernelMachine interface |
CKernelRidgeRegression | Class KernelRidgeRegression implements Kernel Ridge Regression - a regularized least square method for classification and regression |
CSVM | A generic Support Vector Machine Interface |
CCPLEXSVM | CplexSVM a SVM solver implementation based on cplex (unfinished) |
CGNPPSVM | Class GNPPSVM |
CGPBTSVM | Class GPBTSVM |
CLibSVM | LibSVM |
CLibSVMOneClass | Class LibSVMOneClass |
CLibSVR | Class LibSVR, performs support vector regression using LibSVM |
CMKL | Multiple Kernel Learning |
CMKLClassification | Multiple Kernel Learning for two-class-classification |
CMKLOneClass | Multiple Kernel Learning for one-class-classification |
CMKLRegression | Multiple Kernel Learning for regression |
CMPDSVM | Class MPDSVM |
CSVMLight | Class SVMlight |
CDomainAdaptationSVM | Class DomainAdaptationSVM |
CSVMLightOneClass | Trains a one class C SVM |
CSVRLight | Class SVRLight, performs support vector regression using SVMLight |
CLinearMachine | Class LinearMachine is a generic interface for all kinds of linear machines like classifiers |
CAveragedPerceptron | Class Averaged Perceptron implements the standard linear (online) algorithm. Averaged perceptron is the simple extension of Perceptron |
CFeatureBlockLogisticRegression | Class 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 |
CLDA | Class LDA implements regularized Linear Discriminant Analysis |
CLeastAngleRegression | Class for Least Angle Regression, can be used to solve LASSO |
CLibLinear | Class to implement LibLinear |
CDomainAdaptationSVMLinear | Class DomainAdaptationSVMLinear |
CLibLinearMTL | Class to implement LibLinear |
CLibLinearRegression | LibLinear for regression |
CLinearLatentMachine | Abstract implementaion of Linear Machine with latent variable This is the base implementation of all linear machines with latent variable |
CLatentSOSVM | Class Latent Structured Output SVM, an structured output based machine for classification problems with latent variables |
CLatentSVM | LatentSVM class Latent SVM implementation based on [1]. For optimization this implementation uses SVMOcas |
CLinearRidgeRegression | Class LinearRidgeRegression implements Ridge Regression - a regularized least square method for classification and regression |
CLeastSquaresRegression | Class to perform Least Squares Regression |
CLPBoost | Class LPBoost trains a linear classifier called Linear Programming Machine, i.e. a SVM using a norm regularizer |
CLPM | Class LPM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a norm regularizer |
CMultitaskLinearMachine | Class MultitaskLinearMachine, a base class for linear multitask classifiers |
CMultitaskLeastSquaresRegression | Class 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 |
CMultitaskLogisticRegression | Class 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 |
CMultitaskClusteredLogisticRegression | Class 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 |
CMultitaskL12LogisticRegression | Class MultitaskL12LogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library |
CMultitaskTraceLogisticRegression | Class MultitaskTraceLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library |
CNewtonSVM | NewtonSVM, 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 |
CPerceptron | Class Perceptron implements the standard linear (online) perceptron |
CSGDQN | Class SGDQN |
CSubGradientLPM | Class SubGradientSVM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a norm regularizer |
CSubGradientSVM | Class SubGradientSVM |
CSVMLin | Class SVMLin |
CSVMOcas | Class SVMOcas |
CSVMSGD | Class SVMSGD |
CMultitaskCompositeMachine | Class MultitaskCompositeMachine used to solve multitask binary classification problems with separate training of given binary classifier on each task |
COnlineLinearMachine | Class OnlineLinearMachine is a generic interface for linear machines like classifiers which work through online algorithms |
COnlineLibLinear | Class implementing a purely online version of LibLinear, using the L2R_L1LOSS_SVC_DUAL solver only |
COnlineSVMSGD | Class OnlineSVMSGD |
CVowpalWabbit | Class CVowpalWabbit is the implementation of the online learning algorithm used in Vowpal Wabbit |
CPluginEstimate | Class PluginEstimate |
CStructuredOutputMachine | |
CKernelStructuredOutputMachine | |
CLinearStructuredOutputMachine | |
CDualLibQPBMSOSVM | Class DualLibQPBMSOSVM that uses Bundle Methods for Regularized Risk Minimization algorithms for structured output (SO) problems [1] presented in [2] |
CWDSVMOcas | Class WDSVMOcas |
CMachineEvaluation | Machine Evaluation is an abstract class that evaluates a machine according to some criterion |
CCrossValidation | Base 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 |
CGradientEvaluation | GradientEvaluation evaluates a machine using its associated differentiable function for the function value and its gradient with respect to parameters |
CMap< K, T > | Class CMap, a map based on the hash-table. w: http://en.wikipedia.org/wiki/Hash_table |
CMath | Class which collects generic mathematical functions |
CMeanFunction | Mean Function base class |
CZeroMean | Zero Mean Function |
CMemoryMappedFile< T > | Memory mapped file |
CModelSelection | Abstract 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 |
CGradientModelSelection | Model selection class which searches for the best model by a gradient- search |
CGridSearchModelSelection | Model selection class which searches for the best model by a grid- search. See CModelSelection for details |
CRandomSearchModelSelection | Model selection class which searches for the best model by a random search. See CModelSelection for details |
CModelSelectionParameters | Class 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 |
CMulticlassStrategy | Class MulticlassStrategy used to construct generic multiclass classifiers with ensembles of binary classifiers |
CECOCStrategy | |
CMulticlassOneVsOneStrategy | Multiclass 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 |
CMulticlassOneVsRestStrategy | Multiclass one vs rest strategy used to train generic multiclass machines for K-class problems with building ensemble of K binary classifiers |
CNode | A CNode is an element of a CTaxonomy, which is used to describe hierarchical structure between tasks |
CParameterCombination | Class 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 |
CPlifBase | Class PlifBase |
CPlif | Class Plif |
CPlifArray | Class PlifArray |
CPlifMatrix | Store plif arrays for all transitions in the model |
CPreprocessor | Class Preprocessor defines a preprocessor interface |
CDensePreprocessor< float64_t > | |
CDimensionReductionPreprocessor | Class DimensionReductionPreprocessor, a base class for preprocessors used to lower the dimensionality of given simple features (dense matrices) |
CKernelPCA | Preprocessor KernelPCA performs kernel principal component analysis |
CPCA | Preprocessor PCACut performs principial component analysis on the input vectors and keeps only the n eigenvectors with eigenvalues above a certain threshold |
CHomogeneousKernelMap | Preprocessor HomogeneousKernelMap performs homogeneous kernel maps as described in |
CLogPlusOne | Preprocessor LogPlusOne does what the name says, it adds one to a dense real valued vector and takes the logarithm of each component of it |
CNormOne | Preprocessor NormOne, normalizes vectors to have norm 1 |
CPNorm | Preprocessor PNorm, normalizes vectors to have p-norm |
CPruneVarSubMean | Preprocessor PruneVarSubMean will substract the mean and remove features that have zero variance |
CRandomFourierGaussPreproc | Preprocessor 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 |
CSumOne | Preprocessor SumOne, normalizes vectors to have sum 1 |
CStringPreprocessor< uint16_t > | |
CSortWordString | Preprocessor SortWordString, sorts the indivual strings in ascending order |
CStringPreprocessor< uint64_t > | |
CSortUlongString | Preprocessor SortUlongString, sorts the indivual strings in ascending order |
CDensePreprocessor< ST > | Template class DensePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CDenseFeatures (i.e. rectangular dense matrices) |
CSparsePreprocessor< ST > | Template class SparsePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CSparseFeatures |
CStringPreprocessor< ST > | Template class StringPreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CStringFeatures (i.e. strings of variable length) |
CDecompressString< ST > | Preprocessor that decompresses compressed strings |
CQPBSVMLib | Class QPBSVMLib |
CRejectionStrategy | Base rejection strategy class |
CDixonQTestRejectionStrategy | Simplified 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 |
CThresholdRejectionStrategy | Threshold based rejection strategy |
CResultSet | |
CSegmentLoss | Class IntronList |
CSerializableFile | Serializable file |
CSerializableAsciiFile | Serializable ascii file |
CSerializableFile::TSerializableReader | Serializable reader |
SerializableAsciiReader00 | Serializable ascii reader |
CSet< T > | Class CSet, a set based on the hash-table. w: http://en.wikipedia.org/wiki/Hash_table |
CSignal | Class 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 |
CSparseInverseCovariance | Used to estimate inverse covariance matrix using graphical lasso |
CSplittingStrategy | Abstract 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(...) |
CCrossValidationSplitting | Implementation of normal cross-validation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference) |
CStratifiedCrossValidationSplitting | Implementation 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 |
CStateModel | Class CStateModel base, abstract class for the internal state representation used in the CHMSVMModel |
CTwoStateModel | Class CTwoStateModel class for the internal two-state representation used in the CHMSVMModel |
CStatistics | Class that contains certain functions related to statistics, such as probability/cumulative distribution functions, different statistics, etc |
CStreamingFile | A Streaming File access class |
CStreamingAsciiFile | Class StreamingAsciiFile to read vector-by-vector from ASCII files |
CStreamingFileFromFeatures | Class StreamingFileFromFeatures to read vector-by-vector from a CFeatures object |
CStreamingFileFromDenseFeatures< T > | Class CStreamingFileFromDenseFeatures is a derived class of CStreamingFile which creates an input source for the online framework from a CDenseFeatures 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 |
CStreamingVwCacheFile | Class StreamingVwCacheFile to read vector-by-vector from VW cache files |
CStreamingVwFile | Class StreamingVwFile to read vector-by-vector from Vowpal Wabbit data files. It reads the example and label into one object of VwExample type |
CStructuredData | Base class of the components of StructuredLabels |
CRealNumber | Class 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 |
CSequence | Class CSequence to be used in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HM-SVM) |
CStructuredModel | Class 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 and the argmax function . See: MulticlassModel.h and .cpp for an example of these functions implemented |
CHMSVMModel | Class 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 |
CMulticlassModel | Class CMulticlassModel that represents the application specific model and contains the application dependent logic to solve multiclass classification within a generic SO framework |
CSubset | Wrapper class for an index subset which is used by SubsetStack |
CSubsetStack | Class to add subset support to another class. A CSubsetStackStack instance should be added and wrapper methods to all interfaces should be added |
CTask | Class Task used to represent tasks in multitask learning. Essentially it represent a set of feature vector indices |
CTaskRelation | Used to represent tasks in multitask learning |
CTaskGroup | Class TaskGroup used to represent a group of tasks. Tasks in group do not overlap |
CTaskTree | Class TaskTree used to represent a tree of tasks. Tree is constructed via task with subtasks (and subtasks of subtasks ..) passed to the TaskTree |
CTaxonomy | CTaxonomy is used to describe hierarchical structure between tasks |
CTestStatistic | Test 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 |
CTwoDistributionsTestStatistic | Provides 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 |
CKernelIndependenceTestStatistic | Independence test base class. Provides an interface for performing an independence test. Given samples from the joint distribution , does the joint distribution factorize as ? The null- hypothesis says yes, i.e. no independence, the alternative hypothesis says yes |
CHSIC | This class implements the Hilbert Schmidtd Independence Criterion based independence test as described in [1] |
CKernelTwoSampleTestStatistic | Two sample test base class. Provides an interface for performing a two-sample test, i.e. Given samples from two distributions and , the null-hypothesis is: , the alternative hypothesis: |
CLinearTimeMMD | This class implements the linear time Maximum Mean Statistic as described in [1]. The MMD is the distance of two probability distributions and in a RKHS.
|
CQuadraticTimeMMD | This class implements the quadratic time Maximum Mean Statistic as described in [1]. The MMD is the distance of two probability distributions and in a RKHS
|
CTime | Class Time that implements a stopwatch based on either cpu time or wall clock time |
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 |
CVwCacheReader | Base class from which all cache readers for VW should be derived |
CVwNativeCacheReader | Class CVwNativeCacheReader reads from a cache exactly as that which has been produced by VW's default cache format |
CVwCacheWriter | CVwCacheWriter is the base class for all VW cache creating classes |
CVwNativeCacheWriter | Class CVwNativeCacheWriter writes a cache exactly as that which would be produced by VW's default cache format |
CVwEnvironment | Class CVwEnvironment is the environment used by VW |
CVwLearner | Base class for all VW learners |
CVwAdaptiveLearner | VwAdaptiveLearner uses an adaptive subgradient technique to update weights |
CVwNonAdaptiveLearner | VwNonAdaptiveLearner uses a standard gradient descent weight update rule |
CVwParser | CVwParser is the object which provides the functions to parse examples from buffered input |
CVwRegressor | Regressor used by VW |
MKLMulticlassOptimizationBase | MKLMulticlassOptimizationBase is a helper class for MKLMulticlass |
MKLMulticlassGLPK | MKLMulticlassGLPK is a helper class for MKLMulticlass |
MKLMulticlassGradient | MKLMulticlassGradient is a helper class for MKLMulticlass |
CSyntaxHighLight | Syntax highlight |
CTron | Class Tron |
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 | |
MappedSparseMatrix | Mapped sparse matrix for representing graph relations of tasks |
mocas_data | |
Model | Class Model |
Munkres | Munkres |
CGradientModelSelection::nlopt_package | Struct used for nlopt callback function |
node< P > | |
Parallel | Class Parallel provides helper functions for multithreading |
Parameter | Parameter class |
ParameterMap | Implements a map of ParameterMapElement instances Maps one key to a set of values |
ParameterMapElement | Class 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 | |
SGIO | Class SGIO, used to do input output operations throughout shogun |
SGNDArray< T > | Shogun n-dimensional array |
SGParamInfo | Class 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 |
SGReferencedData | Shogun reference count managed data |
SGMatrix< float64_t > | |
SGMatrix< T > | Shogun matrix |
SGMatrixList< T > | Shogun matrix list |
SGSparseMatrix< T > | Template class SGSparseMatrix |
SGSparseVector< T > | Template class SGSparseVector |
SGVector< T > | Shogun vector |
SGSparseVectorEntry< T > | Template class SGSparseVectorEntry |
SGString< T > | Shogun string |
SGStringList< T > | Template class SGStringList |
ShareBoostOptimizer | |
ShogunException | Class ShogunException defines an exception which is thrown whenever an error inside of shogun occurs |
SPE_COVERTREE_POINT | |
SSKFeatures | SSKFeatures |
substring | Struct Substring, specified by start position and end position |
tag_callback_data | |
tag_iteration_data | |
task_tree_node_t | |
TMultipleCPinfo | |
TParameter | Parameter struct |
tree_node_t | |
TSGDataType | Datatypes that shogun supports |
v_array< T > | Class v_array taken directly from JL's implementation |
Version | Class Version provides version information |
VwConditionalProbabilityTreeNodeData | |
VwExample | Example class for VW |
VwFeature | One feature in VW |
VwLabel | Class VwLabel holds a label object used by VW |