Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
de.jstacs.models.Model

Packages that use Model
de.jstacs.classifier.assessment | This package allows to assess classifiers.
de.jstacs.classifier.modelBased | Provides the classes for `Classifier`s that are based on `Model`s
de.jstacs.models | Provides the interface `Model` and its abstract implementation `AbstractModel`, which is the super class of all other models.
de.jstacs.models.discrete |
de.jstacs.models.discrete.homogeneous |
de.jstacs.models.discrete.inhomogeneous | This package contains various inhomogeneous models.
de.jstacs.models.discrete.inhomogeneous.shared |
de.jstacs.models.hmm | The package provides all interfaces and classes for a hidden Markov model (HMM).
de.jstacs.models.hmm.models | The package provides different implementations of hidden Markov models based on `AbstractHMM`
de.jstacs.models.mixture | This package is the super package for any mixture model.
de.jstacs.models.mixture.motif |
de.jstacs.models.utils |

Uses of Model in de.jstacs.classifier.assessment

Fields in de.jstacs.classifier.assessment declared as Model
`protected Model[][]` | `ClassifierAssessment.myModel` This array contains for each class the internal used models.

Constructors in de.jstacs.classifier.assessment with parameters of type Model
`ClassifierAssessment(AbstractClassifier[] aCs, boolean buildClassifiersByCrossProduct, Model[]... aMs)` This constructor allows to assess a collection of given `AbstractClassifier`s and, in addition, classifiers that will be constructed using the given `AbstractModel`s.
`ClassifierAssessment(AbstractClassifier[] aCs, Model[][] aMs, boolean buildClassifiersByCrossProduct, boolean checkAlphabetConsistencyAndLength)` Creates a new `ClassifierAssessment` from an array of `AbstractClassifier`s and a two-dimensional array of `Model` s, which are combined to additional classifiers.
`ClassifierAssessment(boolean buildClassifiersByCrossProduct, Model[]... aMs)` Creates a new `ClassifierAssessment` from a set of `Model`s.
`KFoldCrossValidation(AbstractClassifier[] aCs, boolean buildClassifiersByCrossProduct, Model[]... aMs)` This constructor allows to assess a collection of given `AbstractClassifier`s and those constructed using the given `AbstractModel`s by a `KFoldCrossValidation` .
`KFoldCrossValidation(AbstractClassifier[] aCs, Model[][] aMs, boolean buildClassifiersByCrossProduct, boolean checkAlphabetConsistencyAndLength)` Creates a new `KFoldCrossValidation` from an array of `AbstractClassifier`s and a two-dimensional array of `Model` s, which are combined to additional classifiers.
`KFoldCrossValidation(boolean buildClassifiersByCrossProduct, Model[]... aMs)` Creates a new `KFoldCrossValidation` from a set of `Model`s.
`RepeatedHoldOutExperiment(AbstractClassifier[] aCs, boolean buildClassifiersByCrossProduct, Model[]... aMs)` This constructor allows to assess a collection of given `AbstractClassifier`s and those constructed using the given `AbstractModel`s by a `RepeatedHoldOutExperiment`.
`RepeatedHoldOutExperiment(AbstractClassifier[] aCs, Model[][] aMs, boolean buildClassifiersByCrossProduct, boolean checkAlphabetConsistencyAndLength)` Creates a new `RepeatedHoldOutExperiment` from an array of `AbstractClassifier`s and a two-dimensional array of `Model` s, which are combined to additional classifiers.
`RepeatedHoldOutExperiment(boolean buildClassifiersByCrossProduct, Model[]... aMs)` Creates a new `RepeatedHoldOutExperiment` from a set of `Model`s.
`RepeatedSubSamplingExperiment(AbstractClassifier[] aCs, boolean buildClassifiersByCrossProduct, Model[]... aMs)` This constructor allows to assess a collection of given `AbstractClassifier`s and those constructed using the given `AbstractModel`s by a `RepeatedSubSamplingExperiment`.
`RepeatedSubSamplingExperiment(AbstractClassifier[] aCs, Model[][] aMs, boolean buildClassifiersByCrossProduct, boolean checkAlphabetConsistencyAndLength)` Creates a new `RepeatedSubSamplingExperiment` from an array of `AbstractClassifier`s and a two-dimensional array of `Model` s, which are combined to additional classifiers.
`RepeatedSubSamplingExperiment(boolean buildClassifiersByCrossProduct, Model[]... aMs)` Creates a new `RepeatedSubSamplingExperiment` from a set of `Model`s.
`Sampled_RepeatedHoldOutExperiment(AbstractClassifier[] aCs, boolean buildClassifiersByCrossProduct, Model[]... aMs)` This constructor allows to assess a collection of given `AbstractClassifier`s and those constructed using the given `AbstractModel`s by a `Sampled_RepeatedHoldOutExperiment`.
`Sampled_RepeatedHoldOutExperiment(AbstractClassifier[] aCs, Model[][] aMs, boolean buildClassifiersByCrossProduct, boolean checkAlphabetConsistencyAndLength)` Creates a new `Sampled_RepeatedHoldOutExperiment` from an array of `AbstractClassifier`s and a two-dimensional array of `Model` s, which are combined to additional classifiers.
`Sampled_RepeatedHoldOutExperiment(boolean buildClassifiersByCrossProduct, Model[]... aMs)` Creates a new `Sampled_RepeatedHoldOutExperiment` from a set of `Model`s.

