kalman-inversion-lib 0.0.1__tar.gz

kalman_inversion_lib-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Konstantin Ibadullaev]
+
+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.

kalman_inversion_lib-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: kalman_inversion_lib
+Version: 0.0.1
+Summary: The package implements various Kalman Inversion algorithms in Python.
+Author-email: Konstantin Ibadullaev <konstantin.ibadullaev.post@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Kalman Inversion Lib Package

kalman_inversion_lib-0.0.1/README.md

@@ -0,0 +1 @@
+# Kalman Inversion Lib Package

kalman_inversion_lib-0.0.1/kalman_inversion_lib/src/diagnostics.py

@@ -0,0 +1,20 @@
+class EnsembleMonitor:
+    def __init__(self, kalman_object):
+        self.kalman_object = kalman_object
+        self.ensemble_list = []
+        self.posterior_mean_list = []
+        self.posterior_covariance_list = []
+        
+    def collect_stats(self):
+        self.ensemble_list.append(self.kalman_object.ensemble.copy())
+        self.posterior_mean_list.append(self.kalman_object.posterior_mean.copy())
+        self.posterior_covariance_list.append(self.kalman_object.posterior_covariance.copy())
+    
+    def get_ensemble_list(self):
+        return self.ensemble_list
+
+    def get_posterior_mean_list(self):
+        return self.posterior_mean_list
+
+    def get_posterior_covariance_list(self):
+        return self.posterior_covariance_list

kalman_inversion_lib-0.0.1/kalman_inversion_lib/src/kalman_base_classes.py

@@ -0,0 +1,349 @@
+import numpy as np
+import scipy as sp
+from abc import ABC, abstractmethod
+from tqdm.notebook import tqdm
+
+#from timestep_schedulers import *
+
+from diagnostics import EnsembleMonitor
+
+
+
+################### Base Class For Learning Rate/Time Step Schedulers ############################################
+class BaseTimeStepScheduler:
+    def __init__(self, kalman_object:type(BaseKalmanInversion)| type(BaseKalmanSampler)):
+        self.kalman_object = kalman_object
+        
+    def compute_timestep(self):
+        raise NotImplementedError("Subclasses must implement this method"  )
+
+
+################### Class Data Container ############################################
+class KalmanInversionDataContainer:
+    def __init__(
+                             self,
+                             y_observations:np.ndarray,
+                             Gamma_noise_matrix:np.ndarray,
+                             prior_mean:np.ndarray,
+                             prior_covariance:np.ndarray,
+                        
+                            
+    ):
+
+        
+                
+                        self.Gamma_noise_matrix = Gamma_noise_matrix
+                        self.prior_mean = prior_mean
+                        self.prior_covariance = prior_covariance 
+                        self.dim_parameter = len(self.prior_mean)
+                        self.y_observations = y_observations
+                        self.dim_y = len(self.y_observations)
+                        
+                    
+                        
+                   
+################### Base Class for Kalman Inversion (Optimizers) ############################################
+
+class BaseKalmanInversion(ABC):
+    def __init__(
+                    self, 
+                 time_step_scheduler:type(BaseTimeStepScheduler),
+                 kalman_data_container:type(KalmanInversionDataContainer),
+                 seed:int = 42, 
+                if_extend_space:bool=False,
+                if_impose_prior:bool=False,
+                 eps = 1e-10,
+        max_step :float = 0.75,
+       
+                ):
+        
+        self.monitor = EnsembleMonitor(self)
+        
+        self.eps = eps
+        self.max_step = max_step
+        self.ki_random_gen = np.random.default_rng(seed)
+    
+        self.kalman_data_container = kalman_data_container
+        # scheduler reuses internal state of the kalman object
+        self.time_step_scheduler = time_step_scheduler(self)
+        
+        self.y_observations =  None
+        self.ensemble = None
+        self.posterior_mean = self.kalman_data_container.prior_mean
+        self.posterior_covariance = self.kalman_data_container.prior_covariance
+        self.total_time = 0.0
+
+        self.if_extend_space = if_extend_space
+        self.if_impose_prior = False if self.if_extend_space else if_impose_prior
+        # self.if_impose_prior = if_impose_prior
+       
+        
+
+
+    # @abstractmethod
+    def ensemble_transform(self):
+         pass
+
+
+    
+       
+
+
+    def compute_forward_model(self, y_forward, ensemble):
+        # we might need this function for general purposes as well
+        for j in range(0, self.J):
+            y_forward[j,:] = np.hstack([self.forward_model(ensemble[j,:].flatten(), **self.kwargs_object), ensemble[j,:].flatten()]) if self.if_extend_space  else self.forward_model(ensemble[j,:].flatten(), **self.kwargs_object).flatten()
+        return y_forward
+            
+
+
+        
+    def create_observation_space(self):
+        if self.if_extend_space :
+            # extend observation space
+            self.y_observations = np.hstack([self.kalman_data_container.y_observations, self.kalman_data_container.prior_mean]) 
+            # extend error matrix
+            self.sigma_nu_const = np.zeros((self.kalman_data_container.dim_y + self.kalman_data_container.dim_parameter, self.kalman_data_container.dim_y  + self.kalman_data_container.dim_parameter))
+            self.sigma_nu_const[:self.kalman_data_container.dim_y, :self.kalman_data_container.dim_y ] = self.kalman_data_container.Gamma_noise_matrix
+            self.sigma_nu_const[self.kalman_data_container.dim_y :, -self.kalman_data_container.dim_parameter: ]  = self.kalman_data_container.prior_covariance      
+        else:
+            self.y_observations = self.kalman_data_container.y_observations
+            self.sigma_nu_const = self.kalman_data_container.Gamma_noise_matrix 
+        pass
+
+
+    
+    @abstractmethod
+    def predict_step(self):
+        """
+        Predict step, the method should be implemented for each type of algorithms
+        """
+        pass
+    
+    @abstractmethod    
+    def analysis_step(self):
+        """
+        Analysis step, the method should be implemented for each type of algorithms
+        """
+        pass
+
+
+
+    def update_sigmas(self):
+        self.omega_gamma = ( (self.time_step/(1.0 - self.time_step)) + 1.0 - self.alpha_regularizer**2 ) if (self.if_impose_prior and not self.if_extend_space) else (self.time_step/(1.0 - self.time_step ))
+        self.sigma_omega = self.omega_gamma  * self.kalman_data_container.prior_covariance if  (self.if_impose_prior and not self.if_extend_space) else (self.time_step/(1.0 - self.time_step )) * self.posterior_covariance
+        # self.omega_gamma = (self.time_step/(1.0 - self.time_step ))
+        # self.sigma_omega =  self.omega_gamma  * self.posterior_covariance
+        self.sigma_nu = self.sigma_nu_const/(self.time_step)
+        
+    def inversion_step(self, **kwargs):
+        step_counter = 0.0
+
+        
+        # perform evaluation until step is 1.0
+        while step_counter < 1.0 - self.eps:
+            # # compute ensemble for the scheduler
+            self.ensemble_transform()
+            # # compute data for the schedulers
+            self.y_forward = self.compute_forward_model(self.y_forward, self.ensemble)
+            # get a time step for the next iteration: cap the values to hold dt in range(0, 1)
+            a_max = min( (1.0 - step_counter), self.max_step)
+            self.time_step = np.clip( self.time_step_scheduler.compute_timestep(), a_min=self.eps , a_max=a_max)
+            step_counter += self.time_step
+            
+            # update artificial error matrix in the parameter space
+            self.update_sigmas()
+            # predict step
+            self.predict_step()
+            # transformation before the analysis step
+            self.ensemble_transform()
+            # analysis step
+            self.analysis_step(**kwargs)
+            self.total_time += self.time_step
+         
+     
+
+            
+
+
+    def run_inversion(self, forward_model:callable,  time_step: float=0.5, num_iterations :int = 1 , alpha_regularizer:float=1.0, **kwargs):
+        
+        self.time_step = time_step
+        self.init_step = time_step
+
+
+
+        self.alpha_regularizer = 1.0 if self.if_extend_space else np.clip(alpha_regularizer, a_min=0.0, a_max=1.0)
+        
+        
+        self.num_iterations =  num_iterations
+       
+        
+        self.create_observation_space()
+        self.M = len(self.y_observations.flatten())
+        
+        
+        
+        self.sigma_omega = self.posterior_covariance
+
+        self.forward_model = forward_model
+        
+        # kwargs for the forward model function
+        self.kwargs_object = kwargs
+
+        self.y_forward = np.zeros((self.J, self.M) )
+        
+        # self.ensemble_transform()
+        # self.y_forward = self.compute_forward_model(y_forward = self.y_forward, ensemble=self.ensemble)
+        
+
+        
+        for i in tqdm( range(0, self.num_iterations)):
+            self.inversion_step()
+            self.monitor.collect_stats()
+            
+    
+    def get_posterior_mean(self):
+        return self.posterior_mean
+        
+    def get_posterior_covariance(self):
+        return self.posterior_covariance
+
+################### Base Class for Kalman Inversion (Samplers) ############################################
+
+class BaseKalmanSampler(ABC):
+    def __init__(
+                    self, 
+        initial_ensemble:np.ndarray,
+            J:int,
+                 time_step_scheduler:type(BaseTimeStepScheduler),
+                 kalman_data_container:type(KalmanInversionDataContainer),
+                 seed:int = 42, 
+                   eps = 1e-10,
+        max_step :float = 1.0,
+        if_centered:bool=True,
+       
+                ):
+        
+        self.monitor = EnsembleMonitor(self)
+        self.if_centered = if_centered
+        self.eps = eps
+        self.max_step = max_step
+        self.ki_random_gen = np.random.default_rng(seed)
+    
+        self.kalman_data_container = kalman_data_container
+        # scheduler reuses internal state of the kalman object
+        self.time_step_scheduler = time_step_scheduler(self)
+        
+        self.y_observations = self.kalman_data_container.y_observations
+        self.ensemble = initial_ensemble
+        self.J = J
+        
+        self.y_forward =  np.zeros((self.J, self.kalman_data_container.dim_y))
+        
+        self.posterior_mean = self.kalman_data_container.prior_mean
+        self.posterior_covariance = self.kalman_data_container.prior_covariance
+        self.total_time = 0.0
+
+        if self.if_centered:
+            # center the ensemble
+            self.ensemble =  self.ensemble - self.kalman_data_container.prior_mean
+        
+
+    def compute_forward_model(self, y_forward, ensemble, J):
+        if self.if_centered:
+            ensemble = ensemble + self.kalman_data_container.prior_mean
+        # we might need this function for general purposes as well
+        for j in range(0, J):
+            y_forward[j,:] = self.forward_model(ensemble[j,:].flatten() , **self.kwargs_object).flatten()
+        return y_forward
+        
+
+    def get_posterior_mean(self,):
+            return self.posterior_mean
+        
+    def get_posterior_covariance(self,):
+            return self.posterior_covariance
+    
+    def compute_mean(self, ensemble, y_forward, covariance, J):
+        raise NotImplementedError("Subclass must implement this method")
+        
+    def draw_proposal(self,proposed_mean, covariance , J):
+        raise NotImplementedError("Subclass must implement this method")
+    
+    
+    def one_step_inverse(self, ensemble, y_forward, J,covariance):
+
+        
+        
+        # # compute mean and covariance
+        # covariance = self.compute_covariance(ensemble=ensemble)
+        proposed_mean = self.compute_mean( ensemble=ensemble, y_forward=y_forward, covariance=covariance, J=J)
+                
+        # draw a proposal ensemble
+        proposed_ensemble = self.draw_proposal( proposed_mean=proposed_mean, covariance = covariance, J=J)
+        
+        # update ensemble
+        ensemble = self.update_ensemble(ensemble=proposed_ensemble)
+        return (ensemble, proposed_mean)
+        
+    def block_wrapper(self, ensemble, y_forward, J):
+        # compute covariance and pass it into inverse
+        covariance = self.compute_covariance(ensemble=ensemble)
+        # this one is for MA extension
+        
+        # if we have several blocks  -> write for loop and choose corresponding ensemble members   
+        ensemble, _ = self.one_step_inverse( ensemble, y_forward, J, covariance)
+        return ensemble
+
+        
+    def compute_covariance(self, ensemble):
+        # compute covariance P x P
+        return np.cov(ensemble.T, bias=True)
+
+    def get_posterior_mean(self):
+        return self.ensemble.mean(0) + self.kalman_data_container.prior_mean
+        
+    def get_posterior_covariance(self):
+        return self.compute_covariance(self.ensemble)
+        
+    def update_ensemble(self, ensemble):
+        # can be extended for accept/reject step
+        return ensemble
+        
+    def inversion_step(self,ensemble, y_forward, J):
+        step_counter = 0.0
+       
+        # perform evaluation until step is 1.0
+        while step_counter < 1.0 - self.eps:
+            # compute data for the schedulers
+            self.y_forward = self.compute_forward_model( ensemble=ensemble, y_forward=y_forward, J=J)
+            
+            # get a time step for the next iteration: cap the values to hold dt in range(0, 1)
+            a_max = min( (1.0 - step_counter), self.max_step)
+            self.time_step = np.clip( self.time_step_scheduler.compute_timestep(), a_min=self.eps , a_max=a_max)
+            step_counter += self.time_step
+            self.total_time += self.time_step
+            # get a new ensemble
+            ensemble = self.block_wrapper(ensemble, y_forward, J)
+        return ensemble
+
+           
+
+    def run_inversion(self,  forward_model:callable,  time_step: float=0.5, num_iterations :int = 1 ,  **kwargs ):
+
+            
+            self.forward_model = forward_model
+        
+            # kwargs for the forward model function
+            self.kwargs_object = kwargs
+        
+
+            
+            self.time_step = time_step
+            self.init_step = time_step
+            self.num_iterations = num_iterations
+
+            for i in tqdm( range(0, self.num_iterations)):
+                self.ensemble = self.inversion_step(ensemble=self.ensemble, y_forward = self.y_forward, J=self.J)
+                self.monitor.collect_stats()

kalman_inversion_lib-0.0.1/kalman_inversion_lib/src/kalman_inversion_optimizers.py

@@ -0,0 +1,133 @@
+import numpy as np
+import scipy as sp
+#from tqdm.notebook import tqdm
+from kalman_base_classes import BaseKalmanInversion, KalmanInversionDataContainer, BaseTimeStepScheduler
+
+
+
+######## Ensemble Kalman Inversion #########
+class EnsembleKalmanInversion(BaseKalmanInversion):
+    def __init__(
+                 self, 
+                 kalman_data_container:type(KalmanInversionDataContainer),
+                 initial_ensemble:np.ndarray,
+                 time_step_scheduler:type(BaseTimeStepScheduler),
+                 eps = 1e-10,
+                 max_step :float = 0.75,
+                  seed:int = 42, 
+                if_extend_space:bool=False,
+                if_impose_prior:bool=False,
+                
+                ):
+
+        
+        super().__init__(      kalman_data_container=kalman_data_container,      seed=seed,      time_step_scheduler=time_step_scheduler,            eps=eps  , if_extend_space = if_extend_space, max_step =max_step, if_impose_prior=if_impose_prior   )
+        self.ensemble = initial_ensemble
+       
+        self.J = self.ensemble.shape[0]
+        
+        
+    def predict_step(self):
+        # self.m_hat = self.kalman_data_container.prior_mean + self.alpha_regularizer * (self.ensemble.mean(0) - self.kalman_data_container.prior_mean)
+        # self.ensemble = self.m_hat +  np.sqrt( self.alpha_regularizer**2 + self.omega_gamma) * (self.ensemble - self.ensemble.mean(0) )
+        self.ensemble = self.alpha_regularizer * self.ensemble + (1 - self.alpha_regularizer) * self.kalman_data_container.prior_mean + self.ki_random_gen.multivariate_normal(np.zeros(self.kalman_data_container.dim_parameter), self.sigma_omega, self.J)
+        self.m_hat = np.mean(self.ensemble, axis=0)
+        
+    def get_posterior_mean(self):
+        return self.ensemble.mean(0)
+        
+    def get_posterior_covariance(self):
+        return np.cov(self.ensemble.T, bias=False)
+
+        
+    def analysis_step(self):
+
+        # forward computation
+        self.y_forward = self.compute_forward_model(self.y_forward,self.ensemble)
+
+        # compute cross/ covariances
+        cov_theta_gamma = ( self.ensemble - self.m_hat ).T @ (self.y_forward - self.y_forward.mean(0) ) / (self.J-1)   # P x D
+        cov_gamma_gamma = ( self.y_forward - self.y_forward.mean(0) ).T @ (self.y_forward - self.y_forward.mean(0) ) / (self.J-1) + self.sigma_nu  # D x D
+
+        # residuals
+        Z = self.y_observations - self.y_forward - self.ki_random_gen.multivariate_normal(np.zeros(self.M), self.sigma_nu, self.J) # J x D
+        
+        # Kalman update
+        K = ( cov_theta_gamma @ np.linalg.solve( cov_gamma_gamma, Z.T) ).T # J x P
+        # Ensemble update
+        self.ensemble = self.ensemble + K
+        self.posterior_covariance = np.cov(self.ensemble.T, bias=False)
+        self.posterior_mean = np.mean(self.ensemble, axis=0)
+
+
+######## Unscented Kalman Inversion #########
+class UnscentedKalmanInversion(BaseKalmanInversion):
+    def __init__(
+                 self, 
+                 kalman_data_container:type(KalmanInversionDataContainer),
+                
+                 time_step_scheduler:type(BaseTimeStepScheduler),
+                 eps = 1e-10,
+              max_step :float = 0.75,
+                  seed:int = 42, 
+                  if_extend_space:bool=False,
+                if_impose_prior:bool=False,
+                
+                ):
+
+        
+        super().__init__(      kalman_data_container=kalman_data_container,      seed=seed,      time_step_scheduler=time_step_scheduler,            eps=eps  , if_extend_space = if_extend_space,  max_step =max_step,if_impose_prior=if_impose_prior
+                             
+                        )   
+        self.J = self.kalman_data_container.dim_parameter * 2 + 1
+        self.ensemble =  np.zeros((self.J, self.kalman_data_container.dim_parameter ))
+        self.ensemble_transform()
+        
+        
+    def ensemble_transform(self):
+        
+        # quadrature coefficients
+        self.coeff_a = min(np.sqrt(4 / (self.kalman_data_container.dim_parameter)), 1)
+        self.coeff_c = self.coeff_a * np.sqrt(self.kalman_data_container.dim_parameter)
+        self.coeff_w = 1 / (2 * (self.kalman_data_container.dim_parameter) * self.coeff_a**2)
+        
+        # cholesky factorization
+        cholesky_C = np.linalg.cholesky( self.posterior_covariance + self.eps * np.eye(self.kalman_data_container.dim_parameter))
+
+        # create symmetric ensemble
+        self.ensemble[0,:] = self.posterior_mean
+        self.ensemble[1:self.kalman_data_container.dim_parameter+1, :] = np.vstack([ self.posterior_mean + self.coeff_c * cholesky_C[:,j] for j in range(0,self.kalman_data_container.dim_parameter)])
+        self.ensemble[self.kalman_data_container.dim_parameter+1:,  :] = np.vstack([ self.posterior_mean - self.coeff_c * cholesky_C[:,j] for j in range(0,self.kalman_data_container.dim_parameter)])
+        
+        
+    def predict_step(self):
+        # predict mean and covariance
+        self.posterior_mean = self.kalman_data_container.prior_mean + self.alpha_regularizer * (self.posterior_mean - self.kalman_data_container.prior_mean)
+        self.posterior_covariance = self.alpha_regularizer**2 * self.posterior_covariance + self.sigma_omega
+        
+
+        
+    def analysis_step(self):
+
+        # forward computation
+        self.y_forward = self.compute_forward_model(self.y_forward, self.ensemble)
+
+        # compute cross/ covariances
+        cov_theta_gamma =  self.coeff_w * (self.ensemble[1:,:] - self.posterior_mean ).T @ (self.y_forward[1:,:] - self.y_forward[0,:]) # P x D
+        cov_gamma_gamma =  self.coeff_w * (self.y_forward[1:,:] - self.y_forward[0,:]).T @ (self.y_forward[1:,:] - self.y_forward[0,:]) + self.sigma_nu  # D x D
+
+        # residuals
+        Z = self.y_observations - self.y_forward[0,:] # J x D
+        
+        # Kalman update
+        K = ( cov_theta_gamma @ np.linalg.solve( cov_gamma_gamma, Z.T) ).T # J x P
+        
+        # parameters update
+        self.posterior_mean = self.posterior_mean + K
+        self.posterior_covariance =  self.posterior_covariance - cov_theta_gamma @ np.linalg.solve( cov_gamma_gamma, cov_theta_gamma.T)
+        
+    
+
+
+
+

kalman_inversion_lib-0.0.1/kalman_inversion_lib/src/kalman_inversion_samplers.py

@@ -0,0 +1,96 @@
+import numpy as np
+import scipy as sp
+#from tqdm.notebook import tqdm
+from kalman_base_classes import BaseKalmanSampler, KalmanInversionDataContainer,BaseTimeStepScheduler
+
+
+
+
+class EnsembleKalmanSampler(BaseKalmanSampler):
+    def __init__(              self,
+                              
+                               kalman_data_container:type(KalmanInversionDataContainer),
+                               seed,
+                               time_step_scheduler:type(BaseTimeStepScheduler),
+                               eps,
+                               max_step,
+                               initial_ensemble,
+                               J:int,
+                               if_centered:bool=True,
+                                if_cholesky_sqrt:bool=True,
+                 ):
+        
+        super().__init__(      
+                               kalman_data_container=kalman_data_container,
+                               seed=seed,
+                               time_step_scheduler=time_step_scheduler, 
+                               eps=eps,
+                               max_step=max_step,
+            initial_ensemble=initial_ensemble,
+            if_centered=if_centered,
+            J=J
+            )
+
+        
+        
+        # covariance matrix factorization type
+        self.if_cholesky_sqrt = if_cholesky_sqrt
+        
+    def compute_mean(self, y_forward, ensemble, covariance, J):
+         
+         # y_forward = self.compute_forward_model(
+         #                                                                       y_forward=y_forward,
+                                                                               
+         #                                                                       ensemble=(ensemble ),
+         #                                                                       J=J, 
+                                                                              
+         #                                                                      )
+         # ensemble covariance P x P
+         covariance_theta_theta =  covariance
+        
+         # residuals (J x D).T
+         Z =  (y_forward - self.y_observations).T
+
+         
+         # this is the gamma weighted product of < ( G(u) - \bar{G(u)}) x Gamma^{-1} x ( G(u) - y) > /J JxJ
+         gamma_weighted_product =  (y_forward - y_forward.mean(0)) @ np.linalg.solve(self.kalman_data_container.Gamma_noise_matrix, Z) / J
+         
+         # split-step  discretization
+     
+         # 1 step
+         
+         # left handside of u*_{n+1}:
+         #         (dt * C(U) * Sigma_0 ^{-1}):
+         
+         left_handside = (  np.eye(self.kalman_data_container.dim_parameter) + self.time_step *  np.linalg.solve(self.kalman_data_container.prior_covariance,   covariance_theta_theta.T).T)
+                      
+         
+         # right handside u^j_n - dt * gamma weighted product * U
+         right_handside = ensemble - self.time_step *  gamma_weighted_product.T @ ensemble     
+          
+         # inverse of left handside: J x P           
+         theta_mean = np.linalg.solve(left_handside, right_handside.T).T
+
+         # return mean and covariance
+         return theta_mean
+        
+
+    def draw_proposal(self, proposed_mean, covariance, J):
+        # 2 step draw proposal
+        brown_noise =  self.ki_random_gen.multivariate_normal(np.zeros(self.kalman_data_container.dim_parameter), np.eye(self.kalman_data_container.dim_parameter), J) 
+
+        # matrix factorization
+        if self.if_cholesky_sqrt:
+            L =  np.linalg.cholesky(covariance + self.eps * np.eye(self.kalman_data_container.dim_parameter)) 
+        else:                
+            L =  sp.linalg.sqrtm(0.5 * (covariance  + covariance.T))
+
+        
+        proposed_ensemble = proposed_mean + (np.sqrt(2 * self.time_step) * L @ brown_noise.T).T
+        return proposed_ensemble
+
+
+   
+            
+            
+           

kalman_inversion_lib-0.0.1/kalman_inversion_lib/src/timestep_schedulers.py

@@ -0,0 +1,50 @@
+ 
+import numpy as np
+from kalman_base_classes import BaseTimeStepScheduler
+    
+
+
+
+# class BaseTimeStepScheduler:
+#     def __init__(self,kalman_object):
+#         self.kalman_object = kalman_object
+        
+#     def compute_timestep(self):
+#         raise NotImplementedError("Subclasses must implement this method"  )
+
+
+class DataMisfitTimeStepScheduler(BaseTimeStepScheduler):
+
+    def compute_timestep(self):
+        self.misfit = 0.5 * (self.kalman_object.kalman_data_container.y_observations - self.kalman_object.y_forward[:, :self.kalman_object.kalman_data_container.dim_y ]) @ np.linalg.solve(self.kalman_object.kalman_data_container.Gamma_noise_matrix ,(self.kalman_object.kalman_data_container.y_observations - self.kalman_object.y_forward[:, :self.kalman_object.kalman_data_container.dim_y ]).T )
+        
+        self.misfit_norm = np.diag(self.misfit)
+        step = max( self.kalman_object.kalman_data_container.dim_y/(2 * self.misfit_norm.mean(0)), np.sqrt(self.kalman_object.kalman_data_container.dim_y/(2 * self.misfit_norm.var(0) )))
+        
+      
+        return step
+
+class AdaptiveTimeStepScheduler(BaseTimeStepScheduler):
+    def compute_timestep(self):     
+   
+        # this is the gamma weighted product of < ( G(u) - \bar{G(u)}) x Gamma^{-1} x ( G(u) - y) >/J      
+        self.gamma_weighted_product = (self.kalman_object.y_forward[:, :self.kalman_object.kalman_data_container.dim_y ] - self.kalman_object.y_forward[:, :self.kalman_object.kalman_data_container.dim_y ].mean(0) ) @ np.linalg.solve(self.kalman_object.kalman_data_container.Gamma_noise_matrix ,(self.kalman_object.y_forward[:, :self.kalman_object.kalman_data_container.dim_y ] - self.kalman_object.kalman_data_container.y_observations  ).T ) /self.kalman_object.J
+
+        
+        
+        # use gamma weighted product to update artificial time step
+        step = self.kalman_object.init_step / (np.linalg.norm( self.gamma_weighted_product, ord='fro') + 1e-8)
+      
+        
+        return step
+
+
+        
+class FixedTimeStepScheduler(BaseTimeStepScheduler):
+   
+    def compute_timestep(self):     
+        step = self.kalman_object.init_step
+      
+        
+        return step
+        

kalman_inversion_lib-0.0.1/kalman_inversion_lib.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: kalman_inversion_lib
+Version: 0.0.1
+Summary: The package implements various Kalman Inversion algorithms in Python.
+Author-email: Konstantin Ibadullaev <konstantin.ibadullaev.post@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Kalman Inversion Lib Package

kalman_inversion_lib-0.0.1/kalman_inversion_lib.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+kalman_inversion_lib.egg-info/PKG-INFO
+kalman_inversion_lib.egg-info/SOURCES.txt
+kalman_inversion_lib.egg-info/dependency_links.txt
+kalman_inversion_lib.egg-info/top_level.txt
+kalman_inversion_lib/src/__init__.py
+kalman_inversion_lib/src/diagnostics.py
+kalman_inversion_lib/src/kalman_base_classes.py
+kalman_inversion_lib/src/kalman_inversion_optimizers.py
+kalman_inversion_lib/src/kalman_inversion_samplers.py
+kalman_inversion_lib/src/timestep_schedulers.py

kalman_inversion_lib-0.0.1/kalman_inversion_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kalman_inversion_lib-0.0.1/kalman_inversion_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+kalman_inversion_lib

kalman_inversion_lib-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kalman_inversion_lib"
+version = "0.0.1"
+authors = [
+  { name="Konstantin Ibadullaev", email="konstantin.ibadullaev.post@gmail.com" },
+]
+description = "The package implements various Kalman Inversion algorithms in Python."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+#[project.urls]
+#Homepage = ""
+#Issues = ""

kalman_inversion_lib-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+