diffkalman 0.1.0__py3-none-any.whl

diffkalman/__init__.py

@@ -0,0 +1,6 @@
+"""Top level module for diffkalman package."""
+from .filter import DiffrentiableKalmanFilter
+from .em_loop import em_updates
+
+
+__all__ = ['DiffrentiableKalmanFilter', 'em_updates']

diffkalman/em_loop.py

@@ -0,0 +1,115 @@
+"""The EM loop module that implements the EM algorithm for the Differentiable Kalman Filter."""
+
+from .filter import DiffrentiableKalmanFilter
+from .utils import SymmetricPositiveDefiniteMatrix
+import torch
+import torch.nn as nn
+
+
+__all__ = [
+    "em_updates",
+]
+
+
+def em_updates(
+    dkf: DiffrentiableKalmanFilter,
+    z_seq: torch.Tensor,
+    x0: torch.Tensor,
+    P0: torch.Tensor,
+    Q: SymmetricPositiveDefiniteMatrix,
+    R: SymmetricPositiveDefiniteMatrix,
+    optimizer: torch.optim.Optimizer,
+    lr_scheduler: torch.optim.lr_scheduler._LRScheduler,
+    num_cycles: int = 20,
+    num_epochs: int = 100,
+    h_args: tuple = (),
+    f_args: tuple = (),
+) -> dict:
+    """A sample implementation of the EM algorithm for the Differentiable Kalman Filter.
+
+    Args:
+        z (torch.Tensor): The noisy measurements sequence. Dimension: (seq_len, obs_dim)
+        x0 (torch.Tensor): The initial state vector. Dimension: (state_dim,)
+        P0 (torch.Tensor): The initial covariance matrix of the state vector. Dimension: (state_dim, state_dim)
+        Q (SymmetricPositiveDefiniteMatrix): The process noise covariance matrix module.
+        R (SymmetricPositiveDefiniteMatrix): The measurement noise covariance matrix module.
+        optimizer (torch.optim.Optimizer): The optimizer
+        lr_scheduler (torch.optim.lr_scheduler._LRScheduler): The learning rate scheduler
+        num_cycles (int): The number of cycles. Default: 20
+        num_epochs (int): The number of epochs. Default: 100
+        h_args (tuple): Additional arguments for the measurement model. Default: ()
+        f_args (tuple): Additional arguments for the transition function. Default: ()
+
+    Returns:
+        dict: log likelihoods of the model with respect to the number of epochs and cycles
+
+    Note:
+        - Use the SymmetricPositiveDefiniteMatrix module to ensure that the process noise covariance matrix Q and the measurement noise covariance matrix R are symmetric and positive definite.
+        - The optimizer and the learning rate scheduler should be initialized before calling this function.
+        - The measurement model and the transition function should be differentiable torch modules.
+    """
+    likelihoods = torch.zeros(num_epochs, num_cycles)
+
+    # Perform EM updates for num_epochs
+    for e in range(num_epochs):
+
+        ## The E-step
+        ## Without gradients tracking, get the posterior state distribution wrt current values of the parameters
+        with torch.no_grad():
+            posterior = dkf.sequence_smooth(
+                z_seq=z_seq,
+                x0=x0,
+                P0=P0,
+                Q=Q().repeat(len(z_seq), 1, 1),
+                R=R().repeat(len(z_seq), 1, 1),
+                f_args=f_args,
+                h_args=h_args,
+            )
+
+        ## The M-step (Update the parameters) with respect to the current posterior state distribution for num_cycles
+        for c in range(num_cycles):
+            # Zero the gradients
+            optimizer.zero_grad()
+
+            # Compute the marginal likelihood for logging
+            with torch.no_grad():
+                marginal_likelihood = dkf.marginal_log_likelihood(
+                    z_seq=z_seq,
+                    x0=x0,
+                    P0=P0,
+                    Q=Q().repeat(len(z_seq), 1, 1),
+                    R=R().repeat(len(z_seq), 1, 1),
+                    f_args=f_args,
+                    h_args=h_args,
+                )
+                likelihoods[e, c] = marginal_likelihood
+
+            # Perform the forward pass i.e compute the expected complete joint log-likelihood with respect previous posterior state distribution and current parameters
+            complete_log_likelihood = dkf.monte_carlo_expected_joint_log_likekihood(
+                z_seq=z_seq,
+                x0=x0,
+                P0=P0,
+                # below represents the posterior state distribution
+                x0_smoothed=posterior["x0_smoothed"],
+                P0_smoothed=posterior["P0_smoothed"],
+                x_smoothed=posterior["x_smoothed"],
+                P_smoothed=posterior["P_smoothed"],
+                Q_seq=Q().repeat(len(z_seq), 1, 1),
+                R_seq=R().repeat(len(z_seq), 1, 1),
+                f_args=f_args,
+                h_args=h_args,
+            )
+
+            # Update the parameters
+            (-complete_log_likelihood).backward()
+            optimizer.step()
+            lr_scheduler.step()
+
+            # Print the log likelihood
+            print(
+                f"Epoch {e + 1}/{num_epochs} Cycle {c + 1}/{num_cycles} Log Likelihood: {marginal_likelihood.item()}"
+            )
+
+    return {
+        "likelihoods": likelihoods,
+    }

diffkalman/filter.py