Uses of Model in de.jstacs.classifier.modelBased

Fields in de.jstacs.classifier.modelBased declared as Model
`protected Model[]` | `ModelBasedClassifier.models` The internal `Model`s.

Methods in de.jstacs.classifier.modelBased that return Model
`Model` | `ModelBasedClassifier.getModel(int classIndex)` Returns a clone of the `Model` for a specified class.

Methods in de.jstacs.classifier.modelBased with parameters of type Model
`static int` | `ModelBasedClassifier.getPossibleLength(Model... models)` This method returns the possible length of a classifier that would use the given `Model`s.

Constructors in de.jstacs.classifier.modelBased with parameters of type Model
`ModelBasedClassifier(boolean cloneModels, Model... models)` This constructor creates a new instance with the given `Model`s and clones these if necessary.
`ModelBasedClassifier(Model... models)` The default constructor that creates a new instance with the given `Model`s.

Uses of Model in de.jstacs.models

Classes in de.jstacs.models that implement Model
`class` | `AbstractModel` Abstract class for a model for pattern recognition.
`class` | `CompositeModel` This class is for modelling sequences by modelling the different positions of the each sequence by different models.
`class` | `NormalizableScoringFunctionModel` This model can be used to use a NormalizableScoringFunction as model.
`class` | `UniformModel` This class represents a uniform model.
`class` | `VariableLengthWrapperModel` This class allows to train any `Model` on `Sample`s of `Sequence`s with variable length if each individual length is at least `getLength()`.

Fields in de.jstacs.models declared as Model
`protected Model[]` | `CompositeModel.models` The models for the components

Methods in de.jstacs.models that return Model
`Model` | `Model.clone()` Creates a clone (deep copy) of the current `Model` instance.
`Model[]` | `CompositeModel.getModels()` Returns the a deep copy of the models.

Methods in de.jstacs.models with parameters of type Model
`static MixtureModel` | `ModelFactory.createMixtureModel(double[] hyper, Model[] model)` This method allows to create a `MixtureModel` that allows to model a `Sample` as a mixture of individual components.
`static StrandModel` | `ModelFactory.createStrandModel(Model model)` This method allows to create a `StrandModel` that allows to score binding sites on both strand of DNA.
`static SingleHiddenMotifMixture` | `ModelFactory.createZOOPS(Model motif, Model bg, double[] hyper, boolean trainOnlyMotifModel)` This method allows to create a "zero or one occurrence per sequence" (ZOOPS) model that allows to discovers binding sites in a `Sample`.

Constructors in de.jstacs.models with parameters of type Model
`CompositeModel(AlphabetContainer alphabets, int[] assignment, Model... models)` Creates a new `CompositeModel`.
`VariableLengthWrapperModel(Model m)` This is the main constructor that creates an instance from any `Model`.

Uses of Model in de.jstacs.models.discrete

Classes in de.jstacs.models.discrete that implement Model
`class` | `DiscreteGraphicalModel` This is the main class for all discrete graphical models (DGM).

Uses of Model in de.jstacs.models.discrete.homogeneous

Classes in de.jstacs.models.discrete.homogeneous that implement Model
`class` | `HomogeneousMM` This class implements homogeneous Markov models (hMM) of arbitrary order.
`class` | `HomogeneousModel` This class implements homogeneous models of arbitrary order.

Uses of Model in de.jstacs.models.discrete.inhomogeneous

Classes in de.jstacs.models.discrete.inhomogeneous that implement Model
`class` | `BayesianNetworkModel` The class implements a Bayesian network ( `StructureLearner.ModelType.BN` ) of fixed order.
`class` | `DAGModel` The abstract class for directed acyclic graphical models (`DAGModel`).
`class` | `FSDAGModel` This class can be used for any discrete fixed structure directed acyclic graphical model ( `FSDAGModel`).
`class` | `FSDAGModelForGibbsSampling` This is the class for a fixed structure directed acyclic graphical model (see `FSDAGModel`) that can be used in a Gibbs sampling.
`class` | `InhomogeneousDGM` This class is the main class for all inhomogeneous discrete graphical models (`InhomogeneousDGM`).

Methods in de.jstacs.models.discrete.inhomogeneous with parameters of type Model
`static void` | `FSDAGModel.train(Model[] models, int[][] graph, double[][] weights, Sample... data)` Computes the models with structure `graph`.

Uses of Model in de.jstacs.models.discrete.inhomogeneous.shared

Classes in de.jstacs.models.discrete.inhomogeneous.shared that implement Model
`class` | `SharedStructureMixture` This class handles a mixture of models with the same structure that is learned via EM.

Uses of Model in de.jstacs.models.hmm

Classes in de.jstacs.models.hmm that implement Model
`class` | `AbstractHMM` This class is the super class of all implementations hidden Markov models (HMMs) in Jstacs.

Uses of Model in de.jstacs.models.hmm.models

Classes in de.jstacs.models.hmm.models that implement Model
`class` | `DifferentiableHigherOrderHMM` This class combines an `HigherOrderHMM` and a `NormalizableScoringFunction` by implementing some of the declared methods.
`class` | `HigherOrderHMM` This class implements a higher order hidden Markov model.
`class` | `SamplingHigherOrderHMM`
`class` | `SamplingPhyloHMM` This class implements an (higher order) HMM that contains multi-dimensional emissions described by a phylogenetic tree.

Uses of Model in de.jstacs.models.mixture

Classes in de.jstacs.models.mixture that implement Model
`class` | `AbstractMixtureModel` This is the abstract class for all kinds of mixture models.
`class` | `MixtureModel` The class for a mixture model of any `Model`s.
`class` | `StrandModel` This model handles sequences that can either lie on the forward strand or on the reverse complementary strand.

Fields in de.jstacs.models.mixture declared as Model
`protected Model[]` | `AbstractMixtureModel.alternativeModel` The alternative models for the EM.
`protected Model[]` | `AbstractMixtureModel.model` The model for the sequences.

Methods in de.jstacs.models.mixture that return Model
`Model` | `AbstractMixtureModel.getModel(int i)` Returns a deep copy of the `i`-th model.
`Model[]` | `AbstractMixtureModel.getModels()` Returns a deep copy of the models.

Constructors in de.jstacs.models.mixture with parameters of type Model
`AbstractMixtureModel(int length, Model[] models, boolean[] optimizeModel, int dimension, int starts, boolean estimateComponentProbs, double[] componentHyperParams, double[] weights, AbstractMixtureModel.Algorithm algorithm, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates a new `AbstractMixtureModel`.
`MixtureModel(int length, Model[] models, double[] weights, int starts, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization)` Creates an instance using EM and fixed component probabilities.
`MixtureModel(int length, Model[] models, double[] weights, int starts, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates an instance using Gibbs Sampling and fixed component probabilities.
`MixtureModel(int length, Model[] models, int starts, boolean estimateComponentProbs, double[] componentHyperParams, double[] weights, AbstractMixtureModel.Algorithm algorithm, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates a new `MixtureModel`.
`MixtureModel(int length, Model[] models, int starts, double[] componentHyperParams, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization)` Creates an instance using EM and estimating the component probabilities.
`MixtureModel(int length, Model[] models, int starts, double[] componentHyperParams, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates an instance using Gibbs Sampling and sampling the component probabilities.
`StrandModel(Model model, int starts, boolean estimateComponentProbs, double[] componentHyperParams, double forwardStrandProb, AbstractMixtureModel.Algorithm algorithm, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates a new `StrandModel`.
`StrandModel(Model model, int starts, double[] componentHyperParams, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization)` Creates an instance using EM and estimating the component probabilities.
`StrandModel(Model model, int starts, double[] componentHyperParams, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates an instance using Gibbs Sampling and sampling the component probabilities.
`StrandModel(Model model, int starts, double forwardStrandProb, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization)` Creates an instance using EM and fixed component probabilities.
`StrandModel(Model model, int starts, double forwardStrandProb, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates an instance using Gibbs Sampling and fixed component probabilities.

Uses of Model in de.jstacs.models.mixture.motif

Classes in de.jstacs.models.mixture.motif that implement Model
`class` | `HiddenMotifMixture` This is the main class that every generative motif discoverer should implement.
`class` | `SingleHiddenMotifMixture` This class enables the user to search for a single motif in a sequence.

Constructors in de.jstacs.models.mixture.motif with parameters of type Model
`HiddenMotifMixture(Model[] models, boolean[] optimzeArray, int components, int starts, boolean estimateComponentProbs, double[] componentHyperParams, double[] weights, PositionPrior posPrior, AbstractMixtureModel.Algorithm algorithm, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates a new `HiddenMotifMixture`.
`SingleHiddenMotifMixture(Model motif, Model bg, boolean trainOnlyMotifModel, int starts, double[] componentHyperParams, double[] weights, PositionPrior posPrior, AbstractMixtureModel.Algorithm algorithm, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization, int initialIteration, int stationaryIteration, BurnInTest burnInTest)` Creates a new `SingleHiddenMotifMixture`.
`SingleHiddenMotifMixture(Model motif, Model bg, boolean trainOnlyMotifModel, int starts, double[] componentHyperParams, PositionPrior posPrior, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization)` Creates a new `SingleHiddenMotifMixture` using EM and estimating the probability for finding a motif.
`SingleHiddenMotifMixture(Model motif, Model bg, boolean trainOnlyMotifModel, int starts, double motifProb, PositionPrior posPrior, double alpha, TerminationCondition tc, AbstractMixtureModel.Parameterization parametrization)` Creates a new `SingleHiddenMotifMixture` using EM and fixed probability for finding a motif.

Uses of Model in de.jstacs.models.utils

Methods in de.jstacs.models.utils with parameters of type Model
`static Sample` | `DiscreteInhomogenousSampleEmitter.emitSample(Model m, int n)` This method emits a sample with `n`sequences from the discrete inhomogeneous model `m` .``
`static double` | `ModelTester.getKLDivergence(Model m1, Model m2, int length)` Returns the Kullback-Leibler-divergence `D(p_m1||p_m2)`.
`static double` | `ModelTester.getLogLikelihood(Model m, Sample data)` Returns the log-likelihood of a `Sample` `data` for a given model `m`.
`static double` | `ModelTester.getLogLikelihood(Model m, Sample data, double[] weights)` Returns the log-likelihood of a `Sample` `data` for a given model `m`.
`static double` | `ModelTester.getMarginalDistribution(Model m, int[] constraint)` This method computes the marginal distribution for any discrete model `m` and all sequences that fulfill the `constraint` , if possible.
`static double` | `ModelTester.getMaxOfDeviation(Model m1, Model m2, int length)` This method computes the maximum deviation between the probabilities for all sequences of `length` for discrete models `m1` and `m2`.
`static Sequence` | `ModelTester.getMostProbableSequence(Model m, int length)` Returns one most probable sequence for the discrete model `m`.
`static double` | `ModelTester.getShannonEntropy(Model m, int length)` This method computes the Shannon entropy for any discrete model `m` and all sequences of `length`, if possible.
`static double` | `ModelTester.getShannonEntropyInBits(Model m, int length)` This method computes the Shannon entropy in bits for any discrete model `m` and all sequences of `length`, if possible.
`static double` | `ModelTester.getSumOfDeviation(Model m1, Model m2, int length)` This method computes the sum of deviations between the probabilities for all sequences of `length` for discrete models `m1` and `m2`.
`static double` | `ModelTester.getSumOfDistribution(Model m, int length)` This method computes the marginal distribution for any discrete model `m` and all sequences of `length`, if possible.
`static double` | `ModelTester.getSymKLDivergence(Model m1, Model m2, int length)` Returns the difference of the Kullback-Leibler-divergences, i.e.
`static double` | `ModelTester.getValueOfAIC(Model m, Sample s, int k)` This method computes the value of Akaikes Information Criterion (AIC).
`static double` | `ModelTester.getValueOfBIC(Model m, Sample s, int k)` This method computes the value of the Bayesian Information Criterion (BIC).

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES