__attribute__ | |
PLearn::_plearn_nan_type | |
PLearn::AbsVariable | |
PLearn::AdaBoost | |
PLearn::AdaptGradientOptimizer | |
PLearn::AddBagInformationVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::AddCostToLearner | |
PLearn::AdditiveGaussianNoiseVariable | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::AdditiveNormalizationKernel | |
PLearn::AddLayersNNet | |
PLearn::AddMissingVMatrix | |
PLearn::AffineTransformVariable | |
PLearn::AffineTransformWeightPenalty | Weight decay terms for affine transforms |
PLearn::PMemArena::Aligner | Utility union to ensure alignment across platforms |
alist | |
PLearn::AnalyzeDond2DiscreteVariables | Generate samples from a mixture of two gaussians |
PLearn::AnalyzeFieldStats | Generate samples from a mixture of two gaussians |
PLearn::AppendNeighborsVMatrix | Appends the nearest neighbors of the input samples of a source VMatrix |
PLearn::ARDBaseKernel | Base class for kernels that carry out Automatic Relevance Determination (ARD) |
PLearn::ArgDoc | Documentation for a single remote method argument |
PLearn::ArgmaxModule | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ArgmaxVariable | |
PLearn::ArgminOfVariable | |
PLearn::ArgminVariable | |
PLearn::ArgTypeDoc | Documentation 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::AutoLinearRegressor | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::AutoRunCommand | |
PLearn::AutoScaledGradientOptimizer | |
PLearn::AutoSDBVMatrix | A 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::AutoVMatrix | This class is a simple wrapper to an underlying VMatrix of another type All it does is forward the method calls |
PLearn::AutoVMatrixSaveSource | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::AutoVMatrixTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::BackConvolution2DModule | Transpose of Convolution2DModule |
PLearn::BaggingLearner | Learner that trains several sub-learners on 'bags' |
PLearn::BallTreeNearestNeighbors | |
PLearn::BaseRegressorConfidence | |
PLearn::BaseRegressorWrapper | |
PLearn::BasicIdentityCallsTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::BasisSelectionRegressor | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::BatchVMatrix | VMat class that replicates small parts of a matrix (mini-batches), so that each mini-batch appears twice (consecutively) |
PLearn::BernoulliSampleVariable | |
PLearn::BestAveragingPLearner | Select the M "best" of N trained PLearners based on a train cost |
PLearn::BetaKernel | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::BiasWeightAffineTransformVariable | Affine transformation of a vector variable, from a weight and bias variable |
PLearn::BinarizeModule | Map 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::BinaryKernelDiscrimination | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::BinaryNumbersVMatrix | VMatrix 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::BodyDoc | Documentation 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::CachedFeatureSet | Feature set that maintains a cached mapping between tokens and their features |
PLearn::Calendar | Encapsulates the concept of a calendar as an ordered finite list of timestamps |
PLearn::Callback | This is a virtual base class that contains a single abstract method callback() |
PLearn::CallbackMeasurer | |
PLearn::CartesianProductOracle | |
PLearn::CCCostVariable | |
PLearn::CenteredVMatrix | |
PLearn::ChainedLearners | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::CheckDond2FileSequence | Generate samples from a mixture of two gaussians |
PLearn::ChemicalICP | The 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::ClassErrorCostModule | Multiclass classification error |
PLearn::ClassificationLossVariable | Indicator(classnum==argmax(netout)) |
PLearn::ClassifierFromConditionalPDistribution | Classifier 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::ClassSeparationSplitter | Splitter that separates examples of some classes (test) from the examples of other classes (train) |
PLearn::ClassSubsetVMatrix | |
cllist | |
PLearn::ColumnIndexVariable | |
PLearn::ColumnSumVariable | Result is a single row that contains the sum of each column of the input |
PLearn::CombiningCostsModule | Combine several CostModules with the same input and target |
PLearn::CompactFileVMatrix | A VMatrix that exists in a .pmat file (native PLearn matrix format, same as for Mat) |
PLearn::CompactVMatrix | |
PLearn::CompactVMatrixGaussianKernel | |
PLearn::CompactVMatrixPolynomialKernel | |
PLearn::compareIndexAndMissingFlags | Comparison function used in sorting |
PLearn::CompareLearner | |
PLearn::ComplementedProbSparseMatrix | |
complex | |
PLearn::CompressedVMatrix | |
PLearn::ComputeDond2Target | Generate samples from a mixture of two gaussians |
PLearn::ComputePurenneError | |
PLearn::ConcatColumnsRandomVariable | Concatenate the columns of the matrix arguments, just like the hconcat function (PLearn.h) on Vars |
PLearn::ConcatColumnsVariable | Concatenation of the columns of several variables |
PLearn::ConcatColumnsVMatrix | |
PLearn::ConcatDisjointFeatureSet | Feature set that is the concatenation of disjoint feature sets |
PLearn::ConcatOfVariable | |
PLearn::ConcatRowsSubVMatrix | |
PLearn::ConcatRowsVariable | Concatenation 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::ConfigParsing | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ConfRatedAdaboostCostVariable | |
PLearn::ConjGradientOptimizer | |
PLearn::ConjRosenbrock | Exercises the Conjugate Gradient optimizer through the Rosenbrock Function |
PLearn::ConstantRealFunction | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ConstantRegressor | |
PLearn::ConstantVMatrix | This VMatrix returns a constant element (specified upon construction) |
PLearn::ConstrainedSourceVariable | SourceVariable 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::ConvexBasisKernel | Returns prod_i log(1+exp(c*(x1[i]-x2[i]))) NOTE: IT IS NOT SYMMETRIC! |
PLearn::Convolution2DModule | Apply convolution filters on (possibly multiple) 2D inputs (images) |
PLearn::ConvolveVariable | A convolve var; equals convolve(input, mask) |
PLearn::CorrelationKernel | |
PLearn::CorrelationProfiler | Used to profile the correlation between the elements of a vector |
PLearn::Correspondence | |
PLearn::CosKernel | This class implements an Ln distance (defaults to L2 i.e. euclidean distance) |
PLearn::CostModule | General class representing a cost function module |
PLearn::CountEventsSemaphore | |
PLearn::Cov2CorrVariable | |
PLearn::CovariancePreservationImputationVMatrix | |
PLearn::CrossEntropyCostModule | Computes the cross-entropy, given two activation vectors |
PLearn::CrossEntropyVariable | Cost = - sum_i {target_i * log(output_i) + (1-target_i) * log(1-output_i)} |
PLearn::CrossReferenceVMatrix | |
PLearn::CubicSpline | Unidimensional cubic spline learner |
PLearn::CumVMatrix | |
PLearn::CutAboveThresholdVariable | |
PLearn::CutBelowThresholdVariable | |
PLearn::DatedJoinVMatrix | |
PLearn::DatedVMatrix | |
PLearn::FieldValue::DateVal_t | |
PLearn::DBSplitter | |
PLearn::DeepBeliefNet | Neural net, learned layer-wise in a greedy fashion |
PLearn::DeepFeatureExtractorNNet | Deep Neural Network that extracts features in a greedy, mostly unsupervised way |
PLearn::DeepNNet | |
PLearn::DeepNonLocalManifoldParzen | Neural net, trained layer-wise to predict the manifold structure of the data |
PLearn::DeepReconstructorNet | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::DenoisingRecurrentNet | Model made of RBMs linked through time |
PLearn::DeterminantVariable | The argument must be a square matrix Var and the result is its determinant |
PLearn::DiagonalizedFactorsProductVariable | |
PLearn::DiagonalNormalRandomVariable | |
PLearn::DiagonalNormalSampleVariable | |
PLearn::DiagVariable | |
PLearn::DichotomizeDond2DiscreteVariables | Generate samples from a mixture of two gaussians |
PLearn::DichotomizeVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Dictionary | |
PLearn::DictionaryVMatrix | VMat of text files, encoded with Dictionaries, The lines of the text files that are empty are ommited |
PLearn::DiffCommand | |
PLearn::DifferenceKernel | Returns 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::DilogarithmVariable | This is the primitive of a sigmoid: log(1+exp(x)) |
PLearn::DirectNegativeCostFunction | |
PLearn::DiscriminativeDeepBeliefNet | Deep Belief Net where the stacked RBMs also use a discriminative criteria |
PLearn::DiscriminativeRBM | Discriminative Restricted Boltzmann Machine classifier |
PLearn::DiskVMatrix | A VMatrix whose (compressed) data resides in a directory and can span several files |
PLearn::DisregardRowsVMatrix | |
PLearn::DistanceKernel | This class implements an Ln distance (defaults to L2 i.e. euclidean distance) |
PLearn::DistRepNNet | |
PLearn::Distribution | |
PLearn::DiverseComponentAnalysis | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::DivisiveNormalizationKernel | |
PLearn::DivVariable | |
PLearn::DotProductKernel | Returns <x1,x2> |
PLearn::DotProductVariable | Dot product between 2 vectors (or possibly 2 matrices, which are then simply seen as vectors) |
PLearn::DoubleAccessSparseMatrix< T > | |
doublecomplex | |
PLearn::DoubleProductVariable | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::DoublyLinkedList< T > | Class description: |
PLearn::DoublyLinkedListElement< T > | Class description: |
PLearn::DTWKernel | Kernel for Dynamic Time Warping see sect.4.7 of Rabiner, L |
PLearn::DuplicateColumnVariable | |
PLearn::DuplicateRowVariable | |
PLearn::DuplicateScalarVariable | |
PLearn::DynamicallyLinkedRBMsModel | Model 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::EqualConstantVariable | A scalar var; equal 1 if input1==input2, 0 otherwise |
PLearn::EqualScalarVariable | A scalar var; equal 1 if input1==input2, 0 otherwise |
PLearn::EqualVariable | A scalar var; equal 1 if input1==input2, 0 otherwise |
PLearn::ErfVariable | |
PLearn::ExhaustiveNearestNeighbors | This class provides the basic implementation of the classical O(N^2) nearest-neighbors algorithm |
PLearn::Experiment | |
PLearn::Experimentation | Generate 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::ExtractOptionCommand | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ExtractVariable | |
PLearn::FdPStreamBuf | |
PLearn::FeatureSet | Base class for sets of sparse features |
PLearn::FeatureSetNaiveBayesClassifier | Naive Bayes classifier on a feature set space |
PLearn::FeatureSetNNet | Feedforward Neural Network for symbolic data represented using features |
PLearn::FeatureSetSequentialCRF | Feedforward 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::FileVMatrix | A VMatrix that exists in a .pmat file (native PLearn matrix format, same as for Mat) |
PLearn::FileVMatrixTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::FillFeatureSetCommand | PLearn command that fills a FeatureSet with the features instantiated in a VMat |
PLearn::FilteredVMatrix | |
PLearn::FilterSplitter | |
PLearn::FinancePreprocVMatrix | |
PLearn::FixDond2BinaryVariables | Generate samples from a mixture of two gaussians |
PLearn::FNetLayerVariable | Single 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::GaussianDBNClassification | Does the same thing as Hinton's deep belief nets |
PLearn::GaussianDBNRegression | Does the same thing as Hinton's deep belief nets |
PLearn::GaussianDensityKernel | |
PLearn::GaussianDistribution | |
PLearn::GaussianizeVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::GaussianKernel | Returns exp(-norm_2(x1-x2)^2/sigma^2) |
PLearn::GaussianProcessNLLVariable | Compute the Negative-Log-Marginal-Likelihood for Gaussian Process Regression |
PLearn::GaussianProcessRegressor | Implements Gaussian Process Regression (GPR) with an arbitrary kernel |
PLearn::GaussMix | |
PLearn::GaussMixLocalProjections | |
PLearn::GaussPartSupervisedDBN | Hinton's DBN plus supervised gradient from a logistic regression layer |
PLearn::GeneralizedDistanceRBFKernel | Returns exp(-phi*(sum_i[abs(x1_i^a - x2_i^a)^b])^c) |
PLearn::GeneralizedOneHotVMatrix | This 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::GradientAdaboostCostVariable | Cost 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::GradientCorrector | Virtual class used for converting a sequence of n-dimensional gradients g_t into corrected update directions v_t |
PLearn::GradientOptimizer | |
PLearn::GradNNetLayerModule | Affine transformation module, with stochastic gradient descent updates |
PLearn::GramVMatrix | |
graph | |
PLearn::Graph_ | |
PLearn::Grapher | |
PLearn::GraphicalBiText | |
PLearn::GroupInfo | Each row contains a certain amount of field groups |
PLearn::HardSlopeVariable | |
PLearn::Hash< KeyType, DataType > | |
PLearn::HashKeyDataPair< KeyType, DataType > | |
PLearn::HashMapFeatureSet | Base 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::Heading | Support stuff for heading manipulator |
PLearn::HeapTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::HelpCommand | |
PLearn::HelpSystem | |
PLearn::HeterogenuousAffineTransformVariable | Affine transform with continuous and discrete input |
PLearn::HeterogenuousAffineTransformWeightPenalty | Penalty associated to an affine transform with continuous and discrete input |
PLearn::HintonDeepBeliefNet | Does the same thing as Hinton's deep belief nets |
PLearn::HistogramDistribution | |
PLearn::HorizonStatefulLearner | A HorizonStatefulLearner is a StatefulLearner designed for forecasting at horizon h |
PLearn::HSV | |
PLearn::HTMLHelpCommand | Forward-declare |
PLearn::HTMLHelpConfig | |
PLearn::HTMLHelpGenerator | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::HTMLUtils | |
PLearn::HyperCommand | |
PLearn::HyperLearner | |
PLearn::HyperOptimize | Carry out an hyper-parameter optimization according to an Oracle |
PLearn::HyperRetrain | |
PLearn::HyperSetOption | |
icilist | |
PLearn::ICP | |
PLearn::IdentityFeatureSet | FeatureSet with features corresponding to the input string token |
PLearn::IdentityModule | |
PLearn::IdentityPLearner | |
PLearn::IdentityVariable | |
PLearn::IfThenElseVariable | Variable that represents the element-wise IF-THEN-ELSE: |
PLearn::IIDNoiseKernel | Kernel representing independent and identically-distributed observation noise |
PLearn::ImputationVMatrix | |
PLearn::IncrementalNNet | |
PLearn::IndexAndMissingFlags | Simple 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::IndexedVMatrix | VMat 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::IndexedVMatrixTest | Tests for IndexedVMatrix, including handling of NaN and string mappings |
PLearn::InferenceRBM | RBM to be used when doing joint supervised learning by CD |
PLearn::InfiniteMNISTVMatrix | VMatrix 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::InjectionTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
inlist | |
PLearn::InMemoryIntStream | |
PLearn::InsertZerosVariable | |
PLearn::InstanceSnippetTest | |
PLearn::InterfunctionXchgTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::InterleaveVMatrix | Interleave several VMats row-wise |
PLearn::InterValuesVariable | If values = [x1,x2,...,x10], the resulting variable is [(x1+x2)/2,(x2+x3)/2, .. |
PLearn::IntPair | Example of class that can be used as key |
PLearn::IntStream | |
PLearn::IntStreamVMatrix | |
PLearn::IntVecFile | |
PLearn::InvertElementsVariable | |
iostream | |
PLearn::IPopen | |
PLearn::IPServer | |
PLearn::IsAboveThresholdVariable | Does elementwise newx_i = (x_i>=threshold ?truevalue :falsevalue); |
PLearn::IsLargerVariable | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
PLearn::IsMissingVariable | A 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::KernelDensityEstimator | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::KernelPCA | |
PLearn::KernelProjection | |
PLearn::KernelRidgeRegressor | Implements a 'kernelized' version of linear ridge regression |
PLearn::KernelVMatrix | |
PLearn::KFoldLogisticClassifier | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::KFoldSplitter | |
PLearn::KLp0p1RBMModule | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::KMeansClustering | |
PLearn::KNNClassifier | This class provides a simple N-class classifier based upon an enclosed K-nearest-neighbors finder (derived from GenericNearestNeighbors; specified with the 'knn' option) |
PLearn::KNNImputationVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::KNNRegressor | This 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::KroneckerBaseKernel | Base class for kernels that make use of Kronecker terms |
PLearn::LaplacianKernel | Returns exp(-phi*(sum_i[abs(x1_i - x2_i)])) |
PLearn::LayerCostModule | Computes a cost function for a (hidden) representation |
PLearn::Learner | |
PLearn::LearnerCommand | |
PLearn::LearnerProcessedVMatrix | |
PLearn::LeftPseudoInverseVariable | |
PLearn::LemmatizeVMatrix | Takes a VMatrix with a word and a POS field and adds a field consisting of the lemma form of the word |
PLearn::LIBSVMSparseVMatrix | VMatrix containing data from a libsvm format file |
PLearn::LiftBinaryCostFunction | |
PLearn::LiftOutputVariable | |
PLearn::LiftStatsCollector | |
PLearn::LiftStatsIterator | |
PLearn::LimitedGaussianSmoother | |
PLearn::LinearARDKernel | Linear kernel that can be used for Automatic Relevance Determination |
PLearn::LinearCombinationModule | This module outputs a linear combination of input ports |
PLearn::LinearCombinationOfScalarVariables | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::LinearFilterModule | Affine transformation module, with stochastic gradient descent updates |
PLearn::LinearInductiveTransferClassifier | Linear classifier that uses class representations in order to make use of inductive transfer between classes |
PLearn::LinearRegressor | |
PLearn::LineOutputProgressBarPlugin | Similar to TextProgressBarPlugin with a different output format so that updates appear on different lines of output |
PLearn::LLC | |
PLearn::LLE | |
PLearn::LLEKernel | |
PLearn::LocalGaussianClassifier | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::LocalizedFeaturesLayerVariable | Single 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::LogAddVariable | Output = log(exp(input1)+exp(input2)) but it is computed in such a way as to preserve precision |
PLearn::LogInterceptorPStreamBuf | This class sends stuff to a PL_LogPluginInterceptor when it's flushed |
PLearn::LogOfGaussianDensityKernel | |
PLearn::LogRandomVariable | |
PLearn::LogSoftmaxVariable | |
PLearn::LogSoftSoftMaxVariable | Log of SoftSoftMaxVariable (see SoftSoftMaxVariable for more details) |
PLearn::LogSumVariable | |
PLearn::LogVariable | |
PLearn::ManifoldKNNDistribution | K nearest neighbors density estimator that takes into accound the local manifold structure |
PLearn::ManifoldParzen | Manifold Parzen Windows classifier and distribution |
PLearn::ManifoldParzen2 | |
PLearn::ManifoldParzenKernel | |
PLearn::ManualBinner | |
PLearn::MarginPerceptronCostVariable | |
PLearn::Matern1ARDKernel | Matern kernel with nu=1/2 that can be used for Automatic Relevance Determination |
PLearn::MatlabInterface | |
PLearn::MatrixAffineTransformFeedbackVariable | Affine transformation of a MATRIX variable |
PLearn::MatrixAffineTransformVariable | Affine transformation of a MATRIX variable |
PLearn::MatrixElementsVariable | |
PLearn::MatrixInverseVariable | |
PLearn::MatrixModule | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::MatrixOneHotSquaredLoss | |
PLearn::MatrixSoftmaxLossVariable | |
PLearn::MatrixSoftmaxVariable | |
PLearn::MatrixSumOfVariable | |
PLearn::MatRowVariable | Variable that is the row of matrix mat indexed by variable input |
PLearn::MatTPlusSumSquaredVec< MatT > | |
PLearn::Max2Variable | |
PLearn::MaxStatsIterator | |
PLearn::MaxSubsampling2DModule | Reduce the size of the 2D images by taking the max value of nearby pixels |
PLearn::MaxSubsamplingTest | Tests MaxSubsampling2DModule |
PLearn::MaxVariable | |
PLearn::MeanImputationVMatrix | Mean imputation for missing variables |
PLearn::MeanMedianModeImputationVMatrix | |
PLearn::MeanStatsIterator | |
PLearn::Measurer | |
PLearn::MemoryCachedKernel | Provide some memory-management utilities for kernels |
PLearn::MemoryStressTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::MemoryVMatrix | |
PLearn::MemoryVMatrixNoSave | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::MergeDond2Files | Generate 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::MissingInstructionVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::MixtureDistribution | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::MixtureRandomVariable | |
PLearn::MixtureVMatrix | Mixes several underlying source VMat, with ponderation |
PLearn::MixUnlabeledNeighbourVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::mNNet | Multi-layer neural network based on matrix-matrix multiplications |
PLearn::ModuleLearner | |
PLearn::ModulesLearner | Trains an OnlineLearningModule wrt the cost of a CostModule |
PLearn::ModuleStackModule | Wraps a stack of layered OnlineLearningModule into a single one |
PLearn::ModuleTester | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Molecule | A molecular surface, represented by a list of points and features on them |
PLearn::MoleculeTemplate | Subclass of Molecule, plus standard devs of points' positions and features |
PLearn::MoleculeTemplateLearner | |
PLearn::MovingAverage | This SequentialLearner only takes the n previous target to predict the next one |
PLearn::MovingAverageVMatrix | |
PLearn::MPIPStreamBuf | An implementation of the PStreamBuf interface using MPI communication |
PLearn::MRUFileList | |
PLearn::MultiClassAdaBoost | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::MulticlassErrorCostFunction | |
PLearn::MulticlassLossVariable | Cost = 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::MultiMaxVariable | This 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::MultiTaskSeparationSplitter | Splitter that removes a task for test and keeps the others for training |
PLearn::MultiToUniInstanceSelectRandomVMatrix | Selects 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::NatGradEstimator | Class 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::NatGradNNet | Multi-layer neural network trained with an efficient Natural Gradient optimization |
PLearn::NatGradSMPNNet | Multi-layer neural network trained with an efficient Natural Gradient optimization |
PLearn::NearestNeighborPredictionCost | |
PLearn::NegateElementsVariable | |
PLearn::NegCrossEntropySigmoidVariable | |
PLearn::NegKernel | |
PLearn::NegLogPoissonVariable | |
PLearn::NegLogProbCostFunction | |
PLearn::NegOutputCostFunction | This 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::NeighborhoodConditionalMean | Generate samples from a mixture of two gaussians |
PLearn::NeighborhoodImputationVMatrix | |
PLearn::NeighborhoodSmoothnessNNet | |
PLearn::NetflixVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::NetworkConnection | |
PLearn::NetworkModule | |
PLearn::NeuralNet | |
PLearn::NeuralNetworkARDKernel | Neural network kernel that can be used for Automatic Relevance Determination |
PLearn::NeuralProbabilisticLanguageModel | Feedforward neural network for language modeling |
PLearn::NGramDistribution | This class implements an ngram distribution for symbol sequence modeling |
PLearn::NGramTree | |
PLearn::NistDB | |
PLearn::NLLCostModule | Computes the NLL, given a probability vector and the true class |
PLearn::NLLErrModule | NLL (and derivatives thereof) between the target and input |
PLearn::NllGeneralGaussianVariable | |
PLearn::NLLNeighborhoodWeightsVariable | WeightsVariable updated online, based on negative log-likelihood of the neighbors |
PLearn::NllSemisphericalGaussianVariable | This class implements the negative log-likelihood cost of a Markov chain that uses semispherical gaussian transition probabilities |
PLearn::NNet | |
PLearn::NnlmOnlineLearner | Trains a Neural Network Language Model (NNLM) |
PLearn::NnlmOutputLayer | Implements a gaussian-based output layer for the Neural Network Language Model |
PLearn::NnlmWordRepresentationLayer | Implements the word representation layer for the online NNLM |
PLearn::NoBpropVariable | |
PLearn::Node | |
PLearn::NonDiagVariable | |
PLearn::NonLocalManifoldParzen | |
PLearn::NonLocalManifoldParzenKernel | |
PLearn::NonRandomVariable | |
PLearn::NoProperty | |
PLearn::NormalizationLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::NormalizedDotProductKernel | |
PLearn::NoSplitSplitter | |
PLearn::NullModule | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::NullProgressBarPlugin | Simpler plugin that doesn't display a progress bar at all |
PLearn::NullPStreamBuf | |
PLearn::NumToStringMapping | |
PLearn::NxProfileLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Object | Object is the base class of all high level PLearn objects |
PLearn::ObjectGenerator | |
PLearn::ObjectGraphIterator | An ObjectGraphIterator iterates through all objects through options |
PLearn::ObjectGraphIteratorTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ObjectOptionsIterator | An ObjectOptionsIterator iterates across all accessible sub-objects of a given PLearn::Object |
PLearn::ObjectOptionVariable | Variable which wraps an option of an object |
PLearn::ObservationWindow | Used by StatsCollector to keep a finite-size window of observations |
olist | |
PLearn::OnBagsModule | |
PLearn::OneHotSquaredLoss | Computes 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::OneHotVariable | Represents 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::OnlineGramNaturalGradientOptimizer | Implements 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::OnlineLearningModule | Learn to map inputs to outputs, online, using caller-provided gradients |
PLearn::OptimizeOptionOracle | |
PLearn::Optimizer | |
PLearn::Option< T, Enclosing > | Template class for option definitions |
PLearn::OptionBase | Base class for option definitions |
PLearn::OptionsOracle | |
PLearn::OracleObjectGenerator | |
PLearn::Other | |
PLearn::OutputFeaturesCommand | PLearn command that fills a FeatureSet with the features instantiated in a VMat |
PLearn::OutputVariable | |
PLearn::PairsVMatrix | |
PLearn::PairwiseDiffsCommand | This command computes a set of statistics (user-specified) on the pairwise differences between a given column of a list of matrices |
PLearn::Parent | |
PLearn::ParentableObject | Object which maintains a "parent" pointer as part of an object graph |
PLearn::PartsDistanceKernel | This class implements an Ln distance (defaults to L2 i.e. euclidean distance) |
PLearn::PartSupervisedDBN | Hinton's DBN plus supervised gradient from a logistic regression layer |
PLearn::ParzenWindow | |
PLearn::PCA | |
PLearn::PConditionalDistribution | |
PLearn::PDate | |
PLearn::PDateTime | |
PLearn::PDistribution | Base class for PLearn probability distributions |
PLearn::PDistributionVariable | |
PLearn::PentaTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PerformanceEvaluator | Evaluates 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_fdstreambuf | Pl_fdstreambuf: stream buffer that acts on a POSIX file descriptor |
PLearn::PL_Log | |
PLearn::PL_LogPlugin | Provides several back-ends for displaying the log messages |
PLearn::PL_LogPluginInterceptor | Forward declare |
PLearn::PL_LogPluginPStream | Default implementation of PL_LogPlugin :: outputs to specified PStream (perr by default) |
PLearn::PL_LogPluginServer | Server 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::PLCheckTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PLearnCommand | This is the base class for all PLearn commands (those that can be issued in the plearn program) |
PLearn::PLearnCommandRegistry | |
PLearn::PLearnDiff | |
PLearn::PLearner | The base class for learning algorithms, which should be the main "products" of PLearn |
PLearn::PLearnerDiagonalKernel | Diagonal kernel from the output of a PLearner |
PLearn::PLearnerOutputVMatrix | |
PLearn::PLearnError | |
PLearn::PLearnInit | |
PLearn::PLearnServer | |
PLearn::PLearnService | |
PLearn::PLGaussQuantileInitializer | |
PLearn::Plide | Command to start the PLearn Integrated Development Environment (PLIDE) |
PLearn::PlideLogPlugin | This plugin connects the logging mechanism to PlideLogPStreamBuf |
PLearn::PlideLogPStreamBuf | This class sends stuff to the PlideLog when it's flushed |
PLearn::PlideProgressPlugin | |
PLearn::PLLogTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PLMathInitializer | |
PLearn::PLMathTest | The 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::PLogPVariable | Returns 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::PLStringutilsTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PlusColumnVariable | Adds a single-column var to each column of a matrix var |
PLearn::PlusConstantVariable | Adds a scalar constant to a matrix var |
PLearn::PlusManyVariable | |
PLearn::PlusRandomVariable | |
PLearn::PlusRowVariable | Adds a single-row var to each row of a matrix var |
PLearn::PlusScalarVariable | Adds a scalar var to a matrix var |
PLearn::PlusVariable | Adds 2 matrix vars of same size |
PLearn::PMemArena | A PMemArena is a fixed-size contiguous block of memory for allocating objects of the SAME SIZE |
PLearn::PMemPool | A 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::Poll | A class for polled IO with PStreams |
PLearn::PolynomialKernel | |
PLearn::Popen | |
PLearn::PotentialsVariable | |
PLearn::PowDistanceKernel | |
PLearn::PowVariable | Elementwise pow (returns 0 wherever input is negative) |
PLearn::PowVariableVariable | |
PLearn::PP< T > | |
PLearn::PPath | |
PLearn::PPathTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PPointable | |
PLearn::PPointableSet | |
PLearn::PPTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PRandom | Important note: the pointers used for some Boost distribution objects are meant to save memory |
PLearn::PRange< T > | |
PLearn::PrecomputedKernel | A kernel that precomputes the kernel matrix as soon as setDataForKernelMatrix is called |
PLearn::PrecomputedProcessedLearner | Identity Learner with a cached 'processDataSet' method |
PLearn::PrecomputedVMatrix | |
PLearn::Preprocessing | Generate 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::ProbabilityPairsVariable | Let 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::ProcessInputCostModule | Processes the input through an embedded OnlineLearningModule |
PLearn::ProcessSymbolicSequenceVMatrix | This VMatrix takes a VMat of a sequence of symbolic elements (corresponding to a set of symbolic attributes) and constructs context rows |
PLearn::ProductRandomVariable | |
PLearn::ProductTransposeVariable | Matrix product between matrix1 and transpose of matrix2 |
PLearn::ProductVariable | Matrix product |
PLearn::Profiler | Profiling tools, to count average time elapsed and number of times traversed for pieces of code delimited by two calls to the static functions |
PLearn::ProgressBar | This class will help you display progress of a calculation |
PLearn::ProgressBarPlugin | Base class for pb plugins |
PLearn::ProjectionErrorVariable | The 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::PrPStreamBuf | An implementation of the PStreamBuf interface using Mozilla's NSPR library |
PLearn::PruningLinearRegressor | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PseudolikelihoodRBM | Restricted Boltzmann Machine trained by (generalized) pseudolikelihood |
PLearn::PSMat | |
PLearn::PStream | |
PLearn::PStreamBuf | |
PLearn::PStreamBufTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PTest | |
PLearn::PTester | This code is deprecated, use PTester.h and PTester.cc instead |
PLearn::PTimer | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PutSubVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::PvGradNNet | Multi-layer neural network based on matrix-matrix multiplications |
PLearn::PyPLearnScript | |
PLearn::PythonCodeSnippet | Enables embedded Python code to be called from PLearn/C++ code |
PLearn::PythonEmbedder | Include this file when you want to embed the Python interpreter |
PLearn::PythonException | C++ Exception object to which Python exceptions are mapped |
PLearn::PythonFeatureSet | FeatureSet with features being defined using a python script |
PLearn::PythonGlobalInterpreterLock | Ensure thread safety by managing the Python Global Interpreter Lock |
PythonGlobalInterpreterLock | Ensure thread safety by managing the Python Global Interpreter Lock |
PLearn::PythonObjectWrapper | Very lightweight wrapper over a Python Object that allows conversion to/from C++ types (including those of PLearn) |
PLearn::PythonProcessedLearner | Allows preprocessing operations to be carried out by a Python code snippet |
PLearn::PythonProcessedVMatrix | Preprocess a source VMatrix using a Python code snippet |
PLearn::PythonTableVMatrix | |
PLearn::QuadraticUtilityCostFunction | |
PLearn::QuantilesStatsIterator | |
PLearn::RandomElementOfRandomVariable | RandomVariable that is the element of the first parent RandomVariable indexed by the second parent RandomVariable |
PLearn::RandomForcedValuesVariable | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RandomGaussMix | |
PLearn::RandomNeighborsDifferencesVMatrix | |
PLearn::RandomSamplesFromVMatrix | VMatrix that contains random samples from a VMatrix |
PLearn::RandomSamplesVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RandomVar | We follow the same pattern as Var & Variable |
PLearn::RandomVariable | |
PLearn::RandomVarVMatrix | This is a convenient wrapping around the required data structures for efficient repeated sampling from a RandomVar |
PLearn::Range | |
PLearn::RangeVMatrix | Outputs scalar samples (length 1) starting at start, up to end (inclusive) with step. When end is reached it starts over again |
PLearn::RankedVMatrix | |
PLearn::RankingFromKernel | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RankLearner | |
PLearn::RationalQuadraticARDKernel | Rational-Quadratic kernel that can be used for Automatic Relevance Determination |
PLearn::RBMBinomialLayer | Layer in an RBM formed with binomial units |
PLearn::RBMClassificationModule | Computes the undirected softmax used in deep belief nets |
PLearn::RBMConnection | Virtual class for the parameters between two layers of an RBM |
PLearn::RBMConv2DConnection | Filter between two linear layers of a 2D convolutional RBM |
PLearn::RBMConv2DLLParameters | Filter between two linear layers of a 2D convolutional RBM |
PLearn::RBMDiagonalMatrixConnection | Stores and learns the parameters between two linear layers of an RBM |
PLearn::RBMDistribution | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RBMGaussianLayer | Layer in an RBM formed with binomial units |
PLearn::RBMGenericParameters | Stores and learns the parameters between two layers of an RBM |
PLearn::RBMJointGenericParameters | Stores and learns the parameters between two layers of an RBM |
PLearn::RBMJointLLParameters | Stores and learns the parameters between two layers of an RBM |
PLearn::RBMLateralBinomialLayer | Layer in an RBM formed with binomial units, with lateral connections |
PLearn::RBMLayer | Virtual class for a layer in an RBM |
PLearn::RBMLLParameters | Stores and learns the parameters between two linear layers of an RBM |
PLearn::RBMLocalMultinomialLayer | Multiple multinomial units, each of them seeing an area of nearby pixels |
PLearn::RBMLQParameters | Stores and learns the parameters between one quadratic layer and one linear layer of an RBM |
PLearn::RBMMatrixConnection | Stores and learns the parameters between two linear layers of an RBM |
PLearn::RBMMatrixConnectionNatGrad | Stores and learns the parameters between two linear layers of an RBM |
PLearn::RBMMatrixTransposeConnection | RBMConnection which uses the tranpose of some other RBMMatrixConnection's weights |
PLearn::RBMMixedConnection | Contains a matrix of other RBMConnections, acting as submatrix of the linear transformation this class computes |
PLearn::RBMMixedLayer | Layer in an RBM formed with binomial units |
PLearn::RBMModule | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RBMMultinomialLayer | Layer in an RBM formed with binomial units |
PLearn::RBMMultitaskClassificationModule | Computes a mean-field approximate of p(y|x), with y a binary vector |
PLearn::RBMParameters | Virtual class for the parameters between two layers of an RBM |
PLearn::RBMQLParameters | Stores and learns the parameters between one quadratic layer and one linear layer of an RBM |
PLearn::RBMRateLayer | Layer in an RBM consisting in rate-coded units |
PLearn::RBMSparse1DMatrixConnection | Stores and learns the parameters between two linear layers of an RBM |
PLearn::RBMTrainer | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RBMTruncExpLayer | Layer in an RBM formed with binomial units |
PLearn::RBMWoodsLayer | RBM layer with tree-structured groups of units |
PLearn::ReadAndWriteCommand | |
PLearn::RealFunction | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RealFunctionFromKernel | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RealFunctionOfInputFeature | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RealFunctionProduct | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RealFunctionsProcessedVMatrix | |
PLearn::RealMapping | Mapping between ranges and values |
PLearn::RealRange | Real range: i.e. one of ]low,high[ ; [low,high[; [low,high]; ]low,high] |
PLearn::RealRangeIndicatorFunction | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RealValueIndicatorFunction | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ReconstructionCandidate | Description 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::RegressorFromDistribution | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RegularGridVMatrix | |
PLearn::ReIndexedTargetVariable | |
PLearn::ReIndexedTargetVMatrix | VMatrix 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::RemoteMethodDoc | Documentation holder for a remote method |
PLearn::RemoteMethodMap | Map for determining a trampoline from a method-name+arity |
PLearn::RemotePLearnServer | |
PLearn::RemoteProgressBarPlugin | Similar to TextProgressBarPlugin with a different output format so that remote servers can update progress bars on a client |
PLearn::RemoteTrampoline | Base 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::RemoveObservationTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RemoveRowsVMatrix | Sees an underlying VMat with the specified rows excluded |
PLearn::ReorderByMissingVMatrix | Re-order samples in a source VMat by their missing attributes |
PLearn::RepeatSplitter | |
PLearn::RepeatVMatrix | |
PLearn::ReplicateSamplesVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ReshapeVariable | Variable that views another variable, but with a different length() and width() (the only restriction being that length()*width() remain the same) |
PLearn::ResourceSemaphore | |
PLearn::RetDoc | Documentation for a remote method return value |
PLearn::RetTypeDoc | Documentation for a method return type (just contains the type as a string) |
PLearn::ReverseMatT< MatT > | |
PLearn::RGB | |
PLearn::RGBImage | Uses 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::RowBufferedVMatrixTest | The 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::RowSumVariable | Result is a single column that contains the sum of each row of the input |
PLearn::RPPath | |
PLearn::RunCommand | |
PLearn::RunICPVariable | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::RunObject | |
PLearn::RVArray | An RVArray stores a table of RandomVar's |
PLearn::RVArrayRandomElementRandomVariable | |
PLearn::RVInstance | RVInstance represents a RandomVariable V along with a "value" v |
PLearn::RVInstanceArray | |
PLearn::SaltPepperNoiseVariable | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ScaledConditionalCDFSmoother | |
PLearn::ScaledGaussianKernel | Returns exp(-sum_i[(phi_i*(x1_i - x2_i))^2]/sigma^2) |
PLearn::ScaledGeneralizedDistanceRBFKernel | Returns exp(-(sum_i phi_i*[abs(x1_i^a - x2_i^a)^b])^c) |
PLearn::ScaledLaplacianKernel | Returns exp(-(sum_i[abs(x1_i - x2_i)*phi_i])) |
PLearn::ScaleGradientModule | Scales (or suppress) the gradient that is backpropagated |
PLearn::Schema | |
PLearn::ScoreLayerVariable | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SDBVMatrix | |
PLearn::SDBVMField | |
PLearn::SDBVMFieldAffine | Apply an affine transformation to the field: y = a*x+b |
PLearn::SDBVMFieldAsIs | Pass through the value within the SDB (after conversion to real of the underlying SDB type) |
PLearn::SDBVMFieldCodeAsIs | |
PLearn::SDBVMFieldDate | Convert a date to fill 3 columns in the VMat: YYYY, MM, DD |
PLearn::SDBVMFieldDateDiff | Difference between two dates ("source1-source2" expressed as an integer number of days, months, or years) |
PLearn::SDBVMFieldDateGreater | Verifies if the date within the row is greater than a threshold date |
PLearn::SDBVMFieldDay | |
PLearn::SDBVMFieldDiscrete | A field that recodes its source field according to an OutputCoder object |
PLearn::SDBVMFieldDivSigma | Just divide by standard deviation |
PLearn::SDBVMFieldFunc1 | |
PLearn::SDBVMFieldFunc2 | |
PLearn::SDBVMFieldHasClaim | |
PLearn::SDBVMFieldICBCClassification | |
PLearn::SDBVMFieldICBCTargets | |
PLearn::SDBVMFieldMonths | Computed year*12+(month-1) |
PLearn::SDBVMFieldMultiDiscrete | |
PLearn::SDBVMFieldNormalize | Normalize the field (subtract the mean then divide by standard dev) |
PLearn::SDBVMFieldPosAffine | Take the positive part of the field, followed by affine transformation: y = a*max(x,0)+b |
PLearn::SDBVMFieldRemapIntervals | |
PLearn::SDBVMFieldRemapReals | |
PLearn::SDBVMFieldRemapStrings | |
PLearn::SDBVMFieldSignedPower | Do the following : y = x^a |
PLearn::SDBVMFieldSource1 | A field that maps exactly 1 SDB field to a VMatrix segment (abstract) |
PLearn::SDBVMFieldSource2 | A field that maps exactly 2 SDB fields to a VMatrix segment (abstract) |
PLearn::SDBVMFieldSumClaims | |
PLearn::SDBVMOutputCoder | |
PLearn::SDBVMSource | A 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::SelectColumnsVMatrix | Selects variables (columns) from a source matrix according to given vector of indices |
PLearn::SelectedIndicesCmp< T > | |
PLearn::SelectedOutputCostFunction | This 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::SelectRowsMultiInstanceVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SelectRowsVMatrix | Selects samples from a source matrix according to given vector of indices |
PLearn::SelectSetsSplitter | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SemId | This 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::SemiSupervisedDBN | Deep Belief Net, possibly supervised, trained only with CD |
PLearn::SemiSupervisedProbClassCostVariable | |
PLearn::semun | |
PLearn::SentencesBlocks | |
PLearn::SeparateInputVMatrix | Separates 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::ShiftAndRescaleFeatureRealFunction | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ShiftAndRescaleVMatrix | |
PLearn::short_and_twobytes | |
PLearn::ShuffleColumnsVMatrix | |
PLearn::ShuntingNNetLayerModule | Affine transformation module, with stochastic gradient descent updates |
PLearn::SigmoidalKernel | Returns sigmoid(c*x1.x2) |
PLearn::SigmoidPrimitiveKernel | Returns log(1+exp(c*x1.x2)) = primitive of sigmoidal kernel |
PLearn::SigmoidVariable | |
PLearn::SignVariable | Sign(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::SoftmaxModule | Computes the softmax function on a vector |
PLearn::SoftmaxNLLCostModule | Computes the NLL, given a probability vector and the true class |
PLearn::SoftmaxVariable | |
PLearn::SoftplusVariable | |
PLearn::SoftSlopeIntegralVariable | |
PLearn::SoftSlopeVariable | |
PLearn::SoftSoftMaxVariable | Kind of SoftMax |
PLearn::SortRowsVMatrix | Sort the samples of a VMatrix according to one (or more) given columns |
PLearn::SourceKernel | |
PLearn::SourceSampleVariable | |
PLearn::SourceVariable | |
PLearn::SourceVMatrix | |
PLearn::SourceVMatrixSplitter | |
PLearn::SparseIncrementalAffineTransformVariable | Affine 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::SplitModule | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Splitter | This class is an abstract base class for mechanisms allowing to "split" a dataset into one or several partitions (or "splits") |
PLearn::SplitWiseValidationVMatrix | VMatrix that takes several experiment split_stats.pmat to extract the split statistics and perform validation |
PLearn::SquaredErrModule | Squared difference (and derivatives thereof) between the target and input |
PLearn::SquaredErrorCostFunction | ********************************************************* The following 'kernels' are rather used as cost functions |
PLearn::SquaredErrorCostModule | Computes the sum of squared difference between input and target |
PLearn::SquaredExponentialARDKernel | Squared-Exponential kernel that can be used for Automatic Relevance Determination |
PLearn::SquaredSymmMatT< MatT > | |
PLearn::SquareRootVariable | |
PLearn::SquareVariable | |
PLearn::StabilisationLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::StackedAutoassociatorsNet | Neural net, trained layer-wise in a greedy fashion using autoassociators |
PLearn::StackedFocusedAutoassociatorsNet | Neural net, trained layer-wise in a greedy but focused fashion using autoassociators/RBMs and a supervised non-parametric gradient |
PLearn::StackedLearner | |
PLearn::StackedModulesLearner | Trains a stack of OnlineLearningModule, which are layers |
PLearn::StackedModulesModule | Wraps a stack of OnlineLearningModule, which are layers |
PLearn::StackedSplitter | |
PLearn::StackedSVDNet | Neural net, initialized with SVDs of logistic auto-regressions |
PLearn::Stan | The 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::StaticInitializer | A 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::StatsCommand | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::StatsItArray | |
PLearn::StatsIterator | |
PLearn::StatSpec | The specification of a statistic to compute (as can be specified as a string in PTester) |
PLearn::StddevStatsIterator | |
PLearn::StderrStatsIterator | |
PLearn::StdPStreamBuf | |
PLearn::StepwiseSelectionOracle | This oracle implements a stepwise forward variable selection procedure |
PLearn::StochasticBinarizeVMatrix | The 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::StructuralLearner | Putain de code fait à la va-vite pour ICML |
PLearn::SubInputVMatrix | |
PLearn::SubMatTransposeVariable | |
PLearn::SubMatVariable | Takes a submatrix of an input variable |
PLearn::SubsampleVariable | A subsample var; equals subrample(input, the_subsamplefactor) |
PLearn::Subsampling2DModule | Reduce the size of the 2D images by adding the values of nearby pixels |
PLearn::SubsamplingDBN | Neural net, learned layer-wise in a greedy fashion |
PLearn::SubVecRandomVariable | Y = sub-vector of X starting at position "start", of length "value->length()" |
PLearn::SubVMatrix | |
PLearn::SumAbsVariable | |
PLearn::SumEntropyOfBernoullis | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SumEntropyOfCategoricals | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SummationKernel | Kernel computing the sum of other kernels |
PLearn::SumOfVariable | Sums the value of a Function evaluated on each row of a VMatrix |
PLearn::SumOverBagsVariable | |
PLearn::SumSquareVariable | |
PLearn::SumVariable | Compute the sum of all elements in the input Var |
PLearn::SumVarianceOfLinearTransformedBernoullis | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SumVarianceOfLinearTransformedCategoricals | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Supersampling2DModule | Augment the size of 2D images by duplicating pixels |
PLearn::SupervisedDBN | Hinton's DBN plus supervised gradient from a logistic regression layer but without joint layer on top |
PLearn::SurfaceMesh | |
PLearn::SurfaceTemplateLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::SVDVariable | |
PLearn::SVMClassificationTorch | |
PLearn::Symbol | |
PLearn::SymbolNode | |
PLearn::TangentLearner | |
PLearn::TanhModule | This class propagates a (possibly scaled) 'tanh' function |
PLearn::TanhVariable | |
PLearn::TargetEncodingLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Template | |
PLearn::TemporalHorizonVMatrix | This VMat delay the last targetsize entries of a source VMat by a certain horizon |
PLearn::TemporaryDiskVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::TemporaryFileVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Test_PP | |
PLearn::TestClientCommand | |
PLearn::TestDependenciesCommand | |
PLearn::TestDependencyCommand | |
PLearn::TestImputations | Generate samples from a mixture of two gaussians |
PLearn::TestingLearner | |
PLearn::TestInTrainSplitter | |
PLearn::TestLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::TestMethod | |
PLearn::TestSnippet | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::TextFilesVMatrix | |
PLearn::TextProgressBarPlugin | Simple plugin for displaying text progress bar |
PLearn::TextSenseSequenceVMatrix | This 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::TimesConstantScalarVariable2 | Multiplies a matrix var by a scalar var |
PLearn::TimesConstantVariable | Multiplies a matrix var by a scalar constant |
PLearn::TimesRowVariable | |
PLearn::TimesScalarVariable | Multiplies a matrix var by a scalar var |
PLearn::TimesVariable | Multiplies 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::TMatTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::TmpFilenames | |
PLearn::ToBagClassifier | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ToBagSplitter | |
PLearn::TopDownAsymetricDeepNetwork | Neural 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::TransformOutputLearner | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::TransparentParentable | Special type of ParentableObject that cannot act as a visible parent |
PLearn::TransposedDoubleProductVariable | Let W, M and H be the inputs and nw the length of W |
PLearn::TransposeProductVariable | Matrix product between transpose of matrix1 and matrix2 |
PLearn::TransposeVariable | |
PLearn::TransposeVMatrix | |
PLearn::TreeDBNModule | |
PLearn::tRule | |
PLearn::TruncatedRealFunction | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::TTensor< T > | |
PLearn::TTensorElementIterator< T > | |
PLearn::TTensorSubTensorIterator< T > | |
PLearn::TupleTest | The 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::TypeFactory | Create new objects given their type name (as a string) |
PLearn::TypeMapEntry | Description 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::UndirectedSoftmaxModule | This class |
PLearn::UnequalConstantVariable | A scalar var; equal 1 if input1!=c, 0 otherwise |
PLearn::UnfoldedFuncVariable | |
PLearn::UnfoldedSumOfVariable | |
PLearn::UnfrozenDeepBeliefNet | Does 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::ValueSelectRowsVMatrix | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::Var | |
PLearn::VarArray | |
PLearn::VarArrayElementVariable | Variable 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::VariablesTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::VarMeasurer | |
PLearn::VarRowsVariable | |
PLearn::VarRowVariable | Variable that is the row of the input1 variable indexed by the input2 variable |
PLearn::VarUtilsTest | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::VBoundDBN2 | 2-RBM DBN trained using Hinton's new variational bound of global likelihood: |
PLearn::VecCompressor | |
PLearn::VecDictionary | |
PLearn::VecElementVariable | Variable that is the element of vector vec indexed by variable input |
PLearn::VecExtendedVMatrix | |
PLearn::VecStatsCollector | |
PLearn::VerifyGradientCommand | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::ViewSplitterVMatrix | |
PLearn::VMat | |
PLearn::VMatAccessBuffer | Simple buffer class for getRow calls on a VMat |
PLearn::VMatCommand | |
PLearn::VMatDictionaryCommand | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::VMatKernel | |
PLearn::VMatLanguage | |
PLearn::VMatrix | Base classes for virtual matrices |
PLearn::VMatrixExtensionRegistrar | Extension registrar for new file types |
PLearn::VMatrixFromDistribution | |
PLearn::VMatViewCommand | The first sentence should be a BRIEF DESCRIPTION of what the class does |
PLearn::VMField | VMField contains a fieldname and a fieldtype |
PLearn::VMFieldStat | This class holds simple statistics about a field |
PLearn::VPLCombinedLearner | |
PLearn::VPLPreprocessedLearner | |
PLearn::VPLPreprocessedLearner2 | |
PLearn::VPLProcessor | |
PLearn::VVec | A VVec is a reference to a row or part of a row (a subrow) of a VMatrix |
PLearn::VVMatrix | This class is a wrapper for a .vmat VMatrix |
PLearn::WeightedCostFunction | A 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::WeightedDistance | This class implements an Ln distance (defaults to L2 i.e. euclidean distance) |
PLearn::WeightedLogGaussian | |
PLearn::WeightedQuadraticPolynomialKernel | |
PLearn::WeightedSumSquareVariable | |
PLearn::wordAndFreq | Used to sort words according to frequency, when determining candidates |
PLearn::wordAndProb | Used to sort words according to probability |
PLearn::WordNetFeatureSet | FeatureSet with features from WordNet |
PLearn::WordNetOntology | |
PLearn::WordNetSenseDictionary | |
PLearn::WPLS | |
X | |
PLearn::X | |
PLearn::Y | |
PLearn::YMDDatedVMatrix | |
PLearn::Z | |