PLearn 0.1
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
__attribute__
PLearn::_plearn_nan_type
PLearn::AbsVariable
PLearn::AdaBoost
PLearn::AdaptGradientOptimizer
PLearn::AddBagInformationVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::AddCostToLearner
PLearn::AdditiveGaussianNoiseVariableThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::AdditiveNormalizationKernel
PLearn::AddLayersNNet
PLearn::AddMissingVMatrix
PLearn::AffineTransformVariable
PLearn::AffineTransformWeightPenaltyWeight decay terms for affine transforms
PLearn::PMemArena::AlignerUtility union to ensure alignment across platforms
alist
PLearn::AnalyzeDond2DiscreteVariablesGenerate samples from a mixture of two gaussians
PLearn::AnalyzeFieldStatsGenerate samples from a mixture of two gaussians
PLearn::AppendNeighborsVMatrixAppends the nearest neighbors of the input samples of a source VMatrix
PLearn::ARDBaseKernelBase class for kernels that carry out Automatic Relevance Determination (ARD)
PLearn::ArgDocDocumentation for a single remote method argument
PLearn::ArgmaxModuleThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ArgmaxVariable
PLearn::ArgminOfVariable
PLearn::ArgminVariable
PLearn::ArgTypeDocDocumentation for a method argument type (just contains the type as a string)
PLearn::Array< T >
PLearn::Array2ArrayMap< T >
PLearn::ArrayAllocator< T, SizeBits >
PLearn::ArrayAllocatorIndex< IndexBase, SizeBits >This type represents an index into the allocated memory, as a bit-field parameterized by the template argument SizeBits
PLearn::ArrayAllocatorOptions
PLearn::ArrayAllocatorTrivial< T, SizeBits >This allocator solely performs allocation
PLearn::AsciiVMatrix
PLearn::AutoLinearRegressorThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::AutoRunCommand
PLearn::AutoScaledGradientOptimizer
PLearn::AutoSDBVMatrixA VMatrix view of a SimpleDB: columns whose type is string are removed from the view, all others are converted to real (characters to their ascii code, and dates to the float date format: 990324)
PLearn::AutoVMatrixThis class is a simple wrapper to an underlying VMatrix of another type All it does is forward the method calls
PLearn::AutoVMatrixSaveSourceThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::AutoVMatrixTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::BackConvolution2DModuleTranspose of Convolution2DModule
PLearn::BaggingLearnerLearner that trains several sub-learners on 'bags'
PLearn::BallTreeNearestNeighbors
PLearn::BaseRegressorConfidence
PLearn::BaseRegressorWrapper
PLearn::BasicIdentityCallsTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::BasisSelectionRegressorThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::BatchVMatrixVMat class that replicates small parts of a matrix (mini-batches), so that each mini-batch appears twice (consecutively)
PLearn::BernoulliSampleVariable
PLearn::BestAveragingPLearnerSelect the M "best" of N trained PLearners based on a train cost
PLearn::BetaKernelThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::BiasWeightAffineTransformVariableAffine transformation of a vector variable, from a weight and bias variable
PLearn::BinarizeModuleMap probabilities in (0,1) to a bit in {0,1}, either according to a hard threshold (> 0.5), or by sampling, and ALLOW GRADIENTS TO PROPAGATE BACKWARDS
PLearn::BinaryBallTree
PLearn::BinaryClassificationLossVariable
PLearn::BinaryKernelDiscriminationThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::BinaryNumbersVMatrixVMatrix that can take its values from a possibly large file (greater than 2Gig) containing numbers in a user-given binary format, preceded by an arbitrary header whose length is user-given
PLearn::BinaryOpVMatrix
PLearn::BinarySampleVariable
PLearn::BinaryStump
PLearn::BinaryVariable
PLearn::Binner
PLearn::BinSplitter
PLearn::BodyDocDocumentation for remote method body
PLearn::BootstrapSplitter
PLearn::BootstrapVMatrix
PLearn::BottomNI< T >
PLearn::BoundedMemoryCache< KeyType, ValueType >Class description:
PLearn::BufferedIntVecFile
PLearn::ByteMemoryVMatrix
PLearn::Cache< KeyType, ValueType >Class description:
PLearn::CachedFeatureSetFeature set that maintains a cached mapping between tokens and their features
PLearn::CalendarEncapsulates the concept of a calendar as an ordered finite list of timestamps
PLearn::CallbackThis is a virtual base class that contains a single abstract method callback()
PLearn::CallbackMeasurer
PLearn::CartesianProductOracle
PLearn::CCCostVariable
PLearn::CenteredVMatrix
PLearn::ChainedLearnersThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::CheckDond2FileSequenceGenerate samples from a mixture of two gaussians
PLearn::ChemicalICPThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ChildA
PLearn::ChildB
PLearn::chkUnsigned< x >
PLearn::chkUnsigned< true >
cilist
PLearn::ClassDistanceProportionCostFunction
PLearn::ClassErrorCostFunction
PLearn::ClassErrorCostModuleMulticlass classification error
PLearn::ClassificationLossVariableIndicator(classnum==argmax(netout))
PLearn::ClassifierFromConditionalPDistributionClassifier that takes a ConditionalPDistribution and classifies with it, by finding the target class y that maximizes p(y|x), where x is the input
PLearn::ClassifierFromDensity
PLearn::ClassMarginCostFunction
PLearn::ClassSeparationSplitterSplitter that separates examples of some classes (test) from the examples of other classes (train)
PLearn::ClassSubsetVMatrix
cllist
PLearn::ColumnIndexVariable
PLearn::ColumnSumVariableResult is a single row that contains the sum of each column of the input
PLearn::CombiningCostsModuleCombine several CostModules with the same input and target
PLearn::CompactFileVMatrixA VMatrix that exists in a .pmat file (native PLearn matrix format, same as for Mat)
PLearn::CompactVMatrix
PLearn::CompactVMatrixGaussianKernel
PLearn::CompactVMatrixPolynomialKernel
PLearn::compareIndexAndMissingFlagsComparison function used in sorting
PLearn::CompareLearner
PLearn::ComplementedProbSparseMatrix
complex
PLearn::CompressedVMatrix
PLearn::ComputeDond2TargetGenerate samples from a mixture of two gaussians
PLearn::ComputePurenneError
PLearn::ConcatColumnsRandomVariableConcatenate the columns of the matrix arguments, just like the hconcat function (PLearn.h) on Vars
PLearn::ConcatColumnsVariableConcatenation of the columns of several variables
PLearn::ConcatColumnsVMatrix
PLearn::ConcatDisjointFeatureSetFeature set that is the concatenation of disjoint feature sets
PLearn::ConcatOfVariable
PLearn::ConcatRowsSubVMatrix
PLearn::ConcatRowsVariableConcatenation of the rows of several variables
PLearn::ConcatRowsVMatrix
PLearn::ConcatSetsSplitter
PLearn::ConditionalCDFSmoother
PLearn::ConditionalDensityNet
PLearn::ConditionalDictionary
PLearn::ConditionalDistribution
PLearn::ConditionalExpression
PLearn::ConditionalGaussianDistribution
PLearn::ConditionalMeanImputationVMatrix
PLearn::ConditionalStatsCollector
PLearn::ConfigParsingThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ConfRatedAdaboostCostVariable
PLearn::ConjGradientOptimizer
PLearn::ConjRosenbrockExercises the Conjugate Gradient optimizer through the Rosenbrock Function
PLearn::ConstantRealFunctionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ConstantRegressor
PLearn::ConstantVMatrixThis VMatrix returns a constant element (specified upon construction)
PLearn::ConstrainedSourceVariableSourceVariable that after each update, modifies values as needed to satisfy simple constraints
PLearn::ConstrainVariable
PLearn::ConvertFromPyObject< T >Set of conversion functions from Python to C++
PLearn::ConvertFromPyObject< Array< T > >
PLearn::ConvertFromPyObject< bool >
PLearn::ConvertFromPyObject< CopiesMap >
PLearn::ConvertFromPyObject< double >
PLearn::ConvertFromPyObject< float >
PLearn::ConvertFromPyObject< int >
PLearn::ConvertFromPyObject< long >
PLearn::ConvertFromPyObject< long long >
PLearn::ConvertFromPyObject< Mat >
PLearn::ConvertFromPyObject< Object * >
PLearn::ConvertFromPyObject< PP< T > >
PLearn::ConvertFromPyObject< PP< VMatrix > >
PLearn::ConvertFromPyObject< PPath >
PLearn::ConvertFromPyObject< PPointable * >
PLearn::ConvertFromPyObject< PyObject * >
PLearn::ConvertFromPyObject< PythonObjectWrapper >
PLearn::ConvertFromPyObject< RealRange >
PLearn::ConvertFromPyObject< short >
PLearn::ConvertFromPyObject< std::map< T, U > >
PLearn::ConvertFromPyObject< std::pair< T, U > >
PLearn::ConvertFromPyObject< std::set< T > >
PLearn::ConvertFromPyObject< std::vector< T > >
PLearn::ConvertFromPyObject< string >
PLearn::ConvertFromPyObject< T * >***///***
PLearn::ConvertFromPyObject< TMat< T > >
PLearn::ConvertFromPyObject< TVec< T > >
PLearn::ConvertFromPyObject< unsigned int >
PLearn::ConvertFromPyObject< unsigned long >
PLearn::ConvertFromPyObject< unsigned long long >
PLearn::ConvertFromPyObject< unsigned short >
PLearn::ConvertFromPyObject< VarArray >
PLearn::ConvertFromPyObject< Vec >***///***
PLearn::ConvertFromPyObject< VMField >
PLearn::ConvertToPyObject< T >
PLearn::ConvertToPyObject< Array< T > >Generic array: create a Python list of those objects recursively
PLearn::ConvertToPyObject< bool >
PLearn::ConvertToPyObject< char * >
PLearn::ConvertToPyObject< char[N]>
PLearn::ConvertToPyObject< CopiesMap >
PLearn::ConvertToPyObject< double >
PLearn::ConvertToPyObject< float >
PLearn::ConvertToPyObject< int >
PLearn::ConvertToPyObject< long >
PLearn::ConvertToPyObject< long long >
PLearn::ConvertToPyObject< Mat >PLearn Mat: use numarray
PLearn::ConvertToPyObject< Object * >
PLearn::ConvertToPyObject< PP< T > >Generic PP: wrap pointed object
PLearn::ConvertToPyObject< PP< VMatrix > >PLearn VMat
PLearn::ConvertToPyObject< PPath >
PLearn::ConvertToPyObject< PythonObjectWrapper >For a general PythonObjectWrapper: we simply increment the refcount to the underlying Python object, no matter whether we own it or not
PLearn::ConvertToPyObject< RealRange >
PLearn::ConvertToPyObject< short >
PLearn::ConvertToPyObject< std::map< T, U > >C++ stlib map<>: create a Python dict of those objects
PLearn::ConvertToPyObject< std::map< T, U > const * >Pointer to map<>: simply dereference pointer, or None if NULL
PLearn::ConvertToPyObject< std::pair< T, U > >C++ stdlib pair<>: create a Python tuple with two elements
PLearn::ConvertToPyObject< std::set< T > >C++ stlib set<>: create a Python set of those objects
PLearn::ConvertToPyObject< std::set< T > const * >Pointer to set<>: simply dereference pointer, or None if NULL
PLearn::ConvertToPyObject< std::vector< T > >C++ stdlib vector<>: create a Python list of those objects recursively
PLearn::ConvertToPyObject< std::vector< T > const * >Pointer to vector<>: simply dereference pointer, or None if NULL
PLearn::ConvertToPyObject< string >
PLearn::ConvertToPyObject< T * >
PLearn::ConvertToPyObject< TMat< T > >Generic matrix: create a Python list of those objects recursively
PLearn::ConvertToPyObject< tuple< T > >Tuples (1 to 7 elts.)
PLearn::ConvertToPyObject< tuple< T, U > >
PLearn::ConvertToPyObject< tuple< T, U, V > >
PLearn::ConvertToPyObject< tuple< T, U, V, W > >
PLearn::ConvertToPyObject< tuple< T, U, V, W, X > >
PLearn::ConvertToPyObject< tuple< T, U, V, W, X, Y > >
PLearn::ConvertToPyObject< tuple< T, U, V, W, X, Y, Z > >
PLearn::ConvertToPyObject< TVec< T > >Generic vector: create a Python list of those objects recursively
PLearn::ConvertToPyObject< unsigned int >
PLearn::ConvertToPyObject< unsigned long >
PLearn::ConvertToPyObject< unsigned long long >
PLearn::ConvertToPyObject< unsigned short >
PLearn::ConvertToPyObject< VarArray >
PLearn::ConvertToPyObject< Vec >PLearn Vec: use numarray
PLearn::ConvertToPyObject< VMField >
PLearn::ConvexBasisKernelReturns prod_i log(1+exp(c*(x1[i]-x2[i]))) NOTE: IT IS NOT SYMMETRIC!
PLearn::Convolution2DModuleApply convolution filters on (possibly multiple) 2D inputs (images)
PLearn::ConvolveVariableA convolve var; equals convolve(input, mask)
PLearn::CorrelationKernel
PLearn::CorrelationProfilerUsed to profile the correlation between the elements of a vector
PLearn::Correspondence
PLearn::CosKernelThis class implements an Ln distance (defaults to L2 i.e. euclidean distance)
PLearn::CostModuleGeneral class representing a cost function module
PLearn::CountEventsSemaphore
PLearn::Cov2CorrVariable
PLearn::CovariancePreservationImputationVMatrix
PLearn::CrossEntropyCostModuleComputes the cross-entropy, given two activation vectors
PLearn::CrossEntropyVariableCost = - sum_i {target_i * log(output_i) + (1-target_i) * log(1-output_i)}
PLearn::CrossReferenceVMatrix
PLearn::CubicSplineUnidimensional cubic spline learner
PLearn::CumVMatrix
PLearn::CutAboveThresholdVariable
PLearn::CutBelowThresholdVariable
PLearn::DatedJoinVMatrix
PLearn::DatedVMatrix
PLearn::FieldValue::DateVal_t
PLearn::DBSplitter
PLearn::DeepBeliefNetNeural net, learned layer-wise in a greedy fashion
PLearn::DeepFeatureExtractorNNetDeep Neural Network that extracts features in a greedy, mostly unsupervised way
PLearn::DeepNNet
PLearn::DeepNonLocalManifoldParzenNeural net, trained layer-wise to predict the manifold structure of the data
PLearn::DeepReconstructorNetThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::DenoisingRecurrentNetModel made of RBMs linked through time
PLearn::DeterminantVariableThe argument must be a square matrix Var and the result is its determinant
PLearn::DiagonalizedFactorsProductVariable
PLearn::DiagonalNormalRandomVariable
PLearn::DiagonalNormalSampleVariable
PLearn::DiagVariable
PLearn::DichotomizeDond2DiscreteVariablesGenerate samples from a mixture of two gaussians
PLearn::DichotomizeVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::Dictionary
PLearn::DictionaryVMatrixVMat of text files, encoded with Dictionaries, The lines of the text files that are empty are ommited
PLearn::DiffCommand
PLearn::DifferenceKernelReturns sum_i[x1_i-x2_i]
PLearn::DiffTemplate< ObjectType, OptionType >
PLearn::DiffTemplate< ObjectType, AbsVariable >
PLearn::DiffTemplate< ObjectType, AdaBoost >
PLearn::DiffTemplate< ObjectType, AddCostToLearner >
PLearn::DiffTemplate< ObjectType, AdditiveGaussianNoiseVariable >
PLearn::DiffTemplate< ObjectType, AdditiveNormalizationKernel >
PLearn::DiffTemplate< ObjectType, AddLayersNNet >
PLearn::DiffTemplate< ObjectType, AddMissingVMatrix >
PLearn::DiffTemplate< ObjectType, AffineTransformVariable >
PLearn::DiffTemplate< ObjectType, AffineTransformWeightPenalty >
PLearn::DiffTemplate< ObjectType, AnalyzeDond2DiscreteVariables >
PLearn::DiffTemplate< ObjectType, AnalyzeFieldStats >
PLearn::DiffTemplate< ObjectType, AppendNeighborsVMatrix >
PLearn::DiffTemplate< ObjectType, ArgmaxVariable >
PLearn::DiffTemplate< ObjectType, ArgminVariable >
PLearn::DiffTemplate< ObjectType, AsciiVMatrix >
PLearn::DiffTemplate< ObjectType, AutoLinearRegressor >
PLearn::DiffTemplate< ObjectType, AutoScaledGradientOptimizer >
PLearn::DiffTemplate< ObjectType, AutoVMatrix >
PLearn::DiffTemplate< ObjectType, AutoVMatrixSaveSource >
PLearn::DiffTemplate< ObjectType, AutoVMatrixTest >
PLearn::DiffTemplate< ObjectType, BaggingLearner >
PLearn::DiffTemplate< ObjectType, BallTreeNearestNeighbors >
PLearn::DiffTemplate< ObjectType, BaseRegressorConfidence >
PLearn::DiffTemplate< ObjectType, BaseRegressorWrapper >
PLearn::DiffTemplate< ObjectType, BasicIdentityCallsTest >
PLearn::DiffTemplate< ObjectType, BasisSelectionRegressor >
PLearn::DiffTemplate< ObjectType, BatchVMatrix >
PLearn::DiffTemplate< ObjectType, BernoulliSampleVariable >
PLearn::DiffTemplate< ObjectType, BestAveragingPLearner >
PLearn::DiffTemplate< ObjectType, BetaKernel >
PLearn::DiffTemplate< ObjectType, BiasWeightAffineTransformVariable >
PLearn::DiffTemplate< ObjectType, BinaryBallTree >
PLearn::DiffTemplate< ObjectType, BinaryClassificationLossVariable >
PLearn::DiffTemplate< ObjectType, BinaryKernelDiscrimination >
PLearn::DiffTemplate< ObjectType, BinaryNumbersVMatrix >
PLearn::DiffTemplate< ObjectType, BinaryOpVMatrix >
PLearn::DiffTemplate< ObjectType, BinaryVariable >
PLearn::DiffTemplate< ObjectType, Binner >
PLearn::DiffTemplate< ObjectType, BinSplitter >
PLearn::DiffTemplate< ObjectType, BootstrapSplitter >
PLearn::DiffTemplate< ObjectType, BootstrapVMatrix >
PLearn::DiffTemplate< ObjectType, ByteMemoryVMatrix >
PLearn::DiffTemplate< ObjectType, Calendar >
PLearn::DiffTemplate< ObjectType, CartesianProductOracle >
PLearn::DiffTemplate< ObjectType, CCCostVariable >
PLearn::DiffTemplate< ObjectType, CenteredVMatrix >
PLearn::DiffTemplate< ObjectType, ChainedLearners >
PLearn::DiffTemplate< ObjectType, ChemicalICP >
PLearn::DiffTemplate< ObjectType, ClassDistanceProportionCostFunction >
PLearn::DiffTemplate< ObjectType, ClassErrorCostFunction >
PLearn::DiffTemplate< ObjectType, ClassificationLossVariable >
PLearn::DiffTemplate< ObjectType, ClassMarginCostFunction >
PLearn::DiffTemplate< ObjectType, ClassSeparationSplitter >
PLearn::DiffTemplate< ObjectType, ClassSubsetVMatrix >
PLearn::DiffTemplate< ObjectType, ColumnIndexVariable >
PLearn::DiffTemplate< ObjectType, CompactFileVMatrix >
PLearn::DiffTemplate< ObjectType, CompactVMatrix >
PLearn::DiffTemplate< ObjectType, CompactVMatrixGaussianKernel >
PLearn::DiffTemplate< ObjectType, CompactVMatrixPolynomialKernel >
PLearn::DiffTemplate< ObjectType, CompareLearner >
PLearn::DiffTemplate< ObjectType, CompressedVMatrix >
PLearn::DiffTemplate< ObjectType, ComputeDond2Target >
PLearn::DiffTemplate< ObjectType, ConcatColumnsVariable >
PLearn::DiffTemplate< ObjectType, ConcatColumnsVMatrix >
PLearn::DiffTemplate< ObjectType, ConcatOfVariable >
PLearn::DiffTemplate< ObjectType, ConcatRowsSubVMatrix >
PLearn::DiffTemplate< ObjectType, ConcatRowsVariable >
PLearn::DiffTemplate< ObjectType, ConcatRowsVMatrix >
PLearn::DiffTemplate< ObjectType, ConcatSetsSplitter >
PLearn::DiffTemplate< ObjectType, ConditionalCDFSmoother >
PLearn::DiffTemplate< ObjectType, ConditionalDensityNet >
PLearn::DiffTemplate< ObjectType, ConditionalDictionary >
PLearn::DiffTemplate< ObjectType, ConditionalMeanImputationVMatrix >
PLearn::DiffTemplate< ObjectType, ConditionalStatsCollector >
PLearn::DiffTemplate< ObjectType, ConfRatedAdaboostCostVariable >
PLearn::DiffTemplate< ObjectType, ConjRosenbrock >
PLearn::DiffTemplate< ObjectType, ConstantRegressor >
PLearn::DiffTemplate< ObjectType, ConstantVMatrix >
PLearn::DiffTemplate< ObjectType, ConstrainVariable >
PLearn::DiffTemplate< ObjectType, ConvexBasisKernel >
PLearn::DiffTemplate< ObjectType, ConvolveVariable >
PLearn::DiffTemplate< ObjectType, CorrelationKernel >
PLearn::DiffTemplate< ObjectType, CorrelationProfiler >
PLearn::DiffTemplate< ObjectType, Correspondence >
PLearn::DiffTemplate< ObjectType, CosKernel >
PLearn::DiffTemplate< ObjectType, Cov2CorrVariable >
PLearn::DiffTemplate< ObjectType, CovariancePreservationImputationVMatrix >
PLearn::DiffTemplate< ObjectType, CrossEntropyVariable >
PLearn::DiffTemplate< ObjectType, CrossReferenceVMatrix >
PLearn::DiffTemplate< ObjectType, CubicSpline >
PLearn::DiffTemplate< ObjectType, CumVMatrix >
PLearn::DiffTemplate< ObjectType, CutAboveThresholdVariable >
PLearn::DiffTemplate< ObjectType, CutBelowThresholdVariable >
PLearn::DiffTemplate< ObjectType, DatedJoinVMatrix >
PLearn::DiffTemplate< ObjectType, DatedVMatrix >
PLearn::DiffTemplate< ObjectType, DBSplitter >
PLearn::DiffTemplate< ObjectType, DeepBeliefNet >
PLearn::DiffTemplate< ObjectType, DeepFeatureExtractorNNet >
PLearn::DiffTemplate< ObjectType, DeepNNet >
PLearn::DiffTemplate< ObjectType, DeepNonLocalManifoldParzen >
PLearn::DiffTemplate< ObjectType, DeepReconstructorNet >
PLearn::DiffTemplate< ObjectType, DenoisingRecurrentNet >
PLearn::DiffTemplate< ObjectType, DeterminantVariable >
PLearn::DiffTemplate< ObjectType, DiagonalizedFactorsProductVariable >
PLearn::DiffTemplate< ObjectType, DiagVariable >
PLearn::DiffTemplate< ObjectType, DichotomizeDond2DiscreteVariables >
PLearn::DiffTemplate< ObjectType, DichotomizeVMatrix >
PLearn::DiffTemplate< ObjectType, Dictionary >
PLearn::DiffTemplate< ObjectType, DictionaryVMatrix >
PLearn::DiffTemplate< ObjectType, DifferenceKernel >
PLearn::DiffTemplate< ObjectType, DilogarithmVariable >
PLearn::DiffTemplate< ObjectType, DiscriminativeDeepBeliefNet >
PLearn::DiffTemplate< ObjectType, DiscriminativeRBM >
PLearn::DiffTemplate< ObjectType, DiskVMatrix >
PLearn::DiffTemplate< ObjectType, DisregardRowsVMatrix >
PLearn::DiffTemplate< ObjectType, DistanceKernel >
PLearn::DiffTemplate< ObjectType, DistRepNNet >
PLearn::DiffTemplate< ObjectType, DiverseComponentAnalysis >
PLearn::DiffTemplate< ObjectType, DivisiveNormalizationKernel >
PLearn::DiffTemplate< ObjectType, DivVariable >
PLearn::DiffTemplate< ObjectType, DotProductKernel >
PLearn::DiffTemplate< ObjectType, DotProductVariable >
PLearn::DiffTemplate< ObjectType, DoubleProductVariable >
PLearn::DiffTemplate< ObjectType, DTWKernel >
PLearn::DiffTemplate< ObjectType, DuplicateColumnVariable >
PLearn::DiffTemplate< ObjectType, DuplicateRowVariable >
PLearn::DiffTemplate< ObjectType, DuplicateScalarVariable >
PLearn::DiffTemplate< ObjectType, DynamicallyLinkedRBMsModel >
PLearn::DiffTemplate< ObjectType, EarlyStoppingOracle >
PLearn::DiffTemplate< ObjectType, ElementAtPositionVariable >
PLearn::DiffTemplate< ObjectType, EmbeddedLearner >
PLearn::DiffTemplate< ObjectType, EmbeddedSequentialLearner >
PLearn::DiffTemplate< ObjectType, EncodedVMatrix >
PLearn::DiffTemplate< ObjectType, EntropyContrast >
PLearn::DiffTemplate< ObjectType, EntropyContrastLearner >
PLearn::DiffTemplate< ObjectType, EpanechnikovKernel >
PLearn::DiffTemplate< ObjectType, EqualConstantVariable >
PLearn::DiffTemplate< ObjectType, EqualScalarVariable >
PLearn::DiffTemplate< ObjectType, EqualVariable >
PLearn::DiffTemplate< ObjectType, ErfVariable >
PLearn::DiffTemplate< ObjectType, ExhaustiveNearestNeighbors >
PLearn::DiffTemplate< ObjectType, Experiment >
PLearn::DiffTemplate< ObjectType, Experimentation >
PLearn::DiffTemplate< ObjectType, ExplicitListOracle >
PLearn::DiffTemplate< ObjectType, ExplicitSplitter >
PLearn::DiffTemplate< ObjectType, ExpMeanStatsIterator >
PLearn::DiffTemplate< ObjectType, ExpVariable >
PLearn::DiffTemplate< ObjectType, ExtendedVariable >
PLearn::DiffTemplate< ObjectType, ExtendedVMatrix >
PLearn::DiffTemplate< ObjectType, ExtractNNetParamsVMatrix >
PLearn::DiffTemplate< ObjectType, ExtractVariable >
PLearn::DiffTemplate< ObjectType, FeatureSet >
PLearn::DiffTemplate< ObjectType, FeatureSetNaiveBayesClassifier >
PLearn::DiffTemplate< ObjectType, FeatureSetNNet >
PLearn::DiffTemplate< ObjectType, FeatureSetSequentialCRF >
PLearn::DiffTemplate< ObjectType, FileDictionary >
PLearn::DiffTemplate< ObjectType, FileVMatrix >
PLearn::DiffTemplate< ObjectType, FileVMatrixTest >
PLearn::DiffTemplate< ObjectType, FilteredVMatrix >
PLearn::DiffTemplate< ObjectType, FilterSplitter >
PLearn::DiffTemplate< ObjectType, FinancePreprocVMatrix >
PLearn::DiffTemplate< ObjectType, FixDond2BinaryVariables >
PLearn::DiffTemplate< ObjectType, FNetLayerVariable >
PLearn::DiffTemplate< ObjectType, ForwardModule >
PLearn::DiffTemplate< ObjectType, ForwardVMatrix >
PLearn::DiffTemplate< ObjectType, FractionSplitter >
PLearn::DiffTemplate< ObjectType, Function >
PLearn::DiffTemplate< ObjectType, GaussianContinuum >
PLearn::DiffTemplate< ObjectType, GaussianContinuumDistribution >
PLearn::DiffTemplate< ObjectType, GaussianDBNClassification >
PLearn::DiffTemplate< ObjectType, GaussianDBNRegression >
PLearn::DiffTemplate< ObjectType, GaussianDensityKernel >
PLearn::DiffTemplate< ObjectType, GaussianizeVMatrix >
PLearn::DiffTemplate< ObjectType, GaussianKernel >
PLearn::DiffTemplate< ObjectType, GaussianProcessNLLVariable >
PLearn::DiffTemplate< ObjectType, GaussianProcessRegressor >
PLearn::DiffTemplate< ObjectType, GaussMix >
PLearn::DiffTemplate< ObjectType, GaussMixLocalProjections >
PLearn::DiffTemplate< ObjectType, GaussPartSupervisedDBN >
PLearn::DiffTemplate< ObjectType, GeneralizedDistanceRBFKernel >
PLearn::DiffTemplate< ObjectType, GeneralizedOneHotVMatrix >
PLearn::DiffTemplate< ObjectType, GenerateDecisionPlot >
PLearn::DiffTemplate< ObjectType, GenericNearestNeighbors >
PLearn::DiffTemplate< ObjectType, GeodesicDistanceKernel >
PLearn::DiffTemplate< ObjectType, GetInputVMatrix >
PLearn::DiffTemplate< ObjectType, GradientAdaboostCostVariable >
PLearn::DiffTemplate< ObjectType, GradientCorrector >
PLearn::DiffTemplate< ObjectType, GradientOptimizer >
PLearn::DiffTemplate< ObjectType, GradNNetLayerModule >
PLearn::DiffTemplate< ObjectType, GramVMatrix >
PLearn::DiffTemplate< ObjectType, Grapher >
PLearn::DiffTemplate< ObjectType, HardSlopeVariable >
PLearn::DiffTemplate< ObjectType, HashMapFeatureSet >
PLearn::DiffTemplate< ObjectType, HeapTest >
PLearn::DiffTemplate< ObjectType, HeterogenuousAffineTransformVariable >
PLearn::DiffTemplate< ObjectType, HeterogenuousAffineTransformWeightPenalty >
PLearn::DiffTemplate< ObjectType, HintonDeepBeliefNet >
PLearn::DiffTemplate< ObjectType, HistogramDistribution >
PLearn::DiffTemplate< ObjectType, HorizonStatefulLearner >
PLearn::DiffTemplate< ObjectType, HTMLHelpGenerator >
PLearn::DiffTemplate< ObjectType, HyperCommand >
PLearn::DiffTemplate< ObjectType, HyperLearner >
PLearn::DiffTemplate< ObjectType, HyperOptimize >
PLearn::DiffTemplate< ObjectType, HyperRetrain >
PLearn::DiffTemplate< ObjectType, HyperSetOption >
PLearn::DiffTemplate< ObjectType, ICP >
PLearn::DiffTemplate< ObjectType, IdentityFeatureSet >
PLearn::DiffTemplate< ObjectType, IdentityModule >
PLearn::DiffTemplate< ObjectType, IdentityPLearner >
PLearn::DiffTemplate< ObjectType, IdentityVariable >
PLearn::DiffTemplate< ObjectType, IfThenElseVariable >
PLearn::DiffTemplate< ObjectType, ImputationVMatrix >
PLearn::DiffTemplate< ObjectType, IncrementalNNet >
PLearn::DiffTemplate< ObjectType, IndexAtPositionVariable >
PLearn::DiffTemplate< ObjectType, IndexedVMatrix >
PLearn::DiffTemplate< ObjectType, IndexedVMatrixTest >
PLearn::DiffTemplate< ObjectType, InferenceRBM >
PLearn::DiffTemplate< ObjectType, InfiniteMNISTVMatrix >
PLearn::DiffTemplate< ObjectType, InjectionTest >
PLearn::DiffTemplate< ObjectType, InsertZerosVariable >
PLearn::DiffTemplate< ObjectType, InstanceSnippetTest >
PLearn::DiffTemplate< ObjectType, InterfunctionXchgTest >
PLearn::DiffTemplate< ObjectType, InterleaveVMatrix >
PLearn::DiffTemplate< ObjectType, InterValuesVariable >
PLearn::DiffTemplate< ObjectType, InvertElementsVariable >
PLearn::DiffTemplate< ObjectType, IsAboveThresholdVariable >
PLearn::DiffTemplate< ObjectType, IsLargerVariable >
PLearn::DiffTemplate< ObjectType, IsMissingVariable >
PLearn::DiffTemplate< ObjectType, Isomap >
PLearn::DiffTemplate< ObjectType, IsomapTangentLearner >
PLearn::DiffTemplate< ObjectType, IsSmallerVariable >
PLearn::DiffTemplate< ObjectType, JoinVMatrix >
PLearn::DiffTemplate< ObjectType, JulianizeVMatrix >
PLearn::DiffTemplate< ObjectType, Kernel >
PLearn::DiffTemplate< ObjectType, KernelDensityEstimator >
PLearn::DiffTemplate< ObjectType, KernelPCA >
PLearn::DiffTemplate< ObjectType, KernelProjection >
PLearn::DiffTemplate< ObjectType, KernelRidgeRegressor >
PLearn::DiffTemplate< ObjectType, KernelVMatrix >
PLearn::DiffTemplate< ObjectType, KFoldSplitter >
PLearn::DiffTemplate< ObjectType, KLp0p1RBMModule >
PLearn::DiffTemplate< ObjectType, KMeansClustering >
PLearn::DiffTemplate< ObjectType, KNNClassifier >
PLearn::DiffTemplate< ObjectType, KNNImputationVMatrix >
PLearn::DiffTemplate< ObjectType, KNNRegressor >
PLearn::DiffTemplate< ObjectType, KNNVMatrix >
PLearn::DiffTemplate< ObjectType, KPCATangentLearner >
PLearn::DiffTemplate< ObjectType, LaplacianKernel >
PLearn::DiffTemplate< ObjectType, LayerCostModule >
PLearn::DiffTemplate< ObjectType, Learner >
PLearn::DiffTemplate< ObjectType, LearnerProcessedVMatrix >
PLearn::DiffTemplate< ObjectType, LeftPseudoInverseVariable >
PLearn::DiffTemplate< ObjectType, LemmatizeVMatrix >
PLearn::DiffTemplate< ObjectType, LIBSVMSparseVMatrix >
PLearn::DiffTemplate< ObjectType, LiftBinaryCostFunction >
PLearn::DiffTemplate< ObjectType, LiftOutputVariable >
PLearn::DiffTemplate< ObjectType, LiftStatsCollector >
PLearn::DiffTemplate< ObjectType, LiftStatsIterator >
PLearn::DiffTemplate< ObjectType, LimitedGaussianSmoother >
PLearn::DiffTemplate< ObjectType, LinearCombinationModule >
PLearn::DiffTemplate< ObjectType, LinearCombinationOfScalarVariables >
PLearn::DiffTemplate< ObjectType, LinearFilterModule >
PLearn::DiffTemplate< ObjectType, LinearInductiveTransferClassifier >
PLearn::DiffTemplate< ObjectType, LinearRegressor >
PLearn::DiffTemplate< ObjectType, LLC >
PLearn::DiffTemplate< ObjectType, LLE >
PLearn::DiffTemplate< ObjectType, LLEKernel >
PLearn::DiffTemplate< ObjectType, LocalizedFeaturesLayerVariable >
PLearn::DiffTemplate< ObjectType, LocallyMagnifiedDistribution >
PLearn::DiffTemplate< ObjectType, LocalMedBoost >
PLearn::DiffTemplate< ObjectType, LocalNeighborsDifferencesVMatrix >
PLearn::DiffTemplate< ObjectType, LogAddVariable >
PLearn::DiffTemplate< ObjectType, LogOfGaussianDensityKernel >
PLearn::DiffTemplate< ObjectType, LogSoftmaxVariable >
PLearn::DiffTemplate< ObjectType, LogSoftSoftMaxVariable >
PLearn::DiffTemplate< ObjectType, LogVariable >
PLearn::DiffTemplate< ObjectType, ManifoldKNNDistribution >
PLearn::DiffTemplate< ObjectType, ManifoldParzen >
PLearn::DiffTemplate< ObjectType, ManifoldParzen2 >
PLearn::DiffTemplate< ObjectType, ManifoldParzenKernel >
PLearn::DiffTemplate< ObjectType, ManualBinner >
PLearn::DiffTemplate< ObjectType, MarginPerceptronCostVariable >
PLearn::DiffTemplate< ObjectType, MatrixAffineTransformFeedbackVariable >
PLearn::DiffTemplate< ObjectType, MatrixAffineTransformVariable >
PLearn::DiffTemplate< ObjectType, MatrixElementsVariable >
PLearn::DiffTemplate< ObjectType, MatrixInverseVariable >
PLearn::DiffTemplate< ObjectType, MatrixModule >
PLearn::DiffTemplate< ObjectType, MatrixOneHotSquaredLoss >
PLearn::DiffTemplate< ObjectType, MatrixSoftmaxLossVariable >
PLearn::DiffTemplate< ObjectType, MatrixSoftmaxVariable >
PLearn::DiffTemplate< ObjectType, MatrixSumOfVariable >
PLearn::DiffTemplate< ObjectType, MatRowVariable >
PLearn::DiffTemplate< ObjectType, Max2Variable >
PLearn::DiffTemplate< ObjectType, MaxStatsIterator >
PLearn::DiffTemplate< ObjectType, MaxSubsampling2DModule >
PLearn::DiffTemplate< ObjectType, MaxSubsamplingTest >
PLearn::DiffTemplate< ObjectType, MaxVariable >
PLearn::DiffTemplate< ObjectType, MeanImputationVMatrix >
PLearn::DiffTemplate< ObjectType, MeanMedianModeImputationVMatrix >
PLearn::DiffTemplate< ObjectType, MeanStatsIterator >
PLearn::DiffTemplate< ObjectType, MemoryCachedKernel >
PLearn::DiffTemplate< ObjectType, MemoryStressTest >
PLearn::DiffTemplate< ObjectType, MemoryVMatrix >
PLearn::DiffTemplate< ObjectType, MemoryVMatrixNoSave >
PLearn::DiffTemplate< ObjectType, MergeDond2Files >
PLearn::DiffTemplate< ObjectType, MeshEdge >
PLearn::DiffTemplate< ObjectType, MeshFace >
PLearn::DiffTemplate< ObjectType, MeshGraph >
PLearn::DiffTemplate< ObjectType, MeshMatch >
PLearn::DiffTemplate< ObjectType, MeshVertex >
PLearn::DiffTemplate< ObjectType, Min2Variable >
PLearn::DiffTemplate< ObjectType, MiniBatchClassificationLossVariable >
PLearn::DiffTemplate< ObjectType, MinStatsIterator >
PLearn::DiffTemplate< ObjectType, MinusColumnVariable >
PLearn::DiffTemplate< ObjectType, MinusRowVariable >
PLearn::DiffTemplate< ObjectType, MinusTransposedColumnVariable >
PLearn::DiffTemplate< ObjectType, MinusVariable >
PLearn::DiffTemplate< ObjectType, MinVariable >
PLearn::DiffTemplate< ObjectType, MissingIndicatorVMatrix >
PLearn::DiffTemplate< ObjectType, MissingInstructionVMatrix >
PLearn::DiffTemplate< ObjectType, MixtureVMatrix >
PLearn::DiffTemplate< ObjectType, MixUnlabeledNeighbourVMatrix >
PLearn::DiffTemplate< ObjectType, mNNet >
PLearn::DiffTemplate< ObjectType, ModuleLearner >
PLearn::DiffTemplate< ObjectType, ModulesLearner >
PLearn::DiffTemplate< ObjectType, ModuleStackModule >
PLearn::DiffTemplate< ObjectType, ModuleTester >
PLearn::DiffTemplate< ObjectType, Molecule >
PLearn::DiffTemplate< ObjectType, MoleculeTemplateLearner >
PLearn::DiffTemplate< ObjectType, MovingAverage >
PLearn::DiffTemplate< ObjectType, MovingAverageVMatrix >
PLearn::DiffTemplate< ObjectType, MultiClassAdaBoost >
PLearn::DiffTemplate< ObjectType, MulticlassErrorCostFunction >
PLearn::DiffTemplate< ObjectType, MulticlassLossVariable >
PLearn::DiffTemplate< ObjectType, MultiInstanceNNet >
PLearn::DiffTemplate< ObjectType, MultiInstanceVMatrix >
PLearn::DiffTemplate< ObjectType, MultiMaxVariable >
PLearn::DiffTemplate< ObjectType, MultiSampleVariable >
PLearn::DiffTemplate< ObjectType, MultiTargetOneHotVMatrix >
PLearn::DiffTemplate< ObjectType, MultiTaskSeparationSplitter >
PLearn::DiffTemplate< ObjectType, MultiToUniInstanceSelectRandomVMatrix >
PLearn::DiffTemplate< ObjectType, NatGradEstimator >
PLearn::DiffTemplate< ObjectType, NatGradNNet >
PLearn::DiffTemplate< ObjectType, NatGradSMPNNet >
PLearn::DiffTemplate< ObjectType, NearestNeighborPredictionCost >
PLearn::DiffTemplate< ObjectType, NegateElementsVariable >
PLearn::DiffTemplate< ObjectType, NegCrossEntropySigmoidVariable >
PLearn::DiffTemplate< ObjectType, NegKernel >
PLearn::DiffTemplate< ObjectType, NegLogPoissonVariable >
PLearn::DiffTemplate< ObjectType, NegLogProbCostFunction >
PLearn::DiffTemplate< ObjectType, NegOutputCostFunction >
PLearn::DiffTemplate< ObjectType, NeighborhoodBoxVolumeDensityEstimator >
PLearn::DiffTemplate< ObjectType, NeighborhoodConditionalMean >
PLearn::DiffTemplate< ObjectType, NeighborhoodImputationVMatrix >
PLearn::DiffTemplate< ObjectType, NeighborhoodSmoothnessNNet >
PLearn::DiffTemplate< ObjectType, NetflixVMatrix >
PLearn::DiffTemplate< ObjectType, NetworkConnection >
PLearn::DiffTemplate< ObjectType, NetworkModule >
PLearn::DiffTemplate< ObjectType, NeuralNet >
PLearn::DiffTemplate< ObjectType, NeuralNetworkARDKernel >
PLearn::DiffTemplate< ObjectType, NeuralProbabilisticLanguageModel >
PLearn::DiffTemplate< ObjectType, NGramTree >
PLearn::DiffTemplate< ObjectType, NLLCostModule >
PLearn::DiffTemplate< ObjectType, NLLErrModule >
PLearn::DiffTemplate< ObjectType, NllGeneralGaussianVariable >
PLearn::DiffTemplate< ObjectType, NLLNeighborhoodWeightsVariable >
PLearn::DiffTemplate< ObjectType, NllSemisphericalGaussianVariable >
PLearn::DiffTemplate< ObjectType, NNet >
PLearn::DiffTemplate< ObjectType, NnlmOnlineLearner >
PLearn::DiffTemplate< ObjectType, NnlmOutputLayer >
PLearn::DiffTemplate< ObjectType, NnlmWordRepresentationLayer >
PLearn::DiffTemplate< ObjectType, NoBpropVariable >
PLearn::DiffTemplate< ObjectType, NonDiagVariable >
PLearn::DiffTemplate< ObjectType, NonLocalManifoldParzen >
PLearn::DiffTemplate< ObjectType, NonLocalManifoldParzenKernel >
PLearn::DiffTemplate< ObjectType, NormalizationLearner >
PLearn::DiffTemplate< ObjectType, NormalizedDotProductKernel >
PLearn::DiffTemplate< ObjectType, NoSplitSplitter >
PLearn::DiffTemplate< ObjectType, NullModule >
PLearn::DiffTemplate< ObjectType, NxProfileLearner >
PLearn::DiffTemplate< ObjectType, ObjectGenerator >
PLearn::DiffTemplate< ObjectType, ObjectOptionVariable >
PLearn::DiffTemplate< ObjectType, ObservationWindow >
PLearn::DiffTemplate< ObjectType, OnBagsModule >
PLearn::DiffTemplate< ObjectType, OneHotSquaredLoss >
PLearn::DiffTemplate< ObjectType, OneHotVariable >
PLearn::DiffTemplate< ObjectType, OneHotVMatrix >
PLearn::DiffTemplate< ObjectType, OneVsAllVMatrix >
PLearn::DiffTemplate< ObjectType, OnlineGramNaturalGradientOptimizer >
PLearn::DiffTemplate< ObjectType, OnlineLearningModule >
PLearn::DiffTemplate< ObjectType, OptimizeOptionOracle >
PLearn::DiffTemplate< ObjectType, Optimizer >
PLearn::DiffTemplate< ObjectType, OptionsOracle >
PLearn::DiffTemplate< ObjectType, OracleObjectGenerator >
PLearn::DiffTemplate< ObjectType, OutputVariable >
PLearn::DiffTemplate< ObjectType, PairsVMatrix >
PLearn::DiffTemplate< ObjectType, ParentableObject >
PLearn::DiffTemplate< ObjectType, PartsDistanceKernel >
PLearn::DiffTemplate< ObjectType, PartSupervisedDBN >
PLearn::DiffTemplate< ObjectType, ParzenWindow >
PLearn::DiffTemplate< ObjectType, PCA >
PLearn::DiffTemplate< ObjectType, PDistributionVariable >
PLearn::DiffTemplate< ObjectType, PerformanceEvaluator >
PLearn::DiffTemplate< ObjectType, PLearnDiff >
PLearn::DiffTemplate< ObjectType, PLearner >
PLearn::DiffTemplate< ObjectType, PLearnerDiagonalKernel >
PLearn::DiffTemplate< ObjectType, PLearnerOutputVMatrix >
PLearn::DiffTemplate< ObjectType, PLogPVariable >
PLearn::DiffTemplate< ObjectType, PLS >
PLearn::DiffTemplate< ObjectType, PlusColumnVariable >
PLearn::DiffTemplate< ObjectType, PlusConstantVariable >
PLearn::DiffTemplate< ObjectType, PlusManyVariable >
PLearn::DiffTemplate< ObjectType, PlusRowVariable >
PLearn::DiffTemplate< ObjectType, PlusScalarVariable >
PLearn::DiffTemplate< ObjectType, PlusVariable >
PLearn::DiffTemplate< ObjectType, PolynomialKernel >
PLearn::DiffTemplate< ObjectType, PotentialsVariable >
PLearn::DiffTemplate< ObjectType, PowDistanceKernel >
PLearn::DiffTemplate< ObjectType, PowVariable >
PLearn::DiffTemplate< ObjectType, PowVariableVariable >
PLearn::DiffTemplate< ObjectType, PRandom >
PLearn::DiffTemplate< ObjectType, PrecomputedKernel >
PLearn::DiffTemplate< ObjectType, PrecomputedProcessedLearner >
PLearn::DiffTemplate< ObjectType, PrecomputedVMatrix >
PLearn::DiffTemplate< ObjectType, Preprocessing >
PLearn::DiffTemplate< ObjectType, PreprocessingVMatrix >
PLearn::DiffTemplate< ObjectType, PricingTransactionPairProfitFunction >
PLearn::DiffTemplate< ObjectType, ProbabilityPairsInverseVariable >
PLearn::DiffTemplate< ObjectType, ProbabilityPairsVariable >
PLearn::DiffTemplate< ObjectType, ProcessDatasetVMatrix >
PLearn::DiffTemplate< ObjectType, ProcessingVMatrix >
PLearn::DiffTemplate< ObjectType, ProcessInputCostModule >
PLearn::DiffTemplate< ObjectType, ProcessSymbolicSequenceVMatrix >
PLearn::DiffTemplate< ObjectType, ProductTransposeVariable >
PLearn::DiffTemplate< ObjectType, ProductVariable >
PLearn::DiffTemplate< ObjectType, ProjectionErrorVariable >
PLearn::DiffTemplate< ObjectType, PruningLinearRegressor >
PLearn::DiffTemplate< ObjectType, PseudolikelihoodRBM >
PLearn::DiffTemplate< ObjectType, PTest >
PLearn::DiffTemplate< ObjectType, PTester >
PLearn::DiffTemplate< ObjectType, PTimer >
PLearn::DiffTemplate< ObjectType, PutSubVMatrix >
PLearn::DiffTemplate< ObjectType, PvGradNNet >
PLearn::DiffTemplate< ObjectType, PyPLearnScript >
PLearn::DiffTemplate< ObjectType, PythonCodeSnippet >
PLearn::DiffTemplate< ObjectType, PythonFeatureSet >
PLearn::DiffTemplate< ObjectType, PythonProcessedLearner >
PLearn::DiffTemplate< ObjectType, PythonProcessedVMatrix >
PLearn::DiffTemplate< ObjectType, PythonTableVMatrix >
PLearn::DiffTemplate< ObjectType, QuadraticUtilityCostFunction >
PLearn::DiffTemplate< ObjectType, QuantilesStatsIterator >
PLearn::DiffTemplate< ObjectType, RandomForcedValuesVariable >
PLearn::DiffTemplate< ObjectType, RandomGaussMix >
PLearn::DiffTemplate< ObjectType, RandomNeighborsDifferencesVMatrix >
PLearn::DiffTemplate< ObjectType, RandomSamplesFromVMatrix >
PLearn::DiffTemplate< ObjectType, RandomSamplesVMatrix >
PLearn::DiffTemplate< ObjectType, RangeVMatrix >
PLearn::DiffTemplate< ObjectType, RankedVMatrix >
PLearn::DiffTemplate< ObjectType, RankingFromKernel >
PLearn::DiffTemplate< ObjectType, RankLearner >
PLearn::DiffTemplate< ObjectType, RationalQuadraticARDKernel >
PLearn::DiffTemplate< ObjectType, RBMClassificationModule >
PLearn::DiffTemplate< ObjectType, RBMConnection >
PLearn::DiffTemplate< ObjectType, RBMConv2DConnection >
PLearn::DiffTemplate< ObjectType, RBMConv2DLLParameters >
PLearn::DiffTemplate< ObjectType, RBMDiagonalMatrixConnection >
PLearn::DiffTemplate< ObjectType, RBMGenericParameters >
PLearn::DiffTemplate< ObjectType, RBMJointGenericParameters >
PLearn::DiffTemplate< ObjectType, RBMJointLLParameters >
PLearn::DiffTemplate< ObjectType, RBMLayer >
PLearn::DiffTemplate< ObjectType, RBMLLParameters >
PLearn::DiffTemplate< ObjectType, RBMLQParameters >
PLearn::DiffTemplate< ObjectType, RBMMatrixConnection >
PLearn::DiffTemplate< ObjectType, RBMMatrixConnectionNatGrad >
PLearn::DiffTemplate< ObjectType, RBMMatrixTransposeConnection >
PLearn::DiffTemplate< ObjectType, RBMMixedConnection >
PLearn::DiffTemplate< ObjectType, RBMModule >
PLearn::DiffTemplate< ObjectType, RBMMultitaskClassificationModule >
PLearn::DiffTemplate< ObjectType, RBMParameters >
PLearn::DiffTemplate< ObjectType, RBMQLParameters >
PLearn::DiffTemplate< ObjectType, RBMSparse1DMatrixConnection >
PLearn::DiffTemplate< ObjectType, RBMTrainer >
PLearn::DiffTemplate< ObjectType, RealFunction >
PLearn::DiffTemplate< ObjectType, RealFunctionFromKernel >
PLearn::DiffTemplate< ObjectType, RealFunctionOfInputFeature >
PLearn::DiffTemplate< ObjectType, RealFunctionProduct >
PLearn::DiffTemplate< ObjectType, RealFunctionsProcessedVMatrix >
PLearn::DiffTemplate< ObjectType, RealMapping >
PLearn::DiffTemplate< ObjectType, RealRangeIndicatorFunction >
PLearn::DiffTemplate< ObjectType, RealValueIndicatorFunction >
PLearn::DiffTemplate< ObjectType, ReconstructionWeightsKernel >
PLearn::DiffTemplate< ObjectType, Redirect >
PLearn::DiffTemplate< ObjectType, RegressionTree >
PLearn::DiffTemplate< ObjectType, RegressionTreeLeave >
PLearn::DiffTemplate< ObjectType, RegressionTreeMulticlassLeave >
PLearn::DiffTemplate< ObjectType, RegressionTreeMulticlassLeaveFast >
PLearn::DiffTemplate< ObjectType, RegressionTreeMulticlassLeaveProb >
PLearn::DiffTemplate< ObjectType, RegressionTreeNode >
PLearn::DiffTemplate< ObjectType, RegressionTreeQueue >
PLearn::DiffTemplate< ObjectType, RegressionTreeRegisters >
PLearn::DiffTemplate< ObjectType, RegressorFromDistribution >
PLearn::DiffTemplate< ObjectType, RegularGridVMatrix >
PLearn::DiffTemplate< ObjectType, ReIndexedTargetVariable >
PLearn::DiffTemplate< ObjectType, ReIndexedTargetVMatrix >
PLearn::DiffTemplate< ObjectType, RemapLastColumnVMatrix >
PLearn::DiffTemplate< ObjectType, RemoveDuplicateVMatrix >
PLearn::DiffTemplate< ObjectType, RemoveObservationTest >
PLearn::DiffTemplate< ObjectType, RemoveRowsVMatrix >
PLearn::DiffTemplate< ObjectType, ReorderByMissingVMatrix >
PLearn::DiffTemplate< ObjectType, RepeatSplitter >
PLearn::DiffTemplate< ObjectType, RepeatVMatrix >
PLearn::DiffTemplate< ObjectType, ReplicateSamplesVMatrix >
PLearn::DiffTemplate< ObjectType, ReshapeVariable >
PLearn::DiffTemplate< ObjectType, RightPseudoInverseVariable >
PLearn::DiffTemplate< ObjectType, RowAtPositionVariable >
PLearn::DiffTemplate< ObjectType, RowBufferedVMatrix >
PLearn::DiffTemplate< ObjectType, RowBufferedVMatrixTest >
PLearn::DiffTemplate< ObjectType, RowOfVariable >
PLearn::DiffTemplate< ObjectType, RowsSubVMatrix >
PLearn::DiffTemplate< ObjectType, RowSumSquareVariable >
PLearn::DiffTemplate< ObjectType, RowSumVariable >
PLearn::DiffTemplate< ObjectType, RPPath >
PLearn::DiffTemplate< ObjectType, RunICPVariable >
PLearn::DiffTemplate< ObjectType, RunObject >
PLearn::DiffTemplate< ObjectType, SaltPepperNoiseVariable >
PLearn::DiffTemplate< ObjectType, ScaledConditionalCDFSmoother >
PLearn::DiffTemplate< ObjectType, ScaledGaussianKernel >
PLearn::DiffTemplate< ObjectType, ScaledGeneralizedDistanceRBFKernel >
PLearn::DiffTemplate< ObjectType, ScaledLaplacianKernel >
PLearn::DiffTemplate< ObjectType, ScaleGradientModule >
PLearn::DiffTemplate< ObjectType, ScoreLayerVariable >
PLearn::DiffTemplate< ObjectType, SecondIterationTester >
PLearn::DiffTemplate< ObjectType, SelectColumnsVMatrix >
PLearn::DiffTemplate< ObjectType, SelectedOutputCostFunction >
PLearn::DiffTemplate< ObjectType, SelectInputSubsetLearner >
PLearn::DiffTemplate< ObjectType, SelectRowsFileIndexVMatrix >
PLearn::DiffTemplate< ObjectType, SelectRowsMultiInstanceVMatrix >
PLearn::DiffTemplate< ObjectType, SelectRowsVMatrix >
PLearn::DiffTemplate< ObjectType, SelectSetsSplitter >
PLearn::DiffTemplate< ObjectType, SemiSupervisedDBN >
PLearn::DiffTemplate< ObjectType, SemiSupervisedProbClassCostVariable >
PLearn::DiffTemplate< ObjectType, SeparateInputVMatrix >
PLearn::DiffTemplate< ObjectType, SequentialLearner >
PLearn::DiffTemplate< ObjectType, SequentialModelSelector >
PLearn::DiffTemplate< ObjectType, SequentialSplitter >
PLearn::DiffTemplate< ObjectType, SequentialValidation >
PLearn::DiffTemplate< ObjectType, SetOption >
PLearn::DiffTemplate< ObjectType, SharpeRatioStatsIterator >
PLearn::DiffTemplate< ObjectType, ShellScript >
PLearn::DiffTemplate< ObjectType, ShiftAndRescaleFeatureRealFunction >
PLearn::DiffTemplate< ObjectType, ShiftAndRescaleVMatrix >
PLearn::DiffTemplate< ObjectType, ShuffleColumnsVMatrix >
PLearn::DiffTemplate< ObjectType, ShuntingNNetLayerModule >
PLearn::DiffTemplate< ObjectType, SigmoidalKernel >
PLearn::DiffTemplate< ObjectType, SigmoidPrimitiveKernel >
PLearn::DiffTemplate< ObjectType, SigmoidVariable >
PLearn::DiffTemplate< ObjectType, SignVariable >
PLearn::DiffTemplate< ObjectType, Smoother >
PLearn::DiffTemplate< ObjectType, SoftHistogramBinner >
PLearn::DiffTemplate< ObjectType, SoftmaxLossVariable >
PLearn::DiffTemplate< ObjectType, SoftmaxModule >
PLearn::DiffTemplate< ObjectType, SoftmaxNLLCostModule >
PLearn::DiffTemplate< ObjectType, SoftmaxVariable >
PLearn::DiffTemplate< ObjectType, SoftplusVariable >
PLearn::DiffTemplate< ObjectType, SoftSlopeIntegralVariable >
PLearn::DiffTemplate< ObjectType, SoftSlopeVariable >
PLearn::DiffTemplate< ObjectType, SoftSoftMaxVariable >
PLearn::DiffTemplate< ObjectType, SortRowsVMatrix >
PLearn::DiffTemplate< ObjectType, SourceKernel >
PLearn::DiffTemplate< ObjectType, SourceVariable >
PLearn::DiffTemplate< ObjectType, SourceVMatrix >
PLearn::DiffTemplate< ObjectType, SourceVMatrixSplitter >
PLearn::DiffTemplate< ObjectType, SparseIncrementalAffineTransformVariable >
PLearn::DiffTemplate< ObjectType, SparseVMatrix >
PLearn::DiffTemplate< ObjectType, SpectralClustering >
PLearn::DiffTemplate< ObjectType, SplitModule >
PLearn::DiffTemplate< ObjectType, Splitter >
PLearn::DiffTemplate< ObjectType, SplitWiseValidationVMatrix >
PLearn::DiffTemplate< ObjectType, SquaredErrModule >
PLearn::DiffTemplate< ObjectType, SquaredErrorCostFunction >
PLearn::DiffTemplate< ObjectType, SquaredErrorCostModule >
PLearn::DiffTemplate< ObjectType, SquaredExponentialARDKernel >
PLearn::DiffTemplate< ObjectType, SquareRootVariable >
PLearn::DiffTemplate< ObjectType, SquareVariable >
PLearn::DiffTemplate< ObjectType, StackedAutoassociatorsNet >
PLearn::DiffTemplate< ObjectType, StackedFocusedAutoassociatorsNet >
PLearn::DiffTemplate< ObjectType, StackedLearner >
PLearn::DiffTemplate< ObjectType, StackedModulesLearner >
PLearn::DiffTemplate< ObjectType, StackedModulesModule >
PLearn::DiffTemplate< ObjectType, StackedSplitter >
PLearn::DiffTemplate< ObjectType, StackedSVDNet >
PLearn::DiffTemplate< ObjectType, StatefulLearner >
PLearn::DiffTemplate< ObjectType, StatsCollector >
PLearn::DiffTemplate< ObjectType, StatsIterator >
PLearn::DiffTemplate< ObjectType, StddevStatsIterator >
PLearn::DiffTemplate< ObjectType, StderrStatsIterator >
PLearn::DiffTemplate< ObjectType, StepwiseSelectionOracle >
PLearn::DiffTemplate< ObjectType, StochasticBinarizeVMatrix >
PLearn::DiffTemplate< ObjectType, StrTableVMatrix >
PLearn::DiffTemplate< ObjectType, StructuralLearner >
PLearn::DiffTemplate< ObjectType, SubInputVMatrix >
PLearn::DiffTemplate< ObjectType, SubMatTransposeVariable >
PLearn::DiffTemplate< ObjectType, SubMatVariable >
PLearn::DiffTemplate< ObjectType, SubsampleVariable >
PLearn::DiffTemplate< ObjectType, Subsampling2DModule >
PLearn::DiffTemplate< ObjectType, SubsamplingDBN >
PLearn::DiffTemplate< ObjectType, SubVMatrix >
PLearn::DiffTemplate< ObjectType, SumAbsVariable >
PLearn::DiffTemplate< ObjectType, SumEntropyOfBernoullis >
PLearn::DiffTemplate< ObjectType, SumEntropyOfCategoricals >
PLearn::DiffTemplate< ObjectType, SummationKernel >
PLearn::DiffTemplate< ObjectType, SumOfVariable >
PLearn::DiffTemplate< ObjectType, SumOverBagsVariable >
PLearn::DiffTemplate< ObjectType, SumSquareVariable >
PLearn::DiffTemplate< ObjectType, SumVariable >
PLearn::DiffTemplate< ObjectType, SumVarianceOfLinearTransformedBernoullis >
PLearn::DiffTemplate< ObjectType, SumVarianceOfLinearTransformedCategoricals >
PLearn::DiffTemplate< ObjectType, Supersampling2DModule >
PLearn::DiffTemplate< ObjectType, SupervisedDBN >
PLearn::DiffTemplate< ObjectType, SurfaceMesh >
PLearn::DiffTemplate< ObjectType, SurfaceTemplateLearner >
PLearn::DiffTemplate< ObjectType, SVDVariable >
PLearn::DiffTemplate< ObjectType, SVMClassificationTorch >
PLearn::DiffTemplate< ObjectType, SymbolNode >
PLearn::DiffTemplate< ObjectType, TangentLearner >
PLearn::DiffTemplate< ObjectType, TanhModule >
PLearn::DiffTemplate< ObjectType, TanhVariable >
PLearn::DiffTemplate< ObjectType, TargetEncodingLearner >
PLearn::DiffTemplate< ObjectType, TemporalHorizonVMatrix >
PLearn::DiffTemplate< ObjectType, TemporaryDiskVMatrix >
PLearn::DiffTemplate< ObjectType, TemporaryFileVMatrix >
PLearn::DiffTemplate< ObjectType, TestImputations >
PLearn::DiffTemplate< ObjectType, TestingLearner >
PLearn::DiffTemplate< ObjectType, TestInTrainSplitter >
PLearn::DiffTemplate< ObjectType, TestLearner >
PLearn::DiffTemplate< ObjectType, TestMethod >
PLearn::DiffTemplate< ObjectType, TextStreamVMatrix >
PLearn::DiffTemplate< ObjectType, ThresholdBpropVariable >
PLearn::DiffTemplate< ObjectType, ThresholdedKernel >
PLearn::DiffTemplate< ObjectType, TimesColumnVariable >
PLearn::DiffTemplate< ObjectType, TimesConstantScalarVariable2 >
PLearn::DiffTemplate< ObjectType, TimesConstantVariable >
PLearn::DiffTemplate< ObjectType, TimesRowVariable >
PLearn::DiffTemplate< ObjectType, TimesScalarVariable >
PLearn::DiffTemplate< ObjectType, TimesVariable >
PLearn::DiffTemplate< ObjectType, ToBagSplitter >
PLearn::DiffTemplate< ObjectType, TopDownAsymetricDeepNetwork >
PLearn::DiffTemplate< ObjectType, TorchLearner >
PLearn::DiffTemplate< ObjectType, TraceVariable >
PLearn::DiffTemplate< ObjectType, Train >
PLearn::DiffTemplate< ObjectType, TrainTestSplitter >
PLearn::DiffTemplate< ObjectType, TrainValidTestSplitter >
PLearn::DiffTemplate< ObjectType, TransformationLearner >
PLearn::DiffTemplate< ObjectType, TransformOutputLearner >
PLearn::DiffTemplate< ObjectType, TransparentParentable >
PLearn::DiffTemplate< ObjectType, TransposedDoubleProductVariable >
PLearn::DiffTemplate< ObjectType, TransposeProductVariable >
PLearn::DiffTemplate< ObjectType, TransposeVariable >
PLearn::DiffTemplate< ObjectType, TransposeVMatrix >
PLearn::DiffTemplate< ObjectType, TreeDBNModule >
PLearn::DiffTemplate< ObjectType, TruncatedRealFunction >
PLearn::DiffTemplate< ObjectType, UCIDataVMatrix >
PLearn::DiffTemplate< ObjectType, UCISpecification >
PLearn::DiffTemplate< ObjectType, UnaryHardSlopeVariable >
PLearn::DiffTemplate< ObjectType, UnaryVariable >
PLearn::DiffTemplate< ObjectType, UndirectedSoftmaxModule >
PLearn::DiffTemplate< ObjectType, UnequalConstantVariable >
PLearn::DiffTemplate< ObjectType, UnfoldedFuncVariable >
PLearn::DiffTemplate< ObjectType, UnfoldedSumOfVariable >
PLearn::DiffTemplate< ObjectType, UnfrozenDeepBeliefNet >
PLearn::DiffTemplate< ObjectType, UniformizeLearner >
PLearn::DiffTemplate< ObjectType, UniformizeVMatrix >
PLearn::DiffTemplate< ObjectType, UniformVMatrix >
PLearn::DiffTemplate< ObjectType, UpsideDownVMatrix >
PLearn::DiffTemplate< ObjectType, ValueSelectRowsVMatrix >
PLearn::DiffTemplate< ObjectType, VarArrayElementVariable >
PLearn::DiffTemplate< ObjectType, VarColumnsVariable >
PLearn::DiffTemplate< ObjectType, VarElementVariable >
PLearn::DiffTemplate< ObjectType, Variable >
PLearn::DiffTemplate< ObjectType, VariableDeletionVMatrix >
PLearn::DiffTemplate< ObjectType, VariableSelectionWithDirectedGradientDescent >
PLearn::DiffTemplate< ObjectType, VariablesTest >
PLearn::DiffTemplate< ObjectType, VarRowsVariable >
PLearn::DiffTemplate< ObjectType, VarRowVariable >
PLearn::DiffTemplate< ObjectType, VarUtilsTest >
PLearn::DiffTemplate< ObjectType, VBoundDBN2 >
PLearn::DiffTemplate< ObjectType, VecDictionary >
PLearn::DiffTemplate< ObjectType, VecElementVariable >
PLearn::DiffTemplate< ObjectType, VecExtendedVMatrix >
PLearn::DiffTemplate< ObjectType, VecStatsCollector >
PLearn::DiffTemplate< ObjectType, ViewSplitterVMatrix >
PLearn::DiffTemplate< ObjectType, VMatKernel >
PLearn::DiffTemplate< ObjectType, VMatLanguage >
PLearn::DiffTemplate< ObjectType, VMatrix >
PLearn::DiffTemplate< ObjectType, VMatrixFromDistribution >
PLearn::DiffTemplate< ObjectType, VPLCombinedLearner >
PLearn::DiffTemplate< ObjectType, VPLPreprocessedLearner >
PLearn::DiffTemplate< ObjectType, VPLPreprocessedLearner2 >
PLearn::DiffTemplate< ObjectType, VPLProcessor >
PLearn::DiffTemplate< ObjectType, VVMatrix >
PLearn::DiffTemplate< ObjectType, WeightedCostFunction >
PLearn::DiffTemplate< ObjectType, WeightedDistance >
PLearn::DiffTemplate< ObjectType, WeightedLogGaussian >
PLearn::DiffTemplate< ObjectType, WeightedQuadraticPolynomialKernel >
PLearn::DiffTemplate< ObjectType, WeightedSumSquareVariable >
PLearn::DiffTemplate< ObjectType, WordNetFeatureSet >
PLearn::DiffTemplate< ObjectType, WordNetSenseDictionary >
PLearn::DiffTemplate< ObjectType, WPLS >
PLearn::DiffTemplate< ObjectType, X >
PLearn::DiffTemplate< ObjectType, Y >
PLearn::DiffTemplate< ObjectType, YMDDatedVMatrix >
PLearn::DiffTemplate< ObjectType, Z >
PLearn::DilogarithmVariableThis is the primitive of a sigmoid: log(1+exp(x))
PLearn::DirectNegativeCostFunction
PLearn::DiscriminativeDeepBeliefNetDeep Belief Net where the stacked RBMs also use a discriminative criteria
PLearn::DiscriminativeRBMDiscriminative Restricted Boltzmann Machine classifier
PLearn::DiskVMatrixA VMatrix whose (compressed) data resides in a directory and can span several files
PLearn::DisregardRowsVMatrix
PLearn::DistanceKernelThis class implements an Ln distance (defaults to L2 i.e. euclidean distance)
PLearn::DistRepNNet
PLearn::Distribution
PLearn::DiverseComponentAnalysisThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::DivisiveNormalizationKernel
PLearn::DivVariable
PLearn::DotProductKernelReturns <x1,x2>
PLearn::DotProductVariableDot product between 2 vectors (or possibly 2 matrices, which are then simply seen as vectors)
PLearn::DoubleAccessSparseMatrix< T >
doublecomplex
PLearn::DoubleProductVariableThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::DoublyLinkedList< T >Class description:
PLearn::DoublyLinkedListElement< T >Class description:
PLearn::DTWKernelKernel for Dynamic Time Warping see sect.4.7 of Rabiner, L
PLearn::DuplicateColumnVariable
PLearn::DuplicateRowVariable
PLearn::DuplicateScalarVariable
PLearn::DynamicallyLinkedRBMsModelModel made of RBMs linked through time
PLearn::EarlyStoppingOracle
PLearn::ElementAtPositionVariable
PLearn::ElementWiseDivisionRandomVariable
PLearn::EmbeddedLearner
PLearn::EmbeddedSequentialLearner
PLearn::EmpiricalDistribution
PLearn::EncodedVMatrix
PLearn::EntropyContrast
PLearn::EntropyContrastLearner
PLearn::EpanechnikovKernel
PLearn::EqualConstantVariableA scalar var; equal 1 if input1==input2, 0 otherwise
PLearn::EqualScalarVariableA scalar var; equal 1 if input1==input2, 0 otherwise
PLearn::EqualVariableA scalar var; equal 1 if input1==input2, 0 otherwise
PLearn::ErfVariable
PLearn::ExhaustiveNearestNeighborsThis class provides the basic implementation of the classical O(N^2) nearest-neighbors algorithm
PLearn::Experiment
PLearn::ExperimentationGenerate samples from a mixture of two gaussians
PLearn::ExplicitListOracle
PLearn::ExplicitSplitter
PLearn::ExpMeanStatsIterator
PLearn::ExpRandomVariable
PLearn::ExpVariable
PLearn::ExtendedRandomVariable
PLearn::ExtendedVariable
PLearn::ExtendedVMatrix
PLearn::ExtractNNetParamsVMatrix
PLearn::ExtractOptionCommandThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ExtractVariable
PLearn::FdPStreamBuf
PLearn::FeatureSetBase class for sets of sparse features
PLearn::FeatureSetNaiveBayesClassifierNaive Bayes classifier on a feature set space
PLearn::FeatureSetNNetFeedforward Neural Network for symbolic data represented using features
PLearn::FeatureSetSequentialCRFFeedforward Neural Network for symbolic data represented using features
PLearn::Field
PLearn::FieldConvertCommand
PLearn::FieldPtr
PLearn::FieldRowRef
PLearn::FieldStat
PLearn::FieldValue
PLearn::FileDictionary
PLearn::FilePStreamBuf
PLearn::FilesIntStream
PLearn::FileVMatrixA VMatrix that exists in a .pmat file (native PLearn matrix format, same as for Mat)
PLearn::FileVMatrixTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::FillFeatureSetCommandPLearn command that fills a FeatureSet with the features instantiated in a VMat
PLearn::FilteredVMatrix
PLearn::FilterSplitter
PLearn::FinancePreprocVMatrix
PLearn::FixDond2BinaryVariablesGenerate samples from a mixture of two gaussians
PLearn::FNetLayerVariableSingle layer of a neural network, with acceleration tricks
PLearn::ForwardModule
PLearn::ForwardVMatrix
PLearn::FractionSplitter
PLearn::FRemoteTrampoline_0< R >Trampolines for functions
PLearn::FRemoteTrampoline_0< void >Trampoline for a void 0-argument function
PLearn::FRemoteTrampoline_1< R, A1 >Trampoline for a non-void 1-argument function
PLearn::FRemoteTrampoline_1< void, A1 >Trampoline for a void 1-argument function
PLearn::FRemoteTrampoline_2< R, A1, A2 >Trampoline for a non-void 2-argument function
PLearn::FRemoteTrampoline_2< void, A1, A2 >Trampoline for a void 2-argument function
PLearn::FRemoteTrampoline_3< R, A1, A2, A3 >Trampoline for a non-void 3-argument function
PLearn::FRemoteTrampoline_3< void, A1, A2, A3 >Trampoline for a void 3-argument function
PLearn::FRemoteTrampoline_4< R, A1, A2, A3, A4 >Trampoline for a non-void 4-argument function
PLearn::FRemoteTrampoline_4< void, A1, A2, A3, A4 >Trampoline for a void 4-argument function
PLearn::FRemoteTrampoline_5< R, A1, A2, A3, A4, A5 >Trampoline for a non-void 5-argument function
PLearn::FRemoteTrampoline_5< void, A1, A2, A3, A4, A5 >Trampoline for a void 5-argument function
PLearn::FRemoteTrampoline_6< R, A1, A2, A3, A4, A5, A6 >Trampoline for a non-void 6-argument function
PLearn::FRemoteTrampoline_6< void, A1, A2, A3, A4, A5, A6 >Trampoline for a void 6-argument function
freqCount
PLearn::Func
PLearn::Function
PLearn::FunctionalRandomVariable
PLearn::GaussianContinuum
PLearn::GaussianContinuumDistribution
PLearn::GaussianDBNClassificationDoes the same thing as Hinton's deep belief nets
PLearn::GaussianDBNRegressionDoes the same thing as Hinton's deep belief nets
PLearn::GaussianDensityKernel
PLearn::GaussianDistribution
PLearn::GaussianizeVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::GaussianKernelReturns exp(-norm_2(x1-x2)^2/sigma^2)
PLearn::GaussianProcessNLLVariableCompute the Negative-Log-Marginal-Likelihood for Gaussian Process Regression
PLearn::GaussianProcessRegressorImplements Gaussian Process Regression (GPR) with an arbitrary kernel
PLearn::GaussMix
PLearn::GaussMixLocalProjections
PLearn::GaussPartSupervisedDBNHinton's DBN plus supervised gradient from a logistic regression layer
PLearn::GeneralizedDistanceRBFKernelReturns exp(-phi*(sum_i[abs(x1_i^a - x2_i^a)^b])^c)
PLearn::GeneralizedOneHotVMatrixThis VMat is a generalization of OneHotVMatrix where many columns (given by the Vec index) are mapped, instead of just the last one
PLearn::GenerateDecisionPlot
PLearn::GenericNearestNeighbors
PLearn::GeodesicDistanceKernel
PLearn::GetInputVMatrix
PLearn::GhostScript
PLearn::Gnuplot
PLearn::GradientAdaboostCostVariableCost for weak learner in MarginBoost version of AdaBoost Cost for a weak learner used in the functional gradient descent view of boosting on a margin-based loss function
PLearn::GradientCorrectorVirtual class used for converting a sequence of n-dimensional gradients g_t into corrected update directions v_t
PLearn::GradientOptimizer
PLearn::GradNNetLayerModuleAffine transformation module, with stochastic gradient descent updates
PLearn::GramVMatrix
graph
PLearn::Graph_
PLearn::Grapher
PLearn::GraphicalBiText
PLearn::GroupInfoEach row contains a certain amount of field groups
PLearn::HardSlopeVariable
PLearn::Hash< KeyType, DataType >
PLearn::HashKeyDataPair< KeyType, DataType >
PLearn::HashMapFeatureSetBase class for feature sets that maintains an explicit mapping between index and string form features", This class facilitates the conception of FeatureSet objects
PLearn::PL_Log::HeadingSupport stuff for heading manipulator
PLearn::HeapTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::HelpCommand
PLearn::HelpSystem
PLearn::HeterogenuousAffineTransformVariableAffine transform with continuous and discrete input
PLearn::HeterogenuousAffineTransformWeightPenaltyPenalty associated to an affine transform with continuous and discrete input
PLearn::HintonDeepBeliefNetDoes the same thing as Hinton's deep belief nets
PLearn::HistogramDistribution
PLearn::HorizonStatefulLearnerA HorizonStatefulLearner is a StatefulLearner designed for forecasting at horizon h
PLearn::HSV
PLearn::HTMLHelpCommandForward-declare
PLearn::HTMLHelpConfig
PLearn::HTMLHelpGeneratorThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::HTMLUtils
PLearn::HyperCommand
PLearn::HyperLearner
PLearn::HyperOptimizeCarry out an hyper-parameter optimization according to an Oracle
PLearn::HyperRetrain
PLearn::HyperSetOption
icilist
PLearn::ICP
PLearn::IdentityFeatureSetFeatureSet with features corresponding to the input string token
PLearn::IdentityModule
PLearn::IdentityPLearner
PLearn::IdentityVariable
PLearn::IfThenElseVariableVariable that represents the element-wise IF-THEN-ELSE:
PLearn::IIDNoiseKernelKernel representing independent and identically-distributed observation noise
PLearn::ImputationVMatrix
PLearn::IncrementalNNet
PLearn::IndexAndMissingFlagsSimple class representing one sample (given by its index) with a string of '0' and '1' where '0' represents a missing value and '1' a non-missing one
PLearn::IndexAtPositionVariable
PLearn::IndexedVMatrixVMat class that sees a matrix as a collection of triplets (row, column, value) Thus it is a N x 3 matrix, with N = the number of elements in the original matrix
PLearn::IndexedVMatrixTestTests for IndexedVMatrix, including handling of NaN and string mappings
PLearn::InferenceRBMRBM to be used when doing joint supervised learning by CD
PLearn::InfiniteMNISTVMatrixVMatrix that uses the code from "Training Invariant Support Vector Machines using Selective Sampling" by Loosli, Canu and Bottou (JMLR 2007), to generate "infinite" stream (i.e
PLearn::InjectionTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
inlist
PLearn::InMemoryIntStream
PLearn::InsertZerosVariable
PLearn::InstanceSnippetTest
PLearn::InterfunctionXchgTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::InterleaveVMatrixInterleave several VMats row-wise
PLearn::InterValuesVariableIf values = [x1,x2,...,x10], the resulting variable is [(x1+x2)/2,(x2+x3)/2, ..
PLearn::IntPairExample of class that can be used as key
PLearn::IntStream
PLearn::IntStreamVMatrix
PLearn::IntVecFile
PLearn::InvertElementsVariable
iostream
PLearn::IPopen
PLearn::IPServer
PLearn::IsAboveThresholdVariableDoes elementwise newx_i = (x_i>=threshold ?truevalue :falsevalue);
PLearn::IsLargerVariable++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
PLearn::IsMissingVariableA scalar var; equal 1 if input1!=c, 0 otherwise
PLearn::Isomap
PLearn::IsomapTangentLearner
PLearn::IsSmallerVariable
PLearn::JoinFieldStat
PLearn::JointRandomVariable
PLearn::JoinVMatrix
PLearn::JulianDateCommand
PLearn::JulianizeVMatrix
PLearn::Ker
PLearn::Kernel
PLearn::KernelDensityEstimatorThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::KernelPCA
PLearn::KernelProjection
PLearn::KernelRidgeRegressorImplements a 'kernelized' version of linear ridge regression
PLearn::KernelVMatrix
PLearn::KFoldLogisticClassifierThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::KFoldSplitter
PLearn::KLp0p1RBMModuleThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::KMeansClustering
PLearn::KNNClassifierThis class provides a simple N-class classifier based upon an enclosed K-nearest-neighbors finder (derived from GenericNearestNeighbors; specified with the 'knn' option)
PLearn::KNNImputationVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::KNNRegressorThis class provides a simple multivariate regressor based upon an enclosed K-nearest-neighbors finder (derived from GenericNearestNeighbors; specified with the 'knn' option)
PLearn::KNNVMatrix
PLearn::KolmogorovSmirnovCommand
PLearn::KPCATangentLearner
PLearn::KroneckerBaseKernelBase class for kernels that make use of Kronecker terms
PLearn::LaplacianKernelReturns exp(-phi*(sum_i[abs(x1_i - x2_i)]))
PLearn::LayerCostModuleComputes a cost function for a (hidden) representation
PLearn::Learner
PLearn::LearnerCommand
PLearn::LearnerProcessedVMatrix
PLearn::LeftPseudoInverseVariable
PLearn::LemmatizeVMatrixTakes a VMatrix with a word and a POS field and adds a field consisting of the lemma form of the word
PLearn::LIBSVMSparseVMatrixVMatrix containing data from a libsvm format file
PLearn::LiftBinaryCostFunction
PLearn::LiftOutputVariable
PLearn::LiftStatsCollector
PLearn::LiftStatsIterator
PLearn::LimitedGaussianSmoother
PLearn::LinearARDKernelLinear kernel that can be used for Automatic Relevance Determination
PLearn::LinearCombinationModuleThis module outputs a linear combination of input ports
PLearn::LinearCombinationOfScalarVariablesThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::LinearFilterModuleAffine transformation module, with stochastic gradient descent updates
PLearn::LinearInductiveTransferClassifierLinear classifier that uses class representations in order to make use of inductive transfer between classes
PLearn::LinearRegressor
PLearn::LineOutputProgressBarPluginSimilar to TextProgressBarPlugin with a different output format so that updates appear on different lines of output
PLearn::LLC
PLearn::LLE
PLearn::LLEKernel
PLearn::LocalGaussianClassifierThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::LocalizedFeaturesLayerVariableSingle layer of a neural network with local connectivity upon a set of localized features, i.e
PLearn::LocallyMagnifiedDistribution
PLearn::LocallyPrecomputedVMatrix
PLearn::LocallyWeightedDistribution
PLearn::LocalMedBoost
PLearn::LocalNeighborsDifferencesVMatrix
PLearn::LogaddOnBagsModule
PLearn::LogAddVariableOutput = log(exp(input1)+exp(input2)) but it is computed in such a way as to preserve precision
PLearn::LogInterceptorPStreamBufThis class sends stuff to a PL_LogPluginInterceptor when it's flushed
PLearn::LogOfGaussianDensityKernel
PLearn::LogRandomVariable
PLearn::LogSoftmaxVariable
PLearn::LogSoftSoftMaxVariableLog of SoftSoftMaxVariable (see SoftSoftMaxVariable for more details)
PLearn::LogSumVariable
PLearn::LogVariable
PLearn::ManifoldKNNDistributionK nearest neighbors density estimator that takes into accound the local manifold structure
PLearn::ManifoldParzenManifold Parzen Windows classifier and distribution
PLearn::ManifoldParzen2
PLearn::ManifoldParzenKernel
PLearn::ManualBinner
PLearn::MarginPerceptronCostVariable
PLearn::Matern1ARDKernelMatern kernel with nu=1/2 that can be used for Automatic Relevance Determination
PLearn::MatlabInterface
PLearn::MatrixAffineTransformFeedbackVariableAffine transformation of a MATRIX variable
PLearn::MatrixAffineTransformVariableAffine transformation of a MATRIX variable
PLearn::MatrixElementsVariable
PLearn::MatrixInverseVariable
PLearn::MatrixModuleThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MatrixOneHotSquaredLoss
PLearn::MatrixSoftmaxLossVariable
PLearn::MatrixSoftmaxVariable
PLearn::MatrixSumOfVariable
PLearn::MatRowVariableVariable that is the row of matrix mat indexed by variable input
PLearn::MatTPlusSumSquaredVec< MatT >
PLearn::Max2Variable
PLearn::MaxStatsIterator
PLearn::MaxSubsampling2DModuleReduce the size of the 2D images by taking the max value of nearby pixels
PLearn::MaxSubsamplingTestTests MaxSubsampling2DModule
PLearn::MaxVariable
PLearn::MeanImputationVMatrixMean imputation for missing variables
PLearn::MeanMedianModeImputationVMatrix
PLearn::MeanStatsIterator
PLearn::Measurer
PLearn::MemoryCachedKernelProvide some memory-management utilities for kernels
PLearn::MemoryStressTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MemoryVMatrix
PLearn::MemoryVMatrixNoSaveThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MergeDond2FilesGenerate samples from a mixture of two gaussians
PLearn::MeshEdge
PLearn::MeshFace
PLearn::MeshGraph
PLearn::MeshMatch
PLearn::MeshVertex
PLearn::Min2Variable
PLearn::MiniBatchClassificationLossVariable
PLearn::MinStatsIterator
PLearn::MinusColumnVariable
PLearn::MinusRandomVariable
PLearn::MinusRowVariable
PLearn::MinusScalarVariable
PLearn::MinusTransposedColumnVariable
PLearn::MinusVariable
PLearn::MinVariable
PLearn::MissingFlag
PLearn::MissingIndicatorVMatrix
PLearn::MissingInstructionVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MixtureDistributionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MixtureRandomVariable
PLearn::MixtureVMatrixMixes several underlying source VMat, with ponderation
PLearn::MixUnlabeledNeighbourVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::mNNetMulti-layer neural network based on matrix-matrix multiplications
PLearn::ModuleLearner
PLearn::ModulesLearnerTrains an OnlineLearningModule wrt the cost of a CostModule
PLearn::ModuleStackModuleWraps a stack of layered OnlineLearningModule into a single one
PLearn::ModuleTesterThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MoleculeA molecular surface, represented by a list of points and features on them
PLearn::MoleculeTemplateSubclass of Molecule, plus standard devs of points' positions and features
PLearn::MoleculeTemplateLearner
PLearn::MovingAverageThis SequentialLearner only takes the n previous target to predict the next one
PLearn::MovingAverageVMatrix
PLearn::MPIPStreamBufAn implementation of the PStreamBuf interface using MPI communication
PLearn::MRUFileList
PLearn::MultiClassAdaBoostThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::MulticlassErrorCostFunction
PLearn::MulticlassLossVariableCost = sum_i {cost_i}, with cost_i = 1 if (target_i == 1 && output_i < 1/2) cost_i = 1 if (target_i == 0 && output_i > 1/2) cost_i = 0 otherwise
PLearn::MultiInstanceNNet
PLearn::MultiInstanceVMatrix
PLearn::MultiMap< A, B >
PLearn::MultiMaxVariableThis variables computes a max functions (softmax, log-softmax, hardmax, etc., determined by the field computation_type) on subvectors of the input, which lenght is defined by the field groupsizes
PLearn::MultinomialRandomVariable
PLearn::MultinomialSampleVariable
PLearn::MultiSampleVariable
PLearn::MultiTargetOneHotVMatrix
PLearn::MultiTaskSeparationSplitterSplitter that removes a task for test and keeps the others for training
PLearn::MultiToUniInstanceSelectRandomVMatrixSelects randomly one row per bags from a multi instances conforming VMatrix and discard the multi instances bag information column
Multitype
MyStruct
Namelist
PLearn::NaryVariable
PLearn::NatGradEstimatorClass used for converting a sequence of n-dimensional gradients g_t into covariance-corrected update directions v_t, approximating v_t = inv(C_t) g_t, with C_t = gamma C_{t-1} + g_t g_t'
PLearn::NatGradNNetMulti-layer neural network trained with an efficient Natural Gradient optimization
PLearn::NatGradSMPNNetMulti-layer neural network trained with an efficient Natural Gradient optimization
PLearn::NearestNeighborPredictionCost
PLearn::NegateElementsVariable
PLearn::NegCrossEntropySigmoidVariable
PLearn::NegKernel
PLearn::NegLogPoissonVariable
PLearn::NegLogProbCostFunction
PLearn::NegOutputCostFunctionThis simply returns -output[0] (target should usually have a length of 0) This is used for density estimators whose use(x) method typically computes log(p(x))
PLearn::NegRandomVariable
PLearn::NeighborhoodBoxVolumeDensityEstimator
PLearn::NeighborhoodConditionalMeanGenerate samples from a mixture of two gaussians
PLearn::NeighborhoodImputationVMatrix
PLearn::NeighborhoodSmoothnessNNet
PLearn::NetflixVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::NetworkConnection
PLearn::NetworkModule
PLearn::NeuralNet
PLearn::NeuralNetworkARDKernelNeural network kernel that can be used for Automatic Relevance Determination
PLearn::NeuralProbabilisticLanguageModelFeedforward neural network for language modeling
PLearn::NGramDistributionThis class implements an ngram distribution for symbol sequence modeling
PLearn::NGramTree
PLearn::NistDB
PLearn::NLLCostModuleComputes the NLL, given a probability vector and the true class
PLearn::NLLErrModuleNLL (and derivatives thereof) between the target and input
PLearn::NllGeneralGaussianVariable
PLearn::NLLNeighborhoodWeightsVariableWeightsVariable updated online, based on negative log-likelihood of the neighbors
PLearn::NllSemisphericalGaussianVariableThis class implements the negative log-likelihood cost of a Markov chain that uses semispherical gaussian transition probabilities
PLearn::NNet
PLearn::NnlmOnlineLearnerTrains a Neural Network Language Model (NNLM)
PLearn::NnlmOutputLayerImplements a gaussian-based output layer for the Neural Network Language Model
PLearn::NnlmWordRepresentationLayerImplements the word representation layer for the online NNLM
PLearn::NoBpropVariable
PLearn::Node
PLearn::NonDiagVariable
PLearn::NonLocalManifoldParzen
PLearn::NonLocalManifoldParzenKernel
PLearn::NonRandomVariable
PLearn::NoProperty
PLearn::NormalizationLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::NormalizedDotProductKernel
PLearn::NoSplitSplitter
PLearn::NullModuleThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::NullProgressBarPluginSimpler plugin that doesn't display a progress bar at all
PLearn::NullPStreamBuf
PLearn::NumToStringMapping
PLearn::NxProfileLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ObjectObject is the base class of all high level PLearn objects
PLearn::ObjectGenerator
PLearn::ObjectGraphIteratorAn ObjectGraphIterator iterates through all objects through options
PLearn::ObjectGraphIteratorTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ObjectOptionsIteratorAn ObjectOptionsIterator iterates across all accessible sub-objects of a given PLearn::Object
PLearn::ObjectOptionVariableVariable which wraps an option of an object
PLearn::ObservationWindowUsed by StatsCollector to keep a finite-size window of observations
olist
PLearn::OnBagsModule
PLearn::OneHotSquaredLossComputes sum(square_i(netout[i]-(i==classnum ?hotval :coldval)) This is used typically in a classification setting where netout is a Var of network outputs, and classnum is the target class number
PLearn::OneHotVariableRepresents a vector of a given lenth, that has value 1 at the index given by another variable and 0 everywhere else
PLearn::OneHotVMatrix
PLearn::OneVsAllVMatrix
PLearn::OnlineGramNaturalGradientOptimizerImplements an online natural gradient, based on keeping an estimate of the gradients' covariance C through its main eigen vectors and values which are updated through those of the gram matrix
PLearn::OnlineLearningModuleLearn to map inputs to outputs, online, using caller-provided gradients
PLearn::OptimizeOptionOracle
PLearn::Optimizer
PLearn::Option< T, Enclosing >Template class for option definitions
PLearn::OptionBaseBase class for option definitions
PLearn::OptionsOracle
PLearn::OracleObjectGenerator
PLearn::Other
PLearn::OutputFeaturesCommandPLearn command that fills a FeatureSet with the features instantiated in a VMat
PLearn::OutputVariable
PLearn::PairsVMatrix
PLearn::PairwiseDiffsCommandThis command computes a set of statistics (user-specified) on the pairwise differences between a given column of a list of matrices
PLearn::Parent
PLearn::ParentableObjectObject which maintains a "parent" pointer as part of an object graph
PLearn::PartsDistanceKernelThis class implements an Ln distance (defaults to L2 i.e. euclidean distance)
PLearn::PartSupervisedDBNHinton's DBN plus supervised gradient from a logistic regression layer
PLearn::ParzenWindow
PLearn::PCA
PLearn::PConditionalDistribution
PLearn::PDate
PLearn::PDateTime
PLearn::PDistributionBase class for PLearn probability distributions
PLearn::PDistributionVariable
PLearn::PentaTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PerformanceEvaluatorEvaluates the performance of a learner given a testset VMat and the learner's corresponding output VMat
PLearn::PIFStream
PLearn::PIStringStream
PLearn::pl_fdstream
PLearn::pl_fdstreambufPl_fdstreambuf: stream buffer that acts on a POSIX file descriptor
PLearn::PL_Log
PLearn::PL_LogPluginProvides several back-ends for displaying the log messages
PLearn::PL_LogPluginInterceptorForward declare
PLearn::PL_LogPluginPStreamDefault implementation of PL_LogPlugin :: outputs to specified PStream (perr by default)
PLearn::PL_LogPluginServerServer implementation of PL_LogPlugin :: outputs to client through opened socket
PLearn::pl_nullstreambuf
PLearn::pl_stream_clear_flags
PLearn::pl_stream_initiate
PLearn::pl_stream_raw
PLearn::pl_streambuf
PLearn::pl_streammarker
PLearn::PLCheckTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PLearnCommandThis is the base class for all PLearn commands (those that can be issued in the plearn program)
PLearn::PLearnCommandRegistry
PLearn::PLearnDiff
PLearn::PLearnerThe base class for learning algorithms, which should be the main "products" of PLearn
PLearn::PLearnerDiagonalKernelDiagonal kernel from the output of a PLearner
PLearn::PLearnerOutputVMatrix
PLearn::PLearnError
PLearn::PLearnInit
PLearn::PLearnServer
PLearn::PLearnService
PLearn::PLGaussQuantileInitializer
PLearn::PlideCommand to start the PLearn Integrated Development Environment (PLIDE)
PLearn::PlideLogPluginThis plugin connects the logging mechanism to PlideLogPStreamBuf
PLearn::PlideLogPStreamBufThis class sends stuff to the PlideLog when it's flushed
PLearn::PlideProgressPlugin
PLearn::PLLogTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PLMathInitializer
PLearn::PLMathTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PLMPI** PLMPI is just a "namespace holder" (because we're not actually using namespaces) for a few MPI related variables. All members are static **
PLearn::PLogPVariableReturns the elementwise x*log(x) in a (hopefully!) numerically stable way This can be used to compute the Entropy for instance
PLearn::PLPyClass
PLearn::PLS
PLearn::PLStringutilsTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PlusColumnVariableAdds a single-column var to each column of a matrix var
PLearn::PlusConstantVariableAdds a scalar constant to a matrix var
PLearn::PlusManyVariable
PLearn::PlusRandomVariable
PLearn::PlusRowVariableAdds a single-row var to each row of a matrix var
PLearn::PlusScalarVariableAdds a scalar var to a matrix var
PLearn::PlusVariableAdds 2 matrix vars of same size
PLearn::PMemArenaA PMemArena is a fixed-size contiguous block of memory for allocating objects of the SAME SIZE
PLearn::PMemPoolA PMemPool is a collection of arenas for allocating an arbitrary number of objects of a fixed size
PLearn::PObjectPool< T >A PObjectPool is a thin wrapper around PMemPool that provides typed pointers on the allocated memory
PLearn::POFStream
PLearn::PollA class for polled IO with PStreams
PLearn::PolynomialKernel
PLearn::Popen
PLearn::PotentialsVariable
PLearn::PowDistanceKernel
PLearn::PowVariableElementwise pow (returns 0 wherever input is negative)
PLearn::PowVariableVariable
PLearn::PP< T >
PLearn::PPath
PLearn::PPathTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PPointable
PLearn::PPointableSet
PLearn::PPTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PRandomImportant note: the pointers used for some Boost distribution objects are meant to save memory
PLearn::PRange< T >
PLearn::PrecomputedKernelA kernel that precomputes the kernel matrix as soon as setDataForKernelMatrix is called
PLearn::PrecomputedProcessedLearnerIdentity Learner with a cached 'processDataSet' method
PLearn::PrecomputedVMatrix
PLearn::PreprocessingGenerate samples from a mixture of two gaussians
PLearn::PreprocessingVMatrix
PLearn::PricingTransactionPairProfitFunction
PLearn::ProbabilityPairsInverseVariable[x1,x2,x3,...,xn] -> [f(x1), f(x3), ..., f(xn)] with f(x) = (max-min)*x - min and with n even It is the inverse of ProbabilityPairsVariable
PLearn::ProbabilityPairsVariableLet define f(x) = (x-min)/(max-min) for min<=x<=max, then this variable is defined by [x1,x2,...,xn] |-> [ f(x1), 1-f(x1), f(x2), 1-f(x2), ..
PLearn::ProbabilitySparseMatrix
PLearn::ProbSparseMatrix
PLearn::ProbVector
PLearn::ProcessDatasetVMatrix
PLearn::ProcessingVMatrix
PLearn::ProcessInputCostModuleProcesses the input through an embedded OnlineLearningModule
PLearn::ProcessSymbolicSequenceVMatrixThis VMatrix takes a VMat of a sequence of symbolic elements (corresponding to a set of symbolic attributes) and constructs context rows
PLearn::ProductRandomVariable
PLearn::ProductTransposeVariableMatrix product between matrix1 and transpose of matrix2
PLearn::ProductVariableMatrix product
PLearn::ProfilerProfiling tools, to count average time elapsed and number of times traversed for pieces of code delimited by two calls to the static functions
PLearn::ProgressBarThis class will help you display progress of a calculation
PLearn::ProgressBarPluginBase class for pb plugins
PLearn::ProjectionErrorVariableThe first input is a set of n_dim vectors (possibly seen as a single vector of their concatenation) f_i, each in R^n The second input is a set of T vectors (possibly seen as a single vector of their concatenation) t_j, each in R^n The output is the following: sum_j min_{w_j} || t_j - sum_i w_{ji} f_i ||^2 where row w_j of w is optmized analytically and separately for each j
PLearn::PrPStreamBufAn implementation of the PStreamBuf interface using Mozilla's NSPR library
PLearn::PruningLinearRegressorThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PseudolikelihoodRBMRestricted Boltzmann Machine trained by (generalized) pseudolikelihood
PLearn::PSMat
PLearn::PStream
PLearn::PStreamBuf
PLearn::PStreamBufTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PTest
PLearn::PTesterThis code is deprecated, use PTester.h and PTester.cc instead
PLearn::PTimerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PutSubVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::PvGradNNetMulti-layer neural network based on matrix-matrix multiplications
PLearn::PyPLearnScript
PLearn::PythonCodeSnippetEnables embedded Python code to be called from PLearn/C++ code
PLearn::PythonEmbedderInclude this file when you want to embed the Python interpreter
PLearn::PythonExceptionC++ Exception object to which Python exceptions are mapped
PLearn::PythonFeatureSetFeatureSet with features being defined using a python script
PLearn::PythonGlobalInterpreterLockEnsure thread safety by managing the Python Global Interpreter Lock
PythonGlobalInterpreterLockEnsure thread safety by managing the Python Global Interpreter Lock
PLearn::PythonObjectWrapperVery lightweight wrapper over a Python Object that allows conversion to/from C++ types (including those of PLearn)
PLearn::PythonProcessedLearnerAllows preprocessing operations to be carried out by a Python code snippet
PLearn::PythonProcessedVMatrixPreprocess a source VMatrix using a Python code snippet
PLearn::PythonTableVMatrix
PLearn::QuadraticUtilityCostFunction
PLearn::QuantilesStatsIterator
PLearn::RandomElementOfRandomVariableRandomVariable that is the element of the first parent RandomVariable indexed by the second parent RandomVariable
PLearn::RandomForcedValuesVariableThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RandomGaussMix
PLearn::RandomNeighborsDifferencesVMatrix
PLearn::RandomSamplesFromVMatrixVMatrix that contains random samples from a VMatrix
PLearn::RandomSamplesVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RandomVarWe follow the same pattern as Var & Variable
PLearn::RandomVariable
PLearn::RandomVarVMatrixThis is a convenient wrapping around the required data structures for efficient repeated sampling from a RandomVar
PLearn::Range
PLearn::RangeVMatrixOutputs scalar samples (length 1) starting at start, up to end (inclusive) with step. When end is reached it starts over again
PLearn::RankedVMatrix
PLearn::RankingFromKernelThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RankLearner
PLearn::RationalQuadraticARDKernelRational-Quadratic kernel that can be used for Automatic Relevance Determination
PLearn::RBMBinomialLayerLayer in an RBM formed with binomial units
PLearn::RBMClassificationModuleComputes the undirected softmax used in deep belief nets
PLearn::RBMConnectionVirtual class for the parameters between two layers of an RBM
PLearn::RBMConv2DConnectionFilter between two linear layers of a 2D convolutional RBM
PLearn::RBMConv2DLLParametersFilter between two linear layers of a 2D convolutional RBM
PLearn::RBMDiagonalMatrixConnectionStores and learns the parameters between two linear layers of an RBM
PLearn::RBMDistributionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RBMGaussianLayerLayer in an RBM formed with binomial units
PLearn::RBMGenericParametersStores and learns the parameters between two layers of an RBM
PLearn::RBMJointGenericParametersStores and learns the parameters between two layers of an RBM
PLearn::RBMJointLLParametersStores and learns the parameters between two layers of an RBM
PLearn::RBMLateralBinomialLayerLayer in an RBM formed with binomial units, with lateral connections
PLearn::RBMLayerVirtual class for a layer in an RBM
PLearn::RBMLLParametersStores and learns the parameters between two linear layers of an RBM
PLearn::RBMLocalMultinomialLayerMultiple multinomial units, each of them seeing an area of nearby pixels
PLearn::RBMLQParametersStores and learns the parameters between one quadratic layer and one linear layer of an RBM
PLearn::RBMMatrixConnectionStores and learns the parameters between two linear layers of an RBM
PLearn::RBMMatrixConnectionNatGradStores and learns the parameters between two linear layers of an RBM
PLearn::RBMMatrixTransposeConnectionRBMConnection which uses the tranpose of some other RBMMatrixConnection's weights
PLearn::RBMMixedConnectionContains a matrix of other RBMConnections, acting as submatrix of the linear transformation this class computes
PLearn::RBMMixedLayerLayer in an RBM formed with binomial units
PLearn::RBMModuleThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RBMMultinomialLayerLayer in an RBM formed with binomial units
PLearn::RBMMultitaskClassificationModuleComputes a mean-field approximate of p(y|x), with y a binary vector
PLearn::RBMParametersVirtual class for the parameters between two layers of an RBM
PLearn::RBMQLParametersStores and learns the parameters between one quadratic layer and one linear layer of an RBM
PLearn::RBMRateLayerLayer in an RBM consisting in rate-coded units
PLearn::RBMSparse1DMatrixConnectionStores and learns the parameters between two linear layers of an RBM
PLearn::RBMTrainerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RBMTruncExpLayerLayer in an RBM formed with binomial units
PLearn::RBMWoodsLayerRBM layer with tree-structured groups of units
PLearn::ReadAndWriteCommand
PLearn::RealFunctionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RealFunctionFromKernelThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RealFunctionOfInputFeatureThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RealFunctionProductThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RealFunctionsProcessedVMatrix
PLearn::RealMappingMapping between ranges and values
PLearn::RealRangeReal range: i.e. one of ]low,high[ ; [low,high[; [low,high]; ]low,high]
PLearn::RealRangeIndicatorFunctionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RealValueIndicatorFunctionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ReconstructionCandidateDescription of the main class: TransformationLearner
PLearn::ReconstructionWeightsKernel
PLearn::Redirect
PLearn::RegressionTree
PLearn::RegressionTreeLeave
PLearn::RegressionTreeMulticlassLeave
PLearn::RegressionTreeMulticlassLeaveFast
PLearn::RegressionTreeMulticlassLeaveProb
PLearn::RegressionTreeNode
PLearn::RegressionTreeQueue
PLearn::RegressionTreeRegisters
PLearn::RegressorFromDistributionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RegularGridVMatrix
PLearn::ReIndexedTargetVariable
PLearn::ReIndexedTargetVMatrixVMatrix the reindexes the target fields of a source VMatrix, according to the getValues(row,target_col) function, where row contains the values of a row of the source VMatrix, and target_col is the column index of (one of ) the target field
PLearn::RemapLastColumnVMatrix
PLearn::RemoteMethodDocDocumentation holder for a remote method
PLearn::RemoteMethodMapMap for determining a trampoline from a method-name+arity
PLearn::RemotePLearnServer
PLearn::RemoteProgressBarPluginSimilar to TextProgressBarPlugin with a different output format so that remote servers can update progress bars on a client
PLearn::RemoteTrampolineBase for the trampoline mechanism of PLearn remote method invocation
PLearn::RemoteTrampoline_0< T, R >Trampoline for a non-void non-const 0-argument method
PLearn::RemoteTrampoline_0< T, void >Trampoline for a void non-const 0-argument method
PLearn::RemoteTrampoline_1< T, R, A1 >Trampoline for a non-void non-const 1-argument method
PLearn::RemoteTrampoline_1< T, void, A1 >Trampoline for a void non-const 1-argument method
PLearn::RemoteTrampoline_2< T, R, A1, A2 >Trampoline for a non-void non-const 2-argument method
PLearn::RemoteTrampoline_2< T, void, A1, A2 >Trampoline for a void non-const 2-argument method
PLearn::RemoteTrampoline_3< T, R, A1, A2, A3 >Trampoline for a non-void non-const 3-argument method
PLearn::RemoteTrampoline_3< T, void, A1, A2, A3 >Trampoline for a void non-const 3-argument method
PLearn::RemoteTrampoline_4< T, R, A1, A2, A3, A4 >Trampoline for a non-void non-const 4-argument method
PLearn::RemoteTrampoline_4< T, void, A1, A2, A3, A4 >Trampoline for a void non-const 4-argument method
PLearn::RemoteTrampoline_5< T, R, A1, A2, A3, A4, A5 >Trampoline for a non-void non-const 5-argument method
PLearn::RemoteTrampoline_5< T, void, A1, A2, A3, A4, A5 >Trampoline for a void non-const 5-argument method
PLearn::RemoteTrampoline_6< T, R, A1, A2, A3, A4, A5, A6 >Trampoline for a non-void non-const 6-argument method
PLearn::RemoteTrampoline_6< T, void, A1, A2, A3, A4, A5, A6 >Trampoline for a void non-const 6-argument method
PLearn::RemoveDuplicateVMatrix
PLearn::RemoveObservationTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RemoveRowsVMatrixSees an underlying VMat with the specified rows excluded
PLearn::ReorderByMissingVMatrixRe-order samples in a source VMat by their missing attributes
PLearn::RepeatSplitter
PLearn::RepeatVMatrix
PLearn::ReplicateSamplesVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ReshapeVariableVariable that views another variable, but with a different length() and width() (the only restriction being that length()*width() remain the same)
PLearn::ResourceSemaphore
PLearn::RetDocDocumentation for a remote method return value
PLearn::RetTypeDocDocumentation for a method return type (just contains the type as a string)
PLearn::ReverseMatT< MatT >
PLearn::RGB
PLearn::RGBImageUses top left coordinate system Pixel (i,j) is at row i, column j
PLearn::RGBImageDB
PLearn::RGBImagesVMatrix
PLearn::RGBImageVMatrix
PLearn::RightPseudoInverseVariable
PLearn::Row
PLearn::RowAtPositionVariable
PLearn::RowBufferedVMatrix
PLearn::RowBufferedVMatrixTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RowIterator
PLearn::RowMapSparseMatrix< T >
PLearn::RowMapSparseValueMatrix< T >
PLearn::RowOfVariable
PLearn::RowsSubVMatrix
PLearn::RowSumSquareVariable
PLearn::RowSumVariableResult is a single column that contains the sum of each row of the input
PLearn::RPPath
PLearn::RunCommand
PLearn::RunICPVariableThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::RunObject
PLearn::RVArrayAn RVArray stores a table of RandomVar's
PLearn::RVArrayRandomElementRandomVariable
PLearn::RVInstanceRVInstance represents a RandomVariable V along with a "value" v
PLearn::RVInstanceArray
PLearn::SaltPepperNoiseVariableThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ScaledConditionalCDFSmoother
PLearn::ScaledGaussianKernelReturns exp(-sum_i[(phi_i*(x1_i - x2_i))^2]/sigma^2)
PLearn::ScaledGeneralizedDistanceRBFKernelReturns exp(-(sum_i phi_i*[abs(x1_i^a - x2_i^a)^b])^c)
PLearn::ScaledLaplacianKernelReturns exp(-(sum_i[abs(x1_i - x2_i)*phi_i]))
PLearn::ScaleGradientModuleScales (or suppress) the gradient that is backpropagated
PLearn::Schema
PLearn::ScoreLayerVariableThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SDBVMatrix
PLearn::SDBVMField
PLearn::SDBVMFieldAffineApply an affine transformation to the field: y = a*x+b
PLearn::SDBVMFieldAsIsPass through the value within the SDB (after conversion to real of the underlying SDB type)
PLearn::SDBVMFieldCodeAsIs
PLearn::SDBVMFieldDateConvert a date to fill 3 columns in the VMat: YYYY, MM, DD
PLearn::SDBVMFieldDateDiffDifference between two dates ("source1-source2" expressed as an integer number of days, months, or years)
PLearn::SDBVMFieldDateGreaterVerifies if the date within the row is greater than a threshold date
PLearn::SDBVMFieldDay
PLearn::SDBVMFieldDiscreteA field that recodes its source field according to an OutputCoder object
PLearn::SDBVMFieldDivSigmaJust divide by standard deviation
PLearn::SDBVMFieldFunc1
PLearn::SDBVMFieldFunc2
PLearn::SDBVMFieldHasClaim
PLearn::SDBVMFieldICBCClassification
PLearn::SDBVMFieldICBCTargets
PLearn::SDBVMFieldMonthsComputed year*12+(month-1)
PLearn::SDBVMFieldMultiDiscrete
PLearn::SDBVMFieldNormalizeNormalize the field (subtract the mean then divide by standard dev)
PLearn::SDBVMFieldPosAffineTake the positive part of the field, followed by affine transformation: y = a*max(x,0)+b
PLearn::SDBVMFieldRemapIntervals
PLearn::SDBVMFieldRemapReals
PLearn::SDBVMFieldRemapStrings
PLearn::SDBVMFieldSignedPowerDo the following : y = x^a
PLearn::SDBVMFieldSource1A field that maps exactly 1 SDB field to a VMatrix segment (abstract)
PLearn::SDBVMFieldSource2A field that maps exactly 2 SDB fields to a VMatrix segment (abstract)
PLearn::SDBVMFieldSumClaims
PLearn::SDBVMOutputCoder
PLearn::SDBVMSourceA SDBVMSource represents a source for a value that can be either directly a field from a SDB or an already processed SDBVMField
PLearn::SDBWithStats
PLearn::SecondIterationTester
PLearn::SecondIterationWrapper
PLearn::SelectColumnsVMatrixSelects variables (columns) from a source matrix according to given vector of indices
PLearn::SelectedIndicesCmp< T >
PLearn::SelectedOutputCostFunctionThis allows to apply a costfunction on a single output element (and correponding target element) of a larger output vector, rather than on the whole vector
PLearn::SelectInputSubsetLearner
PLearn::SelectRowsFileIndexVMatrix
PLearn::SelectRowsMultiInstanceVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SelectRowsVMatrixSelects samples from a source matrix according to given vector of indices
PLearn::SelectSetsSplitterThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SemIdThis class is defined in order to distinguish semaphore and shared memory id's from plain integers when constructing a Semaphore or a SharedMemory object
PLearn::SemiSupervisedDBNDeep Belief Net, possibly supervised, trained only with CD
PLearn::SemiSupervisedProbClassCostVariable
PLearn::semun
PLearn::SentencesBlocks
PLearn::SeparateInputVMatrixSeparates the input in nsep parts and distributes them on different rows
PLearn::SequentialLearner
PLearn::SequentialModelSelector
PLearn::SequentialSplitter
PLearn::SequentialValidation
PLearn::ServerCommand
PLearn::ServerLogStreamBuf
PLearn::Set
PLearn::SetOption
PLearn::SharedMemory< T >
PLearn::SharpeRatioStatsIterator
PLearn::ShellProgressBar
PLearn::ShellScript
PLearn::ShiftAndRescaleFeatureRealFunctionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ShiftAndRescaleVMatrix
PLearn::short_and_twobytes
PLearn::ShuffleColumnsVMatrix
PLearn::ShuntingNNetLayerModuleAffine transformation module, with stochastic gradient descent updates
PLearn::SigmoidalKernelReturns sigmoid(c*x1.x2)
PLearn::SigmoidPrimitiveKernelReturns log(1+exp(c*x1.x2)) = primitive of sigmoidal kernel
PLearn::SigmoidVariable
PLearn::SignVariableSign(x) = 1 if x>0, -1 if x<0, 0 if x=0, all done element by element
PLearn::SimpleDB< KeyType, QueryResult >
PLearn::SimpleDBIndexKey< KeyType >
PLearn::SmallVector< T, SizeBits, Allocator >
PLearn::SMat< T >
PLearn::SmoothedProbSparseMatrix
PLearn::Smoother
PLearn::SoftHistogramBinner
PLearn::SoftmaxLossVariable
PLearn::SoftmaxModuleComputes the softmax function on a vector
PLearn::SoftmaxNLLCostModuleComputes the NLL, given a probability vector and the true class
PLearn::SoftmaxVariable
PLearn::SoftplusVariable
PLearn::SoftSlopeIntegralVariable
PLearn::SoftSlopeVariable
PLearn::SoftSoftMaxVariableKind of SoftMax
PLearn::SortRowsVMatrixSort the samples of a VMatrix according to one (or more) given columns
PLearn::SourceKernel
PLearn::SourceSampleVariable
PLearn::SourceVariable
PLearn::SourceVMatrix
PLearn::SourceVMatrixSplitter
PLearn::SparseIncrementalAffineTransformVariableAffine transformation of a vector variable, with weights that are sparse and incrementally added Should work for both column and row vectors: result vector will be of same kind (row or col) First row of transformation matrix contains bias b, following rows contain linear-transformation T Will compute b + x.T
PLearn::SparseMatrix
PLearn::SparseVMatrix
PLearn::SparseVMatrixRow
PLearn::SpectralClustering
PLearn::SpiralDistribution
PLearn::SplitModuleThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SplitterThis class is an abstract base class for mechanisms allowing to "split" a dataset into one or several partitions (or "splits")
PLearn::SplitWiseValidationVMatrixVMatrix that takes several experiment split_stats.pmat to extract the split statistics and perform validation
PLearn::SquaredErrModuleSquared difference (and derivatives thereof) between the target and input
PLearn::SquaredErrorCostFunction********************************************************* The following 'kernels' are rather used as cost functions
PLearn::SquaredErrorCostModuleComputes the sum of squared difference between input and target
PLearn::SquaredExponentialARDKernelSquared-Exponential kernel that can be used for Automatic Relevance Determination
PLearn::SquaredSymmMatT< MatT >
PLearn::SquareRootVariable
PLearn::SquareVariable
PLearn::StabilisationLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::StackedAutoassociatorsNetNeural net, trained layer-wise in a greedy fashion using autoassociators
PLearn::StackedFocusedAutoassociatorsNetNeural net, trained layer-wise in a greedy but focused fashion using autoassociators/RBMs and a supervised non-parametric gradient
PLearn::StackedLearner
PLearn::StackedModulesLearnerTrains a stack of OnlineLearningModule, which are layers
PLearn::StackedModulesModuleWraps a stack of OnlineLearningModule, which are layers
PLearn::StackedSplitter
PLearn::StackedSVDNetNeural net, initialized with SVDs of logistic auto-regressions
PLearn::StanThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::StatefulLearner
PLearn::StaticConvertEnumFromPyObject< U, is_enum >
PLearn::StaticConvertEnumFromPyObject< U, true >
PLearn::StaticConvertEnumToPyObject< T, is_enum >
PLearn::StaticConvertEnumToPyObject< T, true >
PLearn::StaticInitializerA StaticInitializer is typically declared as a static member of a class, and given a parameter that is a static initialization function for said class
PLearn::StaticOption< OptionType >Template class for static option definitions This is not thread safe while loading or saving! If you have some data in memory then load some other, the static value will be overwrited! This will be saved and loaded for each instance, but will override the station version each time
PLearn::Profiler::Stats
PLearn::StatsCollector
PLearn::StatsCollectorCounts
PLearn::StatsCommandThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::StatsItArray
PLearn::StatsIterator
PLearn::StatSpecThe specification of a statistic to compute (as can be specified as a string in PTester)
PLearn::StddevStatsIterator
PLearn::StderrStatsIterator
PLearn::StdPStreamBuf
PLearn::StepwiseSelectionOracleThis oracle implements a stepwise forward variable selection procedure
PLearn::StochasticBinarizeVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::StochasticRandomVariable
PLearn::Storage< T >
streambuf
PLearn::StringFieldMapping
PLearn::StringPStreamBuf
PLearn::StringTable
PLearn::StrTableVMatrix
PLearn::StructuralLearnerPutain de code fait à la va-vite pour ICML
PLearn::SubInputVMatrix
PLearn::SubMatTransposeVariable
PLearn::SubMatVariableTakes a submatrix of an input variable
PLearn::SubsampleVariableA subsample var; equals subrample(input, the_subsamplefactor)
PLearn::Subsampling2DModuleReduce the size of the 2D images by adding the values of nearby pixels
PLearn::SubsamplingDBNNeural net, learned layer-wise in a greedy fashion
PLearn::SubVecRandomVariableY = sub-vector of X starting at position "start", of length "value->length()"
PLearn::SubVMatrix
PLearn::SumAbsVariable
PLearn::SumEntropyOfBernoullisThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SumEntropyOfCategoricalsThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SummationKernelKernel computing the sum of other kernels
PLearn::SumOfVariableSums the value of a Function evaluated on each row of a VMatrix
PLearn::SumOverBagsVariable
PLearn::SumSquareVariable
PLearn::SumVariableCompute the sum of all elements in the input Var
PLearn::SumVarianceOfLinearTransformedBernoullisThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SumVarianceOfLinearTransformedCategoricalsThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::Supersampling2DModuleAugment the size of 2D images by duplicating pixels
PLearn::SupervisedDBNHinton's DBN plus supervised gradient from a logistic regression layer but without joint layer on top
PLearn::SurfaceMesh
PLearn::SurfaceTemplateLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::SVDVariable
PLearn::SVMClassificationTorch
PLearn::Symbol
PLearn::SymbolNode
PLearn::TangentLearner
PLearn::TanhModuleThis class propagates a (possibly scaled) 'tanh' function
PLearn::TanhVariable
PLearn::TargetEncodingLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::Template
PLearn::TemporalHorizonVMatrixThis VMat delay the last targetsize entries of a source VMat by a certain horizon
PLearn::TemporaryDiskVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TemporaryFileVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::Test_PP
PLearn::TestClientCommand
PLearn::TestDependenciesCommand
PLearn::TestDependencyCommand
PLearn::TestImputationsGenerate samples from a mixture of two gaussians
PLearn::TestingLearner
PLearn::TestInTrainSplitter
PLearn::TestLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TestMethod
PLearn::TestSnippetThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TextFilesVMatrix
PLearn::TextProgressBarPluginSimple plugin for displaying text progress bar
PLearn::TextSenseSequenceVMatrixThis class handles a sequence of words/sense tag/POS triplets to present it as target words and their context
PLearn::TextStreamVMatrix
PLearn::BasisSelectionRegressor::thread_wawr
PLearn::ThresholdBpropVariable
PLearn::ThresholdedKernel
PLearn::ThresholdVMatrix
PLearn::TimesColumnVariable
PLearn::TimesConstantScalarVariable2Multiplies a matrix var by a scalar var
PLearn::TimesConstantVariableMultiplies a matrix var by a scalar constant
PLearn::TimesRowVariable
PLearn::TimesScalarVariableMultiplies a matrix var by a scalar var
PLearn::TimesVariableMultiplies 2 matrix vars of same size elementwise
PLearn::TinyVector< T, N, TTrait >Compile-time fixed-size vector with interface close to std::vector
PLearn::TinyVectorTrait< T >Define "missing-value" for a number of types with TinyVector
PLearn::TinyVectorTrait< char >
PLearn::TinyVectorTrait< int >
PLearn::TinyVectorTrait< short >
PLearn::TinyVectorTrait< signed char >
PLearn::TinyVectorTrait< unsigned char >
PLearn::TinyVectorTrait< unsigned int >
PLearn::TinyVectorTrait< unsigned short >
PLearn::TMat< T >
PLearn::TMatColRowsIterator< T >Model of the Random Access Iterator concept for iterating through a single column of a TMat, one row at a time
PLearn::TMatElementIterator< T >
PLearn::TMatRowsAsArraysIterator< T >Model of the Random Access Iterator concept for iterating through the ROWS of a TMat
PLearn::TMatRowsIterator< T >Model of the Random Access Iterator concept for iterating through the ROWS of a TMat
PLearn::TMatTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TmpFilenames
PLearn::ToBagClassifierThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ToBagSplitter
PLearn::TopDownAsymetricDeepNetworkNeural net, trained layer-wise in a greedy but focused fashion using autoassociators/RBMs and a supervised non-parametric gradient
PLearn::TopNI< T >
PLearn::TorchLearner
PLearn::TraceVariable
PLearn::Train
PLearn::TrainTestSplitter
PLearn::TrainValidTestSplitter
PLearn::TransformationLearner
PLearn::TransformOutputLearnerThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TransparentParentableSpecial type of ParentableObject that cannot act as a visible parent
PLearn::TransposedDoubleProductVariableLet W, M and H be the inputs and nw the length of W
PLearn::TransposeProductVariableMatrix product between transpose of matrix1 and matrix2
PLearn::TransposeVariable
PLearn::TransposeVMatrix
PLearn::TreeDBNModule
PLearn::tRule
PLearn::TruncatedRealFunctionThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TTensor< T >
PLearn::TTensorElementIterator< T >
PLearn::TTensorSubTensorIterator< T >
PLearn::TupleTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::TVec< T >
PLearn::TVecOption< ObjectType, VecElementType >
PLearn::TVecStaticOption< VecElementType >
PLearn::TxtmatCommand
PLearn::TypedParentableObject< ParentT >
PLearn::TypeFactoryCreate new objects given their type name (as a string)
PLearn::TypeMapEntryDescription of a single type within the TypeMap
PLearn::TypeTraits< T >TypeTraits provides a type-information mechanism for C++ types
PLearn::TypeTraits< AbsVariable >
PLearn::TypeTraits< AdaBoost >
PLearn::TypeTraits< AddCostToLearner >
PLearn::TypeTraits< AdditiveGaussianNoiseVariable >
PLearn::TypeTraits< AdditiveNormalizationKernel >
PLearn::TypeTraits< AddLayersNNet >
PLearn::TypeTraits< AddMissingVMatrix >
PLearn::TypeTraits< AffineTransformVariable >
PLearn::TypeTraits< AffineTransformWeightPenalty >
PLearn::TypeTraits< AnalyzeDond2DiscreteVariables >
PLearn::TypeTraits< AnalyzeFieldStats >
PLearn::TypeTraits< AppendNeighborsVMatrix >
PLearn::TypeTraits< ArgmaxVariable >
PLearn::TypeTraits< ArgminVariable >
PLearn::TypeTraits< Array< T > >
PLearn::TypeTraits< AsciiVMatrix >
PLearn::TypeTraits< AutoLinearRegressor >
PLearn::TypeTraits< AutoScaledGradientOptimizer >
PLearn::TypeTraits< AutoVMatrix >
PLearn::TypeTraits< AutoVMatrixSaveSource >
PLearn::TypeTraits< AutoVMatrixTest >
PLearn::TypeTraits< BaggingLearner >
PLearn::TypeTraits< BallTreeNearestNeighbors >
PLearn::TypeTraits< BaseRegressorConfidence >
PLearn::TypeTraits< BaseRegressorWrapper >
PLearn::TypeTraits< BasicIdentityCallsTest >
PLearn::TypeTraits< BasisSelectionRegressor >
PLearn::TypeTraits< BatchVMatrix >
PLearn::TypeTraits< BernoulliSampleVariable >
PLearn::TypeTraits< BestAveragingPLearner >
PLearn::TypeTraits< BetaKernel >
PLearn::TypeTraits< BiasWeightAffineTransformVariable >
PLearn::TypeTraits< BinaryBallTree >
PLearn::TypeTraits< BinaryClassificationLossVariable >
PLearn::TypeTraits< BinaryKernelDiscrimination >
PLearn::TypeTraits< BinaryNumbersVMatrix >
PLearn::TypeTraits< BinaryOpVMatrix >
PLearn::TypeTraits< BinaryVariable >
PLearn::TypeTraits< Binner >
PLearn::TypeTraits< BinSplitter >
PLearn::TypeTraits< BootstrapSplitter >
PLearn::TypeTraits< BootstrapVMatrix >
PLearn::TypeTraits< ByteMemoryVMatrix >
PLearn::TypeTraits< Calendar >
PLearn::TypeTraits< CartesianProductOracle >
PLearn::TypeTraits< CCCostVariable >
PLearn::TypeTraits< CenteredVMatrix >
PLearn::TypeTraits< ChainedLearners >
PLearn::TypeTraits< ChemicalICP >
PLearn::TypeTraits< ClassDistanceProportionCostFunction >
PLearn::TypeTraits< ClassErrorCostFunction >
PLearn::TypeTraits< ClassificationLossVariable >
PLearn::TypeTraits< ClassMarginCostFunction >
PLearn::TypeTraits< ClassSeparationSplitter >
PLearn::TypeTraits< ClassSubsetVMatrix >
PLearn::TypeTraits< ColumnIndexVariable >
PLearn::TypeTraits< CompactFileVMatrix >
PLearn::TypeTraits< CompactVMatrix >
PLearn::TypeTraits< CompactVMatrixGaussianKernel >
PLearn::TypeTraits< CompactVMatrixPolynomialKernel >
PLearn::TypeTraits< CompareLearner >
PLearn::TypeTraits< CompressedVMatrix >
PLearn::TypeTraits< ComputeDond2Target >
PLearn::TypeTraits< ConcatColumnsVariable >
PLearn::TypeTraits< ConcatColumnsVMatrix >
PLearn::TypeTraits< ConcatOfVariable >
PLearn::TypeTraits< ConcatRowsSubVMatrix >
PLearn::TypeTraits< ConcatRowsVariable >
PLearn::TypeTraits< ConcatRowsVMatrix >
PLearn::TypeTraits< ConcatSetsSplitter >
PLearn::TypeTraits< ConditionalCDFSmoother >
PLearn::TypeTraits< ConditionalDensityNet >
PLearn::TypeTraits< ConditionalDictionary >
PLearn::TypeTraits< ConditionalMeanImputationVMatrix >
PLearn::TypeTraits< ConditionalStatsCollector >
PLearn::TypeTraits< ConfRatedAdaboostCostVariable >
PLearn::TypeTraits< ConjRosenbrock >
PLearn::TypeTraits< ConstantRegressor >
PLearn::TypeTraits< ConstantVMatrix >
PLearn::TypeTraits< ConstrainVariable >
PLearn::TypeTraits< ConvexBasisKernel >
PLearn::TypeTraits< ConvolveVariable >
PLearn::TypeTraits< CorrelationKernel >
PLearn::TypeTraits< CorrelationProfiler >
PLearn::TypeTraits< Correspondence >
PLearn::TypeTraits< CosKernel >
PLearn::TypeTraits< Cov2CorrVariable >
PLearn::TypeTraits< CovariancePreservationImputationVMatrix >
PLearn::TypeTraits< CrossEntropyVariable >
PLearn::TypeTraits< CrossReferenceVMatrix >
PLearn::TypeTraits< CubicSpline >
PLearn::TypeTraits< CumVMatrix >
PLearn::TypeTraits< CutAboveThresholdVariable >
PLearn::TypeTraits< CutBelowThresholdVariable >
PLearn::TypeTraits< DatedJoinVMatrix >
PLearn::TypeTraits< DatedVMatrix >
PLearn::TypeTraits< DBSplitter >
PLearn::TypeTraits< DeepBeliefNet >
PLearn::TypeTraits< DeepFeatureExtractorNNet >
PLearn::TypeTraits< DeepNNet >
PLearn::TypeTraits< DeepNonLocalManifoldParzen >
PLearn::TypeTraits< DeepReconstructorNet >
PLearn::TypeTraits< DenoisingRecurrentNet >
PLearn::TypeTraits< DeterminantVariable >
PLearn::TypeTraits< DiagonalizedFactorsProductVariable >
PLearn::TypeTraits< DiagVariable >
PLearn::TypeTraits< DichotomizeDond2DiscreteVariables >
PLearn::TypeTraits< DichotomizeVMatrix >
PLearn::TypeTraits< Dictionary >
PLearn::TypeTraits< DictionaryVMatrix >
PLearn::TypeTraits< DifferenceKernel >
PLearn::TypeTraits< DilogarithmVariable >
PLearn::TypeTraits< DiscriminativeDeepBeliefNet >
PLearn::TypeTraits< DiscriminativeRBM >
PLearn::TypeTraits< DiskVMatrix >
PLearn::TypeTraits< DisregardRowsVMatrix >
PLearn::TypeTraits< DistanceKernel >
PLearn::TypeTraits< DistRepNNet >
PLearn::TypeTraits< DiverseComponentAnalysis >
PLearn::TypeTraits< DivisiveNormalizationKernel >
PLearn::TypeTraits< DivVariable >
PLearn::TypeTraits< DotProductKernel >
PLearn::TypeTraits< DotProductVariable >
PLearn::TypeTraits< DoubleProductVariable >
PLearn::TypeTraits< DTWKernel >
PLearn::TypeTraits< DuplicateColumnVariable >
PLearn::TypeTraits< DuplicateRowVariable >
PLearn::TypeTraits< DuplicateScalarVariable >
PLearn::TypeTraits< DynamicallyLinkedRBMsModel >
PLearn::TypeTraits< EarlyStoppingOracle >
PLearn::TypeTraits< ElementAtPositionVariable >
PLearn::TypeTraits< EmbeddedLearner >
PLearn::TypeTraits< EmbeddedSequentialLearner >
PLearn::TypeTraits< EncodedVMatrix >
PLearn::TypeTraits< EntropyContrast >
PLearn::TypeTraits< EntropyContrastLearner >
PLearn::TypeTraits< EpanechnikovKernel >
PLearn::TypeTraits< EqualConstantVariable >
PLearn::TypeTraits< EqualScalarVariable >
PLearn::TypeTraits< EqualVariable >
PLearn::TypeTraits< ErfVariable >
PLearn::TypeTraits< ExhaustiveNearestNeighbors >
PLearn::TypeTraits< Experiment >
PLearn::TypeTraits< Experimentation >
PLearn::TypeTraits< ExplicitListOracle >
PLearn::TypeTraits< ExplicitSplitter >
PLearn::TypeTraits< ExpMeanStatsIterator >
PLearn::TypeTraits< ExpVariable >
PLearn::TypeTraits< ExtendedVariable >
PLearn::TypeTraits< ExtendedVMatrix >
PLearn::TypeTraits< ExtractNNetParamsVMatrix >
PLearn::TypeTraits< ExtractVariable >
PLearn::TypeTraits< FeatureSet >
PLearn::TypeTraits< FeatureSetNaiveBayesClassifier >
PLearn::TypeTraits< FeatureSetNNet >
PLearn::TypeTraits< FeatureSetSequentialCRF >
PLearn::TypeTraits< FileDictionary >
PLearn::TypeTraits< FileVMatrix >
PLearn::TypeTraits< FileVMatrixTest >
PLearn::TypeTraits< FilteredVMatrix >
PLearn::TypeTraits< FilterSplitter >
PLearn::TypeTraits< FinancePreprocVMatrix >
PLearn::TypeTraits< FixDond2BinaryVariables >
PLearn::TypeTraits< FNetLayerVariable >
PLearn::TypeTraits< ForwardModule >
PLearn::TypeTraits< ForwardVMatrix >
PLearn::TypeTraits< FractionSplitter >
PLearn::TypeTraits< Func >
PLearn::TypeTraits< Function >
PLearn::TypeTraits< GaussianContinuum >
PLearn::TypeTraits< GaussianContinuumDistribution >
PLearn::TypeTraits< GaussianDBNClassification >
PLearn::TypeTraits< GaussianDBNRegression >
PLearn::TypeTraits< GaussianDensityKernel >
PLearn::TypeTraits< GaussianizeVMatrix >
PLearn::TypeTraits< GaussianKernel >
PLearn::TypeTraits< GaussianProcessNLLVariable >
PLearn::TypeTraits< GaussianProcessRegressor >
PLearn::TypeTraits< GaussMix >
PLearn::TypeTraits< GaussMixLocalProjections >
PLearn::TypeTraits< GaussPartSupervisedDBN >
PLearn::TypeTraits< GeneralizedDistanceRBFKernel >
PLearn::TypeTraits< GeneralizedOneHotVMatrix >
PLearn::TypeTraits< GenerateDecisionPlot >
PLearn::TypeTraits< GenericNearestNeighbors >
PLearn::TypeTraits< GeodesicDistanceKernel >
PLearn::TypeTraits< GetInputVMatrix >
PLearn::TypeTraits< GradientAdaboostCostVariable >
PLearn::TypeTraits< GradientCorrector >
PLearn::TypeTraits< GradientOptimizer >
PLearn::TypeTraits< GradNNetLayerModule >
PLearn::TypeTraits< GramVMatrix >
PLearn::TypeTraits< Grapher >
PLearn::TypeTraits< HardSlopeVariable >
PLearn::TypeTraits< HashMapFeatureSet >
PLearn::TypeTraits< HeapTest >
PLearn::TypeTraits< HeterogenuousAffineTransformVariable >
PLearn::TypeTraits< HeterogenuousAffineTransformWeightPenalty >
PLearn::TypeTraits< HintonDeepBeliefNet >
PLearn::TypeTraits< HistogramDistribution >
PLearn::TypeTraits< HorizonStatefulLearner >
PLearn::TypeTraits< HTMLHelpGenerator >
PLearn::TypeTraits< HyperCommand >
PLearn::TypeTraits< HyperLearner >
PLearn::TypeTraits< HyperOptimize >
PLearn::TypeTraits< HyperRetrain >
PLearn::TypeTraits< HyperSetOption >
PLearn::TypeTraits< ICP >
PLearn::TypeTraits< IdentityFeatureSet >
PLearn::TypeTraits< IdentityModule >
PLearn::TypeTraits< IdentityPLearner >
PLearn::TypeTraits< IdentityVariable >
PLearn::TypeTraits< IfThenElseVariable >
PLearn::TypeTraits< ImputationVMatrix >
PLearn::TypeTraits< IncrementalNNet >
PLearn::TypeTraits< IndexAtPositionVariable >
PLearn::TypeTraits< IndexedVMatrix >
PLearn::TypeTraits< IndexedVMatrixTest >
PLearn::TypeTraits< InferenceRBM >
PLearn::TypeTraits< InfiniteMNISTVMatrix >
PLearn::TypeTraits< InjectionTest >
PLearn::TypeTraits< InsertZerosVariable >
PLearn::TypeTraits< InstanceSnippetTest >
PLearn::TypeTraits< InterfunctionXchgTest >
PLearn::TypeTraits< InterleaveVMatrix >
PLearn::TypeTraits< InterValuesVariable >
PLearn::TypeTraits< InvertElementsVariable >
PLearn::TypeTraits< IsAboveThresholdVariable >
PLearn::TypeTraits< IsLargerVariable >
PLearn::TypeTraits< IsMissingVariable >
PLearn::TypeTraits< Isomap >
PLearn::TypeTraits< IsomapTangentLearner >
PLearn::TypeTraits< IsSmallerVariable >
PLearn::TypeTraits< JoinVMatrix >
PLearn::TypeTraits< JulianizeVMatrix >
PLearn::TypeTraits< Ker >
PLearn::TypeTraits< Kernel >
PLearn::TypeTraits< KernelDensityEstimator >
PLearn::TypeTraits< KernelPCA >
PLearn::TypeTraits< KernelProjection >
PLearn::TypeTraits< KernelRidgeRegressor >
PLearn::TypeTraits< KernelVMatrix >
PLearn::TypeTraits< KFoldSplitter >
PLearn::TypeTraits< KLp0p1RBMModule >
PLearn::TypeTraits< KMeansClustering >
PLearn::TypeTraits< KNNClassifier >
PLearn::TypeTraits< KNNImputationVMatrix >
PLearn::TypeTraits< KNNRegressor >
PLearn::TypeTraits< KNNVMatrix >
PLearn::TypeTraits< KPCATangentLearner >
PLearn::TypeTraits< LaplacianKernel >
PLearn::TypeTraits< LayerCostModule >
PLearn::TypeTraits< Learner >
PLearn::TypeTraits< LearnerProcessedVMatrix >
PLearn::TypeTraits< LeftPseudoInverseVariable >
PLearn::TypeTraits< LemmatizeVMatrix >
PLearn::TypeTraits< LIBSVMSparseVMatrix >
PLearn::TypeTraits< LiftBinaryCostFunction >
PLearn::TypeTraits< LiftOutputVariable >
PLearn::TypeTraits< LiftStatsCollector >
PLearn::TypeTraits< LiftStatsIterator >
PLearn::TypeTraits< LimitedGaussianSmoother >
PLearn::TypeTraits< LinearCombinationModule >
PLearn::TypeTraits< LinearCombinationOfScalarVariables >
PLearn::TypeTraits< LinearFilterModule >
PLearn::TypeTraits< LinearInductiveTransferClassifier >
PLearn::TypeTraits< LinearRegressor >
PLearn::TypeTraits< LLC >
PLearn::TypeTraits< LLE >
PLearn::TypeTraits< LLEKernel >
PLearn::TypeTraits< LocalizedFeaturesLayerVariable >
PLearn::TypeTraits< LocallyMagnifiedDistribution >
PLearn::TypeTraits< LocalMedBoost >
PLearn::TypeTraits< LocalNeighborsDifferencesVMatrix >
PLearn::TypeTraits< LogAddVariable >
PLearn::TypeTraits< LogOfGaussianDensityKernel >
PLearn::TypeTraits< LogSoftmaxVariable >
PLearn::TypeTraits< LogSoftSoftMaxVariable >
PLearn::TypeTraits< LogVariable >
PLearn::TypeTraits< ManifoldKNNDistribution >
PLearn::TypeTraits< ManifoldParzen >
PLearn::TypeTraits< ManifoldParzen2 >
PLearn::TypeTraits< ManifoldParzenKernel >
PLearn::TypeTraits< ManualBinner >
PLearn::TypeTraits< MarginPerceptronCostVariable >
PLearn::TypeTraits< MatrixAffineTransformFeedbackVariable >
PLearn::TypeTraits< MatrixAffineTransformVariable >
PLearn::TypeTraits< MatrixElementsVariable >
PLearn::TypeTraits< MatrixInverseVariable >
PLearn::TypeTraits< MatrixModule >
PLearn::TypeTraits< MatrixOneHotSquaredLoss >
PLearn::TypeTraits< MatrixSoftmaxLossVariable >
PLearn::TypeTraits< MatrixSoftmaxVariable >
PLearn::TypeTraits< MatrixSumOfVariable >
PLearn::TypeTraits< MatRowVariable >
PLearn::TypeTraits< Max2Variable >
PLearn::TypeTraits< MaxStatsIterator >
PLearn::TypeTraits< MaxSubsampling2DModule >
PLearn::TypeTraits< MaxSubsamplingTest >
PLearn::TypeTraits< MaxVariable >
PLearn::TypeTraits< MeanImputationVMatrix >
PLearn::TypeTraits< MeanMedianModeImputationVMatrix >
PLearn::TypeTraits< MeanStatsIterator >
PLearn::TypeTraits< MemoryCachedKernel >
PLearn::TypeTraits< MemoryStressTest >
PLearn::TypeTraits< MemoryVMatrix >
PLearn::TypeTraits< MemoryVMatrixNoSave >
PLearn::TypeTraits< MergeDond2Files >
PLearn::TypeTraits< MeshEdge >
PLearn::TypeTraits< MeshFace >
PLearn::TypeTraits< MeshGraph >
PLearn::TypeTraits< MeshMatch >
PLearn::TypeTraits< MeshVertex >
PLearn::TypeTraits< Min2Variable >
PLearn::TypeTraits< MiniBatchClassificationLossVariable >
PLearn::TypeTraits< MinStatsIterator >
PLearn::TypeTraits< MinusColumnVariable >
PLearn::TypeTraits< MinusRowVariable >
PLearn::TypeTraits< MinusTransposedColumnVariable >
PLearn::TypeTraits< MinusVariable >
PLearn::TypeTraits< MinVariable >
PLearn::TypeTraits< MissingIndicatorVMatrix >
PLearn::TypeTraits< MissingInstructionVMatrix >
PLearn::TypeTraits< MixtureVMatrix >
PLearn::TypeTraits< MixUnlabeledNeighbourVMatrix >
PLearn::TypeTraits< mNNet >
PLearn::TypeTraits< ModuleLearner >
PLearn::TypeTraits< ModulesLearner >
PLearn::TypeTraits< ModuleStackModule >
PLearn::TypeTraits< ModuleTester >
PLearn::TypeTraits< Molecule >
PLearn::TypeTraits< MoleculeTemplateLearner >
PLearn::TypeTraits< MovingAverage >
PLearn::TypeTraits< MovingAverageVMatrix >
PLearn::TypeTraits< MultiClassAdaBoost >
PLearn::TypeTraits< MulticlassErrorCostFunction >
PLearn::TypeTraits< MulticlassLossVariable >
PLearn::TypeTraits< MultiInstanceNNet >
PLearn::TypeTraits< MultiInstanceVMatrix >
PLearn::TypeTraits< MultiMaxVariable >
PLearn::TypeTraits< MultiSampleVariable >
PLearn::TypeTraits< MultiTargetOneHotVMatrix >
PLearn::TypeTraits< MultiTaskSeparationSplitter >
PLearn::TypeTraits< MultiToUniInstanceSelectRandomVMatrix >
PLearn::TypeTraits< NatGradEstimator >
PLearn::TypeTraits< NatGradNNet >
PLearn::TypeTraits< NatGradSMPNNet >
PLearn::TypeTraits< NearestNeighborPredictionCost >
PLearn::TypeTraits< NegateElementsVariable >
PLearn::TypeTraits< NegCrossEntropySigmoidVariable >
PLearn::TypeTraits< NegKernel >
PLearn::TypeTraits< NegLogPoissonVariable >
PLearn::TypeTraits< NegLogProbCostFunction >
PLearn::TypeTraits< NegOutputCostFunction >
PLearn::TypeTraits< NeighborhoodBoxVolumeDensityEstimator >
PLearn::TypeTraits< NeighborhoodConditionalMean >
PLearn::TypeTraits< NeighborhoodImputationVMatrix >
PLearn::TypeTraits< NeighborhoodSmoothnessNNet >
PLearn::TypeTraits< NetflixVMatrix >
PLearn::TypeTraits< NetworkConnection >
PLearn::TypeTraits< NetworkModule >
PLearn::TypeTraits< NeuralNet >
PLearn::TypeTraits< NeuralNetworkARDKernel >
PLearn::TypeTraits< NeuralProbabilisticLanguageModel >
PLearn::TypeTraits< NGramTree >
PLearn::TypeTraits< NLLCostModule >
PLearn::TypeTraits< NLLErrModule >
PLearn::TypeTraits< NllGeneralGaussianVariable >
PLearn::TypeTraits< NLLNeighborhoodWeightsVariable >
PLearn::TypeTraits< NllSemisphericalGaussianVariable >
PLearn::TypeTraits< NNet >
PLearn::TypeTraits< NnlmOnlineLearner >
PLearn::TypeTraits< NnlmOutputLayer >
PLearn::TypeTraits< NnlmWordRepresentationLayer >
PLearn::TypeTraits< NoBpropVariable >
PLearn::TypeTraits< NonDiagVariable >
PLearn::TypeTraits< NonLocalManifoldParzen >
PLearn::TypeTraits< NonLocalManifoldParzenKernel >
PLearn::TypeTraits< NormalizationLearner >
PLearn::TypeTraits< NormalizedDotProductKernel >
PLearn::TypeTraits< NoSplitSplitter >
PLearn::TypeTraits< NullModule >
PLearn::TypeTraits< NxProfileLearner >
PLearn::TypeTraits< ObjectGenerator >
PLearn::TypeTraits< ObjectOptionVariable >
PLearn::TypeTraits< ObservationWindow >
PLearn::TypeTraits< OnBagsModule >
PLearn::TypeTraits< OneHotSquaredLoss >
PLearn::TypeTraits< OneHotVariable >
PLearn::TypeTraits< OneHotVMatrix >
PLearn::TypeTraits< OneVsAllVMatrix >
PLearn::TypeTraits< OnlineGramNaturalGradientOptimizer >
PLearn::TypeTraits< OnlineLearningModule >
PLearn::TypeTraits< OptimizeOptionOracle >
PLearn::TypeTraits< Optimizer >
PLearn::TypeTraits< OptionsOracle >
PLearn::TypeTraits< OracleObjectGenerator >
PLearn::TypeTraits< OutputVariable >
PLearn::TypeTraits< PairsVMatrix >
PLearn::TypeTraits< ParentableObject >
PLearn::TypeTraits< PartsDistanceKernel >
PLearn::TypeTraits< PartSupervisedDBN >
PLearn::TypeTraits< ParzenWindow >
PLearn::TypeTraits< PCA >
PLearn::TypeTraits< PDate >
PLearn::TypeTraits< PDistributionVariable >
PLearn::TypeTraits< PerformanceEvaluator >
PLearn::TypeTraits< PLearnDiff >
PLearn::TypeTraits< PLearner >
PLearn::TypeTraits< PLearnerDiagonalKernel >
PLearn::TypeTraits< PLearnerOutputVMatrix >
PLearn::TypeTraits< PLogPVariable >
PLearn::TypeTraits< PLS >
PLearn::TypeTraits< PlusColumnVariable >
PLearn::TypeTraits< PlusConstantVariable >
PLearn::TypeTraits< PlusManyVariable >
PLearn::TypeTraits< PlusRowVariable >
PLearn::TypeTraits< PlusScalarVariable >
PLearn::TypeTraits< PlusVariable >
PLearn::TypeTraits< PolynomialKernel >
PLearn::TypeTraits< PotentialsVariable >
PLearn::TypeTraits< PowDistanceKernel >
PLearn::TypeTraits< PowVariable >
PLearn::TypeTraits< PowVariableVariable >
PLearn::TypeTraits< PP< T > >
PLearn::TypeTraits< PPath >
PLearn::TypeTraits< PRandom >
PLearn::TypeTraits< PrecomputedKernel >
PLearn::TypeTraits< PrecomputedProcessedLearner >
PLearn::TypeTraits< PrecomputedVMatrix >
PLearn::TypeTraits< Preprocessing >
PLearn::TypeTraits< PreprocessingVMatrix >
PLearn::TypeTraits< PricingTransactionPairProfitFunction >
PLearn::TypeTraits< ProbabilityPairsInverseVariable >
PLearn::TypeTraits< ProbabilityPairsVariable >
PLearn::TypeTraits< ProcessDatasetVMatrix >
PLearn::TypeTraits< ProcessingVMatrix >
PLearn::TypeTraits< ProcessInputCostModule >
PLearn::TypeTraits< ProcessSymbolicSequenceVMatrix >
PLearn::TypeTraits< ProductTransposeVariable >
PLearn::TypeTraits< ProductVariable >
PLearn::TypeTraits< ProjectionErrorVariable >
PLearn::TypeTraits< PruningLinearRegressor >
PLearn::TypeTraits< PseudolikelihoodRBM >
PLearn::TypeTraits< PTest >
PLearn::TypeTraits< PTester >
PLearn::TypeTraits< PTimer >
PLearn::TypeTraits< PutSubVMatrix >
PLearn::TypeTraits< PvGradNNet >
PLearn::TypeTraits< PyPLearnScript >
PLearn::TypeTraits< PythonCodeSnippet >
PLearn::TypeTraits< PythonFeatureSet >
PLearn::TypeTraits< PythonObjectWrapper >
PLearn::TypeTraits< PythonProcessedLearner >
PLearn::TypeTraits< PythonProcessedVMatrix >
PLearn::TypeTraits< PythonTableVMatrix >
PLearn::TypeTraits< QuadraticUtilityCostFunction >
PLearn::TypeTraits< QuantilesStatsIterator >
PLearn::TypeTraits< RandomForcedValuesVariable >
PLearn::TypeTraits< RandomGaussMix >
PLearn::TypeTraits< RandomNeighborsDifferencesVMatrix >
PLearn::TypeTraits< RandomSamplesFromVMatrix >
PLearn::TypeTraits< RandomSamplesVMatrix >
PLearn::TypeTraits< RangeVMatrix >
PLearn::TypeTraits< RankedVMatrix >
PLearn::TypeTraits< RankingFromKernel >
PLearn::TypeTraits< RankLearner >
PLearn::TypeTraits< RationalQuadraticARDKernel >
PLearn::TypeTraits< RBMClassificationModule >
PLearn::TypeTraits< RBMConnection >
PLearn::TypeTraits< RBMConv2DConnection >
PLearn::TypeTraits< RBMConv2DLLParameters >
PLearn::TypeTraits< RBMDiagonalMatrixConnection >
PLearn::TypeTraits< RBMGenericParameters >
PLearn::TypeTraits< RBMJointGenericParameters >
PLearn::TypeTraits< RBMJointLLParameters >
PLearn::TypeTraits< RBMLayer >
PLearn::TypeTraits< RBMLLParameters >
PLearn::TypeTraits< RBMLQParameters >
PLearn::TypeTraits< RBMMatrixConnection >
PLearn::TypeTraits< RBMMatrixConnectionNatGrad >
PLearn::TypeTraits< RBMMatrixTransposeConnection >
PLearn::TypeTraits< RBMMixedConnection >
PLearn::TypeTraits< RBMModule >
PLearn::TypeTraits< RBMMultitaskClassificationModule >
PLearn::TypeTraits< RBMParameters >
PLearn::TypeTraits< RBMQLParameters >
PLearn::TypeTraits< RBMSparse1DMatrixConnection >
PLearn::TypeTraits< RBMTrainer >
PLearn::TypeTraits< RealFunction >
PLearn::TypeTraits< RealFunctionFromKernel >
PLearn::TypeTraits< RealFunctionOfInputFeature >
PLearn::TypeTraits< RealFunctionProduct >
PLearn::TypeTraits< RealFunctionsProcessedVMatrix >
PLearn::TypeTraits< RealMapping >
PLearn::TypeTraits< RealRangeIndicatorFunction >
PLearn::TypeTraits< RealValueIndicatorFunction >
PLearn::TypeTraits< ReconstructionWeightsKernel >
PLearn::TypeTraits< Redirect >
PLearn::TypeTraits< RegressionTree >
PLearn::TypeTraits< RegressionTreeLeave >
PLearn::TypeTraits< RegressionTreeMulticlassLeave >
PLearn::TypeTraits< RegressionTreeMulticlassLeaveFast >
PLearn::TypeTraits< RegressionTreeMulticlassLeaveProb >
PLearn::TypeTraits< RegressionTreeNode >
PLearn::TypeTraits< RegressionTreeQueue >
PLearn::TypeTraits< RegressionTreeRegisters >
PLearn::TypeTraits< RegressorFromDistribution >
PLearn::TypeTraits< RegularGridVMatrix >
PLearn::TypeTraits< ReIndexedTargetVariable >
PLearn::TypeTraits< ReIndexedTargetVMatrix >
PLearn::TypeTraits< RemapLastColumnVMatrix >
PLearn::TypeTraits< RemoveDuplicateVMatrix >
PLearn::TypeTraits< RemoveObservationTest >
PLearn::TypeTraits< RemoveRowsVMatrix >
PLearn::TypeTraits< ReorderByMissingVMatrix >
PLearn::TypeTraits< RepeatSplitter >
PLearn::TypeTraits< RepeatVMatrix >
PLearn::TypeTraits< ReplicateSamplesVMatrix >
PLearn::TypeTraits< ReshapeVariable >
PLearn::TypeTraits< RightPseudoInverseVariable >
PLearn::TypeTraits< RowAtPositionVariable >
PLearn::TypeTraits< RowBufferedVMatrix >
PLearn::TypeTraits< RowBufferedVMatrixTest >
PLearn::TypeTraits< RowOfVariable >
PLearn::TypeTraits< RowsSubVMatrix >
PLearn::TypeTraits< RowSumSquareVariable >
PLearn::TypeTraits< RowSumVariable >
PLearn::TypeTraits< RPPath >
PLearn::TypeTraits< RunICPVariable >
PLearn::TypeTraits< RunObject >
PLearn::TypeTraits< SaltPepperNoiseVariable >
PLearn::TypeTraits< ScaledConditionalCDFSmoother >
PLearn::TypeTraits< ScaledGaussianKernel >
PLearn::TypeTraits< ScaledGeneralizedDistanceRBFKernel >
PLearn::TypeTraits< ScaledLaplacianKernel >
PLearn::TypeTraits< ScaleGradientModule >
PLearn::TypeTraits< ScoreLayerVariable >
PLearn::TypeTraits< SecondIterationTester >
PLearn::TypeTraits< SelectColumnsVMatrix >
PLearn::TypeTraits< SelectedOutputCostFunction >
PLearn::TypeTraits< SelectInputSubsetLearner >
PLearn::TypeTraits< SelectRowsFileIndexVMatrix >
PLearn::TypeTraits< SelectRowsMultiInstanceVMatrix >
PLearn::TypeTraits< SelectRowsVMatrix >
PLearn::TypeTraits< SelectSetsSplitter >
PLearn::TypeTraits< SemiSupervisedDBN >
PLearn::TypeTraits< SemiSupervisedProbClassCostVariable >
PLearn::TypeTraits< SeparateInputVMatrix >
PLearn::TypeTraits< SequentialLearner >
PLearn::TypeTraits< SequentialModelSelector >
PLearn::TypeTraits< SequentialSplitter >
PLearn::TypeTraits< SequentialValidation >
PLearn::TypeTraits< SetOption >
PLearn::TypeTraits< SharpeRatioStatsIterator >
PLearn::TypeTraits< ShellScript >
PLearn::TypeTraits< ShiftAndRescaleFeatureRealFunction >
PLearn::TypeTraits< ShiftAndRescaleVMatrix >
PLearn::TypeTraits< ShuffleColumnsVMatrix >
PLearn::TypeTraits< ShuntingNNetLayerModule >
PLearn::TypeTraits< SigmoidalKernel >
PLearn::TypeTraits< SigmoidPrimitiveKernel >
PLearn::TypeTraits< SigmoidVariable >
PLearn::TypeTraits< SignVariable >
PLearn::TypeTraits< Smoother >
PLearn::TypeTraits< SoftHistogramBinner >
PLearn::TypeTraits< SoftmaxLossVariable >
PLearn::TypeTraits< SoftmaxModule >
PLearn::TypeTraits< SoftmaxNLLCostModule >
PLearn::TypeTraits< SoftmaxVariable >
PLearn::TypeTraits< SoftplusVariable >
PLearn::TypeTraits< SoftSlopeIntegralVariable >
PLearn::TypeTraits< SoftSlopeVariable >
PLearn::TypeTraits< SoftSoftMaxVariable >
PLearn::TypeTraits< SortRowsVMatrix >
PLearn::TypeTraits< SourceKernel >
PLearn::TypeTraits< SourceVariable >
PLearn::TypeTraits< SourceVMatrix >
PLearn::TypeTraits< SourceVMatrixSplitter >
PLearn::TypeTraits< SparseIncrementalAffineTransformVariable >
PLearn::TypeTraits< SparseVMatrix >
PLearn::TypeTraits< SpectralClustering >
PLearn::TypeTraits< SplitModule >
PLearn::TypeTraits< Splitter >
PLearn::TypeTraits< SplitWiseValidationVMatrix >
PLearn::TypeTraits< SquaredErrModule >
PLearn::TypeTraits< SquaredErrorCostFunction >
PLearn::TypeTraits< SquaredErrorCostModule >
PLearn::TypeTraits< SquaredExponentialARDKernel >
PLearn::TypeTraits< SquareRootVariable >
PLearn::TypeTraits< SquareVariable >
PLearn::TypeTraits< StackedAutoassociatorsNet >
PLearn::TypeTraits< StackedFocusedAutoassociatorsNet >
PLearn::TypeTraits< StackedLearner >
PLearn::TypeTraits< StackedModulesLearner >
PLearn::TypeTraits< StackedModulesModule >
PLearn::TypeTraits< StackedSplitter >
PLearn::TypeTraits< StackedSVDNet >
PLearn::TypeTraits< StatefulLearner >
PLearn::TypeTraits< StatsCollector >
PLearn::TypeTraits< StatsItArray >
PLearn::TypeTraits< StatsIterator >
PLearn::TypeTraits< std::list< T > >
PLearn::TypeTraits< std::map< T, U > >
PLearn::TypeTraits< std::pair< T, U > >
PLearn::TypeTraits< std::priority_queue< T > >
PLearn::TypeTraits< std::set< T > >
PLearn::TypeTraits< std::vector< T > >
PLearn::TypeTraits< StddevStatsIterator >
PLearn::TypeTraits< StderrStatsIterator >
PLearn::TypeTraits< StepwiseSelectionOracle >
PLearn::TypeTraits< StochasticBinarizeVMatrix >
PLearn::TypeTraits< string >
PLearn::TypeTraits< StrTableVMatrix >
PLearn::TypeTraits< StructuralLearner >
PLearn::TypeTraits< SubInputVMatrix >
PLearn::TypeTraits< SubMatTransposeVariable >
PLearn::TypeTraits< SubMatVariable >
PLearn::TypeTraits< SubsampleVariable >
PLearn::TypeTraits< Subsampling2DModule >
PLearn::TypeTraits< SubsamplingDBN >
PLearn::TypeTraits< SubVMatrix >
PLearn::TypeTraits< SumAbsVariable >
PLearn::TypeTraits< SumEntropyOfBernoullis >
PLearn::TypeTraits< SumEntropyOfCategoricals >
PLearn::TypeTraits< SummationKernel >
PLearn::TypeTraits< SumOfVariable >
PLearn::TypeTraits< SumOverBagsVariable >
PLearn::TypeTraits< SumSquareVariable >
PLearn::TypeTraits< SumVariable >
PLearn::TypeTraits< SumVarianceOfLinearTransformedBernoullis >
PLearn::TypeTraits< SumVarianceOfLinearTransformedCategoricals >
PLearn::TypeTraits< Supersampling2DModule >
PLearn::TypeTraits< SupervisedDBN >
PLearn::TypeTraits< SurfaceMesh >
PLearn::TypeTraits< SurfaceTemplateLearner >
PLearn::TypeTraits< SVDVariable >
PLearn::TypeTraits< SVMClassificationTorch >
PLearn::TypeTraits< SymbolNode >
PLearn::TypeTraits< T * >
PLearn::TypeTraits< T const >
PLearn::TypeTraits< TangentLearner >
PLearn::TypeTraits< TanhModule >
PLearn::TypeTraits< TanhVariable >
PLearn::TypeTraits< TargetEncodingLearner >
PLearn::TypeTraits< TemporalHorizonVMatrix >
PLearn::TypeTraits< TemporaryDiskVMatrix >
PLearn::TypeTraits< TemporaryFileVMatrix >
PLearn::TypeTraits< TestImputations >
PLearn::TypeTraits< TestingLearner >
PLearn::TypeTraits< TestInTrainSplitter >
PLearn::TypeTraits< TestLearner >
PLearn::TypeTraits< TestMethod >
PLearn::TypeTraits< TextStreamVMatrix >
PLearn::TypeTraits< ThresholdBpropVariable >
PLearn::TypeTraits< ThresholdedKernel >
PLearn::TypeTraits< TimesColumnVariable >
PLearn::TypeTraits< TimesConstantScalarVariable2 >
PLearn::TypeTraits< TimesConstantVariable >
PLearn::TypeTraits< TimesRowVariable >
PLearn::TypeTraits< TimesScalarVariable >
PLearn::TypeTraits< TimesVariable >
PLearn::TypeTraits< TMat< T > >
PLearn::TypeTraits< ToBagSplitter >
PLearn::TypeTraits< TopDownAsymetricDeepNetwork >
PLearn::TypeTraits< TorchLearner >
PLearn::TypeTraits< TraceVariable >
PLearn::TypeTraits< Train >
PLearn::TypeTraits< TrainTestSplitter >
PLearn::TypeTraits< TrainValidTestSplitter >
PLearn::TypeTraits< TransformationLearner >
PLearn::TypeTraits< TransformOutputLearner >
PLearn::TypeTraits< TransparentParentable >
PLearn::TypeTraits< TransposedDoubleProductVariable >
PLearn::TypeTraits< TransposeProductVariable >
PLearn::TypeTraits< TransposeVariable >
PLearn::TypeTraits< TransposeVMatrix >
PLearn::TypeTraits< TreeDBNModule >
PLearn::TypeTraits< TruncatedRealFunction >
PLearn::TypeTraits< tuple< T1 > >
PLearn::TypeTraits< tuple< T1, T2 > >
PLearn::TypeTraits< tuple< T1, T2, T3 > >
PLearn::TypeTraits< tuple< T1, T2, T3, T4 > >
PLearn::TypeTraits< tuple< T1, T2, T3, T4, T5 > >
PLearn::TypeTraits< tuple< T1, T2, T3, T4, T5, T6 > >
PLearn::TypeTraits< TVec< T > >
PLearn::TypeTraits< TypedParentableObject< ParentT > >
PLearn::TypeTraits< UCIDataVMatrix >
PLearn::TypeTraits< UCISpecification >
PLearn::TypeTraits< UnaryHardSlopeVariable >
PLearn::TypeTraits< UnaryVariable >
PLearn::TypeTraits< UndirectedSoftmaxModule >
PLearn::TypeTraits< UnequalConstantVariable >
PLearn::TypeTraits< UnfoldedFuncVariable >
PLearn::TypeTraits< UnfoldedSumOfVariable >
PLearn::TypeTraits< UnfrozenDeepBeliefNet >
PLearn::TypeTraits< UniformizeLearner >
PLearn::TypeTraits< UniformizeVMatrix >
PLearn::TypeTraits< UniformVMatrix >
PLearn::TypeTraits< UpsideDownVMatrix >
PLearn::TypeTraits< ValueSelectRowsVMatrix >
PLearn::TypeTraits< Var >
PLearn::TypeTraits< VarArray >
PLearn::TypeTraits< VarArrayElementVariable >
PLearn::TypeTraits< VarColumnsVariable >
PLearn::TypeTraits< VarElementVariable >
PLearn::TypeTraits< Variable >
PLearn::TypeTraits< VariableDeletionVMatrix >
PLearn::TypeTraits< VariableSelectionWithDirectedGradientDescent >
PLearn::TypeTraits< VariablesTest >
PLearn::TypeTraits< VarRowsVariable >
PLearn::TypeTraits< VarRowVariable >
PLearn::TypeTraits< VarUtilsTest >
PLearn::TypeTraits< VBoundDBN2 >
PLearn::TypeTraits< VecDictionary >
PLearn::TypeTraits< VecElementVariable >
PLearn::TypeTraits< VecExtendedVMatrix >
PLearn::TypeTraits< VecStatsCollector >
PLearn::TypeTraits< ViewSplitterVMatrix >
PLearn::TypeTraits< VMat >
PLearn::TypeTraits< VMatKernel >
PLearn::TypeTraits< VMatLanguage >
PLearn::TypeTraits< VMatrix >
PLearn::TypeTraits< VMatrixFromDistribution >
PLearn::TypeTraits< VPLCombinedLearner >
PLearn::TypeTraits< VPLPreprocessedLearner >
PLearn::TypeTraits< VPLPreprocessedLearner2 >
PLearn::TypeTraits< VPLProcessor >
PLearn::TypeTraits< VVMatrix >
PLearn::TypeTraits< WeightedCostFunction >
PLearn::TypeTraits< WeightedDistance >
PLearn::TypeTraits< WeightedLogGaussian >
PLearn::TypeTraits< WeightedQuadraticPolynomialKernel >
PLearn::TypeTraits< WeightedSumSquareVariable >
PLearn::TypeTraits< WordNetFeatureSet >
PLearn::TypeTraits< WordNetSenseDictionary >
PLearn::TypeTraits< WPLS >
PLearn::TypeTraits< X >
PLearn::TypeTraits< Y >
PLearn::TypeTraits< YMDDatedVMatrix >
PLearn::TypeTraits< Z >
PLearn::UCIDataVMatrix
PLearn::UCISpecification
PLearn::UnaryHardSlopeVariable
PLearn::UnarySampleVariable
PLearn::UnaryVariable
PLearn::UnconditionalDistribution
PLearn::UndirectedSoftmaxModuleThis class
PLearn::UnequalConstantVariableA scalar var; equal 1 if input1!=c, 0 otherwise
PLearn::UnfoldedFuncVariable
PLearn::UnfoldedSumOfVariable
PLearn::UnfrozenDeepBeliefNetDoes the same thing as Hinton's deep belief nets without freezing weights of earlier layers
PLearn::UniformDistribution
PLearn::UniformizeLearner
PLearn::UniformizeVMatrix
PLearn::UniformSampleVariable
PLearn::UniformVMatrix
PLearn::UpsideDownVMatrix
PLearn::ValueSelectRowsVMatrixThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::Var
PLearn::VarArray
PLearn::VarArrayElementVariableVariable that is the element of the input1 VarArray indexed by the input2 variable
PLearn::VarColumnsVariable
Vardesc
PLearn::VarElementVariable
PLearn::Variable
PLearn::VariableDeletionVMatrix
PLearn::VariableSelectionWithDirectedGradientDescent
PLearn::VariablesTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::VarMeasurer
PLearn::VarRowsVariable
PLearn::VarRowVariableVariable that is the row of the input1 variable indexed by the input2 variable
PLearn::VarUtilsTestThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::VBoundDBN22-RBM DBN trained using Hinton's new variational bound of global likelihood:
PLearn::VecCompressor
PLearn::VecDictionary
PLearn::VecElementVariableVariable that is the element of vector vec indexed by variable input
PLearn::VecExtendedVMatrix
PLearn::VecStatsCollector
PLearn::VerifyGradientCommandThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::ViewSplitterVMatrix
PLearn::VMat
PLearn::VMatAccessBufferSimple buffer class for getRow calls on a VMat
PLearn::VMatCommand
PLearn::VMatDictionaryCommandThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::VMatKernel
PLearn::VMatLanguage
PLearn::VMatrixBase classes for virtual matrices
PLearn::VMatrixExtensionRegistrarExtension registrar for new file types
PLearn::VMatrixFromDistribution
PLearn::VMatViewCommandThe first sentence should be a BRIEF DESCRIPTION of what the class does
PLearn::VMFieldVMField contains a fieldname and a fieldtype
PLearn::VMFieldStatThis class holds simple statistics about a field
PLearn::VPLCombinedLearner
PLearn::VPLPreprocessedLearner
PLearn::VPLPreprocessedLearner2
PLearn::VPLProcessor
PLearn::VVecA VVec is a reference to a row or part of a row (a subrow) of a VMatrix
PLearn::VVMatrixThis class is a wrapper for a .vmat VMatrix
PLearn::WeightedCostFunctionA costfunction that allows to reweight another costfunction (weight being last element of target) Returns target.lastElement() * costfunc(output,target.subVec(0,target.length()-1));
PLearn::WeightedDistanceThis class implements an Ln distance (defaults to L2 i.e. euclidean distance)
PLearn::WeightedLogGaussian
PLearn::WeightedQuadraticPolynomialKernel
PLearn::WeightedSumSquareVariable
PLearn::wordAndFreqUsed to sort words according to frequency, when determining candidates
PLearn::wordAndProbUsed to sort words according to probability
PLearn::WordNetFeatureSetFeatureSet with features from WordNet
PLearn::WordNetOntology
PLearn::WordNetSenseDictionary
PLearn::WPLS
X
PLearn::X
PLearn::Y
PLearn::YMDDatedVMatrix
PLearn::Z
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines