def __init__(self,
K,
D,
*,
M=0,
init_state_distn=None,
transitions="nb",
transition_kwargs=None,
observations="gaussian",
observation_kwargs=None,
**kwargs):
if init_state_distn is None:
init_state_distn = isd.InitialStateDistribution(K, D, M=M)
if not isinstance(init_state_distn, isd.InitialStateDistribution):
raise TypeError("'init_state_distn' must be a subclass of"
" ssm.init_state_distns.InitialStateDistribution")
# Make the transition model
transition_classes = dict(nb=NegativeBinomialSemiMarkovTransitions, )
if isinstance(transitions, str):
if transitions not in transition_classes:
raise Exception(
"Invalid transition model: {}. Must be one of {}".format(
transitions, list(transition_classes.keys())))
transition_kwargs = transition_kwargs or {}
transitions = transition_classes[transitions](K,
D,
M=M,
**transition_kwargs)
if not isinstance(transitions, trans.Transitions):
raise TypeError("'transitions' must be a subclass of"
" ssm.transitions.Transitions")
# This is the master list of observation classes.
# When you create a new observation class, add it here.
observation_classes = dict(
gaussian=obs.GaussianObservations,
diagonal_gaussian=obs.DiagonalGaussianObservations,
studentst=obs.MultivariateStudentsTObservations,
t=obs.MultivariateStudentsTObservations,
diagonal_t=obs.StudentsTObservations,
diagonal_studentst=obs.StudentsTObservations,
bernoulli=obs.BernoulliObservations,
categorical=obs.CategoricalObservations,
poisson=obs.PoissonObservations,
vonmises=obs.VonMisesObservations,
ar=obs.AutoRegressiveObservations,
autoregressive=obs.AutoRegressiveObservations,
diagonal_ar=obs.AutoRegressiveDiagonalNoiseObservations,
diagonal_autoregressive=obs.
AutoRegressiveDiagonalNoiseObservations,
independent_ar=obs.IndependentAutoRegressiveObservations,
robust_ar=obs.RobustAutoRegressiveObservations,
robust_autoregressive=obs.RobustAutoRegressiveObservations,
diagonal_robust_ar=obs.
RobustAutoRegressiveDiagonalNoiseObservations,
diagonal_robust_autoregressive=obs.
RobustAutoRegressiveDiagonalNoiseObservations,
)
if isinstance(observations, str):
observations = observations.lower()
if observations not in observation_classes:
raise Exception(
"Invalid observation model: {}. Must be one of {}".format(
observations, list(observation_classes.keys())))
observation_kwargs = observation_kwargs or {}
observations = observation_classes[observations](
K, D, M=M, **observation_kwargs)
if not isinstance(observations, obs.Observations):
raise TypeError("'observations' must be a subclass of"
" ssm.observations.Observations")
super().__init__(K,
D,
M=M,
transitions=transition_distn,
transition_kwargs=transition_kwargs,
observations=observation_distn,
observation_kwargs=observation_kwargs,
**kwargs)
def __init__(self,
N,
D,
*,
M=0,
dynamics="gaussian",
dynamics_kwargs=None,
emissions="gaussian_orthog",
emission_kwargs=None,
**kwargs):
# Make the dynamics distn
dynamics_classes = dict(
none=obs.GaussianObservations,
gaussian=obs.AutoRegressiveObservations,
diagonal_gaussian=obs.AutoRegressiveDiagonalNoiseObservations,
t=obs.RobustAutoRegressiveObservations,
studentst=obs.RobustAutoRegressiveObservations,
diagonal_t=obs.RobustAutoRegressiveDiagonalNoiseObservations,
diagonal_studentst=obs.
RobustAutoRegressiveDiagonalNoiseObservations,
)
if isinstance(dynamics, str):
dynamics = dynamics.lower()
if dynamics not in dynamics_classes:
raise Exception(
"Invalid dynamics model: {}. Must be one of {}".format(
dynamics, list(dynamics_classes.keys())))
dynamics_kwargs = dynamics_kwargs or {}
dynamics = dynamics_classes[dynamics](1, D, M=M, **dynamics_kwargs)
if not isinstance(dynamics, obs.Observations):
raise TypeError("'dynamics' must be a subclass of"
" ssm.observations.Observations")
# Make the emission distn
emission_classes = dict(
gaussian=emssn.GaussianEmissions,
gaussian_orthog=emssn.GaussianOrthogonalEmissions,
gaussian_id=emssn.GaussianIdentityEmissions,
gaussian_nn=emssn.GaussianNeuralNetworkEmissions,
studentst=emssn.StudentsTEmissions,
studentst_orthog=emssn.StudentsTOrthogonalEmissions,
studentst_id=emssn.StudentsTIdentityEmissions,
studentst_nn=emssn.StudentsTNeuralNetworkEmissions,
t=emssn.StudentsTEmissions,
t_orthog=emssn.StudentsTOrthogonalEmissions,
t_id=emssn.StudentsTIdentityEmissions,
t_nn=emssn.StudentsTNeuralNetworkEmissions,
poisson=emssn.PoissonEmissions,
poisson_orthog=emssn.PoissonOrthogonalEmissions,
poisson_id=emssn.PoissonIdentityEmissions,
poisson_nn=emssn.PoissonNeuralNetworkEmissions,
bernoulli=emssn.BernoulliEmissions,
bernoulli_orthog=emssn.BernoulliOrthogonalEmissions,
bernoulli_id=emssn.BernoulliIdentityEmissions,
bernoulli_nn=emssn.BernoulliNeuralNetworkEmissions,
ar=emssn.AutoRegressiveEmissions,
ar_orthog=emssn.AutoRegressiveOrthogonalEmissions,
ar_id=emssn.AutoRegressiveIdentityEmissions,
ar_nn=emssn.AutoRegressiveNeuralNetworkEmissions,
autoregressive=emssn.AutoRegressiveEmissions,
autoregressive_orthog=emssn.AutoRegressiveOrthogonalEmissions,
autoregressive_id=emssn.AutoRegressiveIdentityEmissions,
autoregressive_nn=emssn.AutoRegressiveNeuralNetworkEmissions)
if isinstance(emissions, str):
emissions = emissions.lower()
if emissions not in emission_classes:
raise Exception(
"Invalid emission model: {}. Must be one of {}".format(
emissions, list(emission_classes.keys())))
emission_kwargs = emission_kwargs or {}
emissions = emission_classes[emissions](N,
1,
D,
M=M,
single_subspace=True,
**emission_kwargs)
if not isinstance(emissions, emssn.Emissions):
raise TypeError("'emissions' must be a subclass of"
" ssm.emissions.Emissions")
init_state_distn = isd.InitialStateDistribution(1, D, M)
transitions = trans.StationaryTransitions(1, D, M)
super().__init__(N,
1,
D,
M=M,
init_state_distn=init_state_distn,
transitions=transitions,
dynamics=dynamics,
emissions=emissions)
def __init__(self,
K,
D,
*,
M=0,
init_state_distn=None,
transitions='standard',
transition_kwargs=None,
hierarchical_transition_tags=None,
observations="gaussian",
observation_kwargs=None,
hierarchical_observation_tags=None,
**kwargs):
# Make the initial state distribution
if init_state_distn is None:
init_state_distn = isd.InitialStateDistribution(K, D, M=M)
if not isinstance(init_state_distn, isd.InitialStateDistribution):
raise TypeError("'init_state_distn' must be a subclass of"
" ssm.init_state_distns.InitialStateDistribution")
# Make the transition model
transition_classes = dict(
standard=trans.StationaryTransitions,
stationary=trans.StationaryTransitions,
sticky=trans.StickyTransitions,
inputdriven=trans.InputDrivenTransitions,
recurrent=trans.RecurrentTransitions,
recurrent_only=trans.RecurrentOnlyTransitions,
rbf_recurrent=trans.RBFRecurrentTransitions,
nn_recurrent=trans.NeuralNetworkRecurrentTransitions)
if isinstance(transitions, str):
if transitions not in transition_classes:
raise Exception(
"Invalid transition model: {}. Must be one of {}".format(
transitions, list(transition_classes.keys())))
transition_kwargs = transition_kwargs or {}
transitions = \
hier.HierarchicalTransitions(transition_classes[transitions], K, D, M=M,
tags=hierarchical_transition_tags,
**transition_kwargs) \
if hierarchical_transition_tags is not None \
else transition_classes[transitions](K, D, M=M, **transition_kwargs)
if not isinstance(transitions, trans.Transitions):
raise TypeError("'transitions' must be a subclass of"
" ssm.transitions.Transitions")
# This is the master list of observation classes.
# When you create a new observation class, add it here.
observation_classes = dict(
gaussian=obs.GaussianObservations,
diagonal_gaussian=obs.DiagonalGaussianObservations,
studentst=obs.MultivariateStudentsTObservations,
t=obs.MultivariateStudentsTObservations,
diagonal_t=obs.StudentsTObservations,
diagonal_studentst=obs.StudentsTObservations,
bernoulli=obs.BernoulliObservations,
categorical=obs.CategoricalObservations,
poisson=obs.PoissonObservations,
vonmises=obs.VonMisesObservations,
ar=obs.AutoRegressiveObservations,
autoregressive=obs.AutoRegressiveObservations,
no_input_ar=obs.AutoRegressiveObservationsNoInput,
diagonal_ar=obs.AutoRegressiveDiagonalNoiseObservations,
diagonal_autoregressive=obs.
AutoRegressiveDiagonalNoiseObservations,
independent_ar=obs.IndependentAutoRegressiveObservations,
robust_ar=obs.RobustAutoRegressiveObservations,
no_input_robust_ar=obs.RobustAutoRegressiveObservationsNoInput,
robust_autoregressive=obs.RobustAutoRegressiveObservations,
diagonal_robust_ar=obs.
RobustAutoRegressiveDiagonalNoiseObservations,
diagonal_robust_autoregressive=obs.
RobustAutoRegressiveDiagonalNoiseObservations,
)
if isinstance(observations, str):
observations = observations.lower()
if observations not in observation_classes:
raise Exception(
"Invalid observation model: {}. Must be one of {}".format(
observations, list(observation_classes.keys())))
observation_kwargs = observation_kwargs or {}
observations = \
hier.HierarchicalObservations(observation_classes[observations], K, D, M=M,
tags=hierarchical_observation_tags,
**observation_kwargs) \
if hierarchical_observation_tags is not None \
else observation_classes[observations](K, D, M=M, **observation_kwargs)
if not isinstance(observations, obs.Observations):
raise TypeError("'observations' must be a subclass of"
" ssm.observations.Observations")
self.K, self.D, self.M = K, D, M
self.init_state_distn = init_state_distn
self.transitions = transitions
self.observations = observations
def __init__(self,
N,
K,
D,
*,
M=0,
init_state_distn=None,
transitions="standard",
transition_kwargs=None,
dynamics="gaussian",
dynamics_kwargs=None,
emissions="gaussian_orthog",
emission_kwargs=None,
single_subspace=True,
**kwargs):
# Make the initial state distribution
if init_state_distn is None:
init_state_distn = isd.InitialStateDistribution(K, D, M=M)
assert isinstance(init_state_distn, isd.InitialStateDistribution)
# Make the transition model
transition_classes = dict(
standard=trans.StationaryTransitions,
stationary=trans.StationaryTransitions,
sticky=trans.StickyTransitions,
inputdriven=trans.InputDrivenTransitions,
recurrent=trans.RecurrentTransitions,
recurrent_only=trans.RecurrentOnlyTransitions,
rbf_recurrent=trans.RBFRecurrentTransitions,
nn_recurrent=trans.NeuralNetworkRecurrentTransitions)
if isinstance(transitions, str):
transitions = transitions.lower()
if transitions not in transition_classes:
raise Exception(
"Invalid transition model: {}. Must be one of {}".format(
transitions, list(transition_classes.keys())))
transition_kwargs = transition_kwargs or {}
transitions = transition_classes[transitions](K,
D,
M=M,
**transition_kwargs)
if not isinstance(transitions, trans.Transitions):
raise TypeError("'transitions' must be a subclass of"
" ssm.transitions.Transitions")
# Make the dynamics distn
dynamics_classes = dict(
none=obs.GaussianObservations,
gaussian=obs.AutoRegressiveObservations,
diagonal_gaussian=obs.AutoRegressiveDiagonalNoiseObservations,
t=obs.RobustAutoRegressiveObservations,
studentst=obs.RobustAutoRegressiveObservations,
diagonal_t=obs.RobustAutoRegressiveDiagonalNoiseObservations,
diagonal_studentst=obs.
RobustAutoRegressiveDiagonalNoiseObservations,
)
if isinstance(dynamics, str):
dynamics = dynamics.lower()
if dynamics not in dynamics_classes:
raise Exception(
"Invalid dynamics model: {}. Must be one of {}".format(
dynamics, list(dynamics_classes.keys())))
dynamics_kwargs = dynamics_kwargs or {}
dynamics = dynamics_classes[dynamics](K, D, M=M, **dynamics_kwargs)
if not isinstance(dynamics, obs.Observations):
raise TypeError("'dynamics' must be a subclass of"
" ssm.observations.Observations")
# Make the emission distn
emission_classes = dict(
gaussian=emssn.GaussianEmissions,
gaussian_orthog=emssn.GaussianOrthogonalEmissions,
gaussian_id=emssn.GaussianIdentityEmissions,
gaussian_nn=emssn.GaussianNeuralNetworkEmissions,
studentst=emssn.StudentsTEmissions,
studentst_orthog=emssn.StudentsTOrthogonalEmissions,
studentst_id=emssn.StudentsTIdentityEmissions,
studentst_nn=emssn.StudentsTNeuralNetworkEmissions,
t=emssn.StudentsTEmissions,
t_orthog=emssn.StudentsTOrthogonalEmissions,
t_id=emssn.StudentsTIdentityEmissions,
t_nn=emssn.StudentsTNeuralNetworkEmissions,
poisson=emssn.PoissonEmissions,
poisson_orthog=emssn.PoissonOrthogonalEmissions,
poisson_id=emssn.PoissonIdentityEmissions,
poisson_nn=emssn.PoissonNeuralNetworkEmissions,
bernoulli=emssn.BernoulliEmissions,
bernoulli_orthog=emssn.BernoulliOrthogonalEmissions,
bernoulli_id=emssn.BernoulliIdentityEmissions,
bernoulli_nn=emssn.BernoulliNeuralNetworkEmissions,
ar=emssn.AutoRegressiveEmissions,
ar_orthog=emssn.AutoRegressiveOrthogonalEmissions,
ar_id=emssn.AutoRegressiveIdentityEmissions,
ar_nn=emssn.AutoRegressiveNeuralNetworkEmissions,
autoregressive=emssn.AutoRegressiveEmissions,
autoregressive_orthog=emssn.AutoRegressiveOrthogonalEmissions,
autoregressive_id=emssn.AutoRegressiveIdentityEmissions,
autoregressive_nn=emssn.AutoRegressiveNeuralNetworkEmissions)
if isinstance(emissions, str):
emissions = emissions.lower()
if emissions not in emission_classes:
raise Exception(
"Invalid emission model: {}. Must be one of {}".format(
emissions, list(emission_classes.keys())))
emission_kwargs = emission_kwargs or {}
emissions = emission_classes[emissions](
N,
K,
D,
M=M,
single_subspace=single_subspace,
**emission_kwargs)
if not isinstance(emissions, emssn.Emissions):
raise TypeError("'emissions' must be a subclass of"
" ssm.emissions.Emissions")
self.N, self.K, self.D, self.M = N, K, D, M
self.init_state_distn = init_state_distn
self.transitions = transitions
self.dynamics = dynamics
self.emissions = emissions
