Help on module Markov:

NAME
    Markov - Library to implement hidden Markov Models

FILE
    Markov.py

CLASSES
    __builtin__.object
        BayesianModel
            HMM
        Distribution
            PoissonDistribution
        Probability
    
    class BayesianModel(__builtin__.object)
     |  Represents a Bayesian probability model
     |  
     |  Methods defined here:
     |  
     |  MaximumLikelihoodOutcome(self, PriorProbs=None)
     |      Returns the maximum likelihood outcome given PriorProbs
     |  
     |  MaximumLikelihoodState(self, Observations=None)
     |      Returns the maximum likelihood of the internal state. If Observations
     |      is None, defaults to the maximum likelihood of the Prior
     |  
     |  Outcomes(self)
     |      Returns an iterator over the possible outcomes
     |  
     |  PriorProbs(self, Observations, PriorDist=None)
     |      Returns a Distribution representing the probabilities of the prior
     |      states, given a probability Distribution of Observations
     |  
     |  States(self)
     |      Returns an iterator over the possible states
     |  
     |  __call__(self, PriorProbs=None)
     |      Returns a Distribution representing the probabilities of the outcomes
     |      given a particular distribution of the priors, which defaults to
     |      self.Prior
     |  
     |  __iadd__(self, Model2)
     |      Updates the BayesianModel with the data in another BayesianModel
     |  
     |  __init__(self, Prior, Conditionals)
     |      Prior is a Distribution. Conditionals is a dictionary mapping
     |      each state in Prior to a Distribution
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class Distribution(__builtin__.object)
     |  Represents a probability distribution over a set of categories
     |  
     |  Methods defined here:
     |  
     |  MaximumLikelihoodState(self)
     |      Returns the state with the greatest likelihood
     |  
     |  Sample(self)
     |      Picks a random sample from the distribution
     |  
     |  States(self)
     |      Yields the Distribution's states
     |  
     |  Update(self, categories)
     |      Updates each category in the probability distiribution, according to
     |      a dictionary of numerator and denominator values
     |  
     |  __call__(self, item)
     |      Gives the probability of item
     |  
     |  __iadd__(self, Dist2)
     |      Updates the Distribution given another Distribution with the same states
     |  
     |  __init__(self, categories, k=0)
     |      The distribution may be initialised from a list of categories or a
     |      dictionary of category frequencies. In the latter case, Laplacian
     |      smoothing may be used
     |  
     |  __mul__(self, scalar)
     |      Returns the probability of each item, multiplied by a scalar
     |  
     |  copy(self)
     |      Returns a copy of the Distribution
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class HMM(BayesianModel)
     |  Represents a Hidden Markov Model
     |  
     |  Method resolution order:
     |      HMM
     |      BayesianModel
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  Analyse(self, Sequence, MaximumLikelihood=False)
     |      Yields the an estimate of the internal states that generated a Sequence
     |      of observed values, either as the Maximum Likelihood state
     |      (Maximumlikelihood=True) or as a Distribution (MaximumLikelihood=False)
     |  
     |  MaximumLikelihoodState(self, Observations=None)
     |      Returns the maximum likelihood of the internal state. If Observations
     |      is None, defaults to the maximum likelihood of the the Current state, or
     |      the Prior if self.Current is None
     |  
     |  Outcomes(self)
     |  
     |  Predict(self)
     |      Returns a Distribution representing the probabilities of the next
     |      state given the current state
     |  
     |  PriorProbs(self, Observations)
     |      Returns a Distribution the prior probabilities of the HMM's states
     |      given a Distribution of Observations
     |  
     |  Train(self, Sequence)
     |      Trains the HMM from a sequence of observations
     |  
     |  Update(self, Observations)
     |      Updates the Prior probabilities, TransitionProbs
     |      and Conditionals given Observations
     |  
     |  __call__(self, PriorProbs=None)
     |      Returns a Distribution of outcomes given PriorProbs, which defaults
     |      to self.Current if it is set, or self.Prior otherwise
     |  
     |  __init__(self, states, outcomes)
     |      states is a list or dictionary of states, outcomes is a dictionary
     |      mapping each state in states to a Distribution of the output states
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from BayesianModel:
     |  
     |  MaximumLikelihoodOutcome(self, PriorProbs=None)
     |      Returns the maximum likelihood outcome given PriorProbs
     |  
     |  States(self)
     |      Returns an iterator over the possible states
     |  
     |  __iadd__(self, Model2)
     |      Updates the BayesianModel with the data in another BayesianModel
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from BayesianModel:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class PoissonDistribution(Distribution)
     |  Represents a Poisson distribution
     |  
     |  Method resolution order:
     |      PoissonDistribution
     |      Distribution
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  MaximumLikelihoodState(self)
     |  
     |  Mean(self)
     |      Returns the Mean of the PoissonDistribution
     |  
     |  Sample(self)
     |      Returns a random sample from the Poisson distribution
     |  
     |  States(self, limit=1e-07)
     |      Yields the PoissonDistribution's states, up to a cumulative
     |      probability of 1-limit
     |  
     |  Update(self, N, p=1.0)
     |      Updates the distribution, given a value N that has a probability of P
     |      of being drawn from this distribution
     |  
     |  __call__(self, N)
     |      Returns the probability of N
     |  
     |  __init__(self, mean)
     |      Initialises the distribution with a given mean
     |  
     |  copy(self)
     |      Returns a copy of the PoissonDistribution
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Distribution:
     |  
     |  __iadd__(self, Dist2)
     |      Updates the Distribution given another Distribution with the same states
     |  
     |  __mul__(self, scalar)
     |      Returns the probability of each item, multiplied by a scalar
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Distribution:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class Probability(__builtin__.object)
     |  Represents a probability as a callable object
     |  
     |  Methods defined here:
     |  
     |  Update(self, deltaN, deltaD)
     |      Updates the probability during Bayesian learning
     |  
     |  __call__(self)
     |      Returns the value of the probability
     |  
     |  __iadd__(self, Prob2)
     |      Updates the probability given another Probability object
     |  
     |  __init__(self, n, d)
     |      Initialises the probability from a numerator and a denominator
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)


