pymc-extras 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

pymc_extras/statespace/models/structural/utils.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+from pytensor import tensor as pt
+
+
+def order_to_mask(order):
+    if isinstance(order, int):
+        return np.ones(order).astype(bool)
+    else:
+        return np.array(order).astype(bool)
+
+
+def _frequency_transition_block(s, j):
+    lam = 2 * np.pi * j / s
+
+    return pt.stack([[pt.cos(lam), pt.sin(lam)], [-pt.sin(lam), pt.cos(lam)]])

pymc_extras/statespace/models/utilities.py

@@ -1,6 +1,10 @@
+from typing import cast as type_cast
+
 import numpy as np
 import pytensor.tensor as pt
 
+from pytensor.tensor import TensorVariable
+
 from pymc_extras.statespace.utils.constants import (
     ALL_STATE_AUX_DIM,
     ALL_STATE_DIM,
@@ -374,6 +378,287 @@ def conform_time_varying_and_time_invariant_matrices(A, B):
     return A, B
 
 
+def normalize_axis(x, axis):
+    """
+    Convert negative axis values to positive axis values
+    """
+    if isinstance(axis, tuple):
+        return tuple([normalize_axis(x, i) for i in axis])
+    if axis < 0:
+        axis = x.ndim + axis
+    return axis
+
+
+def reorder_from_labels(
+    x: TensorVariable,
+    labels: list[str],
+    ordered_labels: list[str],
+    labeled_axis: int | tuple[int, int],
+) -> TensorVariable:
+    """
+    Reorder an input tensor along request axis/axes based on lists of string labels
+
+    Parameters
+    ----------
+    x: TensorVariable
+        Input tensor
+    labels: list of str
+        Labels associated with values of the input tensor ``x``, along the ``labeled_axis``. At runtime, should have
+        ``x.shape[labeled_axis] == len(labels)``
+    ordered_labels: list of str
+        Target ordering according to which ``x`` will be reordered.
+    labeled_axis: int or tuple of int
+        Axis along which ``x`` will be labeled. If a tuple, each axis will be assumed to have identical labels, and
+        and reorganization will be done on all requested axes together (NOT fancy indexing!)
+
+    Returns
+    -------
+    x_sorted: TensorVariable
+        Output tensor sorted along ``labeled_axis`` according to ``ordered_labels``
+    """
+    n_out = len(ordered_labels)
+    label_to_index = {label: index for index, label in enumerate(ordered_labels)}
+
+    missing_labels = [label for label in ordered_labels if label not in labels]
+    indices = np.argsort([label_to_index[label] for label in [*labels, *missing_labels]])
+
+    if isinstance(labeled_axis, int):
+        labeled_axis = (labeled_axis,)
+
+    if indices.tolist() != list(range(n_out)):
+        for axis in labeled_axis:
+            idx = np.s_[tuple([slice(None, None) if i != axis else indices for i in range(x.ndim)])]
+            shape = x.type.shape
+            x = pt.specify_shape(x[idx], shape)
+
+    return x
+
+
+def pad_and_reorder(
+    x: TensorVariable, labels: list[str], ordered_labels: list[str], labeled_axis: int
+) -> TensorVariable:
+    """
+    Pad input tensor ``x`` along the `labeled_axis` to match the length of ``ordered_labels``, then reorder the
+    padded dimension to match the ordering in ``ordered_labels``.
+
+    Parameters
+    ----------
+    x: TensorVariable
+        Input tensor
+    labels: list of str
+        String labels associated with the `x` tensor at the ``labeled_axis`` dimension. At runtime, should have
+        ``x.shape[labeled_axis] == len(labels)``. ``labels`` should be a subset of ``ordered_labels``.
+    ordered_labels: list of str
+        Target ordering according to which ``x`` will be reordered.
+    labeled_axis: int
+        Axis along which ``x`` will be labeled.
+
+    Returns
+    -------
+    x_padded: TensorVariable
+        Output tensor padded along ``labeled_axis`` according to ``ordered_labels``, then reordered.
+
+    """
+    n_out = len(ordered_labels)
+    n_missing = n_out - len(labels)
+
+    if n_missing > 0:
+        zeros = pt.zeros(
+            tuple([x.shape[i] if i != labeled_axis else n_missing for i in range(x.ndim)])
+        )
+        x_padded = pt.concatenate([x, zeros], axis=labeled_axis)
+    else:
+        x_padded = x
+
+    return reorder_from_labels(x_padded, labels, ordered_labels, labeled_axis)
+
+
+def ndim_pad_and_reorder(
+    x: TensorVariable,
+    labels: list[str],
+    ordered_labels: list[str],
+    labeled_axis: int | tuple[int, int],
+) -> TensorVariable:
+    """
+    Pad input tensor ``x`` along the `labeled_axis` to match the length of ``ordered_labels``, then reorder the
+    padded dimension to match the ordering in ``ordered_labels``.
+
+    Unlike ``pad_and_reorder``, this function allows padding and reordering to be done simultaneously on multiple
+    axes. In this case, reordering is done jointly on all axes -- it does *not* use fancy indexing.
+
+    Parameters
+    ----------
+    x: TensorVariable
+        Input tensor
+    labels: list of str
+        Labels associated with values of the input tensor ``x``, along the ``labeled_axis``. At runtime, should have
+        ``x.shape[labeled_axis] == len(labels)``. If ``labeled_axis`` is a tuple, all axes are assumed to have the
+        same labels.
+    ordered_labels: list of str
+        Target ordering according to which ``x`` will be reordered. ``labels`` should be a subset of ``ordered_labels``.
+    labeled_axis: int or tuple of int
+        Axis along which ``x`` will be labeled. If a tuple, each axis will be assumed to have identical labels, and
+        and reorganization will be done on all requested axes together (NOT fancy indexing!)
+
+    Returns
+    -------
+    x_sorted: TensorVariable
+        Output tensor. Each ``labeled_axis`` is padded to the length of ``ordered_labels``, then reordered.
+    """
+    n_missing = len(ordered_labels) - len(labels)
+
+    if isinstance(labeled_axis, int):
+        labeled_axis = (labeled_axis,)
+
+    if n_missing > 0:
+        pad_size = [(0, 0) if i not in labeled_axis else (0, n_missing) for i in range(x.ndim)]
+        for axis, (_, after) in enumerate(pad_size):
+            if after > 0:
+                shape = list(x.type.shape)
+                shape[axis] = after
+                zero_shape = [
+                    static_shape if static_shape is not None else x.shape[i]
+                    for i, static_shape in enumerate(shape)
+                ]
+                x = pt.join(axis, x, pt.zeros(zero_shape))
+
+    return reorder_from_labels(x, labels, ordered_labels, labeled_axis)
+
+
+def add_tensors_by_dim_labels(
+    tensor: TensorVariable,
+    other_tensor: TensorVariable,
+    labels: list[str],
+    other_labels: list[str],
+    labeled_axis: int | tuple[int, int] = -1,
+) -> TensorVariable:
+    """
+    Add two tensors based on labels associated with one dimension.
+
+    When combining statespace matrices associated with structural components with potentially different states, it is
+    important to make sure that duplicated states are handled correctly. For bias vectors and covariance matrices,
+    duplicated states should be summed.
+
+    When a state appears in one component but not another, that state should be treated as an implicit zero in the
+    components where the state does not appear. This amounts to padding the relevant matrices with zeros before
+    performing the addition.
+
+    When labeled_axis is a tuple, each provided label is assumed to be identically labeled in each input tensor. This
+    is the case, for example, when working with a covariance matrix. In this case, padding and alignment will be
+    done on each indicated index.
+
+    Parameters
+    ----------
+    tensor: TensorVariable
+        A statespace matrix to be summed with ``other_tensor``.
+    other_tensor: TensorVariable
+        A statespace matrix to be summed with ``tensor``.
+    labels: list of str
+        Dimension labels associated with ``tensor``, on the ``labeled_axis`` dimension.
+    other_labels: list of str
+        Dimension labels associated with ``other_tensor``, on the ``labeled_axis`` dimension.
+    labeled_axis: int or tuple of int
+        Dimension that is labeled by ``labels`` and ``other_labels``. ``tensor.shape[labeled_axis]`` must have the
+        shape of ``len(labels)`` at runtime.
+
+    Returns
+    -------
+    result: TensorVariable
+        Result of addition of ``tensor`` and ``other_tensor``, along the ``labeled_axis`` dimension.  The ordering of
+        the output will be ``labels + [label for label in other_labels if label not in labels]``. That is, ``labels``
+        come first, followed by any new labels introduced by ``other_labels``.
+
+    """
+    labeled_axis = normalize_axis(tensor, labeled_axis)
+    new_labels = [label for label in other_labels if label not in labels]
+    combined_labels = type_cast(list[str], [*labels, *new_labels])
+
+    # If there is no overlap at all, directly concatenate the two matrices -- there's no need to worry about the order
+    # of things, or padding. This is equivalent to padding both out with zeros then adding them.
+    if combined_labels == [*labels, *other_labels]:
+        if isinstance(labeled_axis, int):
+            return pt.concatenate([tensor, other_tensor], axis=labeled_axis)
+        else:
+            # In the case where we want to align multiple dimensions, use block_diag to accomplish padding on the last
+            # two dimensions
+            dims = [*[i for i in range(tensor.ndim) if i not in labeled_axis], *labeled_axis]
+            return pt.linalg.block_diag(
+                type_cast(TensorVariable, tensor.transpose(*dims)),
+                type_cast(TensorVariable, other_tensor.transpose(*dims)),
+            )
+    # Otherwise, there are two possibilities. If all labels are the same, we might need to re-order one or both to get
+    # them to agree. If *some* labels are the same, we will need to pad first, then potentially re-order. In any case,
+    # the final step is just to add the padded and re-ordered tensors.
+    fn = pad_and_reorder if isinstance(labeled_axis, int) else ndim_pad_and_reorder
+
+    padded_tensor = fn(
+        tensor,
+        labels=type_cast(list[str], labels),
+        ordered_labels=combined_labels,
+        labeled_axis=labeled_axis,
+    )
+    padded_tensor.name = tensor.name
+
+    padded_other_tensor = fn(
+        other_tensor,
+        labels=type_cast(list[str], other_labels),
+        ordered_labels=combined_labels,
+        labeled_axis=labeled_axis,
+    )
+
+    padded_other_tensor.name = other_tensor.name
+
+    return padded_tensor + padded_other_tensor
+
+
+def join_tensors_by_dim_labels(
+    tensor: TensorVariable,
+    other_tensor: TensorVariable,
+    labels: list[str],
+    other_labels: list[str],
+    labeled_axis: int = -1,
+    join_axis: int = -1,
+    block_diag_join: bool = False,
+) -> TensorVariable:
+    labeled_axis = normalize_axis(tensor, labeled_axis)
+    new_labels = [label for label in other_labels if label not in labels]
+    combined_labels = [*labels, *new_labels]
+
+    # Check for no overlap first. In this case, do a block_diagonal join, which implicitly results in padding zeros
+    # everywhere they are needed -- no other sorting or padding necessary
+    if combined_labels == [*labels, *other_labels]:
+        res = pt.linalg.block_diag(tensor, other_tensor)
+        new_shape = [
+            shape_1 + shape_2 if (shape_1 is not None and shape_2 is not None) else None
+            for shape_1, shape_2 in zip(tensor.type.shape, other_tensor.type.shape)
+        ]
+        return pt.specify_shape(res, new_shape)
+
+    # Otherwise there is either total overlap or partial overlap. Let the padding and reordering function figure it out.
+    tensor = ndim_pad_and_reorder(tensor, labels, combined_labels, labeled_axis)
+    other_tensor = ndim_pad_and_reorder(other_tensor, other_labels, combined_labels, labeled_axis)
+
+    if block_diag_join:
+        new_shape = [
+            shape_1 + shape_2 if (shape_1 is not None and shape_2 is not None) else None
+            for shape_1, shape_2 in zip(tensor.type.shape, other_tensor.type.shape)
+        ]
+        res = pt.linalg.block_diag(tensor, other_tensor)
+    else:
+        new_shape = []
+        join_axis_norm = normalize_axis(tensor, join_axis)
+        for i, (shape_1, shape_2) in enumerate(zip(tensor.type.shape, other_tensor.type.shape)):
+            if i == join_axis_norm:
+                new_shape.append(
+                    shape_1 + shape_2 if (shape_1 is not None and shape_2 is not None) else None
+                )
+            else:
+                new_shape.append(shape_1 if shape_1 is not None else shape_2)
+        res = pt.concatenate([tensor, other_tensor], axis=join_axis)
+
+    return pt.specify_shape(res, new_shape)
+
+
 def get_exog_dims_from_idata(exog_name, idata):
     if exog_name in idata.posterior.data_vars:
         exog_dims = idata.posterior[exog_name].dims[2:]

pymc_extras/statespace/utils/constants.py

@@ -7,11 +7,12 @@ OBS_STATE_AUX_DIM = "observed_state_aux"
 SHOCK_DIM = "shock"
 SHOCK_AUX_DIM = "shock_aux"
 TIME_DIM = "time"
-AR_PARAM_DIM = "ar_lag"
-MA_PARAM_DIM = "ma_lag"
-SEASONAL_AR_PARAM_DIM = "seasonal_ar_lag"
-SEASONAL_MA_PARAM_DIM = "seasonal_ma_lag"
+AR_PARAM_DIM = "lag_ar"
+MA_PARAM_DIM = "lag_ma"
+SEASONAL_AR_PARAM_DIM = "seasonal_lag_ar"
+SEASONAL_MA_PARAM_DIM = "seasonal_lag_ma"
 ETS_SEASONAL_DIM = "seasonal_lag"
+EXOGENOUS_DIM = "exogenous"
 
 NEVER_TIME_VARYING = ["initial_state", "initial_state_cov", "a0", "P0"]
 VECTOR_VALUED = ["initial_state", "state_intercept", "obs_intercept", "a0", "c", "d"]
@@ -38,14 +39,16 @@ SHORT_NAME_TO_LONG = dict(zip(MATRIX_NAMES, LONG_MATRIX_NAMES))
 LONG_NAME_TO_SHORT = dict(zip(LONG_MATRIX_NAMES, MATRIX_NAMES))
 
 FILTER_OUTPUT_NAMES = [
-    "filtered_state",
-    "predicted_state",
-    "filtered_covariance",
-    "predicted_covariance",
+    "filtered_states",
+    "predicted_states",
+    "filtered_covariances",
+    "predicted_covariances",
+    "predicted_observed_states",
+    "predicted_observed_covariances",
 ]
 
-SMOOTHER_OUTPUT_NAMES = ["smoothed_state", "smoothed_covariance"]
-OBSERVED_OUTPUT_NAMES = ["predicted_observed_state", "predicted_observed_covariance"]
+SMOOTHER_OUTPUT_NAMES = ["smoothed_states", "smoothed_covariances"]
+OBSERVED_OUTPUT_NAMES = ["predicted_observed_states", "predicted_observed_covariances"]
 
 MATRIX_DIMS = {
     "x0": (ALL_STATE_DIM,),
@@ -60,14 +63,14 @@ MATRIX_DIMS = {
 }
 
 FILTER_OUTPUT_DIMS = {
-    "filtered_state": (TIME_DIM, ALL_STATE_DIM),
-    "smoothed_state": (TIME_DIM, ALL_STATE_DIM),
-    "predicted_state": (TIME_DIM, ALL_STATE_DIM),
-    "filtered_covariance": (TIME_DIM, ALL_STATE_DIM, ALL_STATE_AUX_DIM),
-    "smoothed_covariance": (TIME_DIM, ALL_STATE_DIM, ALL_STATE_AUX_DIM),
-    "predicted_covariance": (TIME_DIM, ALL_STATE_DIM, ALL_STATE_AUX_DIM),
-    "predicted_observed_state": (TIME_DIM, OBS_STATE_DIM),
-    "predicted_observed_covariance": (TIME_DIM, OBS_STATE_DIM, OBS_STATE_AUX_DIM),
+    "filtered_states": (TIME_DIM, ALL_STATE_DIM),
+    "smoothed_states": (TIME_DIM, ALL_STATE_DIM),
+    "predicted_states": (TIME_DIM, ALL_STATE_DIM),
+    "filtered_covariances": (TIME_DIM, ALL_STATE_DIM, ALL_STATE_AUX_DIM),
+    "smoothed_covariances": (TIME_DIM, ALL_STATE_DIM, ALL_STATE_AUX_DIM),
+    "predicted_covariances": (TIME_DIM, ALL_STATE_DIM, ALL_STATE_AUX_DIM),
+    "predicted_observed_states": (TIME_DIM, OBS_STATE_DIM),
+    "predicted_observed_covariances": (TIME_DIM, OBS_STATE_DIM, OBS_STATE_AUX_DIM),
 }
 
 POSITION_DERIVATIVE_NAMES = ["level", "trend", "acceleration", "jerk", "snap", "crackle", "pop"]

pymc_extras/statespace/utils/data_tools.py

@@ -53,7 +53,7 @@ def _validate_data_shape(data_shape, n_obs, obs_coords=None, check_col_names=Fal
         if len(missing_cols) > 0:
             raise ValueError(
                 "Columns of DataFrame provided as data do not match state names. The following states were"
-                f'not found: {", ".join(missing_cols)}. This may result in unexpected results in complex'
+                f"not found: {', '.join(missing_cols)}. This may result in unexpected results in complex"
                 f"statespace models"
             )
 
@@ -141,9 +141,10 @@ def add_data_to_active_model(values, index, data_dims=None):
 
     # If the data has just one column, we need to specify the shape as (None, 1), or else the JAX backend will
     # raise a broadcasting error.
-    data_shape = None
-    if values.shape[-1] == 1:
+    if values.shape[-1] == 1 or values.ndim == 1:
         data_shape = (None, 1)
+    else:
+        data_shape = (None, values.shape[-1])
 
     data = pm.Data("data", values, dims=data_dims, shape=data_shape)
 

{pymc_extras-0.3.1.dist-info → pymc_extras-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymc-extras
-Version: 0.3.1
+Version: 0.4.1
 Summary: A home for new additions to PyMC, which may include unusual probability distribitions, advanced model fitting algorithms, or any code that may be inappropriate to include in the pymc repository, but may want to be made available to users.
 Project-URL: Documentation, https://pymc-extras.readthedocs.io/
 Project-URL: Repository, https://github.com/pymc-devs/pymc-extras.git
@@ -232,9 +232,11 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.11
-Requires-Dist: better-optimize>=0.1.4
+Requires-Dist: better-optimize>=0.1.5
+Requires-Dist: preliz>=0.20.0
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: pymc>=5.21.1
+Requires-Dist: pymc>=5.24.1
+Requires-Dist: pytensor>=2.31.4
 Requires-Dist: scikit-learn
 Provides-Extra: complete
 Requires-Dist: dask[complete]<2025.1.1; extra == 'complete'
@@ -245,7 +247,6 @@ Requires-Dist: xhistogram; extra == 'dask-histogram'
 Provides-Extra: dev
 Requires-Dist: blackjax; extra == 'dev'
 Requires-Dist: dask[all]<2025.1.1; extra == 'dev'
-Requires-Dist: preliz>=0.5.0; extra == 'dev'
 Requires-Dist: pytest-mock; extra == 'dev'
 Requires-Dist: pytest>=6.0; extra == 'dev'
 Requires-Dist: statsmodels; extra == 'dev'

{pymc_extras-0.3.1.dist-info → pymc_extras-0.4.1.dist-info}/RECORD

@@ -2,12 +2,12 @@ pymc_extras/__init__.py,sha256=YsR6OG72aW73y6dGS7w3nGGMV-V-ImHkmUOXKMPfMRA,1230
 pymc_extras/deserialize.py,sha256=dktK5gsR96X3zAUoRF5udrTiconknH3uupiAWqkZi0M,5937
 pymc_extras/linearmodel.py,sha256=KkvZ_DBXOD6myPgVNzu742YV0OzDK449_pDqNC5yae4,3975
 pymc_extras/model_builder.py,sha256=sAw77fxdiy046BvDPjocuMlbJ0Efj-CDAGtmcwYmoG0,26361
-pymc_extras/printing.py,sha256=G8mj9dRd6i0PcsbcEWZm56ek6V8mmil78RI4MUhywBs,6506
+pymc_extras/printing.py,sha256=bFOANgsOWDk0vbRMvm2h_D5TsT7OiSojdG7tvyfCw28,6506
 pymc_extras/prior.py,sha256=0XbyRRVuS7aKY5gmvJr_iq4fGyHrRDeI_OjWu_O7CTA,39449
-pymc_extras/distributions/__init__.py,sha256=fDbrBt9mxEVp2CDPwnyCW3oiutzZ0PduB8EUH3fUrjI,1377
+pymc_extras/distributions/__init__.py,sha256=Cge3AP7gzD6qTJY7v2tYRtSgn-rlnIo7wQBgf3IfKQ8,1377
 pymc_extras/distributions/continuous.py,sha256=530wvcO-QcYVdiVN-iQRveImWfyJzzmxiZLMVShP7w4,11251
 pymc_extras/distributions/discrete.py,sha256=HNi-K0_hnNWTcfyBkWGh26sc71FwBgukQ_EjGAaAOjY,13036
-pymc_extras/distributions/histogram_utils.py,sha256=5RTvlGCUrp2qzshrchmPyWxjhs6RIYL62SMikjDM1TU,5814
+pymc_extras/distributions/histogram_utils.py,sha256=xvCc19nlOmeb9PLZDcsR5PRdmcr5sRefZlPlCvxmGfM,5814
 pymc_extras/distributions/timeseries.py,sha256=M5MZ-nik_tgkaoZ1hdUGEZ9g04DQyVLwszVJqSKwNcY,12719
 pymc_extras/distributions/multivariate/__init__.py,sha256=E8OeLW9tTotCbrUjEo4um76-_WQD56PehsPzkKmhfyA,93
 pymc_extras/distributions/multivariate/r2d2m2cp.py,sha256=bUj9bB-hQi6CpaJfvJjgNPi727uTbvAdxl9fm1zNBqY,16005
@@ -15,17 +15,17 @@ pymc_extras/distributions/transforms/__init__.py,sha256=FUp2vyRE6_2eUcQ_FVt5Dn0-
 pymc_extras/distributions/transforms/partial_order.py,sha256=oEZlc9WgnGR46uFEjLzKEUxlhzIo2vrUUbBE3vYrsfQ,8404
 pymc_extras/gp/__init__.py,sha256=sFHw2y3lEl5tG_FDQHZUonQ_k0DF1JRf0Rp8dpHmge0,745
 pymc_extras/gp/latent_approx.py,sha256=cDEMM6H1BL2qyKg7BZU-ISrKn2HJe7hDaM4Y8GgQDf4,6682
-pymc_extras/inference/__init__.py,sha256=YJIBqHoJnjglof7SVESH3u67li_ETmMy24zajld0DNE,917
+pymc_extras/inference/__init__.py,sha256=sy1JYQGNZNvPs-3jVFfbFQTW0iCIrbjH3aHBpx1HQi0,917
 pymc_extras/inference/fit.py,sha256=U_jfzuyjk5bV6AvOxtOKzBg-q4z-_BOR06Hn38T0W6E,1328
 pymc_extras/inference/laplace_approx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymc_extras/inference/laplace_approx/find_map.py,sha256=DihZO3XgiIs7JFKgriluSQDdinMQZG1xjkrQ4OUREno,13859
-pymc_extras/inference/laplace_approx/idata.py,sha256=Ldkzny9qgYg9My2ydIaQfzKJ73y-xcgC7VJiGvbZhWE,13221
-pymc_extras/inference/laplace_approx/laplace.py,sha256=M8s8GfHE5SgNLOiyiHsDuMDvYGEaBMjjqthVnrxY248,18724
+pymc_extras/inference/laplace_approx/find_map.py,sha256=fP8DQ21OZbkUiBaq-TXGe7CtH0umupFacRC3qReoiKU,14022
+pymc_extras/inference/laplace_approx/idata.py,sha256=P_GyodNJy2yr6FBYBqSoMShW2CKKuljBTFY1jOAHEKE,13332
+pymc_extras/inference/laplace_approx/laplace.py,sha256=V49TdsCYGxt7Evg7Ml2qtHW0xeZYP5YjCOBaewTvJog,18778
 pymc_extras/inference/laplace_approx/scipy_interface.py,sha256=qMxYodmmxaUGsOp1jc7HxBJc6L8NnmFT2Fd4UNNXu2c,8835
 pymc_extras/inference/pathfinder/__init__.py,sha256=FhAYrCWNx_dCrynEdjg2CZ9tIinvcVLBm67pNx_Y3kA,101
 pymc_extras/inference/pathfinder/importance_sampling.py,sha256=NwxepXOFit3cA5zEebniKdlnJ1rZWg56aMlH4MEOcG4,6264
 pymc_extras/inference/pathfinder/lbfgs.py,sha256=GOoJBil5Kft_iFwGNUGKSeqzI5x_shA4KQWDwgGuQtQ,7110
-pymc_extras/inference/pathfinder/pathfinder.py,sha256=yme_wBHnREaT5gSOD6CZ0nb87oScmXjplERiQb0mcAg,64454
+pymc_extras/inference/pathfinder/pathfinder.py,sha256=wVDbyvE97iqiYLDHLfnl1MFtDdmEmaI5XZS3Lr6f9sE,64475
 pymc_extras/inference/smc/__init__.py,sha256=wyaT4NJl1YsSQRLiDy-i0Jq3CbJZ2BQd4nnCk-dIngY,603
 pymc_extras/inference/smc/sampling.py,sha256=AYwmKqGoV6pBtKnh9SUbBKbN7VcoFgb3MmNWV7SivMA,15365
 pymc_extras/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -38,32 +38,41 @@ pymc_extras/model/transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 pymc_extras/model/transforms/autoreparam.py,sha256=_NltGWmNqi_X9sHCqAvWcBveLTPxVy11-wENFTcN6kk,12377
 pymc_extras/preprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymc_extras/preprocessing/standard_scaler.py,sha256=Vajp33ma6OkwlU54JYtSS8urHbMJ3CRiRFxZpvFNuus,600
-pymc_extras/statespace/__init__.py,sha256=0MtZj7yT6jcyERvITnn-nkhyY8fO6Za4_vV53CF6ND0,429
-pymc_extras/statespace/core/__init__.py,sha256=huHEiXAm8zV2MZyZ8GBHp6q7_fnWqveM7lC6ilpb3iE,309
+pymc_extras/statespace/__init__.py,sha256=PxV8i4aa2XJarRM6aKU14_bEY1AoLu4bNXIBy_E1rRw,431
+pymc_extras/statespace/core/__init__.py,sha256=LEhkqdMZzzcTyzYml45IM4ykWoCdbWWj2c29IpM_ey8,309
 pymc_extras/statespace/core/compile.py,sha256=9FZfE8Bi3VfElxujfOIKRVvmyL9M5R0WfNEqPc5kbVQ,1603
-pymc_extras/statespace/core/representation.py,sha256=DwNIun6wdeEA20oWBx5M4govyWTf5JI87aGQ_E6Mb4U,18956
-pymc_extras/statespace/core/statespace.py,sha256=mr0jDeCEfclCAGfEfEzMsogiuonGO9k2BV67wH_YKio,105627
-pymc_extras/statespace/filters/__init__.py,sha256=N9Q4D0gAq_ZtT-GtrqiX1HkSg6Orv7o1TbrWUtnbTJE,420
+pymc_extras/statespace/core/representation.py,sha256=boY-jjlkd3KuuO2XiSuV-GwEAyEqRJ9267H72AmE3BU,18956
+pymc_extras/statespace/core/statespace.py,sha256=yu7smA5w7l1LFNjTwuKLnGarGLx4HEPJKQ9ZMDbWhDY,108161
+pymc_extras/statespace/filters/__init__.py,sha256=F0EtZUhArp23lj3upy6zB0mDTjLIjwGh0pKmMny0QfY,420
 pymc_extras/statespace/filters/distributions.py,sha256=-s1c5s2zm6FMc0UqKSrWnJzIF4U5bvJT_3mMNTyV_ak,11927
-pymc_extras/statespace/filters/kalman_filter.py,sha256=Z6kxsbW8_VQ6ZcPjDMA5d_XPfdUY1-4GfRwKbBNfVZs,31438
+pymc_extras/statespace/filters/kalman_filter.py,sha256=rgpgF4KZXX5M8yRwblrt2SEINKgoXgiKNfKkbl7ZU9Y,31464
 pymc_extras/statespace/filters/kalman_smoother.py,sha256=5jlSZAPveJzD5Q8omnpn7Gb1jgElBMgixGR7H9zoH8U,4183
 pymc_extras/statespace/filters/utilities.py,sha256=iwdaYnO1cO06t_XUjLLRmqb8vwzzVH6Nx1iyZcbJL2k,1584
 pymc_extras/statespace/models/ETS.py,sha256=08sbiuNvKdxcgKzS7jWj-z4jf-su73WFkYc8sKkGdEs,28538
-pymc_extras/statespace/models/SARIMAX.py,sha256=aXR6KYuqtSBOk-jvm9NvnOX5vu4QesBgCIL-KR89SXs,22207
-pymc_extras/statespace/models/VARMAX.py,sha256=CX8Gs4GP3u6aD2b8nxonA5zCoQzIca668iLF0SkKF00,16456
-pymc_extras/statespace/models/__init__.py,sha256=U79b8rTHBNijVvvGOd43nLu4PCloPUH1rwlN87-n88c,317
-pymc_extras/statespace/models/structural.py,sha256=ZK2tAlY0VP2BqueKSvEDTrVJNj3Q8muVsW2YO46mtww,64455
-pymc_extras/statespace/models/utilities.py,sha256=G9GuHKsghmIYOlfkPtvxBWF-FZY5-5JI1fJQM8N7EnE,15373
+pymc_extras/statespace/models/SARIMAX.py,sha256=Yppz_k1ZyZuKPC62WIye6K7luw44cP-dog73VVkw0L4,25096
+pymc_extras/statespace/models/VARMAX.py,sha256=7obJFXES9t9NONlcUQoeJ9TCqyoDlVat9FkPviQhAq0,25947
+pymc_extras/statespace/models/__init__.py,sha256=DUwPrwfnz9AUbgZOFvZeUpWEw5FiPAK5X9x7vZrRWqY,319
+pymc_extras/statespace/models/utilities.py,sha256=jpUYByAy6rMFP7l56uST1SEYchRa-clsFQ-At_1NLSw,27123
+pymc_extras/statespace/models/structural/__init__.py,sha256=jvbczE1IeNkhW7gMQ2vF2BhhKHeYyfD90mV-Awko-Vs,811
+pymc_extras/statespace/models/structural/core.py,sha256=n0cbP8_-NFLmflFF4x37AyOOIHcY5iylRrgTzjyOAhM,35374
+pymc_extras/statespace/models/structural/utils.py,sha256=Eze34Z0iXJzDC_gZEY2mHrp2VIYu8rHV915vM4U5Sn4,359
+pymc_extras/statespace/models/structural/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymc_extras/statespace/models/structural/components/autoregressive.py,sha256=HkS5an5fuNOBGcjHFNMUVNJrF1BNnlpQxvmPq_5dD0s,8021
+pymc_extras/statespace/models/structural/components/cycle.py,sha256=qEiGFGMEXKS2Tl_zgzKIp77ijGXCVq6UIHEZp_ErHSQ,13931
+pymc_extras/statespace/models/structural/components/level_trend.py,sha256=7glYX_tKOJPq6uB1NBuPQFFZGkhcwK4GMZUBTcU0xIY,11357
+pymc_extras/statespace/models/structural/components/measurement_error.py,sha256=5LHDx3IplNrWSGcsY3xJLywKPosTqr42jlrvm80ZApM,5316
+pymc_extras/statespace/models/structural/components/regression.py,sha256=27PRV9I64_VXIyjUi7pRr_gbk7sSI5DfJ4FBAbq5WCM,9856
+pymc_extras/statespace/models/structural/components/seasonality.py,sha256=soXJIZ2xewUhSUb5s2MGnxvnQCcir7ZgbgkSr94xEvc,26987
 pymc_extras/statespace/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymc_extras/statespace/utils/constants.py,sha256=Kf6j75ABaDQeRODxKQ76wTUQV4F5sTjn1KBcZgCQx20,2403
+pymc_extras/statespace/utils/constants.py,sha256=-4vCXo7-X3IuzdcplWBrAV9m9tm8JngcgoE-8imGmj0,2518
 pymc_extras/statespace/utils/coord_tools.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymc_extras/statespace/utils/data_tools.py,sha256=01sz6XDtLYK9I5xghxYpD-PuDzGXv9D-wFGfTV6FGEw,6566
+pymc_extras/statespace/utils/data_tools.py,sha256=Tomur7d8WCKlMXUCrPqufqVTKUe_nLLCHdipsM9pmaI,6620
 pymc_extras/utils/__init__.py,sha256=yxI9cJ7fCtVQS0GFw0y6mDGZIQZiK53vm3UNKqIuGSk,758
 pymc_extras/utils/linear_cg.py,sha256=KkXhuimFsrKtNd_0By2ApxQQQNm5FdBtmDQJOVbLYkA,10056
 pymc_extras/utils/model_equivalence.py,sha256=8QIftID2HDxD659i0RXHazQ-l2Q5YegCRLcDqb2p9Pc,2187
 pymc_extras/utils/prior.py,sha256=QlWVr7uKIK9VncBw7Fz3YgaASKGDfqpORZHc-vz_9gQ,6841
 pymc_extras/utils/spline.py,sha256=qGq0gcoMG5dpdazKFzG0RXkkCWP8ADPPXN-653-oFn4,4820
-pymc_extras-0.3.1.dist-info/METADATA,sha256=QxE1LJTwDeUfZzYZhDjhLA4sy0SX6UcXGDyeVC1dkmM,18881
-pymc_extras-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pymc_extras-0.3.1.dist-info/licenses/LICENSE,sha256=WjiLhUKEysJvy5e9jk6WwFv9tmAPtnov1uJ6gcH1kIs,11720
-pymc_extras-0.3.1.dist-info/RECORD,,
+pymc_extras-0.4.1.dist-info/METADATA,sha256=TpuX_8nEFjQfPlC51u_2EvQV3XwHAvgYCQMKYzeVU_E,18898
+pymc_extras-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pymc_extras-0.4.1.dist-info/licenses/LICENSE,sha256=WjiLhUKEysJvy5e9jk6WwFv9tmAPtnov1uJ6gcH1kIs,11720
+pymc_extras-0.4.1.dist-info/RECORD,,