@@ -0,0 +1,654 @@
+"""
+This module provides a differentiable Kalman Filter implementation designed for linear and non-linear dynamical systems perturbed by Gaussian noise. 
+
+The Kalman Filter is implemented using the PyTorch library, allowing seamless integration with neural networks to parameterize the dynamics, observation, and noise models. These parameters are optimized using Stochastic Variational Inference (SVI), which is mathematically equivalent to the classical Expectation-Maximization (EM) algorithm. The Gaussian assumption ensures that the posterior distribution of states remains analytically tractable using Rauch-Tung-Striebel smoother equations. This tractability facilitates the maximization of the log-likelihood of the observed data, given the model parameters.
+
+Key Features:
+- Differentiable Kalman Filter implementation.
+- Flexible state transition and observation models (linear/non-linear, learnable, or fixed).
+- Automatic computation of Jacobians using PyTorch's autograd functionality.
+- Support for Monte Carlo sampling to evaluate the expected joint log-likelihood.
+
+Classes:
+    DifferentiableKalmanFilter: Implements the core Kalman Filter algorithm for linear and non-linear dynamical systems.
+
+Functions:
+    joint_jacobian_transform: Computes joint Jacobians for state and observation functions.
+    log_likelihood: Computes the log-likelihood for Gaussian distributions.
+    gaussian_log_likelihood: Computes Gaussian log-likelihoods for given inputs.
+
+Example:
+    # Define custom state transition and observation functions
+    f = MyStateTransitionFunction()
+    h = MyObservationFunction()
+
+    # Initialize the Kalman filter
+    kalman_filter = DifferentiableKalmanFilter(dim_x=4, dim_z=2, f=f, h=h)
+
+    # Perform filtering on a sequence of observations
+    results = kalman_filter.sequence_filter(
+        z_seq=observations,
+        x0=initial_state,
+        P0=initial_covariance,
+        Q=process_noise_covariance,
+        R=observation_noise_covariance,
+    )
+
+Dependencies:
+    - PyTorch: For deep learning integration and differentiability.
+    - Custom Modules: `joint_jacobian_transform`, `negative_log_likelihood`.
+
+__all__ = ["DifferentiableKalmanFilter"]
+"""
+
+import torch
+import torch.nn as nn
+from .joint_jacobian_transform import joint_jacobian_transform
+from .negative_log_likelihood import log_likelihood, gaussain_log_likelihood
+
+
+__all__ = ["DiffrentiableKalmanFilter"]
+
+
+class DiffrentiableKalmanFilter(nn.Module):
+    """
+    Implements a differentiable Kalman Filter for linear and non-linear dynamical systems.
+
+    This class provides methods for prediction, update, and smoothing, enabling filtering of
+    sequences of observations while allowing the use of learnable neural network models for
+    state transition and observation functions.
+
+    Args:
+        dim_x (int): Dimensionality of the state space.
+        dim_z (int): Dimensionality of the observation space.
+        f (nn.Module): State transition function, which can be linear/non-linear and learnable or fixed.
+        h (nn.Module): Observation function, which can be linear/non-linear and learnable or fixed.
+        mc_samples (int, optional): Number of Monte Carlo samples used for expected log-likelihood computation. Defaults to 100.
+
+    Attributes:
+        dim_x (int): Dimensionality of the state space.
+        dim_z (int): Dimensionality of the observation space.
+        f (nn.Module): State transition function.
+        h (nn.Module): Observation function.
+        I (torch.Tensor): Identity matrix of size `(dim_x, dim_x)`.
+        _f_joint (Callable): Joint Jacobian function of the state transition function.
+        _h_joint (Callable): Joint Jacobian function of the observation function.
+
+    Methods:
+        predict: Performs state prediction given the current state and covariance.
+        update: Updates the state estimate based on the current observation.
+        predict_update: Combines prediction and update steps for a single observation.
+        sequence_filter: Filters a sequence of observations to estimate states over time.
+        sequence_smooth: Smooths a sequence of observations for refined state estimates.
+
+    Note:
+        - PyTorch's autograd functionality is utilized to compute Jacobians of the state transition
+          and observation functions, eliminating the need for manual derivation.
+        - Monte Carlo sampling is used for approximating the expected log-likelihood in non-linear scenarios.
+    """
+
+    def __init__(
+        self, dim_x: int, dim_z: int, f: nn.Module, h: nn.Module, mc_samples: int = 100
+    ) -> None:
+        """Initializes the DiffrentiableKalmanFilter object.
+
+        Args:
+            dim_x (int): Dimensionality of the state space.
+            dim_z (int): Dimensionality of the observation space.
+            f (nn.Module): State transition function which can be parametrized by a neural network which can linear/non-linear and learnable or fixed.
+            h (nn.Module): Observation function which can be parametrized by a neural network which can linear/non-linear and learnable or fixed.
+            mc_samples (int): Number of Monte Carlo samples to draw to calcualte expected joint log-likelihood. Default is 100.
+
+        Returns:
+            None
+
+        Note:
+            - The state transition function signature is f(x: torch.Tensor, *args) -> torch.Tensor.
+            - The observation function signature is h(x: torch.Tensor, *args) -> torch.Tensor.
+        """
+
+        super().__init__()
+
+        # Store the dimensionality of the state and observation space
+        self.dim_x = dim_x
+        self.dim_z = dim_z
+
+        # Store the state transition and observation functions
+        self.f = f
+        self.h = h
+
+        # Store the number of Monte Carlo samples
+        self.mc_samples = mc_samples
+
+        # Register the Jacobian functions of the state transition and observation functions
+        self._f_joint = joint_jacobian_transform(self.f)
+        self._h_joint = joint_jacobian_transform(self.h)
+
+        # Identity matrix of shape (dim_x, dim_x)
+        self.register_buffer("I", torch.eye(dim_x))
+
+    def predict(
+        self,
+        x: torch.Tensor,
+        P: torch.Tensor,
+        Q: torch.Tensor,
+        f_args: tuple = (),
+    ) -> dict[str, torch.Tensor]:
+        """
+        Predicts the next state given the current state and the state transition function.
+
+        Args:
+            x (torch.Tensor): Current state estimate of shape `(dim_x,)`.
+            P (torch.Tensor): Current state covariance of shape `(dim_x, dim_x)`.
+            Q (torch.Tensor): Process noise covariance of shape `(dim_x, dim_x)`.
+            f_args (tuple, optional): Additional arguments to the state transition function.
+
+        Returns:
+            dict[str, torch.Tensor]:
+                - `x_prior`: Predicted state estimate of shape `(dim_x,)`.
+                - `P_prior`: Predicted state covariance of shape `(dim_x, dim_x)`.
+                - `state_jacobian`: Jacobian of the state transition function of shape `(dim_x, dim_x)`.
+
+        Note:
+            - The control input, if any, can be incorporated into the state transition function by passing it as an argument in `f_args`.
+        """
+        # Compute the predicted state estimate and covariance
+        F, x_prior = self._f_joint(x, *f_args)
+
+        P_prior = F @ P @ F.T + Q
+
+        return {"x_prior": x_prior, "P_prior": P_prior, "state_jacobian": F}
+
+    def update(
+        self,
+        z: torch.Tensor,
+        x_prior: torch.Tensor,
+        P_prior: torch.Tensor,
+        R: torch.Tensor,
+        h_args: tuple = (),
+    ) -> dict[str, torch.Tensor]:
+        """
+        Updates the state estimate based on the current observation and observation model.
+
+        Args:
+            x (torch.Tensor): Predicted state estimate of shape `(dim_x,)`.
+            P (torch.Tensor): Predicted state covariance of shape `(dim_x, dim_x)`.
+            z (torch.Tensor): Current observation of shape `(dim_z,)`.
+            R (torch.Tensor): Observation noise covariance of shape `(dim_z, dim_z)`.
+            h_args (tuple, optional): Additional arguments to the observation function.
+
+        Returns:
+            dict[str, torch.Tensor]:
+                - `x_post`: Updated state estimate of shape `(dim_x,)`.
+                - `P_post`: Updated state covariance of shape `(dim_x, dim_x)`.
+                - `y`: Observation residual (innovation) of shape `(dim_z,)`.
+                - `S`: Innovation covariance of shape `(dim_z, dim_z)`.
+                - `K`: Kalman gain of shape `(dim_x, dim_z)`.
+
+        Note:
+            - PyTorch's autograd is used to compute the Jacobian of the observation function, ensuring compatibility with differentiable models.
+        """
+        # Compute the jacboian of the observation function
+        H, z_pred = self._h_joint(x_prior, *h_args)
+
+        # Compute the innovation
+        y = z - z_pred
+        # Compute the innovation covariance matrix
+        S = H @ P_prior @ H.T + R
+        # Compute the Kalman gain
+        K = P_prior @ H.T @ torch.linalg.inv(S)
+
+        # Update the state vector
+        x_post = x_prior + K @ y
+        # Update the state covariance matrix using joseph form
+        factor = self.I - K @ H
+        P_post = factor @ P_prior @ factor.T + K @ R @ K.T
+
+        return {
+            "x_post": x_post,
+            "P_post": P_post,
+            "innovation": y,
+            "innovation_covariance": S,
+            "observation_jacobian": H,
+            "kalman_gain": K,
+        }
+
+    def predict_update(
+        self,
+        z: torch.Tensor,
+        x: torch.Tensor,
+        P: torch.Tensor,
+        Q: torch.Tensor,
+        R: torch.Tensor,
+        f_args: tuple = (),
+        h_args: tuple = (),
+    ) -> dict[str, torch.Tensor]:
+        """
+        Combines prediction and update steps for a single observation.
+
+        Args:
+            x (torch.Tensor): Current state estimate of shape `(dim_x,)`.
+            P (torch.Tensor): Current state covariance of shape `(dim_x, dim_x)`.
+            z (torch.Tensor): Current observation of shape `(dim_z,)`.
+            Q (torch.Tensor): Process noise covariance of shape `(dim_x, dim_x)`.
+            R (torch.Tensor): Observation noise covariance of shape `(dim_z, dim_z)`.
+            f_args (tuple, optional): Additional arguments to the state transition function.
+            h_args (tuple, optional): Additional arguments to the observation function.
+
+        Returns:
+            dict[str, torch.Tensor]:
+                - `x_post`: Updated state estimate of shape `(dim_x,)`.
+                - `P_post`: Updated state covariance of shape `(dim_x, dim_x)`.
+                - `y`: Observation residual (innovation) of shape `(dim_z,)`.
+                - `S`: Innovation covariance of shape `(dim_z, dim_z)`.
+                - `K`: Kalman gain of shape `(dim_x, dim_z)`.
+
+        Note:
+            - This method is particularly useful for real-time filtering where observations arrive sequentially.
+        """
+        # Predict the next state
+        prediction = self.predict(x=x, P=P, Q=Q, f_args=f_args)
+
+        # Update the state estimate
+        update = self.update(
+            z=z,
+            x_prior=prediction["x_prior"],
+            P_prior=prediction["P_prior"],
+            R=R,
+            h_args=h_args,
+        )
+
+        return {**prediction, **update}
+
+    def sequence_filter(
+        self,
+        z_seq: torch.Tensor,
+        x0: torch.Tensor,
+        P0: torch.Tensor,
+        Q: torch.Tensor,
+        R: torch.Tensor,
+        f_args: tuple = (),
+        h_args: tuple = (),
+    ) -> dict[str, torch.Tensor]:
+        """
+        Filters a sequence of observations to estimate states over time.
+
+        Args:
+            z_seq (torch.Tensor): Sequence of observations of shape `(T, dim_z)`, where `T` is the number of time steps.
+            x0 (torch.Tensor): Initial state estimate of shape `(dim_x,)`.
+            P0 (torch.Tensor): Initial state covariance of shape `(dim_x, dim_x)`.
+            Q (torch.Tensor): Process noise covariance of shape `(T, dim_x, dim_x)`.
+            R (torch.Tensor): Observation noise covariance of shape `(T, dim_z, dim_z)`.
+            f_args (tuple, optional): Additional arguments to the state transition function.
+            h_args (tuple, optional): Additional arguments to the observation function.
+
+        Returns:
+            dict[str, torch.Tensor]:
+                - `x_filtered`: Filtered state estimates of shape `(T, dim_x)`.
+                - `P_filtered`: Filtered state covariances of shape `(T, dim_x, dim_x)`.
+
+        Note:
+            - Each time step is processed iteratively using the `predict` and `update` methods.
+        """
+        # Get the sequence length
+        T = z_seq.size(0)
+
+        # Initialize the output tensors
+        outs_terms = [
+            "x_prior",
+            "P_prior",
+            "x_post",
+            "P_post",
+            "state_jacobian",
+            "innovation",
+            "innovation_covariance",
+            "observation_jacobian",
+            "kalman_gain",
+        ]
+        outputs = {term: [] for term in outs_terms}
+
+        # Run the Kalman Filter sequentially
+        for t in range(T):
+            # Predict the next state
+            results = self.predict_update(
+                z=z_seq[t],
+                x=x0 if t == 0 else outputs["x_post"][-1],
+                P=P0 if t == 0 else outputs["P_post"][-1],
+                Q=Q[t],
+                R=R[t],
+                f_args=(args[t] for args in f_args),
+                h_args=(args[t] for args in h_args),
+            )
+
+            # Update the output tensors
+            for term in outs_terms:
+                outputs[term].append(results[term])
+
+        # Stack the output tensors
+        for term in outs_terms:
+            outputs[term] = torch.stack(outputs[term])
+
+        # Calculate the log-likelihood
+        log_like = log_likelihood(
+            innovation=outputs["innovation"],
+            innovation_covariance=outputs["innovation_covariance"],
+        )
+        outputs["log_likelihood"] = log_like
+
+        return outputs
+
+    def marginal_log_likelihood(
+        self,
+        z_seq: torch.Tensor,
+        x0: torch.Tensor,
+        P0: torch.Tensor,
+        Q: torch.Tensor,
+        R: torch.Tensor,
+        f_args: tuple = (),
+        h_args: tuple = (),
+    ) -> torch.Tensor:
+        """
+        Computes the marginal log-likelihood of the observed data given the model parameters.
+
+        Args:
+            z_seq (torch.Tensor): Sequence of observations of shape `(T, dim_z)`, where `T` is the number of time steps.
+            x0 (torch.Tensor): Initial state estimate of shape `(dim_x,)`.
+            P0 (torch.Tensor): Initial state covariance of shape `(dim_x, dim_x)`.
+            Q (torch.Tensor): Process noise covariance of shape `(T, dim_x, dim_x)`.
+            R (torch.Tensor): Observation noise covariance of shape `(T, dim_z, dim_z)`.
+            f_args (tuple, optional): Additional arguments to the state transition function.
+            h_args (tuple, optional): Additional arguments to the observation function.
+
+        Returns:
+            torch.Tensor: The marginal log-likelihood of the observed data given the model parameters.
+        """
+        # Run the Kalman Filter and only track innovation and innovation covariance
+        innov = []
+        innov_cov = []
+
+        # Initialize the state estimate
+        x_post = x0
+        P_post = P0
+
+        for t in range(z_seq.size(0)):
+            # Predict the next state
+            prediction = self.predict(
+                x=x_post,
+                P=P_post,
+                Q=Q[t],
+                f_args=(args[t] for args in f_args),
+            )
+
+            # Update the state estimate
+            update = self.update(
+                z=z_seq[t],
+                x_prior=prediction["x_prior"],
+                P_prior=prediction["P_prior"],
+                R=R[t],
+                h_args=(args[t] for args in h_args),
+            )
+
+            # Update the state estimate
+            x_post = update["x_post"]
+            P_post = update["P_post"]
+
+            # Store the innovation and innovation covariance
+            innov.append(update["innovation"])
+            innov_cov.append(update["innovation_covariance"])
+
+        return log_likelihood(
+            innovation=torch.stack(innov),
+            innovation_covariance=torch.stack(innov_cov),
+        )
+
+    def rauch_tung_striebel_smoothing(
+        self,
+        x0: torch.Tensor,
+        P0: torch.Tensor,
+        x_prior: torch.Tensor,
+        P_prior: torch.Tensor,
+        x_filtered: torch.Tensor,
+        P_filtered: torch.Tensor,
+        state_jacobian: torch.Tensor,
+    ) -> dict[str, torch.Tensor]:
+        """
+        Smooths a sequence of filtered states for refined estimates over time.
+
+        Args:
+            x_filtered (torch.Tensor): Filtered state estimates of shape `(T, dim_x)`.
+            P_filtered (torch.Tensor): Filtered state covariances of shape `(T, dim_x, dim_x)`.
+            Q (torch.Tensor): Process noise covariance of shape `(dim_x, dim_x)`.
+            f_args (tuple, optional): Additional arguments to the state transition function.
+
+        Returns:
+            dict[str, torch.Tensor]:
+                - `x_smoothed`: Smoothed state estimates of shape `(T, dim_x)`.
+                - `P_smoothed`: Smoothed state covariances of shape `(T, dim_x, dim_x)`.
+
+        Note:
+            - This method uses Rauch-Tung-Striebel smoothing equations to refine the estimates.
+            - Smoothed states incorporate information from future observations, improving the overall estimation accuracy.
+        """
+
+        # Initialize the output tensors
+        outs_terms = ["x_smoothed", "P_smoothed", "smoothing_gain"]
+        outputs = {term: [] for term in outs_terms}
+
+        # Last state estimate is already the smoothed state estimate
+        # by definition
+        outputs["x_smoothed"].append(x_filtered[-1])
+        outputs["P_smoothed"].append(P_filtered[-1])
+
+        # Sequence length
+        T = x_filtered.size(0)
+
+        # Start the backward-recursion form the second last time step
+        # to the first time step
+        for t in range(T - 2, -1, -1):
+            # Compute the smoothing gain
+            L = (
+                P_filtered[t]
+                @ state_jacobian[t + 1].T
+                @ torch.linalg.inv(P_prior[t + 1])
+            )
+            # Insert the smoothing gain into the output tensor
+            outputs["smoothing_gain"].insert(0, L)
+            # Compute the smoothed state estimate
+            outputs["x_smoothed"].insert(
+                0, x_filtered[t] + L @ (outputs["x_smoothed"][0] - x_prior[t + 1])
+            )
+            # Compute the smoothed state covariance
+            outputs["P_smoothed"].insert(
+                0, P_filtered[t] + L @ (outputs["P_smoothed"][0] - P_prior[t + 1]) @ L.T
+            )
+
+        # Smoothed the initial state estimate
+        L0 = P0 @ state_jacobian[0].T @ torch.linalg.inv(P_prior[0])
+        outputs["smoothing_gain"].insert(0, L0)
+        x0_smoothed = x0 + L0 @ (outputs["x_smoothed"][0] - x_prior[0])
+        P0_smoothed = P0 + L0 @ (outputs["P_smoothed"][0] - P_prior[0]) @ L0.T
+
+        return {
+            "x_smoothed": torch.stack(outputs["x_smoothed"]),
+            "P_smoothed": torch.stack(outputs["P_smoothed"]),
+            "smoothing_gain": torch.stack(outputs["smoothing_gain"]),
+            "x0_smoothed": x0_smoothed,
+            "P0_smoothed": P0_smoothed,
+        }
+
+    def sequence_smooth(
+        self,
+        z_seq: torch.Tensor,
+        x0: torch.Tensor,
+        P0: torch.Tensor,
+        Q: torch.Tensor,
+        R: torch.Tensor,
+        f_args: tuple = (),
+        h_args: tuple = (),
+    ) -> dict[str, torch.Tensor]:
+        """
+        Applies a smoothing algorithm to a sequence of observations using a two-step process:
+        Kalman filtering followed by Rauch-Tung-Striebel smoothing.
+
+        Args:
+            z_seq (torch.Tensor): Sequence of observations with shape `(seq_len, dim_z)`.
+            x0 (torch.Tensor): Initial state estimate with shape `(dim_x,)`.
+            P0 (torch.Tensor): Initial state covariance matrix with shape `(dim_x, dim_x)`.
+            Q (torch.Tensor): Process noise covariance matrix with shape `(seq_len, dim_x, dim_x)`.
+            R (torch.Tensor): Observation noise covariance matrix with shape `(seq_len, dim_z, dim_z)`.
+            f_args (tuple): Optional sequence of additional arguments for the state transition function.
+            h_args (tuple): Optional sequence of additional arguments for the observation function.
+
+        Returns:
+            dict[str, torch.Tensor]: A dictionary containing:
+                - Filtered state estimates (`x_post`) and covariances (`P_post`).
+                - Smoothed state estimates (`x_smooth`) and covariances (`P_smooth`).
+
+        Notes:
+            - The `f_args` and `h_args` sequences correspond to specific time steps.
+            - For time-invariant `Q` or `R`, use PyTorch's `repeat` functionality to create sequences.
+        """
+        # Run the Kalman Filter
+        filter_results = self.sequence_filter(
+            z_seq=z_seq,
+            x0=x0,
+            P0=P0,
+            Q=Q,
+            R=R,
+            f_args=f_args,
+            h_args=h_args,
+        )
+
+        # Run the Rauch-Tung-Striebel Smoothing
+        smooth_results = self.rauch_tung_striebel_smoothing(
+            x0=x0,
+            P0=P0,
+            x_prior=filter_results["x_prior"],
+            P_prior=filter_results["P_prior"],
+            x_filtered=filter_results["x_post"],
+            P_filtered=filter_results["P_post"],
+            state_jacobian=filter_results["state_jacobian"],
+        )
+
+        return {**filter_results, **smooth_results}
+
+    def draw_samples(
+        self, n_samples: int, mu: torch.Tensor, P: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        Generates samples from a multivariate normal distribution parameterized
+        by a mean vector and covariance matrix.
+
+        Args:
+            n_samples (int): Number of samples to generate.
+            mu (torch.Tensor): Mean vector of the distribution with shape `(dim_x,)`.
+            P (torch.Tensor): Covariance matrix of the distribution with shape `(dim_x, dim_x)`.
+
+        Returns:
+            torch.Tensor: A tensor of generated samples with shape `(n_samples, dim_x)`.
+
+        Notes:
+            - Cholesky decomposition is used to ensure numerical stability.
+            - The samples are drawn using PyTorch's distribution utilities.
+        """
+        # Draw samples from a multivariate normal distribution
+        X_unit_samples = (
+            torch.distributions.MultivariateNormal(
+                loc=torch.zeros(self.dim_x), covariance_matrix=torch.eye(self.dim_x)
+            )
+            .sample((n_samples,))
+            .to(device=mu.device, dtype=mu.dtype)
+        )
+
+        return mu + torch.einsum("kk,jk->jk", torch.linalg.cholesky(P), X_unit_samples)
+
+    def monte_carlo_expected_joint_log_likekihood(
+        self,
+        z_seq: torch.Tensor,
+        x0: torch.Tensor,
+        P0: torch.Tensor,
+        x0_smoothed: torch.Tensor,
+        P0_smoothed: torch.Tensor,
+        x_smoothed: torch.Tensor,
+        P_smoothed: torch.Tensor,
+        Q_seq: torch.Tensor,
+        R_seq: torch.Tensor,
+        f_args: tuple = (),
+        h_args: tuple = (),
+    ) -> torch.Tensor:
+        """
+        This function computes the Monte Carlo approximation of the expected joint log-likelihood 
+        of the observed data given the posterior distribution of the states.
+
+        The posterior distribution of the states is derived from the smoothed state estimates, 
+        which are tractable and exact in the case of linear Gaussian models. This simplifies the 
+        process compared to a full-fledged Variational Inference (VI) approach, where the posterior 
+        distribution is approximated using a variational distribution. Here, the exact posterior 
+        distribution is used, as it is directly obtained from the smoothing algorithm, eliminating 
+        the need for variational approximations.
+
+        In the case where the dynamics and observation models are parameterized by neural networks, 
+        the variational distribution corresponds to the exact posterior distribution over the unknown 
+        variables (e.g., parameters of the models). This formulation maintains computational efficiency 
+        while leveraging the expressiveness of neural networks for system modeling.
+
+        Args:
+            z_seq (torch.Tensor): Sequence of observations of shape (seq_len, dim_z).\
+            x0 (torch.Tensor): Initial state estimate of shape (dim_x,).
+            P0 (torch.Tensor): Initial state covariance of shape (dim_x, dim_x).
+            x0_smoothed (torch.Tensor): Initial smoothed state estimate of shape (dim_x,).
+            P0_smoothed (torch.Tensor): Initial smoothed state covariance of shape (dim_x, dim_x).
+            x_smoothed (torch.Tensor): Smoothed state estimates of shape (seq_len, dim_x).
+            P_smoothed (torch.Tensor): Smoothed state covariances of shape (seq_len, dim_x, dim_x).
+            Q_seq (torch.Tensor): Process noise covariance of shape (seq_len, dim_x, dim_x).
+            R_seq (torch.Tensor): Observation noise covariance of shape (seq_len, dim_z, dim_z).
+            f_args (tuple): Additional arguments to the state transition function.
+            h_args (tuple): Additional arguments to the observation function.
+
+       
+        Returns:
+            torch.Tensor: The Monte Carlo approximation of the expected joint log-likelihood.
+        """
+        # Loop to calculate the monte-carlo approximation of the expected joint log-likelihood
+        E_log_likelihood = 0.0
+        # Here we will use the vmap function to vectorize the computation of the log-likelihood
+        vllf = torch.vmap(
+            func=gaussain_log_likelihood,
+            in_dims=(0, None),
+        )
+
+        # Draw samples from the smoothed initial distribution
+        X0_samples = self.draw_samples(
+            n_samples=self.mc_samples,
+            mu=x0_smoothed,
+            P=P0_smoothed,
+        )
+        innov_x0 = X0_samples - x0
+        E_log_likelihood += vllf(innov_x0, P0).mean()
+
+        # For each measurement calculate the expected log-likelihood
+        for i in range(z_seq.size(0)):
+            # Calculate the measurement term
+            Xt = self.draw_samples(
+                n_samples=self.mc_samples,
+                mu=x_smoothed[i],
+                P=P_smoothed[i],
+            )
+            innov_z = z_seq[i] - torch.vmap(
+                lambda x: self.h(x, *(args[i] for args in h_args)),
+            )(Xt)
+            E_log_likelihood += vllf(innov_z, R_seq[i]).mean()
+
+            # Calculate the transition term
+            Xp = self.draw_samples(
+                n_samples=self.mc_samples,
+                mu=x_smoothed[i - 1] if i > 0 else x0_smoothed,
+                P=P_smoothed[i - 1] if i > 0 else P0_smoothed,
+            )
+            innov_x = Xt - torch.vmap(
+                lambda x: self.f(x, *(args[i] for args in f_args)),
+            )(Xp)
+
+            E_log_likelihood += vllf(innov_x, Q_seq[i]).mean()
+
+        return E_log_likelihood

diffkalman/joint_jacobian_transform.py

@@ -0,0 +1,54 @@
+"""Joint Jacobian Transformation to compute the Jacobian of a function with respect to its first argument and the function output."""
+
+from torch.func import jacrev
+
+__all__ = ["joint_jacobian_transform"]
+
+
+def joint_jacobian_transform(f: callable) -> callable:
+    """
+    Transforms a given function f into a joint function that returns both the
+    function's output and its Jacobian matrix with respect to its first argument.
+
+    The transformed function, when called, returns a tuple where the first element
+    is the Jacobian matrix of the function `f` with respect to its first argument
+    and the second element is the output of the function `f`.
+
+    Args:
+        f (callable): The function to be transformed. It should be of the form
+                      `f(x, *args)` where `x` is the variable with respect to
+                      which the Jacobian is computed and `*args` are additional
+                      arguments.
+
+    Returns:
+        callable: A new function `F` such that `F(x, *args)` returns a tuple
+                  `(Df(x, *args), f(x, *args))`, where `Df(x, *args)` is the
+                  Jacobian matrix of `f` with respect to `x` and `f(x, *args)`
+                  is the original output of `f`.
+
+    Example:
+        >>> def my_function(x, a, b):
+        >>>     return a * x + b
+        >>>
+        >>> F = joint_jacobian_transform(my_function)
+        >>> x = torch.tensor([1.0, 2.0])
+        >>> a = torch.tensor([2.0])
+        >>> b = torch.tensor([3.0])
+        >>> jacobian, output = F(x, a, b)
+        >>> print(jacobian)  # Jacobian of my_function with respect to x
+        >>> print(output)    # Output of my_function
+    """
+
+    # Define the new joint function
+    def joint_func(*args, **kwargs):
+        # Compute the output of the function
+        output = f(*args, **kwargs)
+        return output, output
+
+    # The new joint jacrev function
+    Df = jacrev(
+        func=joint_func,
+        argnums=0,
+        has_aux=True,
+    )
+    return Df

diffkalman/negative_log_likelihood.py

@@ -0,0 +1,133 @@
+"""
+Utility functions for calculating negative log likelihood of observations.
+
+This module provides functions to compute the negative log likelihood of a sequence of observations given 
+their predicted values and associated covariance matrices. The negative log likelihood quantifies the 
+likelihood of observing the data under a given model, incorporating uncertainties in the measurements.
+
+The negative log likelihood for a sequence of innovations and their covariances is computed using the 
+logarithm of the joint distribution of the observations given the parameters. It is expressed mathematically as:
+
+$$
+\ln(\mathcal{L}(\Phi \mid \mathcal{D})) = -\frac{nk}{2} \ln(2\pi) - \frac{1}{2} \sum_{i=1}^{n} \left[ \ln |S_{i}| + \Delta y_{i}^T S_{i}^{-1} \Delta y_i \right]
+$$
+
+where $ n $ is the sequence length, $ k $ is the dimension of the innovation vector, 
+$ \Delta y_i $ is the innovation vector at time step $ i $, and $ S_i $ is the innovation 
+covariance matrix at time step $ i $.
+
+Functions:
+- `likelihood_at_time`: Calculates likelihood at a single time step.
+- `log_likelihood`: Computes total log likelihood for a sequence of time steps.
+- `negative_log_likelihood`: Computes total negative log likelihood for a sequence of time steps.
+
+Note:
+- The constant factor $ \frac{nk}{2} \ln(2\pi) $ is skipped in the implementation since it does not affect the optimization process.
+"""
+
+import torch
+
+__all__ = ["gaussain_log_likelihood", "log_likelihood"]
+
+
+def gaussain_log_likelihood(
+    innovation: torch.Tensor,
+    innovation_covariance: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Calculates the likelihood estimation at a single time step.
+
+    Args:
+        innovation (torch.Tensor): The innovation vector, representing the difference
+                                   between the observed and predicted measurements.
+                                   Shape: (dim_z,)
+        innovation_covariance (torch.Tensor): The innovation covariance matrix,
+                                              representing the uncertainty in the innovation.
+                                              Shape: (dim_z, dim_z)
+
+    Returns:
+        torch.Tensor: The loss value for the given innovation and its covariance.
+
+    Note:
+        - The dimension factor is skipped since it is a constant and does not affect the optimization.
+
+    Example:
+        >>> innovation = torch.tensor([1.0, 2.0])
+        >>> innovation_covariance = torch.tensor([[1.0, 0.0], [0.0, 1.0]])
+        >>> loss = likelihood_at_time(innovation, innovation_covariance)
+        >>> print(loss)
+    """
+    # Calculate the log determinant of the innovation covariance matrix
+    log_det = torch.linalg.slogdet(innovation_covariance)[1]
+
+    k = innovation.shape[0]
+    C = (-k / 2) * torch.log(
+        2 * torch.tensor(torch.pi, dtype=innovation.dtype, device=innovation.device)
+    )
+    return C - 0.5 * (
+        log_det + innovation @ torch.linalg.inv(innovation_covariance) @ innovation
+    )
+
+
+def log_likelihood(
+    innovation: torch.Tensor,
+    innovation_covariance: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Calculates the log likelihood estimation for a sequence of time steps.
+
+    Args:
+        innovation (torch.Tensor): The innovation vector for each time step,
+                                   representing the differences between observed and predicted
+                                   measurements over a sequence. Shape: (seq_len, dim_z)
+        innovation_covariance (torch.Tensor): The innovation covariance matrix for each time step,
+                                              representing the uncertainty in the innovations
+                                              over a sequence. Shape: (seq_len, dim_z, dim_z)
+
+    Returns:
+        torch.Tensor: The total log likelihood value for the sequence of innovations and
+                      their covariances.
+
+    Example:
+        >>> innovation = torch.tensor([[1.0, 2.0], [0.5, 1.5]])
+        >>> innovation_covariance = torch.tensor([
+        >>>     [[1.0, 0.0], [0.0, 1.0]],
+        >>>     [[0.5, 0.0], [0.0, 0.5]]
+        >>> ])
+        >>> total_log_likelihood = log_likelihood(innovation, innovation_covariance)
+        >>> print(total_log_likelihood)
+    """
+    return torch.vmap(gaussain_log_likelihood, in_dims=0)(
+        innovation, innovation_covariance
+    ).sum()
+
+
+def negative_log_likelihood(
+    innovation: torch.Tensor,
+    innovation_covariance: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Calculates the negative log likelihood estimation for a sequence of time steps.
+
+    Args:
+        innovation (torch.Tensor): The innovation vector for each time step,
+                                   representing the differences between observed and predicted
+                                   measurements over a sequence. Shape: (seq_len, dim_z)
+        innovation_covariance (torch.Tensor): The innovation covariance matrix for each time step,
+                                              representing the uncertainty in the innovations
+                                              over a sequence. Shape: (seq_len, dim_z, dim_z)
+
+    Returns:
+        torch.Tensor: The total negative log likelihood value for the sequence of innovations and
+                      their covariances.
+
+    Example:
+        >>> innovation = torch.tensor([[1.0, 2.0], [0.5, 1.5]])
+        >>> innovation_covariance = torch.tensor([
+        >>>     [[1.0, 0.0], [0.0, 1.0]],
+        >>>     [[0.5, 0.0], [0.0, 0.5]]
+        >>> ])
+        >>> total_negative_log_likelihood = negative_log_likelihood(innovation, innovation_covariance)
+        >>> print(total_negative_log_likelihood)
+    """
+    return -log_likelihood(innovation, innovation_covariance)

diffkalman/utils.py

@@ -0,0 +1,90 @@
+"""Implementation of utility modules for the differentiable Kalman filter."""
+
+import torch
+import torch.nn as nn
+
+__all__ = [
+    "SymmetricPositiveDefiniteMatrix",
+    "DiagonalSymmetricPositiveDefiniteMatrix",
+]
+
+
+class SymmetricPositiveDefiniteMatrix(nn.Module):
+    """
+    Module for ensuring a symmetric positive definite matrix using a parameterized approach.
+
+    This module constructs a symmetric positive definite matrix from an initial matrix Q_0.
+    It ensures that the resultant matrix is symmetric and has positive eigenvalues.
+
+    Attributes:
+        LT_mask (torch.Tensor): Lower triangular mask used for parameter initialization.
+        W (nn.Parameter): Parameter representing the input matrix adjusted for symmetry and positivity.
+
+    Methods:
+        forward():
+            Performs the forward pass of the module.
+            Returns a symmetric positive definite matrix derived from the input parameter.
+    """
+
+    def __init__(self, M: torch.Tensor, trainable: bool = True):
+        """
+        Initializes the SymmetricPositiveDefiniteMatrix module.
+
+        Args:
+            M (torch.Tensor): Initial matrix for the parameter.
+            trainable (bool): Flag to indicate whether the parameter is trainable. Default: True.
+        """
+        super().__init__()
+
+        # Cholesky decomposition of the initial matrix
+        L = torch.linalg.cholesky(M, upper=False)
+
+        # Initialize the parameter with the lower triangular part of the Cholesky decomposition
+        self.W = nn.Parameter(L, requires_grad=trainable)
+
+        # Mask for the diagonal entries
+        self.diag_mask = torch.eye(M.shape[0], dtype=torch.bool)
+
+    def forward(self) -> torch.Tensor:
+        """
+        Forward pass of the SymmetricPositiveDefiniteMatrix module.
+
+        Returns:
+            torch.Tensor: Symmetric positive definite matrix derived from the input parameter.
+        """
+        # Make the diagonal entries positive
+        L = torch.tril(self.W)
+        L[self.diag_mask] = torch.abs(L[self.diag_mask])
+
+        return L @ L.T
+
+
+class DiagonalSymmetricPositiveDefiniteMatrix(nn.Module):
+    """
+    A PyTorch module representing a diagonal symmetric positive definite matrix.
+
+    This module takes a diagonal matrix `M` as input and constructs a diagonal symmetric positive definite matrix `W`.
+    The diagonal entries of `W` are initialized with the diagonal entries of `M` and can be trained if `trainable` is set to True.
+
+    Args:
+        M (torch.Tensor): The diagonal matrix used to initialize the diagonal entries of `W`.
+        trainable (bool, optional): Whether the diagonal entries of `W` should be trainable. Defaults to True.
+
+    Returns:
+        torch.Tensor: The diagonal symmetric positive definite matrix `W`.
+    """
+
+    def __init__(self, M: torch.Tensor, trainable: bool = True):
+        super().__init__()
+
+        self.W = nn.Parameter(torch.diag(M.diagonal()), requires_grad=trainable)
+
+    def forward(self) -> torch.Tensor:
+        """
+        Forward pass of the module.
+
+        Returns:
+            torch.Tensor: The diagonal symmetric positive definite matrix `W`.
+        """
+        # Make the diagonal entries positive
+        return torch.abs(self.W)

diffkalman-0.1.0.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: diffkalman
+Version: 0.1.0
+Summary: A diffrentiable kalman filter library for auto-tuning kalman filters.
+Author-email: hades <nischalbhattaraipi@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: numpy>=2.2.1
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: cpu
+Requires-Dist: torch>=2.5.1; extra == 'cpu'
+Provides-Extra: cu124
+Requires-Dist: torch>=2.5.1; extra == 'cu124'
+Description-Content-Type: text/markdown
+
+# Differentiable Kalman Filter
+
+A PyTorch-based implementation of a differentiable Kalman Filter designed for both linear and non-linear dynamical systems with Gaussian noise. This module seamlessly integrates with neural networks, enabling learnable dynamics, observation, and noise models optimized through Stochastic Variational Inference (SVI).
+
+## Features
+
+- **Fully Differentiable**: End-to-end differentiable implementation compatible with PyTorch's autograd
+- **Flexible Models**: Support for both linear and non-linear state transition and observation models
+- **Neural Network Integration**: Models can be parameterized using neural networks
+- **Automatic Jacobian Computation**: Utilizes PyTorch's autograd for derivative calculations
+- **Monte Carlo Sampling**: Supports evaluation of expected joint log-likelihood to perform Expectation-Maximization (EM) learning
+- **Rauch-Tung-Striebel Smoothing**: Implements forward-backward smoothing for improved state estimation using RTS algorithm
+
+## Installation
+
+```bash
+pip install torch  # Required dependency
+# Add your package installation command here
+```
+
+## Quick Start
+
+Here's a simple example of using the Differentiable Kalman Filter:
+
+```python
+import torch
+from diffkalman import DifferentiableKalmanFilter
+from diffkalman.utils import SymmetricPositiveDefiniteMatrix
+from diffkalman.em_loop import em_updates
+
+# Define custom state transition and observation functions
+class StateTransition(torch.nn.Module):
+    def forward(self, x, *args):
+        # Your state transition logic here
+        return x
+
+class ObservationModel(torch.nn.Module):
+    def forward(self, x, *args):
+        # Your observation logic here
+        return x
+
+# Initialize the filter
+f = StateTransition()
+h = ObservationModel()
+Q = SymmetricPositiveDefiniteMatrix(dim=4, trainable=True)
+R = SymmetricPositiveDefiniteMatrix(dim=2, trainable=True)
+kalman_filter = DifferentiableKalmanFilter(
+    dim_x=4,  # State dimension
+    dim_z=2,  # Observation dimension
+    f=f,      # State transition function
+    h=h       # Observation function
+)
+
+# Run the filter
+results = kalman_filter.sequence_filter(
+    z_seq=observations,           # Shape: (T, dim_z)
+    x0=initial_state,            # Shape: (dim_x,)
+    P0=initial_covariance,       # Shape: (dim_x, dim_x)
+    Q=Q().repeat(len(observations), 1, 1),  # Shape: (T, dim_x, dim_x)
+    R=R().repeat(len(observations), 1, 1)   # Shape: (T, dim_z, dim_z)
+)
+```
+
+## Detailed Usage
+
+### State Estimation
+
+The module provides three main estimation methods:
+
+1. **Filtering**: Forward pass only
+```python
+filtered_results = kalman_filter.sequence_filter(
+    z_seq=observations,
+    x0=initial_state,
+    P0=initial_covariance,
+    Q=process_noise,
+    R=observation_noise
+)
+```
+
+2. **Smoothing**: Forward-backward pass
+```python
+smoothed_results = kalman_filter.sequence_smooth(
+    z_seq=observations,
+    x0=initial_state,
+    P0=initial_covariance,
+    Q=process_noise,
+    R=observation_noise
+)
+```
+
+3. **Single-step Prediction**: For real-time applications
+```python
+step_result = kalman_filter.predict_update(
+    z=current_observation,
+    x=current_state,
+    P=current_covariance,
+    Q=process_noise,
+    R=observation_noise
+)
+```
+
+### Parameter Learning
+
+The module supports learning model parameters through using backpropagation using the negative expected joint log-likelihood of the 
+data as the loss function.
+
+```python
+# Define optimizer
+optimizer = torch.optim.Adam(params=[
+    {'params': kalman_filter.f.parameters()},
+    {'params': kalman_filter.h.parameters()},
+    {'params': Q.parameters()},
+    {'params': R.parameters()}
+]
+
+NUM_EPOCHS = 10
+NUM_CYCLES = 10
+
+# Run the EM loop
+marginal_likelihoods = em_updates(
+    kalman_filter=kalman_filter,
+    z_seq=observations,
+    x0=initial_state,
+    P0=initial_covariance,
+    Q=Q,
+    R=R,
+    optimizer=optimizer,
+    num_cycles=NUM_CYCLES,
+    num_epochs=NUM_EPOCHS
+) 
+    
+```
+
+## API Reference
+
+### DifferentiableKalmanFilter
+
+Main class implementing the Kalman Filter algorithm.
+
+#### Constructor Parameters:
+- `dim_x` (int): State space dimension
+- `dim_z` (int): Observation space dimension
+- `f` (nn.Module): State transition function
+- `h` (nn.Module): Observation function
+- `mc_samples` (int, optional): Number of Monte Carlo samples for log-likelihood estimation
+
+#### Key Methods:
+- `predict`: State prediction step
+- `update`: Measurement update step
+- `predict_update`: Combined prediction and update
+- `sequence_filter`: Full sequence filtering
+- `sequence_smooth`: Full sequence smoothing
+- `marginal_log_likelihood`: Compute marginal log-likelihood
+- `monte_carlo_expected_joint_log_likekihood`: Estimate expected joint log-likelihood
+
+## Requirements
+
+- PyTorch >= 1.9.0
+- Python >= 3.7
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

diffkalman-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+diffkalman/__init__.py,sha256=owxzQKRKYYZU_0bQ9QEIanoOx-Fv138JSFl8VdvQfI8,180
+diffkalman/em_loop.py,sha256=j-OJEGuotI-3z8l35joevBIMWZeNOvaKNUr1QLqzRbM,4682
+diffkalman/filter.py,sha256=xGk-JqZlf7vhHFk3wV3GQQN9fZrf5XbGezECK6iCo2U,27412
+diffkalman/joint_jacobian_transform.py,sha256=HRmWkcCwCQxrENZjJeE3RY7901bPUP9qnbqh7NRKiYw,2000
+diffkalman/negative_log_likelihood.py,sha256=B1ICGZ0urrS1THxvg020rjJe3gua_AabvwB64L7Rhdo,5730
+diffkalman/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffkalman/utils.py,sha256=ovlLCdPJksAA5mfGtDaNCqqA7hLBhH5-IMRdGvMQ22o,3230
+diffkalman-0.1.0.dist-info/METADATA,sha256=s50Zc-lmWCINrgyBHP-SMgW-WvbtZYGBV9ALgCuE0UY,5423
+diffkalman-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+diffkalman-0.1.0.dist-info/licenses/LICENSE,sha256=IHkfLg6o-U7zWIh6oiJUp0j0abQ59foTPoB1OLEPleQ,1063
+diffkalman-0.1.0.dist-info/RECORD,,

diffkalman-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

diffkalman-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 HadesX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.