From 2ded706f82ea65502c68f5dcb41e63da3210ff8e Mon Sep 17 00:00:00 2001 From: ostrow Date: Mon, 27 Oct 2025 18:30:20 -0400 Subject: [PATCH 01/51] updates from dsa-v2 --- DSA/dsa.py | 444 +++++++++++++++++++++++----------------- DSA/kerneldmd.py | 180 ---------------- DSA/preprocessing.py | 109 +++++++++- DSA/simdist.py | 476 +++++++++++++++++++++++++++---------------- DSA/sweeps.py | 41 ++-- 5 files changed, 673 insertions(+), 577 deletions(-) delete mode 100644 DSA/kerneldmd.py diff --git a/DSA/dsa.py b/DSA/dsa.py index 5036180..9631508 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -1,79 +1,83 @@ -from DSA.dmd import DMD -#from DSA.kerneldmd import KernelDMD +from DSA.dmd import DMD as DefaultDMD from DSA.simdist import SimilarityTransformDist from typing import Literal import torch import numpy as np from omegaconf.listconfig import ListConfig +import tqdm +from joblib import Parallel, delayed + + +CAST_TYPES = { + "n_delays": int, + "delay_interval": int, + "rank": int, + "rank_thresh": float, + "rank_explained_variance": float, + "lamb": float, + "steps_ahead": int, + "reduced_rank_reg": bool, + "send_to_cpu": bool, +} + class DSA: """ - Computes the Dynamical Similarity Analysis (DSA) for two data matrices + Computes the Dynamical Similarity Analysis (DSA) for two data tensors """ - def __init__(self, - X, - Y=None, - n_delays=1, - delay_interval=1, - rank=None, - rank_thresh=None, - rank_explained_variance = None, - lamb = 0.0, - steps_ahead=1, - send_to_cpu = True, - iters = 1500, - score_method: Literal["angular", "euclidean","wasserstein"] = "angular", - lr = 5e-3, - group: Literal["GL(n)", "O(n)", "SO(n)"] = "O(n)", - zero_pad = False, - device = 'cpu', - verbose = False, - reduced_rank_reg = False, - kernel=None, - num_centers=0.1, - svd_solver='arnoldi', - wasserstein_compare: Literal['sv','eig',None] = None - ): + + def __init__( + self, + X, + Y=None, + dmd_class=DefaultDMD, + iters=1500, + score_method: Literal["angular", "euclidean", "wasserstein"] = "angular", + lr=5e-3, + zero_pad=False, + device="cpu", + wasserstein_compare: Literal["sv", "eig", None] = "eig", + n_jobs: int = 1, + dsa_verbose=False, + **dmd_kwargs, + ): """ Parameters __________ X : np.array or torch.tensor or list of np.arrays or torch.tensors first data matrix/matrices - + Y : None or np.array or torch.tensor or list of np.arrays or torch.tensors - second data matrix/matrices. - * If Y is None, X is compared to itself pairwise + second data matrix/matrices. + * If Y is None, X is compared to itself pairwise (must be a list) * If Y is a single matrix, all matrices in X are compared to Y * If Y is a list, all matrices in X are compared to all matrices in Y - - DMD parameters: + + DMD parameters : n_delays : int or list or tuple/list: (int,int), (list,list),(list,int),(int,list) number of delays to use in constructing the Hankel matrix - + delay_interval : int or list or tuple/list: (int,int), (list,list),(list,int),(int,list) interval between samples taken in constructing Hankel matrix rank : int or list or tuple/list: (int,int), (list,list),(list,int),(int,list) rank of DMD matrix fit in reduced-rank regression - + rank_thresh : float or list or tuple/list: (float,float), (list,list),(list,float),(float,list) Parameter that controls the rank of V in fitting HAVOK DMD by dictating a threshold of singular values to use. Explicitly, the rank of V will be the number of singular values greater than rank_thresh. Defaults to None. - + rank_explained_variance : float or list or tuple: (float,float), (list,list),(list,float),(float,list) Parameter that controls the rank of V in fitting HAVOK DMD by indicating the percentage of cumulative explained variance that should be explained by the columns of V. Defaults to None. - + lamb : float L-1 regularization parameter in DMD fit - steps_ahead: int - number of steps ahead to predict in DMD - send_to_cpu: bool If True, will send all tensors in the object back to the cpu after everything is computed. This is implemented to prevent gpu memory overload when computing multiple DMDs. @@ -81,7 +85,7 @@ def __init__(self, NOTE: for all of these above, they can be single values or lists or tuples, depending on the corresponding dimensions of the data If at least one of X and Y are lists, then if they are a single value - it will default to the rank of all DMD matrices. + it will default to the rank of all DMD matrices. If they are (int,int), then they will correspond to an individual dmd matrix OR to X and Y respectively across all matrices If it is (list,list), then each element will correspond to an individual @@ -91,133 +95,199 @@ def __init__(self, iters : int number of optimization iterations in Procrustes over vector fields - + score_method : {'angular','euclidean'} type of metric to compute, angular vs euclidean distance - + lr : float learning rate of the Procrustes over vector fields optimization - group : {'SO(n)','O(n)', 'GL(n)'} - specifies the group of matrices to optimize over - zero_pad : bool whether or not to zero-pad if the dimensions are different device : 'cpu' or 'cuda' or int hardware to use in both DMD and PoVF - - verbose : bool + + dsa_verbose : bool whether or not print when sections of the analysis is completed - + wasserstein_compare : {'sv','eig',None} specifies whether to compare the singular values or eigenvalues if score_method is "wasserstein", or the shapes are different """ self.X = X self.Y = Y - if self.X is None and isinstance(self.Y,list): - self.X, self.Y = self.Y, self.X #swap so code is easy + self.iters = iters + self.score_method = score_method + self.lr = lr + self.device = device + self.zero_pad = zero_pad + self.n_jobs = n_jobs + self.dsa_verbose = dsa_verbose + self.dmd_class = dmd_class + + if self.X is None and isinstance(self.Y, list): + self.X, self.Y = self.Y, self.X # swap so code is easy self.check_method() - if self.method == 'self-pairwise': + if self.method == "self-pairwise": self.data = [self.X] else: self.data = [self.X, self.Y] - - self.n_delays = self.broadcast_params(n_delays,cast=int) - self.delay_interval = self.broadcast_params(delay_interval,cast=int) - self.rank = self.broadcast_params(rank,cast=int) - self.rank_thresh = self.broadcast_params(rank_thresh) - self.rank_explained_variance = self.broadcast_params(rank_explained_variance) - self.lamb = self.broadcast_params(lamb) - self.steps_ahead = self.broadcast_params(steps_ahead,cast=int) - self.send_to_cpu = send_to_cpu - self.iters = iters - self.score_method = score_method - self.lr = lr - self.device = device - self.verbose = verbose - self.zero_pad = zero_pad - self.group = group - self.reduced_rank_reg = reduced_rank_reg - self.kernel = kernel - self.wasserstein_compare = wasserstein_compare - self.steps_ahead = self.broadcast_params(steps_ahead,cast=int) - - if kernel is None: - #get a list of all DMDs here - self.dmds = [[DMD(Xi, - self.n_delays[i][j], - delay_interval=self.delay_interval[i][j], - rank=self.rank[i][j], - rank_thresh=self.rank_thresh[i][j], - rank_explained_variance=self.rank_explained_variance[i][j], - reduced_rank_reg=self.reduced_rank_reg, - lamb=self.lamb[i][j], - steps_ahead = self.steps_ahead[i][j], - device=self.device, - verbose=self.verbose, - send_to_cpu=self.send_to_cpu) for j,Xi in enumerate(dat)] for i,dat in enumerate(self.data)] + + # Process DMD keyword arguments from **dmd_kwargs + # These are parameters like n_delays, rank, etc., that are specific to DMDs + # and need to be broadcasted according to X and Y data structure. + self.dmd_kwargs = ( + {} + ) # This will store {'param_name': broadcasted_value_list_of_lists} + + if dmd_kwargs: + for key, value in dmd_kwargs.items(): + cast_type = CAST_TYPES.get(key) + + if cast_type is not None: + broadcasted_value = self.broadcast_params(value, cast=cast_type) + else: + broadcasted_value = self.broadcast_params(value) + + setattr( + self, key, broadcasted_value + ) # e.g., self.n_delays = [[v,v],[v,v]] + self.dmd_kwargs[key] = ( + broadcasted_value # Store in dict for DMD instantiation + ) + + + self._dmd_api_source(dmd_class) + self._initiate_dmds() + + self.simdist = SimilarityTransformDist( + iters, score_method, lr, device, dsa_verbose, wasserstein_compare + ) + + def _initiate_dmds(self): + if self.dmd_api_source == "local_dsa_dmd": + self.dmds = [ + [ + self.dmd_class(Xi, **{k: v[i][j] for k, v in self.dmd_kwargs.items()}) + for j, Xi in enumerate(dat) + ] + for i, dat in enumerate(self.data) + ] else: - raise ValueError('KernelDMD not implemented yet') + self.dmds = [ + [self.dmd_class(**{k: v[i][j] for k, v in self.dmd_kwargs.items()}) for j, Xi in enumerate(dat)] + for i, dat in enumerate(self.data) + ] - self.simdist = SimilarityTransformDist(iters,score_method,lr,device,verbose,group,wasserstein_compare) + def _dmd_api_source(self, dmd_class): + module_name = dmd_class.__module__ + if "pydmd" in module_name: + self.dmd_api_source = "pydmd" + raise ValueError("DSA is not currently directly compatible with pydmd due to \ + data structure incompatibility. Please use pykoopman instead. \ + Note that you can pass in pydmd objects through pykoopman's Koopman class.") + elif "pykoopman" in module_name: + self.dmd_api_source = "pykoopman" + elif "DSA.dmd" in module_name: + self.dmd_api_source = "local_dsa_dmd" + else: + self.dmd_api_source = "unknown" + raise ValueError( + f"dmd_class {dmd_class.__name__} from unknown module {module_name}" + ) + + def fit_dmds(self): + if self.n_jobs != 1: + n_jobs = self.n_jobs if self.n_jobs > 0 else -1 # -1 means use all available cores + + if self.dmd_api_source == "local_dsa_dmd": + for dmd_sets in self.dmds: + if self.dsa_verbose: + print(f"Fitting {len(dmd_sets)} DMDs in parallel with {n_jobs} jobs") + Parallel(n_jobs=n_jobs)( + delayed(lambda dmd: dmd.fit())(dmd) for dmd in dmd_sets + ) + else: + for dmd_list, dat in zip(self.dmds, self.data): + if self.dsa_verbose: + print(f"Fitting {len(dmd_list)} DMDs in parallel with {n_jobs} jobs") + Parallel(n_jobs=n_jobs)( + delayed(lambda dmd, X: dmd.fit(X))(dmd, Xi) for dmd, Xi in zip(dmd_list, dat) + ) + else: + # Sequential processing + if self.dmd_api_source == "local_dsa_dmd": + for dmd_sets in self.dmds: + loop = dmd_sets if not self.dsa_verbose else tqdm.tqdm(dmd_sets, desc="Fitting DMDs") + for dmd in loop: + dmd.fit() + else: + for dmd_list, dat in zip(self.dmds, self.data): + loop = zip(dmd_list, dat) if not self.dsa_verbose else tqdm.tqdm(zip(dmd_list, dat), desc="Fitting DMDs") + for dmd, Xi in loop: + dmd.fit(Xi) def check_method(self): - ''' + """ helper function to identify what type of dsa we're running - ''' - tensor_or_np = lambda x: isinstance(x,(np.ndarray,torch.Tensor)) + """ + tensor_or_np = lambda x: isinstance(x, (np.ndarray, torch.Tensor)) - if isinstance(self.X,list): + if isinstance(self.X, list): if self.Y is None: - self.method = 'self-pairwise' - elif isinstance(self.Y,list): - self.method = 'bipartite-pairwise' + self.method = "self-pairwise" + elif isinstance(self.Y, list): + self.method = "bipartite-pairwise" elif tensor_or_np(self.Y): - self.method = 'list-to-one' - self.Y = [self.Y] #wrap in a list for iteration + self.method = "list-to-one" + self.Y = [self.Y] # wrap in a list for iteration else: - raise ValueError('unknown type of Y') + raise ValueError("unknown type of Y") elif tensor_or_np(self.X): self.X = [self.X] if self.Y is None: - raise ValueError('only one element provided') - elif isinstance(self.Y,list): - self.method = 'one-to-list' + raise ValueError("only one element provided") + elif isinstance(self.Y, list): + self.method = "one-to-list" elif tensor_or_np(self.Y): - self.method = 'default' + self.method = "default" self.Y = [self.Y] else: - raise ValueError('unknown type of Y') + raise ValueError("unknown type of Y") else: - raise ValueError('unknown type of X') + raise ValueError("unknown type of X") - def broadcast_params(self,param,cast=None): - ''' + def broadcast_params(self, param, cast=None): + """ aligns the dimensionality of the parameters with the data so it's one-to-one - ''' + """ out = [] - if isinstance(param,(int,float,np.integer)) or param is None: #self.X has already been mapped to [self.X] - out.append([param] * len(self.X)) - if self.Y is not None: - out.append([param] * len(self.Y)) - elif isinstance(param,(tuple,list,np.ndarray,ListConfig)): - if self.method == 'self-pairwise' and len(param) >= len(self.X): + if isinstance(param, (tuple, list, np.ndarray, ListConfig)): + if self.method == "self-pairwise" and len(param) >= len(self.X): out = [param] else: - assert len(param) <= 2 #only 2 elements max + assert len(param) <= 2 # only 2 elements max - #if the inner terms are singly valued, we broadcast, otherwise needs to be the same dimensions - for i,data in enumerate([self.X,self.Y]): + # if the inner terms are singly valued, we broadcast, otherwise needs to be the same dimensions + for i, data in enumerate([self.X, self.Y]): if data is None: continue - if isinstance(param[i],(int,float)): + if isinstance(param[i], (int, float)): out.append([param[i]] * len(data)) - elif isinstance(param[i],(list,np.ndarray,tuple)): + elif isinstance(param[i], (list, np.ndarray, tuple)): assert len(param[i]) >= len(data) - out.append(param[i][:len(data)]) + out.append(param[i][: len(data)]) + elif ( + isinstance(param, (int, float, np.integer)) or param in {None,'None','none'} or + (hasattr(param, '__module__') and ('pykoopman' in param.__module__ or 'pydmd' in param.__module__)) + ): # self.X has already been mapped to [self.X] + if param in {'None','none'}: + param = None + out.append([param] * len(self.X)) + if self.Y is not None: + out.append([param] * len(self.Y)) else: raise ValueError("unknown type entered for parameter") @@ -225,55 +295,11 @@ def broadcast_params(self,param,cast=None): out = [[cast(x) for x in dat] for dat in out] return out - - def fit_dmds(self, - X=None, - Y=None, - n_delays=None, - delay_interval=None, - rank=None, - rank_thresh = None, - rank_explained_variance=None, - reduced_rank_reg=None, - lamb = None, - device='cpu', - verbose=False, - send_to_cpu=True - ): - """ - Recomputes only the DMDs with a single set of hyperparameters. This will not compare, that will need to be done with the full procedure - """ - X = self.X if X is None else X - Y = self.Y if Y is None else Y - n_delays = self.n_delays if n_delays is None else n_delays - delay_interval = self.delay_interval if delay_interval is None else delay_interval - rank = self.rank if rank is None else rank - lamb = self.lamb if lamb is None else lamb - data = [] - if isinstance(X,list): - data.append(X) - else: - data.append([X]) - if Y is not None: - if isinstance(Y,list): - data.append(Y) - else: - data.append([Y]) - - dmds = [[DMD(Xi,n_delays,delay_interval, - rank,rank_thresh,rank_explained_variance,reduced_rank_reg, - lamb,device,verbose,send_to_cpu) for Xi in dat] for dat in data] - - for dmd_sets in dmds: - for dmd in dmd_sets: - dmd.fit() - - return dmds def fit_score(self): """ - Standard fitting function for both DMDs and PoVF - + Standard fitting function for both DMDs and PAVF + Parameters __________ @@ -281,18 +307,23 @@ def fit_score(self): _______ sims : np.array - data matrix of the similarity scores between the specific sets of data + data matrix of the similarity scores between the specific sets of data """ - for dmd_sets in self.dmds: - for dmd in dmd_sets: - dmd.fit() - + self.fit_dmds() return self.score() - - def score(self,iters=None,lr=None,score_method=None): - """ - Rescore DSA with precomputed dmds if you want to try again + def get_dmd_matrix(self, dmd): + if self.dmd_api_source == "local_dsa_dmd": + return dmd.A_v + elif self.dmd_api_source == "pykoopman": + return dmd.A + elif self.dmd_api_source == "pydmd": + raise ValueError("DSA is not currently compatible with pydmd due to \ + data structure incompatibility. Please use pykoopman instead.") + + def score(self, iters=None, lr=None, score_method=None): + """ + Score DSA with precomputed dmds Parameters __________ iters : int or None @@ -312,25 +343,60 @@ def score(self,iters=None,lr=None,score_method=None): lr = self.lr if lr is None else lr score_method = self.score_method if score_method is None else score_method - ind2 = 1 - int(self.method == 'self-pairwise') + ind2 = 1 - int(self.method == "self-pairwise") # 0 if self.pairwise (want to compare the set to itself) - self.sims = np.zeros((len(self.dmds[0]),len(self.dmds[ind2]))) - for i,dmd1 in enumerate(self.dmds[0]): - for j,dmd2 in enumerate(self.dmds[ind2]): - if self.method == 'self-pairwise': - if j >= i: - continue - if self.verbose: - print(f'computing similarity between DMDs {i} and {j}') - - self.sims[i,j] = self.simdist.fit_score(dmd1.A_v,dmd2.A_v,iters,lr,score_method,zero_pad=self.zero_pad) + self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]))) - if self.method == 'self-pairwise': - self.sims[j,i] = self.sims[i,j] + if self.dsa_verbose: + print('comparing dmds') + + def compute_similarity(i, j): + if self.method == "self-pairwise" and j >= i: + return None + + if self.dsa_verbose and self.n_jobs != 1: + print(f"computing similarity between DMDs {i} and {j}") + sim = self.simdist.fit_score( + self.get_dmd_matrix(self.dmds[0][i]), + self.get_dmd_matrix(self.dmds[ind2][j]), + iters, + lr, + score_method, + zero_pad=self.zero_pad, + ) + if self.dsa_verbose and self.n_jobs != 1: + print(f"computing similarity between DMDs {i} and {j}") + + return (i, j, sim) + + pairs = [] + for i in range(len(self.dmds[0])): + for j in range(len(self.dmds[ind2])): + if not (self.method == "self-pairwise" and j >= i): + pairs.append((i, j)) + + if self.n_jobs != 1: + n_jobs = self.n_jobs if self.n_jobs > 0 else -1 + if self.dsa_verbose: + print(f"Computing {len(pairs)} DMD similarities in parallel with {n_jobs} jobs") + + results = Parallel(n_jobs=n_jobs)( + delayed(compute_similarity)(i, j) for i, j in pairs + ) + else: + loop = pairs if not self.dsa_verbose else tqdm.tqdm(pairs, desc="Computing DMD similarities") + results = [compute_similarity(i, j) for i, j in loop] + + for result in results: + if result is not None: + i, j, sim = result + self.sims[i, j] = sim + if self.method == "self-pairwise": + self.sims[j, i] = sim - if self.method == 'default': - return self.sims[0,0] + if self.method == "default": + return self.sims[0, 0] return self.sims diff --git a/DSA/kerneldmd.py b/DSA/kerneldmd.py deleted file mode 100644 index 26313cb..0000000 --- a/DSA/kerneldmd.py +++ /dev/null @@ -1,180 +0,0 @@ -from sklearn.gaussian_process.kernels import DotProduct, RBF -from kooplearn.data import traj_to_contexts -from kooplearn.models import NystroemKernel -import numpy as np -import torch - -class KernelDMD(NystroemKernel): - def __init__( - self, - data, - n_delays, - kernel = RBF(), - num_centers=0.1, - delay_interval=1, - rank=10, - reduced_rank_reg=True, - lamb=1e-10, - verbose=False, - svd_solver='arnoldi', - ): - """ - Subclass of kooplearn that uses a kernel to compute the DMD model. - This will also use Reduced Rank Regression as opposed to Principal Component Regression (above) - """ - super().__init__(kernel,reduced_rank_reg,rank,lamb,svd_solver,num_centers) - self.n_delays = n_delays - self.context_window_len = n_delays + 1 - self.delay_interval = delay_interval - self.verbose = verbose - self.rank = rank - self.lamb = 0 if lamb is None else lamb - - self.data = data - - def fit( - self, - data=None, - lamb=None, - ): - """ - Parameters - ---------- - data : np.ndarray or torch.tensor - The data to fit the DMD model to. Must be either: (1) a - 2-dimensional array/tensor of shape T x N where T is the number - of time points and N is the number of observed dimensions - at each time point, or (2) a 3-dimensional array/tensor of shape - K x T x N where K is the number of "trials" and T and N are - as defined above. Defaults to None - provide only if you want to - override the value from the init. - - lamb : float - Regularization parameter for ridge regression. Defaults to None - provide only if you want to - override the value from the init. - """ - data = self.data if data is None else data - lamb = self.lamb if lamb is None else lamb - - self.compute_hankel(data) - self.compute_kernel_dmd(lamb) - - def compute_hankel(self,trajs): - ''' - Given a numpy array or list of trajectories, returns a numpy array of delay embeddings - in the format required by kooplearn. - Parameters - ---------- - trajs : np.ndarray or list, with each array having shape - (num_samples, timesteps, dimension) or shape (timesteps, dimension). - Note that trajectories can have different numbers of timesteps but must have the same dimension - n_delays : int - The number of delays to include in the delay embedding - delay_interval : int - The number of time steps between each delay in the delay embedding - ''' - if isinstance(trajs, torch.Tensor): - #convert trajs to a np array - trajs = trajs.numpy() - if isinstance(trajs,np.ndarray) and trajs.ndim == 2: - trajs = trajs[np.newaxis,:,:] - - data = traj_to_contexts(trajs[0],context_window_len=self.context_window_len, - time_lag=self.delay_interval) - # idx = np.zeros(data.idx_map.shape) - # data.idx_map = np.concatenate((idx,data.idx_map),axis=-1) - for i in range(1,len(trajs)): - new_traj = traj_to_contexts(trajs[i],context_window_len=self.context_window_len, - time_lag=self.delay_interval) - - data.data = np.concatenate((data.data,new_traj.data),axis=0) - - #update index map for consistency - # idx = np.zeros(new_traj.idx_map.shape) + 1 - # new_traj.idx_map = np.concatenate((idx,new_traj.idx_map),axis=-1) - # data.idx_map = np.concatenate((data.idx_map,new_traj.idx_map),axis=0) - - self.data = data - - if self.verbose: - print("Hankel matrix computed") - - def compute_kernel_dmd(self,lamb = None): - ''' - Computes the kernel DMD model. - ''' - self.tikhonov_reg = self.lamb if lamb is None else lamb - #we need to use the inherited .fit method from NystroemKernel - - # data = self.data.reshape(-1,*self.data.shape[2:]) - super().fit(self.data) - - self.A_v = self.V.T @ self.kernel_YX @ self.U / len(self.kernel_YX) - - if self.verbose: - print("kernel regression complete") - - def predict( - self, - test_data=None, - reseed=None, - ): - ''' - Assuming test_data is one trajectory or list of trajectories - - Returns - ------- - pred_data : np.ndarray - The predictions generated by the kernelDMD model. Of the same shape as test_data. Note that the first - (self.n_delays - 1)*self.delay_interval + 1 time steps of the generated predictions are by construction - identical to the test_data. - ''' - if test_data is None: - test_data = self.data - if reseed is None: - reseed = 1 - else: - raise NotImplementedError - - if isinstance(test_data, torch.Tensor): - test_data = test_data.numpy() - if isinstance(test_data,list): - test_data = np.array(test_data) - - isdim2 = test_data.ndim == 2 - if isdim2: #if we have a single trajectory - test_data = test_data[np.newaxis, :, :] - - pred_data = np.zeros(test_data.shape) - pred_data[:, 0:self.n_delays] = test_data[:, 0:self.n_delays] - - #here the hankel matrix should be (ntrials,time,n_delays,dim) - self.compute_hankel(test_data) - - pred = super().predict(self.data) - pred = pred.reshape(test_data.shape[0],test_data.shape[1]-self.n_delays,test_data.shape[2]) - pred_data[:,self.n_delays:] = pred - - return pred_data.squeeze() - #TODO: integrate tailbiting - #split into original trajectories so pred_data matches test_data - # import ipdb; ipdb.set_trace() - - # #reshape into the right 4 dimensions - # test_data = self.data.data.reshape(test_data.shape[0],test_data.shape[1]-self.n_delays,self.context_window_len,test_data.shape[2]) - - # #get the test data into the format of the hankel matrix - # #apply the nystroem predict function - # for t in range(self.n_delays, test_data.shape[1]): - # if t % reseed == 0: - # #need to ignore the current value which is what we're trying to predict - # #hence the -1 at the end - # curr = test_data[:,t-1:t,:-1].reshape(-1,self.n_delays,test_data.shape[-1]) - # pred_data[:,t] = super().predict(curr) - # else: - # past = pred_data[:,t-self.context_window_len:t] - # pred_data[:,t] = super().predict(past) - - # if isdim2: - # pred_data = pred_data[0] - diff --git a/DSA/preprocessing.py b/DSA/preprocessing.py index 3dd5a6a..a44badd 100644 --- a/DSA/preprocessing.py +++ b/DSA/preprocessing.py @@ -46,7 +46,6 @@ def normalize_data(data_list): return normalized_data_list - def coarse_grain(trajectories, bin_size=5, bins_overlapping=0): """ Bin or sum trajectories over time windows, with optional overlap. @@ -76,7 +75,7 @@ def coarse_grain(trajectories, bin_size=5, bins_overlapping=0): for j in range(n_bins): start_idx = j * (bin_size - bins_overlapping) end_idx = start_idx + bin_size - coarse_trajectories[:, j] = np.sum( + coarse_trajectories[:, j] = np.mean( trajectories[:, start_idx:end_idx], axis=1 ) else: @@ -90,7 +89,7 @@ def coarse_grain(trajectories, bin_size=5, bins_overlapping=0): for j in range(n_bins): start_idx = j * (bin_size - bins_overlapping) end_idx = start_idx + bin_size - coarse_trajectories[j] = np.sum(trajectories[start_idx:end_idx], axis=0) + coarse_trajectories[j] = np.mean(trajectories[start_idx:end_idx], axis=0) return coarse_trajectories @@ -213,11 +212,7 @@ def nonlinear_dimensionality_reduction( pca = PCA(n_components=n_components) model = make_pipeline(nystroem, pca) elif method.lower() == "umap": - #assert that umap is installed - try: - from umap import UMAP - except ImportError: - raise ImportError("umap is not installed. Please install it with `pip install umap-learn`") + from umap import UMAP model = UMAP(n_components=n_components, **kwargs) else: @@ -304,4 +299,100 @@ def gaussian_filter(data, sigma, truncate=2.0,causal=True,dim=0,mode='same'): arr=data ) - return filtered_data, kernel \ No newline at end of file + return filtered_data, kernel + + +def coarse_grain_space(data, method='uniform', nbins_per_dim=20, sigma=None, kernel_width=2, scale='standard'): + ''' + Convert continuous data to one-hot encoded spatial bins, optionally with spatial smoothing. + + Parameters + ---------- + data : np.ndarray + Input data of shape (n_conditions, n_timepoints, n_dims) or (n_timepoints, n_dims) + method : str + Method for binning. Currently only 'uniform' is supported. + nbins_per_dim : int + Number of bins per dimension + sigma : float or None + Standard deviation for Gaussian smoothing kernel. If None, no smoothing is applied. + kernel_width : int + Width of smoothing kernel in number of bins + scale : str + Scaling method: 'standard' for zero mean unit variance, or 'minmax' for [0,1] range + + Returns + ------- + encoded : np.ndarray + One-hot encoded data with shape (n_conditions, n_timepoints, n_total_bins) + or (n_timepoints, n_total_bins) + ''' + if method != 'uniform': + raise NotImplementedError(f"Method {method} not implemented. Only 'uniform' is currently supported.") + + # Get input shape and dimensionality + orig_shape = data.shape + if data.ndim == 3: + n_conds, n_time, n_dims = data.shape + data_reshaped = data.reshape(-1, n_dims) + else: + n_time, n_dims = data.shape + data_reshaped = data + + # Scale the data + if scale == 'standard': + mean = np.mean(data_reshaped, axis=0) + std = np.std(data_reshaped, axis=0) + data_scaled = (data_reshaped - mean) / std + elif scale == 'minmax': + min_vals = np.min(data_reshaped, axis=0) + max_vals = np.max(data_reshaped, axis=0) + data_scaled = (data_reshaped - min_vals) / (max_vals - min_vals) + else: + raise ValueError("scale must be 'standard' or 'minmax'") + + # Calculate total number of bins and check if reasonable + n_total_bins = nbins_per_dim ** n_dims + if n_total_bins > 1e6: + raise ValueError(f"Total number of bins ({n_total_bins}) too large. Reduce nbins_per_dim or use different binning method.") + + # Create bin edges + bin_edges = [np.linspace(np.min(data_scaled[:,d]), np.max(data_scaled[:,d]), nbins_per_dim+1) + for d in range(n_dims)] + + # Initialize one-hot encoded array + if data.ndim == 3: + encoded = np.zeros((n_conds, n_time, n_total_bins)) + else: + encoded = np.zeros((n_time, n_total_bins)) + + # Assign data points to bins and handle edge cases + # Vectorized bin assignment and clipping for all dimensions at once + bin_indices = np.stack([ + np.clip(np.digitize(data_scaled[:,d], bin_edges[d]) - 1, 0, nbins_per_dim-1) + for d in range(n_dims) + ]).T + + if n_dims > 1: + flat_indices = np.ravel_multi_index(bin_indices.T, [nbins_per_dim] * n_dims) + else: + # For 1D case, bin_indices is already the flat indices + flat_indices = bin_indices.ravel() + + if data.ndim == 3: + encoded.reshape(-1, n_total_bins)[np.arange(len(flat_indices)), flat_indices] = 1 + else: + encoded[np.arange(len(flat_indices)), flat_indices] = 1 + + # Apply spatial smoothing if requested + if sigma is not None: + from scipy.ndimage import gaussian_filter1d + if data.ndim == 3: + for i in range(n_conds): + for t in range(n_time): + encoded[i,t] = gaussian_filter1d(encoded[i,t], sigma=sigma, truncate=kernel_width) + else: + for t in range(n_time): + encoded[t] = gaussian_filter1d(encoded[t], sigma=sigma, truncate=kernel_width) + + return encoded \ No newline at end of file diff --git a/DSA/simdist.py b/DSA/simdist.py index 8d73078..e15e909 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -5,27 +5,41 @@ import numpy as np import torch.nn.utils.parametrize as parametrize from scipy.stats import wasserstein_distance -import ot #optimal transport for multidimensional l2 wasserstein +import ot # optimal transport for multidimensional l2 wasserstein +from DSA import DMD -def pad_zeros(A,B,device): + +def pad_zeros(A, B, device): with torch.no_grad(): - dim = max(A.shape[0],B.shape[0]) - A1 = torch.zeros((dim,dim)).float() - A1[:A.shape[0],:A.shape[1]] += A + dim = max(A.shape[0], B.shape[0]) + A1 = torch.zeros((dim, dim)).float() + A1[: A.shape[0], : A.shape[1]] += A A = A1.float().to(device) - B1 = torch.zeros((dim,dim)).float() - B1[:B.shape[0],:B.shape[1]] += B + B1 = torch.zeros((dim, dim)).float() + B1[: B.shape[0], : B.shape[1]] += B B = B1.float().to(device) - return A,B - + return A, B + +def compute_angle(evec): + ''' + computes the angle between multiple complex eigenvectors + ''' + if isinstance(evec, np.ndarray): + evec = torch.from_numpy(evec).float() + # evec /= torch.linalg.norm(evec, dim=1, keepdim=True) + ang = torch.real(evec.H @ evec) + ang = torch.arccos(ang) + ang[torch.isnan(ang)] = 0 + return ang class LearnableSimilarityTransform(nn.Module): """ - Computes the similarity transform for a learnable orthonormal matrix C + Computes the similarity transform for a learnable orthonormal matrix C """ - def __init__(self, n,orthog=True): + + def __init__(self, n, orthog=True): """ Parameters __________ @@ -33,27 +47,28 @@ def __init__(self, n,orthog=True): dimension of the C matrix """ super(LearnableSimilarityTransform, self).__init__() - #initialize orthogonal matrix as identity + # initialize orthogonal matrix as identity self.C = nn.Parameter(torch.eye(n).float()) self.orthog = orthog - + def forward(self, B): if self.orthog: return self.C @ B @ self.C.transpose(-1, -2) else: return self.C @ B @ torch.linalg.inv(self.C) + class Skew(nn.Module): - def __init__(self,n,device): + def __init__(self, n, device): """ Computes a skew-symmetric matrix X from some parameters (also called X) - + """ super().__init__() - - self.L1 = nn.Linear(n,n,bias = False, device = device) - self.L2 = nn.Linear(n,n,bias = False, device = device) - self.L3 = nn.Linear(n,n,bias = False, device = device) + + self.L1 = nn.Linear(n, n, bias=False, device=device) + self.L2 = nn.Linear(n, n, bias=False, device=device) + self.L3 = nn.Linear(n, n, bias=False, device=device) def forward(self, X): X = torch.tanh(self.L1(X)) @@ -61,17 +76,18 @@ def forward(self, X): X = self.L3(X) return X - X.transpose(-1, -2) + class Matrix(nn.Module): - def __init__(self,n,device): + def __init__(self, n, device): """ Computes a matrix X from some parameters (also called X) - + """ super().__init__() - - self.L1 = nn.Linear(n,n,bias = False, device = device) - self.L2 = nn.Linear(n,n,bias = False, device = device) - self.L3 = nn.Linear(n,n,bias = False, device = device) + + self.L1 = nn.Linear(n, n, bias=False, device=device) + self.L2 = nn.Linear(n, n, bias=False, device=device) + self.L3 = nn.Linear(n, n, bias=False, device=device) def forward(self, X): X = torch.tanh(self.L1(X)) @@ -79,49 +95,55 @@ def forward(self, X): X = self.L3(X) return X + class CayleyMap(nn.Module): """ Maps a skew-symmetric matrix to an orthogonal matrix in O(n) """ + def __init__(self, n, device): """ Parameters __________ - n : int + n : int dimension of the matrix we want to map - + device : {'cpu','cuda'} or int hardware device on which to send the matrix """ super().__init__() - self.register_buffer("Id", torch.eye(n,device = device)) + self.register_buffer("Id", torch.eye(n, device=device)) def forward(self, X): # (I + X)(I - X)^{-1} return torch.linalg.solve(self.Id + X, self.Id - X) - + + class SimilarityTransformDist: """ Computes the Procrustes Analysis over Vector Fields """ - def __init__(self, - iters = 200, - score_method: Literal["angular", "euclidean","wasserstein"] = "angular", - lr = 0.01, - device: Literal["cpu","cuda"] = 'cpu', - verbose = False, - group: Literal["O(n)","SO(n)","GL(n)"] = "O(n)", - wasserstein_compare = 'eig' - ): + + def __init__( + self, + iters=200, + score_method: Literal["angular", "euclidean", "wasserstein"] = "angular", + lr=0.01, + device: Literal["cpu", "cuda"] = "cpu", + verbose=False, + wasserstein_compare: Literal["sv", "eig"] = "eig", + eps=1e-5, + rescale_wasserstein=False, + ): """ Parameters _________ iters : int number of iterations to perform gradient descent - + score_method : {"angular","euclidean","wasserstein"} - specifies the type of metric to use + specifies the type of metric to use "wasserstein" will compare the singular values or eigenvalues of the two matrices as in Redman et al., (2023) @@ -132,13 +154,13 @@ def __init__(self, verbose : bool prints when finished optimizing - - group : {'SO(n)','O(n)', 'GL(n)'} - specifies the group of matrices to optimize over - wasserstein_compare : {,'eig',None} + wasserstein_compare : {'sv','eig',None} specifies whether to compare the singular values or eigenvalues if score_method is "wasserstein", or the shapes are different + + eps : float + early stopping threshold """ self.iters = iters @@ -149,94 +171,154 @@ def __init__(self, self.C_star = None self.A = None self.B = None - self.group = group self.wasserstein_compare = wasserstein_compare - - def fit(self, - A, - B, - iters = None, - lr = None, - group = None, - ): + self.eps = eps + self.rescale_wasserstein = rescale_wasserstein + + def fit( + self, + A, + B, + iters=None, + lr=None, + score_method=None, + wasserstein_compare=None, + wasserstein_weightings = None, + + ): """ Computes the optimal matrix C over specified group Parameters __________ - A : np.array or torch.tensor + A : np.array or torch.tensor or DMD object first data matrix - B : np.array or torch.tensor + B : np.array or torch.tensor or DMD object second data matrix iters : int or None number of optimization steps, if None then resorts to saved self.iters lr : float or None learning rate, if None then resorts to saved self.lr - group : {'SO(n)','O(n)', 'GL(n)'} - specifies the group of matrices to optimize over Returns _______ None """ + if isinstance(A,DMD): + A = A.A_v + if isinstance(B,DMD): + B = B.A_v + assert A.shape[0] == A.shape[1] assert B.shape[0] == B.shape[1] - + A = A.to(self.device) B = B.to(self.device) - self.A,self.B = A,B + self.A, self.B = A, B lr = self.lr if lr is None else lr - iters = self.iters if iters is None else iters - group = self.group if group is None else group - - if group in {"SO(n)", "O(n)"}: - self.losses, self.C_star, self.sim_net = self.optimize_C(A, - B, - lr,iters, - orthog=True, - verbose=self.verbose) - if group == "O(n)": - #permute the first row and column of B then rerun the optimization - P = torch.eye(B.shape[0],device=self.device) + iters = self.iters if iters is None else iters + wasserstein_compare = self.wasserstein_compare if wasserstein_compare is None else wasserstein_compare + score_method = self.score_method if score_method is None else score_method + + if score_method == 'wasserstein': + a,b = self._get_wasserstein_vars(A, B) + device = a.device + # a = a # .cpu() + # b = b # .cpu() + self.M = ot.dist(a, b) # .numpy() + if wasserstein_weightings is not None: + a, b = wasserstein_weightings + assert isinstance(a, (torch.Tensor, np.ndarray)) + assert isinstance(b, (torch.Tensor, np.ndarray)) + assert a.shape[0] == self.M.shape[0] + assert b.shape[0] == self.M.shape[1] + assert a.sum() == b.sum() == 1 + else: + a, b = ( + torch.ones(a.shape[0]) / a.shape[0], + torch.ones(b.shape[0]) / b.shape[0], + ) + a, b = a.to(device), b.to(device) + + self.C_star = ot.emd(a, b, self.M) + self.score_star = ot.emd2(a, b, self.M) *a.shape[0] #add scaling factor due to random matrix theory + # self.score_star = np.sum(self.C_star * self.M) + self.C_star = self.C_star / torch.linalg.norm(self.C_star, dim=1, keepdim=True) + # wasserstein_distance(A.cpu().numpy(),B.cpu().numpy()) + + else: + self.losses, self.C_star, self.sim_net = self.optimize_C( + A, B, lr, iters, orthog=True, verbose=self.verbose + ) + # permute the first row and column of B then rerun the optimization + P = torch.eye(B.shape[0], device=self.device) if P.shape[0] > 1: P[[0, 1], :] = P[[1, 0], :] - losses, C_star, sim_net = self.optimize_C(A, - P @ B @ P.T, - lr,iters, - orthog=True, - verbose=self.verbose) + losses, C_star, sim_net = self.optimize_C( + A, P @ B @ P.T, lr, iters, orthog=True, verbose=self.verbose + ) if losses[-1] < self.losses[-1]: self.losses = losses self.C_star = C_star @ P self.sim_net = sim_net - if group == "GL(n)": - self.losses, self.C_star, self.sim_net = self.optimize_C(A, - B, - lr,iters, - orthog=False, - verbose=self.verbose) - - def optimize_C(self,A,B,lr,iters,orthog,verbose): - #parameterize mapping to be orthogonal + + def _get_wasserstein_vars(self,A, B): + assert self.wasserstein_compare in {"sv", "eig","evec_angle", 'evec'} + if self.wasserstein_compare == "sv": + a = torch.svd(A).S.view(-1, 1) + b = torch.svd(B).S.view(-1, 1) + elif self.wasserstein_compare == "eig": + a = torch.linalg.eig(A).eigenvalues + a = torch.vstack([a.real, a.imag]).T + + b = torch.linalg.eig(B).eigenvalues + b = torch.vstack([b.real, b.imag]).T + elif self.wasserstein_compare in {'evec_angle', 'evec'}: + #this will compute the interior angles between eigenvectors + aevec = torch.linalg.eig(A).eigenvectors + bevec = torch.linalg.eig(B).eigenvectors + + a = compute_angle(aevec) + b = compute_angle(bevec) + else: + raise AssertionError("wasserstein_compare must be 'sv', 'eig', 'evec_angle', or 'evec'") + + #if the number of elements in the sets are different, then we need to pad the smaller set with zeros + if a.shape[0] != b.shape[0]: + if self.wasserstein_compare in {'evec_angle', 'evec'}: + raise AssertionError("Wasserstein comparison of eigenvectors is not supported when \ + the number of elements in the sets are different") + if self.verbose: + print(f"Padding the smaller set with zeros") + if a.shape[0] < b.shape[0]: + a = torch.cat([a, torch.zeros(b.shape[0] - a.shape[0], a.shape[1])], dim=0) + else: + b = torch.cat([b, torch.zeros(a.shape[0] - b.shape[0], b.shape[1])], dim=0) + return a,b + + def optimize_C(self, A, B, lr, iters, orthog, verbose): + # parameterize mapping to be orthogonal n = A.shape[0] - sim_net = LearnableSimilarityTransform(n,orthog=orthog).to(self.device) + sim_net = LearnableSimilarityTransform(n, orthog=orthog).to(self.device) if orthog: - parametrize.register_parametrization(sim_net, "C", Skew(n,self.device)) - parametrize.register_parametrization(sim_net, "C", CayleyMap(n,self.device)) + parametrize.register_parametrization(sim_net, "C", Skew(n, self.device)) + parametrize.register_parametrization( + sim_net, "C", CayleyMap(n, self.device) + ) else: - parametrize.register_parametrization(sim_net, "C", Matrix(n,self.device)) - - simdist_loss = nn.MSELoss(reduction = 'sum') + parametrize.register_parametrization(sim_net, "C", Matrix(n, self.device)) + + simdist_loss = nn.MSELoss(reduction="sum") optimizer = optim.Adam(sim_net.parameters(), lr=lr) # scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.999) losses = [] - A = A / torch.linalg.norm(A) - B = B / torch.linalg.norm(B) + A /= torch.linalg.norm(A) + B /= torch.linalg.norm(B) for _ in range(iters): # Zero the gradients of the optimizer. - optimizer.zero_grad() + optimizer.zero_grad() # Compute the Frobenius norm between A and the product. loss = simdist_loss(A, sim_net(B)) @@ -246,14 +328,17 @@ def optimize_C(self,A,B,lr,iters,orthog,verbose): # if _ % 99: # scheduler.step() losses.append(loss.item()) - + #TODO: add a flag for this + # if _ > 2 and abs(losses[-1] - losses[-2]) < self.eps: #early stopping + # break + if verbose: print("Finished optimizing C") C_star = sim_net.C.detach() - return losses, C_star,sim_net - - def score(self,A=None,B=None,score_method=None,group=None): + return losses, C_star, sim_net + + def score(self, A=None, B=None, score_method=None, wasserstein_compare=None): """ Given an optimal C already computed, calculate the metric @@ -273,70 +358,67 @@ def score(self,A=None,B=None,score_method=None,group=None): """ assert self.C_star is not None A = self.A if A is None else A - B = self.B if B is None else B + B = self.B if B is None else B assert A is not None assert B is not None - assert A.shape == self.C_star.shape - assert B.shape == self.C_star.shape + assert A.shape == self.C_star.shape or score_method == 'wasserstein' + assert B.shape == self.C_star.shape or score_method == 'wasserstein' score_method = self.score_method if score_method is None else score_method - group = self.group if group is None else group + wasserstein_compare = self.wasserstein_compare if wasserstein_compare is None else wasserstein_compare with torch.no_grad(): - if not isinstance(A,torch.Tensor): + if not isinstance(A, torch.Tensor): A = torch.from_numpy(A).float().to(self.device) - if not isinstance(B,torch.Tensor): + if not isinstance(B, torch.Tensor): B = torch.from_numpy(B).float().to(self.device) C = self.C_star.to(self.device) - if group in {"SO(n)", "O(n)"}: - Cinv = C.T - elif group in {"GL(n)"}: - Cinv = torch.linalg.inv(C) - else: - raise AssertionError("Need proper group name") - if score_method == 'angular': - num = torch.trace(A.T @ C @ B @ Cinv) - den = torch.norm(A,p = 'fro')*torch.norm(B,p = 'fro') - score_tensor = torch.arccos(num / den) - - if score_tensor.requires_grad: - pi_tensor = torch.tensor(np.pi, device=score_tensor.device, dtype=score_tensor.dtype) - zero_tensor = torch.tensor(0.0, device=score_tensor.device, dtype=score_tensor.dtype) - - score = torch.where( - torch.isnan(score_tensor), - torch.where((num / den) < 0, pi_tensor, zero_tensor), - score_tensor - ) + if score_method == "angular": + num = torch.trace(A.T @ C @ B @ C.T) + den = torch.norm(A, p="fro") * torch.norm(B, p="fro") + score = torch.arccos(num / den).cpu().numpy() + if np.isnan(score): # around -1 and 1, we sometimes get NaNs due to arccos + if num / den < 0: + score = np.pi + else: + score = 0 + elif score_method == 'euclidean': + score = ( + torch.norm(A - C @ B @ C.T, p="fro").cpu().numpy().item() + ) # / A.numpy().size + elif score_method == 'wasserstein': + #use the current C_star to compute the score + assert hasattr(self, 'score_star') + if wasserstein_compare == self.wasserstein_compare: + score = self.score_star.item() else: - score = score_tensor.detach().cpu().numpy() - if np.isnan(score): - score = np.pi if (num / den).item() < 0 else 0.0 - else: - norm_tensor = torch.norm(A - C @ B @ Cinv, p='fro') - if norm_tensor.requires_grad: - score = norm_tensor - else: - score = norm_tensor.detach().cpu().numpy().item() - - + #apply the current transport plan to the new data + a,b = self._get_wasserstein_vars(A, B) + # a_transported = self.C_star @ A #shouldn't this be a? + + M = ot.dist(a, b, metric='sqeuclidean') + score = torch.sum(self.C_star * M).item() + #TODO: validate this + # a_transported = self.C_star @ a + # row_wise_sq_distances = torch.sum(torch.square(a_transported - b), axis=1) + # transported_score = torch.sum(a * row_wise_sq_distances) + # score = transported_score.item() + if self.rescale_wasserstein: + score = score * A.shape[0] #add scaling factor due to random matrix theory + return score - - def fit_score(self, - A, - B, - iters = None, - lr = None, - score_method = None, - group = None): + + def fit_score( + self, A, B, iters=None, lr=None, score_method=None, zero_pad=True, wasserstein_weightings=None + ): """ - for efficiency, computes the optimal matrix and returns the score + for efficiency, computes the optimal matrix and returns the score Parameters __________ A : np.array or torch.tensor first data matrix B : np.array or torch.tensor - second data matrix + second data matrix iters : int or None number of optimization steps, if None then resorts to saved self.iters lr : float or None @@ -350,50 +432,84 @@ def fit_score(self, score : float similarity of the data under the similarity transform w.r.t C - + """ score_method = self.score_method if score_method is None else score_method - group = self.group if group is None else group - if isinstance(A,np.ndarray): + if isinstance(A, np.ndarray): A = torch.from_numpy(A).float() - if isinstance(B,np.ndarray): + if isinstance(B, np.ndarray): B = torch.from_numpy(B).float() assert A.shape[0] == B.shape[1] or self.wasserstein_compare is not None if A.shape[0] != B.shape[0]: if self.wasserstein_compare is None: - raise AssertionError("Matrices must be the same size unless using wasserstein distance") - elif self.verbose: #otherwise resort to L2 Wasserstein over singular or eigenvalues - print(f"resorting to wasserstein distance over {self.wasserstein_compare}") - - if self.score_method == "wasserstein": - # assert self.wasserstein_compare in {"sv","eig"} - # if self.wasserstein_compare == "sv": - # a = torch.svd(A).S.view(-1,1) - # b = torch.svd(B).S.view(-1,1) - # if self.wasserstein_compare == "eig": - a = torch.linalg.eig(A).eigenvalues - a = torch.vstack([a.real,a.imag]).T - - b = torch.linalg.eig(B).eigenvalues - b = torch.vstack([b.real,b.imag]).T - # else: - # raise AssertionError("wasserstein_compare must be or 'eig'") - device = a.device - a = a#.cpu() - b = b#.cpu() - M = ot.dist(a,b)#.numpy() - a,b = torch.ones(a.shape[0])/a.shape[0],torch.ones(b.shape[0])/b.shape[0] - a,b = a.to(device),b.to(device) - - score_star = ot.emd2(a,b,M) - #wasserstein_distance(A.cpu().numpy(),B.cpu().numpy()) + raise AssertionError( + "Matrices must be the same size unless using wasserstein distance" + ) + elif score_method != 'wasserstein': # otherwise resort to L2 Wasserstein over singular or eigenvalues + print( + f"resorting to wasserstein distance over {self.wasserstein_compare}" + ) + score_method = 'wasserstein' + else: + pass - else: - - self.fit(A, B,iters,lr,group) - score_star = self.score(self.A,self.B,score_method=score_method,group=group) - return score_star + self.fit(A, B, iters, lr, wasserstein_weightings=wasserstein_weightings, score_method=score_method) + return self.score( + self.A, self.B, score_method=score_method + ) + +def compute_subspace_angles(A, B): + """ + Computes the subspace angles between two DMD matrices. + Matrices must be square and the same size. + + Parameters + ---------- + A : DMD object or numpy array + First DMD matrix + B : DMD object or numpy array + Second DMD matrix + + Returns + ------- + angles : np.ndarray + Principal angles between the subspaces + """ + + A_mat = val_matrix(A) + B_mat = val_matrix(B) + + # Check matrices are same size + if A_mat.shape != B_mat.shape: + raise ValueError("Matrices must be the same size") + + # Get orthonormal bases via SVD + U_A = np.linalg.svd(A_mat)[0] + U_B = np.linalg.svd(B_mat)[0] + + # Compute principal angles + S = np.linalg.svd(U_A.T @ U_B)[1] + S = np.clip(S, -1.0, 1.0) # Numerical stability + angles = np.arccos(S) + + return angles + +def val_matrix(matrix): + if isinstance(matrix, DMD): + mat = matrix.A_havok_dmd + elif isinstance(matrix, torch.Tensor): + mat = matrix.detach().numpy() + elif isinstance(matrix, np.ndarray): + mat = matrix + else: + raise AssertionError(f" must be tensor, numpy array, or DMD object") + + # Check matrix is square + if mat.shape[0] != mat.shape[1]: + raise ValueError(f"matrix must be square") + + return mat diff --git a/DSA/sweeps.py b/DSA/sweeps.py index 04e89ce..4bb07ba 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -1,8 +1,8 @@ import numpy as np from tqdm import tqdm -from DSA.dmd import DMD -from DSA.stats import measure_nonnormality_transpose, compute_all_stats, measure_transient_growth -from DSA.resdmd import compute_residuals +from .dmd import DMD +from .stats import measure_nonnormality_transpose, compute_all_stats, measure_transient_growth +from .resdmd import compute_residuals import matplotlib.pyplot as plt from typing import Literal @@ -110,11 +110,11 @@ def sweep_ranks_delays( if isinstance(pred,list): pred = np.concatenate(pred,axis=0) test_data_err = np.concatenate(test_data_err,axis=0) - if featurize and ndim is not None: - pred = pred[:, :, -ndim:] - stats = compute_all_stats(pred, test_data_err[:, :, -ndim:], dmd.rank) - else: - stats = compute_all_stats(test_data_err, pred, dmd.rank) + # if featurize and ndim is not None: + # pred = pred[:, :, -ndim:] + # stats = compute_all_stats(pred, test_data_err[:, :, -ndim:], dmd.rank) + # else: + stats = compute_all_stats(test_data_err, pred, dmd.rank) aic = stats["AIC"] mase = stats["MASE"] if return_mse: @@ -323,10 +323,12 @@ def plot_sweep_results_all_error_types( figsize=(2, 4), xscale='log', aic_scale='symlog', + mase_scale = 'log', plot_herror=False, new_plot_reseeds=False, cmap="gist_gray", - metrics_order=['AIC','MASE','MSE'] + metrics_order=['AIC','MASE','MSE'], + pretty_yticks=False ): """ Plot all error types from sweep_ranks_delays_all_error_types as a 3 x (3*len(reseeds)) grid, @@ -429,8 +431,8 @@ def plot_sweep_results_all_error_types( row_ymaxs[metric_idx] = max(row_ymaxs[metric_idx], np.nanmax(valid_y)) if metric == "MASE": ax.axhline(1, color="black", linestyle="--", linewidth=0.7) - if metric in {"MASE", "MSE"}: - ax.set_yscale("log") + if metric in {"MASE", "MSE"} and mase_scale in {'symlog','log','linear'}: + ax.set_yscale(mase_scale) if aic_scale in {'symlog','log','linear'} and metric == "AIC": ax.set_yscale(aic_scale) if xscale == 'log': @@ -460,14 +462,15 @@ def plot_sweep_results_all_error_types( ax.set_yticklabels([]) ax.yaxis.set_major_locator(plt.NullLocator()) ax.yaxis.set_minor_locator(plt.NullLocator()) - for reseed_idx in range(n_reseeds): - ax = axes[metric_idx][reseed_idx] - # Only set exactly two yticks (min and max), and always set their labels - ax.set_ylim([ymin, ymax]) - ax.set_yticks([ymin, ymax]) - # Set tick labels to formatted numbers (scientific if needed) - ticklabels = [f"{ymin:.2g}", f"{ymax:.2g}"] - ax.set_yticklabels(ticklabels) + if pretty_yticks: + for reseed_idx in range(n_reseeds): + ax = axes[metric_idx][reseed_idx] + # Only set exactly two yticks (min and max), and always set their labels + ax.set_ylim([ymin, ymax]) + ax.set_yticks([ymin, ymax]) + # Set tick labels to formatted numbers (scientific if needed) + ticklabels = [f"{ymin:.2g}", f"{ymax:.2g}"] + ax.set_yticklabels(ticklabels) plt.suptitle(f"{name + '_' if name else ''}{space} tuning", fontsize=14,y=1.05) plt.tight_layout() #rect=[0, 0, 1, 0.97]) From 0884e186bb7143deb5f5fd7bb1b35dc3c0833208 Mon Sep 17 00:00:00 2001 From: ostrow Date: Mon, 27 Oct 2025 18:32:22 -0400 Subject: [PATCH 02/51] add modified version of pykoopman (until they accept my pull request) --- DSA/pykoopman/.readthedocs.yaml | 35 + DSA/pykoopman/LICENSE | 21 + DSA/pykoopman/README.rst | 262 +++ DSA/pykoopman/src/pykoopman/__init__.py | 23 + .../src/pykoopman/analytics/__init__.py | 7 + .../src/pykoopman/analytics/_base_analyzer.py | 89 + .../src/pykoopman/analytics/_ms_pd21.py | 462 ++++++ .../pykoopman/analytics/_pruned_koopman.py | 162 ++ .../src/pykoopman/common/__init__.py | 37 + DSA/pykoopman/src/pykoopman/common/cqgle.py | 234 +++ .../src/pykoopman/common/examples.py | 1045 ++++++++++++ DSA/pykoopman/src/pykoopman/common/ks.py | 189 +++ DSA/pykoopman/src/pykoopman/common/nlse.py | 186 +++ .../src/pykoopman/common/validation.py | 88 + DSA/pykoopman/src/pykoopman/common/vbe.py | 177 ++ .../src/pykoopman/differentiation/__init__.py | 6 + .../pykoopman/differentiation/_derivative.py | 89 + .../differentiation/_finite_difference.py | 12 + DSA/pykoopman/src/pykoopman/koopman.py | 637 ++++++++ .../src/pykoopman/koopman_continuous.py | 154 ++ .../src/pykoopman/observables/__init__.py | 17 + .../src/pykoopman/observables/_base.py | 408 +++++ .../observables/_custom_observables.py | 239 +++ .../src/pykoopman/observables/_identity.py | 89 + .../src/pykoopman/observables/_polynomial.py | 263 +++ .../observables/_radial_basis_functions.py | 293 ++++ .../observables/_random_fourier_features.py | 193 +++ .../src/pykoopman/observables/_time_delay.py | 216 +++ .../src/pykoopman/regression/__init__.py | 22 + .../src/pykoopman/regression/_base.py | 163 ++ .../pykoopman/regression/_base_ensemble.py | 366 +++++ .../src/pykoopman/regression/_dmd.py | 360 ++++ .../src/pykoopman/regression/_dmdc.py | 468 ++++++ .../src/pykoopman/regression/_edmd.py | 248 +++ .../src/pykoopman/regression/_edmdc.py | 239 +++ .../src/pykoopman/regression/_havok.py | 341 ++++ .../src/pykoopman/regression/_kdmd.py | 460 ++++++ .../src/pykoopman/regression/_nndmd.py | 1454 +++++++++++++++++ 38 files changed, 9754 insertions(+) create mode 100644 DSA/pykoopman/.readthedocs.yaml create mode 100644 DSA/pykoopman/LICENSE create mode 100644 DSA/pykoopman/README.rst create mode 100644 DSA/pykoopman/src/pykoopman/__init__.py create mode 100644 DSA/pykoopman/src/pykoopman/analytics/__init__.py create mode 100644 DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py create mode 100644 DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py create mode 100644 DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py create mode 100644 DSA/pykoopman/src/pykoopman/common/__init__.py create mode 100644 DSA/pykoopman/src/pykoopman/common/cqgle.py create mode 100644 DSA/pykoopman/src/pykoopman/common/examples.py create mode 100644 DSA/pykoopman/src/pykoopman/common/ks.py create mode 100644 DSA/pykoopman/src/pykoopman/common/nlse.py create mode 100644 DSA/pykoopman/src/pykoopman/common/validation.py create mode 100644 DSA/pykoopman/src/pykoopman/common/vbe.py create mode 100644 DSA/pykoopman/src/pykoopman/differentiation/__init__.py create mode 100644 DSA/pykoopman/src/pykoopman/differentiation/_derivative.py create mode 100644 DSA/pykoopman/src/pykoopman/differentiation/_finite_difference.py create mode 100644 DSA/pykoopman/src/pykoopman/koopman.py create mode 100644 DSA/pykoopman/src/pykoopman/koopman_continuous.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/__init__.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_base.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_custom_observables.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_identity.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_polynomial.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py create mode 100644 DSA/pykoopman/src/pykoopman/observables/_time_delay.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/__init__.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_base.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_dmd.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_dmdc.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_edmd.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_edmdc.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_havok.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_kdmd.py create mode 100644 DSA/pykoopman/src/pykoopman/regression/_nndmd.py diff --git a/DSA/pykoopman/.readthedocs.yaml b/DSA/pykoopman/.readthedocs.yaml new file mode 100644 index 0000000..f915bd9 --- /dev/null +++ b/DSA/pykoopman/.readthedocs.yaml @@ -0,0 +1,35 @@ +# .readthedocs.yaml +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the version of Python and other tools you might need +build: + os: ubuntu-22.04 + tools: + python: "3.10" + # You can also specify other tool versions: + # nodejs: "19" + # rust: "1.64" + # golang: "1.19" + +# Build documentation in the docs/ directory with Sphinx +sphinx: + configuration: docs/conf.py + +# If using Sphinx, optionally build your docs in additional formats such as PDF +# formats: +# - pdf + +# Optionally declare the Python requirements required to build your docs +#python: +# install: +# - requirements: requirements-dev.txt +# - method: pip +# path: . +python: + install: + - method: pip + path: .[dev] diff --git a/DSA/pykoopman/LICENSE b/DSA/pykoopman/LICENSE new file mode 100644 index 0000000..7d426ab --- /dev/null +++ b/DSA/pykoopman/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright 2023 Shaowu Pan, Eurika Kaiser, Brian de Silva, J. Nathan Kutz and Steven L. Brunton + +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. diff --git a/DSA/pykoopman/README.rst b/DSA/pykoopman/README.rst new file mode 100644 index 0000000..a255bb6 --- /dev/null +++ b/DSA/pykoopman/README.rst @@ -0,0 +1,262 @@ +PyKoopman +========= + +|Build| |Docs| |PyPI| |Codecov| |DOI| |JOSS| + +**PyKoopman** is a Python package for computing data-driven approximations to the Koopman operator. + +Data-driven approximation of Koopman operator +--------------------------------------------- + +.. figure:: docs/JOSS/Fig1.png + +Given a nonlinear dynamical system, + +.. math:: + + x'(t) = f(x(t)), + +the Koopman operator governs the temporal evolution of the measurement function. +Unfortunately, it is an infinite-dimensional linear operator. Most of the time, one has to +project the Koopman operator onto a finite-dimensional subspace that is spanned by user-defined/data-adaptive functions. + +.. math:: + z = \Phi(x). + +If the system state is also contained in such subspace, then effectively, the nonlinear dynamical system is (approximately) +linearized in a global sense. + +The goal of data-driven approximation of Koopman operator is to find such a set of +functions that span such lifted space and the transition matrix associated with the +lifted system. + +Structure of PyKoopman +^^^^^^^^^^^^^^^^^^^^^^ + +.. figure:: docs/JOSS/Fig2.png + +PyKoopman package is centered around the ``Koopman`` class and ``KoopmanContinuous`` class. It consists of two key components + +* ``observables``: a set of observables functions, which spans the subspace for projection. + +* ``regressor``: the optimization algorithm to find the best ``fit`` for the + projection of Koopman operator. + +After ``Koopman``/``KoopmanContinuous`` object has been created, it must be fit to data, similar to a ``scikit-learn`` model. +We design ``PyKoopman`` such that it is compatible to ``scikit-learn`` objects and methods as much as possible. + + +Features implemented +^^^^^^^^^^^^^^^^^^^^ + +- Observable library for lifting the state into the observable space + + - Identity (for DMD/DMDc or in case users want to compute observables themselves): + ``Identity`` + - Multivariate polynomials: ``Polynomial`` + - Time delay coordinates: ``TimeDelay`` + - Radial basis functions: ``RadialBasisFunctions`` + - Random Fourier features: ``RandomFourierFeatures`` + - Custom library (defined by user-supplied functions): ``CustomObservables`` + - Concatenation of observables: ``ConcatObservables`` + + +- System identification method for performing regression + + - Dynamic mode decomposition: ``PyDMDRegressor`` + - Dynamic mode decomposition with control: ``DMDc`` + - Extended dynamic mode decomposition: ``EDMD`` + - Extended dynamic mode decomposition with control: ``EDMDc`` + - Kernel dynamic mode decomposition: ``KDMD`` + - Hankel Alternative View of Koopman Analysis: ``HAVOK`` + - Neural Network DMD: ``NNDMD`` + +- Sparse construction of Koopman invariant subspace + + - Multi-task learning based on linearity consistency + + +Examples +^^^^^^^^ + +1. `Learning how to create observables `__ + +2. `Learning how to compute time derivatives `__ + +3. `Dynamic mode decomposition on two mixed spatial signals `__ + +4. `Dynamic mode decomposition with control on a 2D linear system `__ + +5. `Dynamic mode decomposition with control (DMDc) for a 128D system `__ + +6. `Dynamic mode decomposition with control on a high-dimensional linear system `__ + +7. `Successful examples of using Dynamic mode decomposition on PDE system `__ + +8. `Unsuccessful examples of using Dynamic mode decomposition on PDE system `__ + +9. `Extended DMD for Van Der Pol System `__ + +10. `Learning Koopman eigenfunctions on Slow manifold `__ + +11. `Comparing DMD and KDMD for Slow manifold dynamics `__ + +12. `Extended DMD with control for chaotic duffing oscillator `__ + +13. `Extended DMD with control for Van der Pol oscillator `__ + +14. `Hankel Alternative View of Koopman Operator for Lorenz System `__ + +15. `Hankel DMD with control for Van der Pol Oscillator `__ + +16. `Neural Network DMD on Slow Manifold `__ + +17. `EDMD and NNDMD for a simple linear system `__ + +18. `Sparisfying a minimal Koopman invariant subspace from EDMD for a simple linear system `__ + +Installation +------------- + +Language +^^^^^^^^^^^^^^^^^^^^ +- Python == 3.10 + + +Installing with pip +^^^^^^^^^^^^^^^^^^^ + +If you are using Linux or macOS you can install PyKoopman with pip: + +.. code-block:: bash + + pip install pykoopman + +Installing from source +^^^^^^^^^^^^^^^^^^^^^^ +First clone this repository: + +.. code-block:: bash + + git clone https://github.com/dynamicslab/pykoopman + +Second, it is highly recommended to use `venv` to get a local python environment + +.. code-block:: bash + + python -m venv venv + source ./venv/bin/activate + +In windows, you activate virtual environment in a different way + +.. code-block:: bash + + .\venv\Scripts\activate.ps1 + +Then, to install the package, run + +.. code-block:: bash + + python -m pip install -e . + +If you do not have root access, you should add the ``--user`` option to the above lines. + + +Installing with GPU support +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +After you download the Github package, go to the directory, type + +.. code-block:: bash + + python -m pip install -r requirements-dev.txt + +Documentation +------------- +The documentation for PyKoopman is hosted on `Read the Docs `__. + +Community guidelines +-------------------- + +Contributing code +^^^^^^^^^^^^^^^^^ +We welcome contributions to PyKoopman. To contribute a new feature please submit a +pull request. To get started we recommend installing the packages in "developer mode" +via + +.. code-block:: bash + + python -m pip install -e .[dev] + +This will allow you to run unit tests and automatically format your code. To be accepted your code should conform to PEP8 and pass all unit tests. Code can be tested by invoking + +.. code-block:: bash + + pytest + +We recommed using ``pre-commit`` to format your code. Once you have staged changes to commit + +.. code-block:: bash + + git add path/to/changed/file.py + +you can run the following to automatically reformat your staged code + +.. code-block:: bash + + pre-commit run -a -v + +Note that you will then need to re-stage any changes ``pre-commit`` made to your code. + +Reporting issues or bugs +^^^^^^^^^^^^^^^^^^^^^^^^ +If you find a bug in the code or want to request a new feature, please open an issue. + +Known issues: + +- Python 3.12 might cause unexpected problems. + +Citing PyKoopman +---------------- + +.. code-block:: text + + @article{Pan2024, doi = {10.21105/joss.05881}, + url = {https://doi.org/10.21105/joss.05881}, + year = {2024}, + publisher = {The Open Journal}, + volume = {9}, + number = {94}, + pages = {5881}, + author = {Shaowu Pan and Eurika Kaiser and Brian M. de Silva and J. Nathan Kutz and Steven L. Brunton}, + title = {PyKoopman: A Python Package for Data-Driven Approximation of the Koopman Operator}, + journal = {Journal of Open Source Software}} + +Related packages +---------------- +* `PySINDy `_ - A Python libray for the Sparse Identification of Nonlinear Dynamical + systems (SINDy) method introduced in Brunton et al. (2016a). +* `Deeptime `_ - A Python library for the analysis of time series data with methods for dimension reduction, clustering, and Markov model estimation. +* `PyDMD `_ - A Python package using the Dynamic Mode Decomposition (DMD) for a data-driven model simplification based on spatiotemporal coherent structures. DMD is a great alternative to SINDy. +* `pykoop `_ - a Koopman operator identification library written in Python +* `DLKoopman `_ - a deep learning library for + Koopman operator + +.. |Build| image:: https://github.com/dynamicslab/pykoopman/actions/workflows/run-tests.yml/badge.svg + :target: https://github.com/dynamicslab/pykoopman/actions?query=workflow%3ATests + +.. |Docs| image:: https://readthedocs.org/projects/pykoopman/badge/?version=master + :target: https://pykoopman.readthedocs.io/en/master/?badge=master + :alt: Documentation Status + +.. |PyPI| image:: https://badge.fury.io/py/pykoopman.svg + :target: https://badge.fury.io/py/pykoopman + +.. |Codecov| image:: https://codecov.io/github/dynamicslab/pykoopman/coverage.svg + :target: https://app.codecov.io/gh/dynamicslab/pykoopman + +.. |DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.8060893.svg + :target: https://doi.org/10.5281/zenodo.8060893 + +.. |JOSS| image:: https://joss.theoj.org/papers/10.21105/joss.05881/status.svg + :target: https://doi.org/10.21105/joss.05881 diff --git a/DSA/pykoopman/src/pykoopman/__init__.py b/DSA/pykoopman/src/pykoopman/__init__.py new file mode 100644 index 0000000..b6e344d --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/__init__.py @@ -0,0 +1,23 @@ +from __future__ import annotations + +from pkg_resources import DistributionNotFound +from pkg_resources import get_distribution + +try: + __version__ = get_distribution(__name__).version +except DistributionNotFound: + pass + +from .koopman import Koopman +from .koopman_continuous import KoopmanContinuous + + +__all__ = [ + "Koopman", + "KoopmanContinuous", + "common", + "differentiation", + "observables", + "regression", + "analytics", +] diff --git a/DSA/pykoopman/src/pykoopman/analytics/__init__.py b/DSA/pykoopman/src/pykoopman/analytics/__init__.py new file mode 100644 index 0000000..73a9c1a --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/analytics/__init__.py @@ -0,0 +1,7 @@ +from __future__ import annotations + +from ._base_analyzer import BaseAnalyzer +from ._ms_pd21 import ModesSelectionPAD21 +from ._pruned_koopman import PrunedKoopman + +__all__ = ["BaseAnalyzer", "ModesSelectionPAD21", "PrunedKoopman"] diff --git a/DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py b/DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py new file mode 100644 index 0000000..9cdb156 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py @@ -0,0 +1,89 @@ +"""module for implement modes analyzer for Koopman approximation""" +from __future__ import annotations + +import abc + +import numpy as np + + +class BaseAnalyzer(object): + """Base class for Koopman model analyzer. + + Attributes: + model (Koopman): An instance of `pykoopman.koopman.Koopman`. + eigenfunction (Koopman.compute_eigenfunction): A function that evaluates Koopman + psi. + eigenvalues_cont (numpy.ndarray): Koopman lamda in continuous-time. + eigenvalues_discrete (numpy.ndarray): Koopman lamda in discrete-time. + """ + + def __init__(self, model): + """Initialize the BaseAnalyzer object. + + Args: + model (Koopman): An instance of `pykoopman.koopman.Koopman`. + """ + self.model = model + self.eigenfunction = self.model.psi + self.eigenvalues_cont = self.model.continuous_lamda_array + self.eigenvalues_discrete = self.model.lamda_array + + def _compute_phi_minus_phi_evolved(self, t, validate_data_one_traj): + """Compute the difference between psi evolved and psi observed. + + Args: + t (numpy.ndarray): Time stamp of this validation trajectory. + validate_data_one_traj (numpy.ndarray): Data matrix of this validation + trajectory. + + Returns: + list: Linear residual for each mode. + """ + + # shape of phi = (num_samples, num_modes) + psi = self.eigenfunction(validate_data_one_traj.T).T + + linear_residual_list = [] + for i in range(len(self.eigenvalues_cont)): + linear_residual_list.append( + psi[:, i] - np.exp(self.eigenvalues_cont[i] * t) * psi[0:1, i] + ) + return linear_residual_list + + def validate(self, t, validate_data_one_traj): + """Validate Koopman psi. + + Given a single trajectory, compute the norm of the difference + between observed psi and evolved psi for each mode. + + Args: + t (numpy.ndarray): Time stamp of this validation trajectory. + validate_data_one_traj (numpy.ndarray): Data matrix of this validation + trajectory. + + Returns: + list: Difference in norm for each mode. + """ + + linear_residual_list = self._compute_phi_minus_phi_evolved( + t, validate_data_one_traj + ) + linear_residual_norm_list = [ + np.linalg.norm(tmp) for tmp in linear_residual_list + ] + return linear_residual_norm_list + + @abc.abstractmethod + def prune_model(self, *params, **kwargs): + """Prune the model. + + This method should be implemented by the derived classes. + + Args: + *params: Variable length argument list. + **kwargs: Arbitrary keyword arguments. + + Raises: + NotImplementedError: If the method is not implemented by the derived class. + """ + raise NotImplementedError diff --git a/DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py b/DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py new file mode 100644 index 0000000..bf789bb --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py @@ -0,0 +1,462 @@ +"""Module for implementing Pan-Duraisamy modes selection algorithm""" +from __future__ import annotations + +import numpy as np +from matplotlib import pyplot as plt +from prettytable import PrettyTable +from pykoopman.koopman import Koopman +from sklearn.linear_model import enet_path + +from ._base_analyzer import BaseAnalyzer +from ._pruned_koopman import PrunedKoopman + + +class ModesSelectionPAD21(BaseAnalyzer): + """Koopman V selection algorithm from Pan, et al.,JFM (2021). + + Aims to extract a low-dimensional Koopman invariant subspace + in a model-agnostic way, i.e., applies to any algorithms for + approximating the Koopman operator. + + See the following reference for more details: + Pan, S., Arnold-Medabalimi, N., & Duraisamy, K. (2021). + Sparsity-promoting algorithms for the discovery of informative + Koopman-invariant subspaces. Journal of Fluid Mechanics, 917. + + + Parameters: + model (Koopman): An instance of `pykoopman.koopman.Koopman`. + validate_data_traj (list): A list of dictionaries that contains validation + trajectories. Each dictionary has two keys: `t` and `x`, which correspond to + time stamps and data matrix. + truncation_threshold (float): When sweeping the `alpha` in the sparse linear + regression solver over the data, we consider any term with an absolute + coefficient smaller than the truncation threshold as zero. Default is 1e-3. + max_terms_allowed (int): The maximum number of terms used to perform sparse + linear regression. It can be inferred by the Q-R plot. Default is 10. + plot (bool): True if the figures should be plotted. Default is False. + + Attributes: + L (int): Total number of terms considered in sparse linear regression. + dir (str): The path where figures are saved. + eigenfunction_on_traj_total_top_k (numpy.ndarray): Evaluations of the best k + eigenfunctions evaluated on all of the validation trajectories. + small_to_large_error_eigen_index (numpy.ndarray): Indices of eigenmodes from + best to worst in terms of linear evolution error. + sweep_index_list (list): A list of a list of bool. It is the final result of + sweeping in the sparse linear regression. It contains which V are + selected at a certain `alpha`. + validate_data_traj (list): A list of dictionaries that contains validation + trajectories. Each dictionary has two keys: `t` and `x`, which correspond + to time stamps and data matrix. + truncation_threshold (float): When sweeping the `alpha` in the sparse linear + regression solver over the data, we consider any term with an absolute + coefficient smaller than the truncation threshold as zero. + """ + + def __init__( + self, + model: Koopman, + validate_data_traj: list, + truncation_threshold=1e-3, + max_terms_allowed=10, + plot=False, + ): + """Initialize the ModesSelectionPAD21 object. + + Args: + model (Koopman): An instance of `pykoopman.koopman.Koopman`. + validate_data_traj (list): A list of dictionaries that contains + validation trajectories. Each dictionary should have the keys 't' + and 'x', corresponding to time stamps and data matrix, respectively. + truncation_threshold (float, optional): When sweeping the alpha in the + sparse linear regression solver over the data, we consider any term + with an absolute coefficient smaller than the truncation threshold as + zero. Defaults to 1e-3. + max_terms_allowed (int, optional): The maximum number of terms used to + perform sparse linear regression. It can be inferred by the Q-R plot. + Defaults to 10. + plot (bool, optional): Set to True to plot the figures. Defaults to False. + """ + + super().__init__(model) + + self.validate_data_traj = validate_data_traj + self.truncation_threshold = truncation_threshold + self.dir = "/" + + if not isinstance(validate_data_traj, list): + raise NotImplementedError("validate_data_traj should be a list.") + + # loop over each validation trajectory + Q_i = [] + for validate_data_one_traj in validate_data_traj: + validate_data = validate_data_one_traj["x"] + validate_time = validate_data_one_traj["t"] + + # 1. residual of linearity equation + linear_residual_list = self._compute_phi_minus_phi_evolved( + validate_time, validate_data + ) + + # 1.1 normalization factor for each psi + eigenfunction_evaluated_on_traj = self.eigenfunction(validate_data.T).T + + tmp = np.abs(eigenfunction_evaluated_on_traj) ** 2 # pointwise square only + dt_arr = np.diff(validate_time, prepend=validate_time[0] - validate_time[1]) + tmp = np.dot(dt_arr, tmp) / (validate_time[-1] - validate_time[0]) + normal_constant = np.sqrt(tmp) + + # 1.2 normalized residual and pick the maximized one over t + tmp = [ + np.max(np.abs(tmp) / normal_constant[i]) + for i, tmp in enumerate(linear_residual_list) + ] + Q_i.append(tmp) + + # compute the mean Q_i for all of the trajectories + Q_i_mean = np.array(Q_i).mean(axis=0) + + # sort Q to get i_1 to i_L + self.small_to_large_error_eigen_index = np.argsort(Q_i_mean)[ + : max_terms_allowed + 1 + ] + + # loop over each validation trajectory - for the second time + R_i = [] + for validate_data_one_traj in validate_data_traj: + validate_data = validate_data_one_traj["x"] + eigenfunction_evaluated_on_traj = self.eigenfunction(validate_data.T).T + + # get reconstruction error with increasing number of V + R_i_each = [] + for k in range(1, max_terms_allowed + 1): + eigenfunction_evaluated_on_traj_top_k = eigenfunction_evaluated_on_traj[ + :, self.small_to_large_error_eigen_index[:k] + ] + sparse_measurement_matrix = np.linalg.lstsq( + eigenfunction_evaluated_on_traj_top_k, validate_data + )[0] + residual = ( + eigenfunction_evaluated_on_traj_top_k @ sparse_measurement_matrix + - validate_data + ) + normalized_err_top_k = np.linalg.norm(residual) / np.linalg.norm( + validate_data + ) + R_i_each.append(normalized_err_top_k) + R_i_each = np.array(R_i_each) + R_i.append(R_i_each) + R_i_mean = np.array(R_i).mean(axis=0) + + # print out the Q-R + QR_table = PrettyTable() + + QR_table.field_names = ["Index", "Eigenvalue", "Q", "R"] + tmp = self.eigenvalues_discrete[self.small_to_large_error_eigen_index] + for i in range(len(R_i_mean)): + QR_table.add_row( + [ + self.small_to_large_error_eigen_index[i], + tmp[i], + Q_i_mean[i], + R_i_mean[i], + ] + ) + print(QR_table) + + # prepare top max k selected eigentraj + eigenfunction_evaluated_on_traj_total = np.vstack( + [self.eigenfunction(tmp1["x"].T).T for tmp1 in validate_data_traj] + ) + self.eigenfunction_on_traj_total_top_k = eigenfunction_evaluated_on_traj_total[ + :, self.small_to_large_error_eigen_index[: max_terms_allowed + 1] + ] + + if plot: + fig = plt.figure(figsize=(6, 6)) + ax1 = fig.add_subplot(111) + ax2 = ax1.twinx() + ax1.plot( + range(1, len(Q_i_mean) + 1), + Q_i_mean[self.small_to_large_error_eigen_index], + "b-^", + label="Max relative psi error", + ) + ax1.set_xlabel("Number of eigenmodes included", fontsize=16) + ax1.set_yscale("log") + ax1.set_ylabel( + "Max linear evolving normalized error", + color="b", + fontsize=16, + ) + ax2.plot( + np.arange(1, len(R_i_mean) + 1), + R_i_mean, + "r-o", + label="Reconstruction normalized error", + ) + ax2.set_ylabel("Reconstruction normalized error", color="r", fontsize=16) + ax2.set_yscale("log") + plt.grid("both") + # annotate the lamda + for i in range(len(Q_i_mean)): + ax1.text( + i, + Q_i_mean[self.small_to_large_error_eigen_index][i], + "{:.2f}".format( + self.eigenvalues_discrete[ + self.small_to_large_error_eigen_index + ][i] + ), + size=10, + rotation=25, + ) + plt.tight_layout() + plt.show() + + def sweep_among_best_L_modes( + self, + L: int, + ALPHA_RANGE=np.logspace(-3, 1, 100), + MAX_ITER=1e5, + save_figure=True, + plot=True, + ): + """Perform sweeping among the best L modes using multi-task elastic net. + + Computes multi-task elastic net over a list of alpha values and saves the + coefficients for each path. + + Parameters: + L (int): The number of eigenmodes considered for sparse linear regression. + ALPHA_RANGE (numpy.ndarray, optional): An array of alpha values on which to + perform sparse linear regression. Defaults to np.logspace(-3, 1, 100). + MAX_ITER (int, optional): Maximum iterations allowed in the coordinate + descent algorithm. Defaults to 1e5. + save_figure (bool, optional): True if the figures should be saved. Defaults + to True. + plot (bool, optional): True if the figures should be plotted. Defaults to + True. + """ + + self.L = L + # options + TOL = 1e-12 + L1_RATIO = 0.99 + + phi_tilde = self.eigenfunction_on_traj_total_top_k[:, :L] + X = np.vstack([tmp["x"] for tmp in self.validate_data_traj]) + num_alpha = len(ALPHA_RANGE) + + # 1. normalize the features by making modal amplitude to 1 for all features + phi_tilde_scaled = phi_tilde / np.abs(phi_tilde[0, :]) + assert phi_tilde_scaled.shape == phi_tilde.shape + + # 2. augment the complex AX=B problem into an AX=B problem with real entries + # since the current package only supports real number arrays + + a = np.hstack([np.real(phi_tilde_scaled), -np.imag(phi_tilde_scaled)]) + b = np.hstack([np.imag(phi_tilde_scaled), np.real(phi_tilde_scaled)]) + phi_tilde_aug = np.vstack([a, b]) + X_aug = np.vstack([X, np.zeros(X.shape)]) + num_data = X.shape[0] + alphas_enet, coefs_enet_aug, _ = enet_path( + phi_tilde_aug, + X_aug, + l1_ratio=L1_RATIO, + tol=TOL, + max_iter=MAX_ITER, + alphas=ALPHA_RANGE, + check_input=True, + verbose=0, + ) + num_total_eigen_func = int(coefs_enet_aug.shape[1] / 2) + + # get the real and imaginary parts from the complex solution + coefs_enet_real = coefs_enet_aug[:, :num_total_eigen_func, :] + coefs_enet_imag = coefs_enet_aug[:, num_total_eigen_func:, :] + assert coefs_enet_imag.shape == coefs_enet_real.shape + + # combine them into a complex array for final results + coefs_enet_comp = coefs_enet_real + 1j * coefs_enet_imag + + # 2.5 remove features that are smaller than 'self.truncation_threshold' + # of the max, because most often + for i_alpha in range(coefs_enet_comp.shape[2]): + for i_target in range(coefs_enet_comp.shape[0]): + coef_cutoff_value = self.truncation_threshold * np.max( + abs(coefs_enet_comp[i_target, :, i_alpha]) + ) + index_remove = ( + abs(coefs_enet_comp[i_target, :, i_alpha]) < coef_cutoff_value + ) + coefs_enet_comp[i_target, index_remove, i_alpha] = 0 + 0j + + # 2.7 given the selected features, do LS-refit to remove the bias of any kind + # of regularization + for i_alpha in range(coefs_enet_comp.shape[2]): + bool_non_zero = np.linalg.norm(coefs_enet_comp[:, :, i_alpha], axis=0) > 0 + phi_tilde_scaled_reduced = phi_tilde_scaled[:, bool_non_zero] + coef_enet_comp_reduced_i_alpha = np.linalg.lstsq( + phi_tilde_scaled_reduced, X + )[0] + coefs_enet_comp[ + :, bool_non_zero, i_alpha + ] = coef_enet_comp_reduced_i_alpha.T + coefs_enet_comp[:, np.invert(bool_non_zero), i_alpha] = 0 + + # 3. compute residual for parameter sweep to draw the trade-off + coefs_enet = np.abs(coefs_enet_comp) + residual_array = [] + for i in range(num_alpha): + residual = np.linalg.norm( + X + - np.matmul(phi_tilde_scaled, coefs_enet_comp[:, :, i].T)[:num_data] + # computed the augmented but only compare the first half rows + ) + residual /= np.linalg.norm(X) + residual_array.append(residual) + residual_array = np.array(residual_array) + + # compute the number of non-zeros + num_non_zero_all_alpha = [] + num_target_components = coefs_enet_comp.shape[0] + for ii in range(coefs_enet_comp.shape[2]): + non_zero_index_per_alpha = [] + for i_component in range(num_target_components): + non_zero_index_per_alpha_per_target = abs( + coefs_enet_comp[i_component, :, ii] + ) > 0 * np.max(abs(coefs_enet_comp[i_component, :, ii])) + non_zero_index_per_alpha.append(non_zero_index_per_alpha_per_target) + non_zero_index_per_alpha_all_targets = np.logical_or.reduce( + non_zero_index_per_alpha + ) + num_non_zero_all_alpha.append(np.sum(non_zero_index_per_alpha_all_targets)) + num_non_zero_all_alpha = np.array(num_non_zero_all_alpha) + + # print a table for non-zero alpha + sparse_error_table = PrettyTable() + sparse_error_table.field_names = [ + "Index", + "Alpha", + "# Non-zero", + "Reconstruction Error", + ] + for i in range(len(ALPHA_RANGE)): + sparse_error_table.add_row( + [ + i, + ALPHA_RANGE[i], + num_non_zero_all_alpha[i], + residual_array[i], + ] + ) + print(sparse_error_table) + + # plot figures + num_target_components = coefs_enet_comp.shape[0] + alphas_enet_log_negative = -np.log10(alphas_enet) + top_k_modes_list = np.arange(L) + + # figure set 1 -- sparsity of Koopman mode in reconstructing each target + if plot: + for i_component in range(num_target_components): + plt.figure(figsize=(6, 6)) + for i in top_k_modes_list: + i_s = self.small_to_large_error_eigen_index[i] + plt.plot( + alphas_enet_log_negative, + abs(coefs_enet[i_component, i, :]), + "-*", + label=r"$\lambda_{}$ = {:.2f}".format( + i_s, self.eigenvalues_discrete[i_s] + ), + ) + max_val = np.max(abs(coefs_enet[i_component, :, -1])) + min_val = np.min(abs(coefs_enet[i_component, :, -1])) + diss = (max_val - min_val) / 2 + mean = (max_val + min_val) / 2 + plt.xlabel(r"-$\log_{10}(\alpha)$", fontsize=16) + plt.ylabel( + "Absolute Value of Coefficients", + fontsize=16, + ) + plt.ylim([mean - diss * 3, mean + diss * 3]) + plt.title(r"$x_{}$".format(i_component + 1)) + plt.legend(loc="best") + if save_figure: + plt.savefig( + self.dir + + "multi-elastic-net-coef-" + + str(i_component + 1) + + ".png", + bbox_inches="tight", + ) + plt.close() + else: + plt.tight_layout() + plt.show() + + # figure set 2 -- reconstruction MSE vs alpha + fig = plt.figure(figsize=(6, 6)) + ax1 = fig.add_subplot(111) + ax2 = ax1.twinx() + ax1.plot(alphas_enet_log_negative, residual_array, "k*-") + ax1.set_xlabel(r"-$\log_{10}(\alpha)$", fontsize=16) + ax1.set_ylabel( + "Normalized Reconstruction MSE", + color="k", + fontsize=16, + ) + + ax2.plot(alphas_enet_log_negative, num_non_zero_all_alpha, "r*-") + ax2.set_ylabel( + "Number of Selected Koopman V", + color="r", + fontsize=16, + ) + + if save_figure: + plt.savefig( + self.dir + "/multi-elastic-net-mse.png", bbox_inches="tight" + ) + plt.close() + else: + plt.tight_layout() + plt.show() + + # 4. find the selected index within the top L best eigenmodes for each alpha + sweep_index_list = [] + for ii, alpha in enumerate(alphas_enet): + non_zero_index_bool_array = ( + np.linalg.norm(coefs_enet_comp[:, :, ii], axis=0) > 0 + ) + sweep_index_list.append(non_zero_index_bool_array) + self.sweep_index_list = sweep_index_list + + def prune_model(self, i_alpha, x_train, dt=1): + """Prune the `pykoopman.koopman.Koopman` model. + + Returns a pruned model that contains most of the functionality of + the original model. + + Parameters: + i_alpha (int): The chosen index from the result of sparse linear regression + to prune the model. + x_train (numpy.ndarray): The training data, but only the `x`. Used to refit + the Koopman V since the Koopman eigenmodes are sparsified. + dt (float, optional): Time step used in the original model. Defaults to 1. + + Returns: + pruned_model (PrunedKoopman): The pruned model with fewer Koopman V, but + similar accuracy. + """ + sweep_bool_index = self.sweep_index_list[i_alpha] + sweep_index = self.small_to_large_error_eigen_index[: self.L][sweep_bool_index] + + pruned_model = PrunedKoopman(self.model, sweep_index, dt) + pruned_model = pruned_model.fit(x_train) + return pruned_model diff --git a/DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py b/DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py new file mode 100644 index 0000000..d795bf4 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py @@ -0,0 +1,162 @@ +"""Module for pruning Koopman models.""" +from __future__ import annotations + +import numpy as np +from pykoopman.koopman import Koopman +from sklearn.utils.validation import check_is_fitted + + +class PrunedKoopman: + """Prune the given original Koopman `model` at `sweep_index`. + + Parameters: + model (Koopman): An instance of `pykoopman.koopman.Koopman`. + sweep_index (np.ndarray): Selected indices in the original Koopman model. + dt (float): Time step used in the original model. + + Attributes: + sweep_index (np.ndarray): Selected indices in the original Koopman model. + lamda_ (np.ndarray): Diagonal matrix that contains the selected eigenvalues. + original_model (Koopman): An instance of `pykoopman.koopman.Koopman`. + W_ (np.ndarray): Matrix that maps selected Koopman eigenfunctions back to the + system state. + + Methods: + fit(x): Fit the pruned model to the training data `x`. + predict(x): Predict the system state at the next time stamp given `x`. + psi(x_col): Evaluate the selected eigenfunctions at a given state `x`. + phi(x_col): **Not implemented**. + ur: **Not implemented**. + A: **Not implemented**. + B: **Not implemented**. + C: Property. Returns `NotImplementedError`. + W: Property. Returns the matrix that maps the selected Koopman eigenfunctions + back to the system state. + lamda: Property. Returns the diagonal matrix of selected eigenvalues. + lamda_array: Property. Returns the selected eigenvalues as a 1D array. + continuous_lamda_array: Property. Returns the selected eigenvalues in + continuous-time as a 1D array. + """ + + def __init__(self, model: Koopman, sweep_index: np.ndarray, dt): + # construct lambda + self.sweep_index = sweep_index + # self.lamda_ = np.diag(np.diag(model.lamda)[self.sweep_index]) + self.original_model = model + self.time = {"dt": dt} + + # no support for controllable for now + if self.original_model.n_control_features_ > 0: + raise NotImplementedError + + self.A_ = None + + def fit(self, x): + """Fit the pruned model given data matrix `x` + + Parameters + ---------- + x : numpy.ndarray + Training data for refitting the Koopman V + + Returns + ------- + self : PrunedKoopman + """ + + # pruned V + selected_eigenphi = self.psi(x.T).T + result = np.linalg.lstsq(selected_eigenphi, x) + # print('refit residual = {}'.format(result[1])) + self.W_ = result[0].T + + # lamda, W = np.linalg.eig(self.original_model.A) + + self.lamda_ = np.diag(np.diag(self.original_model.lamda)[self.sweep_index]) + 0j + # evecs = self.original_model._regressor_eigenvectors + + return self + + def predict(self, x): + """Predict system state at the next time stamp given `x` + + Parameters + ---------- + x : numpy.ndarray + System state `x` in row-wise + + Returns + ------- + xnext : numpy.ndarray + System state at the next time stamp + """ + + if x.ndim == 1: + x = x.reshape(1, -1) + gnext = self.lamda @ self.psi(x.T) + # xnext = self.compute_state_from_psi(gnext) + xnext = self.W @ gnext + return np.real(xnext.T) + + def psi(self, x_col): + """Evaluate the selected psi at given state `x` + + Parameters + ---------- + x : numpy.ndarray + System state `x` in column-wise + + Returns + ------- + eigenphi : numpy.ndarray + Selected eigenfunctions' value at given state `x` + """ + + # eigenphi_ori = self.original_model.psi(x_col).T + # eigenphi_selected = eigenphi_ori[:, self.sweep_index] + + eigenphi_ori = self.original_model.psi(x_col) + eigenphi_selected = eigenphi_ori[self.sweep_index] + return eigenphi_selected + + def phi(self, x_col): + # return self.original_model._regressor_eigenvectors @ self.psi(x_col) + raise NotImplementedError("Pruned model does not have `phi` but only `psi`") + + @property + def ur(self): + raise NotImplementedError("Pruned model does not have `ur`") + + @property + def A(self): + raise NotImplementedError( + "Pruning only happen in eigen-space. So no self.A " "but only self.lamda" + ) + + @property + def B(self): + raise NotImplementedError( + "Pruning only for autonomous system rather than " "controlled system" + ) + + @property + def C(self): + return NotImplementedError("Pruning model does not have `C`") + + @property + def W(self): + check_is_fitted(self, "W_") + return self.W_ + + @property + def lamda(self): + return self.lamda_ + + @property + def lamda_array(self): + return np.diag(self.lamda) + 0j + + @property + def continuous_lamda_array(self): + check_is_fitted(self, "_pipeline") + return np.log(self.lamda_array) / self.time["dt"] diff --git a/DSA/pykoopman/src/pykoopman/common/__init__.py b/DSA/pykoopman/src/pykoopman/common/__init__.py new file mode 100644 index 0000000..4badea5 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/__init__.py @@ -0,0 +1,37 @@ +from __future__ import annotations + +from .cqgle import cqgle +from .examples import advance_linear_system +from .examples import drss +from .examples import Linear2Ddynamics +from .examples import lorenz +from .examples import rev_dvdp +from .examples import rk4 +from .examples import slow_manifold +from .examples import torus_dynamics +from .examples import vdp_osc +from .ks import ks +from .nlse import nlse +from .validation import check_array +from .validation import drop_nan_rows +from .validation import validate_input +from .vbe import vbe + +__all__ = [ + "check_array", + "drop_nan_rows", + "validate_input", + "drss", + "advance_linear_system", + "torus_dynamics", + "lorenz", + "vdp_osc", + "rk4", + "rev_dvdp", + "Linear2Ddynamics", + "slow_manifold", + "nlse", + "vbe", + "cqgle", + "ks", +] diff --git a/DSA/pykoopman/src/pykoopman/common/cqgle.py b/DSA/pykoopman/src/pykoopman/common/cqgle.py new file mode 100644 index 0000000..f91e230 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/cqgle.py @@ -0,0 +1,234 @@ +"""Module for cubic-quintic Ginzburg-Landau equation.""" +from __future__ import annotations + +import numpy as np +from matplotlib import pyplot as plt +from mpl_toolkits.mplot3d import Axes3D +from pykoopman.common.examples import rk4 +from scipy.fft import fft +from scipy.fft import fftfreq +from scipy.fft import ifft + + +class cqgle: + """ + Cubic-quintic Ginzburg-Landau equation solver. + + Solves the equation: + i*u_t + (0.5 - i * tau) u_{xx} - i * kappa u_{xxxx} + (1-i * beta)|u|^2 u + + (nu - i * sigma)|u|^4 u - i * gamma u = 0 + + Solves the periodic boundary conditions PDE using spectral methods. + + Attributes: + n_states (int): Number of states. + x (numpy.ndarray): x-coordinates. + dt (float): Time step. + tau (float): Parameter tau. + kappa (float): Parameter kappa. + beta (float): Parameter beta. + nu (float): Parameter nu. + sigma (float): Parameter sigma. + gamma (float): Parameter gamma. + k (numpy.ndarray): Wave numbers. + dk (float): Wave number spacing. + + Methods: + sys(t, x, u): System dynamics function. + simulate(x0, n_int, n_sample): Simulate the system for a given initial + condition. + collect_data_continuous(x0): Collect training data pairs in continuous sense. + collect_one_step_data_discrete(x0): Collect training data pairs in discrete + sense. + collect_one_trajectory_data(x0, n_int, n_sample): Collect data for one + trajectory. + visualize_data(x, t, X): Visualize the data in physical space. + visualize_state_space(X): Visualize the data in state space. + """ + + def __init__( + self, + n, + x, + dt, + tau=0.08, + kappa=0, + beta=0.66, + nu=-0.1, + sigma=-0.1, + gamma=-0.1, + L=2 * np.pi, + ): + self.n_states = n + self.x = x + + self.tau = tau + self.kappa = kappa + self.beta = beta + self.nu = nu + self.sigma = sigma + self.gamma = gamma + + dk = 2 * np.pi / L + self.k = fftfreq(self.n_states, 1.0 / self.n_states) * dk + self.dt = dt + + def sys(self, t, x, u): + xk = fft(x) + + # 1/3 truncation rule + xk[self.n_states // 6 : 5 * self.n_states // 6] = 0j + x = ifft(xk) + + tmp_1_k = (0.5 - 1j * self.tau) * (-self.k**2) * xk + tmp_2_k = -1j * self.kappa * self.k**4 * xk + tmp_3_k = fft( + (1 - 1j * self.beta) * abs(x) ** 2 * x + + (self.nu - 1j * self.sigma) * abs(x) ** 4 * x + ) + tmp_4_k = -1j * self.gamma * xk + + # return back to physical space + y = ifft(1j * (tmp_1_k + tmp_2_k + tmp_3_k + tmp_4_k)) + return y + + def simulate(self, x0, n_int, n_sample): + # n_traj = x0.shape[1] + x = x0 + u = np.zeros((n_int, 1), dtype=complex) + X = np.zeros((n_int // n_sample, self.n_states), dtype=complex) + t = 0 + j = 0 + t_list = [] + for step in range(n_int): + t += self.dt + y = rk4(0, x, u[step], self.dt, self.sys) + if (step + 1) % n_sample == 0: + X[j] = y + j += 1 + t_list.append(t) + x = y + return X, np.array(t_list) + + def collect_data_continuous(self, x0): + """ + collect training data pairs - continuous sense. + + given x0, with shape (n_dim, n_traj), the function + returns dx/dt with shape (n_dim, n_traj) + """ + + n_traj = x0.shape[0] + u = np.zeros((n_traj, 1)) + X = x0 + Y = [] + for i in range(n_traj): + y = self.sys(0, x0[i], u[i]) + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_step_data_discrete(self, x0): + """ + collect training data pairs - discrete sense. + + given x0, with shape (n_dim, n_traj), the function + returns system state x1 after self.dt with shape + (n_dim, n_traj) + """ + + n_traj = x0.shape[0] + X = x0 + Y = [] + for i in range(n_traj): + y, _ = self.simulate(x0[i], n_int=1, n_sample=1) + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_trajectory_data(self, x0, n_int, n_sample): + x = x0 + y, _ = self.simulate(x, n_int, n_sample) + return y + + def visualize_data(self, x, t, X): + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + for i in range(X.shape[0]): + ax.plot(x, abs(X[i]), zs=t[i], zdir="t", label="time = " + str(i * self.dt)) + # plt.legend(loc='best') + ax.view_init(elev=35.0, azim=-65, vertical_axis="y") + ax.set(ylabel=r"$mag. of. u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") + plt.title("CQGLE (Kutz et al., Complexity, 2018)") + plt.show() + + def visualize_state_space(self, X): + u, s, vt = np.linalg.svd(X, full_matrices=False) + # this is a pde problem so the number of snapshots are smaller than dof + pca_1_r, pca_1_i = np.real(u[:, 0]), np.imag(u[:, 0]) + pca_2_r, pca_2_i = np.real(u[:, 1]), np.imag(u[:, 1]) + pca_3_r, pca_3_i = np.real(u[:, 2]), np.imag(u[:, 2]) + + plt.figure(figsize=(6, 6)) + plt.semilogy(s) + plt.xlabel("number of SVD terms") + plt.ylabel("singular values") + plt.title("PCA singular value decays") + plt.show() + + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + ax.plot3D(pca_1_r, pca_2_r, pca_3_r, "k-o") + ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") + plt.title("PCA visualization (real)") + plt.show() + + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + ax.plot3D(pca_1_i, pca_2_i, pca_3_i, "k-o") + ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") + plt.title("PCA visualization (imag)") + plt.show() + + +if __name__ == "__main__": + n = 512 + x = np.linspace(-10, 10, n, endpoint=False) + u0 = np.exp(-((x) ** 2)) + # u0 = 2.0 / np.cosh(x) + # u0 = u0.reshape(-1,1) + n_int = 9000 + n_snapshot = 300 + dt = 40.0 / n_int + n_sample = n_int // n_snapshot + + model = cqgle(n, x, dt, L=20) + X, t = model.simulate(u0, n_int, n_sample) + + print(X.shape) + print(X[:, -1].max()) + + # usage: visualize the data in physical space + model.visualize_data(x, t, X) + print(t) + + # usage: visualize the data in state space + model.visualize_state_space(X) + + # usage: collect continuous data pair: x and dx/dt + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_data_continuous(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect discrete data pair + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_one_step_data_discrete(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect one trajectory data + X = model.collect_one_trajectory_data(u0, n_int, n_sample) + print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/common/examples.py b/DSA/pykoopman/src/pykoopman/common/examples.py new file mode 100644 index 0000000..ae2ff22 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/examples.py @@ -0,0 +1,1045 @@ +"""module for example dynamics data""" +from __future__ import annotations + +import matplotlib as mpl +import matplotlib.pyplot as plt +import numpy as np +from scipy.linalg import orth + + +def drss( + n=2, p=2, m=2, p_int_first=0.1, p_int_others=0.01, p_repeat=0.05, p_complex=0.5 +): + """ + Create a discrete-time, random, stable, linear state space model. + + Args: + n (int, optional): Number of states. Default is 2. + p (int, optional): Number of control inputs. Default is 2. + m (int, optional): Number of output measurements. + If m=0, C becomes the identity matrix, so that y=x. Default is 2. + p_int_first (float, optional): Probability of an integrator as the first pole. + Default is 0.1. + p_int_others (float, optional): Probability of other integrators beyond the + first. Default is 0.01. + p_repeat (float, optional): Probability of repeated roots. Default is 0.05. + p_complex (float, optional): Probability of complex roots. Default is 0.5. + + Returns: + Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]: A tuple containing the + state transition matrix (A), control matrix (B), and measurement matrix (C). + + A (numpy.ndarray): State transition matrix of shape (n, n). + B (numpy.ndarray): Control matrix of shape (n, p). + C (numpy.ndarray): Measurement matrix of shape (m, n). If m = 0, C is the + identity matrix. + + """ + + # Number of integrators + nint = int( + (np.random.rand(1) < p_int_first) + sum(np.random.rand(n - 1) < p_int_others) + ) + # Number of repeated roots + nrepeated = int(np.floor(sum(np.random.rand(n - nint) < p_repeat) / 2)) + # Number of complex roots + ncomplex = int( + np.floor(sum(np.random.rand(n - nint - 2 * nrepeated, 1) < p_complex) / 2) + ) + nreal = n - nint - 2 * nrepeated - 2 * ncomplex + + # Random poles + rep = 2 * np.random.rand(nrepeated) - 1 + if ncomplex != 0: + mag = np.random.rand(ncomplex) + cplx = np.zeros(ncomplex, dtype=complex) + for i in range(ncomplex): + cplx[i] = mag[i] * np.exp(complex(0, np.pi * np.random.rand(1))) + re = np.real(cplx) + im = np.imag(cplx) + + # Generate random state space model + A = np.zeros((n, n)) + if ncomplex != 0: + for i in range(0, ncomplex): + A[2 * i : 2 * i + 2, 2 * i : 2 * i + 2] = np.array( + [[re[i], im[i]], [-im[i], re[i]]] + ) + + if 2 * ncomplex < n: + list_poles = [] + if nint: + list_poles = np.append(list_poles, np.ones(nint)) + if rep: + list_poles = np.append(list_poles, rep) + list_poles = np.append(list_poles, rep) + if nreal: + list_poles = np.append(list_poles, 2 * np.random.rand(nreal) - 1) + + A[2 * ncomplex :, 2 * ncomplex :] = np.diag(list_poles) + + T = orth(np.random.rand(n, n)) + A = np.transpose(T) @ (A @ T) + + # control matrix + B = np.random.randn(n, p) + # mask for nonzero entries in B + mask = np.random.rand(B.shape[0], B.shape[1]) + B = np.squeeze(np.multiply(B, [(mask < 0.75) != 0])) + + # Measurement matrix + if m == 0: + C = np.identity(n) + else: + C = np.random.randn(m, n) + mask = np.random.rand(C.shape[0], C.shape[1]) + C = np.squeeze(C * [(mask < 0.75) != 0]) + + return A, B, C + + +def advance_linear_system(x0, u, n, A=None, B=None, C=None): + """ + Simulate the linear system dynamics for a given number of steps. + + Args: + x0 (numpy.ndarray): Initial state vector of shape (n,). + u (numpy.ndarray): Control input array of shape (p,) or (p, n-1). + If 1-dimensional, it will be converted to a row vector. + n (int): Number of steps to simulate. + A (numpy.ndarray, optional): State transition matrix of shape (n, n). + If not provided, it defaults to None. + B (numpy.ndarray, optional): Control matrix of shape (n, p). + If not provided, it defaults to None. + C (numpy.ndarray, optional): Measurement matrix of shape (m, n). + If not provided, it defaults to None. + + Returns: + Tuple[numpy.ndarray, numpy.ndarray]: A tuple containing the state trajectory + (x) and the output trajectory (y). + + x (numpy.ndarray): State trajectory of shape (n, len(x0)). + y (numpy.ndarray): Output trajectory of shape (n, C.shape[0]). + + """ + if C is None: + C = np.identity(len(x0)) + if u.ndim == 1: + u = u[np.newaxis, :] + + y = np.zeros([n, C.shape[0]]) + x = np.zeros([n, len(x0)]) + x[0, :] = x0 + y[0, :] = C.dot(x[0, :]) + for i in range(n - 1): + x[i + 1, :] = A.dot(x[i, :]) + B.dot(u[:, i]) + y[i + 1, :] = C.dot(x[i + 1, :]) + return x, y + + +def vdp_osc(t, x, u): + """ + Compute the dynamics of the Van der Pol oscillator. + + Args: + t (float): Time. + x (numpy.ndarray): State vector of shape (2,). + u (float): Control input. + + Returns: + numpy.ndarray: Updated state vector of shape (2,). + + """ + y = np.zeros(x.shape) + y[0, :] = 2 * x[1, :] + y[1, :] = -0.8 * x[0, :] + 2 * x[1, :] - 10 * (x[0, :] ** 2) * x[1, :] + u + return y + + +def rk4(t, x, u, _dt=0.01, func=vdp_osc): + """ + Perform a 4th order Runge-Kutta integration. + + Args: + t (float): Time. + x (numpy.ndarray): State vector of shape (2,). + u (float): Control input. + _dt (float, optional): Time step. Defaults to 0.01. + func (function, optional): Function defining the dynamics. Defaults to vdp_osc. + + Returns: + numpy.ndarray: Updated state vector of shape (2,). + + """ + # 4th order Runge-Kutta + k1 = func(t, x, u) + k2 = func(t, x + k1 * _dt / 2, u) + k3 = func(t, x + k2 * _dt / 2, u) + k4 = func(t, x + k1 * _dt, u) + return x + (_dt / 6) * (k1 + 2 * k2 + 2 * k3 + k4) + + +def square_wave(step): + """ + Generate a square wave with a period of 60 time steps. + + Args: + step (int): Current time step. + + Returns: + float: Square wave value at the given time step. + + """ + return (-1.0) ** (round(step / 30.0)) + + +def sine_wave(step): + """ + Generate a sine wave with a period of 60 time steps. + + Args: + step (int): Current time step. + + Returns: + float: Sine wave value at the given time step. + + """ + return np.sin(round(step / 30.0)) + + +def lorenz(x, t, sigma=10, beta=8 / 3, rho=28): + """ + Compute the derivative of the Lorenz system at a given state. + + Args: + x (list): Current state of the Lorenz system [x, y, z]. + t (float): Current time. + sigma (float, optional): Parameter sigma. Default is 10. + beta (float, optional): Parameter beta. Default is 8/3. + rho (float, optional): Parameter rho. Default is 28. + + Returns: + list: Derivative of the Lorenz system [dx/dt, dy/dt, dz/dt]. + + """ + return [ + sigma * (x[1] - x[0]), + x[0] * (rho - x[2]) - x[1], + x[0] * x[1] - beta * x[2], + ] + + +def rev_dvdp(t, x, u=0, dt=0.1): + """ + Reverse dynamics of the Van der Pol oscillator. + + Args: + t (float): Time. + x (numpy.ndarray): Current state of the system [x1, x2]. + u (float, optional): Input. Default is 0. + dt (float, optional): Time step. Default is 0.1. + + Returns: + numpy.ndarray: Updated state of the system [x1', x2']. + + """ + return np.array( + [ + x[0, :] - x[1, :] * dt, + x[1, :] + (x[0, :] - x[1, :] + x[0, :] ** 2 * x[1, :]) * dt, + ] + ) + + +class Linear2Ddynamics: + def __init__(self): + """ + Initializes a Linear2Ddynamics object. + + """ + self.n_states = 2 # Number of states + + def linear_map(self, x): + """ + Applies the linear mapping to the input state. + + Args: + x (numpy.ndarray): Input state. + + Returns: + numpy.ndarray: Resulting mapped state. + + """ + return np.array([[0.8, -0.05], [0, 0.7]]) @ x + + def collect_data(self, x, n_int, n_traj): + """ + Collects data by integrating the linear dynamics. + + Args: + x (numpy.ndarray): Initial state. + n_int (int): Number of integration steps. + n_traj (int): Number of trajectories. + + Returns: + numpy.ndarray: Input data. + numpy.ndarray: Output data. + + """ + # Init + X = np.zeros((self.n_states, n_int * n_traj)) + Y = np.zeros((self.n_states, n_int * n_traj)) + + # Integrate + for step in range(n_int): + y = self.linear_map(x) + X[:, (step) * n_traj : (step + 1) * n_traj] = x + Y[:, (step) * n_traj : (step + 1) * n_traj] = y + x = y + + return X, Y + + def visualize_modes(self, x, phi, eigvals, order=None): + """ + Visualizes the modes of the linear dynamics. + + Args: + x (numpy.ndarray): State data. + phi (numpy.ndarray): Eigenvectors. + eigvals (numpy.ndarray): Eigenvalues. + order (list, optional): Order of the modes to visualize. Default is None. + + """ + n_modes = min(10, phi.shape[1]) + fig, axs = plt.subplots(2, n_modes, figsize=(3 * n_modes, 6)) + if order is None: + index_list = range(n_modes) + else: + index_list = order + j = 0 + for i in index_list: + axs[0, j].scatter( + x[0, :], + x[1, :], + c=np.real(phi[:, i]), + marker="o", + cmap=plt.get_cmap("jet"), + ) + axs[1, j].scatter( + x[0, :], + x[1, :], + c=np.imag(phi[:, i]), + marker="o", + cmap=plt.get_cmap("jet"), + ) + axs[0, j].set_title(r"$\lambda$=" + "{:2.3f}".format(eigvals[i])) + j += 1 + + +class torus_dynamics: + """ + Sparse dynamics in Fourier space on torus. + + Attributes: + n_states (int): Number of states. + sparsity (int): Degree of sparsity. + freq_max (int): Maximum frequency. + noisemag (float): Magnitude of noise. + + Methods: + __init__(self, n_states=128, sparsity=5, freq_max=15, noisemag=0.0): + Initializes a torus_dynamics object. + + setup(self): + Sets up the dynamics. + + advance(self, n_samples, dt=1): + Advances the continuous-time dynamics without control. + + advance_discrete_time(self, n_samples, dt, u=None): + Advances the discrete-time dynamics with or without control. + + set_control_matrix_physical(self, B): + Sets the control matrix in physical space. + + set_control_matrix_fourier(self, Bhat): + Sets the control matrix in Fourier space. + + set_point_actuator(self, position=None): + Sets a single point actuator. + + viz_setup(self): + Sets up the visualization. + + viz_torus(self, ax, x): + Visualizes the torus dynamics. + + viz_all_modes(self, modes=None): + Visualizes all modes. + + modes(self): + Returns the modes of the dynamics. + + B_effective(self): + Returns the effective control matrix. + + """ + + def __init__(self, n_states=128, sparsity=5, freq_max=15, noisemag=0.0): + """ + Initializes a torus_dynamics object. + + Args: + n_states (int, optional): Number of states. Default is 128. + sparsity (int, optional): Degree of sparsity. Default is 5. + freq_max (int, optional): Maximum frequency. Default is 15. + noisemag (float, optional): Magnitude of noise. Default is 0.0. + + """ + self.n_states = n_states + self.sparsity = sparsity + self.freq_max = freq_max + self.noisemag = noisemag + self.setup() + + def setup(self): + """ + Sets up the dynamics. + + """ + # Initialization in the Fourier space + xhat = np.zeros((self.n_states, self.n_states), complex) + # Index of nonzero frequency components + self.J = np.zeros((self.sparsity, 2), dtype=int) + IC = np.zeros(self.sparsity) # Initial condition, real number + frequencies = np.zeros(self.sparsity) + damping = np.zeros(self.sparsity) + + IC = np.random.randn(self.sparsity) + frequencies = np.sqrt(4 * np.random.rand(self.sparsity)) + damping = -np.random.rand(self.sparsity) * 0.1 + for k in range(self.sparsity): + loopbreak = 0 + while loopbreak != 1: + self.J[k, 0] = np.ceil( + np.random.rand(1) * self.n_states / (self.freq_max + 1) + ) + self.J[k, 1] = np.ceil( + np.random.rand(1) * self.n_states / (self.freq_max + 1) + ) + if xhat[self.J[k, 0], self.J[k, 1]] == 0.0: + loopbreak = 1 + + xhat[self.J[k, 0], self.J[k, 1]] = IC[k] + + mask = np.zeros((self.n_states, self.n_states), int) + for k in range(self.sparsity): + mask[self.J[k, 0], self.J[k, 1]] = 1 + + self.damping = damping + self.frequencies = frequencies + self.IC = IC + self.xhat = xhat + self.mask = mask + + def advance(self, n_samples, dt=1): + """ + Advances the continuous-time dynamics without control. + + Args: + n_samples (int): Number of samples to advance. + dt (float, optional): Time step. Default is 1. + + """ + print("Evolving continuous-time dynamics without control.") + self.n_samples = n_samples + self.dt = dt + + # Initilization + # In physical space + self.X = np.ndarray((self.n_states**2, self.n_samples)) + # In Fourier space + self.Xhat = np.ndarray((self.n_states**2, self.n_samples), complex) + self.time_vector = np.zeros(self.n_samples) + + # if self.noisemag != 0: + # self.XhatClean = np.ndarray((self.n_states**2, self.n_samples), complex) + # self.XClean = np.ndarray((self.n_states**2, self.n_samples)) + + for step in range(self.n_samples): + t = step * self.dt + self.time_vector[step] = t + xhat = np.zeros((self.n_states, self.n_states), complex) + for k in range(self.sparsity): + xhat[self.J[k, 0], self.J[k, 1]] = ( + np.exp((self.damping[k] + 1j * 2 * np.pi * self.frequencies[k]) * t) + * self.IC[k] + ) + + if self.noisemag != 0: + self.XhatClean[:, step] = xhat.reshape(self.n_states**2) + xClean = np.real(np.fft.ifft2(xhat)) + self.XClean[:, step] = xClean.reshape(self.n_states**2) + + # xRMS = np.sqrt(np.mean(xhat.reshape((self.n_states**2,1))**2)) + # xhat = xhat + self.noisemag*xRMS\ + # *np.random.randn(xhat.shape[0],xhat.shape[1]) \ + # + 1j*self.noisemag*xRMS \ + # *np.random.randn(xhat.shape[0],xhat.shape[1]) + self.Xhat[:, step] = xhat.reshape(self.n_states**2) + x = np.real(np.fft.ifft2(xhat)) + self.X[:, step] = x.reshape(self.n_states**2) + + def advance_discrete_time(self, n_samples, dt, u=None): + """ + Advances the discrete-time dynamics with or without control. + + Args: + n_samples (int): Number of samples to advance. + dt (float): Time step. + u (array-like, optional): Control input. Default is None. + + """ + print("Evolving discrete-time dynamics with or without control.") + if u is None: + self.n_control_features_ = 0 + self.U = np.zeros(n_samples) + self.U = self.U[np.newaxis, :] + print("No control input provided. Evolving unforced system.") + else: + if u.ndim == 1: + if len(u) > n_samples: + u = u[:-1] + self.U = u[np.newaxis, :] + elif u.ndim == 2: + if u.shape[0] > n_samples: + u = u[:-1, :] + self.U = u + self.n_control_features_ = self.U.shape[1] + + if not hasattr(self, "B"): + B = np.zeros((self.n_states, self.n_states)) + print(B.shape) + self.set_control_matrix_physical(B) + print("Control matrix is not set. Continue with unforced system.") + + self.n_samples = n_samples + self.dt = dt + + # Initilization + # In physical space + self.X = np.ndarray((self.n_states**2, self.n_samples)) + # In Fourier space + self.Xhat = np.ndarray((self.n_states**2, self.n_samples), complex) + self.time_vector = np.zeros(self.n_samples) + + # Set initial condition + xhat0 = np.zeros((self.n_states, self.n_states), complex) + for k in range(self.sparsity): + xhat0[self.J[k, 0], self.J[k, 1]] = self.IC[k] + self.Xhat[:, 0] = xhat0.reshape(self.n_states**2) + x0 = np.real(np.fft.ifft2(xhat0)) + self.X[:, 0] = x0.reshape(self.n_states**2) + + for step in range(1, self.n_samples, 1): + t = step * self.dt + self.time_vector[step] = t + # self.Xhat[:, step] = np.reshape(self.Bhat * self.U[0,step - 1],\ + # self.n_states ** 2) + # xhat = self.Xhat[:,step].reshape(self.n_states,self.n_states) + # xhat_prev = \ + # self.Xhat[:, step - 1].reshape(self.n_states, self.n_states) + + # forced torus dynamics linearly evolve in the spectral space, sparsely + xhat = np.array((self.n_states, self.n_states), complex) + xhat = self.Xhat[:, step].reshape(self.n_states, self.n_states) + xhat_prev = self.Xhat[:, step - 1].reshape(self.n_states, self.n_states) + for k in range(self.sparsity): + xhat[self.J[k, 0], self.J[k, 1]] = ( + np.exp( + (self.damping[k] + 1j * 2 * np.pi * self.frequencies[k]) + * self.dt + ) + * xhat_prev[self.J[k, 0], self.J[k, 1]] + + self.Bhat[self.J[k, 0], self.J[k, 1]] * self.U[0, step - 1] + ) + + # xhat_prev = self.Xhat[:,step-1].reshape(self.n_states, self.n_states) + # for k in range(self.sparsity): + # xhat[self.J[k,0], self.J[k,1]] += np.exp((self.damping[k] \ + # + 1j * 2 * np.pi * self.frequencies[k]) * self.dt) \ + # * xhat_prev[self.J[k,0], self.J[k,1]] + + self.Xhat[:, step] = xhat.reshape(self.n_states**2) + x = np.real(np.fft.ifft2(xhat)) + self.X[:, step] = x.reshape(self.n_states**2) + + def set_control_matrix_physical(self, B): + """ + Sets the control matrix in physical space. + + Args: + B (array-like): Control matrix in physical space. + + """ + if np.allclose(B.shape, np.array([self.n_states, self.n_states])) is False: + raise TypeError("Control matrix B has wrong shape.") + self.B = B + self.Bhat = np.fft.fft2(B) + + def set_control_matrix_fourier(self, Bhat): + """ + Sets the control matrix in Fourier space. + + Args: + Bhat (array-like): Control matrix in Fourier space. + + """ + if np.allclose(Bhat.shape, np.array([self.n_states, self.n_states])) is False: + raise TypeError("Control matrix Bhat has wrong shape.") + self.Bhat = Bhat + self.B = np.real(np.fft.ifft2(self.Bhat)) + + def set_point_actuator(self, position=None): + """ + Sets a single point actuator. + + Args: + position (array-like, optional): Position of the actuator. Default is None. + + """ + if position is None: + position = np.random.randint(0, self.n_states, 2) + try: + for i in range(len(position)): + position[i] = int(position[i]) + except ValueError: + print("position was not a valid integer.") + + is_position_in_valid_domain = (position >= 0) & (position < self.n_states) + if all(is_position_in_valid_domain) is False: + raise ValueError( + "Actuator position was not a valid integer inside of domain." + ) + + # Control matrix in physical space (single point actuator) + B = np.zeros((self.n_states, self.n_states)) + B[position[0], position[1]] = 1 + self.set_control_matrix_physical(B) + + def viz_setup(self): + """ + Sets up the visualization. + + """ + self.cmap_torus = plt.cm.jet # bwr #plt.cm.RdYlBu + self.n_colors = self.n_states + r1 = 2 + r2 = 1 + [T1, T2] = np.meshgrid( + np.linspace(0, 2 * np.pi, self.n_states), + np.linspace(0, 2 * np.pi, self.n_states), + ) + R = r1 + r2 * np.cos(T2) + self.Zgrid = r2 * np.sin(T2) + self.Xgrid = R * np.cos(T1) + self.Ygrid = R * np.sin(T1) + + def viz_torus(self, ax, x): + """ + Visualizes the torus dynamics. + + Args: + ax: Axes object for plotting. + x (array-like): Dynamics to be visualized. + + Returns: + surface: Surface plot of the torus dynamics. + + """ + if not hasattr(self, "viz"): + self.viz_setup() + + norm = mpl.colors.Normalize(vmin=-abs(x).max(), vmax=abs(x).max()) + surface = ax.plot_surface( + self.Xgrid, + self.Ygrid, + self.Zgrid, + facecolors=self.cmap_torus(norm(x)), + shade=False, + rstride=1, + cstride=1, + ) + # m = cm.ScalarMappable(cmap=cmap_torus, norm=norm) + # m.set_array([]) + # plt.colorbar(m) + # ax.figure.colorbar(surf, ax=ax) + ax.set_zlim(-3.01, 3.01) + return surface + + def viz_all_modes(self, modes=None): + """ + Visualizes all modes. + + Args: + modes (array-like, optional): Modes to be visualized. Default is None. + + Returns: + fig: Figure object containing the visualizations. + + """ + if modes is None: + modes = self.modes + + if not hasattr(self, "viz"): + self.viz_setup() + + fig = plt.figure(figsize=(20, 10)) + for k in range(self.sparsity): + ax = plt.subplot2grid((1, self.sparsity), (0, k), projection="3d") + self.viz_torus(ax, modes[:, k].reshape(self.n_states, self.n_states)) + plt.axis("off") + return fig + + @property + def modes(self): + """ + Returns the modes of the dynamics. + + Returns: + modes (array-like): Modes of the dynamics. + + """ + modes = np.zeros((self.n_states**2, self.sparsity)) + + for k in range(self.sparsity): + mode_in_fourier = np.zeros((self.n_states, self.n_states)) + mode_in_fourier[self.J[k, 0], self.J[k, 1]] = 1 + modes[:, k] = np.real( + np.fft.ifft2(mode_in_fourier).reshape(self.n_states**2) + ) + + return modes + + @property + def B_effective(self): + """ + Returns the effective control matrix. + + Returns: + B_effective (array-like): Effective control matrix. + + """ + Bhat_effective = np.zeros((self.n_states, self.n_states), complex) + for k in range(self.sparsity): + control_mode = np.zeros((self.n_states, self.n_states), complex) + control_mode[self.J[k, 0], self.J[k, 1]] = self.Bhat[ + self.J[k, 0], self.J[k, 1] + ] + Bhat_effective += control_mode + B_effective = np.fft.ifft2(Bhat_effective) + + return B_effective + + +class slow_manifold: + """ + Represents the slow manifold class. + + Args: + mu (float, optional): Parameter mu. Default is -0.05. + la (float, optional): Parameter la. Default is -1.0. + dt (float, optional): Time step size. Default is 0.01. + + Attributes: + mu (float): Parameter mu. + la (float): Parameter la. + b (float): Value computed from mu and la. + dt (float): Time step size. + n_states (int): Number of states. + + Methods: + sys(t, x, u): Computes the system dynamics. + output(x): Computes the output based on the state. + simulate(x0, n_int): Simulates the system dynamics. + collect_data_continuous(x0): Collects data from continuous-time dynamics. + collect_data_discrete(x0, n_int): Collects data from discrete-time dynamics. + visualize_trajectories(t, X, n_traj): Visualizes the trajectories. + visualize_state_space(X, Y, n_traj): Visualizes the state space. + """ + + def __init__(self, mu=-0.05, la=-1.0, dt=0.01): + self.mu = mu + self.la = la + self.b = self.la / (self.la - 2 * self.mu) + self.dt = dt + self.n_states = 2 + + def sys(self, t, x, u): + """ + Computes the system dynamics. + + Args: + t (float): Time. + x (array-like): State. + u (array-like): Control input. + + Returns: + array-like: Computed system dynamics. + + """ + return np.array([self.mu * x[0, :], self.la * (x[1, :] - x[0, :] ** 2)]) + + def output(self, x): + """ + Computes the output based on the state. + + Args: + x (array-like): State. + + Returns: + array-like: Computed output. + + """ + return x[0, :] ** 2 + x[1, :] + + def simulate(self, x0, n_int): + """ + Simulates the system dynamics. + + Args: + x0 (array-like): Initial state. + n_int (int): Number of integration steps. + + Returns: + array-like: Simulated trajectory. + + """ + n_traj = x0.shape[1] + x = x0 + u = np.zeros((n_int, 1)) + X = np.zeros((self.n_states, n_int * n_traj)) + for step in range(n_int): + y = rk4(0, x, u[step, :], self.dt, self.sys) + X[:, (step) * n_traj : (step + 1) * n_traj] = y + x = y + return X + + def collect_data_continuous(self, x0): + """ + Collects data from continuous-time dynamics. + + Args: + x0 (array-like): Initial state. + + Returns: + tuple: Collected data (X, Y). + + """ + n_traj = x0.shape[1] + u = np.zeros((1, n_traj)) + X = x0 + Y = self.sys(0, x0, u) + return X, Y + + def collect_data_discrete(self, x0, n_int): + """ + Collects data from discrete-time dynamics. + + Args: + x0 (array-like): Initial state. + n_int (int): Number of integration steps. + + Returns: + tuple: Collected data (X, Y). + + """ + n_traj = x0.shape[1] + x = x0 + u = np.zeros((n_int, n_traj)) + X = np.zeros((self.n_states, n_int * n_traj)) + Y = np.zeros((self.n_states, n_int * n_traj)) + for step in range(n_int): + y = rk4(0, x, u[step, :], self.dt, self.sys) + X[:, (step) * n_traj : (step + 1) * n_traj] = x + Y[:, (step) * n_traj : (step + 1) * n_traj] = y + x = y + return X, Y + + def visualize_trajectories(self, t, X, n_traj): + """ + Visualizes the trajectories. + + Args: + t (array-like): Time vector. + X (array-like): State trajectories. + n_traj (int): Number of trajectories. + + """ + fig, axs = plt.subplots(1, 1, tight_layout=True, figsize=(12, 4)) + for traj_idx in range(n_traj): + x = X[:, traj_idx::n_traj] + axs.plot(t[0:100], x[1, 0:100], "k") + axs.set(ylabel=r"$x_2$", xlabel=r"$t$") + + def visualize_state_space(self, X, Y, n_traj): + """ + Visualizes the state space. + + Args: + X (array-like): State trajectories. + Y (array-like): Output trajectories. + n_traj (int): Number of trajectories. + + """ + fig, axs = plt.subplots(1, 1, tight_layout=True, figsize=(4, 4)) + for traj_idx in range(n_traj): + axs.plot( + [X[0, traj_idx::n_traj], Y[0, traj_idx::n_traj]], + [X[1, traj_idx::n_traj], Y[1, traj_idx::n_traj]], + "-k", + ) + axs.set(ylabel=r"$x_2$", xlabel=r"$x_1$") + + +class forced_duffing: + """ + Forced Duffing Oscillator. + + dx1/dt = x2 + dx2/dt = -d*x2-alpha*x1-beta*x1^3 + u + + [1] S. Peitz, S. E. Otto, and C. W. Rowley, + “Data-driven model predictive control using interpolated koopman generators,” + SIAM J. Appl. Dyn. Syst., vol. 19, no. 3, pp. 2162–2193, Mar. 2020. + """ + + def __init__(self, dt, d, alpha, beta): + """ + Initializes the Forced Duffing Oscillator. + + Args: + dt (float): Time step. + d (float): Damping coefficient. + alpha (float): Coefficient of x1. + beta (float): Coefficient of x1^3. + """ + self.dt = dt + self.d = d + self.alpha = alpha + self.beta = beta + self.n_states = 2 + + def sys(self, t, x, u): + """ + Defines the system dynamics of the Forced Duffing Oscillator. + + Args: + t (float): Time. + x (array-like): State vector. + u (array-like): Control input. + + Returns: + array-like: Rate of change of the state vector. + """ + y = np.array( + [ + x[1, :], + -self.d * x[1, :] - self.alpha * x[0, :] - self.beta * x[0, :] ** 3 + u, + ] + ) + return y + + def simulate(self, x0, n_int, u): + """ + Simulates the Forced Duffing Oscillator. + + Args: + x0 (array-like): Initial state vector. + n_int (int): Number of time steps. + u (array-like): Control inputs. + + Returns: + array-like: State trajectories. + """ + n_traj = x0.shape[1] + x = x0 + X = np.zeros((self.n_states, n_int * n_traj)) + for step in range(n_int): + y = rk4(0, x, u[step, :], self.dt, self.sys) + X[:, (step) * n_traj : (step + 1) * n_traj] = y + x = y + return X + + def collect_data_continuous(self, x0, u): + """ + Collects continuous data for the Forced Duffing Oscillator. + + Args: + x0 (array-like): Initial state vector. + u (array-like): Control inputs. + + Returns: + tuple: State and output trajectories. + """ + X = x0 + Y = self.sys(0, x0, u) + return X, Y + + def collect_data_discrete(self, x0, n_int, u): + """ + Collects discrete-time data for the Forced Duffing Oscillator. + + Args: + x0 (array-like): Initial state vector. + n_int (int): Number of time steps. + u (array-like): Control inputs. + + Returns: + tuple: State and output trajectories. + """ + n_traj = x0.shape[1] + x = x0 + X = np.zeros((self.n_states, n_int * n_traj)) + Y = np.zeros((self.n_states, n_int * n_traj)) + for step in range(n_int): + y = rk4(0, x, u[step, :], self.dt, self.sys) + X[:, (step) * n_traj : (step + 1) * n_traj] = x + Y[:, (step) * n_traj : (step + 1) * n_traj] = y + x = y + return X, Y + + def visualize_trajectories(self, t, X, n_traj): + """ + Visualizes the state trajectories of the Forced Duffing Oscillator. + + Args: + t (array-like): Time vector. + X (array-like): State trajectories. + n_traj (int): Number of trajectories to visualize. + """ + fig, axs = plt.subplots(1, 2, tight_layout=True, figsize=(12, 4)) + for traj_idx in range(n_traj): + x = X[:, traj_idx::n_traj] + axs[0].plot(t, x[0, :], "k") + axs[1].plot(t, x[1, :], "b") + axs[0].set(ylabel=r"$x_1$", xlabel=r"$t$") + axs[1].set(ylabel=r"$x_2$", xlabel=r"$t$") + + def visualize_state_space(self, X, Y, n_traj): + """ + Visualizes the state space trajectories of the Forced Duffing Oscillator. + + Args: + X (array-like): State trajectories. + Y (array-like): Output trajectories. + n_traj (int): Number of trajectories to visualize. + """ + fig, axs = plt.subplots(1, 1, tight_layout=True, figsize=(4, 4)) + for traj_idx in range(n_traj): + axs.plot( + [X[0, traj_idx::n_traj], Y[0, traj_idx::n_traj]], + [X[1, traj_idx::n_traj], Y[1, traj_idx::n_traj]], + "-k", + ) + axs.set(ylabel=r"$x_2$", xlabel=r"$x_1$") diff --git a/DSA/pykoopman/src/pykoopman/common/ks.py b/DSA/pykoopman/src/pykoopman/common/ks.py new file mode 100644 index 0000000..e356bdf --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/ks.py @@ -0,0 +1,189 @@ +"""module for 1D KS equation""" +from __future__ import annotations + +import numpy as np +from matplotlib import pyplot as plt +from mpl_toolkits.mplot3d import Axes3D +from scipy.fft import fft +from scipy.fft import fftfreq +from scipy.fft import ifft + + +class ks: + """ + Solving 1D KS equation + + u_t = -u*u_x + u_{xx} + nu*u_{xxxx} + + Periodic B.C. between 0 and 2*pi. This PDE is solved + using spectral methods. + """ + + def __init__(self, n, x, nu, dt, M=16): + self.n_states = n + self.dt = dt + self.x = x + dk = 1 + k = fftfreq(self.n_states, 1.0 / self.n_states) * dk + k[n // 2] = 0.0 + L = k**2 - nu * k**4 + self.E = np.exp(self.dt * L) + self.E2 = np.exp(self.dt * L / 2.0) + # self.M = M + r = np.exp(1j * np.pi * (np.arange(1, M + 1) - 0.5) / M) + r = r.reshape(1, -1) + r_on_circle = np.repeat(r, n, axis=0) + LR = self.dt * L + LR = LR.reshape(-1, 1) + LR = LR.astype("complex") + LR = np.repeat(LR, M, axis=1) + LR += r_on_circle + self.g = -0.5j * k + + self.Q = self.dt * np.real(np.mean((np.exp(LR / 2.0) - 1) / LR, axis=1)) + self.f1 = self.dt * np.real( + np.mean( + (-4.0 - LR + np.exp(LR) * (4.0 - 3.0 * LR + LR**2)) / LR**3, axis=1 + ) + ) + self.f2 = self.dt * np.real( + np.mean((2.0 + LR + np.exp(LR) * (-2.0 + LR)) / LR**3, axis=1) + ) + self.f3 = self.dt * np.real( + np.mean( + (-4.0 - 3.0 * LR - LR**2 + np.exp(LR) * (4.0 - LR)) / LR**3, axis=1 + ) + ) + + @staticmethod + def compute_u2k_zeropad_dealiased(uk_): + # three over two law + N = uk_.size + # map uk to uk_fine + uk_fine = ( + np.hstack((uk_[0 : int(N / 2)], np.zeros((int(N / 2))), uk_[int(-N / 2) :])) + * 3.0 + / 2.0 + ) + # convert uk_fine to physical space + u_fine = np.real(ifft(uk_fine)) + # compute square + u2_fine = np.square(u_fine) + # compute fft on u2_fine + u2k_fine = fft(u2_fine) + # convert u2k_fine to u2k + u2k = np.hstack((u2k_fine[0 : int(N / 2)], u2k_fine[int(-N / 2) :])) / 3.0 * 2.0 + return u2k + + def sys(self, t, x, u): + raise NotImplementedError + + def simulate(self, x0, n_int, n_sample): + xk = fft(x0) + u = np.zeros((n_int, 1)) + X = np.zeros((n_int // n_sample, self.n_states)) + t = 0 + j = 0 + t_list = [] + for step in range(n_int): + t += self.dt + Nv = self.g * self.compute_u2k_zeropad_dealiased(xk) + a = self.E2 * xk + self.Q * Nv + Na = self.g * self.compute_u2k_zeropad_dealiased(a) + b = self.E2 * xk + self.Q * Na + Nb = self.g * self.compute_u2k_zeropad_dealiased(b) + c = self.E2 * a + self.Q * (2.0 * Nb - Nv) + Nc = self.g * self.compute_u2k_zeropad_dealiased(c) + xk = self.E * xk + Nv * self.f1 + 2.0 * (Na + Nb) * self.f2 + Nc * self.f3 + + if (step + 1) % n_sample == 0: + y = np.real(ifft(xk)) + self.dt * u[j] + X[j, :] = y + j += 1 + t_list.append(t) + xk = fft(y) + + return X, np.array(t_list) + + def collect_data_continuous(self, x0): + raise NotImplementedError + + def collect_one_step_data_discrete(self, x0): + """ + collect training data pairs - discrete sense. + + given x0, with shape (n_dim, n_traj), the function + returns system state x1 after self.dt with shape + (n_dim, n_traj) + """ + n_traj = x0.shape[0] + X = x0 + Y = [] + for i in range(n_traj): + y, _ = self.simulate(x0[i], n_int=1, n_sample=1) + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_trajectory_data(self, x0, n_int, n_sample): + x = x0 + y, _ = self.simulate(x, n_int, n_sample) + return y + + def visualize_data(self, x, t, X): + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + for i in range(X.shape[0]): + ax.plot(x, X[i], zs=t[i], zdir="t", label="time = " + str(i * self.dt)) + ax.view_init(elev=35.0, azim=-65, vertical_axis="y") + ax.set(ylabel=r"$u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") + plt.title("1D K-S equation") + plt.show() + + def visualize_state_space(self, X): + u, s, vt = np.linalg.svd(X, full_matrices=False) + plt.figure(figsize=(6, 6)) + plt.semilogy(s) + plt.xlabel("number of SVD terms") + plt.ylabel("singular values") + plt.title("PCA singular value decays") + plt.show() + + # this is a pde problem so the number of snapshots are smaller than dof + pca_1, pca_2, pca_3 = u[:, 0], u[:, 1], u[:, 2] + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + ax.plot3D(pca_1, pca_2, pca_3, "k-o") + ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") + plt.title("PCA visualization") + plt.show() + + +if __name__ == "__main__": + n = 256 + x = np.linspace(0, 2.0 * np.pi, n, endpoint=False) + u0 = np.sin(x) + nu = 0.01 + n_int = 1000 + n_snapshot = 500 + dt = 4.0 / n_int + n_sample = n_int // n_snapshot + + model = ks(n, x, nu=nu, dt=dt) + X, t = model.simulate(u0, n_int, n_sample) + print(X.shape) + model.visualize_data(x, t, X) + + # usage: visualize the data in state space + model.visualize_state_space(X) + + # usage: collect discrete data pair + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_one_step_data_discrete(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect one trajectory data + X = model.collect_one_trajectory_data(u0, n_int, n_sample) + print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/common/nlse.py b/DSA/pykoopman/src/pykoopman/common/nlse.py new file mode 100644 index 0000000..b82585f --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/nlse.py @@ -0,0 +1,186 @@ +"""module for nonlinear schrodinger equation""" +from __future__ import annotations + +import numpy as np +from matplotlib import pyplot as plt +from mpl_toolkits.mplot3d import Axes3D +from pykoopman.common.examples import rk4 +from scipy.fft import fft +from scipy.fft import fftfreq +from scipy.fft import ifft + + +class nlse: + """ + nonlinear schrodinger equation + + iu_t + 0.5u_xx + u*|u|^2 = 0 + + periodic B.C. PDE is solved with Spectral methods using FFT + """ + + def __init__(self, n, dt, L=2 * np.pi): + self.n_states = n + # assert self.u0.size == self.n_states, 'check the size of initial + # condition and mesh size n' + + dk = 2 * np.pi / L + self.k = fftfreq(self.n_states, 1.0 / self.n_states) * dk + self.dt = dt + + def sys(self, t, x, u): + """the RHS for the governing equation using FFT""" + xk = fft(x) + + # 4/3 truncation rule + # dealiasing due to triple nonlinearity + # note: you could do zero-padding to improve memory + # efficiency + xk[self.n_states // 4 : 3 * self.n_states // 4] = 0j + x = ifft(xk) + + yk = (-self.k**2 * xk.ravel() / 2) * 1j + y = ifft(yk) + 1j * abs(x) ** 2 * x + u + return y + + def simulate(self, x0, n_int, n_sample): + # n_traj = x0.shape[1] + x = x0 + u = np.zeros((n_int, 1), dtype=complex) + X = np.zeros((n_int // n_sample, self.n_states), dtype=complex) + t = 0 + j = 0 + t_list = [] + for step in range(n_int): + t += self.dt + y = rk4(0, x, u[step], self.dt, self.sys) + if (step + 1) % n_sample == 0: + X[j] = y + j += 1 + t_list.append(t) + x = y + return X, np.array(t_list) + + def collect_data_continuous(self, x0): + """ + collect training data pairs - continuous sense. + + given x0, with shape (n_dim, n_traj), the function + returns dx/dt with shape (n_dim, n_traj) + """ + + n_traj = x0.shape[0] + u = np.zeros((n_traj, 1)) + X = x0 + Y = [] + for i in range(n_traj): + y = self.sys(0, x0[i], u[i]) + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_step_data_discrete(self, x0): + """ + collect training data pairs - discrete sense. + + given x0, with shape (n_dim, n_traj), the function + returns system state x1 after self.dt with shape + (n_dim, n_traj) + """ + + n_traj = x0.shape[0] + X = x0 + Y = [] + for i in range(n_traj): + y, _ = self.simulate(x0[i], n_int=1, n_sample=1) + # for j in range(int(delta_t // self.dt)): + # y = rk4(0, x, u[:, i], self.dt, self.sys) + # x = y + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_trajectory_data(self, x0, n_int, n_sample): + x = x0 + y, _ = self.simulate(x, n_int, n_sample) + return y + + def visualize_data(self, x, t, X): + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + for i in range(X.shape[0]): + ax.plot(x, abs(X[i]), zs=t[i], zdir="t", label="time = " + str(i * self.dt)) + # plt.legend(loc='best') + ax.view_init(elev=35.0, azim=-65, vertical_axis="y") + ax.set(ylabel=r"$mag. of u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") + plt.title("Nonlinear schrodinger equation (Kutz et al., Complexity, 2018)") + plt.show() + + def visualize_state_space(self, X): + u, s, vt = np.linalg.svd(X, full_matrices=False) + # this is a pde problem so the number of snapshots are smaller than dof + pca_1_r, pca_1_i = np.real(u[:, 0]), np.imag(u[:, 0]) + pca_2_r, pca_2_i = np.real(u[:, 1]), np.imag(u[:, 1]) + pca_3_r, pca_3_i = np.real(u[:, 2]), np.imag(u[:, 2]) + + plt.figure(figsize=(6, 6)) + plt.semilogy(s) + plt.xlabel("number of SVD terms") + plt.ylabel("singular values") + plt.title("PCA singular value decays") + plt.show() + + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + ax.plot3D(pca_1_r, pca_2_r, pca_3_r, "k-o") + ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") + plt.title("PCA visualization (real)") + plt.show() + + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + ax.plot3D(pca_1_i, pca_2_i, pca_3_i, "k-o") + ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") + plt.title("PCA visualization (imag)") + plt.show() + + +if __name__ == "__main__": + n = 512 + x = np.linspace(-15, 15, n, endpoint=False) + u0 = 2.0 / np.cosh(x) + # u0 = u0.reshape(-1,1) + n_int = 10000 + n_snapshot = 80 # in the original paper, it is 20, but I think too small + dt = np.pi / n_int + n_sample = n_int // n_snapshot + + model = nlse(n, dt=dt, L=30) + X, t = model.simulate(u0, n_int, n_sample) + + # usage: visualize the data in physical space + model.visualize_data(x, t, X) + + # usage: visualize the data in state space + model.visualize_state_space(X) + + print(X.shape) + print(t[1] - t[0]) + + # usage: collect continuous data pair: x and dx/dt + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_data_continuous(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect discrete data pair + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_one_step_data_discrete(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect one trajectory data + X = model.collect_one_trajectory_data(u0, n_int, n_sample) + print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/common/validation.py b/DSA/pykoopman/src/pykoopman/common/validation.py new file mode 100644 index 0000000..69ef91f --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/validation.py @@ -0,0 +1,88 @@ +from __future__ import annotations + +import numpy as np +from sklearn.utils import check_array as skl_check_array + +T_DEFAULT = object() + + +def validate_input(x, t=T_DEFAULT): + if not isinstance(x, np.ndarray) and not isinstance(x, list): + raise ValueError("x must be array-like OR a list of array-like") + elif isinstance(x, list): + for i in range(len(x)): + x[i] = validate_input(x[i], t) + return x + elif x.ndim == 1: + x = x.reshape(-1, 1) + x = check_array(x) + + # add another case if x is a list of trajectory + + if t is not T_DEFAULT: + if t is None: + raise ValueError("t must be a scalar or array-like.") + # Apply this check if t is a scalar + elif np.ndim(t) == 0 and (isinstance(t, int) or isinstance(t, float)): + if t <= 0: + raise ValueError("t must be positive") + # Only apply these tests if t is array-like + elif isinstance(t, np.ndarray): + if not len(t) == x.shape[0]: + raise ValueError("Length of t should match x.shape[0].") + if not np.all(t[:-1] < t[1:]): + raise ValueError("Values in t should be in strictly increasing order.") + else: + raise ValueError("t must be a scalar or array-like.") + + return x + + +def check_array(x, **kwargs): + if np.iscomplexobj(x): + if x.ndim == 3: + # Handle 3D arrays by processing each 2D slice + result = np.zeros_like(x) + for i in range(x.shape[0]): + result[i] = skl_check_array(x[i].real, **kwargs) + 1j * skl_check_array( + x[i].imag, **kwargs + ) + return result + else: + return skl_check_array(x.real, **kwargs) + 1j * skl_check_array( + x.imag, **kwargs + ) + else: + if x.ndim == 3: + # Handle 3D arrays by processing each 2D slice + result = np.zeros_like(x) + for i in range(x.shape[0]): + result[i] = skl_check_array(x[i], **kwargs) + return result + else: + return skl_check_array(x, **kwargs) + + +def drop_nan_rows(arr, *args): + """ + Remove rows in all inputs for which `arr` has `_np.nan` entries. + + Parameters + ---------- + arr : numpy.ndarray + Array whose rows are checked for nan entries. + Any rows containing nans are removed from ``arr`` and all arguments + passed via ``args``. + *args : variable length argument list of numpy.ndarray + Additional arrays from which to remove rows. + Each argument should have the same number of rows as ``arr``. + + Returns + ------- + arrays : tuple of numpy.ndarray + Arrays with nan rows dropped. + The first entry corresponds to ``arr`` and all following entries + to ``*args``. + """ + nan_inds = np.isnan(arr).any(axis=1) + return (arr[~nan_inds], *[arg[~nan_inds] for arg in args]) diff --git a/DSA/pykoopman/src/pykoopman/common/vbe.py b/DSA/pykoopman/src/pykoopman/common/vbe.py new file mode 100644 index 0000000..2a3cec2 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/common/vbe.py @@ -0,0 +1,177 @@ +"""module for 1D viscous burgers""" +from __future__ import annotations + +import numpy as np +from matplotlib import pyplot as plt +from mpl_toolkits.mplot3d import Axes3D +from pykoopman.common.examples import rk4 +from scipy.fft import fft +from scipy.fft import fftfreq +from scipy.fft import ifft + + +class vbe: + """ + 1D viscous Burgers equation + + u_t = -u*u_x + \nu u_{xx} + + periodic B.C. PDE is solved using spectral methods + """ + + def __init__(self, n, x, dt, nu=0.1, L=2 * np.pi): + self.n_states = n + self.x = x + self.nu = nu + dk = 2 * np.pi / L + self.k = fftfreq(self.n_states, 1.0 / self.n_states) * dk + self.dt = dt + + def sys(self, t, x, u): + xk = fft(x) + + # 3/2 truncation rule + xk[self.n_states // 3 : 2 * self.n_states // 3] = 0j + x = ifft(xk) + + # nonlinear advection + tmp_nl_k = fft(-0.5 * x * x) + tmp_nl_x_k = 1j * self.k * tmp_nl_k + + # linear viscous term + tmp_vis_k = -self.nu * self.k**2 * xk + + # return back to physical space + y = np.real(ifft(tmp_nl_x_k + tmp_vis_k)) + return y + + def simulate(self, x0, n_int, n_sample): + # n_traj = x0.shape[1] + x = x0 + u = np.zeros((n_int, 1)) + X = np.zeros((n_int // n_sample, self.n_states)) + t = 0 + j = 0 + t_list = [] + for step in range(n_int): + t += self.dt + y = rk4(0, x, u[step, :], self.dt, self.sys) + if (step + 1) % n_sample == 0: + X[j, :] = y + j += 1 + t_list.append(t) + x = y + return X, np.array(t_list) + + def collect_data_continuous(self, x0): + """ + collect training data pairs - continuous sense. + + given x0, with shape (n_dim, n_traj), the function + returns dx/dt with shape (n_dim, n_traj) + """ + + n_traj = x0.shape[0] + u = np.zeros((n_traj, 1)) + X = x0 + Y = [] + for i in range(n_traj): + y = self.sys(0, x0[i], u[i]) + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_step_data_discrete(self, x0): + """ + collect training data pairs - discrete sense. + + given x0, with shape (n_dim, n_traj), the function + returns system state x1 after self.dt with shape + (n_dim, n_traj) + """ + + n_traj = x0.shape[0] + X = x0 + Y = [] + for i in range(n_traj): + y, _ = self.simulate(x0[i], n_int=1, n_sample=1) + Y.append(y) + Y = np.vstack(Y) + return X, Y + + def collect_one_trajectory_data(self, x0, n_int, n_sample): + x = x0 + y, _ = self.simulate(x, n_int, n_sample) + return y + + def visualize_data(self, x, t, X): + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + for i in range(X.shape[0]): + ax.plot(x, X[i], zs=t[i], zdir="t", label="time = " + str(i * self.dt)) + # plt.legend(loc='best') + ax.view_init(elev=35.0, azim=-65, vertical_axis="y") + ax.set(ylabel=r"$u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") + plt.title("1D Viscous Burgers equation (Kutz et al., Complexity, 2018)") + plt.show() + + def visualize_state_space(self, X): + u, s, vt = np.linalg.svd(X, full_matrices=False) + plt.figure(figsize=(6, 6)) + plt.semilogy(s) + plt.xlabel("number of SVD terms") + plt.ylabel("singular values") + plt.title("PCA singular value decays") + plt.show() + + # this is a pde problem so the number of snapshots are smaller than dof + pca_1, pca_2, pca_3 = u[:, 0], u[:, 1], u[:, 2] + plt.figure(figsize=(6, 6)) + ax = plt.axes(projection=Axes3D.name) + ax.plot3D(pca_1, pca_2, pca_3, "k-o") + ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") + plt.title("PCA visualization") + plt.show() + + +if __name__ == "__main__": + n = 256 + x = np.linspace(-15, 15, n, endpoint=False) + u0 = np.exp(-((x + 2) ** 2)) + # u0 = 2.0 / np.cosh(x) + # u0 = u0.reshape(-1,1) + n_int = 3000 + n_snapshot = 30 + dt = 30.0 / n_int + n_sample = n_int // n_snapshot + + model = vbe(n, x, dt=dt, L=30) + X, t = model.simulate(u0, n_int, n_sample) + + print(X.shape) + # print(X[:,-1].max()) + + # usage: visualize the data in physical space + model.visualize_data(x, t, X) + print(t) + + # usage: visualize the data in state space + model.visualize_state_space(X) + + # usage: collect continuous data pair: x and dx/dt + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_data_continuous(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect discrete data pair + x0_array = np.vstack([u0, u0, u0]) + X, Y = model.collect_one_step_data_discrete(x0_array) + + print(X.shape) + print(Y.shape) + + # usage: collect one trajectory data + X = model.collect_one_trajectory_data(u0, n_int, n_sample) + print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/differentiation/__init__.py b/DSA/pykoopman/src/pykoopman/differentiation/__init__.py new file mode 100644 index 0000000..285c279 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/differentiation/__init__.py @@ -0,0 +1,6 @@ +from __future__ import annotations + +from ._derivative import Derivative +from ._finite_difference import FiniteDifference + +__all__ = ["Derivative", "FiniteDifference"] diff --git a/DSA/pykoopman/src/pykoopman/differentiation/_derivative.py b/DSA/pykoopman/src/pykoopman/differentiation/_derivative.py new file mode 100644 index 0000000..52c94dc --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/differentiation/_derivative.py @@ -0,0 +1,89 @@ +"""Wrapper classes for differentiation methods from the :doc:`derivative:index` package. + +Some default values used here may differ from those used in :doc:`derivative:index`. +""" +from __future__ import annotations + +from derivative import dxdt +from numpy import arange +from sklearn.base import BaseEstimator + +from ..common import validate_input + + +class Derivative(BaseEstimator): + """ + Wrapper class for differentiation classes from the :doc:`derivative:index` package. + This class is meant to provide all the same functionality as the + `dxdt `_ method. + + This class includes a :meth:`__call__` method. + + Parameters + ---------- + derivative_kws: dictionary, optional + Keyword arguments to be passed to the + `dxdt `_ + method. + + Notes + ----- + See the `derivative documentation `_ + for acceptable keywords. + """ + + def __init__(self, **kwargs): + self.kwargs = kwargs + + def set_params(self, **params): + """ + Set the parameters of this estimator. + + Returns + ------- + self + """ + if not params: + # Simple optimization to gain speed (inspect is slow) + return self + else: + self.kwargs.update(params) + + return self + + def get_params(self, deep=True): + """Get parameters.""" + params = super().get_params(deep) + + if isinstance(self.kwargs, dict): + params.update(self.kwargs) + + return params + + def __call__(self, x, t, axis=0): + """ + Perform numerical differentiation by calling the ``dxdt`` method. + + Paramters + --------- + x: np.ndarray, shape (n_samples, n_features) + Data to be differentiated. Rows should correspond to different + points in time and columns to different features. + + t: np.ndarray, shape (n_samples, ) + Time points for each sample (row) in ``x``. + + Returns + ------- + x_dot: np.ndarray, shape (n_samples, n_features) + """ + x = validate_input(x, t=t) + + if isinstance(t, (int, float)): + if t < 0: + raise ValueError("t must be a positive constant or an array") + t = arange(x.shape[0]) * t + + return dxdt(x, t, axis=axis, **self.kwargs) diff --git a/DSA/pykoopman/src/pykoopman/differentiation/_finite_difference.py b/DSA/pykoopman/src/pykoopman/differentiation/_finite_difference.py new file mode 100644 index 0000000..0f50070 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/differentiation/_finite_difference.py @@ -0,0 +1,12 @@ +from __future__ import annotations + +import numpy as np +from sklearn.base import BaseEstimator + + +class FiniteDifference(BaseEstimator): + def __init__(self, order=1): + self.order = order + + def __call__(self, x, t=1): + return np.gradient(x) diff --git a/DSA/pykoopman/src/pykoopman/koopman.py b/DSA/pykoopman/src/pykoopman/koopman.py new file mode 100644 index 0000000..4330a68 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/koopman.py @@ -0,0 +1,637 @@ +"""module for discrete time Koopman class""" +from __future__ import annotations + +from warnings import catch_warnings +from warnings import filterwarnings +from warnings import warn + +import numpy as np +from numpy import empty +from pydmd import DMD +from pydmd import DMDBase +from sklearn.base import BaseEstimator +from sklearn.metrics import r2_score +from sklearn.pipeline import Pipeline +from sklearn.utils.validation import check_is_fitted + +from .common import validate_input +from .observables import Identity +from .observables import TimeDelay +from .regression import BaseRegressor +from .regression import DMDc +from .regression import EDMDc +from .regression import EnsembleBaseRegressor +from .regression import HAVOK +from .regression import NNDMD +from .regression import PyDMDRegressor + + +class Koopman(BaseEstimator): + """Discrete-Time Koopman class. + + The input-output data is all row-wise if stated elsewhere. + All of the matrix, are based on column-wise linear system. + This class is inherited from `pykoopman.regression.BaseEstimator`. + + Args: + observables: observables object, optional + (default: `pykoopman.observables.Identity`) + Map(s) to apply to raw measurement data before estimating the + Koopman operator. + Must extend `pykoopman.observables.BaseObservables`. + The default option, `pykoopman.observables.Identity`, leaves + the input untouched. + + regressor: regressor object, optional (default: `DMD`) + The regressor used to learn the Koopman operator from the observables. + `regressor` can either extend the `pykoopman.regression.BaseRegressor`, + or `pydmd.DMDBase`. + In the latter case, the pydmd object must have both a `fit` + and a `predict` method. + + quiet: boolean, optional (default: False) + Whether or not warnings should be silenced during fitting. + + Attributes: + model: sklearn.pipeline.Pipeline + Internal representation of the forward model. + Applies the observables and the regressor. + + n_input_features_: int + Number of input features before computing observables. + + n_output_features_: int + Number of output features after computing observables. + + n_control_features_: int + Number of control features used as input to the system. + + time: dictionary + Time vector properties. + """ + + def __init__(self, observables=None, regressor=None, quiet=False): + """Constructor for the Koopman class. + + Args: + observables: observables object, optional + (default: `pykoopman.observables.Identity`) + Map(s) to apply to raw measurement data before estimating the + Koopman operator. + Must extend `pykoopman.observables.BaseObservables`. + The default option, `pykoopman.observables.Identity`, leaves + the input untouched. + + regressor: regressor object, optional (default: `DMD`) + The regressor used to learn the Koopman operator from the observables. + `regressor` can either extend the `pykoopman.regression.BaseRegressor`, + or `pydmd.DMDBase`. + In the latter case, the pydmd object must have both a `fit` + and a `predict` method. + + quiet: boolean, optional (default: False) + Whether or not warnings should be silenced during fitting. + """ + if observables is None: + observables = Identity() + if regressor is None: + regressor = PyDMDRegressor(DMD(svd_rank=2)) # set default svd rank 2 + if isinstance(regressor, DMDBase): + regressor = PyDMDRegressor(regressor) + elif not isinstance(regressor, (BaseRegressor)): + raise TypeError("Regressor must be from valid class") + self.observables = observables + self.regressor = regressor + self.quiet = quiet + + def fit(self, x, y=None, u=None, dt=1): + """ + Fit the Koopman model by learning an approximate Koopman operator. + + Args: + x: numpy.ndarray, shape (n_samples, n_features) + Measurement data to be fit. Each row should correspond to an example + and each column a feature. If only x is provided, it is assumed that + examples are equi-spaced in time (i.e., a uniform timestep is assumed). + + y: numpy.ndarray, shape (n_samples, n_features), optional (default: None) + Target measurement data to be fit, i.e., it is assumed y = fun(x). Each + row should correspond to an example and each column a feature. The + samples in x and y are generally not required to be consecutive and + equi-spaced. + + u: numpy.ndarray, shape (n_samples, n_control_features), optional (default: + None) Control/actuation/external parameter data. Each row should + correspond to one sample and each column a control variable or feature. + The control variable may be the amplitude of an actuator or an external, + time-varying parameter. It is assumed that samples in u occur at the + time instances of the corresponding samples in x, + e.g., x(t+1) = fun(x(t), u(t)). + + dt: float, optional (default: 1) + Time step between samples + + Returns: + self: returns a fit `Koopman` instance + """ + x = validate_input(x) + + if u is None: + self.n_control_features_ = 0 + elif not isinstance(self.regressor, DMDc) and not isinstance( + self.regressor, EDMDc + ): + raise ValueError( + "Control input u was passed, " "but self.regressor is not DMDc or EDMDc" + ) + + if y is None: # or isinstance(self.regressor, PyDMDRegressor): + # if there is only 1 trajectory OR regressor is PyDMD + y_flag = True + # regressor = self.regressor + x, y = self._detect_reshape(x, offset=True) + if isinstance(self.regressor, HAVOK): + regressor = self.regressor + y_flag = False + else: + regressor = EnsembleBaseRegressor( + regressor=self.regressor, + func=self.observables.transform, + inverse_func=self.observables.inverse, + ) + # regressor = self.regressor + elif isinstance(self.regressor, NNDMD): + regressor = self.regressor + y_flag = False + + else: + # multiple 1-step-trajectories + regressor = EnsembleBaseRegressor( + regressor=self.regressor, + func=self.observables.transform, + inverse_func=self.observables.inverse, + ) + # if x is a list, we need to further change trajectories into 1-step-traj + x, _ = self._detect_reshape(x, offset=False) + y, _ = self._detect_reshape(y, offset=False) + y_flag = False + # if isinstance(x, list): + # x_tmp = [] + # y_tmp = [] + # for traj_dat in x: + # x_tmp.append(traj_dat[:-1]) + # y_tmp.append(traj_dat[1:]) + # x = np.hstack(x_tmp) + # y = np.hstack(y_tmp) + + steps = [ + ("observables", self.observables), + ("regressor", regressor), + ] + self._pipeline = Pipeline(steps) # create `model` object using Pipeline + + action = "ignore" if self.quiet else "default" + with catch_warnings(): + filterwarnings(action, category=UserWarning) + if u is None: + self._pipeline.fit(x, y, regressor__dt=dt) + else: + self._pipeline.fit(x, y, regressor__u=u, regressor__dt=dt) + # update the second step with just the regressor, not the + # EnsembleBaseRegressor + if isinstance(self._pipeline.steps[1][1], EnsembleBaseRegressor): + self._pipeline.steps[1] = ( + self._pipeline.steps[1][0], + self._pipeline.steps[1][1].regressor_, + ) + + # pykoopman's n_input/output_features are simply + # observables's input output features + # observable's input features are just the number + # of states. but the output features can be really high + self.n_input_features_ = self._pipeline.steps[0][1].n_input_features_ + self.n_output_features_ = self._pipeline.steps[0][1].n_output_features_ + if hasattr(self._pipeline.steps[1][1], "n_control_features_"): + self.n_control_features_ = self._pipeline.steps[1][1].n_control_features_ + + # compute amplitudes + if isinstance(x, list): + self._amplitudes = None + elif y_flag: + if hasattr(self.observables, "n_consumed_samples"): + # g0 = self.observables.transform( + # x[0 : 1 + self.observables.n_consumed_samples] + # ) + self._amplitudes = np.abs( + self.psi(x[0 : 1 + self.observables.n_consumed_samples].T) + ) + else: + # g0 = self.observables.transform(x[0:1]) + + self._amplitudes = np.abs(self.psi(x[0:1].T)) + else: + self._amplitudes = None + + self.time = { + "tstart": 0, + "tend": dt * (self._pipeline.steps[1][1].n_samples_ - 1), + "dt": dt, + } + + return self + + def predict(self, x, u=None): + """ + Predict the state one timestep in the future. + + Args: + x: numpy.ndarray, shape (n_samples, n_input_features) + Current state. + + u: numpy.ndarray, shape (n_samples, n_control_features), + optional (default None) + Time series of external actuation/control. + + Returns: + x_next: numpy.ndarray, shape (n_samples, n_input_features) + Predicted state one timestep in the future. + """ + + x = validate_input(x) + + check_is_fitted(self, "n_output_features_") + x_next = self.observables.inverse(self._step(x, u)) + return x_next + + def simulate(self, x0, u=None, n_steps=1): + """Simulate an initial state forward in time with the learned Koopman model. + + Args: + x0: numpy.ndarray, shape (n_input_features,) or + (n_consumed_samples + 1, n_input_features) + Initial state from which to simulate. + If using TimeDelay observables, `x0` should contain + enough examples to compute all required time delays, + i.e., `n_consumed_samples + 1`. + + u: numpy.ndarray, shape (n_samples, n_control_features), + optional (default None) + Time series of external actuation/control. + + n_steps: int, optional (default 1) + Number of forward steps to be simulated. + + Returns: + x: numpy.ndarray, shape (n_steps, n_input_features) + Simulated states. + Note that `x[0, :]` is one timestep ahead of `x0`. + """ + check_is_fitted(self, "n_output_features_") + # Could have an option to only return the end state and not all + # intermediate states to save memory. + + if x0.ndim == 1: # handle non-time delay input but 1D accidently + x0 = x0.reshape(-1, 1) + elif x0.ndim == 2 and x0.shape[0] > 1: # handle time delay input + x0 = x0.T + else: + raise TypeError("Check your initial condition shape!") + # x = empty((n_steps, self.n_input_features_), dtype=self.A.dtype) + y = empty((n_steps, self.A.shape[0]), dtype=self.W.dtype) + + if u is None: + # lifted eigen space and move 1 step forward + y[0] = self.lamda @ self.psi(x0).flatten() + + # iterate in the lifted space + for k in range(n_steps - 1): + # tmp = self.W @ self.lamda**(k+1) @ y[0].reshape(-1,1) + y[k + 1] = self.lamda @ y[k] + x = np.transpose(self.W @ y.T) + # x = x.astype(self.A.dtype) + else: + # lifted space (not eigen) + y[0] = self.A @ self.phi(x0).flatten() + self.B @ u[0] + + # iterate in the lifted space + for k in range(n_steps - 1): + tmp = self.A @ y[k].reshape(-1, 1) + self.B @ u[k + 1].reshape(-1, 1) + y[k + 1] = tmp.flatten() + x = np.transpose(self.C @ y.T) + # x = x.astype(self.A.dtype) + + if np.isrealobj(x0): + x = np.real(x) + return x + + def get_feature_names(self, input_features=None): + """Get the names of the individual features constituting the observables. + + Args: + input_features: list of string, length n_input_features, + optional (default None) + String names for input features, if available. By default, + the names "x0", "x1", ..., "xn_input_features" are used. + + Returns: + output_feature_names: list of string, length n_output_features + Output feature names. + """ + check_is_fitted(self, "n_input_features_") + return self.observables.get_feature_names(input_features=input_features) + + def _step(self, x, u=None): + """Map x one timestep forward in the space of observables. + + Args: + x: numpy.ndarray, shape (n_samples, n_input_features) + State vectors to be stepped forward. + + u: numpy.ndarray, shape (n_samples, n_control_features), + optional (default None) + Time series of external actuation/control. + + Returns: + X': numpy.ndarray, shape (n_samples, self.n_output_features_) + Observables one timestep after x. + """ + check_is_fitted(self, "n_output_features_") + + if u is None or self.n_control_features_ == 0: + if self.n_control_features_ > 0: + raise TypeError( + "Model was fit using control variables, so u is required" + ) + elif u is not None: + warn( + "Control variables u were ignored because control variables were" + " not used when the model was fit" + ) + return self._pipeline.predict(X=x) + else: + if not isinstance(self.regressor, DMDc) and not isinstance( + self.regressor, EDMDc + ): + raise ValueError( + "Control input u was passed, but self.regressor is not DMDc " + "or EDMDc" + ) + return self._pipeline.predict(X=x, u=u) + + def phi(self, x_col): + """Compute the feature matrix phi(x) given `x_col`. + + Args: + x_col: numpy.ndarray, shape (n_features, n_samples) + State vectors to be evaluated for phi. + + Returns: + phi: numpy.ndarray, shape (n_samples, self.n_output_features_) + Value of phi evaluated at input `x_col`. + """ + x = x_col.T + y = self.observables.transform(x) + phi = self._pipeline.steps[-1][1]._compute_phi(y.T) + return phi + + def psi(self, x_col): + """Compute the Koopman psi(x) given `x_col`. + + Args: + x_col: numpy.ndarray, shape (n_features, n_samples) + State vectors to be evaluated for psi. + + Returns: + eigen_phi: numpy.ndarray, shape (n_samples, self.n_output_features_) + Value of psi evaluated at input `x_col`. + """ + x = x_col.T + y = self.observables.transform(x) + ephi = self._pipeline.steps[-1][1]._compute_psi(y.T) + return ephi + + @property + def A(self): + """Returns the state transition matrix `A`. + + The state transition matrix A satisfies y' = Ay or y' = Ay + Bu, + respectively, where y = g(x) and y is a low-rank representation. + """ + check_is_fitted(self, "_pipeline") + if isinstance(self.regressor, DMDBase): + raise ValueError("self.regressor " "has no A!") + if hasattr(self._pipeline.steps[-1][1], "state_matrix_"): + return self._pipeline.steps[-1][1].state_matrix_ + else: + raise ValueError("self.regressor" "has no state_matrix") + + @property + def B(self): + """Returns the control matrix `B`. + + The control matrix (or vector) B satisfies y' = Ay + Bu. + y is the reduced system state. + """ + check_is_fitted(self, "_pipeline") + if isinstance(self.regressor, DMDBase): + raise ValueError("this type of self.regressor has no B") + return self._pipeline.steps[-1][1].control_matrix_ + + @property + def C(self): + """Returns the measurement matrix (or vector) C. + + The measurement matrix C satisfies x = C * phi_r. + """ + check_is_fitted(self, "_pipeline") + # if not isinstance(self.observables, RadialBasisFunction): + # raise ValueError("this type of self.observable has no C") + # return self._pipeline.steps[0][1].measurement_matrix_ + measure_mat = self._pipeline.steps[0][1].measurement_matrix_ + ur = self._pipeline.steps[-1][1].ur + C = measure_mat @ ur + return C + + @property + def W(self): + """Returns the Koopman modes.""" + + check_is_fitted(self, "_pipeline") + # return self.C @ self._pipeline.steps[-1][1].unnormalized_modes + return self.C @ self._pipeline.steps[-1][1].eigenvectors_ + + @property + def _regressor_eigenvectors(self): + """Returns the eigenvectors of the regressor.""" + check_is_fitted(self, "_pipeline") + return self._pipeline.steps[-1][1].eigenvectors_ + + @property + def lamda(self): + """Returns the discrete-time Koopman lambda obtained from spectral + decomposition.""" + check_is_fitted(self, "_pipeline") + return np.diag(self._pipeline.steps[-1][1].eigenvalues_) + + @property + def lamda_array(self): + """Returns the discrete-time Koopman lambda as an array.""" + check_is_fitted(self, "_pipeline") + return np.diag(self.lamda) + 0j + + @property + def continuous_lamda_array(self): + """Returns the continuous-time Koopman lambda as an array.""" + check_is_fitted(self, "_pipeline") + return np.log(self.lamda_array) / self.time["dt"] + + @property + def ur(self): + """Returns the projection matrix Ur.""" + check_is_fitted(self, "_pipeline") + return self._pipeline.steps[-1][1].ur + + def validity_check(self, t, x): + """Perform a validity check of eigenfunctions. + + The validity check tests the linearity of eigenfunctions phi(x(t)) == phi(x(0)) + * exp(lambda*t). + + Args: + t: numpy.ndarray, shape (n_samples,) + Time vector. + x: numpy.ndarray, shape (n_samples, n_input_features) + State vectors to be checked. + + Returns: + efun_index: list + Sorted indices of eigenfunctions based on linearity error. + linearity_error: list + Linearity error for each eigenfunction. + """ + + psi = self.psi(x.T) + omega = np.log(np.diag(self.lamda) + 0j) / self.time["dt"] + + # omega = self.eigenvalues_continuous + linearity_error = [] + for i in range(self.lamda.shape[0]): + linearity_error.append( + np.linalg.norm(psi[i, :] - np.exp(omega[i] * t) * psi[i, 0:1]) + ) + sort_idx = np.argsort(linearity_error) + efun_index = np.arange(len(linearity_error))[sort_idx] + linearity_error = [linearity_error[i] for i in sort_idx] + return efun_index, linearity_error + + def score(self, x, y=None, cast_as_real=True, metric=r2_score, **metric_kws): + """Score the model predictions for the next timestep. + + Parameters: + x: numpy.ndarray, shape (n_samples, n_input_features) + State measurements. + y: numpy.ndarray, shape (n_samples, n_input_features), optional + (default None). State measurements one timestep in the future. + cast_as_real: bool, optional (default True) + Whether to take the real part of predictions when computing the score. + metric: callable, optional (default r2_score) + The metric function used to score the model predictions. + metric_kws: dict, optional + Optional parameters to pass to the metric function. + + Returns: + score: float + Metric function value for the model predictions at the next timestep. + """ + check_is_fitted(self, "n_output_features_") + x = validate_input(x) + + if isinstance(self.observables, TimeDelay): + n_consumed_samples = self.observables.n_consumed_samples + + # User may pass in too-large + if y is not None and len(y) == len(x): + warn( + f"The first {n_consumed_samples} entries of y were ignored because " + "TimeDelay obesrvables were used." + ) + y = y[n_consumed_samples:] + else: + n_consumed_samples = 0 + + if y is None: + if cast_as_real: + return metric( + x[n_consumed_samples + 1 :].real, + self.predict(x[:-1]).real, + **metric_kws, + ) + else: + return metric( + x[n_consumed_samples + 1 :], self.predict(x[:-1]), **metric_kws + ) + else: + if cast_as_real: + return metric(y.real, self.predict(x).real, **metric_kws) + else: + return metric(y, self.predict(x), **metric_kws) + + def _observable(self): + """Returns the observable transformation.""" + return self._pipeline.steps[0][1] + + def _regressor(self): + """Returns the fitted regressor.""" + # this can access the fitted regressor + # todo: future we need to figure out a way to do time delay multiple + # trajectories DMD + # my idea is to manually call xN observables then concate the data to let + # the _regressor.fit to update the model coefficients. + # call this function with _regressor() + return self._pipeline.steps[1][1] + + def _detect_reshape(self, X, offset=True): + """ + Detect the shape of the input data and reshape it accordingly to return + both X and Y in the correct shape. + """ + s1 = -1 if offset else None + s2 = 1 if offset else None + if isinstance(X, np.ndarray): + if X.ndim == 1: + X = X.reshape(-1, 1) + + if X.ndim == 2: + self.n_samples_, self.n_input_features_ = X.shape + self.n_trials_ = 1 + return X[:s1], X[s2:] + elif X.ndim == 3: + self.n_trials_, self.n_samples_, self.n_input_features_ = X.shape + X, Y = X[:, :s1, :], X[:, s2:, :] + return X.reshape(-1, X.shape[2]), Y.reshape( + -1, Y.shape[2] + ) # time*trials, features + + elif isinstance(X, list): + assert all(isinstance(x, np.ndarray) for x in X) + self.n_trials_tot, self.n_samples_tot, self.n_input_features_tot = ( + [], + [], + [], + ) + X_tot, Y_tot = [], [] + for x in X: + x, y = self._detect_reshape(x) + X_tot.append(x) + Y_tot.append(y) + self.n_trials_tot.append(self.n_trials_) + self.n_samples_tot.append(self.n_samples_) + self.n_input_features_tot.append(self.n_input_features_) + X = np.concatenate(X_tot, axis=0) + Y = np.concatenate(Y_tot, axis=0) + + self.n_trials_ = sum(self.n_trials_tot) + self.n_samples_ = sum(self.n_samples_tot) + self.n_input_features_ = sum(self.n_input_features_tot) + + return X, Y diff --git a/DSA/pykoopman/src/pykoopman/koopman_continuous.py b/DSA/pykoopman/src/pykoopman/koopman_continuous.py new file mode 100644 index 0000000..2ba881d --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/koopman_continuous.py @@ -0,0 +1,154 @@ +"""module for continuous time Koopman class""" +from __future__ import annotations + +import numpy as np +from sklearn.utils.validation import check_is_fitted + +from .differentiation import Derivative +from .koopman import Koopman + + +class KoopmanContinuous(Koopman): + """ + Continuous-time Koopman class. + + Args: + observables: Observables object, optional + (default: pykoopman.observables.Identity) + Map(s) to apply to raw measurement data before + estimating the Koopman operator. Must extend + pykoopman.observables.BaseObservables. The default + option, pykoopman.observables.Identity, leaves the + input untouched. + differentiator: Callable, optional + (default: centered difference) + Function used to compute numerical derivatives. + The function must have the call signature + differentiator(x, t), where x is a 2D numpy ndarray + of shape (n_samples, n_features) and t is a 1D numpy + ndarray of shape (n_samples,). + regressor: Regressor object, optional + (default: DMD) + The regressor used to learn the Koopman operator from + the observables. regressor can either extend + pykoopman.regression.BaseRegressor, or the + pydmd.DMDBase class. In the latter case, the pydmd + object must have both a fit and a predict method. + """ + + def __init__( + self, + observables=None, + differentiator=Derivative(kind="finite_difference", k=1), + regressor=None, + ): + """ + Continuous-time Koopman class. + + Args: + observables: Observables object, optional + (default: pykoopman.observables.Identity) + Map(s) to apply to raw measurement data before + estimating the Koopman operator. Must extend + pykoopman.observables.BaseObservables. The default + option, pykoopman.observables.Identity, leaves the + input untouched. + differentiator: Callable, optional + (default: centered difference) + Function used to compute numerical derivatives. + The function must have the call signature + differentiator(x, t), where x is a 2D numpy ndarray + of shape (n_samples, n_features) and t is a 1D numpy + ndarray of shape (n_samples,). + regressor: Regressor object, optional + (default: DMD) + The regressor used to learn the Koopman operator from + the observables. regressor can either extend + pykoopman.regression.BaseRegressor, or the + pydmd.DMDBase class. In the latter case, the pydmd + object must have both a fit and a predict method. + """ + super().__init__(observables, regressor) + self.differentiator = differentiator + + def predict(self, x, dt=0, u=None): + """ + Predict using continuous-time Koopman model. + + Args: + x: numpy.ndarray + State measurements. Each row should correspond to + the system state at some point in time. + dt: float, optional (default: 0) + Time step between measurements. If specified, the + prediction is made for the given time step in the + future. + u: numpy.ndarray, optional (default: None) + Control input/actuation data. Each row should + correspond to one sample and each column a control + variable or feature. + + Returns: + output: numpy.ndarray + Predicted state using the continuous-time Koopman + model. Each row corresponds to the predicted state + for the corresponding row in x. + """ + check_is_fitted(self, "_pipeline") + + if u is None: + ypred = self._pipeline.predict(X=x, t=dt) + else: + ypred = self._pipeline.predict(X=x, u=u, t=dt) + + output = self.observables.inverse(ypred) + + return output + + def simulate(self, x, t=0, u=None): + """ + Simulate continuous-time Koopman model. + + Args: + x: numpy.ndarray + Initial state from which to simulate. Each row + corresponds to the system state at some point in time. + t: float, optional (default: 0) + Time at which to simulate the system. If specified, + the simulation is performed for the given time. + u: numpy.ndarray, optional (default: None) + Control input/actuation data. Each row should + correspond to one sample and each column a control + variable or feature. + + Returns: + output: numpy.ndarray + Simulated states of the system. Each row corresponds + to the simulated state at a specific time point. + """ + check_is_fitted(self, "_pipeline") + + if u is None: + ypred = self._pipeline.predict(X=x, t=t) + else: + ypred = self._pipeline.predict(X=x, u=u, t=t) + + output = [] + for k in range(ypred.shape[0]): + output.append(np.squeeze(self.observables.inverse(ypred[k][np.newaxis, :]))) + + return np.array(output) + + def _step(self, x, u=None): + """ + Placeholder method for step function. + + This method is not implemented in the ContinuousKoopman class + as there is no explicit step function for continuous-time + Koopman models. + + Raises: + NotImplementedError: This method is not implemented + in the ContinuousKoopman class. + """ + raise NotImplementedError("ContinuousKoopman does not have a step function.") diff --git a/DSA/pykoopman/src/pykoopman/observables/__init__.py b/DSA/pykoopman/src/pykoopman/observables/__init__.py new file mode 100644 index 0000000..8a26f3a --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/__init__.py @@ -0,0 +1,17 @@ +from __future__ import annotations + +from ._custom_observables import CustomObservables +from ._identity import Identity +from ._polynomial import Polynomial +from ._radial_basis_functions import RadialBasisFunction +from ._random_fourier_features import RandomFourierFeatures +from ._time_delay import TimeDelay + +__all__ = [ + "CustomObservables", + "Identity", + "Polynomial", + "RadialBasisFunction", + "RandomFourierFeatures", + "TimeDelay", +] diff --git a/DSA/pykoopman/src/pykoopman/observables/_base.py b/DSA/pykoopman/src/pykoopman/observables/_base.py new file mode 100644 index 0000000..2d9af34 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_base.py @@ -0,0 +1,408 @@ +"""Module for base classes for specific observable classes.""" +from __future__ import annotations + +import abc + +import numpy as np +from sklearn.base import BaseEstimator +from sklearn.base import TransformerMixin +from sklearn.utils.validation import check_is_fitted + + +class BaseObservables(TransformerMixin, BaseEstimator): + """ + Abstract base class for observable classes. + + This class defines the interface for observable classes. It uses + the transformer interface from scikit-learn. + """ + + def __init__(self): + """ + Initialize a BaseObservables instance. + + Initializes the parent classes with the super function. + """ + super(BaseObservables, self).__init__() + + @abc.abstractmethod + def fit(self, X, y=None): + """ + Abstract method for fitting the observables. + + Args: + X (np.ndarray): The input data. + y (np.ndarray, optional): The target values. + + Raises: + NotImplementedError: This method must be overwritten by any child class. + """ + raise NotImplementedError + + @abc.abstractmethod + def transform(self, X): + """ + Abstract method for transforming the data. + + Args: + X (np.ndarray): The input data. + + Raises: + NotImplementedError: This method must be overwritten by any child class. + """ + raise NotImplementedError + + @abc.abstractmethod + def get_feature_names(self, input_features=None): + """ + Abstract method for getting the names of the features. + + Args: + input_features (list of str, optional): The names of the input features. + + Raises: + NotImplementedError: This method must be overwritten by any child class. + """ + raise NotImplementedError + + def inverse(self, y): + """ + Inverse the transformation. + + Args: + y (np.ndarray): The transformed data. + + Returns: + np.ndarray: The original data. + + Raises: + ValueError: If the shape of the input does not match the expected shape. + """ + check_is_fitted(self, ["n_input_features_", "measurement_matrix_"]) + if isinstance(y, list): + return [self.inverse(y_trial) for y_trial in y] + if y.ndim == 3: + return np.array([self.inverse(y_trial) for y_trial in y]) + + if y.ndim == 1: + y = y.reshape(1, -1) + + if y.shape[-1] != self.n_output_features_: + raise ValueError( + "Wrong number of input features." + f"Expected y.shape[-1] = {self.n_output_features_}; " + f"instead y.shape[-1] = {y.shape[-1]}." + ) + + return y @ self.measurement_matrix_.T + + def __add__(self, other): + if isinstance(self, ConcatObservables): + return ConcatObservables(self.observables_list_ + [other]) + else: + return ConcatObservables([self, other]) + + @property + def size(self): + check_is_fitted(self) + return self.n_output_features_ + + +# learned from https://github.com/dynamicslab/pysindy/blob/ +# d0d96f4466b9c16cdd349fdc515abe9081e5b2cf/pysindy/feature_library/base.py#L235 + + +class ConcatObservables(BaseObservables): + """ + This class concatenates two or more `BaseObservables` instances into a single + `ConcatObservables` instance. + + The concatenated observables are handled in such a way that only the first + observable with the identity mapping is kept, while the identity mapping in + the rest is removed. The same applies to observables that are polynomials with + `include_bias=True`, in which case the bias feature is also removed. + + Args: + observables_list_ (list, optional): A list of `BaseObservables` instances + to concatenate. Defaults to None. + + Attributes: + observables_list_ (list, optional): The list of `BaseObservables` instances + that were concatenated. Defaults to None. + include_state (bool): True if a linear feature (i.e., the system state) is + included. This indicator can help to identify if a redundant linear feature + can be removed. + n_input_features_ (int): The dimensionality of the input features, e.g., + the system state. + n_output_features_ (int): The dimensionality of the transformed/output + features, e.g., the observables. + n_consumed_samples (int): The number of effective samples. This can be less + than the total number of samples due to time-delay stacking. + measurement_matrix_ (numpy.ndarray): This matrix transforms a row feature + vector to return the system state. Its shape is (n_input_features_, + n_output_features_). + + Methods: + fit(X, y=None): Calculates and stores important information such as the + dimensions of the input and output features, the number of effective + samples, and the measurement matrix. + transform(X): Applies the transformation defined by the observables to + input data. + get_feature_names(input_features=None): Returns the names of the features + after transformation. + inverse(y): Applies the inverse transformation to the transformed data to + recover the original system state. + """ + + def __init__(self, observables_list_=None): + """Initializes a ConcatObservables instance. + + Args: + observables_list_ (list, optional): A list of `BaseObservables` instances. + If provided, the first observable must have an `include_state` + attribute. The default value is None. + + Raises: + AssertionError: If the first observable in `observables_list_` does not have + an `include_state` attribute. + """ + super(ConcatObservables, self).__init__() + self.observables_list_ = observables_list_ + assert hasattr( + self.observables_list_[0], "include_state" + ), "first observable must have `include_state' attribute" + self.include_state = self.observables_list_[0].include_state + + def fit(self, X, y=None): + """Sets up observable by fitting the model to the data. + + This method fits each observable in the list to the data, determines the + total number of output features, and sets up the measurement matrix. + + Args: + X (numpy.ndarray): Measurement data to be fit, with shape (n_samples, + n_input_features_). + y (numpy.ndarray, optional): Time-shifted measurement data to be fit. + Default is None. + + Returns: + ConcatObservables: A fitted instance of the class. + + Raises: + AssertionError: If any observable in the list does not have an + `include_state` attribute, or if the shape of the temporary least + squares solution does not match the shape of the measurement matrix. + """ + + # first, one must call fit of every observable in the observer list + # so that n_input_features_ and n_output_features_ are defined + for obs in self.observables_list_: + obs.fit(X, y) + + self.n_input_features_ = X.shape[1] + + # total number of output features takes care of redundant identity features + # for polynomial feature, we will remove the 1 as well if include_bias is true + + first_obs = self.observables_list_[0] + s = 0 + obs_list_contain_state_counter = 1 if first_obs.include_state else 0 + obs_list_contain_bias_counter = ( + 1 if getattr(first_obs, "include_bias", False) else 0 + ) + for obs in self.observables_list_[1:]: + assert hasattr(obs, "include_state"), ( + "observable Must have `include_state' " "attribute" + ) + if obs_list_contain_state_counter > 1 and obs.include_state: + s += obs.n_output_features_ - obs.n_input_features_ + else: + s += obs.n_output_features_ + if obs_list_contain_bias_counter > 1 and getattr( + obs, "include_bias", False + ): + s -= 1 + obs_list_contain_state_counter += 1 if obs.include_state is True else 0 + obs_list_contain_bias_counter += ( + 1 if getattr(obs, "include_bias", False) else 0 + ) + + self.n_output_features_ = first_obs.n_output_features_ + s + + # take care of consuming samples in time delay observables: \ + # we will look for the largest delay + max_n_consumed_samples = 0 + for obs in self.observables_list_: + if hasattr(obs, "n_consumed_samples"): + max_n_consumed_samples = max( + max_n_consumed_samples, obs.n_consumed_samples + ) + self.n_consumed_samples = max_n_consumed_samples + + # choosing measurement_matrix + self.measurement_matrix_ = np.zeros( + [self.n_input_features_, self.n_output_features_] + ) + # 1. if any observable has `include_state` == True + if any([obs.include_state for obs in self.observables_list_]) is True: + jj = 0 + for i in range(len(self.observables_list_)): + jcol = self.observables_list_[i].measurement_matrix_.shape[1] + if self.observables_list_[i].include_state is True: + break + jj += jcol + self.measurement_matrix_[:, jj : jj + jcol] = self.observables_list_[ + i + ].measurement_matrix_ + else: + g = self.transform(X) + tmp = np.linalg.lstsq(g, X)[0].T + assert tmp.shape == self.measurement_matrix_.shape + self.measurement_matrix_ = tmp + + # 1. if first observable does not contain include state but others do + # then we will use the nearest one's measurement matrix + + # otherwise, + + # C comes from the first observable + + # first_obs_measurement_matrix = self.observables_list_[0].measurement_matrix_ + # self.measurement_matrix_[:first_obs_measurement_matrix.shape[0], + # :first_obs_measurement_matrix.shape[1],] = first_obs_measurement_matrix + + return self + + def transform(self, X): + """Evaluate observable at `X`. + + This method checks if the model is fitted and then evaluates the observables + at the provided data, excluding features that are state or bias based on + certain conditions. + + Args: + X (numpy.ndarray): Measurement data to be fit, with shape (n_samples, + n_input_features_) or (n_trials, n_samples, n_input_features_). + + Returns: + y (numpy.ndarray): Evaluation of observables at `X`, with shape (n_samples, + n_output_features_) or (n_trials, n_samples, n_output_features_). + + Raises: + NotFittedError: If the model is not fitted yet. + """ + + # Handle 3D data (multiple trials) by processing each trial separately + if isinstance(X, list): + return [self.transform(X_trial) for X_trial in X] + + if X.ndim == 3: + return np.array([self.transform(X_trial) for X_trial in X]) + + # for obs in self.observables_list_: + # check_is_fitted(obs, "n_consumed_samples_") + check_is_fitted(self, "n_consumed_samples") + num_samples_updated = X.shape[0] - self.n_consumed_samples + first_obs = self.observables_list_[0] + obs_list_contain_state_counter = 1 if first_obs.include_state else 0 + obs_list_contain_bias_counter = ( + 1 if getattr(first_obs, "include_bias", False) else 0 + ) + y_list = [first_obs.transform(X)[-num_samples_updated:, :]] + + # only include those features that are not state + y_rest_list = [] + for obs in self.observables_list_[1:]: + if obs_list_contain_state_counter > 1 and obs.include_state: + y_new = obs.transform(X)[-num_samples_updated:, obs.n_input_features_ :] + else: + y_new = obs.transform(X)[-num_samples_updated:, :] + if obs_list_contain_bias_counter > 1 and getattr( + obs, "include_bias", False + ): + y_new = y_new[:, 1:] + obs_list_contain_state_counter += 1 if obs.include_state else 0 + obs_list_contain_bias_counter += ( + 1 if getattr(obs, "include_bias", False) else 0 + ) + + y_rest_list.append(y_new) + y_list += y_rest_list + + # y_list += [ + # obs.transform(X)[-num_samples_updated:, obs.n_input_features_ :] + # for obs in self.observables_list_[1:] + # ] + y = np.hstack(y_list) + return y + + def get_feature_names(self, input_features=None): + """Return names of observables. + + This method returns a list of feature names, which are created by + concatenating the feature names from all observables in the list. + + Args: + input_features (list of str, optional): Default list is "x0", "x1", ..., + "xn", where n = n_features. Defaults to None. + + Returns: + list of str: List of feature names of length n_output_features. + + Raises: + NotFittedError: If the model is not fitted yet. + """ + check_is_fitted(self, "n_input_features_") + + concat_feature_names = self.observables_list_[0].get_feature_names() + for obs in self.observables_list_[1:]: + if getattr(obs, "include_bias", False): + concat_feature_names += obs.get_feature_names()[ + obs.n_input_features_ + 1 : + ] + else: + concat_feature_names += obs.get_feature_names()[obs.n_input_features_ :] + return concat_feature_names + + def inverse(self, y): + """Invert the transformation to get system state `x`. + + This function approximately (due to some of them use least-square) + satisfies :code:`self.inverse(self.transform(x)) == x`. + + Args: + y (numpy.ndarray): Data to which to apply the inverse. + Shape must be (n_samples, n_output_features) or + (n_trials, n_samples, n_output_features). + Must have the same number of features as the transformed data. + + Returns: + numpy.ndarray: Output of inverse map applied to y. + Shape will be (n_samples, n_input_features) or + (n_trials, n_samples, n_input_features). + + Raises: + NotFittedError: If the model is not fitted yet. + ValueError: If the number of features in `y` does not match + `n_output_features_`. + + """ + + # Handle 3D data (multiple trials) by processing each trial separately + if isinstance(y, list): + return [self.inverse(y_trial) for y_trial in y] + + if y.ndim == 3: + return np.array([self.inverse(y_trial) for y_trial in y]) + + check_is_fitted(self, ["n_input_features_", "measurement_matrix_"]) + if y.shape[-1] != self.n_output_features_: + raise ValueError( + "Wrong number of input features." + f"Expected y.shape[-1] = {self.n_output_features_}; " + f"instead y.shape[-1] = {y.shape[-1]}." + ) + + # dim_output_first_obs = self.observables_list_[0].n_output_features_ + x = y @ self.measurement_matrix_.T + return x diff --git a/DSA/pykoopman/src/pykoopman/observables/_custom_observables.py b/DSA/pykoopman/src/pykoopman/observables/_custom_observables.py new file mode 100644 index 0000000..6d9cefb --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_custom_observables.py @@ -0,0 +1,239 @@ +"""Module for customized observables""" +from __future__ import annotations + +from itertools import combinations +from itertools import combinations_with_replacement + +import numpy as np +from numpy import empty +from sklearn.utils.validation import check_is_fitted + +from ..common import validate_input +from ._base import BaseObservables + + +class CustomObservables(BaseObservables): + """ + A class to map state variables using custom observables. + + This class allows the user to specify a list of functions that map state variables + to observables. The identity map is automatically included. It can be configured to + include or exclude self-interaction terms. + + Attributes: + observables (list of callable): List of functions mapping state variables to + observables. Univariate functions are applied to each state variable, + and multivariable functions are applied to combinations of state + variables. The identity map is automatically included in this list. + observable_names (list of callable, optional): List of functions mapping from + names of state variables to names of observables. For example, + the observable name lambda x: f"{x}^2" would correspond to the function + x^2. If None, the names "f0(...)", "f1(...)", ... will be used. Default + is None. + interaction_only (bool, optional): If True, omits self-interaction terms. + Function evaluations of the form f(x,x) and f(x,y,x) will be omitted, + but those of the form f(x,y) and f(x,y,z) will be included. If False, + all combinations will be included. Default is True. + n_input_features_ (int): Number of input features. + n_output_features_ (int): Number of output features. + """ + + def __init__(self, observables, observable_names=None, interaction_only=True): + """ + Initialize a CustomObservables instance. + + Args: + observables (list of callable): List of functions mapping state variables + to observables. Univariate functions are applied to each state + variable, and multivariable functions are applied to combinations of + state variables. The identity map is automatically included in this + list. + observable_names (list of callable, optional): List of functions mapping + from names of state variables to names of observables. For example, + the observable name lambda x: f"{x}^2" would correspond to the + function x^2. If None, the names "f0(...)", "f1(...)", ... will + be used. Default is None. + interaction_only (bool, optional): If True, omits self-interaction terms. + Function evaluations of the form f(x,x) and f(x,y,x) will be omitted, + but those of the form f(x,y) and f(x,y,z) will be included. If False, + all combinations will be included. Default is True. + """ + super(CustomObservables, self).__init__() + self.observables = [identity, *observables] + if observable_names and (len(observables) != len(observable_names)): + raise ValueError( + "observables and observable_names must have the same length" + ) + self.observable_names = observable_names + self.interaction_only = interaction_only + self.include_state = True + + def fit(self, x, y=None): + """ + Fit the model to the measurement data. + + This method calculates the number of input and output features and generates + default values for 'observable_names' if necessary. It also prepares the + measurement matrix for data transformation. + + Args: + x (array-like, shape (n_samples, n_input_features)): Measurement data to be + fitted. + y (None): This is a dummy parameter added for compatibility with sklearn's + API. Default is None. + + Returns: + self (CustomObservables): This method returns the fitted instance. + """ + x = validate_input(x) + n_samples, n_features = x.shape + + n_output_features = 0 + for f in self.observables: + n_args = f.__code__.co_argcount + n_output_features += len( + list(self._combinations(n_features, n_args, self.interaction_only)) + ) + + self.n_input_features_ = n_features + self.n_output_features_ = n_output_features + self.n_consumed_samples = 0 + + if self.observable_names is None: + self.observable_names = list( + map( + lambda i: (lambda *x: "f" + str(i) + "(" + ",".join(x) + ")"), + range(len(self.observables)), + ) + ) + + # First map is the identity + self.observable_names.insert(0, identity_name) + + # since the first map is identity + self.measurement_matrix_ = np.zeros( + (self.n_input_features_, self.n_output_features_) + ) + self.measurement_matrix_[ + : self.n_input_features_, : self.n_input_features_ + ] = np.eye(self.n_input_features_) + + return self + + def transform(self, x): + """ + Apply custom transformations to data, computing observables. + + This method applies the user-defined observables functions to the input data, + effectively transforming the state variables into observable ones. + + Args: + x (array-like, shape (n_samples, n_input_features)): The measurement data + to be transformed. + + Returns: + x_transformed (array-like, shape (n_samples, n_output_features)): The + transformed data, i.e., the computed observables. + """ + check_is_fitted(self, "n_input_features_") + check_is_fitted(self, "n_output_features_") + x = validate_input(x) + + if isinstance(x, list): + return [self.transform(x_trial) for x_trial in x] + + if x.ndim == 3: + return np.array([self.transform(x_trial) for x_trial in x]) + + n_samples, n_features = x.shape + + if n_features != self.n_input_features_: + raise ValueError("x.shape[1] does not match n_input_features_") + + x_transformed = empty((n_samples, self.n_output_features_), dtype=x.dtype) + observables_idx = 0 + for f in self.observables: + for c in self._combinations( + self.n_input_features_, f.__code__.co_argcount, self.interaction_only + ): + x_transformed[:, observables_idx] = f(*[x[:, j] for j in c]) + observables_idx += 1 + + return x_transformed + + def get_feature_names(self, input_features=None): + """ + Get the names of the output features. + + This method returns the names of the output features as defined by the + observable functions. If names for the input features are provided, they are + used in the output feature names. Otherwise, default names ("x0", "x1", ..., + "xn_input_features") are used. + + Args: + input_features (list of string, length n_input_features, optional): + String names for input features, if available. By default, the names + "x0", "x1", ... ,"xn_input_features" are used. + + Returns: + output_feature_names (list of string, length n_output_features): + Output feature names. + """ + check_is_fitted(self, "n_input_features_") + if input_features is None: + input_features = [f"x{i}" for i in range(self.n_input_features_)] + else: + if len(input_features) != self.n_input_features_: + raise ValueError( + "input_features must have n_input_features_ " + f"({self.n_input_features_}) elements" + ) + + feature_names = [] + for i, f in enumerate(self.observables): + feature_names.extend( + [ + self.observable_names[i](*[input_features[j] for j in c]) + for c in self._combinations( + self.n_input_features_, + f.__code__.co_argcount, + self.interaction_only, + ) + ] + ) + + return feature_names + + @staticmethod + def _combinations(n_features, n_args, interaction_only): + """ + Get the combinations of features to be passed to observable functions. + + This static method generates all possible combinations or combinations with + replacement (depending on the `interaction_only` flag) of features that are to + be passed to the observable functions. The combinations are represented as + tuples of indices. + + Args: + n_features (int): The total number of features. + n_args (int): The number of arguments that the observable function accepts. + interaction_only (bool): If True, combinations of the same feature + (self-interactions) are omitted. If False, all combinations including + self-interactions are included. + + Returns: + iterable of tuples: An iterable over all combinations of feature indices + to be passed to the observable functions. + """ + comb = combinations if interaction_only else combinations_with_replacement + return comb(range(n_features), n_args) + + +def identity(x): + """Identity map.""" + return x + + +def identity_name(x): + """Name for identity map.""" + return str(x) diff --git a/DSA/pykoopman/src/pykoopman/observables/_identity.py b/DSA/pykoopman/src/pykoopman/observables/_identity.py new file mode 100644 index 0000000..3f7ceb0 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_identity.py @@ -0,0 +1,89 @@ +"""module for Linear observables""" +from __future__ import annotations + +import numpy as np +from sklearn.utils.validation import check_is_fitted + +from ..common import validate_input +from ._base import BaseObservables + + +class Identity(BaseObservables): + """ + A dummy observables class that simply returns its input. + """ + + def __init__(self): + """ + Initialize the Identity class. + + This constructor initializes the Identity class which simply returns its input + when transformed. + """ + super().__init__() + self.include_state = True + + def fit(self, x, y=None): + """ + Fit the model to the provided measurement data. + + Args: + x (array-like): The measurement data to be fit. It must have a shape of + (n_samples, n_input_features). + y (None): This parameter is retained for sklearn compatibility. + + Returns: + self: Returns a fit instance of the class `pykoopman.observables.Identity`. + + Note: + only identity mapping is supported for list of arb trajectories + """ + x = validate_input(x) + if not isinstance(x, list): + self.n_input_features_ = self.n_output_features_ = x.shape[1] + self.measurement_matrix_ = np.eye(x.shape[1]).T + else: + self.n_input_features_ = self.n_output_features_ = x[0].shape[1] + self.measurement_matrix_ = np.eye(x[0].shape[1]).T + + self.n_consumed_samples = 0 + + return self + + def transform(self, x): + """ + Apply Identity transformation to the provided data. + + Args: + x (array-like): The measurement data to be transformed. It must have a + shape of (n_samples, n_input_features). + + Returns: + array-like: Returns the transformed data which is the same as the input + data in this case. + """ + check_is_fitted(self, "n_input_features_") + return x + + def get_feature_names(self, input_features=None): + """ + Get the names of the output features. + + Args: + input_features (list of string, optional): The string names for input + features, if available. By default, the names "x0", "x1", ... , + "xn_input_features" are used. + + Returns: + list of string: Returns the output feature names. + """ + check_is_fitted(self, "n_input_features_") + if input_features is None: + input_features = [f"x{i}" for i in range(self.n_input_features_)] + else: + if len(input_features) != self.n_input_features_: + raise ValueError( + "input_features must have n_input_features_ " + f"({self.n_input_features_}) elements" + ) + return input_features diff --git a/DSA/pykoopman/src/pykoopman/observables/_polynomial.py b/DSA/pykoopman/src/pykoopman/observables/_polynomial.py new file mode 100644 index 0000000..5e852de --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_polynomial.py @@ -0,0 +1,263 @@ +"""moduel for Polynomial observables""" +from __future__ import annotations + +from itertools import chain +from itertools import combinations +from itertools import combinations_with_replacement as combinations_w_r + +import numpy as np +from scipy import sparse +from sklearn.preprocessing import PolynomialFeatures +from sklearn.preprocessing._csr_polynomial_expansion import _csr_polynomial_expansion +from sklearn.utils.validation import check_is_fitted +from sklearn.utils.validation import FLOAT_DTYPES + +from ..common import check_array +from ..common import validate_input +from ._base import BaseObservables + + +class Polynomial(PolynomialFeatures, BaseObservables): + """ + Polynomial observables. + + This is essentially the `sklearn.preprocessing.PolynomialFeatures` with support for + complex numbers. + + Args: + degree (int, optional): The degree of the polynomial features. Default is 2. + interaction_only (bool, optional): If True, only interaction features are + produced: features that are products of at most ``degree`` *distinct* + input features (so not ``x[1] ** 2``, ``x[0] * x[2] ** 3``, + etc.). Default is False. + include_bias (bool, optional): If True, then include a bias column, the feature + in which all polynomial powers are zero (i.e., a column of ones - acts as an + intercept term in a linear model). Default is True. + order (str in {'C', 'F'}, optional): Order of output array in the dense case. + 'F' order is faster to compute, but may slow down subsequent estimators. + Default is 'C'. + + Raises: + ValueError: If degree is less than 1. + """ + + def __init__(self, degree=2, interaction_only=False, include_bias=True, order="C"): + """ + Initialize the Polynomial object. + + Args: + degree (int, optional): The degree of the polynomial features. Default is 2. + interaction_only (bool, optional): If True, only interaction features are + produced: features that are products of at most ``degree`` *distinct* + input features (so not ``x[1] ** 2``, ``x[0] * x[2] ** 3``, + etc.). Default is False. + include_bias (bool, optional): If True, then include a bias column, the + feature in which all polynomial powers are zero (i.e., a column of + ones - acts as an intercept term in a linear model). Default is True. + order (str in {'C', 'F'}, optional): Order of output array in the dense + case. 'F' order is faster to compute, but may slow down subsequent + estimators. Default is 'C'. + + Raises: + ValueError: If degree is less than 1. + """ + if degree == 0: + raise ValueError( + "degree must be at least 1, otherwise inverse cannot be " "computed" + ) + super(Polynomial, self).__init__( + degree=degree, + interaction_only=interaction_only, + include_bias=include_bias, + order=order, + ) + self.include_state = True + + def fit(self, x, y=None): + """ + Compute number of output features. + + This method fits the `Polynomial` instance to the input data `x`. It calls the + `fit` method of the superclass (`PolynomialFeatures` from + `sklearn.preprocessing`), which computes the number of output features based + on the degree of the polynomial and the interaction_only flag. It also sets + `n_input_features_` and `n_output_features_` attributes. Then, it initializes + `measurement_matrix_` as a zero matrix of size `n_input_features_` by + `n_output_features_` and sets the main diagonal to 1, depending on the + `include_bias` attribute. The input `y` is not used in this method; it is + only included to maintain compatibility with the usual interface of `fit` + methods in scikit-learn. + + Args: + x (np.ndarray): The measurement data to be fit, with shape (n_samples, + n_features). + y (array-like, optional): Dummy input. Defaults to None. + + Returns: + self: A fit instance of `Polynomial`. + + Raises: + ValueError: If the input data is not valid. + """ + x = validate_input(x) + self.n_consumed_samples = 0 + + y_poly_out = super(Polynomial, self).fit(x.real, y) + + self.measurement_matrix_ = np.zeros([x.shape[1], y_poly_out.n_output_features_]) + if self.include_bias: + self.measurement_matrix_[:, 1 : 1 + x.shape[1]] = np.eye(x.shape[1]) + else: + self.measurement_matrix_[:, : x.shape[1]] = np.eye(x.shape[1]) + + return y_poly_out + + def transform(self, x): + """ + Transforms the data to polynomial features. + + This method transforms the data `x` into polynomial features. It first checks if + the fit method has been called by checking the `n_input_features_` attribute, + then it validates the input `x`. If `x` is a CSR sparse matrix and the degree is + less than 4, it uses a method based on "Leveraging Sparsity to Speed Up + Polynomial Feature Expansions of CSR Matrices Using K-Simplex Numbers" by + Andrew Nystrom and John Hughes. If `x` is a CSC sparse matrix and the degree + is less than 4, it converts `x` to CSR, generates the polynomial features, + then converts back to CSC. For dense arrays or CSC sparse matrix with a + degree of 4 or more, it generates the polynomial features through a slower + process. + + Args: + x (array-like or CSR/CSC sparse matrix): The data to transform, row by row. + The shape should be (n_samples, n_features). Prefer CSR over CSC for + sparse input (for speed), but CSC is required if the degree is 4 or higher. + + Returns: + xp (np.ndarray or CSR/CSC sparse matrix): The matrix of features, where + n_output_features is the number of polynomial features generated from the + combination of inputs. The shape is (n_samples, n_output_features). + + Raises: + ValueError: If the input data is not valid or the shape of `x` does not + match training shape. + """ + if isinstance(x, list): + return [self.transform(x_trial) for x_trial in x] + + if x.ndim == 3: + return np.array([self.transform(x_trial) for x_trial in x]) + + check_is_fitted(self, "n_input_features_") + + x = check_array(x, order="F", dtype=FLOAT_DTYPES, accept_sparse=("csr", "csc")) + + n_samples, n_features = x.shape + + if n_features != self.n_input_features_: + raise ValueError("x shape does not match training shape") + + if sparse.isspmatrix_csr(x): + if self.degree > 3: + return self.transform(x.tocsc()).tocsr() + to_stack = [] + if self.include_bias: + to_stack.append(np.ones(shape=(n_samples, 1), dtype=x.dtype)) + to_stack.append(x) + for deg in range(2, self.degree + 1): + xp_next = _csr_polynomial_expansion( + x.data, + x.indices, + x.indptr, + x.shape[1], + self.interaction_only, + deg, + ) + if xp_next is None: + break + to_stack.append(xp_next) + xp = sparse.hstack(to_stack, format="csr") + elif sparse.isspmatrix_csc(x) and self.degree < 4: + return self.transform(x.tocsr()).tocsc() + else: + combinations = self._combinations( + n_features, + self.degree, + self.interaction_only, + self.include_bias, + ) + if sparse.isspmatrix(x): + columns = [] + for comb in combinations: + if comb: + out_col = 1 + for col_idx in comb: + out_col = x[:, col_idx].multiply(out_col) + columns.append(out_col) + else: + bias = sparse.csc_matrix(np.ones((x.shape[0], 1))) + columns.append(bias) + xp = sparse.hstack(columns, dtype=x.dtype).tocsc() + else: + xp = np.empty( + (n_samples, self.n_output_features_), + dtype=x.dtype, + order=self.order, + ) + for i, comb in enumerate(combinations): + xp[:, i] = x[:, comb].prod(1) + + return xp + + @staticmethod + def _combinations(n_features, degree, interaction_only, include_bias): + """ + Generate combinations for polynomial features. + + This static method generates combinations of features for the polynomial + transformation. The combinations depend on whether interaction_only is set + and whether a bias term should be included. + + Args: + n_features (int): The number of features. + degree (int): The degree of the polynomial. + interaction_only (bool): If True, only interaction features are produced. + include_bias (bool): If True, a bias column is included. + + Returns: + itertools.chain: An iterable over all combinations. + """ + comb = combinations if interaction_only else combinations_w_r + start = int(not include_bias) + return chain.from_iterable( + comb(range(n_features), i) for i in range(start, degree + 1) + ) + + @property + def powers_(self): + """ + Get the exponent for each of the inputs in the output. + + This property method returns the exponents for each input feature in the + polynomial output. It first checks whether the model has been fitted, then + uses the `_combinations` method to get the combinations of features, and + finally calculates the exponents for each input feature. + + Returns: + np.ndarray: A 2D array where each row represents a feature and each + column represents an output of the polynomial transformation. The + values are the exponents of the input features. + + Raises: + NotFittedError: If the model has not been fitted. + """ + check_is_fitted(self) + + combinations = self._combinations( + n_features=self.n_input_features_, + degree=self.degree, + interaction_only=self.interaction_only, + include_bias=self.include_bias, + ) + return np.vstack( + [np.bincount(c, minlength=self.n_input_features_) for c in combinations] + ) diff --git a/DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py b/DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py new file mode 100644 index 0000000..217f485 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py @@ -0,0 +1,293 @@ +"""module for Radial basis function observables""" +from __future__ import annotations + +import numpy as np +from numpy import empty +from numpy import random +from sklearn.utils.validation import check_is_fitted + +from ..common import validate_input +from ._base import BaseObservables + + +class RadialBasisFunction(BaseObservables): + """ + This class represents Radial Basis Functions (RBF) used as observables. + Observables are formed as RBFs of the state variables, interpreted as new state + variables. + + For instance, a single state variable :math:`[x(t)]` could be evaluated using + multiple centers, yielding a new set of observables. This implementation supports + various types of RBFs including 'gauss', 'thinplate', 'invquad', 'invmultquad', + and 'polyharmonic'. + + Attributes: + rbf_type (str): The type of radial basis functions to be used. + n_centers (int): The number of centers to compute RBF with. + centers (numpy array): The centers to compute RBF with. + kernel_width (float): The kernel width for Gaussian RBFs. + polyharmonic_coeff (float): The polyharmonic coefficient for polyharmonic RBFs. + include_state (bool): Whether to include the input coordinates as additional + coordinates in the observable. + n_input_features_ (int): Number of input features. + n_output_features_ (int): Number of output features = Number of centers plus + number of input features. + + Note: + The implementation is based on the following references: + - Williams, Matthew O and Kevrekidis, Ioannis G and Rowley, Clarence W + "A data-driven approximation of the {K}oopman operator: extending dynamic + mode decomposition." + Journal of Nonlinear Science 6 (2015): 1307-1346 + - Williams, Matthew O and Rowley, Clarence W and Kevrekidis, Ioannis G + "A Kernel Approach to Data-Driven {K}oopman Spectral Analysis." + Journal of Computational Dynamics 2.2 (2015): 247-265 + - Korda, Milan and Mezic, Igor + "Linear predictors for nonlinear dynamical systems: Koopman operator meets + model predictive control." + Automatica 93 (2018): 149-160 + """ + + def __init__( + self, + rbf_type="gauss", + n_centers=10, + centers=None, + kernel_width=1.0, + polyharmonic_coeff=1.0, + include_state=True, + ): + super().__init__() + if type(rbf_type) != str: + raise TypeError("rbf_type must be a string") + if type(n_centers) != int: + raise TypeError("n_centers must be an int") + if n_centers < 0: + raise ValueError("n_centers must be a nonnegative int") + if kernel_width < 0: + raise ValueError("kernel_width must be a nonnegative float") + if polyharmonic_coeff < 0: + raise ValueError("polyharmonic_coeff must be a nonnegative float") + if rbf_type not in [ + "thinplate", + "gauss", + "invquad", + "invmultquad", + "polyharmonic", + ]: + raise ValueError("rbf_type not of available type") + if type(include_state) != bool: + raise TypeError("include_states must be a boolean") + if centers is not None: + if int(n_centers) not in centers.shape: + raise ValueError( + "n_centers is not equal to centers.shape[1]. " + "centers must be of shape (n_input_features, " + "n_centers). " + ) + self.rbf_type = rbf_type + self.n_centers = int(n_centers) + self.centers = centers + self.kernel_width = kernel_width + self.polyharmonic_coeff = polyharmonic_coeff + self.include_state = include_state + + def fit(self, x, y=None): + """ + Initializes the RadialBasisFunction with specified parameters. + + Args: + rbf_type (str, optional): The type of radial basis functions to be used. + Options are: 'gauss', 'thinplate', 'invquad', 'invmultquad', + 'polyharmonic'. Defaults to 'gauss'. + n_centers (int, optional): The number of centers to compute RBF with. + Must be a non-negative integer. Defaults to 10. + centers (numpy array, optional): The centers to compute RBF with. + If provided, it should have a shape of (n_input_features, n_centers). + Defaults to None, in which case the centers are uniformly distributed + over input data. + kernel_width (float, optional): The kernel width for Gaussian RBFs. + Must be a non-negative float. Defaults to 1.0. + polyharmonic_coeff (float, optional): The polyharmonic coefficient for + polyharmonic RBFs. Must be a non-negative float. Defaults to 1.0. + include_state (bool, optional): Whether to include the input coordinates + as additional coordinates in the observable. Defaults to True. + + Raises: + TypeError: If rbf_type is not a string, n_centers is not an int, or + include_state is not a bool. + ValueError: If n_centers, kernel_width or polyharmonic_coeff is negative, + rbf_type is not of available type, or centers is provided but + n_centers is not equal to centers.shape[1]. + """ + x = validate_input(x) + n_samples, n_features = x.shape + self.n_consumed_samples = 0 + + self.n_samples_ = n_samples + self.n_input_features_ = n_features + if self.include_state is True: + self.n_output_features_ = n_features * 1 + self.n_centers + elif self.include_state is False: + self.n_output_features_ = self.n_centers + + x = validate_input(x) + + if x.shape[1] != self.n_input_features_: + raise ValueError( + "Wrong number of input features. " + f"Expected x.shape[1] = {self.n_input_features_}; " + f"instead x.shape[1] = {x.shape[1]}." + ) + + if self.centers is None: + # Uniformly distributed centers + self.centers = random.rand(self.n_input_features_, self.n_centers) + # Change range to range of input features' range + for feat in range(self.n_input_features_): + xminmax = self._minmax(x[:, feat]) + + # Map to range [0,1] + self.centers[feat, :] = ( + self.centers[feat, :] - min(self.centers[feat, :]) + ) / (max(self.centers[feat, :]) - min(self.centers[feat, :])) + # Scale to input features' range + self.centers[feat, :] = ( + self.centers[feat, :] * (xminmax[1] - xminmax[0]) + xminmax[0] + ) + + xlift = self._rbf_lifting(x) + # self.measurement_matrix_ = x.T @ np.linalg.pinv(xlift.T) + self.measurement_matrix_ = np.linalg.lstsq(xlift, x)[0].T + + return self + + def transform(self, x): + """ + Apply radial basis function transformation to the data. + + Args: + x (array-like): Measurement data to be transformed, with shape (n_samples, + n_input_features). It is assumed that rows correspond to examples, + which are not required to be equi-spaced in time or in sequential order. + + Returns: + array-like: Transformed data, with shape (n_samples, n_output_features). + + Raises: + NotFittedError: If the 'fit' method has not been called before the + 'transform' method. + ValueError: If the number of features in 'x' does not match the number of + input features expected by the transformer. + """ + check_is_fitted(self, ["n_input_features_", "centers"]) + if isinstance(x, list): + return [self.transform(x_trial) for x_trial in x] + + if x.ndim == 3: + return np.array([self.transform(x_trial) for x_trial in x]) + + x = validate_input(x) + + if x.shape[1] != self.n_input_features_: + raise ValueError( + "Wrong number of input features. " + f"Expected x.shape[1] = {self.n_input_features_}; " + f"instead x.shape[1] = {x.shape[1]}." + ) + + y = self._rbf_lifting(x) + return y + + def get_feature_names(self, input_features=None): + """ + Get the names of the output features. + + Args: + input_features (list of str, optional): String names for input features, + if available. By default, the names "x0", "x1", ... , + "xn_input_features" are used. + + Returns: + list of str: Output feature names. + + Raises: + NotFittedError: If the 'fit' method has not been called before the + 'get_feature_names' method. + ValueError: If the length of 'input_features' does not match the number of + input features expected by the transformer. + """ + + check_is_fitted(self, "n_input_features_") + if input_features is None: + input_features = [f"x{i}" for i in range(self.n_input_features_)] + else: + if len(input_features) != self.n_input_features_: + raise ValueError( + "input_features must have n_input_features_ " + f"({self.n_input_features_}) elements" + ) + + output_features = [] + if self.include_state is True: + output_features.extend([f"{xi}(t)" for xi in input_features]) + output_features.extend([f"phi(x(t)-c{i})" for i in range(self.n_centers)]) + return output_features + + def _rbf_lifting(self, x): + """ + Internal method that performs Radial Basis Function (RBF) transformation. + + Args: + x (numpy.ndarray): Input data of shape (n_samples, n_input_features) + + Returns: + y (numpy.ndarray): Transformed data of shape (n_samples, n_output_features) + + Raises: + ValueError: If 'rbf_type' is not one of the available types. + + Notes: + This method should not be called directly. It is used internally by the + 'transform' method. + """ + n_samples = x.shape[0] + y = empty( + (n_samples, self.n_output_features_), + dtype=x.dtype, + ) + + y_index = 0 + if self.include_state is True: + y[:, : self.n_input_features_] = x + y_index = self.n_input_features_ + + for index_of_center in range(self.n_centers): + C = self.centers[:, index_of_center] + r_squared = np.sum((x - C[np.newaxis, :]) ** 2, axis=1) + + if self.rbf_type == "thinplate": + y_ = r_squared * np.log(np.sqrt(r_squared)) + y_[np.isnan(y_)] = 0 + elif self.rbf_type == "gauss": + y_ = np.exp(-self.kernel_width**2 * r_squared) + elif self.rbf_type == "invquad": + y_ = np.reciprocal(1 + self.kernel_width**2 * r_squared) + elif self.rbf_type == "invmultquad": + y_ = np.reciprocal(np.sqrt(1 + self.kernel_width**2 * r_squared)) + elif self.rbf_type == "polyharmonic": + y_ = r_squared ** (self.polyharmonic_coeff / 2) * np.log( + np.sqrt(r_squared) + ) + else: + # if none of the above cases match: + raise ValueError("provided rbf_type not available") + + y[:, y_index + index_of_center] = y_ + + return y + + def _minmax(self, x): + min_val = min(x) + max_val = max(x) + return (min_val, max_val) diff --git a/DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py b/DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py new file mode 100644 index 0000000..a9ebec7 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py @@ -0,0 +1,193 @@ +"""module for random fourier features observables""" +from __future__ import annotations + +import numpy as np +from sklearn.utils.validation import check_is_fitted + +from ..common import validate_input +from ._base import BaseObservables + + +class RandomFourierFeatures(BaseObservables): + """ + Random Fourier Features for observables. + + This class applies the random Fourier features method for kernel approximation. + It can include the system state in the kernel function. It uses the + Gaussian kernel by default. + + Args: + include_state (bool, optional): If True, includes the system state. Defaults to + True. + gamma (float, optional): The scale of the Gaussian kernel. Defaults to 1.0. + D (int, optional): The number of random samples in Monte Carlo approximation. + Defaults to 100. + random_state (int, None, optional): The seed of the random number for repeatable + experiments. Defaults to None. + + Attributes: + include_state (bool): If True, includes the system state. + gamma (float): The scale of the Gaussian kernel. + D (int): The number of random samples in Monte Carlo approximation. + random_state (int, None): The seed of the random number for repeatable + experiments. + measurement_matrix_ (numpy.ndarray): A row feature vector right multiply with + `measurement_matrix_` will return the system state. + n_input_features_ (int): Dimension of input features, e.g., system state. + n_output_features_ (int): Dimension of transformed/output features, e.g., + observables. + w (numpy.ndarray): The frequencies randomly sampled for random fourier features. + """ + + def __init__(self, include_state=True, gamma=1.0, D=100, random_state=None): + """ + Initialize the RandomFourierFeatures class with given parameters. + + Args: + include_state (bool, optional): If True, includes the system state. + Defaults to True. + gamma (float, optional): The scale of the Gaussian kernel. Defaults to 1.0. + D (int, optional): The number of random samples in Monte Carlo + approximation. Defaults to 100. + random_state (int or None, optional): The seed of the random number + for repeatable experiments. Defaults to None. + """ + super(RandomFourierFeatures, self).__init__() + self.include_state = include_state + self.gamma = gamma + self.D = D + self.random_state = random_state + + def fit(self, x, y=None): + """ + Set up observable. + + Args: + x (numpy.ndarray): Measurement data to be fit. Shape (n_samples, + n_input_features_). + y (numpy.ndarray, optional): Time-shifted measurement data to be fit. + Defaults to None. + + Returns: + self: Returns a fitted RandomFourierFeatures instance. + """ + x = validate_input(x) + np.random.seed(self.random_state) + self.n_consumed_samples = 0 + + self.n_input_features_ = x.shape[1] + # although we have double the output dim, the convergence + # rate is described in only self.n_components + self.n_output_features_ = 2 * self.D + + if self.include_state is True: + self.n_output_features_ += self.n_input_features_ + + # 1. generate (n_feature, n_component) random w + self.w = np.sqrt(2.0 * self.gamma) * np.random.normal( + 0, 1, [self.n_input_features_, self.D] + ) + + # 3. get the C to map back to state + if self.include_state: + self.measurement_matrix_ = np.zeros( + (self.n_input_features_, self.n_output_features_) + ) + self.measurement_matrix_[ + : self.n_input_features_, : self.n_input_features_ + ] = np.eye(self.n_input_features_) + else: + # we have to transform the data x in order to find a matrix by fitting + # z = np.zeros((x.shape[0], self.n_output_features_)) + # z[:,:x.shape[1]] = x + # z[:,x.shape[1]:] = self._rff_lifting(x) + z = self._rff_lifting(x) + self.measurement_matrix_ = np.linalg.lstsq(z, x)[0].T + + return self + + def transform(self, x): + """ + Evaluate observable at `x`. + + Args: + x (numpy.ndarray): Measurement data to be fit. Shape (n_samples, + n_input_features_). + + Returns: + y (numpy.ndarray): Evaluation of observables at `x`. Shape (n_samples, + n_output_features_). + """ + + check_is_fitted(self, "n_input_features_") + if isinstance(x, list): + return [self.transform(x_trial) for x_trial in x] + + if x.ndim == 3: + return np.array([self.transform(x_trial) for x_trial in x]) + + z = np.zeros((x.shape[0], self.n_output_features_)) + z_rff = self._rff_lifting(x) + if self.include_state: + z[:, : x.shape[1]] = x + z[:, x.shape[1] :] = z_rff + else: + z = z_rff + + return z + + def get_feature_names(self, input_features=None): + """ + Return names of observables. + + Args: + input_features (list of string of length n_features, optional): + Default list is "x0", "x1", ..., "xn", where n = n_features. + + Returns: + output_feature_names (list of string of length n_output_features): + Returns a list of observable names. + """ + + check_is_fitted(self, "n_input_features_") + + if input_features is None: + input_features = [f"x{i}" for i in range(self.n_input_features_)] + else: + if len(input_features) != self.n_input_features_: + raise ValueError( + "input_features must have n_input_features_ " + f"({self.n_input_features_}) elements" + ) + + if self.include_state: + # very easy to make mistake... python pass list by reference OMG + output_features = input_features[:] + else: + output_features = [] + output_features += [f"cos(w_{i}'x)/sqrt({self.D})" for i in range(self.D)] + [ + f"sin(w_{i}'x)/sqrt({self.D})" for i in range(self.D) + ] + + return output_features + + def _rff_lifting(self, x): + """ + Core algorithm that computes random Fourier features. + + This method uses the `cos` and `sin` transformations to get random Fourier + features. + + Args: + x (numpy.ndarray): System state. + + Returns: + z_rff (numpy.ndarray): Random Fourier features evaluated on `x`. Shape + (n_samples, n_output_features_). + """ + + # 2. get the feature vector z + xw = np.dot(x, self.w) + z_rff = np.hstack([np.cos(xw), np.sin(xw)]) + z_rff *= 1.0 / np.sqrt(self.D) + return z_rff diff --git a/DSA/pykoopman/src/pykoopman/observables/_time_delay.py b/DSA/pykoopman/src/pykoopman/observables/_time_delay.py new file mode 100644 index 0000000..eb0c9db --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/observables/_time_delay.py @@ -0,0 +1,216 @@ +"""moduel for time-delay observables""" +from __future__ import annotations + +import numpy as np +from numpy import arange +from numpy import empty +from sklearn.utils.validation import check_is_fitted + +from ..common import validate_input +from ._base import BaseObservables + + +class TimeDelay(BaseObservables): + """ + A class for creating time-delay observables. These observables are formed by + taking time-lagged measurements of state variables and interpreting them as new + state variables. + + The two state variables :math:`[x(t), y(t)]` could be supplemented with two + time-delays each, yielding a new set of observables: + + .. math:: + [x(t), y(t), x(t-\\Delta$ t), y(t-\\Delta t), + x(t-2\\Delta t), y(t - 2\\Delta t)] + + This example corresponds to taking :code:`delay =` :math:`\\Delta t` and + :code:`n_delays = 2`. + + Note that when transforming data the first :code:`delay * n_delays` rows/samples + are dropped as there is insufficient time history to form time-delays for them. + + For more information, see the following references: + + Brunton, Steven L., et al. + "Chaos as an intermittently forced linear system." + Nature communications 8.1 (2017): 1-9. + + Susuki, Yoshihiko, and Igor Mezić. + "A prony approximation of Koopman mode decomposition." + 2015 54th IEEE Conference on Decision and Control (CDC). IEEE, 2015. + + Arbabi, Hassan, and Igor Mezic. + "Ergodic theory, dynamic mode decomposition, and computation + of spectral properties of the Koopman operator." + SIAM Journal on Applied Dynamical Systems 16.4 (2017): 2096-2126. + + Args: + delay (int, optional): The length of each delay. Defaults to 1. + n_delays (int, optional): The number of delays to compute for each + variable. Defaults to 2. + + Attributes: + include_state (bool): If True, includes the system state. + delay (int): The length of each delay. + n_delays (int): The number of delays to compute for each variable. + _n_consumed_samples (int): Number of samples consumed when :code:`transform` + is called,i.e. :code:`n_delays * delay`. + """ + + def __init__(self, delay=1, n_delays=2): + """ + Initialize the TimeDelay class with given parameters. + + Args: + delay (int, optional): The length of each delay. Defaults to 1. Or + we say this is the "stride of delay". + n_delays (int, optional): The number of delays to compute for each + variable. Defaults to 2. + + Raises: + ValueError: If delay or n_delays are negative. + """ + super(TimeDelay, self).__init__() + if delay < 0: + raise ValueError("delay must be a nonnegative int") + if n_delays < 0: + raise ValueError("n_delays must be a nonnegative int") + + self.include_state = True + self.delay = int(delay) + self.n_delays = int(n_delays) + self._n_consumed_samples = self.delay * self.n_delays + + def fit(self, x, y=None): + """ + Fit the model to measurement data. + + Args: + x (array-like): The input data, shape (n_samples, n_input_features). + y (None): Dummy parameter for sklearn compatibility. + + Returns: + TimeDelay: The fitted instance. + """ + + x = validate_input(x) + n_samples, n_features = x.shape + + self.n_input_features_ = n_features + self.n_output_features_ = n_features * (1 + self.n_delays) + + self.measurement_matrix_ = np.zeros( + (self.n_input_features_, self.n_output_features_) + ) + self.measurement_matrix_[ + : self.n_input_features_, : self.n_input_features_ + ] = np.eye(self.n_input_features_) + + return self + + def transform(self, x): + """ + Add time-delay features to the data, dropping the first :code:`delay - + n_delays` samples. + + Args: + x (array-like): The input data, shape (n_samples, n_input_features). + It is assumed that rows correspond to examples that are equi-spaced + in time and are in sequential order. + + Returns: + y (array-like): The transformed data, shape (n_samples - delay * n_delays, + n_output_features). + """ + check_is_fitted(self, "n_input_features_") + + if isinstance(x, list): + return [self.transform(x_trial) for x_trial in x] + + if x.ndim == 3: + return np.array([self.transform(x_trial) for x_trial in x]) + + x = validate_input(x) + + if x.shape[-1] != self.n_input_features_: + raise ValueError( + "Wrong number of input features. " + f"Expected x.shape[1] = {self.n_input_features_}; " + f"instead x.shape[1] = {x.shape[1]}." + ) + + self._n_consumed_samples = self.delay * self.n_delays + if len(x) < self._n_consumed_samples + 1: + raise ValueError( + "x has too few rows. To compute time-delay features with " + f"delay = {self.delay} and n_delays = {self.n_delays} " + f"x must have at least {self._n_consumed_samples + 1} rows." + ) + + y = empty( + (x.shape[0] - self._n_consumed_samples, self.n_output_features_), + dtype=x.dtype, + ) + y[:, : self.n_input_features_] = x[self._n_consumed_samples :] + + for i in range(self._n_consumed_samples, x.shape[0]): + y[i - self._n_consumed_samples, self.n_input_features_ :] = x[ + self._delay_inds(i), : + ].flatten() + return y + + def get_feature_names(self, input_features=None): + """ + Get the names of the output features. + + Args: + input_features (list of str, optional): Names for input features. + If None, defaults to "x0", "x1", ... ,"xn_input_features". + + Returns: + list of str: Names of the output features. + """ + check_is_fitted(self, "n_input_features_") + if input_features is None: + input_features = [f"x{i}" for i in range(self.n_input_features_)] + else: + if len(input_features) != self.n_input_features_: + raise ValueError( + "input_features must have n_input_features_ " + f"({self.n_input_features_}) elements" + ) + + output_features = [f"{xi}(t)" for xi in input_features] + output_features.extend( + [ + f"{xi}(t-{i * self.delay}dt)" + for i in range(1, self.n_delays + 1) + for xi in input_features + ] + ) + + return output_features + + def _delay_inds(self, index): + """ + Private method to get the indices for the delayed data. + + Args: + index (int): The index from which to calculate the delay indices. + + Returns: + array-like: The delay indices. + """ + return index - self.delay * arange(1, self.n_delays + 1) + + @property + def n_consumed_samples(self): + """ + The number of samples that are consumed as "initial conditions" for + other samples, i.e., the number of samples for which time delays cannot + be computed. + + Returns: + int: The number of consumed samples. + """ + return self._n_consumed_samples diff --git a/DSA/pykoopman/src/pykoopman/regression/__init__.py b/DSA/pykoopman/src/pykoopman/regression/__init__.py new file mode 100644 index 0000000..4cbc09c --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/__init__.py @@ -0,0 +1,22 @@ +from __future__ import annotations + +from ._base import BaseRegressor +from ._base_ensemble import EnsembleBaseRegressor +from ._dmd import PyDMDRegressor +from ._dmdc import DMDc +from ._edmd import EDMD +from ._edmdc import EDMDc +from ._havok import HAVOK +from ._kdmd import KDMD +from ._nndmd import NNDMD + +__all__ = [ + "PyDMDRegressor", + "EDMD", + "KDMD", + "DMDc", + "EDMDc", + "EnsembleBaseRegressor", + "HAVOK", + "NNDMD", +] diff --git a/DSA/pykoopman/src/pykoopman/regression/_base.py b/DSA/pykoopman/src/pykoopman/regression/_base.py new file mode 100644 index 0000000..6c49394 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_base.py @@ -0,0 +1,163 @@ +"""module for base class of regressor""" +from __future__ import annotations + +from abc import ABC +from abc import abstractmethod + +import numpy as np +from sklearn.base import BaseEstimator + + +class BaseRegressor(BaseEstimator, ABC): + """ + Base class for PyKoopman regressors. + + This class provides a wrapper for regressors used in the PyKoopman package. + It's designed to be used with any regressor object that implements `fit` + and `predict` methods following the `sklearn.base.BaseEstimator` interface. + + Note: This is an abstract base class, and should not be instantiated directly. + Instead, a subclass should be created that implements the required abstract methods. + + Args: + regressor (BaseEstimator): A regressor object implementing `fit` and `predict` + methods. + + Attributes: + regressor (BaseEstimator): The regressor object passed during initialization. + + Abstract methods: + coef_ : Should return the coefficients of the regression model. + + state_matrix_ : Should return the state matrix of the dynamic system. + + eigenvectors_ : Should return the eigenvectors of the system. + + eigenvalues_ : Should return the eigenvalues of the system. + + _compute_phi(x_col) : Should compute and return the phi function on given data. + + _compute_psi(x_col) : Should compute and return the psi function on given data. + + ur : Should return the u_r of the system. + + unnormalized_modes : Should return the unnormalized modes of the system. + """ + + def __init__(self, regressor): + # check .fit + if not hasattr(regressor, "fit") or not callable(getattr(regressor, "fit")): + raise AttributeError("regressor does not have a callable fit method") + # check .predict + if not hasattr(regressor, "predict") or not callable( + getattr(regressor, "predict") + ): + raise AttributeError("regressor does not have a callable predict method") + self.regressor = regressor + + def _detect_reshape(self, X, offset=True): + """ + Detect the shape of the input data and reshape it accordingly to return + both X and Y in the correct shape. + """ + s1 = -1 if offset else None + s2 = 1 if offset else None + if isinstance(X, np.ndarray): + if X.ndim == 1: + X = X.reshape(-1, 1) + + if X.ndim == 2: + self.n_samples_, self.n_input_features_ = X.shape + self.n_trials_ = 1 + return X[:s1], X[s2:] + elif X.ndim == 3: + self.n_trials_, self.n_samples_, self.n_input_features_ = X.shape + X, Y = X[:, :s1, :], X[:, s2:, :] + return X.reshape(-1, X.shape[2]), Y.reshape( + -1, Y.shape[2] + ) # time*trials, features + + elif isinstance(X, list): + assert all(isinstance(x, np.ndarray) for x in X) + self.n_trials_tot, self.n_samples_tot, self.n_input_features_tot = ( + [], + [], + [], + ) + X_tot, Y_tot = [], [] + for x in X: + x, y = self._detect_reshape(x) + X_tot.append(x) + Y_tot.append(y) + self.n_trials_tot.append(self.n_trials_) + self.n_samples_tot.append(self.n_samples_) + self.n_input_features_tot.append(self.n_input_features_) + X = np.concatenate(X_tot, axis=0) + Y = np.concatenate(Y_tot, axis=0) + + self.n_trials_ = sum(self.n_trials_tot) + self.n_samples_ = sum(self.n_samples_tot) + self.n_input_features_ = sum(self.n_input_features_tot) + + return X, Y + + def _return_orig_shape(self, X): + """ + X will be a 2d array of shape (n_samples * n_trials, n_features). + This function will return the original shape of X. + """ + if not hasattr(self, "n_trials_tot"): + X = X.reshape(self.n_trials_, -1, self.n_input_features_) + if X.shape[0] == 1: + X = X[0] + return X + + else: + X_tot = [] + prev_t = 0 + for i in range(len(self.n_trials_tot)): + X_i = X[prev_t : prev_t + self.n_trials_tot[i] * self.n_samples_tot[i]] + X_i = X_i.reshape( + self.n_trials_tot[i], -1, self.n_input_features_tot[i] + ) + X_tot.append(X_i) + prev_t += self.n_trials_tot[i] * self.n_samples_tot[i] + return X_tot + + def fit(self, x, y=None): + raise NotImplementedError + + def predict(self, x): + raise NotImplementedError + + @abstractmethod + def coef_(self): + pass + + @abstractmethod + def state_matrix_(self): + pass + + @abstractmethod + def eigenvectors_(self): + pass + + @abstractmethod + def eigenvalues_(self): + pass + + @abstractmethod + def _compute_phi(self, x_col): + pass + + @abstractmethod + def _compute_psi(self, x_col): + pass + + @abstractmethod + def ur(self): + pass + + @abstractmethod + def unnormalized_modes(self): + pass diff --git a/DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py b/DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py new file mode 100644 index 0000000..53f7f16 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py @@ -0,0 +1,366 @@ +"""module for handling a ensemble of x-x' pair. + +Manual changes are made to add support to complex numeric data +""" +from __future__ import annotations + +from sklearn.base import BaseEstimator +from sklearn.base import clone +from sklearn.base import TransformerMixin +from sklearn.compose import TransformedTargetRegressor + + +class EnsembleBaseRegressor(TransformedTargetRegressor): + """ + This class serves as a wrapper for PyKoopman regressors that utilize ensemble or + non-consecutive training data. + + `EnsembleBaseRegressor` inherits from `TransformedTargetRegressor` and checks + whether the provided regressor object implements the `fit` and `predict` methods. + + Attributes: + regressor (sklearn.base.BaseEstimator): A regressor object that implements + `fit` and `predict` methods. + func (function): A function to apply to the target `y` before passing it to + the `fit` method. The function must return a 2-dimensional array. + If `func` is `None`, the identity function is used. + inverse_func (function): A function to apply to the prediction of the + regressor. This function is used to return predictions to the same space + as the original training labels. It must return a 2-dimensional array. + + Raises: + AttributeError: If the regressor does not have a callable `fit` or + `predict` method. + ValueError: If both `transformer` and functions `func`/`inverse_func` + are set, or if 'func' is provided while 'inverse_func' is not. + + Note: + This class does not implement the `fit` method on its own, instead, it checks + the methods of the provided regressor object and raises an AttributeError if + the required methods are not present or not callable. It also performs some + pre-processing on the target values `y` before fitting the regressor, and + provides additional checks and warnings for the transformer and inverse + functions. + """ + + def __init__(self, regressor, func, inverse_func): + super().__init__(regressor=regressor, func=func, inverse_func=inverse_func) + if not hasattr(regressor, "fit") or not callable(getattr(regressor, "fit")): + raise AttributeError("regressor does not have a callable fit method") + if not hasattr(regressor, "predict") or not callable( + getattr(regressor, "predict") + ): + raise AttributeError("regressor does not have a callable predict method") + + def fit(self, X, y, **fit_params): + """ + Fits the model according to the given training data. + + Args: + X (array-like or sparse matrix of shape (n_samples, n_features)): + Training vector, where `n_samples` is the number of samples and + `n_features` is the number of features. + y (array-like of shape (n_samples,)): Target values. + **fit_params (dict): Additional parameters passed to the `fit` method of + the underlying regressor. + + Returns: + self: The fitted estimator. + + Raises: + ValueError: If 'transformer' and functions 'func'/'inverse_func' are both + set, or if 'func' is provided while 'inverse_func' is not. + + Note: + This method transforms the target `y` before fitting the regressor and + performs additional checks and warnings for the transformer and inverse + functions. + """ + + # transformers are designed to modify X which is 2d dimensional, we + # need to modify y accordingly. + + self._training_dim = y.ndim + if y.ndim == 1: + y_2d = y.reshape(-1, 1) + else: + y_2d = y + self._fit_transformer(y_2d) + + # transform y and convert back to 1d array if needed + y_trans = self.transformer_.transform(y_2d) + # FIXME: a FunctionTransformer can return a 1D array even when validate + # is set to True. Therefore, we need to check the number of dimension + # first. + # if y_trans.ndim == 2 and y_trans.shape[1] == 1: + # y_trans = y_trans.squeeze(axis=1) + + if self.regressor is None: + from sklearn.linear_model import LinearRegression + + self.regressor_ = LinearRegression() + else: + self.regressor_ = clone(self.regressor) + + self.regressor_.fit(X, y_trans, **fit_params) + + if hasattr(self.regressor_, "feature_names_in_"): + self.feature_names_in_ = self.regressor_.feature_names_in_ + + return self + + def _fit_transformer(self, y): + """ + Checks the transformer and fits it. + + This method creates the default transformer if necessary, fits it, and + performs additional inverse checks on a subset (optional). + + Args: + y (array-like): The target values. + + Raises: + ValueError: If both 'transformer' and functions 'func'/'inverse_func' + are set, or if 'func' is provided while 'inverse_func' is not. + + Note: + The method does not currently pass 'sample_weight' to the transformer. + However, if the transformer starts using 'sample_weight', the code should + be modified accordingly. During the consideration of the 'sample_prop' + feature, this is also a good use case to consider. + """ + if self.transformer is not None and ( + self.func is not None or self.inverse_func is not None + ): + raise ValueError( + "'transformer' and functions 'func'/'inverse_func' cannot both be set." + ) + elif self.transformer is not None: + self.transformer_ = clone(self.transformer) + else: + if self.func is not None and self.inverse_func is None: + raise ValueError( + "When 'func' is provided, 'inverse_func' must also be provided" + ) + self.transformer_ = FunctionTransformer( + func=self.func, + inverse_func=self.inverse_func, + validate=True, + check_inverse=self.check_inverse, + ) + # XXX: sample_weight is not currently passed to the + # transformer. However, if transformer starts using sample_weight, the + # code should be modified accordingly. At the time to consider the + # sample_prop feature, it is also a good use case to be considered. + self.transformer_.fit(y) + # if self.check_inverse: + # idx_selected = slice(None, None, max(1, y.shape[0] // 10)) + # y_sel = _safe_indexing(y, idx_selected) + # y_sel_t = self.transformer_.transform(y_sel) + # if not np.allclose(y_sel, self.transformer_.inverse_transform(y_sel_t)): + # warnings.warn( + # "The provided functions or transformer are" + # " not strictly inverse of each other. If" + # " you are sure you want to proceed regardless" + # ", set 'check_inverse=False'", + # UserWarning, + # ) + + +class FunctionTransformer(TransformerMixin, BaseEstimator): + """Constructs a transformer from an arbitrary callable. + + This class forwards its X (and optionally y) arguments to a user-defined function + or function object and returns the result of this function. This is useful for + stateless transformations such as taking the log of frequencies, doing custom + scaling, etc. + + Note: If a lambda is used as the function, then the resulting transformer will + not be pickleable. + + Attributes: + func (callable): The callable to use for the transformation. This will be + passed the same arguments as transform, with args and kwargs forwarded. + If func is None, then func will be the identity function. + inverse_func (callable): The callable to use for the inverse transformation. + This will be passed the same arguments as inverse transform, with args + and kwargs forwarded. If inverse_func is None, then inverse_func will be + the identity function. + validate (bool): Indicate that the input X array should be checked before + calling func. The default is False. + accept_sparse (bool): Indicate that func accepts a sparse matrix as input. + The default is False. + check_inverse (bool): Whether to check that or func followed by inverse_func + leads to the original inputs. The default is True. + kw_args (dict): Dictionary of additional keyword arguments to pass to func. + inv_kw_args (dict): Dictionary of additional keyword arguments to pass to + inverse_func. + n_input_features_ (int): Number of features seen during fit. Defined only + when validate=True. + feature_names_in_ (ndarray): Names of features seen during fit. Defined only + when validate=True and X has feature names that are all strings. + + Examples: + >>> import numpy as np + >>> from sklearn.preprocessing import FunctionTransformer + >>> transformer = FunctionTransformer(np.log1p) + >>> X = np.array([[0, 1], [2, 3]]) + >>> transformer.transform(X) + array([[0. , 0.6931...], + [1.0986..., 1.3862...]]) + """ + + def __init__( + self, + func=None, + inverse_func=None, + *, + validate=False, + accept_sparse=False, + check_inverse=True, + kw_args=None, + inv_kw_args=None, + ): + """Initialize the FunctionTransformer instance. + + Args: + func (callable, optional): The callable to use for the transformation. + This will be passed the same arguments as transform, with args and + kwargs forwarded. If func is None, then + func will be the identity function. Defaults to None. + inverse_func (callable, optional): The callable to use for the inverse + transformation. This will be passed the same arguments as inverse + transform, with args and kwargs forwarded. If inverse_func is None, then + inverse_func will be the identity function. Defaults to None. + validate (bool, optional): Indicate that the input X array should be + checked before calling func. Defaults to False. + accept_sparse (bool, optional): Indicate that func accepts a sparse matrix + as input. Defaults to False. + check_inverse (bool, optional): Whether to check that func followed by + inverse_func leads to the original inputs. Defaults to True. + kw_args (dict, optional): Dictionary of additional keyword arguments to + pass to func. Defaults to None. + inv_kw_args (dict, optional): Dictionary of additional keyword arguments + to pass to inverse_func. Defaults to None. + """ + self.func = func + self.inverse_func = inverse_func + self.validate = validate + self.accept_sparse = accept_sparse + self.check_inverse = check_inverse + self.kw_args = kw_args + self.inv_kw_args = inv_kw_args + + def _check_input(self, X, *, reset): + """Checks the input X. If validation is enabled, it validates the data. + + Args: + X (array-like): Input data to be checked/validated. + reset (bool): Flag indicating whether to reset the validation. + + Returns: + array-like: The original input data, possibly validated if `validate` + attribute is set to True. + """ + # if self.validate: + # return self._validate_data(X, accept_sparse=self.accept_sparse, + # reset=reset) + return X + + def _check_inverse_transform(self, X): + """Checks if the provided functions are the inverse of each other. + + Selects a subset of X and performs a round trip transformation: forward + transform followed by inverse transform. Raises a warning if the round trip + does not return the original inputs. + + Args: + X (array-like): Input data to be checked for inverse transform consistency. + """ + idx_selected = slice(None, None, max(1, X.shape[0] // 100)) + # X_round_trip = self.inverse_transform(self.transform(X[idx_selected])) + self.inverse_transform(self.transform(X[idx_selected])) + # if not _allclose_dense_sparse(X[idx_selected], X_round_trip): + # warnings.warn( + # "The provided functions are not strictly" + # " inverse of each other. If you are sure you" + # " want to proceed regardless, set" + # " 'check_inverse=False'.", + # UserWarning, + # ) + + def fit(self, X, y=None): + """Fits transformer by checking X. + + If ``validate`` is ``True``, ``X`` will be checked. Also checks if the provided + functions are the inverse of each other if `check_inverse` is set to True. + + Args: + X (array-like): The data to fit. Shape should be (n_samples, n_features). + y (None, optional): Ignored. Not used, present here for API consistency by + convention. + + Returns: + FunctionTransformer: The fitted transformer. + """ + X = self._check_input(X, reset=True) + if self.check_inverse and not (self.func is None or self.inverse_func is None): + self._check_inverse_transform(X) + return self + + def transform(self, X): + """Transforms X using the forward function. + + Args: + X (array-like): The data to transform. Shape should be (n_samples, + n_features). + + Returns: + array-like: Transformed data with same shape as input. + """ + X = self._check_input(X, reset=False) + return self._transform(X, func=self.func, kw_args=self.kw_args) + + def inverse_transform(self, X): + """Transforms X using the inverse function. + + Args: + X (array-like): The data to inverse transform. Shape should be + (n_samples, n_features). + + Returns: + array-like: Inverse transformed data with the same shape as input. + """ + # if self.validate: + # X = check_array(X, accept_sparse=self.accept_sparse) + return self._transform(X, func=self.inverse_func, kw_args=self.inv_kw_args) + + def _transform(self, X, func=None, kw_args=None): + """Applies the given function to the data X. + + Args: + X (array-like): The data to transform. Shape should be (n_samples, + n_features). + func (callable, optional): The function to apply. If None, identity + function is used. + kw_args (dict, optional): Additional arguments to pass to the function. + + Returns: + array-like: Transformed data with the same shape as input. + """ + if func is None: + func = _identity + + return func(X, **(kw_args if kw_args else {})) + + def __sklearn_is_fitted__(self): + """Return True since FunctionTransfomer is stateless.""" + return True + + def _more_tags(self): + return {"no_validation": not self.validate, "stateless": True} + + +def _identity(X): + """The identity function.""" + return X diff --git a/DSA/pykoopman/src/pykoopman/regression/_dmd.py b/DSA/pykoopman/src/pykoopman/regression/_dmd.py new file mode 100644 index 0000000..d447571 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_dmd.py @@ -0,0 +1,360 @@ +"""module for dmd""" +# from warnings import warn +from __future__ import annotations + +import numpy as np +from pydmd import DMDBase +from pydmd.dmdbase import DMDTimeDict +from pydmd.utils import compute_svd +from pydmd.utils import compute_tlsq +from scipy.linalg import eig +from scipy.linalg import sqrtm +from sklearn.utils.validation import check_is_fitted + +from ._base import BaseRegressor + + +class PyDMDRegressor(BaseRegressor): + """ + PyDMDRegressor is a wrapper for `pydmd` regressors. + + This class provides a wrapper for the `pydmd` regressor. The details about + `pydmd` can be found in the reference: + + Demo, N., Tezzele, M., & Rozza, G. (2018). PyDMD: Python dynamic mode decomposition. + Journal of Open Source Software, 3(22), 530. + `_ + + Args: + regressor (DMDBase): A regressor instance from DMDBase in `pydmd`. + tikhonov_regularization (bool or None, optional): Indicates if Tikhonov + regularization should be applied. Defaults to None. + + Attributes: + tlsq_rank (int): Rank for truncation in TLSQ method. If 0, no noise reduction + is computed. If positive, it is used for SVD truncation. + svd_rank (int): Rank for truncation. If 0, optimal rank is computed and used + for truncation. If positive integer, it is used for truncation. If float + between 0 and 1, the rank is the number of the biggest singular values + that are needed to reach the 'energy' specified by `svd_rank`. If -1, no + truncation is computed. + forward_backward (bool): If True, the low-rank operator is computed like in + fbDMD. + tikhonov_regularization (bool or None, optional): If None, no regularization + is applied. If float, it is used as the Tikhonov regularization parameter. + flag_xy (bool): If True, the regressor is operating on multiple trajectories + instead of just one. + n_samples_ (int): Number of samples. + n_input_features_ (int): Number of features, i.e., the dimension of phi. + _unnormalized_modes (ndarray): Raw DMD V with each column as one DMD mode. + _state_matrix_ (ndarray): DMD state transition matrix. + _reduced_state_matrix_ (ndarray): Reduced DMD state transition matrix. + _eigenvalues_ (ndarray): Identified Koopman lambda. + _eigenvectors_ (ndarray): Identified Koopman eigenvectors. + _coef_ (ndarray): Weight vectors of the regression problem. Corresponds to + either [A] or [A,B]. + C (ndarray): Matrix that maps psi to the input features. + """ + + def __init__(self, regressor, tikhonov_regularization=None): + """ + Initializes a PyDMDRegressor instance. + + Args: + regressor (DMDBase): A regressor instance from DMDBase in `pydmd`. + tikhonov_regularization (bool or None, optional): Indicates if Tikhonov + regularization should be applied. Defaults to None. + + Raises: + ValueError: If regressor is not a subclass of DMDBase from pydmd. + """ + if not isinstance(regressor, DMDBase): + raise ValueError("regressor must be a subclass of DMDBase from pydmd.") + self.regressor = regressor + # super(PyDMDRegressor, self).__init__(regressor) + self.tlsq_rank = regressor._tlsq_rank + self.svd_rank = regressor._Atilde._svd_rank + self.forward_backward = regressor._Atilde._forward_backward + self.tikhonov_regularization = tikhonov_regularization + self.flag_xy = False + self._ur = None + + def fit(self, x, y=None, dt=1): + """ + Fit the PyDMDRegressor model according to the given training data. + + Args: + x (np.ndarray): Measurement data input. Should be of shape (n_samples, + n_features). + Can also be of shape (n_trials, n_samples, n_features), where + n_trials is the number of independent trials. + Can also be of a list of arrays, where each array is a trajectory + or a 3d array of trajectories. + + y (np.ndarray, optional): Measurement data output to be fitted. Should be + of shape (n_samples, n_features). Defaults to None. + dt (float, optional): Time interval between `x` and `y`. Defaults to 1. + + Returns: + self : Returns the instance itself. + """ + + if y is None: + # single trajectory + self.flag_xy = False + X, Y = self._detect_reshape(x) + X = X.T + Y = Y.T + + else: + # multiple segments of trajectories + self.flag_xy = True + X, _ = self._detect_reshape(x, offset=False) + Y, _ = self._detect_reshape(y, offset=False) + X = X.T + Y = Y.T + + X, Y = compute_tlsq(X, Y, self.tlsq_rank) + U, s, V = compute_svd(X, self.svd_rank) + + if self.tikhonov_regularization is not None: + _norm_X = np.linalg.norm(X) + else: + _norm_X = 0 + + atilde = self._least_square_operator( + U, s, V, Y, self.tikhonov_regularization, _norm_X + ) + if self.forward_backward: + # b stands for "backward" + bU, bs, bV = compute_svd(Y, svd_rank=len(s)) + atilde_back = self._least_square_operator( + bU, bs, bV, X, self.tikhonov_regularization, _norm_X + ) + atilde = sqrtm(atilde @ np.linalg.inv(atilde_back)) + + # - V, lamda, eigenvectors + self._coef_ = atilde + self._state_matrix_ = atilde + [self._eigenvalues_, self._eigenvectors_] = eig(self._state_matrix_) + + # self._coef_ = U @ atilde @ U.conj().T + # self._state_matrix_ = self._coef_ + # self._reduced_state_matrix_ = atilde + # [self._eigenvalues_, self._eigenvectors_] = eig(self._reduced_state_matrix_) + self._ur = U + self._unnormalized_modes = self._ur @ self._eigenvectors_ + + self._tmp_compute_psi = np.linalg.pinv(self.unnormalized_modes) + + # self.C = np.linalg.inv(self._eigenvectors_) @ U.conj().T + # self._modes_ = U.dot(self._eigenvectors_) + + return self + + def predict(self, x): + """ + Predict the future values based on the input measurement data. + + Args: + x (np.ndarray): Measurement data upon which to base the prediction. + Should be of shape (n_samples, n_features). + Can also be of shape (n_trials, n_samples, n_features), where + n_trials is the number of independent trials. + Returns: + np.ndarray: Predicted values of `x` one timestep in the future. The shape + is (n_samples, n_features). + """ + # if isinstance(x, list): + # raise ValueError("list of arrays is not supported yet") + x, _ = self._detect_reshape(x, offset=False) + if x.ndim == 1: + x = x.reshape(1, -1) + check_is_fitted(self, "coef_") + y = np.linalg.multi_dot([self.ur, self._coef_, self.ur.conj().T, x.T]).T + # reshape y back to the original shape + y = self._return_orig_shape(y) + + return y + + def _compute_phi(self, x_col): + """ + Compute the `phi(x)` value given `x`. + + Args: + x_col (np.ndarray): Input data, if one-dimensional it will be reshaped + to (-1, 1). + + Returns: + np.ndarray: Computed `phi(x)` value. + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + phi = self.ur.T @ x_col + return phi + + def _compute_psi(self, x_col): + """ + Compute the `psi(x)` value given `x`. + + Args: + x_col (np.ndarray): Input data, if one-dimensional it will be reshaped + to (-1, 1). + + Returns: + np.ndarray: Value of Koopman eigenfunction psi at x. + """ + + # compute psi - one column if x is a row + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + psi = self._tmp_compute_psi @ x_col + return psi + + def _set_initial_time_dictionary(self, time_dict): + """ + Sets the initial values for `time_dict` and `original_time`. + Typically called in `fit()` and not used again afterwards. + + Args: + time_dict (dict): Initial time dictionary for this DMD instance. Must + contain the keys "t0", "tend", and "dt". + + Raises: + ValueError: If the time_dict does not contain the keys "t0", "tend" and + "dt" or if it contains more than these keys. + """ + + if not ("t0" in time_dict and "tend" in time_dict and "dt" in time_dict): + raise ValueError( + 'time_dict must contain the keys "t0", ' '"tend" and "dt".' + ) + if len(time_dict) > 3: + raise ValueError( + 'time_dict must contain only the keys "t0", ' '"tend" and "dt".' + ) + + self._original_time = DMDTimeDict(dict(time_dict)) + self._dmd_time = DMDTimeDict(dict(time_dict)) + + def _least_square_operator(self, U, s, V, Y, tikhonov_regularization, _norm_X): + """ + Calculates the least square estimation 'A' using the provided parameters. + + Args: + U (numpy.ndarray): Left singular vectors, shape (n_features, svd_rank). + s (numpy.ndarray): Singular values, shape (svd_rank, ). + V (numpy.ndarray): Right singular vectors, shape (n_features, svd_rank). + Y (numpy.ndarray): Measurement data for prediction, shape (n_samples, + n_features). + tikhonov_regularization (bool or NoneType): Tikhonov parameter for + regularization. If `None`, no regularization is applied, if `float`, + it is used as the :math:`\\lambda` tikhonov parameter. + _norm_X (numpy.ndarray): Norm of `X` for Tikhonov regularization, shape + (n_samples, n_features). + + Returns: + numpy.ndarray: The least square estimation 'A', shape (svd_rank, svd_rank). + """ + + if tikhonov_regularization is not None: + s = (s**2 + tikhonov_regularization * _norm_X) * np.reciprocal(s) + A = np.linalg.multi_dot([U.T.conj(), Y, V]) * np.reciprocal(s) + return A + + @property + def coef_(self): + """ + The weight vectors of the regression problem. + + This method checks if the regressor is fitted before returning the coefficient. + + Returns: + numpy.ndarray: The coefficient matrix. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + """ + The DMD state transition matrix. + + This method checks if the regressor is fitted before returning the state matrix. + + Returns: + numpy.ndarray: The state transition matrix. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_state_matrix_") + return self._state_matrix_ + + @property + def eigenvalues_(self): + """ + The identified Koopman eigenvalues. + + This method checks if the regressor is fitted before returning the eigenvalues. + + Returns: + numpy.ndarray: The Koopman eigenvalues. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def eigenvectors_(self): + """ + The identified Koopman eigenvectors. + + This method checks if the regressor is fitted before returning the eigenvectors. + + Returns: + numpy.ndarray: The Koopman eigenvectors. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def unnormalized_modes(self): + """ + The raw DMD V with each column as one DMD mode. + + This method checks if the regressor is fitted before returning the unnormalized + modes. + + Returns: + numpy.ndarray: The unnormalized modes. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + """ + The left singular vectors 'U'. + + This method checks if the regressor is fitted before returning 'U'. + + Returns: + numpy.ndarray: The left singular vectors 'U'. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_ur") + return self._ur diff --git a/DSA/pykoopman/src/pykoopman/regression/_dmdc.py b/DSA/pykoopman/src/pykoopman/regression/_dmdc.py new file mode 100644 index 0000000..9de8a5d --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_dmdc.py @@ -0,0 +1,468 @@ +"""module for dmd with control""" +from __future__ import annotations + +import numpy as np +from sklearn.utils.validation import check_is_fitted + +from ._base import BaseRegressor + + +class DMDc(BaseRegressor): + """ + Implements Dynamic Mode Decomposition with Control (DMDc) regressor. + + This class provides an implementation for DMDc, a variant of Dynamic Mode + Decomposition, which is a dimensionality reduction technique used to analyze + dynamical systems. The goal of DMDc is to compute matrices A and B that satisfy + the equation x' = Ax + Bu, where x' is the time-shifted state w.r.t. x and u is + the control input. + + Attributes: + svd_rank (int): Rank of SVD for the input space, i.e., the space of `X` and + input `U`. This determines the dimensionality of the projected state and + control matrices. Defaults to None. + svd_output_rank (int): Rank of SVD for the output space, i.e., the space of `Y`. + Defaults to None. + input_control_matrix (numpy.ndarray): The known input control matrix B. Defaults + to None. + n_samples_ (int): Total number of one step evolution samples. + n_input_features_ (int): Dimension of input features. + n_control_features_ (int): Dimension of input control signal. + coef_ (numpy.ndarray): Weight vectors of the regression problem. Corresponds + to either [A] or [A,B]. + state_matrix_ (numpy.ndarray): Identified state transition matrix A of the + underlying system. + control_matrix_ (numpy.ndarray): Identified control matrix B of the underlying + system. + reduced_state_matrix_ (numpy.ndarray): Reduced state transition matrix. + reduced_control_matrix_ (numpy.ndarray): Reduced control matrix. + eigenvalues_ (numpy.ndarray): DMD lamda. + unnormalized_modes (numpy.ndarray): DMD V. + projection_matrix_ (numpy.ndarray): Projection matrix into low-dimensional + subspace. + projection_matrix_output_ (numpy.ndarray): Projection matrix into + low-dimensional subspace. + eigenvectors_ (numpy.ndarray): DMD eigenvectors. + + Example: + >>> import numpy as np + >>> import pykoopman as pk + >>> A = np.matrix([[1.5, 0],[0, 0.1]]) + >>> B = np.matrix([[1],[0]]) + >>> x0 = np.array([4,7]) + >>> u = np.array([-4, -2, -1, -0.5, 0, 0.5, 1, 3, 5]) + >>> n = len(u)+1 + >>> x = np.zeros([n,len(x0)]) + >>> x[0,:] = x0 + >>> for i in range(n-1): + >>> x[i+1,:] = A.dot(x[i,:]) + B.dot(u[np.newaxis,i]) + >>> X1 = x[:-1,:] + >>> X2 = x[1:,:] + >>> C = u[:,np.newaxis] + >>> DMDc = pk.regression.DMDc(svd_rank=3, input_control_matrix=B) + >>> model = pk.Koopman(regressor=DMDc) + >>> model.fit(x,C) + >>> Aest = model.A + >>> Best = model.B + >>> print(Aest) + >>> np.allclose(A,Aest) + [[ 1.50000000e+00 -1.36609474e-17] + [-1.58023594e-17 1.00000000e-01]] + True + """ + + def __init__(self, svd_rank=None, svd_output_rank=None, input_control_matrix=None): + """ + Initialize a DMDc class object. + + Args: + svd_rank (int, optional): Rank of SVD for the input space. This determines + the dimensionality of the projected state and control matrices. + Defaults to None. + svd_output_rank (int, optional): Rank of SVD for the output space. + Defaults to None. + input_control_matrix (numpy.ndarray, optional): The known input control + matrix B. Defaults to None. + + Raises: + ValueError: If svd_rank is not an integer. + ValueError: If svd_output_rank is not an integer. + ValueError: If input_control_matrix is not a numpy array. + """ + self.svd_rank = svd_rank + self.svd_output_rank = svd_output_rank + self._input_control_matrix = input_control_matrix + + def fit(self, x, y=None, u=None, dt=None): + """ + Fit the DMDc model to the provided data. + + Parameters + ---------- + x : numpy.ndarray, shape (n_samples, n_features) + Measurement data to be fit. + Can be of shape (n_samples, n_features), or (n_trials, n_samples, + n_features), where + n_trials is the number of independent trials. + Can also be of a list of arrays, where each array is a trajectory + or a 2- or 3-d array of trajectories, provided they have the + same last dimension. + + y : numpy.ndarray, shape (n_samples, n_features), default=None + Measurement data output to be fitted. + + u : numpy.ndarray, shape (n_samples, n_control_features), optional, default=None + Time series of external actuation/control. + + dt : float, optional + Time interval between `X` and `Y` + + Returns + ------- + self: returns a fitted ``DMDc`` instance + """ + + if y is None: + X1, X2 = self._detect_reshape(x) + else: + X1, _ = self._detect_reshape(x, offset=False) + X2, _ = self._detect_reshape(y, offset=False) + if u is not None: + offset = u.shape[0] > X1.shape[0] + u, _ = self._detect_reshape(u, offset=offset) + self.n_control_features_ = u.shape[1] + self.n_input_features_ = X1.shape[1] + C = u + + self.n_control_features_ = C.shape[1] + + if self.svd_rank is None: + self.svd_rank = self.n_input_features_ + self.n_control_features_ + if self.svd_output_rank is None: + self.svd_output_rank = self.n_input_features_ + else: + if self.svd_output_rank is None: + self.svd_output_rank = self.svd_rank + + rout = self.svd_output_rank + r = self.svd_rank + + if self._input_control_matrix is None: + self._fit_unknown_B(X1, X2, C, r, rout) + else: + self._fit_known_B(X1, X2, C, r) + + return self + + def _fit_unknown_B(self, X1, X2, C, r, rout): + """ + Fits the DMDc model when the control matrix B is unknown. It computes + the state matrix `A` and control matrix `B` using the Dynamic Mode + Decomposition with control (DMDc) algorithm. + + Args: + X1 (numpy.ndarray): The state matrix at time t. + X2 (numpy.ndarray): The state matrix at time t+1. + C (numpy.ndarray): The control input matrix. + r (int): Rank for truncation of singular value decomposition. + rout (int): Rank for truncation of singular value decomposition on X2 + transpose. + + Returns: + None. Updates the instance variables _state_matrix_, _control_matrix_, + _coef_, _eigenvectors_, _eigenvalues_, _ur, _tmp_compute_psi, + _unnormalized_modes. + + Raises: + ValueError: If the dimensions of X1, X2, and C are not compatible. + """ + + assert rout <= r + Omega = np.vstack([X1.T, C.T]) + # SVD of input space + U, s, Vh = np.linalg.svd(Omega, full_matrices=False) + Ur = U[:, 0:r] + Sr = np.diag(s[0:r]) + Vr = Vh[0:r, :].T + + Uhat, _, _ = np.linalg.svd(X2.T, full_matrices=False) + Uhatr = Uhat[:, 0:rout] + + U1 = Ur[: self.n_input_features_, :] + U2 = Ur[self.n_input_features_ :, :] + + # this is reduced A_r + self._state_matrix_ = Uhatr.T @ X2.T @ Vr @ np.linalg.inv(Sr) @ U1.T @ Uhatr + self._control_matrix_ = Uhatr.T @ X2.T @ Vr @ np.linalg.inv(Sr) @ U2.T + + # self._state_matrix_ = self._reduced_state_matrix_ + # self._control_matrix_ = self._reduced_control_matrix_ + # self._state_matrix_ = Uhatr @ self._reduced_state_matrix_ @ Uhatr.T + # self._control_matrix_ = Uhatr @ self._reduced_control_matrix_ + + # pack [A full, B full] as self.coef_ + self._coef_ = np.concatenate( + (self._state_matrix_, self._control_matrix_), axis=1 + ) + + # self._projection_matrix_ = Ur + # self._projection_matrix_output_ = Uhatr + + # eigenvectors, lamda + [self._eigenvalues_, self._eigenvectors_] = np.linalg.eig(self._state_matrix_) + + # Koopman modes V + self._unnormalized_modes = Uhatr @ self._eigenvectors_ + self._ur = Uhatr + self._tmp_compute_psi = np.linalg.inv(self._eigenvectors_) @ Uhatr.T + + def _fit_known_B(self, X1, X2, C, r): + """ + Fits the DMDc model when the control matrix B is known. It computes + the state matrix `A` using the Dynamic Mode Decomposition with control + (DMDc) algorithm. + + Args: + X1 (numpy.ndarray): The state matrix at time t. + X2 (numpy.ndarray): The state matrix at time t+1. + C (numpy.ndarray): The control input matrix. + r (int): Rank for truncation of singular value decomposition. + + Returns: + None. Updates the instance variables _state_matrix_, _coef_, + _eigenvectors_, _eigenvalues_, _ur, _tmp_compute_psi, _unnormalized_modes. + + Raises: + ValueError: If the dimensions of X1, X2, and C are not compatible. + """ + if self.n_input_features_ in self._input_control_matrix.shape is False: + raise TypeError("Control vector/matrix B has wrong shape.") + if self._input_control_matrix.shape[1] == self.n_input_features_: + self._input_control_matrix = self._input_control_matrix.T + if self._input_control_matrix.shape[1] != self.n_control_features_: + raise TypeError( + "The control matrix B must have the same " + "number of inputs as the control variable u." + ) + + U, s, Vh = np.linalg.svd(X1.T, full_matrices=False) + Ur = U[:, :r] + sr = s[:r] + Vhr = Vh[:r, :] + + self._state_matrix_ = np.linalg.multi_dot( + [ + Ur.T, + X2.T - self._input_control_matrix @ C.T, + Vhr.T, + np.diag(np.reciprocal(sr)), + ] + ) + self._control_matrix_ = Ur.T @ self._input_control_matrix + # self._state_matrix_ = Ur @ self._reduced_state_matrix_ @ Ur.T + + self._coef_ = np.concatenate( + (self._state_matrix_, self.control_matrix_), axis=1 + ) + # self._coef_ = Ur @ self._state_matrix_ @ Ur.T + # self._projection_matrix_ = Ur + # self._projection_matrix_output_ = Ur + + # Compute , eigenvectors, lamda + [self._eigenvalues_, self._eigenvectors_] = np.linalg.eig(self._state_matrix_) + + # Koopman V + self._unnormalized_modes = Ur @ self._eigenvectors_ + self._ur = Ur + self._tmp_compute_psi = np.linalg.inv(self._eigenvectors_) @ Ur.T + + # compute psi + # self.C = np.linalg.inv(self._eigenvectors_) @ Ur.T + + def predict(self, x, u): + """ + Predicts the future state of the system based on the current state and the + current value of control input, using the fitted DMDc model. + + Args: + x (numpy.ndarray): The current state of the system. + u (numpy.ndarray): The current value of the input. + + Returns: + numpy.ndarray: The predicted future state of the system. + + Raises: + NotFittedError: If the model is not fitted, raise this error to prevent + misuse of the model. + """ + check_is_fitted(self, "coef_") + if x.ndim == 1: + x = x.reshape(1, -1) + if u.ndim == 1: + u = u.reshape(1, -1) + u, _ = self._detect_reshape(u, offset=False) + x, _ = self._detect_reshape(x, offset=False) + # y = self.coef_ @ np.vstack([x.reshape(1, -1).T, u.reshape(1, -1).T]) + y = ( + x @ self.ur @ self.state_matrix_.T @ self.ur.T + + u @ self.control_matrix_.T @ self.ur.T + ) + # y = x @ self.state_matrix_.T + u @ self.control_matrix_.T + # y = y.T + y = self._return_orig_shape(y) + return y + + def _compute_phi(self, x_col): + """ + Returns the transformed matrix `phi(x)` given `x`. + + The method takes a column vector or a 1-D numpy array and computes its + transformation using the `_ur` matrix. If the input `x_col` is a 1-D array, + it reshapes it into a column vector before the computation. + + Args: + x_col (numpy.ndarray): A column vector or a 1-D numpy array + representing `x`. + + Returns: + numpy.ndarray: The transformed matrix `phi(x)`. + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + phi = self._ur.T @ x_col + return phi + + def _compute_psi(self, x_col): + """ + Returns `psi(x)` given `x` + + Args: + x: numpy.ndarray, shape (n_samples, n_features) + Measurement data upon which to compute psi values. + + Returns + phi : numpy.ndarray, shape (n_samples, n_input_features_) value of + Koopman psi at x + """ + + # compute psi - one column if x is a row + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + psi = self._tmp_compute_psi @ x_col + return psi + + @property + def coef_(self): + """ + The weight vectors of the regression problem. + + This method checks if the regressor is fitted before returning the coefficient. + + Returns: + numpy.ndarray: The coefficient matrix. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + """ + The DMD state transition matrix. + + This method checks if the regressor is fitted before returning the state matrix. + + Returns: + numpy.ndarray: The state transition matrix. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_state_matrix_") + return self._state_matrix_ + + @property + def control_matrix_(self): + check_is_fitted(self, "_control_matrix_") + return self._control_matrix_ + + # @property + # def reduced_state_matrix_(self): + # check_is_fitted(self, "_reduced_state_matrix_") + # return self._reduced_state_matrix_ + # + # @property + # def reduced_control_matrix_(self): + # check_is_fitted(self, "_reduced_control_matrix_") + # return self._reduced_control_matrix_ + + @property + def eigenvectors_(self): + """ + The identified Koopman eigenvectors. + + This method checks if the regressor is fitted before returning the eigenvectors. + + Returns: + numpy.ndarray: The Koopman eigenvectors. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def eigenvalues_(self): + """ + The identified Koopman eigenvalues. + + This method checks if the regressor is fitted before returning the eigenvalues. + + Returns: + numpy.ndarray: The Koopman eigenvalues. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def unnormalized_modes(self): + """ + The raw DMD V with each column as one DMD mode. + + This method checks if the regressor is fitted before returning the unnormalized + modes. + + Returns: + numpy.ndarray: The unnormalized modes. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + """ + The left singular vectors 'U'. + + This method checks if the regressor is fitted before returning 'U'. + + Returns: + numpy.ndarray: The left singular vectors 'U'. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_ur") + return self._ur + + @property + def input_control_matrix(self): + return self._input_control_matrix diff --git a/DSA/pykoopman/src/pykoopman/regression/_edmd.py b/DSA/pykoopman/src/pykoopman/regression/_edmd.py new file mode 100644 index 0000000..409028b --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_edmd.py @@ -0,0 +1,248 @@ +"""module for extended dmd""" +# from warnings import warn +from __future__ import annotations + +import numpy as np +import scipy +from pydmd.dmdbase import DMDTimeDict +from pydmd.utils import compute_svd +from pydmd.utils import compute_tlsq +from sklearn.utils.validation import check_is_fitted + +from ._base import BaseRegressor + + +class EDMD(BaseRegressor): + """Extended DMD (EDMD) regressor. + + Aims to determine the system matrices A,C that satisfy y' = Ay and x = Cy, + where y' is the time-shifted observable with y0 = phi(x0). C is the measurement + matrix that maps back to the state. + + The objective functions, \\|Y'-AY\\|_F, are minimized using least-squares regression + and singular value decomposition. + + See the following reference for more details: + `M.O. Williams, I.G. Kevrekidis, C.W. Rowley + "A Data–Driven Approximation of the Koopman Operator: + Extending Dynamic Mode Decomposition." + Journal of Nonlinear Science, Vol. 25, 1307-1346, 2015. + `_ + + Attributes: + _coef_ (numpy.ndarray): Weight vectors of the regression problem. Corresponds + to either [A] or [A,B]. + _state_matrix_ (numpy.ndarray): Identified state transition matrix A of the + underlying system. + _eigenvalues_ (numpy.ndarray): Identified Koopman lambda. + _eigenvectors_ (numpy.ndarray): Identified Koopman eigenvectors. + _unnormalized_modes_ (numpy.ndarray): Identified Koopman eigenvectors. + n_samples_ (int): Number of samples. + n_input_features_ (int): Number of input features. + C (numpy.ndarray): Matrix that maps psi to the input features. + """ + + def __init__(self, svd_rank=1.0, tlsq_rank=0): + """Initialize the EDMD regressor. + + Args: + svd_rank (float): Rank parameter for singular value decomposition. + Default is 1.0. + tlsq_rank (int): Rank parameter for total least squares. Default is 0. + """ + self.svd_rank = svd_rank + self.tlsq_rank = tlsq_rank + + def fit(self, x, y=None, dt=None): + """Fit the EDMD regressor to the given data. + + Args: + x (numpy.ndarray): Measurement data to be fit. + Can be of shape (n_samples, n_features), or (n_trials, n_samples, + n_features), where n_trials is the number of independent trials. + Can also be of a list of arrays, where each array is a trajectory + or a 2- or 3-d array of trajectories, provided they have the + same last dimension. + y (numpy.ndarray, optional): Time-shifted measurement data to be fit. + Defaults to None. + dt (scalar, optional): Discrete time-step. Defaults to None. + + Returns: + self: Fitted EDMD instance. + """ + if y is None: + X1, X2 = self._detect_reshape(x) + else: + X1, _ = self._detect_reshape(x, offset=False) + X2, _ = self._detect_reshape(y, offset=False) + + # perform SVD + X1T, X2T = compute_tlsq(X1.T, X2.T, self.tlsq_rank) + U, s, V = compute_svd(X1T, self.svd_rank) + + # X1, X2 are row-wise data, so there is a transpose in the end. + self._coef_ = U.conj().T @ X2T @ V @ np.diag(np.reciprocal(s)) + # self._coef_ = np.linalg.lstsq(X1, X2)[0].T # [0:Nlift, 0:Nlift] + self._state_matrix_ = self._coef_ + [self._eigenvalues_, self._eigenvectors_] = scipy.linalg.eig(self.state_matrix_) + # self._ur = np.eye(self.n_input_features_) + self._ur = U + # self._unnormalized_modes = self._eigenvectors_ + self._unnormalized_modes = self._ur @ self._eigenvectors_ + + # np.linalg.pinv(self._unnormalized_modes) + self._tmp_compute_psi = np.linalg.inv(self._eigenvectors_) @ self._ur.conj().T + + return self + + def predict(self, x): + """Predict the next timestep based on the given data. + + Args: + x (numpy.ndarray): Measurement data upon which to base prediction. + + Returns: + y (numpy.ndarray): Prediction of x one timestep in the future. + """ + check_is_fitted(self, "coef_") + x, _ = self._detect_reshape(x, offset=False) + y = x @ self.ur.conj() @ self.state_matrix_.T @ self.ur.T + y = self._return_orig_shape(y) + return y + + def _compute_phi(self, x_col): + """Compute phi(x) given x. + + Args: + x_col (numpy.ndarray): Input data x. + + Returns: + phi (numpy.ndarray): Value of phi(x). + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + phi = self._ur.conj().T @ x_col + return phi + + def _compute_psi(self, x_col): + """Compute psi(x) given x. + + Args: + x_col (numpy.ndarray): Input data x. + + Returns: + psi (numpy.ndarray): Value of psi(x). + """ + # compute psi - one column if x is a row + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + psi = self._tmp_compute_psi @ x_col + return psi + + def _set_initial_time_dictionary(self, time_dict): + """Set the initial values for the class fields time_dict and original_time. + + Args: + time_dict (dict): Initial time dictionary for this DMD instance. + """ + if not ("t0" in time_dict and "tend" in time_dict and "dt" in time_dict): + raise ValueError('time_dict must contain the keys "t0", "tend" and "dt".') + if len(time_dict) > 3: + raise ValueError( + 'time_dict must contain only the keys "t0", "tend" and "dt".' + ) + + self._original_time = DMDTimeDict(dict(time_dict)) + self._dmd_time = DMDTimeDict(dict(time_dict)) + + @property + def coef_(self): + """ + Weight vectors of the regression problem. Corresponds to either [A] or + [A,B]. + + """ + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + """ + The EDMD state transition matrix. + + This method checks if the regressor is fitted before returning the state matrix. + + Returns: + numpy.ndarray: The state transition matrix. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_state_matrix_") + return self._state_matrix_ + + @property + def eigenvalues_(self): + """ + The identified Koopman eigenvalues. + + This method checks if the regressor is fitted before returning the eigenvalues. + + Returns: + numpy.ndarray: The Koopman eigenvalues. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def eigenvectors_(self): + """ + The identified Koopman eigenvectors. + + This method checks if the regressor is fitted before returning the eigenvectors. + + Returns: + numpy.ndarray: The Koopman eigenvectors. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def unnormalized_modes(self): + """ + The raw EDMD V with each column as one EDMD mode. + + This method checks if the regressor is fitted before returning the unnormalized + modes. Note that this will combined with the measurement matrix from the + observer to give you the true Koopman modes + + Returns: + numpy.ndarray: The unnormalized modes. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + """ + The left singular vectors 'U'. + + This method checks if the regressor is fitted before returning 'U'. + + Returns: + numpy.ndarray: The left singular vectors 'U'. + + Raises: + NotFittedError: If the regressor is not fitted yet. + """ + check_is_fitted(self, "_ur") + return self._ur diff --git a/DSA/pykoopman/src/pykoopman/regression/_edmdc.py b/DSA/pykoopman/src/pykoopman/regression/_edmdc.py new file mode 100644 index 0000000..1826a65 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_edmdc.py @@ -0,0 +1,239 @@ +"""module for extended dmd with control""" +from __future__ import annotations + +import numpy as np +from sklearn.utils.validation import check_is_fitted + +from ._base import BaseRegressor + +# TODO: add support for time delay observables, so we will +# have n_consumption_. + + +class EDMDc(BaseRegressor): + """Module for Extended DMD with control (EDMDc) regressor. + + Aims to determine the system matrices A, B, C that satisfy y' = Ay + Bu and x = Cy, + where y' is the time-shifted observable with y0 = phi(x0) and u is the control + input. B and C are the unknown control and measurement matrices, respectively. + + The objective functions, \\|Y'-AY-BU\\|_F and \\|X-CY\\|_F, are minimized using + least-squares regression and singular value decomposition. + + See the following reference for more details: + Korda, M. and Mezic, I. "Linear predictors for nonlinear dynamical systems: + Koopman operator meets model predictive control." Automatica, Vol. 93, 149–160. + + + Attributes: + coef_ (numpy.ndarray): + Weight vectors of the regression problem. Corresponds to either [A] or + [A,B]. + state_matrix_ (numpy.ndarray): + Identified state transition matrix A of the underlying system. + control_matrix_ (numpy.ndarray): + Identified control matrix B of the underlying system. + projection_matrix_ (numpy.ndarray): + Projection matrix into low-dimensional subspace of shape (n_input_features + +n_control_features, svd_rank). + projection_matrix_output_ (numpy.ndarray): + Projection matrix into low-dimensional subspace of shape (n_input_features + +n_control_features, svd_output_rank). + """ + + def __init__(self): + """Initialize the EDMDc regressor.""" + pass + + def fit(self, x, y=None, u=None, dt=None): + """Fit the EDMDc regressor to the given data. + + Args: + x (numpy.ndarray): + Measurement data to be fit. + Can be of shape (n_samples, n_features), or (n_trials, n_samples, + n_features), where n_trials is the number of independent trials. + Can also be of a list of arrays, where each array is a trajectory + or a 2- or 3-d array of trajectories, provided they have the + same last dimension. + y (numpy.ndarray, optional): + Time-shifted measurement data to be fit. Defaults to None. + u (numpy.ndarray, optional): + Time series of external actuation/control. Defaults to None. + dt (scalar, optional): + Discrete time-step. Defaults to None. + + Returns: + self: Fitted EDMDc instance. + """ + if y is None: + X1, X2 = self._detect_reshape(x) + else: + X1, _ = self._detect_reshape(x, offset=False) + X2, _ = self._detect_reshape(y, offset=False) + + if u.ndim == 1: + if len(u) > X1.shape[0]: + u, _ = self._detect_reshape(u) + C = u[np.newaxis, :] + else: + if u.shape[0] > X1.shape[0]: + u, _ = self._detect_reshape(u) + C = u + self.n_control_features_ = C.shape[1] + + self._fit_with_unknown_b(X1, X2, C) + return self + + def _fit_with_unknown_b(self, X1, X2, U): + """Fit the EDMDc regressor with unknown control matrix B. + + Args: + X1 (numpy.ndarray): + Measurement data given as input. + X2 (numpy.ndarray): + Measurement data given as target. + U (numpy.ndarray): + Time series of external actuation/control. + """ + Nlift = X1.shape[1] + W = X2.T + V = np.vstack([X1.T, U.T]) + VVt = V @ V.T + WVt = W @ V.T + M = WVt @ np.linalg.pinv(VVt) # Matrix [A B] + self._state_matrix_ = M[0:Nlift, 0:Nlift] + self._control_matrix_ = M[0:Nlift, Nlift:] + self._coef_ = M + + # Compute Koopman V, eigenvectors, lamda + [self._eigenvalues_, self._eigenvectors_] = np.linalg.eig(self.state_matrix_) + self._unnormalized_modes = self._eigenvectors_ + self._ur = np.eye(self.n_input_features_) + self._tmp_compute_psi = np.linalg.inv(self._eigenvectors_) + + def predict(self, x, u): + """Predict the next timestep based on the given data. + + Args: + x (numpy.ndarray): + Measurement data upon which to base prediction. + u (numpy.ndarray): + Time series of external actuation/control. + + Returns: + y (numpy.ndarray): + Prediction of x one timestep in the future. + """ + check_is_fitted(self, "coef_") + u, _ = self._detect_reshape(u, offset=False) + x, _ = self._detect_reshape(x, offset=False) + y = x @ self.state_matrix_.T + u @ self.control_matrix_.T + y = self._return_orig_shape(y) + return y + + def _compute_phi(self, x_col): + """Compute psi(x) given x. + + Args: + x_col (numpy.ndarray): + Input data x. + + Returns: + psi (numpy.ndarray): + Value of psi(x). + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + phi = self._ur.T @ x_col + return phi + + def _compute_psi(self, x_col): + """Compute psi(x) given x. + + Args: + x_col (numpy.ndarray): + Input data x. + + Returns: + psi (numpy.ndarray): + Value of psi(x). + """ + # compute psi - one column if x is a row + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + psi = self._tmp_compute_psi @ x_col + return psi + + @property + def coef_(self): + """Weight vectors of the regression problem. Corresponds to either [A] or + [A,B].""" + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + """Identified state transition matrix A of the underlying system. + + Returns: + state_matrix (numpy.ndarray): + State transition matrix A. + """ + check_is_fitted(self, "_state_matrix_") + return self._state_matrix_ + + @property + def control_matrix_(self): + """Identified control matrix B of the underlying system. + + Returns: + control_matrix (numpy.ndarray): + Control matrix B. + """ + check_is_fitted(self, "_control_matrix_") + return self._control_matrix_ + + @property + def eigenvalues_(self): + """Identified Koopman lambda. + + Returns: + eigenvalues (numpy.ndarray): + Koopman eigenvalues. + """ + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def eigenvectors_(self): + """Identified Koopman eigenvectors. + + Returns: + eigenvectors (numpy.ndarray): + Koopman eigenvectors. + """ + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def unnormalized_modes(self): + """Identified Koopman eigenvectors. + + Returns: + unnormalized_modes (numpy.ndarray): + Koopman eigenvectors. + """ + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + """Matrix U that is part of the SVD. + + Returns: + ur (numpy.ndarray): + Matrix U. + """ + check_is_fitted(self, "_ur") + return self._ur diff --git a/DSA/pykoopman/src/pykoopman/regression/_havok.py b/DSA/pykoopman/src/pykoopman/regression/_havok.py new file mode 100644 index 0000000..0273ebd --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_havok.py @@ -0,0 +1,341 @@ +"""module for havok""" +from __future__ import annotations + +from warnings import warn + +import numpy as np +from matplotlib import pyplot as plt +from optht import optht +from scipy.signal import lsim +from scipy.signal import lti +from sklearn.utils.validation import check_is_fitted + +from ..common import drop_nan_rows +from ..differentiation._derivative import Derivative +from ._base import BaseRegressor + + +class HAVOK(BaseRegressor): + """ + HAVOK (Hankel Alternative View of Koopman) regressor. + + Aims to determine the system matrices A, B that satisfy d/dt v = Av + Bu, + where v is the vector of the leading delay coordinates and u is a low-energy + delay coordinate acting as forcing. A and B are the unknown system and control + matrices, respectively. The delay coordinates are obtained by computing the + SVD from a Hankel matrix. + + The objective function, \\|dV-AV-BU\\|_F, is minimized using least-squares + regression. + + See the following reference for more details: + Brunton, S.L., Brunton, B.W., Proctor, J.L., Kaiser, E. & Kutz, J.N. + "Chaos as an intermittently forced linear system." + Nature Communications, Vol. 8(19), 2017. + + + Parameters: + svd_rank (int, optional): + Rank of the SVD used for model reduction. Defaults to None. + differentiator (Derivative, optional): + Differentiation method to compute the time derivative. Defaults to + Derivative(kind="finite_difference", k=1). + plot_sv (bool, optional): + Whether to plot the singular values. Defaults to False. + + Attributes: + coef_ (array): + Weight vectors of the regression problem. Corresponds to either [A] or + [A,B]. + state_matrix_ (array): + Identified state transition matrix A of the underlying system. + control_matrix_ (array): + Identified control matrix B of the underlying system. + projection_matrix_ (array): + Projection matrix into low-dimensional subspace of shape (n_input_features + +n_control_features, svd_rank). + projection_matrix_output_ (array): + Projection matrix into low-dimensional subspace of shape (n_input_features + +n_control_features, svd_output_rank). + """ + + def __init__( + self, + svd_rank=None, + differentiator=Derivative(kind="finite_difference", k=1), + plot_sv=False, + ): + """ + Initialize the HAVOK regressor. + + Args: + svd_rank (int, optional): + Rank of the SVD used for model reduction. Defaults to None. + differentiator (Derivative, optional): + Differentiation method to compute the time derivative. Defaults to + Derivative(kind="finite_difference", k=1). + plot_sv (bool, optional): + Whether to plot the singular values. Defaults to False. + """ + self.svd_rank = svd_rank + self.differentiator = differentiator + self.plot_sv = plot_sv + + def fit(self, x, y=None, dt=None): + """ + Fit the HAVOK regressor to the given data. + + Args: + x (numpy.ndarray): + Measurement data to be fit. + Can be of shape (n_samples, n_features), or (n_trials, n_samples, + n_features), where n_trials is the number of independent trials. + Can also be of a list of arrays, where each array is a trajectory + or a 2- or 3-d array of trajectories, provided they have the + same last dimension. + y (not used): + Time-shifted measurement data to be fit. Ignored. + dt (scalar): + Discrete time-step. + + Returns: + self: Fitted HAVOK instance. + """ + + if y is not None: + warn("havok regressor does not require the y argument when fitting.") + + if dt is None: + raise ValueError("havok regressor requires a timestep dt when fitting.") + + self.dt_ = dt + self.n_control_features_ = 1 + + orig_shape = x.shape if isinstance(x, np.ndarray) else None + x, _ = self._detect_reshape(x, offset=False) # time*trials, features + # Create time vector + t = np.arange(0, self.dt_ * self.n_samples_, self.dt_) + + # SVD to calculate intrinsic observables + U, s, Vh = np.linalg.svd(x.T, full_matrices=False) + + if self.plot_sv: + plt.figure() + plt.semilogy(s) + plt.xlabel("number of terms") + plt.ylabel("singular values") + plt.show() + + # calculate rank using optimal hard threshold by Gavish & Donoho + if self.svd_rank is None: + self.svd_rank = optht(x, sv=s, sigma=None) + Vrh = Vh[: self.svd_rank, :] + Vr = Vrh.T + Ur = U[:, : self.svd_rank] + sr = s[: self.svd_rank] + + # calculate time derivative dxdt of only the first rank-1 & normalize + if len(orig_shape) == 2: + dVr = self.differentiator(Vr[:, :-1], t) + + else: + Vrt = Vr.reshape(orig_shape[0], orig_shape[1], -1) + dVr = self.differentiator(Vrt[:, :-1], t, axis=1) + dVr = dVr.reshape(Vr.shape) # TODO: check if this is correct + + dVr, t, V = drop_nan_rows(dVr, t, Vh.T) + + # regression on intrinsic variables v + # xi = np.zeros((self.svd_rank - 1, self.svd_rank)) + # for i in range(self.svd_rank - 1): + # # here, we use rank terms in V to fit the rank-1 terms dV/dt + # # we perform column wise + # xi[i, :] = np.linalg.lstsq(Vr, dVr[:, i], rcond=None)[0] + + xi = np.linalg.lstsq(Vr, dVr, rcond=None)[0].T + assert xi.shape == (self.svd_rank - 1, self.svd_rank) + + self.forcing_signal = Vr[:, -1] + self._state_matrix_ = xi[:, :-1] + self._control_matrix_ = xi[:, -1].reshape(-1, 1) + + self.svals = s + self._ur = Ur[:, :-1] @ np.diag(sr[:-1]) + self._coef_ = np.hstack([self.state_matrix_, self.control_matrix_]) + + eigenvalues_, self._eigenvectors_ = np.linalg.eig(self.state_matrix_) + # because we fit the model in continuous time, + # so we need to convert to discrete time + self._eigenvalues_ = np.exp(eigenvalues_ * dt) + + self._unnormalized_modes = self._ur @ self.eigenvectors_ + self._tmp_compute_psi = np.linalg.inv(self.eigenvectors_) @ self._ur.T + + # self.C = np.linalg.multi_dot( + # [ + # np.linalg.inv(self.eigenvectors_), + # np.diag(np.reciprocal(s[: self.svd_rank - 1])), + # U[:, : self.svd_rank - 1].T, + # ] + # ) + return self + + def predict(self, x, u, t): + """ + Predict the output based on the input data. + + Args: + x (numpy.ndarray): + Measurement data upon which to base prediction. + u (numpy.ndarray): + Time series of external actuation/control, which is sampled at time + instances in `t`. + t (numpy.ndarray): + Time vector. Instances at which the solution vector shall be provided. + Note: The time vector must start at 0. + + Returns: + y (numpy.ndarray): + Prediction of `x` at the time instances provided in `t`. + """ + # if t[0] != 0: + # raise ValueError("the time vector must start at 0.") + x, _ = self._detect_reshape(x, offset=False) + + check_is_fitted(self, "coef_") + y0 = ( + # np.linalg.inv(np.diag(self.svals[: self.svd_rank - 1])) + # @ + np.linalg.pinv(self._ur) + @ x.T + ) + sys = lti( + self.state_matrix_, + self.control_matrix_, + self._ur, + np.zeros((self.n_input_features_, self.n_control_features_)), + ) + tout, ypred, xpred = lsim(sys, U=u, T=t, X0=y0.T) + return self._return_orig_shape(ypred) + + def _compute_phi(self, x_col): + """ + Compute the feature vector `phi(x)` given `x`. + + Args: + x_col (numpy.ndarray): + Input data `x` for computing `phi(x)`. + + Returns: + phi (numpy.ndarray): + Value of `phi(x)`. + + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + phi = self._ur.T @ x_col + return phi + + def _compute_psi(self, x_col): + """ + Compute the feature vector `psi(x)` given `x`. + + Args: + x_col (numpy.ndarray): + Input data `x` for computing `psi(x)`. + + Returns: + psi (numpy.ndarray): + Value of `psi(x)`. + + """ + # compute psi - one column if x is a row + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + psi = self._tmp_compute_psi @ x_col + return psi + + @property + def coef_(self): + """ + Get the weight vectors of the regression problem. + + Returns: + coef (numpy.ndarray): + Weight vectors of the regression problem. Corresponds to either [A] + or [A,B]. + """ + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + """ + Get the identified state transition matrix A of the underlying system. + + Returns: + state_matrix (numpy.ndarray): + Identified state transition matrix A. + """ + check_is_fitted(self, "_state_matrix_") + return self._state_matrix_ + + @property + def control_matrix_(self): + """ + Get the identified control matrix B of the underlying system. + + Returns: + control_matrix (numpy.ndarray): + Identified control matrix B. + """ + check_is_fitted(self, "_control_matrix_") + return self._control_matrix_ + + @property + def eigenvectors_(self): + """ + Get the identified eigenvectors of the state matrix A. + + Returns: + eigenvectors (numpy.ndarray): + Identified eigenvectors of the state matrix A. + """ + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def eigenvalues_(self): + """ + Get the identified eigenvalues of the state matrix A. + + Returns: + eigenvalues (numpy.ndarray): + Identified eigenvalues of the state matrix A. + """ + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def unnormalized_modes(self): + """ + Get the identified unnormalized modes. + + Returns: + unnormalized_modes (numpy.ndarray): + Identified unnormalized modes. + """ + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + """ + Get the matrix UR. + + Returns: + ur (numpy.ndarray): + Matrix UR. + """ + check_is_fitted(self, "_ur") + return self._ur diff --git a/DSA/pykoopman/src/pykoopman/regression/_kdmd.py b/DSA/pykoopman/src/pykoopman/regression/_kdmd.py new file mode 100644 index 0000000..6e33111 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_kdmd.py @@ -0,0 +1,460 @@ +"""module for kernel dmd""" +from __future__ import annotations + +from warnings import warn + +import numpy as np +from pydmd.dmdbase import DMDTimeDict +from pydmd.utils import compute_svd +from pydmd.utils import compute_tlsq +from scipy.linalg import sqrtm +from sklearn.gaussian_process.kernels import Kernel +from sklearn.gaussian_process.kernels import RBF +from sklearn.utils.validation import check_is_fitted + +from ._base import BaseRegressor + + +class KDMD(BaseRegressor): + """ + Kernel Dynamic Mode Decomposition. + + See the following reference for more details: + + `Williams, M. O., Rowley, C. W., & Kevrekidis, I. G. (2014). + "A kernel-based approach to data-driven Koopman spectral analysis." + arXiv preprint arXiv:1411.2260. ` + + Args: + svd_rank (int): The rank for the truncation. If 0, the method computes + the optimal rank and uses it for truncation. If positive integer, + the method uses the argument for the truncation. If float between 0 + and 1, the rank is the number of the biggest singular values that + are needed to reach the 'energy' specified by `svd_rank`. If -1, + the method does not compute truncation. Default is 0. + tlsq_rank (int): The rank for the truncation. If 0, the method does not + compute any noise reduction. If positive number, the method uses the + argument for the SVD truncation used in the TLSQ method. + forward_backward (bool): If True, the low-rank operator is computed + like in fbDMD (reference: https://arxiv.org/abs/1507.02264). + Default is False. + tikhonov_regularization (bool or None): Tikhonov parameter for the + regularization. If None, no regularization is applied. If float, + it is used as the λ Tikhonov parameter. + kernel (sklearn.gaussian_process.Kernel): An instance of kernel from sklearn. + + Attributes: + svd_rank (int): The rank for the truncation. + tlsq_rank (int): The rank for the truncation. + forward_backward (bool): If True, the low-rank operator is computed + like in fbDMD (reference: https://arxiv.org/abs/1507.02264). + tikhonov_regularization (bool or None): Tikhonov parameter for the + regularization. + kernel (sklearn.gaussian_process.Kernel): An instance of kernel from sklearn. + n_samples_ (int): Number of samples in KDMD. + n_input_features_ (int): Dimension of input features, i.e., the dimension + of each sample. + _snapshots (numpy.ndarray): Column-wise data matrix of shape + (n_input_features_, n_samples_). + _snapshots_shape (tuple): Shape of column-wise data matrix. + _X (numpy.ndarray): Training features column-wise arranged, needed for + prediction. Shape is (n_input_features_, n_samples). + _Y (numpy.ndarray): Training target, column-wise arranged. Shape is + (n_input_features_, n_samples). + _coef_ (numpy.ndarray): Reduced Koopman state transition matrix of shape + (svd_rank, svd_rank). + _eigenvalues_ (numpy.ndarray): Koopman lambda of shape (svd_rank,). + _eigenvectors_ (numpy.ndarray): Koopman eigenvectors of shape + (svd_rank, svd_rank). + _unnormalized_modes (numpy.ndarray): Koopman V of shape + (svd_rank, n_input_features_). + _state_matrix_ (numpy.ndarray): Reduced Koopman state transition matrix + of shape (svd_rank, svd_rank). + self.C (numpy.ndarray): Linear matrix that maps kernel product features + to eigenfunctions of shape (svd_rank, n_samples_). + """ + + def __init__( + self, + svd_rank=1.0, # 1.0 means keeping all ranks + tlsq_rank=0, + forward_backward=False, + tikhonov_regularization=None, + kernel=RBF(), + ): + """ + Kernel Dynamic Mode Decomposition. + + Args: + svd_rank (int, optional): The rank for the truncation. + If set to 0, the method computes the optimal rank + and uses it for truncation. If set to a positive integer, + the method uses the specified rank for truncation. + If set to a float between 0 and 1, the rank is determined + based on the specified energy level. If set to -1, no + truncation is performed. Default is 1.0. + tlsq_rank (int, optional): The rank for the truncation used + in the total least squares preprocessing. If set to 0, + no noise reduction is performed. If set to a positive integer, + the method uses the specified rank for the SVD truncation + in the TLSQ method. Default is 0. + forward_backward (bool, optional): Whether to compute the + low-rank operator using the forward-backward method similar + to fbDMD. If set to True, the low-rank operator is computed + with forward-backward DMD. If set to False, standard DMD is used. + Default is False. + tikhonov_regularization (float or None, optional): Tikhonov + regularization parameter for regularization. If set to None, + no regularization is applied. If set to a float, it is used + as the regularization parameter. Default is None. + kernel (Kernel, optional): An instance of the kernel class from + sklearn.gaussian_process. Default is RBF(). + """ + self.svd_rank = svd_rank + self.tlsq_rank = tlsq_rank + self.forward_backward = forward_backward + self.tikhonov_regularization = tikhonov_regularization + self.kernel = kernel + + if not isinstance(self.kernel, Kernel): + raise ValueError( + "kernel must be a subclass of sklearn.gaussian_process.kernel" + ) + + def fit(self, x, y=None, dt=1): + """ + Fits the KDMD model to the provided training data. + + Args: + x: numpy.ndarray, shape (n_samples, n_features) + Measurement data input. + Can be of shape (n_samples, n_features), or (n_trials, n_samples, + n_features), where n_trials is the number of independent trials. + Can also be of a list of arrays, where each array is a trajectory + or a 2- or 3-d array of trajectories, provided they have the + same last dimension. + + y: numpy.ndarray, shape (n_samples, n_features), optional + Measurement data output to be fitted. Defaults to None. + + dt: float, optional + Time interval between `x` and `y`. Defaults to 1. + + Returns: + KDMD: + The fitted KDMD instance. + """ + + # if y is not None: + # warn("pydmd regressors do not require the y argument when fitting.") + if y is None: + X, Y = self._detect_reshape(x) + else: + X, _ = self._detect_reshape(x, offset=False) + Y, _ = self._detect_reshape(y, offset=False) + X = X.T + Y = Y.T + + n_samples = self.n_samples_ + if y is None: + self._snapshots, self._snapshots_shape = _col_major_2darray(x.T) + + # total least square preprocessing on X and Y - features, samples + self._X, self._Y = compute_tlsq(X, Y, self.tlsq_rank) + + # compute KDMD operators, lamda, and koopman V + # note that this method is built by considering row-wise collected data + [ + self._coef_, + self._eigenvalues_, + self._eigenvectors_, + self._unnormalized_modes, + ] = self._regressor_compute_kdmdoperator(self._X.T, self._Y.T) + + # Default timesteps + self._set_initial_time_dictionary({"t0": 0, "tend": n_samples - 1, "dt": 1}) + + # _coef_ as the transpose + # self._coef_ = self._regressor_atilde.T + + return self + + def predict(self, x): + """ + Predicts the future states based on the given input data. + + Args: + x: numpy.ndarray, shape (n_samples, n_features) + Measurement data upon which to base the prediction. + + Returns: + numpy.ndarray, shape (n_samples, n_features) + Prediction of the future states. + """ + + check_is_fitted(self, "coef_") + x, _ = self._detect_reshape(x, offset=False) + + phi = self._compute_psi(x_col=x.T) + phi_next = np.diag(self.eigenvalues_) @ phi + x_next_T = self._unnormalized_modes @ phi_next + y = np.real(x_next_T).T + return self._return_orig_shape(y) + + def _compute_phi(self, x_col): + """ + Computes the phi(x) given x. + + Args: + x_col: numpy.ndarray, shape (n_samples, n_features) + Measurement data upon which to compute phi values. + + Returns: + numpy.ndarray, shape (n_samples, n_input_features_) + Value of phi at x. + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + psi = self._compute_psi(x_col) + phi = np.real(self.eigenvectors_ @ psi) + return phi + + def _compute_psi(self, x_col): + """ + Computes the psi(x) given x. + + Args: + x_col: numpy.ndarray, shape (n_samples, n_features) + Measurement data upon which to compute psi values. + + Returns: + numpy.ndarray, shape (n_samples, n_input_features_) + Value of psi at x. + """ + # compute psi - one column if x is a row + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + return self._tmp_compute_psi_kdmd @ self.kernel(self._X.T, x_col.T) + + @property + def coef_(self): + """ + Getter property for the coef_ attribute. + + Returns: + numpy.ndarray, shape (svd_rank, svd_rank) + Reduced Koopman state transition matrix. + """ + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + """ + Getter property for the state_matrix_ attribute. + + Returns: + numpy.ndarray, shape (svd_rank, svd_rank) + Reduced Koopman state transition matrix. + """ + check_is_fitted(self, "_state_matrix_") + return self._state_matrix_ + + @property + def eigenvalues_(self): + """ + Getter property for the eigenvalues_ attribute. + + Returns: + numpy.ndarray, shape (svd_rank,) + Koopman eigenvalues. + """ + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def eigenvectors_(self): + """ + Getter property for the eigenvectors_ attribute. + + Returns: + numpy.ndarray, shape (svd_rank, svd_rank) + Koopman eigenvectors. + """ + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def unnormalized_modes(self): + """ + Getter property for the unnormalized_modes attribute. + + Returns: + numpy.ndarray, shape (svd_rank, n_input_features_) + Koopman unnormalized modes. + """ + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + """ + Getter property for the ur attribute. + + Returns: + numpy.ndarray, shape (n_samples_, n_input_features_) + Linear matrix that maps kernel product features to eigenfunctions. + """ + check_is_fitted(self, "_ur") + return self._ur + + def _regressor_compute_kdmdoperator(self, X, Y): + """ + Computes the KDMD operator given input data X and target data Y. + + Args: + X: numpy.ndarray, shape (n_samples_, n_input_features_) + Training data input. + Y: numpy.ndarray, shape (n_samples_, n_input_features_) + Training data target output. + + Returns: + list + A list containing the following elements: + - koopman_matrix: numpy.ndarray, shape (svd_rank, svd_rank) + Reduced Koopman state transition matrix. + - koopman_eigvals: numpy.ndarray, shape (svd_rank,) + Koopman eigenvalues. + - koopman_eigenvectors: numpy.ndarray, shape (svd_rank, svd_rank) + Koopman eigenvectors. + - unnormalized_modes: numpy.ndarray, shape (svd_rank, n_input_features_) + Koopman unnormalized modes. + """ + # compute kernel K(X,X) + # since sklearn kernel function takes rowwise collected data. + KXX = self.kernel(X, X) + KYX = self.kernel(Y, X) + + # compute eig of PD matrix, so it is SVD + U, s2, _ = compute_svd(KXX, self.svd_rank) + s = np.sqrt(s2) + # remember that we need sigma, but svd or eig only gives you the s^2 + + # optional compute tiknoiv reg + if self.tikhonov_regularization is not None: + s = ( + s**2 + self.tikhonov_regularization * np.linalg.norm(X) + ) * np.reciprocal(s) + + koopman_matrix = ( + np.diag(np.reciprocal(s)) + @ U.T.conj() + @ KYX.T + @ U + @ np.diag(np.reciprocal(s)) + ) + + # optional compute fb + if self.forward_backward: + KYY = self.kernel(Y, Y) + KXY = KYX.T + bU, bs2, _ = compute_svd(KYY, self.svd_rank) + bs = np.sqrt(bs2) + if self.tikhonov_regularization is not None: + bs = ( + bs**2 + self.tikhonov_regularization * np.linalg.norm(Y) + ) * np.reciprocal(bs) + + atilde_back = ( + np.diag(np.reciprocal(bs)) + @ bU.T.conj() + @ KXY.T + @ bU + @ np.diag(np.reciprocal(bs)) + ) + koopman_matrix = sqrtm(koopman_matrix @ np.linalg.inv(atilde_back)) + + # self._regressor_atilde = atilde + self._state_matrix_ = koopman_matrix + + # compute eigenquantities + koopman_eigvals, koopman_eigenvectors = np.linalg.eig(koopman_matrix) + + # compute unnormalized V + BV = np.linalg.lstsq(U @ np.diag(s), X, rcond=None)[0].T + unnormalized_modes = BV @ koopman_eigenvectors + + # compute psi + self._ur = BV # U @ np.diag(s) + self._tmp_compute_psi_kdmd = ( + np.linalg.inv(koopman_eigenvectors) @ np.diag(np.reciprocal(s)) @ U.T + ) + + return [ + koopman_matrix, + koopman_eigvals, + koopman_eigenvectors, + unnormalized_modes, + ] + + def _set_initial_time_dictionary(self, time_dict): + """ + Sets the initial time dictionary. + + Args: + time_dict: dict + Dictionary containing the time information with keys 't0', 'tend', + and 'dt'. + """ + if not ("t0" in time_dict and "tend" in time_dict and "dt" in time_dict): + raise ValueError('time_dict must contain the keys "t0", "tend" and "dt".') + if len(time_dict) > 3: + raise ValueError( + 'time_dict must contain only the keys "t0", "tend" and "dt".' + ) + + self._original_time = DMDTimeDict(dict(time_dict)) + self._dmd_time = DMDTimeDict(dict(time_dict)) + + +def _col_major_2darray(X): + """ + Converts the input snapshots into a 2D matrix by column-major ordering. + + Args: + X: int or numpy.ndarray + The input snapshots. + + Returns: + snapshots: numpy.ndarray + The 2D matrix that contains the flattened snapshots. + + snapshots_shape: tuple + The shape of the original snapshots. + """ + + # If the data is already 2D ndarray + if isinstance(X, np.ndarray) and X.ndim == 2: + snapshots = X + snapshots_shape = None + else: + input_shapes = [np.asarray(x).shape for x in X] + + if len(set(input_shapes)) != 1: + raise ValueError("Snapshots have not the same dimension.") + + snapshots_shape = input_shapes[0] + snapshots = np.transpose([np.asarray(x).flatten() for x in X]) + + # check condition number of the data passed in + cond_number = np.linalg.cond(snapshots) + if cond_number > 10e4: + warn( + "Input data matrix X has condition number {}. " + """Consider preprocessing data, passing in augmented + data matrix, or regularization methods.""".format( + cond_number + ) + ) + + return snapshots, snapshots_shape diff --git a/DSA/pykoopman/src/pykoopman/regression/_nndmd.py b/DSA/pykoopman/src/pykoopman/regression/_nndmd.py new file mode 100644 index 0000000..2518761 --- /dev/null +++ b/DSA/pykoopman/src/pykoopman/regression/_nndmd.py @@ -0,0 +1,1454 @@ +"""module for implementing a neural network DMD""" +from __future__ import annotations + +import pickle +from abc import abstractmethod +from warnings import warn + +import lightning as L +import numpy as np +import torch +from pykoopman.regression._base import BaseRegressor +from sklearn.utils.validation import check_is_fitted +from torch import nn +from torch.nn.utils.rnn import pad_sequence +from torch.utils.data import DataLoader +from torch.utils.data import Dataset + + +# todo: add the control version + + +class MaskedMSELoss(nn.Module): + """ + Calculates the mean squared error (MSE) loss between `output` and `target`, with + masking based on `target_lens`. The `max_look_forward` will determine the + + Args: + max_look_forward + + Returns: + The MSE loss as a scalar tensor. + """ + + def __init__(self, max_look_forward): + super().__init__() + self.max_look_forward = torch.tensor(max_look_forward, dtype=torch.int) + + def forward(self, output, target, target_lens): + """ + Calculates the MSE loss between `output` and `target`, with masking based on + `target_lens`. + + Args: + output (torch.Tensor): The output tensor of shape (batch_size, + sequence_length, features). + target (torch.Tensor): The target tensor of shape (batch_size, + sequence_length, features). + target_lens (torch.Tensor): A tensor of shape (batch_size,) containing the + sequence lengths for each item in the batch. + + Returns: + The MSE loss as a scalar tensor. + """ + + # if target is shorter than output, just cut output off + if target.size(1) < self.max_look_forward: + output = output[:, : target.size(1), :] + + # Create mask using target_lens + mask = torch.zeros_like(output, dtype=torch.bool) + for i, length in enumerate(target_lens): + if length > self.max_look_forward: + length_used = self.max_look_forward + else: + length_used = length + mask[i, :length_used, :] = 1 + + # Compute squared differences and apply mask + squared_diff = torch.pow(output - target, 2) + squared_diff_masked = torch.where( + mask, squared_diff, torch.zeros_like(squared_diff) + ) + + # Compute the MSE loss + mse_loss = squared_diff_masked.sum() / mask.sum() + + return mse_loss + + +class FFNN(nn.Module): + """A feedforward neural network with customizable architecture and activation + functions. + + Args: + input_size (int): The size of the input layer. + hidden_sizes (list): A list of the sizes of the hidden layers. + output_size (int): The size of the output layer. + activations (str): A string for activation functions for every layer. + + Attributes: + layers (nn.ModuleList): A list of the neural network layers. + """ + + def __init__( + self, input_size, hidden_sizes, output_size, activations, include_state=False + ): + super(FFNN, self).__init__() + + activations_dict = { + "relu": nn.ReLU(), + "sigmoid": nn.Sigmoid(), + "tanh": nn.Tanh(), + "swish": nn.SiLU(), + "elu": nn.ELU(), + "mish": nn.Mish(), + "linear": nn.Identity(), + } + # whether to directly encode state in observables + self.include_state = include_state + if self.include_state: + output_size_ = output_size - input_size + else: + output_size_ = output_size + + # Define the activation + act = activations_dict[activations] + + # Define the input layer + self.layers = nn.ModuleList() + + # if linear layer, remove bias + if activations == "linear": + bias = False + else: + bias = True + + if len(hidden_sizes) == 0: + # if no hidden layer, then entire NN is just a linear one + self.layers.append(nn.Linear(input_size, output_size_, bias)) + else: + self.layers.append(nn.Linear(input_size, hidden_sizes[0], bias)) + if activations != "linear": + self.layers.append(act) + + # Define the hidden layers + for i in range(1, len(hidden_sizes)): + self.layers.append( + nn.Linear(hidden_sizes[i - 1], hidden_sizes[i], bias) + ) + if activations != "linear": + self.layers.append(act) + + # Define the last output layer + self.layers.append(nn.Linear(hidden_sizes[-1], output_size_, bias=False)) + + def forward(self, x): + """Performs a forward pass through the neural network. + + Args: + x (torch.Tensor): The input tensor to the neural network. + + Returns: + torch.Tensor: The output tensor of the neural network. + """ + in_x = x + for layer in self.layers: + x = layer(x) + + if self.include_state: + x = torch.cat((in_x, x), 1) + return x + + +class HardCodedLinearLayer(nn.Module): + def __init__(self, input_size, output_size): + + pass + + def forward(self, x): + pass + + +class BaseKoopmanOperator(nn.Module): + """Base class for Koopman operator models. + + Args: + dim (int): The dimension of the state space. + dt (float, optional): The time step size. Defaults to 1.0. + init_std (float, optional): The standard deviation of the initializer. + Defaults to 0.1. + + Attributes: + dim (int): The dimension of the state space. + dt (torch.Tensor): The time step size. + init_std (float): The standard deviation of the initializer. + + Note: + rule for self.init_std: a number between 0.1 and 10 over dt + + """ + + def __init__( + self, + dim: int, + dt: float = 1.0, + init_std: float = 0.1, + ): + """ + Initializes the `BaseKoopmanOperator` instance. + """ + super().__init__() + self.dim = dim + self.register_buffer("dt", torch.tensor(dt)) + self.init_std = init_std + + def forward(self, x): + """ + Computes the forward pass of the `BaseKoopmanOperator`. + + Given `x` as a row vector, return `x @ K.T` + + Args: + x (torch.Tensor): The input tensor. + + Returns: + torch.Tensor: The output tensor. + """ + koopman_operator = self.get_discrete_time_Koopman_Operator() + xnext = torch.matmul(x, koopman_operator.t()) # following pytorch convention + return xnext + + def get_discrete_time_Koopman_Operator(self): + """ + Computes the discrete-time Koopman operator. + + Returns: + torch.Tensor: The discrete-time Koopman operator. + """ + return torch.matrix_exp(self.dt * self.get_K()) + + @abstractmethod + def get_K(self): + """ + Computes the matrix K. + + Returns: + torch.Tensor: The matrix K. + """ + pass + + +class StandardKoopmanOperator(BaseKoopmanOperator): + """ + Standard Koopman operator that only has a diagonal matrix for the Koopman operator. + """ + + def __init__(self, **kwargs): + """ + Initializes the StandardKoopmanOperator. + + Args: + **kwargs: Additional keyword arguments. + """ + super().__init__(**kwargs) + self.register_parameter( + "K", + torch.nn.Parameter( + torch.nn.init.trunc_normal_( + torch.zeros(self.dim, self.dim), std=self.init_std + ) + ), + ) + + def get_K(self): + """ + Computes the Koopman operator. + + Returns: + The Koopman operator. + """ + return self.K + + +class HamiltonianKoopmanOperator(BaseKoopmanOperator): + """ + Hamiltonian Koopman operator that has an off-diagonal matrix for the Koopman + operator. + """ + + def __init__(self, **kwargs): + """ + Initializes the HamiltonianKoopmanOperator. + + Args: + **kwargs: Additional keyword arguments. + """ + super().__init__(**kwargs) + self.register_parameter( + "off_diagonal", + torch.nn.Parameter( + torch.nn.init.trunc_normal_( + torch.zeros(self.dim, self.dim), std=self.init_std + ) + ), + ) + + def get_K(self): + """ + Computes the Koopman operator. + + Returns: + The Koopman operator. + """ + return self.off_diagonal - self.off_diagonal.t() + + +class DissipativeKoopmanOperator(BaseKoopmanOperator): + """ + Dissipative Koopman operator that has an off-diagonal and a diagonal matrix for the + Koopman operator. + """ + + def __init__(self, **kwargs): + """ + Initializes the DissipativeKoopmanOperator. + + Args: + **kwargs: Additional keyword arguments. + """ + super().__init__(**kwargs) + self.register_parameter( + "off_diagonal", + torch.nn.Parameter( + torch.nn.init.trunc_normal_( + torch.zeros(self.dim, self.dim), std=self.init_std + ) + ), + ) + self.register_parameter( + "diagonal", + torch.nn.Parameter( + -torch.pow( + torch.nn.init.trunc_normal_( + torch.zeros(self.dim), std=self.init_std + ), + 2, + ) + ), + ) + + def get_K(self): + """ + Computes the Koopman operator. + + Returns: + The Koopman operator. + """ + return torch.diag(self.diagonal) + self.off_diagonal - self.off_diagonal.t() + + +class DLKoopmanRegressor(L.LightningModule): + """ + Deep Learning Koopman Regressor module using a Feedforward Neural Network + encoder and decoder to learn the Koopman operator for a given dynamical system. + + Args: + mode (str): Type of Koopman operator to use - "Standard", "Hamiltonian" or + "Dissipative". Defaults to None. + dt (float): Time step of the Koopman operator. Defaults to 1.0. + look_forward (int): Number of time steps to predict in the future. + Defaults to 1. + config_encoder (dict): Dictionary containing encoder configurations + - input_size, output_size, hidden_sizes, activations. Defaults to {}. + config_decoder (dict): Dictionary containing decoder configurations + - input_size, output_size, hidden_sizes, activations. Defaults to {}. + lbfgs (bool): Use L-BFGS optimizer. Defaults to False. + + Attributes: + input_size (int): Size of input to the encoder. + output_size (int): Size of output from the encoder. + _encoder (FFNN): Feedforward Neural Network encoder. + _decoder (FFNN): Feedforward Neural Network decoder. + _koopman_propagator (BaseKoopmanOperator): Type of Koopman operator used. + look_forward (int): Number of time steps to predict in the future. + using_lbfgs (bool): Use L-BFGS optimizer. + masked_loss_metric (MaskedMSELoss): Mean Squared Error Loss function. + """ + + def __init__( + self, + mode=None, + dt=1.0, + look_forward=1, + config_encoder=dict(), + config_decoder=dict(), + lbfgs=False, + std_koopman=1e-1, + include_state=False, + ): + super(DLKoopmanRegressor, self).__init__() + + self.input_size = config_encoder["input_size"] + self.output_size = config_encoder["output_size"] + + self._encoder = FFNN( + input_size=config_encoder["input_size"], + hidden_sizes=config_encoder["hidden_sizes"], + output_size=config_encoder["output_size"], + activations=config_encoder["activations"], + include_state=include_state, + ) + + self._decoder = FFNN( + input_size=config_decoder["input_size"], + hidden_sizes=config_decoder["hidden_sizes"], + output_size=config_decoder["output_size"], + activations=config_decoder["activations"], + ) + + if mode == "Dissipative": + self._koopman_propagator = DissipativeKoopmanOperator( + dim=config_encoder["output_size"], dt=dt, init_std=std_koopman + ) + elif mode == "Hamiltonian": + self._koopman_propagator = HamiltonianKoopmanOperator( + dim=config_encoder["output_size"], dt=dt, init_std=std_koopman + ) + else: + self._koopman_propagator = StandardKoopmanOperator( + dim=config_encoder["output_size"], dt=dt, init_std=std_koopman + ) + + self.look_forward = look_forward + self.using_lbfgs = lbfgs + + # self.masked_loss_metric = MaskedMSELoss(1) + self.masked_loss_metric = MaskedMSELoss(self.look_forward) + + if self.using_lbfgs: + self.automatic_optimization = False + + def training_step(batch, batch_idx): + optimizer = self.optimizers() + + def closure(): + + # unpack batch data + x, y, ys = batch + + # get the max look forward in this batch + batch_look_forward = ys.max() + + # encode x + encoded_x = self._encoder(x) + + # future unroll look_forward + phi_seq = self._propagate_encoded_n_steps( + encoded_x, n=batch_look_forward + ) + + # standard RNN loss + decoded_y_seq_rnn = torch.zeros( + (x.size(0), self.look_forward, self.input_size), + device=self.device, + ) + + for i in range(batch_look_forward): + decoded_y_seq_rnn[:, i, :] = self._decoder(phi_seq[:, i, :]) + rnn_loss = self.masked_loss_metric(decoded_y_seq_rnn, y, ys) + + # autoencoder reconstruction loss + # for x + decoded_x = self._decoder(encoded_x) + rec_loss = torch.nn.functional.mse_loss(decoded_x, x) + + # for y_seq + decoded_y_seq_rec = torch.zeros( + (x.size(0), self.look_forward, self.input_size), + device=self.device, + ) + for i in range(batch_look_forward): + decoded_y_seq_rec[:, i, :] = self._decoder( + self._encoder(y[:, i, :]) + ) + rec_loss += self.masked_loss_metric(decoded_y_seq_rec, y, ys) + + loss = rnn_loss + rec_loss + + optimizer.zero_grad() + self.manual_backward(loss) + + self.log("loss", loss, prog_bar=True) + self.log("rec_loss", rec_loss, prog_bar=True) + self.log("rnn_loss", rnn_loss, prog_bar=True) + + return loss + + optimizer.step(closure=closure) + + self.training_step = training_step + + self.save_hyperparameters() + + def forward(self, x, n=1): + """ + Propagates input tensor through the model to obtain predicted output tensor + after n steps. + + Args: + x: Input tensor with shape (batch_size, input_size). + n (int): Number of steps to propagate. + + Returns: + decoded: Output tensor with shape (batch_size, output_size). + + """ + encoded = self._encoder(x) + phi_seq = self._propagate_encoded_n_steps(encoded, n) + decoded = self._decoder(phi_seq[:, -1, :]) + return decoded + + def forward_all(self, x, n): + """ + Forward pass of the Koopman Regressor for a given sequence of input states `x`. + This method returns the decoded sequence for all steps within the horizon `n`. + + Args: + x (torch.Tensor): The input state sequence with shape `(batch_size, seq_len, + input_size)`. + n (int): The maximum horizon for which to generate the output sequence. + + Returns: + decoded (torch.Tensor): The decoded sequence with shape `(batch_size, n, + input_size)`. + """ + encoded = self._encoder(x) + phi_seq = self._propagate_encoded_n_steps(encoded, n) + decoded = torch.zeros(x.size(0), n, self.input_size) + for i in range(n): + decoded[:, i, :] = self._decoder(phi_seq[:, i, :]) + return decoded + + def _propagate_encoded_n_steps(self, encoded, n): + """ + Propagates the encoded tensor linearly in the encoded space for n steps. + + Args: + encoded (torch.Tensor): The encoded tensor of shape (batch_size, + encoded_size). n (int): The number of steps to propagate. + + Returns: + torch.Tensor: The propagated encoded tensor of shape (batch_size, n, + encoded_size). + """ + encoded_future = [] + for i in range(n): + encoded = self._koopman_propagator(encoded) + encoded_future.append(encoded) + return torch.stack(encoded_future, 1) + + def training_step(self, batch, batch_idx): + """ + Defines a training step for the DL Koopman Regressor. + + Args: + batch: tuple of (x, y, ys), representing the input data, + the true output data, and the sequence length for + each sample in the batch. + batch_idx: integer, the index of the batch. + + Returns: + tensor representing the loss value for this training step. + """ + # unpack batch data + x, y, ys = batch + + # get the max look forward in this batch + batch_look_forward = ys.max() + + # encode x + encoded_x = self._encoder(x) + + # future unroll look_forward + phi_seq = self._propagate_encoded_n_steps(encoded_x, n=batch_look_forward) + + # standard RNN loss + decoded_y_seq_rnn = torch.zeros( + (x.size(0), self.look_forward, self.input_size), device=self.device + ) + + for i in range(batch_look_forward): + decoded_y_seq_rnn[:, i, :] = self._decoder(phi_seq[:, i, :]) + rnn_loss = self.masked_loss_metric(decoded_y_seq_rnn, y, ys) + + # autoencoder reconstruction loss + # for x + decoded_x = self._decoder(encoded_x) + rec_loss = torch.nn.functional.mse_loss(decoded_x, x) + + # for y_seq + decoded_y_seq_rec = torch.zeros( + (x.size(0), self.look_forward, self.input_size), device=self.device + ) + for i in range(batch_look_forward): + decoded_y_seq_rec[:, i, :] = self._decoder(self._encoder(y[:, i, :])) + rec_loss += self.masked_loss_metric(decoded_y_seq_rec, y, ys) + + loss = rnn_loss + rec_loss + + self.log("loss", loss, prog_bar=True) + self.log("rec_loss", rec_loss, prog_bar=True) + self.log("rnn_loss", rnn_loss, prog_bar=True) + return loss + + def configure_optimizers(self): + """Configures and returns the optimizer to use for training. + + If using LBFGS optimizer, set `using_lbfgs` attribute to True when + initializing the DLKoopmanRegressor instance. + + Returns: + An instance of torch.optim.Optimizer to use for training. + """ + if self.using_lbfgs: + optimizer = torch.optim.LBFGS( + self.parameters(), + lr=1, + history_size=100, + max_iter=20, + line_search_fn="strong_wolfe", + ) + else: + optimizer = torch.optim.Adam(self.parameters(), lr=1e-3) + return optimizer + + +class SeqDataDataset(Dataset): + """ + A PyTorch Dataset class to handle sequential data in the format of (x, y, ys), + where x is the input sequence, y is the target output sequence and ys is a vector + indicating the maximum look-ahead distance. + + Args: + x (torch.Tensor): The input sequence tensor of shape (batch_size, + sequence_length, input_size). + y (torch.Tensor): The output sequence tensor of shape (batch_size, + sequence_length, output_size). + ys (torch.Tensor): The maximum look-ahead distance tensor of shape + (batch_size,). + transform (callable, optional): Optional normalization function to apply to + x and y. + + Returns: + torch.Tensor: The preprocessed input sequence tensor. + torch.Tensor: The preprocessed target output sequence tensor. + torch.Tensor: The maximum look-ahead distance tensor. + """ + + def __init__(self, x, y, ys, transform=None): + self.x = x.squeeze(1) + self.y = y + self.ys = ys + self.normalization = transform + + def __len__(self): + return len(self.ys) + + def __getitem__(self, idx): + x = self.x[idx].clone() + y = self.y[idx].clone() + ys = self.ys[idx].clone() + + if self.normalization: + x = self.normalization(x) + y = self.normalization(y) + + return x, y, ys + + +class TensorNormalize(nn.Module): + """ + Normalizes the input tensor by subtracting the mean and dividing by the standard + deviation. + + Args: + mean (float or tensor): The mean value to be subtracted from the input tensor. + std (float or tensor): The standard deviation value to divide the input tensor + by. + """ + + def __init__(self, mean, std): + super().__init__() + self.mean = mean + self.std = std + + def forward(self, tensor: torch.Tensor): + """ + Forward pass of the normalization module. + + Args: + tensor (tensor): The input tensor to be normalized. + + Returns: + The normalized tensor. + """ + return torch.divide((tensor - self.mean), self.std) + # return # tensor.copy_(tensor.sub_(self.mean).div_(self.std)) + + def __repr__(self) -> str: + """ + Returns a string representation of the TensorNormalize module. + + Returns: + A string representation of the module. + """ + return f"{self.__class__.__name__}(mean={self.mean}, std={self.std})" + + +class InverseTensorNormalize(nn.Module): + """ + A PyTorch module that performs inverse normalization on input tensors using + a given mean and standard deviation. + + Args: + mean (float or sequence): The mean used for normalization. + std (float or sequence): The standard deviation used for normalization. + + Example: + >>> mean = [0.5, 0.5, 0.5] + >>> std = [0.5, 0.5, 0.5] + >>> inv_norm = InverseTensorNormalize(mean, std) + >>> normalized_tensor = torch.tensor([[-1.0, 0.0, 1.0], [-0.5, 0.0, 0.5]]) + >>> output = inv_norm(normalized_tensor) + + Attributes: + mean (float or sequence): The mean used for normalization. + std (float or sequence): The standard deviation used for normalization. + """ + + def __init__(self, mean, std): + super().__init__() + self.mean = mean + self.std = std + + def forward(self, tensor: torch.Tensor): + return torch.multiply(tensor, self.std) + self.mean + # return tensor.copy_(tensor.mul_(self.std).add_(self.mean)) + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(mean={self.mean}, std={self.std})" + + +class SeqDataModule(L.LightningDataModule): + """ + Class for creating sequence data dataloader for training and validation. + + Args: + data_tr: List of 2D numpy.ndarray representing training data trajectories. + data_val: List of 2D numpy.ndarray representing validation data trajectories. + Can be None. + look_forward: Number of time steps to predict forward. + batch_size: Size of each batch of data. + normalize: Whether to normalize the input data or not. Default is True. + normalize_mode: The type of normalization to use. Either "equal" or "max". + Default is "equal". + normalize_std_factor: Scaling factor for standard deviation during + normalization. Default is 2.0. + + Methods: + prepare_data(): Prepares the data by converting to time-delayed data and + computing mean and std if normalize is True. + setup(stage=None): Sets up training and validation datasets. + train_dataloader(): Returns a DataLoader for training data. + val_dataloader(): Returns a DataLoader for validation data. + convert_seq_list_to_delayed_data(data_list, look_back, look_forward): Converts + list of sequences to time-delayed data. + collate_fn(batch): Custom collate function to be used with DataLoader. + + Returns: + A SeqDataModule object. + """ + + def __init__( + self, + data_tr, + data_val, + look_forward=10, + batch_size=32, + normalize=True, + normalize_mode="equal", + normalize_std_factor=2.0, + ): + """ + Initialize a SeqDataModule. + + Args: + data_tr (Union[str, List[np.ndarray]]): Training data. Can be either a + list of 2D numpy arrays, each 2D numpy array representing a trajectory, + or the path to a pickle file containing such a list. + data_val (Optional[Union[str, List[np.ndarray]]]): Validation data. + Can be either a list of 2D numpy arrays, each 2D numpy array + representing a trajectory, or the path to a pickle file + containing such a list. + look_forward (int): Number of time steps to predict into the future. + batch_size (int): Number of samples per batch. + normalize (bool): Whether to normalize the data. Default is True. + normalize_mode (str): Mode for normalization. Can be either "equal" + or "max". "equal" divides by the standard deviation, while "max" + divides by the maximum absolute value of the data. Default is "equal". + normalize_std_factor (float): Scaling factor for the standard deviation in + normalization. Default is 2.0. + + Returns: + None. + """ + super().__init__() + # input data_tr or data_val is a list of 2D np.ndarray. each 2d + # np.ndarray is a trajectory, and the axis 0 is number of samples, axis 1 is + # the number of system state + self.data_tr = data_tr + self.data_val = data_val + self.look_forward = look_forward + self.batch_size = batch_size + self.look_back = 1 + self.normalize = normalize + self.normalize_mode = normalize_mode + self.normalization = None + self.inverse_transform = None + self.normalize_std_factor = normalize_std_factor + + def prepare_data(self): + """ + Preprocesses the input training and validation data by checking their types, + checking for normalization, finding the mean and standard deviation of + the training data (if normalization is enabled), and creating time-delayed data + from the input data. + + Raises: + ValueError: If the training data is None or has an invalid type. + ValueError: If the validation data has an invalid type. + TypeError: If the data is complex or not float. + + """ + # train data + if self.data_tr is None: + raise ValueError("You must feed training data!") + if isinstance(self.data_tr, list): + data_list = self.data_tr + elif isinstance(self.data_tr, str): + f = open(self.data_tr, "rb") + data_list = pickle.load(f) + else: + raise ValueError("Wrong type of `self.data_tr`") + + # check train data + data_list = self.check_list_of_nparray(data_list) + + # find the mean, std + if self.normalize: + stacked_data_list = np.vstack(data_list) + mean = stacked_data_list.mean(axis=0) + std = stacked_data_list.std(axis=0) + + # zero mean so easier for downstream + self.mean = torch.FloatTensor(mean) * 0 + # default = 2.0, more stable + self.std = torch.FloatTensor(std) * self.normalize_std_factor + + if self.normalize_mode == "max": + self.std = torch.ones_like(self.std) * self.std.max() + + # prevent divide by zero error + for i in range(len(self.std)): + if self.std[i] < 1e-6: + self.std[i] += 1e-3 + + # get transform + self.normalization = TensorNormalize(self.mean, self.std) + + # get inverse transform + self.inverse_transform = InverseTensorNormalize(self.mean, self.std) + + # create time-delayed data + self._tr_x, self._tr_yseq, self._tr_ys = self.convert_seq_list_to_delayed_data( + data_list, self.look_back, self.look_forward + ) + + # validation data + if self.data_val is not None: + # raise ValueError("You need to feed validation data!") + if isinstance(self.data_val, list): + data_list = self.data_val + elif isinstance(self.data_val, str): + f = open(self.data_val, "rb") + data_list = pickle.load(f) + else: + raise ValueError("Wrong type of `self.data_val`") + + # check val data + data_list = self.check_list_of_nparray(data_list) + + # create time-delayed data + ( + self._val_x, + self._val_yseq, + self._val_ys, + ) = self.convert_seq_list_to_delayed_data( + data_list, self.look_back, self.look_forward + ) + else: + warn("Warning: no validation data prepared") + + def setup(self, stage=None): + """ + Prepares the train and validation datasets for the Lightning module. + The train dataset is created from the training data specified in the + constructor by creating time-delayed versions of the input/output sequences. + If `normalize` is True, the data is normalized using the mean and standard + deviation of the training data. The validation dataset is created from the + validation data specified in the constructor in the same way as the training + dataset. If `normalize` is True, it is also normalized using the mean and + standard deviation of the training data. If `stage` is not "fit", + an exception is raised as the `setup()` method has not been implemented + for other stages. + + Args: + stage: The stage of training, validation or testing (default is None). + + Raises: + NotImplementedError: If `stage` is not "fit". + """ + # Load data and split into train and validation sets here + # Assign train/val datasets for use in dataloaders + if stage == "fit": + self.tr_dataset = SeqDataDataset( + self._tr_x, self._tr_yseq, self._tr_ys, self.normalization + ) + if self.data_val is not None: + self.val_dataset = SeqDataDataset( + self._val_x, self._val_yseq, self._val_ys, self.normalization + ) + else: + raise NotImplementedError("We didn't implement for stage not `fit`") + + def train_dataloader(self): + return DataLoader( + self.tr_dataset, self.batch_size, shuffle=True, collate_fn=self.collate_fn + ) + + def val_dataloader(self): + return DataLoader( + self.val_dataset, self.batch_size, shuffle=True, collate_fn=self.collate_fn + ) + + def convert_seq_list_to_delayed_data(self, data_list, look_back, look_forward): + """ + Converts a list of sequences to time-delayed data by extracting subsequences + of length `look_back` and `look_forward` from each sequence in the list. + + Args: + data_list (List[np.ndarray]): A list of 2D numpy arrays. Each array + represents a trajectory, with axis 0 representing the number of samples + and axis 1 representing the number of system states. + look_back (int): The number of previous time steps to include in each + subsequence. + look_forward (int): The number of future time steps to include in each + subsequence. + + Returns: + Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: A tuple containing three + tensors: + 1) The time-delayed input data, with shape (num_samples, look_back, + num_system_states). + 2) The time-delayed output data, with shape (num_samples, look_forward, + num_system_states). + 3) The sequence lengths of the output data, with shape (num_samples,). + """ + time_delayed_x_list = [] + time_delayed_yseq_list = [] + for seq in data_list: + # if self.look_forward + self.look_back > len(seq): + # raise ValueError("look_forward too large") + n_sub_traj = len(seq) - look_back - look_forward + 1 + if n_sub_traj >= 1: + for i in range(len(seq) - look_back - look_forward + 1): + time_delayed_x_list.append(seq[i : i + look_back]) + time_delayed_yseq_list.append( + seq[i + look_back : i + look_back + look_forward] + ) + else: + # only 1 traj, just to predict to its end + time_delayed_x_list.append(seq[0:1]) + time_delayed_yseq_list.append(seq[1:]) + time_delayed_yseq_lens_list = [x.shape[0] for x in time_delayed_yseq_list] + + # convert data to tensor + time_delayed_x = torch.FloatTensor(np.array(time_delayed_x_list)) + time_delayed_yseq = pad_sequence( + [torch.FloatTensor(x) for x in time_delayed_yseq_list], True + ) + time_delayed_yseq_lens = torch.LongTensor(time_delayed_yseq_lens_list) + return time_delayed_x, time_delayed_yseq, time_delayed_yseq_lens + + def collate_fn(self, batch): + """ + Collates a batch of data. + + Args: + batch: A list of tuples where each tuple represents a sample containing + the input sequence `x`, the output sequence `y`, and the maximum + number of steps to predict `ys`. + + Returns: + A tuple containing the input sequences as a stacked tensor, the output + sequences as a stacked tensor, and the maximum number of steps to predict + as a stacked tensor. + + """ + x_batch, y_batch, ys_batch = zip(*batch) + xx = torch.stack(x_batch, 0) + yy = torch.stack(y_batch, 0) + ys = torch.stack(ys_batch, 0) + return xx, yy, ys + + @classmethod + def check_list_of_nparray(cls, data_list): + """ + Check if the input is a list of numpy arrays, and convert data to float32 if + float64. + + Args: + data_list (List[np.ndarray]): A list of numpy arrays representing system + states. + + Returns: + List[np.ndarray]: The input list of numpy arrays converted to float32. + + Raises: + TypeError: If the input data is complex or not float. + """ + # check if data is complex + if any(np.iscomplexobj(x) for x in data_list): + raise TypeError("Complex data is not supported") + + # check if data has float64 + if any(x.dtype is np.float64 for x in data_list): + warn("Found float64 data. Will convert to float32") + + # convert data to float32 if float64 + for i, data_traj in enumerate(data_list): + if "float" not in data_traj.dtype.name: + raise TypeError("Found data is not float") + if data_traj.dtype.name == "float64": + data_list[i] = data_traj.astype("float32") + + return data_list + + +class NNDMD(BaseRegressor): + """Implementation of Nonlinear Dynamic Mode Decomposition (NNDMD). + + Args: + mode (str): NNDMD mode, `Dissipative` or `Hamiltonian` or else (default: None). + dt (float): Time step (default: 1.0). + look_forward (int): Number of steps to look forward (default: 1). + config_encoder (dict): Configuration for the encoder network + (default: dict(input_size=2, hidden_sizes=[32]*2, output_size=6, + activations='tanh')). + config_decoder (dict): Configuration for the decoder network + (default: dict(input_size=6, hidden_sizes=[32]*2, output_size=2, + activations='linear')). + batch_size (int): Batch size (default: 16). + lbfgs (bool): Whether to use L-BFGS optimizer (default: False). + normalize (bool): Whether to normalize data (default: True). + normalize_mode (str): Normalization mode, `max` or `equal` + (default: 'equal'). + normalize_std_factor (float): Standard deviation factor for normalization + (default: 2.0). + trainer_kwargs (dict): Arguments for the `pytorch_lightning.Trainer` + (default: {}). + + Attributes: + coef_ (np.ndarray): Koopman operator coefficients. + state_matrix_ (np.ndarray): State matrix of the Koopman operator. + eigenvalues_ (np.ndarray): Eigenvalues of the Koopman operator. + eigenvectors_ (np.ndarray): Eigenvectors of the Koopman operator. + ur (np.ndarray): Effective linear transformation. + unnormalized_modes (np.ndarray): Unnormalized modes. + + Note: + The `n_samples_` attribute is meaningless for this class. + The `dt` argument is only included to please the regressor class and has no + real use. + + """ + + def __init__( + self, + mode=None, + dt=1.0, + look_forward=1, + config_encoder=dict( + input_size=2, hidden_sizes=[32] * 2, output_size=6, activations="tanh" + ), + config_decoder=dict( + input_size=6, hidden_sizes=[32] * 2, output_size=2, activations="linear" + ), + batch_size=16, + lbfgs=False, + normalize=True, + normalize_mode="equal", + normalize_std_factor=2.0, + std_koopman=1e-1, + include_state=False, + trainer_kwargs={}, + ): + """Initializes the NNDMD model.""" + self.mode = mode + self.look_forward = look_forward + self.config_encoder = config_encoder + self.config_decoder = config_decoder + self.lbfgs = lbfgs + self.normalize = normalize + self.normalize_mode = normalize_mode + self.dt = dt + self.trainer_kwargs = trainer_kwargs + self.normalize_std_factor = normalize_std_factor + self.batch_size = batch_size + self.std_koopman = std_koopman + self.include_state = include_state + + # build DLK regressor + self._regressor = DLKoopmanRegressor( + mode, dt, look_forward, config_encoder, config_decoder, lbfgs, std_koopman + ) + + def fit(self, x, y=None, dt=None): + """fit the NNDMD model with data x,y + + Args: + x (np.ndarray or list): The training input data. If a 2D numpy array, + then it represents a single time-series and each row represents a + state, otherwise it should be a list of 2D numpy arrays. + y (np.ndarray or list, optional): The target output data, + corresponding to `x`. If `None`, `x` is assumed to contain the target + data in its second half. Defaults to `None`. + dt (float, optional): The time step used to generate `x`. + Defaults to `None`. + + Returns: + None. The fitted model is stored in the class attribute `_regressor`. + """ + # build trainer + self.trainer = L.Trainer(**self.trainer_kwargs) + + self.n_input_features_ = self.config_encoder["input_size"] + + # create the data module + # case 1: a single traj, x is 2D np.ndarray, no validation + if y is None and isinstance(x, np.ndarray) and x.ndim == 2: + t0, t1 = x[:-1], x[1:] + list_of_traj = [np.stack((t0[i], t1[i]), 0) for i in range(len(x) - 1)] + self.dm = SeqDataModule( + list_of_traj, + None, + self.look_forward, + self.batch_size, + self.normalize, + self.normalize_mode, + self.normalize_std_factor, + ) + self.n_samples_ = len(list_of_traj) + + # case 2: x, y are 2D np.ndarray, no validation + elif ( + isinstance(x, np.ndarray) + and isinstance(y, np.ndarray) + and x.ndim == 2 + and y.ndim == 2 + ): + t0, t1 = x, y + list_of_traj = [np.stack((t0[i], t1[i]), 0) for i in range(len(x) - 1)] + self.dm = SeqDataModule( + list_of_traj, + None, + self.look_forward, + self.batch_size, + self.normalize, + self.normalize_mode, + self.normalize_std_factor, + ) + self.n_samples_ = len(list_of_traj) + + # case 3: only training data, x is a list of trajectories, y is None + elif isinstance(x, list) and y is None: + self.dm = SeqDataModule( + x, + None, + self.look_forward, + self.batch_size, + self.normalize, + self.normalize_mode, + self.normalize_std_factor, + ) + self.n_samples_ = len(x) + + # case 4: x, y are two lists of trajectories, we have validation data + elif isinstance(x, list) and isinstance(y, list): + self.dm = SeqDataModule( + x, + y, + self.look_forward, + self.batch_size, + self.normalize, + self.normalize_mode, + self.normalize_std_factor, + ) + self.n_samples_ = len(x) + else: + raise ValueError("check `x` and `y` for `self.fit`") + + # trainer starts to train + self.trainer.fit(self._regressor, self.dm) + + # compute Koopman operator information + self._state_matrix_ = ( + self._regressor._koopman_propagator.get_discrete_time_Koopman_Operator() + .detach() + .numpy() + ) + [self._eigenvalues_, self._eigenvectors_] = np.linalg.eig(self._state_matrix_) + + self._coef_ = self._state_matrix_ + + # obtain effective linear transformation + decoder_weight_list = [] + for i in range(len(self._regressor._decoder.layers)): + decoder_weight_list.append( + self._regressor._decoder.layers[i].weight.detach().numpy() + ) + if len(decoder_weight_list) > 1: + self._ur = np.linalg.multi_dot(decoder_weight_list[::-1]) + else: + self._ur = decoder_weight_list[0] + + if self.normalize: + std = self.dm.inverse_transform.std + self._ur = np.diag(std) @ self._ur + + self._unnormalized_modes = self._ur @ self._eigenvectors_ + + def predict(self, x, n=1): + """ + Predict the system state after n steps away from x_0 = x. + + Args: + x (numpy.ndarray or torch.Tensor): Input data of shape + (n_samples, n_features). + n (int): Number of steps to predict the system state into the future. + + Returns: + numpy.ndarray: Predicted system state after n steps, of shape + (n_samples, n_features). + + Note: + By default, the model is stored on the CPU for inference. + """ + self._regressor.eval() + x, _ = self._detect_reshape(x, offset=False) + x = self._convert_input_ndarray_to_tensor(x) + + with torch.no_grad(): + # print("inference device = ", self._regressor.device) + + if self.normalize: + y = self.dm.normalization(x) + y = self._regressor(y, n) + y = self.dm.inverse_transform(y).numpy() + else: + y = self._regressor(x, n).numpy() + y = self._return_orig_shape(y) + return y + + def simulate(self, x, n_steps): + """ + Simulate the system forward in time for `n_steps` steps starting from `x`. + + Args: + x (np.ndarray or torch.Tensor): The initial state of the system. + Should be a 2D array/tensor. + n_steps (int): The number of time steps to simulate the system forward. + + Returns: + np.ndarray: The simulated states of the system. Will be of shape + `(n_steps+1, n_features)`. + """ + self._regressor.eval() + x = self._convert_input_ndarray_to_tensor(x) + x_future = torch.zeros([n_steps + 1, x.size(1)]) + x_future[0] = x + with torch.no_grad(): + for i in range(n_steps): + if self.normalize: + y = self.dm.normalization(x) + y = self._regressor(y, i + 1) + x_future[i + 1] = self.dm.inverse_transform(y) + else: + x_future[i + 1] = self._regressor(x, i + 1) + + return x_future.numpy() + + @property + def A(self): + """Returns the state transition matrix A of the NNDMD model. + + Returns + ------- + A : numpy.ndarray + The state transition matrix of shape (n_states, n_states), where + n_states is the number of states in the model. + """ + return self._state_matrix_ + + @property + def B(self): + # todo: we don't have control considered in nndmd for now + pass + + @property + def C(self): + """ + Returns the matrix C representing the effective linear transformation + from the observables to the Koopman modes. The matrix C is computed during + the fit process as the product of the decoder weights of the trained + autoencoder network. + + Returns: + -------- + numpy.ndarray of shape (n_koopman, n_features) + The matrix C. + """ + return self._ur + + @property + def W(self): + """ + Returns the matrix W representing the Koopman modes. The matrix W is computed + during the fit process as the eigenvectors of the Koopman operator. + + Returns: + -------- + numpy.ndarray of shape (n_koopman, n_koopman) + The matrix V, where each column represents a Koopman mode. + """ + return self._unnormalized_modes + + def phi(self, x_col): + return self._compute_phi(x_col) + + def psi(self, x_col): + return self._compute_psi(x_col) + + def _compute_phi(self, x_col): + """ + Computes the Koopman observable vector `phi(x)` for input `x`. + + Args: + x (np.ndarray or torch.Tensor): The input state vector or tensor. + + Returns: + phi (np.ndarray): The Koopman observable vector `phi(x)` for input `x`. + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + x = x_col.T + + self._regressor.eval() + x = self._convert_input_ndarray_to_tensor(x) + + if self.normalize: + x = self.dm.normalization(x) + phi = self._regressor._encoder(x).detach().numpy().T + return phi + + def _compute_psi(self, x_col): + """ + Computes the Koopman eigenfunction expansion coefficients `psi(x)` given `x`. + + Args: + x (numpy.ndarray): Input data of shape `(n_samples, n_features)`. + + Returns: + numpy.ndarray: Koopman eigenfunction expansion coefficients `psi(x)` + of shape `(n_koopman, n_samples)`. + """ + if x_col.ndim == 1: + x_col = x_col.reshape(-1, 1) + # x = x_col.T + + phi = self._compute_phi(x_col) + psi = np.linalg.inv(self._eigenvectors_) @ phi + return psi + + def _convert_input_ndarray_to_tensor(self, x): + """ + Converts input numpy ndarray to PyTorch tensor with appropriate dtype and + device. + + Args: + x (np.ndarray or torch.Tensor): Input data as numpy ndarray or PyTorch + tensor. + + Returns: + torch.Tensor: Input data as PyTorch tensor. + + Raises: + TypeError: If input data is not a numpy ndarray or PyTorch tensor. + ValueError: If input array has more than 2 dimensions. + """ + if isinstance(x, np.ndarray): + if x.ndim > 2: + raise ValueError("input array should be 1 or 2D") + if x.ndim == 1: + x = x.reshape(1, -1) + # convert to a float32 + # if x.dtype == np.float64: + x = torch.FloatTensor(x) + elif isinstance(x, torch.Tensor): + if x.ndim != 2: + raise ValueError("input tensor `x` must be a 2d tensor") + return x + + @property + def coef_(self): + check_is_fitted(self, "_coef_") + return self._coef_ + + @property + def state_matrix_(self): + return self._state_matrix_ + + @property + def eigenvalues_(self): + check_is_fitted(self, "_eigenvalues_") + return self._eigenvalues_ + + @property + def eigenvectors_(self): + check_is_fitted(self, "_eigenvectors_") + return self._eigenvectors_ + + @property + def unnormalized_modes(self): + check_is_fitted(self, "_unnormalized_modes") + return self._unnormalized_modes + + @property + def ur(self): + check_is_fitted(self, "_ur") + return self._ur + + +if __name__ == "__main__": + pass From 53ef2f1873b07f4604a3044eb04b66a92b8218ac Mon Sep 17 00:00:00 2001 From: ostrow Date: Mon, 27 Oct 2025 18:41:20 -0400 Subject: [PATCH 03/51] add new files for inputDSA --- DSA/base_dmd.py | 186 +++++++++ DSA/controllability_simdist.py | 189 +++++++++ DSA/dmd.py | 234 ++--------- DSA/dmdc.py | 0 DSA/stats.py | 43 +- DSA/subspace_dmdc.py | 737 +++++++++++++++++++++++++++++++++ 6 files changed, 1176 insertions(+), 213 deletions(-) create mode 100644 DSA/base_dmd.py create mode 100644 DSA/controllability_simdist.py create mode 100644 DSA/dmdc.py create mode 100644 DSA/subspace_dmdc.py diff --git a/DSA/base_dmd.py b/DSA/base_dmd.py new file mode 100644 index 0000000..f8e3d28 --- /dev/null +++ b/DSA/base_dmd.py @@ -0,0 +1,186 @@ +"""Base class for DMD implementations.""" + +import numpy as np +import torch +from abc import ABC, abstractmethod + + +class BaseDMD(ABC): + """Base class for DMD implementations with common functionality.""" + + def __init__( + self, + device="cpu", + verbose=False, + send_to_cpu=False, + lamb=0, + ): + """ + Parameters + ---------- + device: string, int, or torch.device + A string, int or torch.device object to indicate the device to torch. + verbose: bool + If True, print statements will be provided about the progress of the fitting procedure. + send_to_cpu: bool + If True, will send all tensors in the object back to the cpu after everything is computed. + This is implemented to prevent gpu memory overload when computing multiple DMDs. + lamb : float + Regularization parameter for ridge regression. Defaults to 0. + """ + self.device = device + self.verbose = verbose + self.send_to_cpu = send_to_cpu + self.lamb = lamb + + # Common attributes + self.data = None + self.n = None + self.ntrials = None + self.is_list_data = False + + # SVD attributes - will be set by subclasses + self.cumulative_explained_variance = None + + def _process_single_dataset(self, data): + """Process a single dataset, handling numpy arrays, tensors, and lists.""" + if isinstance(data, list): + try: + # Attempt to convert to a single tensor if possible (non-ragged) + processed_data = [ + torch.from_numpy(d) if isinstance(d, np.ndarray) else d + for d in data + ] + return torch.stack(processed_data), False + except (RuntimeError, ValueError): + # Handle ragged lists + processed_data = [ + torch.from_numpy(d) if isinstance(d, np.ndarray) else d + for d in data + ] + # Check for consistent last dimension + n_features = processed_data[0].shape[-1] + if not all(d.shape[-1] == n_features for d in processed_data): + raise ValueError( + "All tensors in the list must have the same number of features (last dimension)." + ) + return processed_data, True + + elif isinstance(data, np.ndarray): + return torch.from_numpy(data), False + + return data, False + + def _init_single_data(self, data): + """Initialize data attributes for a single dataset.""" + processed_data, is_ragged = self._process_single_dataset(data) + + if is_ragged: + # Set attributes for ragged data + n_features = processed_data[0].shape[-1] + self.n = n_features + self.ntrials = sum( + d.shape[0] if d.ndim == 3 else 1 for d in processed_data + ) + self.trial_counts = [ + d.shape[0] if d.ndim == 3 else 1 for d in processed_data + ] + self.is_list_data = True + else: + # Set attributes for non-ragged data + if processed_data.ndim == 3: + self.ntrials = processed_data.shape[0] + self.n = processed_data.shape[2] + else: + self.n = processed_data.shape[1] + self.ntrials = 1 + self.is_list_data = False + + return processed_data + + def _compute_explained_variance(self, S): + """Compute cumulative explained variance from singular values.""" + exp_variance = S**2 / torch.sum(S**2) + return torch.cumsum(exp_variance, 0) + + def _compute_rank_from_params(self, S, cumulative_explained_variance, max_rank, + rank=None, rank_thresh=None, rank_explained_variance=None): + """ + Compute rank based on provided parameters. + + Parameters + ---------- + S : torch.Tensor + Singular values + cumulative_explained_variance : torch.Tensor + Cumulative explained variance + max_rank : int + Maximum possible rank + rank : int, optional + Explicit rank specification + rank_thresh : float, optional + Threshold for singular values + rank_explained_variance : float, optional + Explained variance threshold + + Returns + ------- + int + Computed rank + """ + parameters_provided = [rank is not None, rank_thresh is not None, rank_explained_variance is not None] + num_parameters_provided = sum(parameters_provided) + + if num_parameters_provided > 1: + raise ValueError( + "More than one rank parameter was provided. Please provide only one of rank, rank_thresh, or rank_explained_variance." + ) + elif num_parameters_provided == 0: + computed_rank = len(S) + else: + if rank is not None: + computed_rank = rank + elif rank_thresh is not None: + # Find the number of singular values greater than the threshold + computed_rank = int((S > rank_thresh).sum().item()) + if computed_rank == 0: + computed_rank = 1 # Ensure at least rank 1 + elif rank_explained_variance is not None: + cumulative_explained_variance_cpu = cumulative_explained_variance.cpu().numpy() + computed_rank = int(np.searchsorted(cumulative_explained_variance_cpu, rank_explained_variance) + 1) + if computed_rank > len(S): + computed_rank = len(S) + + # Ensure rank doesn't exceed maximum possible + if computed_rank > max_rank: + computed_rank = max_rank + + return computed_rank + + def all_to_device(self, device="cpu"): + """Move all tensor attributes to specified device.""" + for k, v in self.__dict__.items(): + if isinstance(v, torch.Tensor): + self.__dict__[k] = v.to(device) + elif isinstance(v, list) and len(v) > 0 and isinstance(v[0], torch.Tensor): + self.__dict__[k] = [tensor.to(device) for tensor in v] + + @abstractmethod + def fit(self, *args, **kwargs): + """Fit the DMD model. Must be implemented by subclasses.""" + pass + + @abstractmethod + def predict(self, *args, **kwargs): + """Make predictions with the DMD model. Must be implemented by subclasses.""" + pass + + @abstractmethod + def compute_hankel(self, *args, **kwargs): + """Compute Hankel matrix. Must be implemented by subclasses.""" + pass + + @abstractmethod + def compute_svd(self, *args, **kwargs): + """Compute SVD. Must be implemented by subclasses.""" + pass diff --git a/DSA/controllability_simdist.py b/DSA/controllability_simdist.py new file mode 100644 index 0000000..0889847 --- /dev/null +++ b/DSA/controllability_simdist.py @@ -0,0 +1,189 @@ +from typing import Literal +import numpy as np +from scipy.linalg import orthogonal_procrustes + +from DSA.simdist import SimilarityTransformDist + +class ControllabilitySimilarityTransformDist: + """ + Procrustes analysis over vector fields / LTI systems. + Only Euclidean scoring is implemented in this closed-form version. + """ + def __init__( + self, + *, + score_method: Literal["euclidean", "angular"] = "euclidean", + alpha: float = 0.5, + joint_optim: bool = False, + ): + """ + Parameters + ---------- + score_method : {"euclidean", "angular"} + Distance method to use. Euclidean uses Frobenius norm, angular uses principal angles. + alpha : float + Weight (only used if you call fit_score with non-default behavior). + align_inputs : bool + If True, do two-sided Procrustes on controllability matrices (solve for C and C_u). + """ + self.score_method = score_method + self.alpha = alpha + self.joint_optim = joint_optim + + + def fit_score(self, A, B, A_control, B_control, alpha=0.5, return_distance_components=False): + C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( + A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim + ) + + + alpha = self.alpha if alpha is None else alpha + score_method = self.score_method + + if alpha == 0.5: + if return_distance_components: + if self.score_method == 'euclidean': + # sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") ** 2 + # sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") ** 2 + sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") + sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") + return sims_joint_euc, sims_state_joint, sims_control_joint + elif self.score_method == 'angular': + sims_control_joint = np.trace((C @ A_control @ C_u).T @ B_control) / (np.linalg.norm(C @ A_control @ C_u, 'fro') * np.linalg.norm(B_control, 'fro')) + sims_state_joint = np.trace((C @ A @ C.T).T @ B) / (np.linalg.norm(C @ A @ C.T, 'fro') * np.linalg.norm(B, 'fro')) + + sims_control_joint = np.clip(sims_control_joint, -1, 1) + sims_state_joint = np.clip(sims_state_joint, -1, 1) + sims_control_joint =np.arccos(sims_control_joint) + sims_state_joint =np.arccos(sims_state_joint) + sims_control_joint = np.clip(sims_control_joint, 0, np.pi) + sims_state_joint = np.clip(sims_state_joint, 0, np.pi) + + return sims_joint_ang, sims_state_joint, sims_control_joint + else: + if self.score_method == 'euclidean': + return sims_joint_euc + elif self.score_method == 'angular': + return sims_joint_ang + else: + raise ValueError('Choose between Euclidean or angular distance') + + elif alpha == 0.0: + return self.compare_A(A, B, score_method=score_method) + + else: + return self.compare_B(A_control, B_control, score_method=score_method) + + + def get_controllability_matrix(self, A, B): + """ + Computes the controllability matrix K = [B, AB, A^2B, ..., A^(n-1)B]. + + Args: + A (np.ndarray): The state matrix (n x n). + B (np.ndarray): The input matrix (n x m). + + Returns: + np.ndarray: The controllability matrix (n x n*m). + """ + n = A.shape[0] + K = B.copy() + current1_term = B.copy() # Start with A^0 * B = B + current2_term = B.copy() # Start with A^0 * B = B + + for i in range(1, n): + # current_term = np.linalg.matrix_power(A, i) @ B # Use stable matrix power function + current1_term = A @ current1_term + current2_term = A.T @ current2_term + + # Check for numerical instability + # term_norm = np.linalg.norm(current_term) + # if term_norm < 1e-12 or term_norm > 1e12: + # break + + # Check for linear dependence (rank deficiency) + K_test = np.hstack((K, current1_term, current2_term)) + # if np.linalg.matrix_rank(K_test) <= np.linalg.matrix_rank(K): + # break + + K = K_test + return K + + def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False, n=100): + """ + Compares two LTI systems by finding the optimal orthogonal transformation + that aligns their controllability matrices. + + This implements the fast, non-iterative solution to the Orthogonal + Procrustes problem. + + Args: + A1, B1 (np.ndarray): Matrices for the first system. + A2, B2 (np.ndarray): Matrices for the second system. + align_inputs (bool): If True, do two-sided Procrustes (not used in updated version). + n (int): Number of terms in controllability matrix. + + Returns + ------- + C : (n×n) orthogonal state transform + C_u : (p×p) orthogonal input/right transform (identity in updated version) + err : Frobenius residual + cos_sim : cosine similarity between K1 and aligned K2 + """ + # Build controllability matrices: K \in R^{n x p} + K1 = self.get_controllability_matrix(A1, B1) + K2 = self.get_controllability_matrix(A2, B2) + + if not align_inputs: + # One-sided: C = argmin ||K1 - C K2||_F + M = K2 @ K1.T + U, _, Vh = np.linalg.svd(M, full_matrices=False) + C = U @ Vh + K2_aligned = C @ K2 + err = np.linalg.norm(K1 - K2_aligned, "fro") + cos_sim = (np.vdot(K1, K2_aligned).real / + (np.linalg.norm(K1, "fro") * np.linalg.norm(K2, "fro"))) + cos_sim = np.clip(cos_sim, -1, 1) + cos_sim = np.arccos(cos_sim) + cos_sim = np.clip(cos_sim, 0, np.pi) + return C, np.eye(B2.shape[-1]), err, cos_sim + + # Two-sided: C, C_u = argmin ||K1 - C K2 C_u||_F + U1, S1, V1t = np.linalg.svd(K1, full_matrices=False) + U2, S2, V2t = np.linalg.svd(K2, full_matrices=False) + + C = U1 @ U2.T + C_u = V2t.T @ V1t # = V2 @ V1^T + + # import matplotlib.pyplot as plt + # plt.imshow(C_u) + # plt.savefig('C_u.png') + + #TODO: truncate C_u + #TODO: compute error on A and B instead of the observability matrix + K2_aligned = C @ K2 @ C_u + err = np.linalg.norm(K1 - K2_aligned, "fro") + cos_sim = (np.vdot(K1, K2_aligned).real / + (np.linalg.norm(K1, "fro") * np.linalg.norm(K2, "fro"))) + cos_sim = np.clip(cos_sim, -1, 1) + cos_sim = np.arccos(cos_sim) + cos_sim = np.clip(cos_sim, 0, np.pi) + + return C, C_u, err, cos_sim + + @staticmethod + def compare_A(A1, A2, score_method='euclidean'): + simdist = SimilarityTransformDist(iters=1000, score_method=score_method, lr=1e-3, verbose=True) + return simdist.fit_score(A1, A2, score_method=score_method) + + @staticmethod + def compare_B(B1, B2, score_method='euclidean'): + if score_method == 'euclidean': + R, _ = orthogonal_procrustes(B2.T, B1.T) + return np.linalg.norm(B1 - R.T @ B2, "fro") + # return np.linalg.norm(B1 - R.T @ B2, "fro") ** 2 + elif score_method == 'angular': + return np.trace(B1.T @ (R.T @ B2)) / (np.linalg.norm(B1, 'fro') * np.linalg.norm(R.T @ B2, 'fro')) + else: + raise ValueError('Choose between Euclidean or angular distance') + diff --git a/DSA/dmd.py b/DSA/dmd.py index a245a81..6e3e64a 100644 --- a/DSA/dmd.py +++ b/DSA/dmd.py @@ -2,6 +2,10 @@ import numpy as np import torch +try: + from .base_dmd import BaseDMD +except ImportError: + from base_dmd import BaseDMD def embed_signal_torch(data, n_delays, delay_interval=1): @@ -66,33 +70,8 @@ def embed_signal_torch(data, n_delays, delay_interval=1): return embedding -def create_shift_operator(n_features, n_delays, delay_interval, steps_ahead,verbose=False): - """ - Creates the shift operator matrix for a given delay embedding configuration. - - Args: - n_features (int): The number of features (N). - n_delays (int): The number of delays (d). - delay_interval (int): The delay interval (tau). - steps_ahead (int): The number of time steps ahead to predict. - - Returns: - torch.tensor: The shift operator matrix, or None if not constructible. - """ - if steps_ahead != delay_interval: - if verbose: - print("Shift operator is not constructible for the given parameters.") - return None - - embedding_dim = n_delays * n_features - shift_operator = torch.zeros((embedding_dim, embedding_dim)) - - # The bottom (d-1)N rows are the shift part - shift_operator[n_features:, :-n_features] = torch.eye((n_delays - 1) * n_features) - return shift_operator - -class DMD: +class DMD(BaseDMD): """DMD class for computing and predicting with DMD models.""" def __init__( @@ -104,12 +83,11 @@ def __init__( rank_thresh=None, rank_explained_variance=None, reduced_rank_reg=False, - lamb=0, + lamb=1e-8, device="cpu", verbose=False, send_to_cpu=False, steps_ahead=1, - substitute_shift_operator=False ): """ Parameters @@ -162,13 +140,11 @@ def __init__( steps_ahead: int The number of time steps ahead to predict. Defaults to 1. - - substitute_shift_operator: bool - If True, will substitute the bottom (d-1)N rows of the HAVOK operator with a custom shift operator. Defaults to True. """ - self.device = device - self._init_data(data) + super().__init__(device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb) + + self.data = self._init_single_data(data) self.n_delays = n_delays self.delay_interval = delay_interval @@ -176,11 +152,7 @@ def __init__( self.rank_thresh = rank_thresh self.rank_explained_variance = rank_explained_variance self.reduced_rank_reg = reduced_rank_reg - self.lamb = lamb - self.verbose = verbose - self.send_to_cpu = send_to_cpu self.steps_ahead = steps_ahead - self.substitute_shift_operator = substitute_shift_operator # Hankel matrix self.H = None @@ -195,50 +167,6 @@ def __init__( # DMD attributes self.A_v = None self.A_havok_dmd = None - self.is_list_data = isinstance(self.data, list) - - - def _init_data(self, data): - # check if the data is an np.ndarry - if so, convert it to Torch - if isinstance(data, list): - try: - # Attempt to convert to a single tensor if possible (non-ragged) - processed_data = [ - torch.from_numpy(d) if isinstance(d, np.ndarray) else d - for d in data - ] - self.data = torch.stack(processed_data) - except (RuntimeError, ValueError): - # Handle ragged lists - self.data = [ - torch.from_numpy(d) if isinstance(d, np.ndarray) else d - for d in data - ] - # check for consistent last dimension - n_features = self.data[0].shape[-1] - if not all(d.shape[-1] == n_features for d in self.data): - raise ValueError( - "All tensors in the list must have the same number of features (last dimension)." - ) - self.n = n_features - self.ntrials = sum( - d.shape[0] if d.ndim == 3 else 1 for d in self.data - ) - self.trial_counts = [ - d.shape[0] if d.ndim == 3 else 1 for d in self.data - ] - return - elif isinstance(data, np.ndarray): - data = torch.from_numpy(data) - self.data = data - # create attributes for the data dimensions - if self.data.ndim == 3: - self.ntrials = self.data.shape[0] - self.n = self.data.shape[2] - else: - self.n = self.data.shape[1] - self.ntrials = 1 - self.is_list_data = isinstance(self.data, list) def compute_hankel( self, @@ -273,9 +201,8 @@ def compute_hankel( print("Computing Hankel matrix ...") # if parameters are provided, overwrite them from the init - # if parameters are provided, overwrite them from the init if data is not None: - self._init_data(data) + self.data = self._init_single_data(data) self.n_delays = self.n_delays if n_delays is None else n_delays self.delay_interval = ( @@ -337,9 +264,7 @@ def compute_svd(self): self.S_mat_inv = torch.diag(1 / S).to(self.device) # compute explained variance - exp_variance_inds = self.S**2 / ((self.S**2).sum()) - cumulative_explained = torch.cumsum(exp_variance_inds, 0) - self.cumulative_explained_variance = cumulative_explained + self.cumulative_explained_variance = self._compute_explained_variance(self.S) # make the X and Y components of the regression by staggering the hankel eigen-time delay coordinates by time if self.reduced_rank_reg: @@ -432,53 +357,26 @@ def recalc_rank(self, rank, rank_thresh, rank_explained_variance): else rank_explained_variance ) - none_vars = ( - (self.rank is None) - + (self.rank_thresh is None) - + (self.rank_explained_variance is None) - ) - if none_vars < 2: - raise ValueError( - "More than one value was provided between rank, rank_thresh, and rank_explained_variance. Please provide only one of these, and ensure the others are None!" - ) - elif none_vars == 3: - self.rank = len(self.S) - + # Determine which singular values to use if self.reduced_rank_reg: S = self.proj_mat_S + cumulative_explained = self._compute_explained_variance(S) else: S = self.S - - if rank_thresh is not None: - if S[-1] > rank_thresh: - self.rank = len(S) - else: - self.rank = torch.argmax( - torch.arange(len(S), 0, -1).to(self.device) * (S < rank_thresh) - ) - - if rank_explained_variance is not None: - self.rank = int( - torch.argmax( - (self.cumulative_explained_variance > rank_explained_variance).type( - torch.int - ) - ) - .cpu() - .numpy() - ) - + cumulative_explained = self.cumulative_explained_variance + + # Get maximum possible rank h_shape_last = self.H_shapes[-1][-1] if self.is_list_data else self.H.shape[-1] - if self.rank > h_shape_last: - self.rank = h_shape_last - - if self.rank is None: - if S[-1] > self.rank_thresh: - self.rank = len(S) - else: - self.rank = torch.argmax( - torch.arange(len(S), 0, -1).to(self.device) * (S < self.rank_thresh) - ) + + # Use base class method to compute rank + self.rank = self._compute_rank_from_params( + S=S, + cumulative_explained_variance=cumulative_explained, + max_rank=h_shape_last, + rank=self.rank, + rank_thresh=self.rank_thresh, + rank_explained_variance=self.rank_explained_variance + ) def compute_havok_dmd(self, lamb=None): """ @@ -495,7 +393,7 @@ def compute_havok_dmd(self, lamb=None): print("Computing least squares fits to HAVOK DMD ...") self.lamb = self.lamb if lamb is None else lamb - + A_v = ( torch.linalg.inv( self.Vt_minus[:, : self.rank].T @ self.Vt_minus[:, : self.rank] @@ -504,28 +402,15 @@ def compute_havok_dmd(self, lamb=None): @ self.Vt_minus[:, : self.rank].T @ self.Vt_plus[:, : self.rank] ).T - self.A_v_learned = A_v - self.A_havok_dmd_learned = ( + self.A_v = A_v + self.A_havok_dmd = ( self.U @ self.S_mat[: self.U.shape[1], : self.rank] - @ self.A_v_learned + @ self.A_v @ self.S_mat_inv[: self.rank, : self.U.shape[1]] @ self.U.T ) - if self.substitute_shift_operator: - self.A_havok_dmd = self.A_havok_dmd_learned.clone() - shift_operator = create_shift_operator(self.n, self.n_delays, self.delay_interval, self.steps_ahead,self.verbose) - if shift_operator is not None: - self.A_havok_dmd[self.n:, :] = shift_operator[self.n:, :].to(self.device) - self.A_v = self.project_A_havok_to_Av(self.A_havok_dmd) - else: - self.A_havok_dmd = self.A_havok_dmd_learned - self.A_v = self.A_v_learned - else: - self.A_havok_dmd = self.A_havok_dmd_learned - self.A_v = self.A_v_learned - if self.verbose: print("Least squares complete! \n") @@ -581,22 +466,6 @@ def compute_reduced_rank_regression(self, lamb=None): if self.verbose: print("Reduced Rank Regression complete! \n") - def project_A_havok_to_Av(self, A_havok_dmd_matrix): - """ - Projects a full A_havok_dmd matrix back to the low-rank A_v space. - """ - if self.U is None or self.S_mat is None or self.S_mat_inv is None: - raise ValueError("SVD must be computed first.") - - A_v_projected = ( - self.S_mat_inv[:self.rank, :self.rank] - @ self.U[:, :self.rank].T - @ A_havok_dmd_matrix - @ self.U[:, :self.rank] - @ self.S_mat[:self.rank, :self.rank] - ) - return A_v_projected - def fit( self, data=None, @@ -683,6 +552,8 @@ def fit( if self.send_to_cpu: self.all_to_device("cpu") # send back to the cpu to save memory + + # print('After DMD fitting in dmd.py', self.A_v.shape) def predict(self, test_data=None, reseed=None, full_return=False): """ @@ -723,34 +594,23 @@ def predict(self, test_data=None, reseed=None, full_return=False): if reseed is None: reseed = 1 - U_r = self.U[:, :self.rank] - S_inv_r = self.S_mat_inv[:self.rank, :self.rank] - S_r = self.S_mat[:self.rank, :self.rank] + H_test_havok_dmd = torch.zeros(H_test.shape).to(self.device) + H_test_havok_dmd[:, :steps_ahead] = H_test[:, :steps_ahead] - # Project to v space - V_test_T = S_inv_r @ U_r.T @ H_test.transpose(1, 2) - V_test = V_test_T.transpose(1, 2) - - V_test_pred = torch.zeros(V_test.shape).to(self.device) - V_test_pred[:, :steps_ahead] = V_test[:, :steps_ahead] - - for t in range(steps_ahead, V_test.shape[1]): + A = self.A_havok_dmd.unsqueeze(0) + for t in range(steps_ahead, H_test.shape[1]): if t % reseed == 0: - v_t = V_test[:, t - steps_ahead] + H_test_havok_dmd[:, t] = ( + A @ H_test[:, t - steps_ahead].transpose(-2, -1) + ).transpose(-2, -1) else: - v_t = V_test_pred[:, t - steps_ahead] - - v_t_plus_1 = (self.A_v @ v_t.unsqueeze(-1)).squeeze(-1) - V_test_pred[:, t] = v_t_plus_1 - - # Project back to full space - H_test_pred = U_r @ S_r @ V_test_pred.transpose(1, 2) - H_test_pred = H_test_pred.transpose(1, 2) - + H_test_havok_dmd[:, t] = ( + A @ H_test_havok_dmd[:, t - steps_ahead].transpose(-2, -1) + ).transpose(-2, -1) pred_data = torch.hstack( [ test_data[:, : (self.n_delays - 1) * self.delay_interval + steps_ahead], - H_test_pred[:, steps_ahead:, : self.n], + H_test_havok_dmd[:, steps_ahead:, : self.n], ] ) @@ -758,14 +618,10 @@ def predict(self, test_data=None, reseed=None, full_return=False): pred_data = pred_data[0] if full_return: - return pred_data, H_test_pred, H_test, V_test_pred, V_test + return pred_data, H_test_havok_dmd, H_test else: return pred_data - def all_to_device(self, device="cpu"): - for k, v in self.__dict__.items(): - if isinstance(v, torch.Tensor): - self.__dict__[k] = v.to(device) def project_onto_modes(self): eigvals, eigvecs = torch.linalg.eigh(self.A_v) @@ -776,4 +632,4 @@ def project_onto_modes(self): ) # get the data that matches the shape of the original data - return projections, self.data[:, : -self.n_delays + 1] + return projections, self.data[:, : -self.n_delays + 1] \ No newline at end of file diff --git a/DSA/dmdc.py b/DSA/dmdc.py new file mode 100644 index 0000000..e69de29 diff --git a/DSA/stats.py b/DSA/stats.py index 1085183..35287af 100644 --- a/DSA/stats.py +++ b/DSA/stats.py @@ -104,6 +104,24 @@ def mse(x, y): return ((x - y) ** 2).mean().item() +def nmse(x,y): + """ + Compute the mean squared error, normalized by the variance of the ground truth. + + x : np.ndarray or torch.tensor + The ground truth time series. + y : np.ndarray or torch.tensor + The predicted time series. + + Returns + ------- + nmse_val : float + The normalized mean squared error between the provided arrays. + """ + x = torch_convert(x) + y = torch_convert(y) + return ((x - y) ** 2).mean().item() / ((x - x.mean()) ** 2).mean().item() + def r2(true_vals, pred_vals): """ @@ -253,6 +271,7 @@ def compute_all_stats(true_vals, pred_vals, rank, norm=True): return { "MAE": mae(true_vals, pred_vals), "MASE": mase(true_vals, pred_vals), + "NMSE": nmse(true_vals, pred_vals), "MSE": mse(true_vals, pred_vals), "R2": r2(true_vals, pred_vals), "Correl": correl(true_vals, pred_vals), @@ -520,27 +539,3 @@ def measure_transient_growth(A): # num_abscissa = np.max(np.real(np.linalg.eigvals((A + np.conj(A).T) / 2))) # return num_abscissa, l2norm return l2norm - -# def get_period(data,dt=None,units='samples'): - -# if data.ndim == 3: -# return np.mean([get_period(i,dt) for i in data]) -# if dt is None: -# fs = data.shape[0] -# dt = 1/fs -# else: -# fs = 1/dt -# chosen_freqs = [] - -# for comp in data.T: -# #channel-wise frequency computation -# freqs, amps = find_significant_frequencies(comp, surrogate_method='rs', fs=fs, return_amplitudes=True) -# chosen_freqs.append(freqs[np.argmax(np.abs(amps))]) - -# period = 1/np.mean(chosen_freqs) -# if units == 'time': -# return period -# elif units == 'samples': -# return period // dt -# else: -# raise ValueError(f"Invalid units: {units}") \ No newline at end of file diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py new file mode 100644 index 0000000..ef8e151 --- /dev/null +++ b/DSA/subspace_dmdc.py @@ -0,0 +1,737 @@ +"""This module computes the subspace DMD with control (DMDc) model for a given dataset.""" +import numpy as np +import torch +#TODO: convert to torch below to match the DMD class + +class subspaceDMDc(): + """Subspace DMDc class for computing and predicting with DMD with control models. + """ + def __init__( + self, + data, + control_data=None, + n_delays=1, + rank=None, + lamb=1e-8, + device='cpu', + verbose=False, + send_to_cpu=False, + time_first=True, + backend='n4sid' + ): + self.data = data + self.control_data = control_data + self.A_v = None + self.B_v = None + self.C_v = None + self.info = None + self.n_delays = n_delays + self.rank = rank + self.time_first = time_first + self.backend = backend + self.lamb = lamb + + + def fit(self): + self.A_v, self.B_v, self.C_v, self.info = self.subspace_dmdc_multitrial_flexible( + y=self.data, + u=self.control_data, + p=self.n_delays, + f=self.n_delays, + n=self.rank, + backend=self.backend, + lamb=self.lamb) + + + + def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): + """ + Subspace-DMDc for multi-trial data with variable trial lengths. + Now use QR decomposition for computing the oblique projection as in N4SID implementations. + + Parameters: + - y_list: list of arrays, each (p_out, N_i) - output data for trial i + - u_list: list of arrays, each (m, N_i) - input data for trial i + - p: past window length + - f: future window length + - n: state dimension (auto-determined if None) + - ridge: regularization parameter (used only for rank selection/SVD; QR is exact) + - energy: energy threshold for rank selection + + Returns: + - A_hat, B_hat, C_hat: system matrices + - info: dictionary with additional information + """ + if len(y_list) != len(u_list): + raise ValueError("y_list and u_list must have same number of trials") + + n_trials = len(y_list) + p_out = y_list[0].shape[0] + m = u_list[0].shape[0] + + # Validate dimensions across trials + for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): + if y_trial.shape[0] != p_out: + raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") + if u_trial.shape[0] != m: + raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") + if y_trial.shape[1] != u_trial.shape[1]: + raise ValueError(f"Trial {i}: y and u have different time lengths") + + def hankel_stack(X, start, L): + return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + + # Collect data from all trials + U_p_all = [] + Y_p_all = [] + U_f_all = [] + Y_f_all = [] + valid_trials = [] + T_per_trial = [] + + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): + N_trial = Y_trial.shape[1] + T_trial = N_trial - (p + f) + 1 + + if T_trial <= 0: + print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") + continue + + valid_trials.append(trial_idx) + T_per_trial.append(T_trial) + + # Build Hankel matrices for this trial + U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) + Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) + U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) + Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) + + U_p_all.append(U_p_trial) + Y_p_all.append(Y_p_trial) + U_f_all.append(U_f_trial) + Y_f_all.append(Y_f_trial) + + if not valid_trials: + raise ValueError("No trials have sufficient data for given (p,f)") + + # Concatenate across valid trials + U_p = np.concatenate(U_p_all, axis=1) # (p m, T_total) + Y_p = np.concatenate(Y_p_all, axis=1) # (p p_out, T_total) + U_f = np.concatenate(U_f_all, axis=1) # (f m, T_total) + Y_f = np.concatenate(Y_f_all, axis=1) # (f p_out, T_total) + + T_total = sum(T_per_trial) + Z_p = np.vstack([U_p, Y_p]) # (p (m + p_out), T_total) + + H = np.vstack([U_f, Z_p, Y_f]) + + # Perform QR on H.T to get equivalent LQ on H + Q, R_upper = np.linalg.qr(H.T, mode='reduced') # H.T = Q R_upper, R_upper upper triangular + L = R_upper.T # L = R_upper.T, lower triangular + + # Dimensions for slicing + dim_uf = f * m + dim_zp = p * (m + p_out) + dim_yf = f * p_out + + # Extract submatrices from L (lower triangular) + R22 = L[dim_uf:dim_uf + dim_zp, dim_uf:dim_uf + dim_zp] + R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] + + # Compute oblique projection O = R32 @ pinv(R22) @ Z_p + O = R32 @ np.linalg.pinv(R22) @ Z_p + + # The rest remains the same: SVD on O + Uo, s, Vt = np.linalg.svd(O, full_matrices=False) + if n is None: + cs = np.cumsum(s**2) / (s**2).sum() + n = int(np.searchsorted(cs, energy) + 1) + n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) + + U_n = Uo[:, :n] + S_n = np.diag(s[:n]) + V_n = Vt[:n, :] + S_half = np.sqrt(S_n) + Gamma_hat = U_n @ S_half # (f p_out, n) + X_hat = S_half @ V_n # (n, T_total) + + # Time alignment for regression across all trials + # Need to handle variable lengths carefully + X_segments = [] + X_next_segments = [] + U_mid_segments = [] + Y_segments = [] + + start_idx = 0 + for trial_idx, T_trial in enumerate(T_per_trial): + # Extract states for this trial + X_trial = X_hat[:, start_idx:start_idx + T_trial] + + # State transitions within this trial + X_trial_curr = X_trial[:, :-1] + X_trial_next = X_trial[:, 1:] + + # Corresponding control inputs + original_trial_idx = valid_trials[trial_idx] + U_trial = u_list[original_trial_idx] + U_mid_trial = U_trial[:, p:p + (T_trial - 1)] + + X_segments.append(X_trial_curr) + X_next_segments.append(X_trial_next) + U_mid_segments.append(U_mid_trial) + + # TODO: check the time-alignment of Y and X here + # Corresponding output data - align with X_trial time indices + Y_trial = y_list[original_trial_idx] + Y_trial_curr = Y_trial[:, p:p+T_trial-1] + # Y_trial_curr = Y_trial[:, p+1:p+T_trial] + Y_segments.append(Y_trial_curr) + + start_idx += T_trial + + # Concatenate all segments + X = np.concatenate(X_segments, axis=1) + X_next = np.concatenate(X_next_segments, axis=1) + U_mid = np.concatenate(U_mid_segments, axis=1) + + # Regression for A and B + Z = np.vstack([X, U_mid]) + # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T + ZTZ = Z @ Z.T + ridge_term = lamb * np.eye(ZTZ.shape[0]) + AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T + A_hat = AB[:, :n] + B_hat = AB[:, n:] + + # Z = np.vstack([X, U_mid]) + # AB = X_next @ np.linalg.pinv(Z) + # A_hat = AB[:, :n] + # B_hat = AB[:, n:] + + C_hat = Gamma_hat[:p_out, :] + + # Estimate noise covariance matrix + # 0) Outputs aligned to X and U_mid (same time indices/columns) + Y_curr = np.concatenate(Y_segments, axis=1) # shape: (p_out, N) + + # 1) Residuals at time t + # Process noise residual (state eq): w_t ≈ x_{t+1} - A x_t - B u_ts + W_hat = X_next - (A_hat @ X + B_hat @ U_mid) # (n, N) + + # Measurement noise residual (output eq): v_t ≈ y_t - C x_t (since D = 0) + V_hat = Y_curr - (C_hat @ X) # (p_out, N) + + # 2) Mean-centering + V_hat = V_hat - V_hat.mean(axis=1, keepdims=True) + W_hat = W_hat - W_hat.mean(axis=1, keepdims=True) + N_res = V_hat.shape[1] + denom = max(N_res - 1, 1) + + # 3) Covariances + R_hat = (V_hat @ V_hat.T) / denom # (p_out, p_out) measurement + Q_hat = (W_hat @ W_hat.T) / denom # (n, n) process + S_hat = (W_hat @ V_hat.T) / denom # (n, p_out) - cross (w,v) + + # 4) Symmetrize + eps = 1e-12 + R_hat = 0.5 * (R_hat + R_hat.T) + eps * np.eye(R_hat.shape[0]) + Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * np.eye(Q_hat.shape[0]) + + noise_covariance = np.block([[R_hat, S_hat.T], + [S_hat, Q_hat]]) + + info = { + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, + "f": f, + "n_trials_total": n_trials, + "n_trials_used": len(valid_trials), + "valid_trials": valid_trials, + "T_per_trial": T_per_trial, + "T_total": T_total, + "trial_lengths": [y.shape[1] for y in y_list], + "noise_covariance": noise_covariance, + 'R_hat': R_hat, + 'Q_hat': Q_hat, + 'S_hat': S_hat + } + + return A_hat, B_hat, C_hat, info + + + + + def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): + """ + Subspace-DMDc for multi-trial data with variable trial lengths. + + Parameters: + - y_list: list of arrays, each (p_out, N_i) - output data for trial i + - u_list: list of arrays, each (m, N_i) - input data for trial i + - p: past window length + - f: future window length + - n: state dimension (auto-determined if None) + - ridge: regularization parameter + - energy: energy threshold for rank selection∏ + + Returns: + - A_hat, B_hat, C_hat: system matrices + - info: dictionary with additional information + """ + if len(y_list) != len(u_list): + raise ValueError("y_list and u_list must have same number of trials") + + n_trials = len(y_list) + p_out = y_list[0].shape[0] + m = u_list[0].shape[0] + + # Validate dimensions across trials + + for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): + if y_trial.shape[0] != p_out: + raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") + if u_trial.shape[0] != m: + raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") + if y_trial.shape[1] != u_trial.shape[1]: + raise ValueError(f"Trial {i}: y and u have different time lengths") + + def hankel_stack(X, start, L): + return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + + # Collect data from all trials + U_p_all = [] + Y_p_all = [] + U_f_all = [] + Y_f_all = [] + valid_trials = [] + T_per_trial = [] + + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): + N_trial = Y_trial.shape[1] + T_trial = N_trial - (p + f) + 1 + + if T_trial <= 0: + print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") + continue + + valid_trials.append(trial_idx) + T_per_trial.append(T_trial) + + # Build Hankel matrices for this trial + U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) + Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) + U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) + Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) + + U_p_all.append(U_p_trial) + Y_p_all.append(Y_p_trial) + U_f_all.append(U_f_trial) + Y_f_all.append(Y_f_trial) + + + print("="*40) + print(f"Number of valid trials: {len(U_p_trial)}") + + if not valid_trials: + raise ValueError("No trials have sufficient data for given (p,f)") + + # Concatenate across valid trials + U_p = np.concatenate(U_p_all, axis=1) # (pm, T_total) + Y_p = np.concatenate(Y_p_all, axis=1) # (p*p_out, T_total) + U_f = np.concatenate(U_f_all, axis=1) # (fm, T_total) + Y_f = np.concatenate(Y_f_all, axis=1) # (f*p_out, T_total) + + T_total = sum(T_per_trial) + Z_p = np.vstack([U_p, Y_p]) # (p(m+p_out), T_total) + + # Oblique projection: remove row(U_f), project onto row(Z_p) + UfUfT = U_f @ U_f.T + Xsolve = np.linalg.solve(UfUfT + lamb*np.eye(UfUfT.shape[0]), U_f) + Pi_perp = np.eye(T_total) - U_f.T @ Xsolve + Yf_perp = Y_f @ Pi_perp + Zp_perp = Z_p @ Pi_perp + + ZZT = Zp_perp @ Zp_perp.T + Zp_pinv_left = np.linalg.solve(ZZT + lamb*np.eye(ZZT.shape[0]), Zp_perp) + P = Zp_perp.T @ Zp_pinv_left + O = Yf_perp @ P # ≈ Γ_f X_p + + Uo, s, Vt = np.linalg.svd(O, full_matrices=False) + if n is None: + cs = np.cumsum(s**2) / (s**2).sum() + n = int(np.searchsorted(cs, energy) + 1) + n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) + + U_n = Uo[:, :n] + S_n = np.diag(s[:n]) + V_n = Vt[:n, :] + S_half = np.sqrt(S_n) + Gamma_hat = U_n @ S_half # (f*p_out, n) + X_hat = S_half @ V_n # (n, T_total) + + # Time alignment for regression across all trials + # Need to handle variable lengths carefully + X_segments = [] + X_next_segments = [] + U_mid_segments = [] + + start_idx = 0 + for trial_idx, T_trial in enumerate(T_per_trial): + # Extract states for this trial + X_trial = X_hat[:, start_idx:start_idx + T_trial] + + # State transitions within this trial + X_trial_curr = X_trial[:, :-1] + X_trial_next = X_trial[:, 1:] + + # Corresponding control inputs + original_trial_idx = valid_trials[trial_idx] + U_trial = u_list[original_trial_idx] + U_mid_trial = U_trial[:, p:p + (T_trial - 1)] + + X_segments.append(X_trial_curr) + X_next_segments.append(X_trial_next) + U_mid_segments.append(U_mid_trial) + + start_idx += T_trial + + # Concatenate all segments + X = np.concatenate(X_segments, axis=1) + X_next = np.concatenate(X_next_segments, axis=1) + U_mid = np.concatenate(U_mid_segments, axis=1) + + # Regression for A and B + Z = np.vstack([X, U_mid]) + # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T + ZTZ = Z @ Z.T + ridge_term = lamb * np.eye(ZTZ.shape[0]) + AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T + A_hat = AB[:, :n] + B_hat = AB[:, n:] + + C_hat = Gamma_hat[:p_out, :] + + info = { + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, + "f": f, + "n_trials_total": n_trials, + "n_trials_used": len(valid_trials), + "valid_trials": valid_trials, + "T_per_trial": T_per_trial, + "T_total": T_total, + "trial_lengths": [y.shape[1] for y in y_list], + "X_hat": X_hat + } + + return A_hat, B_hat, C_hat, info + + + + def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energy=0.999, backend='n4sid'): + """ + Flexible wrapper that handles both fixed-length and variable-length multi-trial data. + + Parameters: + - y: either (n_trials, p_out, N) array, (p_out, N) array, or list of (p_out, N_i) arrays + - u: either (n_trials, m, N) array, (m, N) array, or list of (m, N_i) arrays + """ + if isinstance(y, list) and isinstance(u, list): + # If time_first=True, transpose each trial from (time_points, variables) to (variables, time_points) + if self.time_first: + y_list = [y_trial.T for y_trial in y] + u_list = [u_trial.T for u_trial in u] + else: + y_list = y + u_list = u + if backend == 'n4sid': + return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) + else: + return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) + + else: + # Handle 2D arrays (single trial) by converting to list format + if y.ndim == 2: + y_list = [y] + u_list = [u] + else: + # Convert 3D arrays to list format + y_list = [y[i] for i in range(y.shape[0])] + u_list = [u[i] for i in range(u.shape[0])] + + # If time_first=True, transpose each trial from (time_points, variables) to (variables, time_points) + if self.time_first: + y_list = [y_trial.T for y_trial in y_list] + u_list = [u_trial.T for u_trial in u_list] + + if backend == 'n4sid': + return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) + else: + return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) + + + def predict(self, Y, U, reseed=None): + # Y and U are (n_times, n_channels) or list of 2D arrays + if reseed is None: + reseed = 1 + + # Handle list of 2D arrays + if isinstance(Y, list): + if not self.time_first: + Y = [y.T for y in Y] + U = [u.T for u in U] + + self.kalman = OnlineKalman(self) + Y_pred = [] + for trial in range(len(Y)): + self.kalman.reset() # Reset filter for each trial + trial_predictions = [] + for t in range(Y[trial].shape[0]): + y_filtered, _ = self.kalman.step( + y=Y[trial][t] if t%reseed == 0 else None, + u=U[trial][t] + ) + trial_predictions.append(y_filtered) + Y_pred.append(np.concatenate(trial_predictions, axis=1).T) + return Y_pred # Return as list to match input format + + # print("time_first", self.time_first) + if not self.time_first: + if Y.ndim == 2: + Y = Y.T + U = U.T + else: + Y = Y.transpose(0, 2, 1) + U = U.transpose(0, 2, 1) + + self.kalman = OnlineKalman(self) + if Y.ndim == 2: + Y_pred = [] + for t in range(Y.shape[0]): + y_filtered, _ = self.kalman.step(y=Y[t] if t%reseed == 0 else None, u=U[t]) + Y_pred.append(y_filtered) + return np.concatenate(Y_pred, axis=1).T + else: + # 3D data (n_trials, time, p_out) + # print("Y.shape", Y.shape) + # print("U.shape", U.shape) + Y_pred = [] + for trial in range(Y.shape[0]): + self.kalman.reset() # Reset filter for each trial + trial_predictions = [] + for t in range(Y.shape[1]): + y_filtered, _ = self.kalman.step(y=Y[trial, t] if t%reseed == 0 else None, u=U[trial, t]) + trial_predictions.append(y_filtered) + # print("y_filtered.shape", y_filtered.shape) + Y_pred.append(np.concatenate(trial_predictions, axis=1).T) + return np.array(Y_pred) + + + +class OnlineKalman: + """ + Online Kalman Filter class for real-time state estimation. + + This class maintains the internal state of the Kalman filter and provides + a step method for updating the filter with new observations and inputs. + """ + + def __init__(self, dmdc): + """ + Initialize the Online Kalman Filter with a fitted DMDc model. + + Parameters + ---------- + dmdc : object + Fitted DMDc model containing A_v, B_v, C_v matrices and + noise covariance estimates (R_hat, S_hat, Q_hat) + """ + self.A = dmdc.A_v + self.B = dmdc.B_v + self.C = dmdc.C_v + self.R = dmdc.info['R_hat'] + self.S = dmdc.info['S_hat'] + self.Q = dmdc.info['Q_hat'] + + # Get dimensions + # print("C_shape", self.C.shape) + self.y_dim, self.x_dim = self.C.shape + + # Initialize state storage + self.p_filtereds = [] + self.x_filtereds = [] + self.p_predicteds = [] + self.x_predicteds = [] + self.us = [] + self.ys = [] + self.y_filtereds = [] + self.y_predicteds = [] + self.kalman_gains = [] + + + # def step(self, y=None, u=None, lam=1e-8): + # """ + # Perform one step of the Kalman filter. + + # Parameters + # ---------- + # y : np.ndarray, optional + # Observed output at current time step. If None, the filter + # will predict without observation update. + # u : np.ndarray, optional + # Input at current time step. If None, no input is applied. + + # Returns + # ------- + # y_filtered : np.ndarray + # Filtered output estimate + # x_filtered : np.ndarray + # Filtered state estimate + # """ + # x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) + # p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) + + # # Ensure inputs are column vectors + # if u is not None and u.ndim == 1: + # u = u.reshape(-1, 1) + # if y is not None and y.ndim == 1: + # y = y.reshape(-1, 1) + # if u is None: + # u = np.zeros((self.u_dim, 1)) + # if y is None: + # y = np.zeros((self.y_dim, 1)) + + # S_innov = self.R + self.C @ p_pred @ self.C.T + # K_filtered = p_pred @ self.C.T @ np.linalg.pinv(S_innov) + # p_filtered = p_pred - K_filtered @ self.C @ p_pred + # if not np.isnan(y).any(): + # x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) + # else: + # x_filtered = x_pred.copy() + + # K_pred = (self.S + self.A @ p_pred @ self.C.T) @ np.linalg.pinv(S_innov) + # p_predicted = (self.A @ p_pred @ self.A.T + self.Q - + # K_pred @ (self.S + self.A @ p_pred @ self.C.T).T) + # x_predicted = self.A @ x_pred + self.B @ u + # if not np.isnan(y).any(): + # x_predicted += K_pred @ (y - self.C @ x_pred) + + # # Store results + # self.p_filtereds.append(p_filtered) + # self.x_filtereds.append(x_filtered) + # self.p_predicteds.append(p_predicted) + # self.x_predicteds.append(x_predicted) + # self.us.append(u) + # self.ys.append(y) + # self.y_filtereds.append(self.C @ x_filtered) + # self.y_predicteds.append(self.C @ x_predicted) + # self.kalman_gains.append(K_pred) + + # return self.y_filtereds[-1], self.x_filtereds[-1] + + + def step(self, y=None, u=None, reg_coef=1e-6): + """ + Perform one step of the Kalman filter. + + Parameters + ---------- + y : np.ndarray, optional + Observed output at current time step. If None, the filter + will predict without observation update. + u : np.ndarray, optional + Input at current time step. If None, no input is applied. + reg_coef : float, optional + Regularization coefficient to add to diagonal of P matrices + to maintain numerical stability. Default: 1e-6 + + Returns + ------- + y_filtered : np.ndarray + Filtered output estimate + x_filtered : np.ndarray + Filtered state estimate + """ + x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) + p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) + + # Add regularization to p_pred to prevent ill-conditioning + p_pred_reg = p_pred + reg_coef * np.eye(self.x_dim) + + # Ensure inputs are column vectors + if u is not None and u.ndim == 1: + u = u.reshape(-1, 1) + if y is not None and y.ndim == 1: + y = y.reshape(-1, 1) + if u is None: + u = np.zeros((self.u_dim, 1)) + if y is None: + y = np.zeros((self.y_dim, 1)) + + # Use regularized p_pred in computations + S_innov = self.R + self.C @ p_pred_reg @ self.C.T + K_filtered = p_pred_reg @ self.C.T @ np.linalg.pinv(S_innov) + p_filtered = p_pred_reg - K_filtered @ self.C @ p_pred_reg + + # Add regularization to p_filtered to maintain positive definiteness + p_filtered = (p_filtered + p_filtered.T) / 2 # Ensure symmetry + p_filtered = p_filtered + reg_coef * np.eye(self.x_dim) # Add regularization + + if not np.isnan(y).any(): + x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) + else: + x_filtered = x_pred.copy() + + K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ np.linalg.pinv(S_innov) + p_predicted = (self.A @ p_pred_reg @ self.A.T + self.Q - + K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T) + + # Add regularization to p_predicted and ensure symmetry + p_predicted = (p_predicted + p_predicted.T) / 2 # Ensure symmetry + p_predicted = p_predicted + reg_coef * np.eye(self.x_dim) # Add regularization + + x_predicted = self.A @ x_pred + self.B @ u + if not np.isnan(y).any(): + x_predicted += K_pred @ (y - self.C @ x_pred) + + # Store results + self.p_filtereds.append(p_filtered) + self.x_filtereds.append(x_filtered) + self.p_predicteds.append(p_predicted) + self.x_predicteds.append(x_predicted) + self.us.append(u) + self.ys.append(y) + self.y_filtereds.append(self.C @ x_filtered) + self.y_predicteds.append(self.C @ x_predicted) + self.kalman_gains.append(K_pred) + + return self.y_filtereds[-1], self.x_filtereds[-1] + + def reset(self): + """Reset the filter to initial state.""" + self.p_filtereds = [] + self.x_filtereds = [] + self.p_predicteds = [] + self.x_predicteds = [] + self.us = [] + self.ys = [] + self.y_filtereds = [] + self.y_predicteds = [] + self.kalman_gains = [] + + + def get_history(self): + """Return the complete history of filter states.""" + return { + 'p_filtereds': self.p_filtereds, + 'x_filtereds': self.x_filtereds, + 'p_predicteds': self.p_predicteds, + 'x_predicteds': self.x_predicteds, + 'us': self.us, + 'ys': self.ys, + 'y_filtereds': self.y_filtereds, + 'y_predicteds': self.y_predicteds, + 'kalman_gains': self.kalman_gains + } \ No newline at end of file From 0c90eacebeafa51c54d137290d2899dddcb4383f Mon Sep 17 00:00:00 2001 From: ostrow Date: Mon, 27 Oct 2025 23:42:06 -0400 Subject: [PATCH 04/51] big alignment of dsa class, fixes on dmdc, simdist_controlalbility, subspace_dmdc. still need to test --- DSA/dmdc.py | 528 ++++++++++++++++++ DSA/dsa.py | 383 +++++++++---- ..._simdist.py => simdist_controllability.py} | 30 +- DSA/subspace_dmdc.py | 5 +- DSA/sweeps.py | 6 - 5 files changed, 805 insertions(+), 147 deletions(-) rename DSA/{controllability_simdist.py => simdist_controllability.py} (91%) diff --git a/DSA/dmdc.py b/DSA/dmdc.py index e69de29..f4052de 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -0,0 +1,528 @@ +"""This module computes the DMD with control (DMDc) model for a given dataset.""" +import numpy as np +import torch +try: + from .dmd import embed_signal_torch + from .base_dmd import BaseDMD +except ImportError: + from dmd import embed_signal_torch + from base_dmd import BaseDMD + +def embed_data_DMDc(data, n_delays=1, n_control_delays=1, delay_interval=1, control=False): + if control: + if n_control_delays == 1: + if data.ndim == 2: + return data[(n_delays-1)*delay_interval:, :] + else: + return data[:, (n_delays-1)*delay_interval:, :] + else: + embedded_data = embed_signal_torch(data, n_control_delays, delay_interval) + return embedded_data + else: + return embed_signal_torch(data, n_delays, delay_interval) + +class DMDc(BaseDMD): + """DMDc class for computing and predicting with DMD with control models. + """ + def __init__( + self, + data, + control_data=None, + n_delays=1, + n_control_delays=1, + delay_interval=1, + rank_input=None, + rank_thresh_input=None, + rank_explained_variance_input=None, + rank_output=None, + rank_thresh_output=None, + rank_explained_variance_output=None, + lamb=1e-8, + device='cpu', + verbose=False, + send_to_cpu=False, + svd_separate = True, + steps_ahead=1 + ): + """ + Parameters + ---------- + data : np.ndarray or torch.tensor + The state data to fit the DMDc model to. Must be either: (1) a + 2-dimensional array/tensor of shape T x N where T is the number + of time points and N is the number of observed dimensions + at each time point, or (2) a 3-dimensional array/tensor of shape + K x T x N where K is the number of "trials" and T and N are + as defined above. + + control_data : np.ndarray or torch.tensor + The control input data corresponding to the state data. Must have compatible dimensions + with the state data. + + n_delays : int + Parameter that controls the size of the delay embedding. Explicitly, + the number of delays to include. + + delay_interval : int + The number of time steps between each delay in the delay embedding. Defaults + to 1 time step. + + rank : int + The rank of V in fitting DMDc - i.e., the number of columns of V to + use to fit the DMDc model. Defaults to None, in which case all columns of V + will be used. + + rank_thresh : float + Parameter that controls the rank of V in fitting DMDc by dictating a threshold + of singular values to use. Explicitly, the rank of V will be the number of singular + values greater than rank_thresh. Defaults to None. + + rank_explained_variance : float + Parameter that controls the rank of V in fitting DMDc by indicating the percentage of + cumulative explained variance that should be explained by the columns of V. Defaults to None. + + lamb : float + Regularization parameter for ridge regression. Defaults to 0. + + device: string, int, or torch.device + A string, int or torch.device object to indicate the device to torch. + + verbose: bool + If True, print statements will be provided about the progress of the fitting procedure. + + send_to_cpu: bool + If True, will send all tensors in the object back to the cpu after everything is computed. + This is implemented to prevent gpu memory overload when computing multiple DMDs. + + steps_ahead: int + The number of time steps ahead to predict. Defaults to 1. + """ + + super().__init__(device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb) + + self._init_data(data, control_data) + + self.n_delays = n_delays + self.n_control_delays = n_control_delays + self.delay_interval = delay_interval + + self.rank_input = rank_input + self.rank_thresh_input = rank_thresh_input + self.rank_explained_variance_input = rank_explained_variance_input + self.rank_output = rank_output + self.rank_thresh_output = rank_thresh_output + self.rank_explained_variance_output = rank_explained_variance_output + self.svd_separate = svd_separate #do svd on H and u separately as well as regression + self.steps_ahead = steps_ahead + + # Hankel matrix + self.H = None + + # Control input Hankel matrix + self.Hu = None + + # SVD attributes + self.U = None + self.S = None + self.V = None + self.S_mat = None + self.S_mat_inv = None + + # Change of basis between the reduced-order subspace and the full space + self.U_out = None + self.S_out = None + self.V_out = None + + # DMDc attributes + self.A_tilde = None + self.B_tilde = None + self.A = None + self.B = None + self.A_havok_dmd = None + self.B_havok_dmd = None + + # Check if the state and control data are list (for different trial lengths) + if not np.all([isinstance(data, list), isinstance(control_data, list)]): + if isinstance(data, list) or isinstance(control_data, list): + raise TypeError("If you pass one of (data, control_data) as list, the other must also be a list.") + + def _init_data(self, data, control_data=None): + # Process main data + self.data, data_is_ragged = self._process_single_dataset(data) + + # Process control data + if control_data is not None: + self.control_data, control_is_ragged = self._process_single_dataset(control_data) + else: + self.control_data = torch.zeros_like(self.data) + control_is_ragged = False + + # Check consistency between data and control_data + if data_is_ragged != control_is_ragged: + raise ValueError("Data and control data have different structure (type or dimensionality).") + + if data_is_ragged: + # Additional validation for ragged data + if not all(d.shape[-1] == control_data[0].shape[-1] for d in control_data): + raise ValueError( + "All control tensors in the list must have the same number of features (last dimension)." + ) + if not all(d.shape[0] == control_d.shape[0] for d, control_d in zip(data, control_data)): + raise ValueError( + "Data and control_data tensors must have the same number of time steps." + ) + + # Set attributes for ragged data + n_features = self.data[0].shape[-1] + self.n = n_features + self.ntrials = sum( + d.shape[0] if d.ndim == 3 else 1 for d in self.data + ) + self.trial_counts = [ + d.shape[0] if d.ndim == 3 else 1 for d in self.data + ] + self.is_list_data = True + else: + # Set attributes for non-ragged data + if self.data.ndim == 3: + self.ntrials = self.data.shape[0] + self.n = self.data.shape[2] + else: + self.n = self.data.shape[1] + self.ntrials = 1 + self.is_list_data = False + + def compute_hankel( + self, + data=None, + control_data=None, + n_delays=None, + delay_interval=None, + ): + """ + Computes the Hankel matrix from the provided data and forms Omega. + """ + if self.verbose: + print("Computing Hankel matrices ...") + + # Overwrite parameters if provided + self.data = self.data if data is None else self._init_data(data, control_data) + self.n_delays = self.n_delays if n_delays is None else n_delays + self.delay_interval = self.delay_interval if delay_interval is None else delay_interval + + if self.is_list_data: + self.data = [d.to(self.device) for d in self.data] + self.control_data = [d.to(self.device) for d in self.control_data] + # Compute Hankel matrices for each trial separately + self.H = [embed_data_DMDc(d, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval).float() for d in self.data] + self.Hu = [embed_data_DMDc(d, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval, control=True).float() for d in self.control_data] + self.H_shapes = [h.shape for h in self.H] + else: + self.data = self.data.to(self.device) + self.control_data = self.control_data.to(self.device) + # Compute Hankel matrices + self.H = embed_data_DMDc(self.data, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval).float() + self.Hu = embed_data_DMDc(self.control_data, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval, control=True).float() + + if self.verbose: + print("Hankel matrices computed!") + + + def compute_svd(self): + """ + Computes the SVD of the Omega and Y matrices. + """ + if self.verbose: + print("Computing SVD on H and U matrices ...") + + + if self.is_list_data: + self.H_shapes = [h.shape for h in self.H] + H_list = [] + Hu_list = [] + for h_elem in self.H: + if h_elem.ndim == 3: + H_list.append( + h_elem.reshape( + h_elem.shape[0] * h_elem.shape[1], h_elem.shape[2] + ) + ) + else: + H_list.append(h_elem) + + for hu_elem in self.Hu: + if hu_elem.ndim == 3: + Hu_list.append( + hu_elem.reshape( + hu_elem.shape[0] * hu_elem.shape[1], hu_elem.shape[2] + ) + ) + else: + Hu_list.append(hu_elem) + self.H = torch.cat(H_list, dim=0) + self.Hu = torch.cat(Hu_list, dim=0) + # H = torch.cat(H_list, dim=0) + self.H_row_counts = [h.shape[0] for h in H_list] + H = self.H + Hu = self.Hu + + elif self.H.ndim == 3: # flatten across trials for 3d + H = self.H.reshape(self.H.shape[0] * self.H.shape[1], self.H.shape[2]) + Hu = self.Hu.reshape(self.Hu.shape[0] * self.Hu.shape[1], self.Hu.shape[2]) + else: + H = self.H + Hu = self.Hu + self.Uh, self.Sh, self.Vh = torch.linalg.svd(H.T, full_matrices=False) + self.Uu, self.Su, self.Vu = torch.linalg.svd(Hu.T, full_matrices=False) + + self.Vh = self.Vh.T + self.Vu = self.Vu.T + + self.Sh_mat = torch.diag(self.Sh).to(self.device) + self.Sh_mat_inv = torch.diag(1 / self.Sh).to(self.device) + + self.Su_mat = torch.diag(self.Su).to(self.device) + self.Su_mat_inv = torch.diag(1 / self.Su).to(self.device) + + self.cumulative_explained_variance_input = self._compute_explained_variance(self.Su) + self.cumulative_explained_variance_output = self._compute_explained_variance(self.Sh) + + self.Vht_minus, self.Vht_plus = self.get_plus_minus(self.Vh, self.H) + self.Vut_minus, _ = self.get_plus_minus(self.Vu, self.Hu) + + if self.verbose: + print("SVDs computed!") + + def get_plus_minus(self, V, H): + if self.ntrials > 1: + if self.is_list_data: + V_split = torch.split(V, self.H_row_counts, dim=0) + Vt_minus_list, Vt_plus_list = [], [] + for v_part, h_shape in zip(V_split, self.H_shapes): + if len(h_shape) == 3: # Has trials + v_part_reshaped = v_part.reshape(h_shape) + newshape = ( + h_shape[0] * (h_shape[1] - self.steps_ahead), + h_shape[2], + ) + Vt_minus_list.append( + v_part_reshaped[:, : -self.steps_ahead].reshape(newshape) + ) + Vt_plus_list.append( + v_part_reshaped[:, self.steps_ahead :].reshape(newshape) + ) + else: # No trials, just time and features + Vt_minus_list.append(v_part[: -self.steps_ahead]) + Vt_plus_list.append(v_part[self.steps_ahead :]) + + Vt_minus = torch.cat(Vt_minus_list, dim=0) + Vt_plus = torch.cat(Vt_plus_list, dim=0) + else: + + if V.numel() < H.numel(): + raise ValueError( + "The dimension of the SVD of the Hankel matrix is smaller than the dimension of the Hankel matrix itself. \n \ + This is likely due to the number of time points being smaller than the number of dimensions. \n \ + Please reduce the number of delays." + ) + + V = V.reshape(H.shape) + + # first reshape back into Hankel shape, separated by trials + newshape = ( + H.shape[0] * (H.shape[1] - self.steps_ahead), + H.shape[2], + ) + Vt_minus = V[:, : -self.steps_ahead].reshape(newshape) + Vt_plus = V[:, self.steps_ahead :].reshape(newshape) + else: + Vt_minus = V[: -self.steps_ahead] + Vt_plus = V[self.steps_ahead :] + + return Vt_minus, Vt_plus + + + def recalc_rank(self, rank_input=None, rank_thresh_input=None, rank_explained_variance_input=None, + rank_output=None, rank_thresh_output=None, rank_explained_variance_output=None): + ''' + Recalculates the rank for input and output based on provided parameters. + ''' + # Recalculate ranks for input + self.rank_input = self._compute_rank_from_params( + S=self.Su, + cumulative_explained_variance=self.cumulative_explained_variance_input, + max_rank=self.Hu.shape[-1], + rank=rank_input, + rank_thresh=rank_thresh_input, + rank_explained_variance=rank_explained_variance_input + ) + # Recalculate ranks for output + self.rank_output = self._compute_rank_from_params( + S=self.Sh, + cumulative_explained_variance=self.cumulative_explained_variance_output, + max_rank=self.H.shape[-1], + rank=rank_output, + rank_thresh=rank_thresh_output, + rank_explained_variance=rank_explained_variance_output + ) + + + def compute_dmdc(self, lamb=None): + if self.verbose: + print("Computing DMDc matrices ...") + + self.lamb = self.lamb if lamb is None else lamb + + V_minus_tot = torch.cat([self.Vht_minus[:, :self.rank_output], self.Vut_minus[:, :self.rank_input]], dim=1) + + A_v_tot = ( + torch.linalg.inv( + V_minus_tot.T @ V_minus_tot + + self.lamb * torch.eye(V_minus_tot.shape[1]).to(self.device) + ) + @ V_minus_tot.T + @ self.Vht_plus[:, :self.rank_output] + ).T + #split A_v_tot into A_v and B_v + self.A_v = A_v_tot[:, :self.rank_output] + self.B_v = A_v_tot[:, self.rank_output:] + self.A_havok_dmd = ( + self.Uh + @ self.Sh_mat[: self.Uh.shape[1], : self.rank_output] + @ self.A_v + @ self.Sh_mat_inv[: self.rank_output, : self.Uh.shape[1]] + @ self.Uh.T + ) + + self.B_havok_dmd = ( + self.Uh + @ self.Sh_mat[: self.Uh.shape[1], : self.rank_output] + @ self.B_v + @ self.Su_mat_inv[: self.rank_input, : self.Uu.shape[1]] + @ self.Uu.T + ) + + # Set the A and B properties for backward compatibility and easier access + self.A = self.A_havok_dmd + self.B = self.B_havok_dmd + + if self.verbose: + print("DMDc matrices computed!") + + def fit( + self, + data=None, + control_data=None, + n_delays=None, + delay_interval=None, + lamb=None, + device=None, + verbose=None, + ): + """ + Fits the DMDc model to the provided data. + """ + # Overwrite parameters if provided + self.device = self.device if device is None else device + self.verbose = self.verbose if verbose is None else verbose + + self.compute_hankel(data, control_data, n_delays, delay_interval) + self.compute_svd() + self.recalc_rank( + self.rank_input, self.rank_thresh_input, self.rank_explained_variance_input, + self.rank_output, self.rank_thresh_output, self.rank_explained_variance_output + ) + self.compute_dmdc(lamb) + if self.send_to_cpu: + self.all_to_device('cpu') # send back to the cpu to save memory + + def predict( + self, + test_data=None, + control_data=None, + reseed=None, + full_return=False + ): + """ + Parameters + ---------- + test_data : np.ndarray or torch.tensor + The state data to make predictions on. + + control_data : np.ndarray or torch.tensor + The control input data corresponding to the test_data. + + reseed : int + Frequency of reseeding the prediction with true data. + + full_return : bool + If True, returns additional matrices used in prediction. + + Returns + ------- + pred_data : torch.tensor + The predictions generated by the DMDc model. Of the same shape as test_data. + + H_test_dmdc : torch.tensor (Optional) + Returned if full_return=True. The predicted Hankel matrix generated by the DMDc model. + + H_test : torch.tensor (Optional) + Returned if full_return=True. The true Hankel matrix. + """ + # Initialize test_data + if test_data is None: + test_data = self.data + if control_data is None: + control_data = self.control_data + + if isinstance(test_data, list): + predictions = [self.predict(test_data=d, control_data=d_control, + reseed=reseed, full_return=full_return) for d, d_control in zip(test_data, control_data)] + if full_return: + pred_data = [pred[0] for pred in predictions] + H_test_dmdc = [pred[1] for pred in predictions] + H_test = [pred[2] for pred in predictions] + return pred_data, H_test_dmdc, H_test + else: + return predictions + + if isinstance(test_data, np.ndarray): + test_data = torch.from_numpy(test_data).to(self.device) + if isinstance(control_data, np.ndarray): + control_data = torch.from_numpy(control_data).to(self.device) + + ndim = test_data.ndim + if ndim == 2: + test_data = test_data.unsqueeze(0) + control_data = control_data.unsqueeze(0) + # H_test = embed_data_DMDc(test_data, n_delays=self.n_delays, delay_interval=self.delay_interval, control=False) + # H_control = embed_data_DMDc(control_data, n_delays=self.n_control_delays, delay_interval=self.delay_interval, control=True) + H_test = embed_signal_torch(test_data, self.n_delays, self.delay_interval).float() + H_control = embed_signal_torch(control_data, self.n_control_delays, self.delay_interval).float() + if reseed is None: + reseed = 1 + + H_test_dmdc = torch.zeros_like(H_test).to(self.device) + H_test_dmdc[:, 0] = H_test[:, 0] + A = self.A_havok_dmd + B = self.B_havok_dmd + + for t in range(1, H_test.shape[1]): + u_t = H_control[:, t - 1] + # print(A.shape) + # print(H_test[:, t - 1].shape) + # print(B.shape) + # print(u_t.shape) + if t % reseed == 0: + H_test_dmdc[:, t] = (A @ H_test[:, t - 1].transpose(-2, -1)).transpose(-2, -1) + (B @ u_t.transpose(-2, -1)).transpose(-2, -1) + else: + H_test_dmdc[:, t] = (A @ H_test_dmdc[:, t - 1].transpose(-2, -1)).transpose(-2, -1) + (B @ u_t.transpose(-2, -1)).transpose(-2, -1) + pred_data = torch.hstack([test_data[:, :(self.n_delays - 1)*self.delay_interval + self.steps_ahead], H_test_dmdc[:, self.steps_ahead:, :self.n]]) + + if ndim == 2: + pred_data = pred_data[0] + + if full_return: + return pred_data, H_test_dmdc, H_test + else: + return pred_data diff --git a/DSA/dsa.py b/DSA/dsa.py index 9631508..92382eb 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -1,4 +1,7 @@ from DSA.dmd import DMD as DefaultDMD +from DSA.simdist_controllability import ControllabilitySimilarityTransformDist +from DSA.dmdc import DMDc as DefaultDMDc +from DSA.subspace_dmdc import SubspaceDMDc from DSA.simdist import SimilarityTransformDist from typing import Literal import torch @@ -6,6 +9,11 @@ from omegaconf.listconfig import ListConfig import tqdm from joblib import Parallel, delayed +from dataclasses import dataclass, is_dataclass, asdict +import DSA.pykoopman as pykoopman +from DSA.pykoopman.regression import DMDc, EDMDc +from typing import Union, Mapping, Any +import warnings CAST_TYPES = { @@ -20,26 +28,61 @@ "send_to_cpu": bool, } - -class DSA: +#___Example config dataclasses for DMD # +@dataclass() +class DefaultDMDConfig: + n_delays: int = 1 + delay_interval: int = 1 + rank: int = None + lamb: float = 0 + send_to_cpu: bool = False +@dataclass() +class pyKoopmanDMDConfig: + observables: pykoopman.observables.BaseObservables = pykoopman.observables.TimeDelay(n_delays=1) + regressor = pykoopman.regression.DMD(svd_rank=2) + +@dataclass() +class SubspaceDMDcConfig: + n_delays: int = 1 + delay_interval: int = 1 + rank: int = None + lamb: float = 0 + backend: str = 'n4sid' + +#__Example config dataclasses for similarity transform distance # +@dataclass +class SimilarityTransformDistConfig: + iters: int = 1500 + score_method: Literal["angular", "euclidean"] = "angular" + lr: float = 5e-3 + zero_pad: bool = False + wasserstein_compare: Literal["sv", "eig", None] = "eig" + +@dataclass() +class ControllabilitySimilarityTransformDistConfig: + score_method: Literal["euclidean", "angular"] = "euclidean" + compare = 'state' + joint_optim: bool = False + return_distance_components: bool = False + +class GeneralizedDSA: """ - Computes the Dynamical Similarity Analysis (DSA) for two data tensors + Computes the Generalized Dynamical Similarity Analysis (DSA) for two data tensors """ def __init__( self, X, Y=None, + X_control=None, + Y_control=None, dmd_class=DefaultDMD, - iters=1500, - score_method: Literal["angular", "euclidean", "wasserstein"] = "angular", - lr=5e-3, - zero_pad=False, - device="cpu", - wasserstein_compare: Literal["sv", "eig", None] = "eig", - n_jobs: int = 1, + similarity_class=SimilarityTransformDist, + dmd_config: Union[Mapping[str, Any], dataclass]= DefaultDMDConfig, + simdist_config: Union[Mapping[str, Any], dataclass] = SimilarityTransformDistConfig, + device='cpu', dsa_verbose=False, - **dmd_kwargs, + n_jobs=1, ): """ Parameters @@ -55,32 +98,16 @@ def __init__( * If Y is a single matrix, all matrices in X are compared to Y * If Y is a list, all matrices in X are compared to all matrices in Y - DMD parameters : - - n_delays : int or list or tuple/list: (int,int), (list,list),(list,int),(int,list) - number of delays to use in constructing the Hankel matrix - - delay_interval : int or list or tuple/list: (int,int), (list,list),(list,int),(int,list) - interval between samples taken in constructing Hankel matrix - - rank : int or list or tuple/list: (int,int), (list,list),(list,int),(int,list) - rank of DMD matrix fit in reduced-rank regression - - rank_thresh : float or list or tuple/list: (float,float), (list,list),(list,float),(float,list) - Parameter that controls the rank of V in fitting HAVOK DMD by dictating a threshold - of singular values to use. Explicitly, the rank of V will be the number of singular - values greater than rank_thresh. Defaults to None. - - rank_explained_variance : float or list or tuple: (float,float), (list,list),(list,float),(float,list) - Parameter that controls the rank of V in fitting HAVOK DMD by indicating the percentage of - cumulative explained variance that should be explained by the columns of V. Defaults to None. - - lamb : float - L-1 regularization parameter in DMD fit + X_control : None or np.array or torch.tensor or list of np.arrays or torch.tensors + control data matrix/matrices. + Must be the same shape as X. + If None, then no control data is used. - send_to_cpu: bool - If True, will send all tensors in the object back to the cpu after everything is computed. - This is implemented to prevent gpu memory overload when computing multiple DMDs. + Y_control : None or np.array or torch.tensor or list of np.arrays or torch.tensors + control data matrix/matrices. + Must be the same shape as Y. + If None, then no control data is used. + NOTE: for all of these above, they can be single values or lists or tuples, depending on the corresponding dimensions of the data @@ -90,99 +117,108 @@ def __init__( OR to X and Y respectively across all matrices If it is (list,list), then each element will correspond to an individual dmd matrix indexed at the same position - - SimDist parameters: - - iters : int - number of optimization iterations in Procrustes over vector fields - - score_method : {'angular','euclidean'} - type of metric to compute, angular vs euclidean distance - - lr : float - learning rate of the Procrustes over vector fields optimization - - zero_pad : bool - whether or not to zero-pad if the dimensions are different - - device : 'cpu' or 'cuda' or int - hardware to use in both DMD and PoVF - - dsa_verbose : bool - whether or not print when sections of the analysis is completed - - wasserstein_compare : {'sv','eig',None} - specifies whether to compare the singular values or eigenvalues - if score_method is "wasserstein", or the shapes are different + """ self.X = X self.Y = Y - self.iters = iters - self.score_method = score_method - self.lr = lr + self.X_control = X_control + self.Y_control = Y_control + self.simdist_config = simdist_config + + if is_dataclass(simdist_config): + self.simdist_config = asdict(self.simdist_config) + self.device = device - self.zero_pad = zero_pad self.n_jobs = n_jobs self.dsa_verbose = dsa_verbose self.dmd_class = dmd_class if self.X is None and isinstance(self.Y, list): self.X, self.Y = self.Y, self.X # swap so code is easy + self.X_control, self.Y_control = self.Y_control, self.X_control # swap control too self.check_method() if self.method == "self-pairwise": self.data = [self.X] + self.control_data = [self.X_control] else: self.data = [self.X, self.Y] + self.control_data = [self.X_control, self.Y_control] # Process DMD keyword arguments from **dmd_kwargs # These are parameters like n_delays, rank, etc., that are specific to DMDs # and need to be broadcasted according to X and Y data structure. - self.dmd_kwargs = ( + if is_dataclass(dmd_config): + dmd_config = asdict(dmd_config) + self.dmd_config = ( {} ) # This will store {'param_name': broadcasted_value_list_of_lists} - if dmd_kwargs: - for key, value in dmd_kwargs.items(): - cast_type = CAST_TYPES.get(key) - - if cast_type is not None: - broadcasted_value = self.broadcast_params(value, cast=cast_type) - else: - broadcasted_value = self.broadcast_params(value) + for key, value in dmd_config.items(): + cast_type = CAST_TYPES.get(key) - setattr( - self, key, broadcasted_value - ) # e.g., self.n_delays = [[v,v],[v,v]] - self.dmd_kwargs[key] = ( - broadcasted_value # Store in dict for DMD instantiation - ) + if cast_type is not None: + broadcasted_value = self.broadcast_params(value, cast=cast_type) + else: + broadcasted_value = self.broadcast_params(value) + setattr( + self, key, broadcasted_value + ) # e.g., self.n_delays = [[v,v],[v,v]] + self.dmd_config[key] = ( + broadcasted_value # Store in dict for DMD instantiation + ) + self._check_dmd_simdist_compatibility(dmd_class,similarity_class) self._dmd_api_source(dmd_class) self._initiate_dmds() + self.simdist = similarity_class(**self.simdist_config) - self.simdist = SimilarityTransformDist( - iters, score_method, lr, device, dsa_verbose, wasserstein_compare - ) def _initiate_dmds(self): - if self.dmd_api_source == "local_dsa_dmd": - self.dmds = [ - [ - self.dmd_class(Xi, **{k: v[i][j] for k, v in self.dmd_kwargs.items()}) - for j, Xi in enumerate(dat) - ] - for i, dat in enumerate(self.data) - ] + if self.dmd_has_control and self.X_control is None and self.Y_control is None: + raise ValueError("Error: You are using a DMD model that fits a control operator but no control data is provided for either X or Y") + + if not self.dmd_has_control and (self.X_control is not None or self.Y_control is not None): + warnings.warn("You are using a DMD model with no control but control data is provided, will be ignored") + + + if self.dmd_api_source == "local_dmd": + self.dmds = [] + #TODO: test this for single numpy array + for i, (dat, control_dat) in enumerate(zip(self.data, self.control_data)): + dmd_list = [] + if control_dat is None: + control_dat = [None] * len(dat) + for j, (Xi, Xi_control) in enumerate(zip(dat, control_dat)): + config = {k: v[i][j] for k, v in self.dmd_config.items()} + + # + if self.dmd_has_control: + dmd_obj = self.dmd_class(Xi, control_data=Xi_control, **config) + else: + dmd_obj = self.dmd_class(Xi, **config) + + dmd_list.append(dmd_obj) + self.dmds.append(dmd_list) else: self.dmds = [ - [self.dmd_class(**{k: v[i][j] for k, v in self.dmd_kwargs.items()}) for j, Xi in enumerate(dat)] + [self.dmd_class(**{k: v[i][j] for k, v in self.dmd_config.items()}) for j, Xi in enumerate(dat)] for i, dat in enumerate(self.data) ] + def _check_dmd_simdist_compatibility(self, dmd_class, similarity_class): + self.dmd_has_control = dmd_class in [DefaultDMDc, SubspaceDMDc] or ('pykoopman' in dmd_class.__module__ and self.dmd_config.get('regressor') in [DMDc, EDMDc]) + self.simdist_has_control = similarity_class in [ControllabilitySimilarityTransformDist] + + if self.dmd_has_control and not self.simdist_has_control: + warnings.warn("Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators") + if not self.dmd_has_control and self.simdist_has_control: + raise ValueError("Error: Your DMD model does not fit a control operator but comparing with a DSA metric that compares control operators") + def _dmd_api_source(self, dmd_class): module_name = dmd_class.__module__ + if "pydmd" in module_name: self.dmd_api_source = "pydmd" raise ValueError("DSA is not currently directly compatible with pydmd due to \ @@ -190,8 +226,14 @@ def _dmd_api_source(self, dmd_class): Note that you can pass in pydmd objects through pykoopman's Koopman class.") elif "pykoopman" in module_name: self.dmd_api_source = "pykoopman" - elif "DSA.dmd" in module_name: - self.dmd_api_source = "local_dsa_dmd" + if self.dmd_has_control and self.dmd_config.get('regressor') in [DMDc, EDMDc]: + raise ValueError("Pykoopman DMDc and EDMDc are not currently compatible with DSA") + elif ( + "DSA.dmd" in module_name or + "DSA.subspace_dmdc" in module_name or + "DSA.dmdc" in module_name + ): + self.dmd_api_source = "local_dmd" else: self.dmd_api_source = "unknown" raise ValueError( @@ -202,7 +244,7 @@ def fit_dmds(self): if self.n_jobs != 1: n_jobs = self.n_jobs if self.n_jobs > 0 else -1 # -1 means use all available cores - if self.dmd_api_source == "local_dsa_dmd": + if self.dmd_api_source == "local_dmd": for dmd_sets in self.dmds: if self.dsa_verbose: print(f"Fitting {len(dmd_sets)} DMDs in parallel with {n_jobs} jobs") @@ -218,7 +260,7 @@ def fit_dmds(self): ) else: # Sequential processing - if self.dmd_api_source == "local_dsa_dmd": + if self.dmd_api_source == "local_dmd": for dmd_sets in self.dmds: loop = dmd_sets if not self.dsa_verbose else tqdm.tqdm(dmd_sets, desc="Fitting DMDs") for dmd in loop: @@ -236,24 +278,38 @@ def check_method(self): tensor_or_np = lambda x: isinstance(x, (np.ndarray, torch.Tensor)) if isinstance(self.X, list): + # Ensure X_control is also a list + if self.X_control is not None and not isinstance(self.X_control, list): + self.X_control = [self.X_control] + if self.Y is None: self.method = "self-pairwise" elif isinstance(self.Y, list): self.method = "bipartite-pairwise" + if self.Y_control is not None and not isinstance(self.Y_control, list): + self.Y_control = [self.Y_control] elif tensor_or_np(self.Y): self.method = "list-to-one" self.Y = [self.Y] # wrap in a list for iteration + if self.Y_control is not None: + self.Y_control = [self.Y_control] else: raise ValueError("unknown type of Y") elif tensor_or_np(self.X): self.X = [self.X] + if self.X_control is not None: + self.X_control = [self.X_control] if self.Y is None: raise ValueError("only one element provided") elif isinstance(self.Y, list): self.method = "one-to-list" + if self.Y_control is not None and not isinstance(self.Y_control, list): + self.Y_control = [self.Y_control] elif tensor_or_np(self.Y): self.method = "default" self.Y = [self.Y] + if self.Y_control is not None: + self.Y_control = [self.Y_control] else: raise ValueError("unknown type of Y") else: @@ -292,7 +348,7 @@ def broadcast_params(self, param, cast=None): raise ValueError("unknown type entered for parameter") if cast is not None and param is not None: - out = [[cast(x) for x in dat] for dat in out] + out = [[cast(x) if x is not None else None for x in dat] for dat in out] return out @@ -313,7 +369,7 @@ def fit_score(self): return self.score() def get_dmd_matrix(self, dmd): - if self.dmd_api_source == "local_dsa_dmd": + if self.dmd_api_source == "local_dmd": return dmd.A_v elif self.dmd_api_source == "pykoopman": return dmd.A @@ -321,32 +377,39 @@ def get_dmd_matrix(self, dmd): raise ValueError("DSA is not currently compatible with pydmd due to \ data structure incompatibility. Please use pykoopman instead.") - def score(self, iters=None, lr=None, score_method=None): + def get_dmd_control_matrix(self, dmd): + if self.dmd_api_source == "local_dmd": + return dmd.B_v + elif self.dmd_api_source == "pykoopman": + return dmd.B + elif self.dmd_api_source == "pydmd": + raise ValueError("DSA is not currently compatible with pydmd due to \ + data structure incompatibility. Please use pykoopman instead.") + + def score(self): """ Score DSA with precomputed dmds Parameters __________ - iters : int or None - number of optimization steps, if None then resorts to saved self.iters - lr : float or None - learning rate, if None then resorts to saved self.lr - score_method : None or {'angular','euclidean'} - overwrites the score method in the object for this application Returns ________ - score : float + score : float or numpy array similarity score of the two precomputed DMDs + if array is d x d, it is a standard DSA (or whatever you set it to be) + if array is d x d x 3 , you ran simdist_controllability with return_distance_components = True + This means that you returned the following similarity scores: + joint similarity scores (both state and control) + state similarity score (optimized jointly) + control similarity score (optimized jointly) """ - iters = self.iters if iters is None else iters - lr = self.lr if lr is None else lr - score_method = self.score_method if score_method is None else score_method - - ind2 = 1 - int(self.method == "self-pairwise") + ind2 = 0 if self.method == "self-pairwise" else 1 # 0 if self.pairwise (want to compare the set to itself) - - self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]))) + n_sims = 1 if not (self.simdist_has_control \ + and self.simdist_config.get("return_distance_components")) else 3 + + self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]),n_sims)) if self.dsa_verbose: print('comparing dmds') @@ -358,14 +421,17 @@ def compute_similarity(i, j): if self.dsa_verbose and self.n_jobs != 1: print(f"computing similarity between DMDs {i} and {j}") - sim = self.simdist.fit_score( - self.get_dmd_matrix(self.dmds[0][i]), - self.get_dmd_matrix(self.dmds[ind2][j]), - iters, - lr, - score_method, - zero_pad=self.zero_pad, - ) + simdist_args = [ + self.get_dmd_matrix(self.dmds[0][i]), + self.get_dmd_matrix(self.dmds[ind2][j]), + ] + if self.dmd_has_control: + simdist_args.extend([ + self.get_dmd_control_matrix(self.dmds[0][i]), + self.get_dmd_control_matrix(self.dmds[ind2][j]), + ]) + sim = self.simdist.fit_score(*simdist_args) + if self.dsa_verbose and self.n_jobs != 1: print(f"computing similarity between DMDs {i} and {j}") @@ -397,6 +463,79 @@ def compute_similarity(i, j): self.sims[j, i] = sim if self.method == "default": - return self.sims[0, 0] + return self.sims[0, 0].squeeze() + + return self.sims.squeeze() - return self.sims + +class DSA(GeneralizedDSA): + def __init__( + self, + X, + Y=None, + dmd_class=DefaultDMD, + device='cpu', + dsa_verbose=False, + n_jobs=1, + # Advanced simdist parameters + score_method: Literal["angular", "euclidean"] = "angular", + iters: int = 1500, + lr: float = 5e-3, + zero_pad: bool = False, + wasserstein_compare: Literal["sv", "eig", None] = "eig", + **dmd_kwargs + ): + #TODO: add readme + # Build simdist_config internally + simdist_config = { + 'score_method': score_method, + 'iters': iters, + 'lr': lr, + 'zero_pad': zero_pad, + 'wasserstein_compare': wasserstein_compare, + } + + dmd_config = dmd_kwargs + + super().__init__( + X=X, + Y=Y, + X_control=None, + Y_control=None, + dmd_class=dmd_class, + similarity_class=SimilarityTransformDist, + dmd_config=dmd_config, + simdist_config=simdist_config, + device=device, + dsa_verbose=dsa_verbose, + n_jobs=n_jobs, + ) + +class InputDSA(GeneralizedDSA): + def __init__( + self, + X, + X_control, + Y=None, + Y_control=None, + dmd_class=SubspaceDMDc, + similarity_class=ControllabilitySimilarityTransformDist, + dmd_config: Union[Mapping[str, Any], dataclass]= SubspaceDMDcConfig, + simdist_config: Union[Mapping[str, Any], dataclass] = ControllabilitySimilarityTransformDistConfig, + device='cpu', + dsa_verbose=False, + n_jobs=1, + ): + super().__init__( + X, + Y, + X_control, + Y_control, + dmd_class, + similarity_class, + dmd_config, + simdist_config, + device, + dsa_verbose, + n_jobs, + ) diff --git a/DSA/controllability_simdist.py b/DSA/simdist_controllability.py similarity index 91% rename from DSA/controllability_simdist.py rename to DSA/simdist_controllability.py index 0889847..6e0b72e 100644 --- a/DSA/controllability_simdist.py +++ b/DSA/simdist_controllability.py @@ -13,35 +13,37 @@ def __init__( self, *, score_method: Literal["euclidean", "angular"] = "euclidean", - alpha: float = 0.5, + compare: Literal['joint','control','state'] = 'joint', joint_optim: bool = False, + return_distance_components=True ): - """ + f""" Parameters ---------- score_method : {"euclidean", "angular"} Distance method to use. Euclidean uses Frobenius norm, angular uses principal angles. - alpha : float - Weight (only used if you call fit_score with non-default behavior). + compare: {'joint','control','state'} + what type of comparison to do on the A and B matrices align_inputs : bool If True, do two-sided Procrustes on controllability matrices (solve for C and C_u). """ self.score_method = score_method - self.alpha = alpha + self.compare = compare self.joint_optim = joint_optim + self.return_distance_components=return_distance_components - def fit_score(self, A, B, A_control, B_control, alpha=0.5, return_distance_components=False): + def fit_score(self, A, B, A_control, B_control): + C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim ) - alpha = self.alpha if alpha is None else alpha score_method = self.score_method - if alpha == 0.5: - if return_distance_components: + if self.compare == 'joint': + if self.return_distance_components: if self.score_method == 'euclidean': # sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") ** 2 # sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") ** 2 @@ -68,7 +70,7 @@ def fit_score(self, A, B, A_control, B_control, alpha=0.5, return_distance_compo else: raise ValueError('Choose between Euclidean or angular distance') - elif alpha == 0.0: + elif self.compare: return self.compare_A(A, B, score_method=score_method) else: @@ -109,7 +111,7 @@ def get_controllability_matrix(self, A, B): K = K_test return K - def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False, n=100): + def compare_systems_procrustes(self, A1, B1, A2, B2, *,align_inputs=False): """ Compares two LTI systems by finding the optimal orthogonal transformation that aligns their controllability matrices. @@ -155,12 +157,6 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False, n=10 C = U1 @ U2.T C_u = V2t.T @ V1t # = V2 @ V1^T - # import matplotlib.pyplot as plt - # plt.imshow(C_u) - # plt.savefig('C_u.png') - - #TODO: truncate C_u - #TODO: compute error on A and B instead of the observability matrix K2_aligned = C @ K2 @ C_u err = np.linalg.norm(K1 - K2_aligned, "fro") cos_sim = (np.vdot(K1, K2_aligned).real / diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index ef8e151..caace53 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -2,14 +2,15 @@ import numpy as np import torch #TODO: convert to torch below to match the DMD class +#TODO: fix time-first argument to match the DMD class -class subspaceDMDc(): +class SubspaceDMDc(): """Subspace DMDc class for computing and predicting with DMD with control models. """ def __init__( self, data, - control_data=None, + control_data, n_delays=1, rank=None, lamb=1e-8, diff --git a/DSA/sweeps.py b/DSA/sweeps.py index 4bb07ba..383e7ca 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -29,8 +29,6 @@ def sweep_ranks_delays( train_frac=0.8, reseed=5, return_residuals=True, - featurize=False, - ndim=None, return_transient_growth=False, return_mse=False, error_space='X', @@ -53,10 +51,6 @@ def sweep_ranks_delays( Reseed for DMD prediction. return_residuals : bool Whether to return residuals. - featurize : bool - Whether to featurize the data (for special cases). - ndim : int or None - Number of dimensions to use if featurizing. measure_transient_growth : bool Whether to measure transient growth (numerical abscissa and l2 norm). return_mse: bool From bf04fc9e894dd062258306f572b1307918df8508 Mon Sep 17 00:00:00 2001 From: ostrow Date: Mon, 27 Oct 2025 23:59:19 -0400 Subject: [PATCH 05/51] convert subspace_dmdc to working in torch --- DSA/subspace_dmdc.py | 265 ++++++++++++++++++++++++++----------------- 1 file changed, 161 insertions(+), 104 deletions(-) diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index caace53..d406902 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -1,8 +1,6 @@ """This module computes the subspace DMD with control (DMDc) model for a given dataset.""" import numpy as np import torch -#TODO: convert to torch below to match the DMD class -#TODO: fix time-first argument to match the DMD class class SubspaceDMDc(): """Subspace DMDc class for computing and predicting with DMD with control models. @@ -20,8 +18,10 @@ def __init__( time_first=True, backend='n4sid' ): - self.data = data - self.control_data = control_data + # Convert inputs to torch tensors and store + self.device = device + self.data = self._to_tensor(data) + self.control_data = self._to_tensor(control_data) self.A_v = None self.B_v = None self.C_v = None @@ -31,6 +31,23 @@ def __init__( self.time_first = time_first self.backend = backend self.lamb = lamb + self.verbose = verbose + self.send_to_cpu = send_to_cpu + + def _to_tensor(self, data): + """Convert data to torch tensor, handling lists and numpy arrays.""" + if isinstance(data, list): + return [self._to_tensor_single(d) for d in data] + else: + return self._to_tensor_single(data) + + def _to_tensor_single(self, data): + """Convert single data item to torch tensor.""" + if isinstance(data, np.ndarray): + return torch.from_numpy(data).float().to(self.device) + elif isinstance(data, torch.Tensor): + return data.float().to(self.device) + return data def fit(self): @@ -38,10 +55,26 @@ def fit(self): y=self.data, u=self.control_data, p=self.n_delays, - f=self.n_delays, + f=self.n_delays, n=self.rank, backend=self.backend, lamb=self.lamb) + + if self.send_to_cpu: + self.all_to_device("cpu") + + def all_to_device(self, device): + """Send all tensors to specified device.""" + if self.A_v is not None: + self.A_v = self.A_v.to(device) + if self.B_v is not None: + self.B_v = self.B_v.to(device) + if self.C_v is not None: + self.C_v = self.C_v.to(device) + if self.info is not None: + for key in ['R_hat', 'Q_hat', 'S_hat', 'Gamma_hat', 'singular_values_O', 'noise_covariance']: + if key in self.info and isinstance(self.info[key], torch.Tensor): + self.info[key] = self.info[key].to(device) @@ -51,8 +84,8 @@ def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None Now use QR decomposition for computing the oblique projection as in N4SID implementations. Parameters: - - y_list: list of arrays, each (p_out, N_i) - output data for trial i - - u_list: list of arrays, each (m, N_i) - input data for trial i + - y_list: list of tensors, each (p_out, N_i) - output data for trial i + - u_list: list of tensors, each (m, N_i) - input data for trial i - p: past window length - f: future window length - n: state dimension (auto-determined if None) @@ -80,7 +113,7 @@ def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None raise ValueError(f"Trial {i}: y and u have different time lengths") def hankel_stack(X, start, L): - return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + return torch.cat([X[:, start + i:start + i + 1] for i in range(L)], dim=0) # Collect data from all trials U_p_all = [] @@ -95,17 +128,18 @@ def hankel_stack(X, start, L): T_trial = N_trial - (p + f) + 1 if T_trial <= 0: - print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") + if self.verbose: + print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") continue valid_trials.append(trial_idx) T_per_trial.append(T_trial) # Build Hankel matrices for this trial - U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) - Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) - U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) - Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) + U_p_trial = torch.cat([hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1) + Y_p_trial = torch.cat([hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1) + U_f_trial = torch.cat([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1) + Y_f_trial = torch.cat([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1) U_p_all.append(U_p_trial) Y_p_all.append(Y_p_trial) @@ -116,18 +150,18 @@ def hankel_stack(X, start, L): raise ValueError("No trials have sufficient data for given (p,f)") # Concatenate across valid trials - U_p = np.concatenate(U_p_all, axis=1) # (p m, T_total) - Y_p = np.concatenate(Y_p_all, axis=1) # (p p_out, T_total) - U_f = np.concatenate(U_f_all, axis=1) # (f m, T_total) - Y_f = np.concatenate(Y_f_all, axis=1) # (f p_out, T_total) + U_p = torch.cat(U_p_all, dim=1) # (p m, T_total) + Y_p = torch.cat(Y_p_all, dim=1) # (p p_out, T_total) + U_f = torch.cat(U_f_all, dim=1) # (f m, T_total) + Y_f = torch.cat(Y_f_all, dim=1) # (f p_out, T_total) T_total = sum(T_per_trial) - Z_p = np.vstack([U_p, Y_p]) # (p (m + p_out), T_total) + Z_p = torch.vstack([U_p, Y_p]) # (p (m + p_out), T_total) - H = np.vstack([U_f, Z_p, Y_f]) + H = torch.vstack([U_f, Z_p, Y_f]) # Perform QR on H.T to get equivalent LQ on H - Q, R_upper = np.linalg.qr(H.T, mode='reduced') # H.T = Q R_upper, R_upper upper triangular + Q, R_upper = torch.linalg.qr(H.T, mode='reduced') # H.T = Q R_upper, R_upper upper triangular L = R_upper.T # L = R_upper.T, lower triangular # Dimensions for slicing @@ -140,19 +174,19 @@ def hankel_stack(X, start, L): R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] # Compute oblique projection O = R32 @ pinv(R22) @ Z_p - O = R32 @ np.linalg.pinv(R22) @ Z_p + O = R32 @ torch.linalg.pinv(R22) @ Z_p # The rest remains the same: SVD on O - Uo, s, Vt = np.linalg.svd(O, full_matrices=False) + Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) if n is None: - cs = np.cumsum(s**2) / (s**2).sum() - n = int(np.searchsorted(cs, energy) + 1) + cs = torch.cumsum(s**2, dim=0) / (s**2).sum() + n = int((cs < energy).sum().item() + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) U_n = Uo[:, :n] - S_n = np.diag(s[:n]) + S_n = torch.diag(s[:n]) V_n = Vt[:n, :] - S_half = np.sqrt(S_n) + S_half = torch.sqrt(S_n) Gamma_hat = U_n @ S_half # (f p_out, n) X_hat = S_half @ V_n # (n, T_total) @@ -191,21 +225,21 @@ def hankel_stack(X, start, L): start_idx += T_trial # Concatenate all segments - X = np.concatenate(X_segments, axis=1) - X_next = np.concatenate(X_next_segments, axis=1) - U_mid = np.concatenate(U_mid_segments, axis=1) + X = torch.cat(X_segments, dim=1) + X_next = torch.cat(X_next_segments, dim=1) + U_mid = torch.cat(U_mid_segments, dim=1) # Regression for A and B - Z = np.vstack([X, U_mid]) + Z = torch.vstack([X, U_mid]) # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T ZTZ = Z @ Z.T - ridge_term = lamb * np.eye(ZTZ.shape[0]) - AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T + ridge_term = lamb * torch.eye(ZTZ.shape[0], device=self.device) + AB = torch.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T A_hat = AB[:, :n] B_hat = AB[:, n:] - # Z = np.vstack([X, U_mid]) - # AB = X_next @ np.linalg.pinv(Z) + # Z = torch.vstack([X, U_mid]) + # AB = X_next @ torch.linalg.pinv(Z) # A_hat = AB[:, :n] # B_hat = AB[:, n:] @@ -213,7 +247,7 @@ def hankel_stack(X, start, L): # Estimate noise covariance matrix # 0) Outputs aligned to X and U_mid (same time indices/columns) - Y_curr = np.concatenate(Y_segments, axis=1) # shape: (p_out, N) + Y_curr = torch.cat(Y_segments, dim=1) # shape: (p_out, N) # 1) Residuals at time t # Process noise residual (state eq): w_t ≈ x_{t+1} - A x_t - B u_ts @@ -223,8 +257,8 @@ def hankel_stack(X, start, L): V_hat = Y_curr - (C_hat @ X) # (p_out, N) # 2) Mean-centering - V_hat = V_hat - V_hat.mean(axis=1, keepdims=True) - W_hat = W_hat - W_hat.mean(axis=1, keepdims=True) + V_hat = V_hat - V_hat.mean(dim=1, keepdim=True) + W_hat = W_hat - W_hat.mean(dim=1, keepdim=True) N_res = V_hat.shape[1] denom = max(N_res - 1, 1) @@ -235,11 +269,17 @@ def hankel_stack(X, start, L): # 4) Symmetrize eps = 1e-12 - R_hat = 0.5 * (R_hat + R_hat.T) + eps * np.eye(R_hat.shape[0]) - Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * np.eye(Q_hat.shape[0]) - - noise_covariance = np.block([[R_hat, S_hat.T], - [S_hat, Q_hat]]) + R_hat = 0.5 * (R_hat + R_hat.T) + eps * torch.eye(R_hat.shape[0], device=self.device) + Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * torch.eye(Q_hat.shape[0], device=self.device) + + noise_covariance = torch.block_diag(R_hat, Q_hat) + # Add off-diagonal blocks + top_right = S_hat.T + bottom_left = S_hat + noise_covariance = torch.cat([ + torch.cat([R_hat, top_right], dim=1), + torch.cat([bottom_left, Q_hat], dim=1) + ], dim=0) info = { "singular_values_O": s, @@ -268,8 +308,8 @@ def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e- Subspace-DMDc for multi-trial data with variable trial lengths. Parameters: - - y_list: list of arrays, each (p_out, N_i) - output data for trial i - - u_list: list of arrays, each (m, N_i) - input data for trial i + - y_list: list of tensors, each (p_out, N_i) - output data for trial i + - u_list: list of tensors, each (m, N_i) - input data for trial i - p: past window length - f: future window length - n: state dimension (auto-determined if None) @@ -298,7 +338,7 @@ def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e- raise ValueError(f"Trial {i}: y and u have different time lengths") def hankel_stack(X, start, L): - return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + return torch.cat([X[:, start + i:start + i + 1] for i in range(L)], dim=0) # Collect data from all trials U_p_all = [] @@ -313,61 +353,62 @@ def hankel_stack(X, start, L): T_trial = N_trial - (p + f) + 1 if T_trial <= 0: - print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") + if self.verbose: + print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") continue valid_trials.append(trial_idx) T_per_trial.append(T_trial) # Build Hankel matrices for this trial - U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) - Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) - U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) - Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) + U_p_trial = torch.cat([hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1) + Y_p_trial = torch.cat([hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1) + U_f_trial = torch.cat([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1) + Y_f_trial = torch.cat([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1) U_p_all.append(U_p_trial) Y_p_all.append(Y_p_trial) U_f_all.append(U_f_trial) Y_f_all.append(Y_f_trial) - - print("="*40) - print(f"Number of valid trials: {len(U_p_trial)}") + if self.verbose: + print("="*40) + print(f"Number of valid trials: {len(valid_trials)}") if not valid_trials: raise ValueError("No trials have sufficient data for given (p,f)") # Concatenate across valid trials - U_p = np.concatenate(U_p_all, axis=1) # (pm, T_total) - Y_p = np.concatenate(Y_p_all, axis=1) # (p*p_out, T_total) - U_f = np.concatenate(U_f_all, axis=1) # (fm, T_total) - Y_f = np.concatenate(Y_f_all, axis=1) # (f*p_out, T_total) + U_p = torch.cat(U_p_all, dim=1) # (pm, T_total) + Y_p = torch.cat(Y_p_all, dim=1) # (p*p_out, T_total) + U_f = torch.cat(U_f_all, dim=1) # (fm, T_total) + Y_f = torch.cat(Y_f_all, dim=1) # (f*p_out, T_total) T_total = sum(T_per_trial) - Z_p = np.vstack([U_p, Y_p]) # (p(m+p_out), T_total) + Z_p = torch.vstack([U_p, Y_p]) # (p(m+p_out), T_total) # Oblique projection: remove row(U_f), project onto row(Z_p) UfUfT = U_f @ U_f.T - Xsolve = np.linalg.solve(UfUfT + lamb*np.eye(UfUfT.shape[0]), U_f) - Pi_perp = np.eye(T_total) - U_f.T @ Xsolve + Xsolve = torch.linalg.solve(UfUfT + lamb*torch.eye(UfUfT.shape[0], device=self.device), U_f) + Pi_perp = torch.eye(T_total, device=self.device) - U_f.T @ Xsolve Yf_perp = Y_f @ Pi_perp Zp_perp = Z_p @ Pi_perp ZZT = Zp_perp @ Zp_perp.T - Zp_pinv_left = np.linalg.solve(ZZT + lamb*np.eye(ZZT.shape[0]), Zp_perp) + Zp_pinv_left = torch.linalg.solve(ZZT + lamb*torch.eye(ZZT.shape[0], device=self.device), Zp_perp) P = Zp_perp.T @ Zp_pinv_left O = Yf_perp @ P # ≈ Γ_f X_p - Uo, s, Vt = np.linalg.svd(O, full_matrices=False) + Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) if n is None: - cs = np.cumsum(s**2) / (s**2).sum() - n = int(np.searchsorted(cs, energy) + 1) + cs = torch.cumsum(s**2, dim=0) / (s**2).sum() + n = int((cs < energy).sum().item() + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) U_n = Uo[:, :n] - S_n = np.diag(s[:n]) + S_n = torch.diag(s[:n]) V_n = Vt[:n, :] - S_half = np.sqrt(S_n) + S_half = torch.sqrt(S_n) Gamma_hat = U_n @ S_half # (f*p_out, n) X_hat = S_half @ V_n # (n, T_total) @@ -398,16 +439,16 @@ def hankel_stack(X, start, L): start_idx += T_trial # Concatenate all segments - X = np.concatenate(X_segments, axis=1) - X_next = np.concatenate(X_next_segments, axis=1) - U_mid = np.concatenate(U_mid_segments, axis=1) + X = torch.cat(X_segments, dim=1) + X_next = torch.cat(X_next_segments, dim=1) + U_mid = torch.cat(U_mid_segments, dim=1) # Regression for A and B - Z = np.vstack([X, U_mid]) + Z = torch.vstack([X, U_mid]) # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T ZTZ = Z @ Z.T - ridge_term = lamb * np.eye(ZTZ.shape[0]) - AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T + ridge_term = lamb * torch.eye(ZTZ.shape[0], device=self.device) + AB = torch.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T A_hat = AB[:, :n] B_hat = AB[:, n:] @@ -474,12 +515,15 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ def predict(self, Y, U, reseed=None): - # Y and U are (n_times, n_channels) or list of 2D arrays + # Y and U are (n_times, n_channels) or list of 2D arrays/tensors if reseed is None: reseed = 1 - # Handle list of 2D arrays + # Convert inputs to tensors if needed if isinstance(Y, list): + Y = [self._to_tensor_single(y) for y in Y] + U = [self._to_tensor_single(u) for u in U] + if not self.time_first: Y = [y.T for y in Y] U = [u.T for u in U] @@ -495,17 +539,21 @@ def predict(self, Y, U, reseed=None): u=U[trial][t] ) trial_predictions.append(y_filtered) - Y_pred.append(np.concatenate(trial_predictions, axis=1).T) + Y_pred.append(torch.cat(trial_predictions, dim=1).T) return Y_pred # Return as list to match input format + # Convert to tensors + Y = self._to_tensor_single(Y) + U = self._to_tensor_single(U) + # print("time_first", self.time_first) if not self.time_first: if Y.ndim == 2: Y = Y.T U = U.T else: - Y = Y.transpose(0, 2, 1) - U = U.transpose(0, 2, 1) + Y = Y.permute(0, 2, 1) + U = U.permute(0, 2, 1) self.kalman = OnlineKalman(self) if Y.ndim == 2: @@ -513,7 +561,7 @@ def predict(self, Y, U, reseed=None): for t in range(Y.shape[0]): y_filtered, _ = self.kalman.step(y=Y[t] if t%reseed == 0 else None, u=U[t]) Y_pred.append(y_filtered) - return np.concatenate(Y_pred, axis=1).T + return torch.cat(Y_pred, dim=1).T else: # 3D data (n_trials, time, p_out) # print("Y.shape", Y.shape) @@ -526,8 +574,8 @@ def predict(self, Y, U, reseed=None): y_filtered, _ = self.kalman.step(y=Y[trial, t] if t%reseed == 0 else None, u=U[trial, t]) trial_predictions.append(y_filtered) # print("y_filtered.shape", y_filtered.shape) - Y_pred.append(np.concatenate(trial_predictions, axis=1).T) - return np.array(Y_pred) + Y_pred.append(torch.cat(trial_predictions, dim=1).T) + return torch.stack(Y_pred) @@ -549,6 +597,7 @@ def __init__(self, dmdc): Fitted DMDc model containing A_v, B_v, C_v matrices and noise covariance estimates (R_hat, S_hat, Q_hat) """ + self.device = dmdc.device self.A = dmdc.A_v self.B = dmdc.B_v self.C = dmdc.C_v @@ -559,6 +608,7 @@ def __init__(self, dmdc): # Get dimensions # print("C_shape", self.C.shape) self.y_dim, self.x_dim = self.C.shape + self.u_dim = self.B.shape[1] # Initialize state storage self.p_filtereds = [] @@ -639,10 +689,10 @@ def step(self, y=None, u=None, reg_coef=1e-6): Parameters ---------- - y : np.ndarray, optional + y : torch.Tensor or np.ndarray, optional Observed output at current time step. If None, the filter will predict without observation update. - u : np.ndarray, optional + u : torch.Tensor or np.ndarray, optional Input at current time step. If None, no input is applied. reg_coef : float, optional Regularization coefficient to add to diagonal of P matrices @@ -650,51 +700,58 @@ def step(self, y=None, u=None, reg_coef=1e-6): Returns ------- - y_filtered : np.ndarray + y_filtered : torch.Tensor Filtered output estimate - x_filtered : np.ndarray + x_filtered : torch.Tensor Filtered state estimate """ - x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) - p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) + x_pred = self.x_predicteds[-1] if self.x_predicteds else torch.zeros((self.x_dim, 1), device=self.device) + p_pred = self.p_predicteds[-1] if self.p_predicteds else torch.eye(self.x_dim, device=self.device) # Add regularization to p_pred to prevent ill-conditioning - p_pred_reg = p_pred + reg_coef * np.eye(self.x_dim) - - # Ensure inputs are column vectors - if u is not None and u.ndim == 1: - u = u.reshape(-1, 1) - if y is not None and y.ndim == 1: - y = y.reshape(-1, 1) - if u is None: - u = np.zeros((self.u_dim, 1)) - if y is None: - y = np.zeros((self.y_dim, 1)) + p_pred_reg = p_pred + reg_coef * torch.eye(self.x_dim, device=self.device) + + # Convert inputs to tensors and ensure column vectors + if u is not None: + if isinstance(u, np.ndarray): + u = torch.from_numpy(u).float().to(self.device) + if u.ndim == 1: + u = u.reshape(-1, 1) + else: + u = torch.zeros((self.u_dim, 1), device=self.device) + + if y is not None: + if isinstance(y, np.ndarray): + y = torch.from_numpy(y).float().to(self.device) + if y.ndim == 1: + y = y.reshape(-1, 1) + else: + y = torch.zeros((self.y_dim, 1), device=self.device) # Use regularized p_pred in computations S_innov = self.R + self.C @ p_pred_reg @ self.C.T - K_filtered = p_pred_reg @ self.C.T @ np.linalg.pinv(S_innov) + K_filtered = p_pred_reg @ self.C.T @ torch.linalg.pinv(S_innov) p_filtered = p_pred_reg - K_filtered @ self.C @ p_pred_reg # Add regularization to p_filtered to maintain positive definiteness p_filtered = (p_filtered + p_filtered.T) / 2 # Ensure symmetry - p_filtered = p_filtered + reg_coef * np.eye(self.x_dim) # Add regularization + p_filtered = p_filtered + reg_coef * torch.eye(self.x_dim, device=self.device) # Add regularization - if not np.isnan(y).any(): + if not torch.isnan(y).any(): x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) else: - x_filtered = x_pred.copy() + x_filtered = x_pred.clone() - K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ np.linalg.pinv(S_innov) + K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ torch.linalg.pinv(S_innov) p_predicted = (self.A @ p_pred_reg @ self.A.T + self.Q - K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T) # Add regularization to p_predicted and ensure symmetry p_predicted = (p_predicted + p_predicted.T) / 2 # Ensure symmetry - p_predicted = p_predicted + reg_coef * np.eye(self.x_dim) # Add regularization + p_predicted = p_predicted + reg_coef * torch.eye(self.x_dim, device=self.device) # Add regularization x_predicted = self.A @ x_pred + self.B @ u - if not np.isnan(y).any(): + if not torch.isnan(y).any(): x_predicted += K_pred @ (y - self.C @ x_pred) # Store results From 0c3aa9ad0b8645c181d188bb33483c21d8e1ba80 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 00:07:33 -0400 Subject: [PATCH 06/51] fix inits --- DSA/__init__.py | 6 ++++-- DSA/subspace_dmdc.py | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/DSA/__init__.py b/DSA/__init__.py index 3a12098..7968a98 100644 --- a/DSA/__init__.py +++ b/DSA/__init__.py @@ -1,7 +1,9 @@ -from DSA.dsa import DSA +from DSA.dsa import DSA, GeneralizedDSA, InputDSA from DSA.dmd import DMD -from DSA.kerneldmd import KernelDMD +from DSA.dmdc import DMDc +from DSA.subspace_dmdc import SubspaceDMDc from DSA.simdist import SimilarityTransformDist +from DSA.simdist_controllability import ControllabilitySimilarityTransformDist from DSA.stats import * from DSA.sweeps import * from DSA.preprocessing import * diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index d406902..eca42d9 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -2,7 +2,7 @@ import numpy as np import torch -class SubspaceDMDc(): +class SubspaceDMDc: """Subspace DMDc class for computing and predicting with DMD with control models. """ def __init__( From f456323c265496a222ff78094b9d915b97771506 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 00:47:21 -0400 Subject: [PATCH 07/51] fix imports --- DSA/dmd.py | 2 +- DSA/dsa.py | 7 +++---- DSA/preprocessing.py | 5 ++++- DSA/resdmd.py | 5 ++++- DSA/simdist.py | 5 ++++- DSA/simdist_controllability.py | 5 ++++- 6 files changed, 20 insertions(+), 9 deletions(-) diff --git a/DSA/dmd.py b/DSA/dmd.py index 6e3e64a..10a6905 100644 --- a/DSA/dmd.py +++ b/DSA/dmd.py @@ -77,7 +77,7 @@ class DMD(BaseDMD): def __init__( self, data, - n_delays, + n_delays=1, delay_interval=1, rank=None, rank_thresh=None, diff --git a/DSA/dsa.py b/DSA/dsa.py index 92382eb..660a76f 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -11,6 +11,7 @@ from joblib import Parallel, delayed from dataclasses import dataclass, is_dataclass, asdict import DSA.pykoopman as pykoopman +import pydmd from DSA.pykoopman.regression import DMDc, EDMDc from typing import Union, Mapping, Any import warnings @@ -38,8 +39,8 @@ class DefaultDMDConfig: send_to_cpu: bool = False @dataclass() class pyKoopmanDMDConfig: - observables: pykoopman.observables.BaseObservables = pykoopman.observables.TimeDelay(n_delays=1) - regressor = pykoopman.regression.DMD(svd_rank=2) + observables = pykoopman.observables.TimeDelay(n_delays=1) + regressor = pydmd.DMD(svd_rank=2) @dataclass() class SubspaceDMDcConfig: @@ -481,7 +482,6 @@ def __init__( score_method: Literal["angular", "euclidean"] = "angular", iters: int = 1500, lr: float = 5e-3, - zero_pad: bool = False, wasserstein_compare: Literal["sv", "eig", None] = "eig", **dmd_kwargs ): @@ -491,7 +491,6 @@ def __init__( 'score_method': score_method, 'iters': iters, 'lr': lr, - 'zero_pad': zero_pad, 'wasserstein_compare': wasserstein_compare, } diff --git a/DSA/preprocessing.py b/DSA/preprocessing.py index a44badd..3a04570 100644 --- a/DSA/preprocessing.py +++ b/DSA/preprocessing.py @@ -4,7 +4,10 @@ from sklearn.decomposition import PCA from sklearn.pipeline import make_pipeline from sklearn.kernel_approximation import Nystroem -from DSA.dmd import embed_signal_torch +try: + from .dmd import embed_signal_torch +except ImportError: + from dmd import embed_signal_torch from scipy.signal import convolve diff --git a/DSA/resdmd.py b/DSA/resdmd.py index 82dce85..d82c56f 100644 --- a/DSA/resdmd.py +++ b/DSA/resdmd.py @@ -2,7 +2,10 @@ import matplotlib.pyplot as plt from matplotlib import cm from matplotlib import colors as mcolors -from DSA.dmd import DMD +try: + from .dmd import DMD +except ImportError: + from dmd import DMD import torch import ot from typing import Literal diff --git a/DSA/simdist.py b/DSA/simdist.py index e15e909..99e5d6c 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -6,7 +6,10 @@ import torch.nn.utils.parametrize as parametrize from scipy.stats import wasserstein_distance import ot # optimal transport for multidimensional l2 wasserstein -from DSA import DMD +try: + from .dmd import DMD +except ImportError: + from dmd import DMD def pad_zeros(A, B, device): diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 6e0b72e..1528865 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -2,7 +2,10 @@ import numpy as np from scipy.linalg import orthogonal_procrustes -from DSA.simdist import SimilarityTransformDist +try: + from .simdist import SimilarityTransformDist +except ImportError: + from simdist import SimilarityTransformDist class ControllabilitySimilarityTransformDist: """ From df63ee64871bfda1cd8d518788387da831d2254d Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 11:38:24 -0400 Subject: [PATCH 08/51] simplify angular distance --- DSA/simdist_controllability.py | 42 +++++++++++++++++++++------------- 1 file changed, 26 insertions(+), 16 deletions(-) diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 1528865..951391b 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -35,6 +35,23 @@ def __init__( self.joint_optim = joint_optim self.return_distance_components=return_distance_components + @staticmethod + def compute_angular_dist(A, B): + """ + Computes the angular distance between two matrices A and B. + + Args: + A (np.ndarray): First matrix + B (np.ndarray): Second matrix + + Returns: + float: Angular distance between A and B + """ + cos_sim = np.trace(A.T @ B) / (np.linalg.norm(A, 'fro') * np.linalg.norm(B, 'fro')) + cos_sim = np.clip(cos_sim, -1, 1) + cos_sim = np.arccos(cos_sim) + cos_sim = np.clip(cos_sim, 0, np.pi) + return cos_sim def fit_score(self, A, B, A_control, B_control): @@ -54,16 +71,8 @@ def fit_score(self, A, B, A_control, B_control): sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") return sims_joint_euc, sims_state_joint, sims_control_joint elif self.score_method == 'angular': - sims_control_joint = np.trace((C @ A_control @ C_u).T @ B_control) / (np.linalg.norm(C @ A_control @ C_u, 'fro') * np.linalg.norm(B_control, 'fro')) - sims_state_joint = np.trace((C @ A @ C.T).T @ B) / (np.linalg.norm(C @ A @ C.T, 'fro') * np.linalg.norm(B, 'fro')) - - sims_control_joint = np.clip(sims_control_joint, -1, 1) - sims_state_joint = np.clip(sims_state_joint, -1, 1) - sims_control_joint =np.arccos(sims_control_joint) - sims_state_joint =np.arccos(sims_state_joint) - sims_control_joint = np.clip(sims_control_joint, 0, np.pi) - sims_state_joint = np.clip(sims_state_joint, 0, np.pi) - + sims_control_joint = self.compute_angular_dist(C @ A_control @ C_u, B_control) + sims_state_joint = self.compute_angular_dist(C @ A @ C.T, B) return sims_joint_ang, sims_state_joint, sims_control_joint else: if self.score_method == 'euclidean': @@ -73,7 +82,7 @@ def fit_score(self, A, B, A_control, B_control): else: raise ValueError('Choose between Euclidean or angular distance') - elif self.compare: + elif self.compare == 'state': return self.compare_A(A, B, score_method=score_method) else: @@ -170,10 +179,10 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *,align_inputs=False): return C, C_u, err, cos_sim - @staticmethod - def compare_A(A1, A2, score_method='euclidean'): - simdist = SimilarityTransformDist(iters=1000, score_method=score_method, lr=1e-3, verbose=True) - return simdist.fit_score(A1, A2, score_method=score_method) + # @staticmethod + # def compare_A(A1, A2, score_method='euclidean'): + # simdist = SimilarityTransformDist(iters=1000, score_method=score_method, lr=1e-3, verbose=True) + # return simdist.fit_score(A1, A2, score_method=score_method) @staticmethod def compare_B(B1, B2, score_method='euclidean'): @@ -182,7 +191,8 @@ def compare_B(B1, B2, score_method='euclidean'): return np.linalg.norm(B1 - R.T @ B2, "fro") # return np.linalg.norm(B1 - R.T @ B2, "fro") ** 2 elif score_method == 'angular': - return np.trace(B1.T @ (R.T @ B2)) / (np.linalg.norm(B1, 'fro') * np.linalg.norm(R.T @ B2, 'fro')) + R, _ = orthogonal_procrustes(B2.T, B1.T) + return ControllabilitySimilarityTransformDist.compute_angular_dist(B1, R.T @ B2) else: raise ValueError('Choose between Euclidean or angular distance') From 1ddac90134e841522f35acb6ad5f1722fc79008d Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 11:47:17 -0400 Subject: [PATCH 09/51] fix comparing A on input-dsa: should use SimDist, not Controllabilitysimdist, and switch intelligently under the hood (so that users just specify parameters) --- DSA/dsa.py | 23 +++++++++++++++++++---- DSA/simdist_controllability.py | 4 ++-- 2 files changed, 21 insertions(+), 6 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index 660a76f..bbea048 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -478,7 +478,7 @@ def __init__( device='cpu', dsa_verbose=False, n_jobs=1, - # Advanced simdist parameters + #simdist parameters score_method: Literal["angular", "euclidean"] = "angular", iters: int = 1500, lr: float = 5e-3, @@ -486,7 +486,6 @@ def __init__( **dmd_kwargs ): #TODO: add readme - # Build simdist_config internally simdist_config = { 'score_method': score_method, 'iters': iters, @@ -518,23 +517,39 @@ def __init__( Y=None, Y_control=None, dmd_class=SubspaceDMDc, - similarity_class=ControllabilitySimilarityTransformDist, dmd_config: Union[Mapping[str, Any], dataclass]= SubspaceDMDcConfig, simdist_config: Union[Mapping[str, Any], dataclass] = ControllabilitySimilarityTransformDistConfig, device='cpu', dsa_verbose=False, n_jobs=1, ): + #check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, + #otherwise use ControllabilitySimilarityTransformDistConfig + if isinstance(simdist_config, dataclass): + compare = simdist_config.compare + elif isinstance(simdist_config,dict): + compare = simdist_config.get("compare",None) + else: + raise ValueError("unknown data type for simdist-config, use dataclass or dict") + if compare == 'state': + simdist = SimilarityTransformDist + else: + simdist = ControllabilitySimilarityTransformDist + super().__init__( X, Y, X_control, Y_control, dmd_class, - similarity_class, + simdist, dmd_config, simdist_config, device, dsa_verbose, n_jobs, ) + + assert X_control is not None + assert self.dmd_has_control + diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 951391b..3137d33 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -58,7 +58,6 @@ def fit_score(self, A, B, A_control, B_control): C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim ) - score_method = self.score_method @@ -83,7 +82,8 @@ def fit_score(self, A, B, A_control, B_control): raise ValueError('Choose between Euclidean or angular distance') elif self.compare == 'state': - return self.compare_A(A, B, score_method=score_method) + # return self.compare_A(A, B, score_method=score_method) + raise ValueError('To compute state similarity alone, use the SimilarityTransformDist class') else: return self.compare_B(A_control, B_control, score_method=score_method) From 5ee74891d3aa5694b0ed195062618be5f6bfd387 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 12:01:09 -0400 Subject: [PATCH 10/51] update readme --- README.md | 105 ++++++++++++++++-- ...tutorial.ipynb => dsa_fig3_tutorial.ipynb} | 8 +- 2 files changed, 99 insertions(+), 14 deletions(-) rename examples/{fig3_tutorial.ipynb => dsa_fig3_tutorial.ipynb} (99%) diff --git a/README.md b/README.md index 58538b5..4431f35 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,32 @@ -# DSA -Dynamical Similarity Analysis code accompanying the paper "Beyond Geometry: Comparing the Temporal Structure of Computation in Neural Circuits via Dynamical Similarity Analysis" +# generalized DSA +Computational techniques for Dynamical Similarity Analysis. First introduced in, + +1. "Beyond Geometry: Comparing the Temporal Structure of Computation in Neural Circuits via Dynamical Similarity Analysis" https://arxiv.org/abs/2306.10168 +Abstract: How can we tell whether two neural networks are utilizing the same internal processes for a particular computation? This question is pertinent for multiple subfields of both neuroscience and machine learning, including neuroAI, mechanistic interpretability, and brain-machine interfaces. Standard approaches for comparing neural networks focus on the spatial geometry of latent states. Yet in recurrent networks, computations are implemented at the level of neural dynamics, which do not have a simple one-to-one mapping with geometry. To bridge this gap, we introduce a novel similarity metric that compares two systems at the level of their dynamics. Our method incorporates two components: Using recent advances in data-driven dynamical systems theory, we learn a high-dimensional linear system that accurately captures core features of the original nonlinear dynamics. Next, we compare these linear approximations via a novel extension of Procrustes Analysis that accounts for how vector fields change under orthogonal transformation. Via four case studies, we demonstrate that our method effectively identifies and distinguishes dynamic structure in recurrent neural networks (RNNs), whereas geometric methods fall short. We additionally show that our method can distinguish learning rules in an unsupervised manner. Our method therefore opens the door to novel data-driven analyses of the temporal structure of neural computation, and to more rigorous testing of RNNs as models of the brain. -Code Authors: Mitchell Ostrow, Adam Eisen, Leo Kozachkov +and now including code from the following: + +2. "InputDSA: Demixing then comparing recurrent and externally driven dynamics +Abstract: +In control problems and basic scientific modeling, it is important to compare observations with dynamical simulations. For example, comparing two neural systems can shed light on the nature of emergent computations in the brain and deep neural networks. Recently, (Ostrow et al., 2023) introduced Dynamical Similarity Analysis (DSA), a method to measure the similarity of two systems based on their state dynamics rather than geometry or topology. However, DSA does not consider how inputs affect the dynamics, meaning that two similar systems, if driven differently, may be classified as different. Because real-world dynamical systems are rarely autonomous, it is important to account for the effects of input drive. To this end, we introduce a novel metric for comparing both intrinsic (recurrent) and input-driven dynamics, called InputDSA (iDSA). InputDSA extends the DSA framework by estimating and comparing both input and intrinsic dynamic operators using a novel variant of Dynamic Mode Decomposition with control (DMDc) based on subspace identification. We demonstrate that InputDSA can successfully compare partially observed, input-driven systems from noisy data. We show that when the true inputs are unknown, surrogate inputs can be substituted without a major deterioration in similarity estimates. We apply InputDSA on Recurrent Neural Networks (RNNs) trained with Deep Reinforcement Learning, identifying that high-performing networks are dynamically similar to one another, while low-performing networks are more diverse. Lastly, we apply InputDSA to neural data recorded from rats performing a cognitive task, demonstrating that it identifies a transition from input-driven evidence accumulation to intrinsically- driven decision-making. Our work demonstrates that InputDSA is a robust and efficient method for comparing intrinsic dynamics and the effect of external input +on dynamical systems + +Code Authors: Mitchell Ostrow, Adam Eisen, Leo Kozachkov, Ann Huang If you use this code, please cite: ``` +@misc{huangostrow2025input, + title={InputDSA: Demixing then comparing recurrent and externally driven dynamics}, + author={Ann Huang and Mitchell Ostrow and Satpreet Singh and Leo Kozachkov and Ila Fiete and Kanka Rajan}, + year={2025}, + archivePrefix={arXiv}, + primaryClass={q-bio.NC} +} + @misc{ostrow2023geometry, title={Beyond Geometry: Comparing the Temporal Structure of Computation in Neural Circuits with Dynamical Similarity Analysis}, author={Mitchell Ostrow and Adam Eisen and Leo Kozachkov and Ila Fiete}, @@ -17,6 +35,7 @@ If you use this code, please cite: archivePrefix={arXiv}, primaryClass={q-bio.NC} } + ``` ## Install the repo using `pip`: @@ -32,12 +51,16 @@ pip install -e . ## Brief Tutorial -The central object in the package is `DSA`, which links together the `DMD` and `SimilarityTransformDist` (called Procrustes Analysis over Vector Fields in the paper) objects. We designed an API that should be easy to use them in conjunction (`DSA`) with a variety of datatypes for a range of analysis cases: +The central object in the package is `GeneralizedDSA`, which links together the different types of `DMD` and `SimilarityTransformDist` (called Procrustes Analysis over Vector Fields in the first paper) objects. We designed an API that should be easy to use them in conjunction (`DSA`) with a variety of datatypes for a range of analysis cases: * Standard: Comparing two data matrices X, Y (can be passed in as numpy arrays or torch Tensors) * Pairwise: Pass in a list of data matrices X, which can be compared all-to-all * Disjoint Pairwise: Pass in two lists of data matrices, X, Y, which are compared all-to-all in a bipartite fashion * One-to-All: Pass in a list of data matrices X and a single matrix Y. All of X are compared to Y. +To run the DSA algorithm as it is specified in Ostrow et al. (2023), the class `DSA` in the file `dsa.py` is recommended. This is a restriction / special case of Generalized DSA. To run the InputDSA algorithm as it is specified in Huang and Ostrow et al. (2025), the class `InputDSA` is recommended. + +The `GeneralizedDSA` class generalizes (hence the name) the `DSA` algorithm from Ostrow et al. (2023) to account for the fact that other types of embeddings and DMD models can improve on HAVOK/Hankel DMD (which applies standard ridge least-squares regression on whitened time-delay embeddings). To that end, we have integrated capabilities with PyKoopman (https://github.com/dynamicslab/pykoopman) and PyDMD (https://github.com/PyDMD/PyDMD) to allow for other DMD models. For a brief tutorial, see below. Likewise, other similarity metrics (e.g. Huang and Ostrow et al., 2025) are desirable as well, given the setting. For kernel-like embeddings, functions in the file `preprocessing.py` can be applied. + # DSA has CUDA capability via pytorch, which is highly recommended for large datasets. * Simply pass in `device='cuda'` to the `DSA`,`DMD`,`SimilarityTransformDist` objects to compute on GPU, if you have one. @@ -47,19 +70,81 @@ Depending on the structure of the data, you can also pass in hyperparameters tha * If your parameters are a list of two lists `([a,b],[c,d])`, they will be mapped onto to all data matrices in X and Y with corresponding indices. Will throw an error if there aren't enough hyperparamters to match the data. * If your parameters are a combination of the previous two (e.g. `(a,[b,c])`), the broadcasting behaviors will be combined accordingly. -Our code also uses an API similar to `scikit-learn` in that all the relevant computation is enclosed in the `.fit()`, `.score()`, and `.fit_score()` style functions: + +Our code also uses an API similar to `scikit-learn` in that all the relevant computation is enclosed in the `.fit()`, `.score()`, and `.fit_score()` style functions. The original DSA case can be applied as follows: ``` -dsa = DSA(models,n_delays=n_delays,rank=rank,delay_interval=delay_interval,verbose=True,device=device) +from DSA import DSA +dsa = DSA(models,n_delays=n_delays,rank=rank,delay_interval=delay_interval,verbose=True,device=device,score_method='angular') similarities = dsa.fit_score() ``` +If you wish to use pykoopman/pydmd DMD models, they can applied as follows, using the pk.Koopman wrapper class. We'll use the pydmd SubspaceDMD as an example: +``` +from DSA import DSA +from pydmd import SubspaceDMD #the DMD class you want to use +import DSA.pykoopman as pk +obs = pk.observables.TimeDelay(n_delays=3) #define some nonlinear observables, if you wish -Simple as that! The data matrices can be of shape `(trials,time,channels)` or `(time,channels)`. If you have multiple conditions you wish to test (for example, different control inputs to your system, you can fit them separately or simultaneously. In our tutorial notebook, `fig3_tutorial.ipynb`, we fit two conditions simultaneously and the model works--here, our data matrices are of shape `(condition,trials,time,channels)` which we collapse to `(condition*trials,time,channels)`. +dsa = DSA(compare_dat,dmd_class=pk.Koopman,score_method='wasserstein',wasserstein_compare='eig',observables=obs,regressor=SubspaceDMD(svd_rank=3)) +``` + +Due to the generalization of the method on different DMDs and different similarity metrics, each which have different arguments, we have changed the structure of the DSA class to take in arguments for each of these objects as dictionaries or dataclass config objects. Here are a few examples: +``` +from dataclass import dataclass +@dataclass() +class DefaultDMDConfig: + n_delays: int = 1 + delay_interval: int = 1 + rank: int = None + lamb: float = 0 + send_to_cpu: bool = False +@dataclass() +class pyKoopmanDMDConfig: + observables = pykoopman.observables.TimeDelay(n_delays=1) + regressor = pydmd.DMD(svd_rank=2) + +@dataclass() +class SubspaceDMDcConfig: + n_delays: int = 1 + delay_interval: int = 1 + rank: int = None + lamb: float = 0 + backend: str = 'n4sid' + +#__Example config dataclasses for similarity transform distance # +@dataclass +class SimilarityTransformDistConfig: + iters: int = 1500 + score_method: Literal["angular", "euclidean"] = "angular" + lr: float = 5e-3 + zero_pad: bool = False + wasserstein_compare: Literal["sv", "eig", None] = "eig" + +@dataclass() +class ControllabilitySimilarityTransformDistConfig: + score_method: Literal["euclidean", "angular"] = "euclidean" + compare = 'state' + joint_optim: bool = False + return_distance_components: bool = False -Note that `DSA` performs multiple fits to the data: one `DMD` matrix per data matrix, and then one `SimilarityTransformDist` similarity per pair of data matrices. When you call `score` after `fit_score`, it will only recompute the `SimilarityTransformDist`s. If you wish to recompute the DMDs, call `.fit_dmds()`. The Procrustes Analysis over Vector Fields metric does not have a closed form solution so it may be worth playing around with its optimization parameters. +``` +Then, these are passed directly into the GeneralizedDSA (DSA, InputDSA) classes via the arguments dmd_config, simdist_config for the arguments of each class: +``` +from DSA import GeneralizedDSA, DMD, SimilarityTransformDist +gdsa = GeneralizedDSA(datasets,dmd_class=DMD,similarity_class=SimilarityTransformDist, + dmd_config=DefaultDMDConfig,simdist_config=SimilarityTransformDistConfig) +sim = gdsa.fit_score() +``` + +The logic for InputDSA is equivalent, with a few key things to note. In this setting, there are two types of DMDc models to use-- DMDc (Proctor et al., 2016), and SubspaceDMDc (Huang and Ostrow et al., 2025). If your system is partially observed, we recommend SubspaceDMDc instead. Likewise, there are a few different types of similarity that can be computed. You may wish to apply DMDc-like models but then only compare the A matrix-- in this case, you can set the argument `compare='state'` in the simdist_config object. Otherwise, you have the options `joint,control` which will jointly compare A and B via controllability, or just the control matrix via Procrustes. InputDSA has one other special argument: `return_distance_components`. If this is true, it will return 3 different metrics, encoded in a single numpy array (data x data x 3). They have the ordering: Full Controllability distance, Jointly optimized State Similarity Score, Jointly Optimized Control Score. + + +Simple as that! The data matrices can be of shape `(trials,time,channels)` or `(time,channels)`. If you have multiple conditions you wish to test (for example, if you have different task settings in your system, you can fit them separately or simultaneously). In our tutorial notebook, `dsa_fig3_tutorial.ipynb`, we fit two conditions simultaneously and the model works--here, our data matrices are of shape `(condition,trials,time,channels)` which we collapse to `(condition*trials,time,channels)`. (As of 2025, DSA objects can also take lists of arrays (shape 2D or 3D) to account for different lengths of time in different time series). + +Note that `DSA` performs multiple fits to the data: one `DMD` matrix per data matrix, and then one `SimilarityTransformDist` similarity per pair of data matrices. When you call `score` after `fit_score`, it will only recompute the `SimilarityTransformDist`s. If you wish to recompute the DMDs, call `.fit_dmds()`. The Procrustes Analysis over Vector Fields metric does not have a closed form solution so it may be worth playing around with its optimization parameters, or use the Wasserstein distance. If you only care about identifying topological conjugacy between your systems, you can set `compare_method='wasserstein'`, and `wasserstein_compare='eig'` to compare the eigenvalues of the DMDs of each system with the wasserstein distance (as used in Redman et al., 2024 and upcoming work). Optimizing the PAVF metric over O(n) compares transients as well as eigenvalues. -In the case of a large number of comparisons, it will be more memory effective to use the `DMD` class to fit the models and then the `SimilarityTransformDist` class to compare them, rather than use `DSA`, as `DSA` requires taking in all of the data matrices at once. Using the pieces separately will allow you to stream data, or generate it on-the-fly. This process is simple too (see `examples/fig3_tutorial.ipynb`): +In the case of a large number of comparisons, it will be more memory effective to use the `DMD` class to fit the models and then the `SimilarityTransformDist` class to compare them, rather than use `DSA`, as `DSA` requires taking in all of the data matrices at once. Using the pieces separately will allow you to stream data, or generate it on-the-fly. This process is simple too (see `examples/dsa_fig3_tutorial.ipynb`): * Fit the DMD: with your data: ``` @@ -72,4 +157,4 @@ Ai = dmd.A_v #extract DMD matrix comparison = SimilarityTransformDist(device='cuda',iters=2000,lr=1e-3) score = comparison_dmd.fit_score(Ai,Aj) #fit to two DMD matrices ``` - +This pipeline can also be generalized using different DMDs and comparison methods. diff --git a/examples/fig3_tutorial.ipynb b/examples/dsa_fig3_tutorial.ipynb similarity index 99% rename from examples/fig3_tutorial.ipynb rename to examples/dsa_fig3_tutorial.ipynb index 6071546..dab6216 100644 --- a/examples/fig3_tutorial.ipynb +++ b/examples/dsa_fig3_tutorial.ipynb @@ -199,7 +199,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -506,7 +506,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -541,7 +541,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -833,7 +833,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] From a53098c55ea198f9aed3ccaa3bd2f65099a9aa8e Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 12:17:54 -0400 Subject: [PATCH 11/51] update simdist to not do wasserstein over anything but eigenvalues --- DSA/simdist.py | 100 ++++++++++++++++++++++++------------------------- 1 file changed, 48 insertions(+), 52 deletions(-) diff --git a/DSA/simdist.py b/DSA/simdist.py index 99e5d6c..3eea468 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -135,7 +135,6 @@ def __init__( lr=0.01, device: Literal["cpu", "cuda"] = "cpu", verbose=False, - wasserstein_compare: Literal["sv", "eig"] = "eig", eps=1e-5, rescale_wasserstein=False, ): @@ -158,10 +157,6 @@ def __init__( verbose : bool prints when finished optimizing - wasserstein_compare : {'sv','eig',None} - specifies whether to compare the singular values or eigenvalues - if score_method is "wasserstein", or the shapes are different - eps : float early stopping threshold """ @@ -174,7 +169,6 @@ def __init__( self.C_star = None self.A = None self.B = None - self.wasserstein_compare = wasserstein_compare self.eps = eps self.rescale_wasserstein = rescale_wasserstein @@ -185,7 +179,6 @@ def fit( iters=None, lr=None, score_method=None, - wasserstein_compare=None, wasserstein_weightings = None, ): @@ -266,31 +259,34 @@ def fit( self.sim_net = sim_net def _get_wasserstein_vars(self,A, B): - assert self.wasserstein_compare in {"sv", "eig","evec_angle", 'evec'} - if self.wasserstein_compare == "sv": - a = torch.svd(A).S.view(-1, 1) - b = torch.svd(B).S.view(-1, 1) - elif self.wasserstein_compare == "eig": - a = torch.linalg.eig(A).eigenvalues - a = torch.vstack([a.real, a.imag]).T - - b = torch.linalg.eig(B).eigenvalues - b = torch.vstack([b.real, b.imag]).T - elif self.wasserstein_compare in {'evec_angle', 'evec'}: - #this will compute the interior angles between eigenvectors - aevec = torch.linalg.eig(A).eigenvectors - bevec = torch.linalg.eig(B).eigenvectors + # assert self.wasserstein_compare in {"sv", "eig","evec_angle", 'evec'} + assert self.wasserstein_compare in {"eig"} + + #deprecated: only do wasserstein comparison on eigenvalues (for now, until others are theoretically validated) + # if self.wasserstein_compare == "sv": + # a = torch.svd(A).S.view(-1, 1) + # b = torch.svd(B).S.view(-1, 1) + # if self.wasserstein_compare == "eig": + a = torch.linalg.eig(A).eigenvalues + a = torch.vstack([a.real, a.imag]).T + + b = torch.linalg.eig(B).eigenvalues + b = torch.vstack([b.real, b.imag]).T + # elif self.wasserstein_compare in {'evec_angle', 'evec'}: + # #this will compute the interior angles between eigenvectors + # aevec = torch.linalg.eig(A).eigenvectors + # bevec = torch.linalg.eig(B).eigenvectors - a = compute_angle(aevec) - b = compute_angle(bevec) - else: - raise AssertionError("wasserstein_compare must be 'sv', 'eig', 'evec_angle', or 'evec'") + # a = compute_angle(aevec) + # b = compute_angle(bevec) + # else: + # raise AssertionError("wasserstein_compare must be 'sv', 'eig', 'evec_angle', or 'evec'") #if the number of elements in the sets are different, then we need to pad the smaller set with zeros if a.shape[0] != b.shape[0]: - if self.wasserstein_compare in {'evec_angle', 'evec'}: - raise AssertionError("Wasserstein comparison of eigenvectors is not supported when \ - the number of elements in the sets are different") + # if self.wasserstein_compare in {'evec_angle', 'evec'}: + # raise AssertionError("Wasserstein comparison of eigenvectors is not supported when \ + # the number of elements in the sets are different") if self.verbose: print(f"Padding the smaller set with zeros") if a.shape[0] < b.shape[0]: @@ -341,7 +337,7 @@ def optimize_C(self, A, B, lr, iters, orthog, verbose): C_star = sim_net.C.detach() return losses, C_star, sim_net - def score(self, A=None, B=None, score_method=None, wasserstein_compare=None): + def score(self, A=None, B=None, score_method=None): """ Given an optimal C already computed, calculate the metric @@ -367,7 +363,6 @@ def score(self, A=None, B=None, score_method=None, wasserstein_compare=None): assert A.shape == self.C_star.shape or score_method == 'wasserstein' assert B.shape == self.C_star.shape or score_method == 'wasserstein' score_method = self.score_method if score_method is None else score_method - wasserstein_compare = self.wasserstein_compare if wasserstein_compare is None else wasserstein_compare with torch.no_grad(): if not isinstance(A, torch.Tensor): A = torch.from_numpy(A).float().to(self.device) @@ -391,27 +386,28 @@ def score(self, A=None, B=None, score_method=None, wasserstein_compare=None): elif score_method == 'wasserstein': #use the current C_star to compute the score assert hasattr(self, 'score_star') - if wasserstein_compare == self.wasserstein_compare: - score = self.score_star.item() - else: - #apply the current transport plan to the new data - a,b = self._get_wasserstein_vars(A, B) - # a_transported = self.C_star @ A #shouldn't this be a? + # if wasserstein_compare == self.wasserstein_compare: + score = self.score_star.item() + #non-eig wasserstein comparisons are deprecated until theoretically validated + # else: + # #apply the current transport plan to the new data + # a,b = self._get_wasserstein_vars(A, B) + # # a_transported = self.C_star @ A #shouldn't this be a? - M = ot.dist(a, b, metric='sqeuclidean') - score = torch.sum(self.C_star * M).item() - #TODO: validate this - # a_transported = self.C_star @ a - # row_wise_sq_distances = torch.sum(torch.square(a_transported - b), axis=1) - # transported_score = torch.sum(a * row_wise_sq_distances) - # score = transported_score.item() - if self.rescale_wasserstein: - score = score * A.shape[0] #add scaling factor due to random matrix theory + # M = ot.dist(a, b, metric='sqeuclidean') + # score = torch.sum(self.C_star * M).item() + # #TODO: validate this + # # a_transported = self.C_star @ a + # # row_wise_sq_distances = torch.sum(torch.square(a_transported - b), axis=1) + # # transported_score = torch.sum(a * row_wise_sq_distances) + # # score = transported_score.item() + # if self.rescale_wasserstein: + # score = score * A.shape[0] #add scaling factor due to random matrix theory return score def fit_score( - self, A, B, iters=None, lr=None, score_method=None, zero_pad=True, wasserstein_weightings=None + self, A, B, iters=None, lr=None, score_method=None, wasserstein_weightings=None ): """ for efficiency, computes the optimal matrix and returns the score @@ -426,7 +422,7 @@ def fit_score( number of optimization steps, if None then resorts to saved self.iters lr : float or None learning rate, if None then resorts to saved self.lr - score_method : {'angular','euclidean'} or None + score_method : {'angular','euclidean', 'wasserstein} or None overwrites parameter in the class zero_pad : bool if True, then the smaller matrix will be zero padded so its the same size @@ -446,11 +442,11 @@ def fit_score( assert A.shape[0] == B.shape[1] or self.wasserstein_compare is not None if A.shape[0] != B.shape[0]: - if self.wasserstein_compare is None: - raise AssertionError( - "Matrices must be the same size unless using wasserstein distance" - ) - elif score_method != 'wasserstein': # otherwise resort to L2 Wasserstein over singular or eigenvalues + # if self.wasserstein_compare is None: + # raise AssertionError( + # "Matrices must be the same size unless using wasserstein distance" + # ) + if score_method != 'wasserstein': # otherwise resort to L2 Wasserstein over singular or eigenvalues print( f"resorting to wasserstein distance over {self.wasserstein_compare}" ) From 25c385d3d8b50e103eae5eb4f4efa418aa1d5cdc Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 12:18:05 -0400 Subject: [PATCH 12/51] add docstrings for dsa --- DSA/dsa.py | 129 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 126 insertions(+), 3 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index bbea048..c21d583 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -32,18 +32,65 @@ #___Example config dataclasses for DMD # @dataclass() class DefaultDMDConfig: + """ + Configuration dataclass for DefaultDMD (standard DMD without control). + + This configuration is used to set parameters for the DefaultDMD class when + performing Dynamical Mode Decomposition on time series data. + + Attributes: + n_delays (int): Number of time delays to use in the Hankel matrix construction. + Default is 1 (no delays). + delay_interval (int): Interval between delays in the Hankel matrix. + Default is 1 (consecutive time steps). + rank (int): Rank for SVD truncation. If None, no truncation is performed. + Default is None. + lamb (float): Regularization parameter for ridge regression. + Default is 0 (no regularization). + send_to_cpu (bool): Whether to move computations to CPU. + Default is False (use GPU if available). + """ n_delays: int = 1 delay_interval: int = 1 rank: int = None lamb: float = 0 send_to_cpu: bool = False + @dataclass() class pyKoopmanDMDConfig: + """ + Configuration dataclass for pyKoopman DMD models. + + This configuration is used to set up pyKoopman observables and regressors + for performing DMD analysis with the pyKoopman library. + + Attributes: + observables: Observable function from pykoopman. Default is TimeDelay with n_delays=1. + regressor: Regressor model from pydmd. Default is DMD with svd_rank=2. + """ observables = pykoopman.observables.TimeDelay(n_delays=1) regressor = pydmd.DMD(svd_rank=2) @dataclass() class SubspaceDMDcConfig: + """ + Configuration dataclass for SubspaceDMDc (DMD with control using subspace identification). + + This configuration is used to set parameters for the SubspaceDMDc class when + performing Dynamical Mode Decomposition on controlled systems. + + Attributes: + n_delays (int): Number of time delays to use in the Hankel matrix construction. + Default is 1 (no delays). + delay_interval (int): Interval between delays in the Hankel matrix. + Default is 1 (consecutive time steps). + rank (int): Rank for SVD truncation. If None, no truncation is performed. + Default is None. + lamb (float): Regularization parameter for ridge regression. + Default is 0 (no regularization). + backend (str): Subspace identification backend to use. + Options: 'n4sid', 'custom'. + """ n_delays: int = 1 delay_interval: int = 1 rank: int = None @@ -53,14 +100,48 @@ class SubspaceDMDcConfig: #__Example config dataclasses for similarity transform distance # @dataclass class SimilarityTransformDistConfig: + """ + Configuration dataclass for SimilarityTransformDist (standard similarity transform distance). + + This configuration is used to compute the similarity transform distance between + two DMD matrices, which measures how similar two dynamical systems are. + + Attributes: + iters (int): Number of optimization iterations for finding the similarity transform. + Default is 1500. + score_method (Literal["angular", "euclidean","wasserstein"]): Method for computing the distance score. + 'angular' uses angular distance, 'euclidean' uses Euclidean distance. + Default is "angular". + lr (float): Learning rate for the optimization algorithm. + Default is 5e-3. + zero_pad (bool): Whether to zero-pad matrices to make them the same size. + Default is False. + """ iters: int = 1500 - score_method: Literal["angular", "euclidean"] = "angular" + score_method: Literal["angular", "euclidean","wasserstein"] = "angular" lr: float = 5e-3 zero_pad: bool = False - wasserstein_compare: Literal["sv", "eig", None] = "eig" @dataclass() class ControllabilitySimilarityTransformDistConfig: + """ + Configuration dataclass for ControllabilitySimilarityTransformDist (similarity transform distance with control). + + This configuration is used to compute the similarity transform distance between + two controlled DMD systems, comparing both state and control operators. + + Attributes: + score_method (Literal["euclidean", "angular"]): Method for computing the distance score. + 'angular' uses angular distance, 'euclidean' uses Euclidean distance. + Default is "euclidean". + compare (str): What to compare between systems. + 'state' compares only state operators, 'control' compares only control operators, + 'joint' compares both. Default is 'state'. + joint_optim (bool): Whether to optimize state and control operators jointly. + Default is False. + return_distance_components (bool): Whether to return individual distance components + (state, control, joint) separately. Default is False. + """ score_method: Literal["euclidean", "angular"] = "euclidean" compare = 'state' joint_optim: bool = False @@ -68,7 +149,28 @@ class ControllabilitySimilarityTransformDistConfig: class GeneralizedDSA: """ - Computes the Generalized Dynamical Similarity Analysis (DSA) for two data tensors + Computes the Generalized Dynamical Similarity Analysis (DSA) for two data tensors. + + This class performs Dynamical Mode Decomposition (DMD) on input data and then computes + similarity scores between the resulting DMD models using similarity transform distances. + It supports various comparison modes including pairwise comparisons, bipartite comparisons, + and comparisons with control inputs. + + The class handles: + - Multiple data formats (single arrays, lists of arrays) + - Different DMD implementations (local DMD, pyKoopman, etc.) + - Control inputs for controlled systems + - Parallel processing for efficiency + - Various similarity metrics + + Example usage: + # Compare two datasets + dsa = GeneralizedDSA(X=data1, Y=data2, dmd_class=DefaultDMD) + similarity_score = dsa.fit_score() + + # Pairwise comparison of multiple datasets + dsa = GeneralizedDSA(X=[data1, data2, data3], Y=None) + similarity_matrix = dsa.fit_score() """ def __init__( @@ -109,6 +211,27 @@ def __init__( Must be the same shape as Y. If None, then no control data is used. + dmd_class : class + DMD class to use for decomposition. Default is DefaultDMD. + + similarity_class : class + Similarity transform distance class to use. Default is SimilarityTransformDist. + + dmd_config : Union[Mapping[str, Any], dataclass] + Configuration for DMD parameters. Can be a dict or dataclass. + + simdist_config : Union[Mapping[str, Any], dataclass] + Configuration for similarity transform distance parameters. Can be a dict or dataclass. + + device : str + Device to use for computation ('cpu' or 'cuda'). Default is 'cpu'. + + dsa_verbose : bool + Whether to print verbose output during computation. Default is False. + + n_jobs : int + Number of parallel jobs to use. Default is 1 (sequential). + Set to -1 to use all available cores. NOTE: for all of these above, they can be single values or lists or tuples, depending on the corresponding dimensions of the data From 8d46192cd78065e9669faaaa1496da993e2e4971 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 12:20:17 -0400 Subject: [PATCH 13/51] add docstring for simdist_controllability --- DSA/simdist_controllability.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 3137d33..f962243 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -18,7 +18,7 @@ def __init__( score_method: Literal["euclidean", "angular"] = "euclidean", compare: Literal['joint','control','state'] = 'joint', joint_optim: bool = False, - return_distance_components=True + return_distance_components: bool =True ): f""" Parameters @@ -29,6 +29,8 @@ def __init__( what type of comparison to do on the A and B matrices align_inputs : bool If True, do two-sided Procrustes on controllability matrices (solve for C and C_u). + return_distance_components: bool + If True, returns the jointly optimized controllability score, the jointly optimize state score, and the jointly optimized control score """ self.score_method = score_method self.compare = compare @@ -186,6 +188,9 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *,align_inputs=False): @staticmethod def compare_B(B1, B2, score_method='euclidean'): + ''' + compares the B matrices with left procrustes + ''' if score_method == 'euclidean': R, _ = orthogonal_procrustes(B2.T, B1.T) return np.linalg.norm(B1 - R.T @ B2, "fro") From 88d8e312e183c19fd8f02bd504a5abcc8163f208 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 12:24:39 -0400 Subject: [PATCH 14/51] black formatting --- DSA/__init__.py | 2 +- DSA/base_dmd.py | 62 ++-- DSA/dmd.py | 20 +- DSA/dmdc.py | 306 +++++++++++-------- DSA/dsa.py | 304 +++++++++++-------- DSA/preprocessing.py | 105 ++++--- DSA/resdmd.py | 34 ++- DSA/simdist.py | 127 ++++---- DSA/simdist_controllability.py | 102 ++++--- DSA/stats.py | 6 +- DSA/subspace_dmdc.py | 516 +++++++++++++++++++-------------- DSA/sweeps.py | 381 +++++++++++++++--------- setup.py | 20 +- tests/dmd_test.py | 156 +++++----- tests/dsa_test.py | 207 ++++++------- tests/simdist_test.py | 138 ++++----- 16 files changed, 1464 insertions(+), 1022 deletions(-) diff --git a/DSA/__init__.py b/DSA/__init__.py index 7968a98..b830265 100644 --- a/DSA/__init__.py +++ b/DSA/__init__.py @@ -7,4 +7,4 @@ from DSA.stats import * from DSA.sweeps import * from DSA.preprocessing import * -from DSA.resdmd import * \ No newline at end of file +from DSA.resdmd import * diff --git a/DSA/base_dmd.py b/DSA/base_dmd.py index f8e3d28..b3c4716 100644 --- a/DSA/base_dmd.py +++ b/DSA/base_dmd.py @@ -7,7 +7,7 @@ class BaseDMD(ABC): """Base class for DMD implementations with common functionality.""" - + def __init__( self, device="cpu", @@ -32,16 +32,16 @@ def __init__( self.verbose = verbose self.send_to_cpu = send_to_cpu self.lamb = lamb - + # Common attributes self.data = None self.n = None self.ntrials = None self.is_list_data = False - + # SVD attributes - will be set by subclasses self.cumulative_explained_variance = None - + def _process_single_dataset(self, data): """Process a single dataset, handling numpy arrays, tensors, and lists.""" if isinstance(data, list): @@ -51,7 +51,7 @@ def _process_single_dataset(self, data): torch.from_numpy(d) if isinstance(d, np.ndarray) else d for d in data ] - return torch.stack(processed_data), False + return torch.stack(processed_data), False except (RuntimeError, ValueError): # Handle ragged lists processed_data = [ @@ -64,24 +64,22 @@ def _process_single_dataset(self, data): raise ValueError( "All tensors in the list must have the same number of features (last dimension)." ) - return processed_data, True - + return processed_data, True + elif isinstance(data, np.ndarray): return torch.from_numpy(data), False - + return data, False def _init_single_data(self, data): """Initialize data attributes for a single dataset.""" processed_data, is_ragged = self._process_single_dataset(data) - + if is_ragged: # Set attributes for ragged data n_features = processed_data[0].shape[-1] self.n = n_features - self.ntrials = sum( - d.shape[0] if d.ndim == 3 else 1 for d in processed_data - ) + self.ntrials = sum(d.shape[0] if d.ndim == 3 else 1 for d in processed_data) self.trial_counts = [ d.shape[0] if d.ndim == 3 else 1 for d in processed_data ] @@ -95,7 +93,7 @@ def _init_single_data(self, data): self.n = processed_data.shape[1] self.ntrials = 1 self.is_list_data = False - + return processed_data def _compute_explained_variance(self, S): @@ -103,11 +101,18 @@ def _compute_explained_variance(self, S): exp_variance = S**2 / torch.sum(S**2) return torch.cumsum(exp_variance, 0) - def _compute_rank_from_params(self, S, cumulative_explained_variance, max_rank, - rank=None, rank_thresh=None, rank_explained_variance=None): + def _compute_rank_from_params( + self, + S, + cumulative_explained_variance, + max_rank, + rank=None, + rank_thresh=None, + rank_explained_variance=None, + ): """ Compute rank based on provided parameters. - + Parameters ---------- S : torch.Tensor @@ -122,15 +127,19 @@ def _compute_rank_from_params(self, S, cumulative_explained_variance, max_rank, Threshold for singular values rank_explained_variance : float, optional Explained variance threshold - + Returns ------- int Computed rank """ - parameters_provided = [rank is not None, rank_thresh is not None, rank_explained_variance is not None] + parameters_provided = [ + rank is not None, + rank_thresh is not None, + rank_explained_variance is not None, + ] num_parameters_provided = sum(parameters_provided) - + if num_parameters_provided > 1: raise ValueError( "More than one rank parameter was provided. Please provide only one of rank, rank_thresh, or rank_explained_variance." @@ -146,15 +155,22 @@ def _compute_rank_from_params(self, S, cumulative_explained_variance, max_rank, if computed_rank == 0: computed_rank = 1 # Ensure at least rank 1 elif rank_explained_variance is not None: - cumulative_explained_variance_cpu = cumulative_explained_variance.cpu().numpy() - computed_rank = int(np.searchsorted(cumulative_explained_variance_cpu, rank_explained_variance) + 1) + cumulative_explained_variance_cpu = ( + cumulative_explained_variance.cpu().numpy() + ) + computed_rank = int( + np.searchsorted( + cumulative_explained_variance_cpu, rank_explained_variance + ) + + 1 + ) if computed_rank > len(S): computed_rank = len(S) - + # Ensure rank doesn't exceed maximum possible if computed_rank > max_rank: computed_rank = max_rank - + return computed_rank def all_to_device(self, device="cpu"): diff --git a/DSA/dmd.py b/DSA/dmd.py index 10a6905..d2b7b4b 100644 --- a/DSA/dmd.py +++ b/DSA/dmd.py @@ -2,6 +2,7 @@ import numpy as np import torch + try: from .base_dmd import BaseDMD except ImportError: @@ -142,8 +143,10 @@ def __init__( The number of time steps ahead to predict. Defaults to 1. """ - super().__init__(device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb) - + super().__init__( + device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb + ) + self.data = self._init_single_data(data) self.n_delays = n_delays @@ -364,10 +367,10 @@ def recalc_rank(self, rank, rank_thresh, rank_explained_variance): else: S = self.S cumulative_explained = self.cumulative_explained_variance - + # Get maximum possible rank h_shape_last = self.H_shapes[-1][-1] if self.is_list_data else self.H.shape[-1] - + # Use base class method to compute rank self.rank = self._compute_rank_from_params( S=S, @@ -375,7 +378,7 @@ def recalc_rank(self, rank, rank_thresh, rank_explained_variance): max_rank=h_shape_last, rank=self.rank, rank_thresh=self.rank_thresh, - rank_explained_variance=self.rank_explained_variance + rank_explained_variance=self.rank_explained_variance, ) def compute_havok_dmd(self, lamb=None): @@ -393,7 +396,7 @@ def compute_havok_dmd(self, lamb=None): print("Computing least squares fits to HAVOK DMD ...") self.lamb = self.lamb if lamb is None else lamb - + A_v = ( torch.linalg.inv( self.Vt_minus[:, : self.rank].T @ self.Vt_minus[:, : self.rank] @@ -552,7 +555,7 @@ def fit( if self.send_to_cpu: self.all_to_device("cpu") # send back to the cpu to save memory - + # print('After DMD fitting in dmd.py', self.A_v.shape) def predict(self, test_data=None, reseed=None, full_return=False): @@ -622,7 +625,6 @@ def predict(self, test_data=None, reseed=None, full_return=False): else: return pred_data - def project_onto_modes(self): eigvals, eigvecs = torch.linalg.eigh(self.A_v) # project Vt_minus onto the eigenvectors @@ -632,4 +634,4 @@ def project_onto_modes(self): ) # get the data that matches the shape of the original data - return projections, self.data[:, : -self.n_delays + 1] \ No newline at end of file + return projections, self.data[:, : -self.n_delays + 1] diff --git a/DSA/dmdc.py b/DSA/dmdc.py index f4052de..94c8c5b 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -1,6 +1,8 @@ """This module computes the DMD with control (DMDc) model for a given dataset.""" + import numpy as np import torch + try: from .dmd import embed_signal_torch from .base_dmd import BaseDMD @@ -8,41 +10,45 @@ from dmd import embed_signal_torch from base_dmd import BaseDMD -def embed_data_DMDc(data, n_delays=1, n_control_delays=1, delay_interval=1, control=False): + +def embed_data_DMDc( + data, n_delays=1, n_control_delays=1, delay_interval=1, control=False +): if control: if n_control_delays == 1: if data.ndim == 2: - return data[(n_delays-1)*delay_interval:, :] + return data[(n_delays - 1) * delay_interval :, :] else: - return data[:, (n_delays-1)*delay_interval:, :] + return data[:, (n_delays - 1) * delay_interval :, :] else: embedded_data = embed_signal_torch(data, n_control_delays, delay_interval) return embedded_data else: return embed_signal_torch(data, n_delays, delay_interval) + class DMDc(BaseDMD): - """DMDc class for computing and predicting with DMD with control models. - """ + """DMDc class for computing and predicting with DMD with control models.""" + def __init__( - self, - data, - control_data=None, - n_delays=1, - n_control_delays=1, - delay_interval=1, - rank_input=None, - rank_thresh_input=None, - rank_explained_variance_input=None, - rank_output=None, - rank_thresh_output=None, - rank_explained_variance_output=None, - lamb=1e-8, - device='cpu', - verbose=False, - send_to_cpu=False, - svd_separate = True, - steps_ahead=1 + self, + data, + control_data=None, + n_delays=1, + n_control_delays=1, + delay_interval=1, + rank_input=None, + rank_thresh_input=None, + rank_explained_variance_input=None, + rank_output=None, + rank_thresh_output=None, + rank_explained_variance_output=None, + lamb=1e-8, + device="cpu", + verbose=False, + send_to_cpu=False, + svd_separate=True, + steps_ahead=1, ): """ Parameters @@ -68,7 +74,7 @@ def __init__( to 1 time step. rank : int - The rank of V in fitting DMDc - i.e., the number of columns of V to + The rank of V in fitting DMDc - i.e., the number of columns of V to use to fit the DMDc model. Defaults to None, in which case all columns of V will be used. @@ -80,7 +86,7 @@ def __init__( rank_explained_variance : float Parameter that controls the rank of V in fitting DMDc by indicating the percentage of cumulative explained variance that should be explained by the columns of V. Defaults to None. - + lamb : float Regularization parameter for ridge regression. Defaults to 0. @@ -93,28 +99,32 @@ def __init__( send_to_cpu: bool If True, will send all tensors in the object back to the cpu after everything is computed. This is implemented to prevent gpu memory overload when computing multiple DMDs. - + steps_ahead: int The number of time steps ahead to predict. Defaults to 1. """ - super().__init__(device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb) - + super().__init__( + device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb + ) + self._init_data(data, control_data) self.n_delays = n_delays self.n_control_delays = n_control_delays self.delay_interval = delay_interval - + self.rank_input = rank_input self.rank_thresh_input = rank_thresh_input self.rank_explained_variance_input = rank_explained_variance_input self.rank_output = rank_output self.rank_thresh_output = rank_thresh_output self.rank_explained_variance_output = rank_explained_variance_output - self.svd_separate = svd_separate #do svd on H and u separately as well as regression + self.svd_separate = ( + svd_separate # do svd on H and u separately as well as regression + ) self.steps_ahead = steps_ahead - + # Hankel matrix self.H = None @@ -127,12 +137,12 @@ def __init__( self.V = None self.S_mat = None self.S_mat_inv = None - + # Change of basis between the reduced-order subspace and the full space self.U_out = None self.S_out = None self.V_out = None - + # DMDc attributes self.A_tilde = None self.B_tilde = None @@ -140,47 +150,52 @@ def __init__( self.B = None self.A_havok_dmd = None self.B_havok_dmd = None - + # Check if the state and control data are list (for different trial lengths) if not np.all([isinstance(data, list), isinstance(control_data, list)]): if isinstance(data, list) or isinstance(control_data, list): - raise TypeError("If you pass one of (data, control_data) as list, the other must also be a list.") + raise TypeError( + "If you pass one of (data, control_data) as list, the other must also be a list." + ) def _init_data(self, data, control_data=None): # Process main data self.data, data_is_ragged = self._process_single_dataset(data) - + # Process control data if control_data is not None: - self.control_data, control_is_ragged = self._process_single_dataset(control_data) + self.control_data, control_is_ragged = self._process_single_dataset( + control_data + ) else: self.control_data = torch.zeros_like(self.data) control_is_ragged = False - + # Check consistency between data and control_data if data_is_ragged != control_is_ragged: - raise ValueError("Data and control data have different structure (type or dimensionality).") - + raise ValueError( + "Data and control data have different structure (type or dimensionality)." + ) + if data_is_ragged: # Additional validation for ragged data if not all(d.shape[-1] == control_data[0].shape[-1] for d in control_data): raise ValueError( "All control tensors in the list must have the same number of features (last dimension)." ) - if not all(d.shape[0] == control_d.shape[0] for d, control_d in zip(data, control_data)): + if not all( + d.shape[0] == control_d.shape[0] + for d, control_d in zip(data, control_data) + ): raise ValueError( "Data and control_data tensors must have the same number of time steps." ) - + # Set attributes for ragged data n_features = self.data[0].shape[-1] self.n = n_features - self.ntrials = sum( - d.shape[0] if d.ndim == 3 else 1 for d in self.data - ) - self.trial_counts = [ - d.shape[0] if d.ndim == 3 else 1 for d in self.data - ] + self.ntrials = sum(d.shape[0] if d.ndim == 3 else 1 for d in self.data) + self.trial_counts = [d.shape[0] if d.ndim == 3 else 1 for d in self.data] self.is_list_data = True else: # Set attributes for non-ragged data @@ -193,12 +208,12 @@ def _init_data(self, data, control_data=None): self.is_list_data = False def compute_hankel( - self, - data=None, - control_data=None, - n_delays=None, - delay_interval=None, - ): + self, + data=None, + control_data=None, + n_delays=None, + delay_interval=None, + ): """ Computes the Hankel matrix from the provided data and forms Omega. """ @@ -208,26 +223,55 @@ def compute_hankel( # Overwrite parameters if provided self.data = self.data if data is None else self._init_data(data, control_data) self.n_delays = self.n_delays if n_delays is None else n_delays - self.delay_interval = self.delay_interval if delay_interval is None else delay_interval - + self.delay_interval = ( + self.delay_interval if delay_interval is None else delay_interval + ) + if self.is_list_data: self.data = [d.to(self.device) for d in self.data] self.control_data = [d.to(self.device) for d in self.control_data] # Compute Hankel matrices for each trial separately - self.H = [embed_data_DMDc(d, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval).float() for d in self.data] - self.Hu = [embed_data_DMDc(d, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval, control=True).float() for d in self.control_data] + self.H = [ + embed_data_DMDc( + d, + n_delays=self.n_delays, + n_control_delays=self.n_control_delays, + delay_interval=self.delay_interval, + ).float() + for d in self.data + ] + self.Hu = [ + embed_data_DMDc( + d, + n_delays=self.n_delays, + n_control_delays=self.n_control_delays, + delay_interval=self.delay_interval, + control=True, + ).float() + for d in self.control_data + ] self.H_shapes = [h.shape for h in self.H] else: self.data = self.data.to(self.device) self.control_data = self.control_data.to(self.device) # Compute Hankel matrices - self.H = embed_data_DMDc(self.data, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval).float() - self.Hu = embed_data_DMDc(self.control_data, n_delays=self.n_delays, n_control_delays=self.n_control_delays, delay_interval=self.delay_interval, control=True).float() + self.H = embed_data_DMDc( + self.data, + n_delays=self.n_delays, + n_control_delays=self.n_control_delays, + delay_interval=self.delay_interval, + ).float() + self.Hu = embed_data_DMDc( + self.control_data, + n_delays=self.n_delays, + n_control_delays=self.n_control_delays, + delay_interval=self.delay_interval, + control=True, + ).float() if self.verbose: print("Hankel matrices computed!") - def compute_svd(self): """ Computes the SVD of the Omega and Y matrices. @@ -235,7 +279,6 @@ def compute_svd(self): if self.verbose: print("Computing SVD on H and U matrices ...") - if self.is_list_data: self.H_shapes = [h.shape for h in self.H] H_list = [] @@ -249,7 +292,7 @@ def compute_svd(self): ) else: H_list.append(h_elem) - + for hu_elem in self.Hu: if hu_elem.ndim == 3: Hu_list.append( @@ -265,7 +308,7 @@ def compute_svd(self): self.H_row_counts = [h.shape[0] for h in H_list] H = self.H Hu = self.Hu - + elif self.H.ndim == 3: # flatten across trials for 3d H = self.H.reshape(self.H.shape[0] * self.H.shape[1], self.H.shape[2]) Hu = self.Hu.reshape(self.Hu.shape[0] * self.Hu.shape[1], self.Hu.shape[2]) @@ -284,15 +327,19 @@ def compute_svd(self): self.Su_mat = torch.diag(self.Su).to(self.device) self.Su_mat_inv = torch.diag(1 / self.Su).to(self.device) - self.cumulative_explained_variance_input = self._compute_explained_variance(self.Su) - self.cumulative_explained_variance_output = self._compute_explained_variance(self.Sh) + self.cumulative_explained_variance_input = self._compute_explained_variance( + self.Su + ) + self.cumulative_explained_variance_output = self._compute_explained_variance( + self.Sh + ) self.Vht_minus, self.Vht_plus = self.get_plus_minus(self.Vh, self.H) self.Vut_minus, _ = self.get_plus_minus(self.Vu, self.Hu) if self.verbose: print("SVDs computed!") - + def get_plus_minus(self, V, H): if self.ntrials > 1: if self.is_list_data: @@ -341,12 +388,18 @@ def get_plus_minus(self, V, H): return Vt_minus, Vt_plus - - def recalc_rank(self, rank_input=None, rank_thresh_input=None, rank_explained_variance_input=None, - rank_output=None, rank_thresh_output=None, rank_explained_variance_output=None): - ''' + def recalc_rank( + self, + rank_input=None, + rank_thresh_input=None, + rank_explained_variance_input=None, + rank_output=None, + rank_thresh_output=None, + rank_explained_variance_output=None, + ): + """ Recalculates the rank for input and output based on provided parameters. - ''' + """ # Recalculate ranks for input self.rank_input = self._compute_rank_from_params( S=self.Su, @@ -354,7 +407,7 @@ def recalc_rank(self, rank_input=None, rank_thresh_input=None, rank_explained_va max_rank=self.Hu.shape[-1], rank=rank_input, rank_thresh=rank_thresh_input, - rank_explained_variance=rank_explained_variance_input + rank_explained_variance=rank_explained_variance_input, ) # Recalculate ranks for output self.rank_output = self._compute_rank_from_params( @@ -363,17 +416,22 @@ def recalc_rank(self, rank_input=None, rank_thresh_input=None, rank_explained_va max_rank=self.H.shape[-1], rank=rank_output, rank_thresh=rank_thresh_output, - rank_explained_variance=rank_explained_variance_output + rank_explained_variance=rank_explained_variance_output, ) - def compute_dmdc(self, lamb=None): if self.verbose: print("Computing DMDc matrices ...") self.lamb = self.lamb if lamb is None else lamb - V_minus_tot = torch.cat([self.Vht_minus[:, :self.rank_output], self.Vut_minus[:, :self.rank_input]], dim=1) + V_minus_tot = torch.cat( + [ + self.Vht_minus[:, : self.rank_output], + self.Vut_minus[:, : self.rank_input], + ], + dim=1, + ) A_v_tot = ( torch.linalg.inv( @@ -381,11 +439,11 @@ def compute_dmdc(self, lamb=None): + self.lamb * torch.eye(V_minus_tot.shape[1]).to(self.device) ) @ V_minus_tot.T - @ self.Vht_plus[:, :self.rank_output] + @ self.Vht_plus[:, : self.rank_output] ).T - #split A_v_tot into A_v and B_v - self.A_v = A_v_tot[:, :self.rank_output] - self.B_v = A_v_tot[:, self.rank_output:] + # split A_v_tot into A_v and B_v + self.A_v = A_v_tot[:, : self.rank_output] + self.B_v = A_v_tot[:, self.rank_output :] self.A_havok_dmd = ( self.Uh @ self.Sh_mat[: self.Uh.shape[1], : self.rank_output] @@ -401,24 +459,24 @@ def compute_dmdc(self, lamb=None): @ self.Su_mat_inv[: self.rank_input, : self.Uu.shape[1]] @ self.Uu.T ) - + # Set the A and B properties for backward compatibility and easier access self.A = self.A_havok_dmd self.B = self.B_havok_dmd - + if self.verbose: print("DMDc matrices computed!") def fit( - self, - data=None, - control_data=None, - n_delays=None, - delay_interval=None, - lamb=None, - device=None, - verbose=None, - ): + self, + data=None, + control_data=None, + n_delays=None, + delay_interval=None, + lamb=None, + device=None, + verbose=None, + ): """ Fits the DMDc model to the provided data. """ @@ -429,20 +487,20 @@ def fit( self.compute_hankel(data, control_data, n_delays, delay_interval) self.compute_svd() self.recalc_rank( - self.rank_input, self.rank_thresh_input, self.rank_explained_variance_input, - self.rank_output, self.rank_thresh_output, self.rank_explained_variance_output + self.rank_input, + self.rank_thresh_input, + self.rank_explained_variance_input, + self.rank_output, + self.rank_thresh_output, + self.rank_explained_variance_output, ) self.compute_dmdc(lamb) if self.send_to_cpu: - self.all_to_device('cpu') # send back to the cpu to save memory + self.all_to_device("cpu") # send back to the cpu to save memory def predict( - self, - test_data=None, - control_data=None, - reseed=None, - full_return=False - ): + self, test_data=None, control_data=None, reseed=None, full_return=False + ): """ Parameters ---------- @@ -474,10 +532,17 @@ def predict( test_data = self.data if control_data is None: control_data = self.control_data - + if isinstance(test_data, list): - predictions = [self.predict(test_data=d, control_data=d_control, - reseed=reseed, full_return=full_return) for d, d_control in zip(test_data, control_data)] + predictions = [ + self.predict( + test_data=d, + control_data=d_control, + reseed=reseed, + full_return=full_return, + ) + for d, d_control in zip(test_data, control_data) + ] if full_return: pred_data = [pred[0] for pred in predictions] H_test_dmdc = [pred[1] for pred in predictions] @@ -485,20 +550,24 @@ def predict( return pred_data, H_test_dmdc, H_test else: return predictions - + if isinstance(test_data, np.ndarray): test_data = torch.from_numpy(test_data).to(self.device) if isinstance(control_data, np.ndarray): control_data = torch.from_numpy(control_data).to(self.device) - + ndim = test_data.ndim if ndim == 2: test_data = test_data.unsqueeze(0) control_data = control_data.unsqueeze(0) # H_test = embed_data_DMDc(test_data, n_delays=self.n_delays, delay_interval=self.delay_interval, control=False) # H_control = embed_data_DMDc(control_data, n_delays=self.n_control_delays, delay_interval=self.delay_interval, control=True) - H_test = embed_signal_torch(test_data, self.n_delays, self.delay_interval).float() - H_control = embed_signal_torch(control_data, self.n_control_delays, self.delay_interval).float() + H_test = embed_signal_torch( + test_data, self.n_delays, self.delay_interval + ).float() + H_control = embed_signal_torch( + control_data, self.n_control_delays, self.delay_interval + ).float() if reseed is None: reseed = 1 @@ -506,22 +575,33 @@ def predict( H_test_dmdc[:, 0] = H_test[:, 0] A = self.A_havok_dmd B = self.B_havok_dmd - + for t in range(1, H_test.shape[1]): - u_t = H_control[:, t - 1] + u_t = H_control[:, t - 1] # print(A.shape) # print(H_test[:, t - 1].shape) # print(B.shape) # print(u_t.shape) if t % reseed == 0: - H_test_dmdc[:, t] = (A @ H_test[:, t - 1].transpose(-2, -1)).transpose(-2, -1) + (B @ u_t.transpose(-2, -1)).transpose(-2, -1) + H_test_dmdc[:, t] = (A @ H_test[:, t - 1].transpose(-2, -1)).transpose( + -2, -1 + ) + (B @ u_t.transpose(-2, -1)).transpose(-2, -1) else: - H_test_dmdc[:, t] = (A @ H_test_dmdc[:, t - 1].transpose(-2, -1)).transpose(-2, -1) + (B @ u_t.transpose(-2, -1)).transpose(-2, -1) - pred_data = torch.hstack([test_data[:, :(self.n_delays - 1)*self.delay_interval + self.steps_ahead], H_test_dmdc[:, self.steps_ahead:, :self.n]]) + H_test_dmdc[:, t] = ( + A @ H_test_dmdc[:, t - 1].transpose(-2, -1) + ).transpose(-2, -1) + (B @ u_t.transpose(-2, -1)).transpose(-2, -1) + pred_data = torch.hstack( + [ + test_data[ + :, : (self.n_delays - 1) * self.delay_interval + self.steps_ahead + ], + H_test_dmdc[:, self.steps_ahead :, : self.n], + ] + ) if ndim == 2: pred_data = pred_data[0] - + if full_return: return pred_data, H_test_dmdc, H_test else: diff --git a/DSA/dsa.py b/DSA/dsa.py index c21d583..b96eb93 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -29,15 +29,16 @@ "send_to_cpu": bool, } -#___Example config dataclasses for DMD # + +# ___Example config dataclasses for DMD # @dataclass() class DefaultDMDConfig: """ Configuration dataclass for DefaultDMD (standard DMD without control). - + This configuration is used to set parameters for the DefaultDMD class when performing Dynamical Mode Decomposition on time series data. - + Attributes: n_delays (int): Number of time delays to use in the Hankel matrix construction. Default is 1 (no delays). @@ -50,35 +51,39 @@ class DefaultDMDConfig: send_to_cpu (bool): Whether to move computations to CPU. Default is False (use GPU if available). """ + n_delays: int = 1 delay_interval: int = 1 rank: int = None lamb: float = 0 send_to_cpu: bool = False + @dataclass() class pyKoopmanDMDConfig: """ Configuration dataclass for pyKoopman DMD models. - + This configuration is used to set up pyKoopman observables and regressors for performing DMD analysis with the pyKoopman library. - + Attributes: observables: Observable function from pykoopman. Default is TimeDelay with n_delays=1. regressor: Regressor model from pydmd. Default is DMD with svd_rank=2. """ + observables = pykoopman.observables.TimeDelay(n_delays=1) regressor = pydmd.DMD(svd_rank=2) - + + @dataclass() class SubspaceDMDcConfig: """ Configuration dataclass for SubspaceDMDc (DMD with control using subspace identification). - + This configuration is used to set parameters for the SubspaceDMDc class when performing Dynamical Mode Decomposition on controlled systems. - + Attributes: n_delays (int): Number of time delays to use in the Hankel matrix construction. Default is 1 (no delays). @@ -91,21 +96,23 @@ class SubspaceDMDcConfig: backend (str): Subspace identification backend to use. Options: 'n4sid', 'custom'. """ + n_delays: int = 1 delay_interval: int = 1 rank: int = None lamb: float = 0 - backend: str = 'n4sid' + backend: str = "n4sid" -#__Example config dataclasses for similarity transform distance # + +# __Example config dataclasses for similarity transform distance # @dataclass class SimilarityTransformDistConfig: """ Configuration dataclass for SimilarityTransformDist (standard similarity transform distance). - + This configuration is used to compute the similarity transform distance between two DMD matrices, which measures how similar two dynamical systems are. - + Attributes: iters (int): Number of optimization iterations for finding the similarity transform. Default is 1500. @@ -117,19 +124,21 @@ class SimilarityTransformDistConfig: zero_pad (bool): Whether to zero-pad matrices to make them the same size. Default is False. """ + iters: int = 1500 - score_method: Literal["angular", "euclidean","wasserstein"] = "angular" + score_method: Literal["angular", "euclidean", "wasserstein"] = "angular" lr: float = 5e-3 zero_pad: bool = False + @dataclass() class ControllabilitySimilarityTransformDistConfig: """ Configuration dataclass for ControllabilitySimilarityTransformDist (similarity transform distance with control). - + This configuration is used to compute the similarity transform distance between two controlled DMD systems, comparing both state and control operators. - + Attributes: score_method (Literal["euclidean", "angular"]): Method for computing the distance score. 'angular' uses angular distance, 'euclidean' uses Euclidean distance. @@ -142,32 +151,34 @@ class ControllabilitySimilarityTransformDistConfig: return_distance_components (bool): Whether to return individual distance components (state, control, joint) separately. Default is False. """ + score_method: Literal["euclidean", "angular"] = "euclidean" - compare = 'state' + compare = "state" joint_optim: bool = False return_distance_components: bool = False + class GeneralizedDSA: """ Computes the Generalized Dynamical Similarity Analysis (DSA) for two data tensors. - + This class performs Dynamical Mode Decomposition (DMD) on input data and then computes similarity scores between the resulting DMD models using similarity transform distances. It supports various comparison modes including pairwise comparisons, bipartite comparisons, and comparisons with control inputs. - + The class handles: - Multiple data formats (single arrays, lists of arrays) - Different DMD implementations (local DMD, pyKoopman, etc.) - Control inputs for controlled systems - Parallel processing for efficiency - Various similarity metrics - + Example usage: # Compare two datasets dsa = GeneralizedDSA(X=data1, Y=data2, dmd_class=DefaultDMD) similarity_score = dsa.fit_score() - + # Pairwise comparison of multiple datasets dsa = GeneralizedDSA(X=[data1, data2, data3], Y=None) similarity_matrix = dsa.fit_score() @@ -181,9 +192,11 @@ def __init__( Y_control=None, dmd_class=DefaultDMD, similarity_class=SimilarityTransformDist, - dmd_config: Union[Mapping[str, Any], dataclass]= DefaultDMDConfig, - simdist_config: Union[Mapping[str, Any], dataclass] = SimilarityTransformDistConfig, - device='cpu', + dmd_config: Union[Mapping[str, Any], dataclass] = DefaultDMDConfig, + simdist_config: Union[ + Mapping[str, Any], dataclass + ] = SimilarityTransformDistConfig, + device="cpu", dsa_verbose=False, n_jobs=1, ): @@ -210,25 +223,25 @@ def __init__( control data matrix/matrices. Must be the same shape as Y. If None, then no control data is used. - + dmd_class : class DMD class to use for decomposition. Default is DefaultDMD. - + similarity_class : class Similarity transform distance class to use. Default is SimilarityTransformDist. - + dmd_config : Union[Mapping[str, Any], dataclass] Configuration for DMD parameters. Can be a dict or dataclass. - + simdist_config : Union[Mapping[str, Any], dataclass] Configuration for similarity transform distance parameters. Can be a dict or dataclass. - + device : str Device to use for computation ('cpu' or 'cuda'). Default is 'cpu'. - + dsa_verbose : bool Whether to print verbose output during computation. Default is False. - + n_jobs : int Number of parallel jobs to use. Default is 1 (sequential). Set to -1 to use all available cores. @@ -241,7 +254,7 @@ def __init__( OR to X and Y respectively across all matrices If it is (list,list), then each element will correspond to an individual dmd matrix indexed at the same position - + """ self.X = X self.Y = Y @@ -259,7 +272,10 @@ def __init__( if self.X is None and isinstance(self.Y, list): self.X, self.Y = self.Y, self.X # swap so code is easy - self.X_control, self.Y_control = self.Y_control, self.X_control # swap control too + self.X_control, self.Y_control = ( + self.Y_control, + self.X_control, + ) # swap control too self.check_method() if self.method == "self-pairwise": @@ -286,76 +302,97 @@ def __init__( else: broadcasted_value = self.broadcast_params(value) - setattr( - self, key, broadcasted_value - ) # e.g., self.n_delays = [[v,v],[v,v]] + setattr(self, key, broadcasted_value) # e.g., self.n_delays = [[v,v],[v,v]] self.dmd_config[key] = ( broadcasted_value # Store in dict for DMD instantiation ) - self._check_dmd_simdist_compatibility(dmd_class,similarity_class) + self._check_dmd_simdist_compatibility(dmd_class, similarity_class) self._dmd_api_source(dmd_class) self._initiate_dmds() self.simdist = similarity_class(**self.simdist_config) - def _initiate_dmds(self): if self.dmd_has_control and self.X_control is None and self.Y_control is None: - raise ValueError("Error: You are using a DMD model that fits a control operator but no control data is provided for either X or Y") - - if not self.dmd_has_control and (self.X_control is not None or self.Y_control is not None): - warnings.warn("You are using a DMD model with no control but control data is provided, will be ignored") + raise ValueError( + "Error: You are using a DMD model that fits a control operator but no control data is provided for either X or Y" + ) + if not self.dmd_has_control and ( + self.X_control is not None or self.Y_control is not None + ): + warnings.warn( + "You are using a DMD model with no control but control data is provided, will be ignored" + ) if self.dmd_api_source == "local_dmd": self.dmds = [] - #TODO: test this for single numpy array + # TODO: test this for single numpy array for i, (dat, control_dat) in enumerate(zip(self.data, self.control_data)): dmd_list = [] if control_dat is None: control_dat = [None] * len(dat) for j, (Xi, Xi_control) in enumerate(zip(dat, control_dat)): config = {k: v[i][j] for k, v in self.dmd_config.items()} - + # if self.dmd_has_control: dmd_obj = self.dmd_class(Xi, control_data=Xi_control, **config) else: dmd_obj = self.dmd_class(Xi, **config) - + dmd_list.append(dmd_obj) self.dmds.append(dmd_list) else: self.dmds = [ - [self.dmd_class(**{k: v[i][j] for k, v in self.dmd_config.items()}) for j, Xi in enumerate(dat)] + [ + self.dmd_class(**{k: v[i][j] for k, v in self.dmd_config.items()}) + for j, Xi in enumerate(dat) + ] for i, dat in enumerate(self.data) ] def _check_dmd_simdist_compatibility(self, dmd_class, similarity_class): - self.dmd_has_control = dmd_class in [DefaultDMDc, SubspaceDMDc] or ('pykoopman' in dmd_class.__module__ and self.dmd_config.get('regressor') in [DMDc, EDMDc]) - self.simdist_has_control = similarity_class in [ControllabilitySimilarityTransformDist] + self.dmd_has_control = dmd_class in [DefaultDMDc, SubspaceDMDc] or ( + "pykoopman" in dmd_class.__module__ + and self.dmd_config.get("regressor") in [DMDc, EDMDc] + ) + self.simdist_has_control = similarity_class in [ + ControllabilitySimilarityTransformDist + ] if self.dmd_has_control and not self.simdist_has_control: - warnings.warn("Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators") + warnings.warn( + "Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators" + ) if not self.dmd_has_control and self.simdist_has_control: - raise ValueError("Error: Your DMD model does not fit a control operator but comparing with a DSA metric that compares control operators") + raise ValueError( + "Error: Your DMD model does not fit a control operator but comparing with a DSA metric that compares control operators" + ) def _dmd_api_source(self, dmd_class): module_name = dmd_class.__module__ if "pydmd" in module_name: self.dmd_api_source = "pydmd" - raise ValueError("DSA is not currently directly compatible with pydmd due to \ + raise ValueError( + "DSA is not currently directly compatible with pydmd due to \ data structure incompatibility. Please use pykoopman instead. \ - Note that you can pass in pydmd objects through pykoopman's Koopman class.") + Note that you can pass in pydmd objects through pykoopman's Koopman class." + ) elif "pykoopman" in module_name: self.dmd_api_source = "pykoopman" - if self.dmd_has_control and self.dmd_config.get('regressor') in [DMDc, EDMDc]: - raise ValueError("Pykoopman DMDc and EDMDc are not currently compatible with DSA") + if self.dmd_has_control and self.dmd_config.get("regressor") in [ + DMDc, + EDMDc, + ]: + raise ValueError( + "Pykoopman DMDc and EDMDc are not currently compatible with DSA" + ) elif ( - "DSA.dmd" in module_name or - "DSA.subspace_dmdc" in module_name or - "DSA.dmdc" in module_name + "DSA.dmd" in module_name + or "DSA.subspace_dmdc" in module_name + or "DSA.dmdc" in module_name ): self.dmd_api_source = "local_dmd" else: @@ -366,32 +403,47 @@ def _dmd_api_source(self, dmd_class): def fit_dmds(self): if self.n_jobs != 1: - n_jobs = self.n_jobs if self.n_jobs > 0 else -1 # -1 means use all available cores - + n_jobs = ( + self.n_jobs if self.n_jobs > 0 else -1 + ) # -1 means use all available cores + if self.dmd_api_source == "local_dmd": for dmd_sets in self.dmds: if self.dsa_verbose: - print(f"Fitting {len(dmd_sets)} DMDs in parallel with {n_jobs} jobs") + print( + f"Fitting {len(dmd_sets)} DMDs in parallel with {n_jobs} jobs" + ) Parallel(n_jobs=n_jobs)( delayed(lambda dmd: dmd.fit())(dmd) for dmd in dmd_sets ) else: for dmd_list, dat in zip(self.dmds, self.data): if self.dsa_verbose: - print(f"Fitting {len(dmd_list)} DMDs in parallel with {n_jobs} jobs") + print( + f"Fitting {len(dmd_list)} DMDs in parallel with {n_jobs} jobs" + ) Parallel(n_jobs=n_jobs)( - delayed(lambda dmd, X: dmd.fit(X))(dmd, Xi) for dmd, Xi in zip(dmd_list, dat) + delayed(lambda dmd, X: dmd.fit(X))(dmd, Xi) + for dmd, Xi in zip(dmd_list, dat) ) else: # Sequential processing if self.dmd_api_source == "local_dmd": for dmd_sets in self.dmds: - loop = dmd_sets if not self.dsa_verbose else tqdm.tqdm(dmd_sets, desc="Fitting DMDs") + loop = ( + dmd_sets + if not self.dsa_verbose + else tqdm.tqdm(dmd_sets, desc="Fitting DMDs") + ) for dmd in loop: dmd.fit() else: for dmd_list, dat in zip(self.dmds, self.data): - loop = zip(dmd_list, dat) if not self.dsa_verbose else tqdm.tqdm(zip(dmd_list, dat), desc="Fitting DMDs") + loop = ( + zip(dmd_list, dat) + if not self.dsa_verbose + else tqdm.tqdm(zip(dmd_list, dat), desc="Fitting DMDs") + ) for dmd, Xi in loop: dmd.fit(Xi) @@ -460,10 +512,14 @@ def broadcast_params(self, param, cast=None): assert len(param[i]) >= len(data) out.append(param[i][: len(data)]) elif ( - isinstance(param, (int, float, np.integer)) or param in {None,'None','none'} or - (hasattr(param, '__module__') and ('pykoopman' in param.__module__ or 'pydmd' in param.__module__)) + isinstance(param, (int, float, np.integer)) + or param in {None, "None", "none"} + or ( + hasattr(param, "__module__") + and ("pykoopman" in param.__module__ or "pydmd" in param.__module__) + ) ): # self.X has already been mapped to [self.X] - if param in {'None','none'}: + if param in {"None", "none"}: param = None out.append([param] * len(self.X)) if self.Y is not None: @@ -498,8 +554,10 @@ def get_dmd_matrix(self, dmd): elif self.dmd_api_source == "pykoopman": return dmd.A elif self.dmd_api_source == "pydmd": - raise ValueError("DSA is not currently compatible with pydmd due to \ - data structure incompatibility. Please use pykoopman instead.") + raise ValueError( + "DSA is not currently compatible with pydmd due to \ + data structure incompatibility. Please use pykoopman instead." + ) def get_dmd_control_matrix(self, dmd): if self.dmd_api_source == "local_dmd": @@ -507,12 +565,14 @@ def get_dmd_control_matrix(self, dmd): elif self.dmd_api_source == "pykoopman": return dmd.B elif self.dmd_api_source == "pydmd": - raise ValueError("DSA is not currently compatible with pydmd due to \ - data structure incompatibility. Please use pykoopman instead.") - + raise ValueError( + "DSA is not currently compatible with pydmd due to \ + data structure incompatibility. Please use pykoopman instead." + ) + def score(self): """ - Score DSA with precomputed dmds + Score DSA with precomputed dmds Parameters __________ @@ -530,62 +590,76 @@ def score(self): ind2 = 0 if self.method == "self-pairwise" else 1 # 0 if self.pairwise (want to compare the set to itself) - n_sims = 1 if not (self.simdist_has_control \ - and self.simdist_config.get("return_distance_components")) else 3 - - self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]),n_sims)) + n_sims = ( + 1 + if not ( + self.simdist_has_control + and self.simdist_config.get("return_distance_components") + ) + else 3 + ) + + self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]), n_sims)) if self.dsa_verbose: - print('comparing dmds') - + print("comparing dmds") + def compute_similarity(i, j): if self.method == "self-pairwise" and j >= i: return None if self.dsa_verbose and self.n_jobs != 1: print(f"computing similarity between DMDs {i} and {j}") - + simdist_args = [ - self.get_dmd_matrix(self.dmds[0][i]), - self.get_dmd_matrix(self.dmds[ind2][j]), + self.get_dmd_matrix(self.dmds[0][i]), + self.get_dmd_matrix(self.dmds[ind2][j]), ] if self.dmd_has_control: - simdist_args.extend([ - self.get_dmd_control_matrix(self.dmds[0][i]), - self.get_dmd_control_matrix(self.dmds[ind2][j]), - ]) + simdist_args.extend( + [ + self.get_dmd_control_matrix(self.dmds[0][i]), + self.get_dmd_control_matrix(self.dmds[ind2][j]), + ] + ) sim = self.simdist.fit_score(*simdist_args) if self.dsa_verbose and self.n_jobs != 1: print(f"computing similarity between DMDs {i} and {j}") - + return (i, j, sim) - + pairs = [] for i in range(len(self.dmds[0])): for j in range(len(self.dmds[ind2])): if not (self.method == "self-pairwise" and j >= i): pairs.append((i, j)) - + if self.n_jobs != 1: n_jobs = self.n_jobs if self.n_jobs > 0 else -1 if self.dsa_verbose: - print(f"Computing {len(pairs)} DMD similarities in parallel with {n_jobs} jobs") - + print( + f"Computing {len(pairs)} DMD similarities in parallel with {n_jobs} jobs" + ) + results = Parallel(n_jobs=n_jobs)( delayed(compute_similarity)(i, j) for i, j in pairs ) else: - loop = pairs if not self.dsa_verbose else tqdm.tqdm(pairs, desc="Computing DMD similarities") + loop = ( + pairs + if not self.dsa_verbose + else tqdm.tqdm(pairs, desc="Computing DMD similarities") + ) results = [compute_similarity(i, j) for i, j in loop] - + for result in results: if result is not None: i, j, sim = result self.sims[i, j] = sim if self.method == "self-pairwise": self.sims[j, i] = sim - + if self.method == "default": return self.sims[0, 0].squeeze() @@ -598,26 +672,26 @@ def __init__( X, Y=None, dmd_class=DefaultDMD, - device='cpu', + device="cpu", dsa_verbose=False, n_jobs=1, - #simdist parameters + # simdist parameters score_method: Literal["angular", "euclidean"] = "angular", iters: int = 1500, lr: float = 5e-3, wasserstein_compare: Literal["sv", "eig", None] = "eig", - **dmd_kwargs + **dmd_kwargs, ): - #TODO: add readme + # TODO: add readme simdist_config = { - 'score_method': score_method, - 'iters': iters, - 'lr': lr, - 'wasserstein_compare': wasserstein_compare, + "score_method": score_method, + "iters": iters, + "lr": lr, + "wasserstein_compare": wasserstein_compare, } dmd_config = dmd_kwargs - + super().__init__( X=X, Y=Y, @@ -632,6 +706,7 @@ def __init__( n_jobs=n_jobs, ) + class InputDSA(GeneralizedDSA): def __init__( self, @@ -640,21 +715,25 @@ def __init__( Y=None, Y_control=None, dmd_class=SubspaceDMDc, - dmd_config: Union[Mapping[str, Any], dataclass]= SubspaceDMDcConfig, - simdist_config: Union[Mapping[str, Any], dataclass] = ControllabilitySimilarityTransformDistConfig, - device='cpu', + dmd_config: Union[Mapping[str, Any], dataclass] = SubspaceDMDcConfig, + simdist_config: Union[ + Mapping[str, Any], dataclass + ] = ControllabilitySimilarityTransformDistConfig, + device="cpu", dsa_verbose=False, n_jobs=1, ): - #check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, - #otherwise use ControllabilitySimilarityTransformDistConfig - if isinstance(simdist_config, dataclass): + # check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, + # otherwise use ControllabilitySimilarityTransformDistConfig + if isinstance(simdist_config, dataclass): compare = simdist_config.compare - elif isinstance(simdist_config,dict): - compare = simdist_config.get("compare",None) + elif isinstance(simdist_config, dict): + compare = simdist_config.get("compare", None) else: - raise ValueError("unknown data type for simdist-config, use dataclass or dict") - if compare == 'state': + raise ValueError( + "unknown data type for simdist-config, use dataclass or dict" + ) + if compare == "state": simdist = SimilarityTransformDist else: simdist = ControllabilitySimilarityTransformDist @@ -675,4 +754,3 @@ def __init__( assert X_control is not None assert self.dmd_has_control - diff --git a/DSA/preprocessing.py b/DSA/preprocessing.py index 3a04570..db5b8b1 100644 --- a/DSA/preprocessing.py +++ b/DSA/preprocessing.py @@ -4,6 +4,7 @@ from sklearn.decomposition import PCA from sklearn.pipeline import make_pipeline from sklearn.kernel_approximation import Nystroem + try: from .dmd import embed_signal_torch except ImportError: @@ -49,6 +50,7 @@ def normalize_data(data_list): return normalized_data_list + def coarse_grain(trajectories, bin_size=5, bins_overlapping=0): """ Bin or sum trajectories over time windows, with optional overlap. @@ -216,7 +218,7 @@ def nonlinear_dimensionality_reduction( model = make_pipeline(nystroem, pca) elif method.lower() == "umap": from umap import UMAP - + model = UMAP(n_components=n_components, **kwargs) else: raise ValueError( @@ -270,9 +272,10 @@ def featurize_data( if len(shape) == 3: return data.reshape(shape[0], shape[1], -1) else: - return data.reshape(shape[0],-1) + return data.reshape(shape[0], -1) + -def gaussian_filter(data, sigma, truncate=2.0,causal=True,dim=0,mode='same'): +def gaussian_filter(data, sigma, truncate=2.0, causal=True, dim=0, mode="same"): """ Applies a causal Gaussian filter to a 1D time series. @@ -287,7 +290,7 @@ def gaussian_filter(data, sigma, truncate=2.0,causal=True,dim=0,mode='same'): kernel_size = int(truncate * sigma + 0.5) t = np.arange(-kernel_size, kernel_size + 1) - kernel = np.exp(-0.5 * (t / sigma)**2) + kernel = np.exp(-0.5 * (t / sigma) ** 2) kernel /= kernel.sum() if causal: @@ -297,18 +300,23 @@ def gaussian_filter(data, sigma, truncate=2.0,causal=True,dim=0,mode='same'): kernel = kernel[::-1] filtered_data = np.apply_along_axis( - lambda x: convolve(x, kernel, mode=mode), - axis=dim, - arr=data + lambda x: convolve(x, kernel, mode=mode), axis=dim, arr=data ) return filtered_data, kernel -def coarse_grain_space(data, method='uniform', nbins_per_dim=20, sigma=None, kernel_width=2, scale='standard'): - ''' +def coarse_grain_space( + data, + method="uniform", + nbins_per_dim=20, + sigma=None, + kernel_width=2, + scale="standard", +): + """ Convert continuous data to one-hot encoded spatial bins, optionally with spatial smoothing. - + Parameters ---------- data : np.ndarray @@ -323,16 +331,18 @@ def coarse_grain_space(data, method='uniform', nbins_per_dim=20, sigma=None, ker Width of smoothing kernel in number of bins scale : str Scaling method: 'standard' for zero mean unit variance, or 'minmax' for [0,1] range - + Returns ------- encoded : np.ndarray - One-hot encoded data with shape (n_conditions, n_timepoints, n_total_bins) + One-hot encoded data with shape (n_conditions, n_timepoints, n_total_bins) or (n_timepoints, n_total_bins) - ''' - if method != 'uniform': - raise NotImplementedError(f"Method {method} not implemented. Only 'uniform' is currently supported.") - + """ + if method != "uniform": + raise NotImplementedError( + f"Method {method} not implemented. Only 'uniform' is currently supported." + ) + # Get input shape and dimensionality orig_shape = data.shape if data.ndim == 3: @@ -341,61 +351,78 @@ def coarse_grain_space(data, method='uniform', nbins_per_dim=20, sigma=None, ker else: n_time, n_dims = data.shape data_reshaped = data - + # Scale the data - if scale == 'standard': + if scale == "standard": mean = np.mean(data_reshaped, axis=0) std = np.std(data_reshaped, axis=0) data_scaled = (data_reshaped - mean) / std - elif scale == 'minmax': + elif scale == "minmax": min_vals = np.min(data_reshaped, axis=0) max_vals = np.max(data_reshaped, axis=0) data_scaled = (data_reshaped - min_vals) / (max_vals - min_vals) else: raise ValueError("scale must be 'standard' or 'minmax'") - + # Calculate total number of bins and check if reasonable - n_total_bins = nbins_per_dim ** n_dims + n_total_bins = nbins_per_dim**n_dims if n_total_bins > 1e6: - raise ValueError(f"Total number of bins ({n_total_bins}) too large. Reduce nbins_per_dim or use different binning method.") - + raise ValueError( + f"Total number of bins ({n_total_bins}) too large. Reduce nbins_per_dim or use different binning method." + ) + # Create bin edges - bin_edges = [np.linspace(np.min(data_scaled[:,d]), np.max(data_scaled[:,d]), nbins_per_dim+1) - for d in range(n_dims)] - + bin_edges = [ + np.linspace( + np.min(data_scaled[:, d]), np.max(data_scaled[:, d]), nbins_per_dim + 1 + ) + for d in range(n_dims) + ] + # Initialize one-hot encoded array if data.ndim == 3: encoded = np.zeros((n_conds, n_time, n_total_bins)) else: encoded = np.zeros((n_time, n_total_bins)) - + # Assign data points to bins and handle edge cases # Vectorized bin assignment and clipping for all dimensions at once - bin_indices = np.stack([ - np.clip(np.digitize(data_scaled[:,d], bin_edges[d]) - 1, 0, nbins_per_dim-1) - for d in range(n_dims) - ]).T - + bin_indices = np.stack( + [ + np.clip( + np.digitize(data_scaled[:, d], bin_edges[d]) - 1, 0, nbins_per_dim - 1 + ) + for d in range(n_dims) + ] + ).T + if n_dims > 1: flat_indices = np.ravel_multi_index(bin_indices.T, [nbins_per_dim] * n_dims) else: # For 1D case, bin_indices is already the flat indices flat_indices = bin_indices.ravel() - + if data.ndim == 3: - encoded.reshape(-1, n_total_bins)[np.arange(len(flat_indices)), flat_indices] = 1 + encoded.reshape(-1, n_total_bins)[ + np.arange(len(flat_indices)), flat_indices + ] = 1 else: encoded[np.arange(len(flat_indices)), flat_indices] = 1 - + # Apply spatial smoothing if requested if sigma is not None: from scipy.ndimage import gaussian_filter1d + if data.ndim == 3: for i in range(n_conds): for t in range(n_time): - encoded[i,t] = gaussian_filter1d(encoded[i,t], sigma=sigma, truncate=kernel_width) + encoded[i, t] = gaussian_filter1d( + encoded[i, t], sigma=sigma, truncate=kernel_width + ) else: for t in range(n_time): - encoded[t] = gaussian_filter1d(encoded[t], sigma=sigma, truncate=kernel_width) - - return encoded \ No newline at end of file + encoded[t] = gaussian_filter1d( + encoded[t], sigma=sigma, truncate=kernel_width + ) + + return encoded diff --git a/DSA/resdmd.py b/DSA/resdmd.py index d82c56f..1b525ca 100644 --- a/DSA/resdmd.py +++ b/DSA/resdmd.py @@ -2,6 +2,7 @@ import matplotlib.pyplot as plt from matplotlib import cm from matplotlib import colors as mcolors + try: from .dmd import DMD except ImportError: @@ -10,14 +11,15 @@ import ot from typing import Literal + def compute_residuals( dmd: "DMD | np.ndarray | torch.Tensor", X: np.ndarray = None, Y: np.ndarray = None, rank: int = None, matrix: Literal["A_v", "A_havok_dmd"] = "A_v", - return_num_denom = False, - tol=1e-6 + return_num_denom=False, + tol=1e-6, ): """ Compute DMD eigenvalues, eigenvectors, and residuals for each mode. @@ -51,12 +53,24 @@ def compute_residuals( # Handle DMD object, numpy array, or torch tensor if hasattr(dmd, matrix): - A = getattr(dmd, matrix).cpu().detach().numpy() if hasattr(getattr(dmd, matrix), "cpu") else getattr(dmd, matrix) + A = ( + getattr(dmd, matrix).cpu().detach().numpy() + if hasattr(getattr(dmd, matrix), "cpu") + else getattr(dmd, matrix) + ) L, G = np.linalg.eig(A) if matrix == "A_havok_dmd": - X = dmd.Vt_minus.cpu().detach().numpy()[:, : dmd.rank] @ dmd.S_mat[:dmd.rank,:dmd.rank].cpu().detach().numpy() @ dmd.U.cpu().detach().numpy().T[:dmd.rank] - Y = dmd.Vt_plus.cpu().detach().numpy()[:, : dmd.rank] @ dmd.S_mat[:dmd.rank,:dmd.rank].cpu().detach().numpy() @ dmd.U.cpu().detach().numpy().T[:dmd.rank] - + X = ( + dmd.Vt_minus.cpu().detach().numpy()[:, : dmd.rank] + @ dmd.S_mat[: dmd.rank, : dmd.rank].cpu().detach().numpy() + @ dmd.U.cpu().detach().numpy().T[: dmd.rank] + ) + Y = ( + dmd.Vt_plus.cpu().detach().numpy()[:, : dmd.rank] + @ dmd.S_mat[: dmd.rank, : dmd.rank].cpu().detach().numpy() + @ dmd.U.cpu().detach().numpy().T[: dmd.rank] + ) + elif matrix == "A_v": X = ( dmd.Vt_minus.cpu().detach().numpy()[:, : dmd.rank] @@ -73,12 +87,16 @@ def compute_residuals( A = dmd L, G = np.linalg.eig(A) if X is None or Y is None or rank is None: - raise ValueError("If passing a raw matrix, must also provide X, Y, and rank.") + raise ValueError( + "If passing a raw matrix, must also provide X, Y, and rank." + ) elif hasattr(dmd, "numpy"): A = dmd.numpy() L, G = np.linalg.eig(A) if X is None or Y is None or rank is None: - raise ValueError("If passing a raw matrix, must also provide X, Y, and rank.") + raise ValueError( + "If passing a raw matrix, must also provide X, Y, and rank." + ) else: raise ValueError("dmd must be a DMD object or a numpy array/torch tensor") diff --git a/DSA/simdist.py b/DSA/simdist.py index 3eea468..37dc9e6 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -6,6 +6,7 @@ import torch.nn.utils.parametrize as parametrize from scipy.stats import wasserstein_distance import ot # optimal transport for multidimensional l2 wasserstein + try: from .dmd import DMD except ImportError: @@ -26,10 +27,11 @@ def pad_zeros(A, B, device): return A, B + def compute_angle(evec): - ''' + """ computes the angle between multiple complex eigenvectors - ''' + """ if isinstance(evec, np.ndarray): evec = torch.from_numpy(evec).float() # evec /= torch.linalg.norm(evec, dim=1, keepdim=True) @@ -37,6 +39,8 @@ def compute_angle(evec): ang = torch.arccos(ang) ang[torch.isnan(ang)] = 0 return ang + + class LearnableSimilarityTransform(nn.Module): """ Computes the similarity transform for a learnable orthonormal matrix C @@ -179,8 +183,7 @@ def fit( iters=None, lr=None, score_method=None, - wasserstein_weightings = None, - + wasserstein_weightings=None, ): """ Computes the optimal matrix C over specified group @@ -200,11 +203,11 @@ def fit( _______ None """ - if isinstance(A,DMD): + if isinstance(A, DMD): A = A.A_v - if isinstance(B,DMD): + if isinstance(B, DMD): B = B.A_v - + assert A.shape[0] == A.shape[1] assert B.shape[0] == B.shape[1] @@ -213,11 +216,15 @@ def fit( self.A, self.B = A, B lr = self.lr if lr is None else lr iters = self.iters if iters is None else iters - wasserstein_compare = self.wasserstein_compare if wasserstein_compare is None else wasserstein_compare + wasserstein_compare = ( + self.wasserstein_compare + if wasserstein_compare is None + else wasserstein_compare + ) score_method = self.score_method if score_method is None else score_method - if score_method == 'wasserstein': - a,b = self._get_wasserstein_vars(A, B) + if score_method == "wasserstein": + a, b = self._get_wasserstein_vars(A, B) device = a.device # a = a # .cpu() # b = b # .cpu() @@ -237,11 +244,15 @@ def fit( a, b = a.to(device), b.to(device) self.C_star = ot.emd(a, b, self.M) - self.score_star = ot.emd2(a, b, self.M) *a.shape[0] #add scaling factor due to random matrix theory + self.score_star = ( + ot.emd2(a, b, self.M) * a.shape[0] + ) # add scaling factor due to random matrix theory # self.score_star = np.sum(self.C_star * self.M) - self.C_star = self.C_star / torch.linalg.norm(self.C_star, dim=1, keepdim=True) + self.C_star = self.C_star / torch.linalg.norm( + self.C_star, dim=1, keepdim=True + ) # wasserstein_distance(A.cpu().numpy(),B.cpu().numpy()) - + else: self.losses, self.C_star, self.sim_net = self.optimize_C( A, B, lr, iters, orthog=True, verbose=self.verbose @@ -258,14 +269,14 @@ def fit( self.C_star = C_star @ P self.sim_net = sim_net - def _get_wasserstein_vars(self,A, B): + def _get_wasserstein_vars(self, A, B): # assert self.wasserstein_compare in {"sv", "eig","evec_angle", 'evec'} assert self.wasserstein_compare in {"eig"} - #deprecated: only do wasserstein comparison on eigenvalues (for now, until others are theoretically validated) + # deprecated: only do wasserstein comparison on eigenvalues (for now, until others are theoretically validated) # if self.wasserstein_compare == "sv": - # a = torch.svd(A).S.view(-1, 1) - # b = torch.svd(B).S.view(-1, 1) + # a = torch.svd(A).S.view(-1, 1) + # b = torch.svd(B).S.view(-1, 1) # if self.wasserstein_compare == "eig": a = torch.linalg.eig(A).eigenvalues a = torch.vstack([a.real, a.imag]).T @@ -276,24 +287,28 @@ def _get_wasserstein_vars(self,A, B): # #this will compute the interior angles between eigenvectors # aevec = torch.linalg.eig(A).eigenvectors # bevec = torch.linalg.eig(B).eigenvectors - + # a = compute_angle(aevec) # b = compute_angle(bevec) # else: - # raise AssertionError("wasserstein_compare must be 'sv', 'eig', 'evec_angle', or 'evec'") - - #if the number of elements in the sets are different, then we need to pad the smaller set with zeros + # raise AssertionError("wasserstein_compare must be 'sv', 'eig', 'evec_angle', or 'evec'") + + # if the number of elements in the sets are different, then we need to pad the smaller set with zeros if a.shape[0] != b.shape[0]: # if self.wasserstein_compare in {'evec_angle', 'evec'}: - # raise AssertionError("Wasserstein comparison of eigenvectors is not supported when \ - # the number of elements in the sets are different") + # raise AssertionError("Wasserstein comparison of eigenvectors is not supported when \ + # the number of elements in the sets are different") if self.verbose: print(f"Padding the smaller set with zeros") if a.shape[0] < b.shape[0]: - a = torch.cat([a, torch.zeros(b.shape[0] - a.shape[0], a.shape[1])], dim=0) + a = torch.cat( + [a, torch.zeros(b.shape[0] - a.shape[0], a.shape[1])], dim=0 + ) else: - b = torch.cat([b, torch.zeros(a.shape[0] - b.shape[0], b.shape[1])], dim=0) - return a,b + b = torch.cat( + [b, torch.zeros(a.shape[0] - b.shape[0], b.shape[1])], dim=0 + ) + return a, b def optimize_C(self, A, B, lr, iters, orthog, verbose): # parameterize mapping to be orthogonal @@ -327,10 +342,10 @@ def optimize_C(self, A, B, lr, iters, orthog, verbose): # if _ % 99: # scheduler.step() losses.append(loss.item()) - #TODO: add a flag for this + # TODO: add a flag for this # if _ > 2 and abs(losses[-1] - losses[-2]) < self.eps: #early stopping - # break - + # break + if verbose: print("Finished optimizing C") @@ -360,8 +375,8 @@ def score(self, A=None, B=None, score_method=None): B = self.B if B is None else B assert A is not None assert B is not None - assert A.shape == self.C_star.shape or score_method == 'wasserstein' - assert B.shape == self.C_star.shape or score_method == 'wasserstein' + assert A.shape == self.C_star.shape or score_method == "wasserstein" + assert B.shape == self.C_star.shape or score_method == "wasserstein" score_method = self.score_method if score_method is None else score_method with torch.no_grad(): if not isinstance(A, torch.Tensor): @@ -379,21 +394,21 @@ def score(self, A=None, B=None, score_method=None): score = np.pi else: score = 0 - elif score_method == 'euclidean': + elif score_method == "euclidean": score = ( torch.norm(A - C @ B @ C.T, p="fro").cpu().numpy().item() ) # / A.numpy().size - elif score_method == 'wasserstein': - #use the current C_star to compute the score - assert hasattr(self, 'score_star') + elif score_method == "wasserstein": + # use the current C_star to compute the score + assert hasattr(self, "score_star") # if wasserstein_compare == self.wasserstein_compare: score = self.score_star.item() - #non-eig wasserstein comparisons are deprecated until theoretically validated + # non-eig wasserstein comparisons are deprecated until theoretically validated # else: # #apply the current transport plan to the new data # a,b = self._get_wasserstein_vars(A, B) # # a_transported = self.C_star @ A #shouldn't this be a? - + # M = ot.dist(a, b, metric='sqeuclidean') # score = torch.sum(self.C_star * M).item() # #TODO: validate this @@ -403,7 +418,7 @@ def score(self, A=None, B=None, score_method=None): # # score = transported_score.item() # if self.rescale_wasserstein: # score = score * A.shape[0] #add scaling factor due to random matrix theory - + return score def fit_score( @@ -443,42 +458,49 @@ def fit_score( assert A.shape[0] == B.shape[1] or self.wasserstein_compare is not None if A.shape[0] != B.shape[0]: # if self.wasserstein_compare is None: - # raise AssertionError( - # "Matrices must be the same size unless using wasserstein distance" - # ) - if score_method != 'wasserstein': # otherwise resort to L2 Wasserstein over singular or eigenvalues + # raise AssertionError( + # "Matrices must be the same size unless using wasserstein distance" + # ) + if ( + score_method != "wasserstein" + ): # otherwise resort to L2 Wasserstein over singular or eigenvalues print( f"resorting to wasserstein distance over {self.wasserstein_compare}" ) - score_method = 'wasserstein' + score_method = "wasserstein" else: pass + self.fit( + A, + B, + iters, + lr, + wasserstein_weightings=wasserstein_weightings, + score_method=score_method, + ) + + return self.score(self.A, self.B, score_method=score_method) - self.fit(A, B, iters, lr, wasserstein_weightings=wasserstein_weightings, score_method=score_method) - return self.score( - self.A, self.B, score_method=score_method - ) - def compute_subspace_angles(A, B): """ Computes the subspace angles between two DMD matrices. Matrices must be square and the same size. - + Parameters ---------- A : DMD object or numpy array First DMD matrix B : DMD object or numpy array Second DMD matrix - + Returns ------- angles : np.ndarray Principal angles between the subspaces """ - + A_mat = val_matrix(A) B_mat = val_matrix(B) @@ -497,6 +519,7 @@ def compute_subspace_angles(A, B): return angles + def val_matrix(matrix): if isinstance(matrix, DMD): mat = matrix.A_havok_dmd @@ -510,5 +533,5 @@ def val_matrix(matrix): # Check matrix is square if mat.shape[0] != mat.shape[1]: raise ValueError(f"matrix must be square") - + return mat diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index f962243..1e270e7 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -5,20 +5,22 @@ try: from .simdist import SimilarityTransformDist except ImportError: - from simdist import SimilarityTransformDist + from simdist import SimilarityTransformDist + class ControllabilitySimilarityTransformDist: """ Procrustes analysis over vector fields / LTI systems. Only Euclidean scoring is implemented in this closed-form version. """ + def __init__( self, *, score_method: Literal["euclidean", "angular"] = "euclidean", - compare: Literal['joint','control','state'] = 'joint', + compare: Literal["joint", "control", "state"] = "joint", joint_optim: bool = False, - return_distance_components: bool =True + return_distance_components: bool = True, ): f""" Parameters @@ -35,62 +37,69 @@ def __init__( self.score_method = score_method self.compare = compare self.joint_optim = joint_optim - self.return_distance_components=return_distance_components + self.return_distance_components = return_distance_components @staticmethod def compute_angular_dist(A, B): """ Computes the angular distance between two matrices A and B. - + Args: A (np.ndarray): First matrix B (np.ndarray): Second matrix - + Returns: float: Angular distance between A and B """ - cos_sim = np.trace(A.T @ B) / (np.linalg.norm(A, 'fro') * np.linalg.norm(B, 'fro')) + cos_sim = np.trace(A.T @ B) / ( + np.linalg.norm(A, "fro") * np.linalg.norm(B, "fro") + ) cos_sim = np.clip(cos_sim, -1, 1) cos_sim = np.arccos(cos_sim) cos_sim = np.clip(cos_sim, 0, np.pi) return cos_sim def fit_score(self, A, B, A_control, B_control): - + C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim ) score_method = self.score_method - if self.compare == 'joint': + if self.compare == "joint": if self.return_distance_components: - if self.score_method == 'euclidean': + if self.score_method == "euclidean": # sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") ** 2 # sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") ** 2 - sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") - sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") + sims_control_joint = np.linalg.norm( + C @ A_control @ C_u - B_control, "fro" + ) + sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") return sims_joint_euc, sims_state_joint, sims_control_joint - elif self.score_method == 'angular': - sims_control_joint = self.compute_angular_dist(C @ A_control @ C_u, B_control) + elif self.score_method == "angular": + sims_control_joint = self.compute_angular_dist( + C @ A_control @ C_u, B_control + ) sims_state_joint = self.compute_angular_dist(C @ A @ C.T, B) return sims_joint_ang, sims_state_joint, sims_control_joint else: - if self.score_method == 'euclidean': + if self.score_method == "euclidean": return sims_joint_euc - elif self.score_method == 'angular': + elif self.score_method == "angular": return sims_joint_ang else: - raise ValueError('Choose between Euclidean or angular distance') + raise ValueError("Choose between Euclidean or angular distance") - elif self.compare == 'state': + elif self.compare == "state": # return self.compare_A(A, B, score_method=score_method) - raise ValueError('To compute state similarity alone, use the SimilarityTransformDist class') + raise ValueError( + "To compute state similarity alone, use the SimilarityTransformDist class" + ) else: return self.compare_B(A_control, B_control, score_method=score_method) - def get_controllability_matrix(self, A, B): """ Computes the controllability matrix K = [B, AB, A^2B, ..., A^(n-1)B]. @@ -106,26 +115,26 @@ def get_controllability_matrix(self, A, B): K = B.copy() current1_term = B.copy() # Start with A^0 * B = B current2_term = B.copy() # Start with A^0 * B = B - + for i in range(1, n): # current_term = np.linalg.matrix_power(A, i) @ B # Use stable matrix power function current1_term = A @ current1_term current2_term = A.T @ current2_term - + # Check for numerical instability # term_norm = np.linalg.norm(current_term) # if term_norm < 1e-12 or term_norm > 1e12: - # break - + # break + # Check for linear dependence (rank deficiency) K_test = np.hstack((K, current1_term, current2_term)) # if np.linalg.matrix_rank(K_test) <= np.linalg.matrix_rank(K): - # break - + # break + K = K_test return K - def compare_systems_procrustes(self, A1, B1, A2, B2, *,align_inputs=False): + def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False): """ Compares two LTI systems by finding the optimal orthogonal transformation that aligns their controllability matrices. @@ -157,8 +166,9 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *,align_inputs=False): C = U @ Vh K2_aligned = C @ K2 err = np.linalg.norm(K1 - K2_aligned, "fro") - cos_sim = (np.vdot(K1, K2_aligned).real / - (np.linalg.norm(K1, "fro") * np.linalg.norm(K2, "fro"))) + cos_sim = np.vdot(K1, K2_aligned).real / ( + np.linalg.norm(K1, "fro") * np.linalg.norm(K2, "fro") + ) cos_sim = np.clip(cos_sim, -1, 1) cos_sim = np.arccos(cos_sim) cos_sim = np.clip(cos_sim, 0, np.pi) @@ -168,36 +178,38 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *,align_inputs=False): U1, S1, V1t = np.linalg.svd(K1, full_matrices=False) U2, S2, V2t = np.linalg.svd(K2, full_matrices=False) - C = U1 @ U2.T + C = U1 @ U2.T C_u = V2t.T @ V1t # = V2 @ V1^T - + K2_aligned = C @ K2 @ C_u err = np.linalg.norm(K1 - K2_aligned, "fro") - cos_sim = (np.vdot(K1, K2_aligned).real / - (np.linalg.norm(K1, "fro") * np.linalg.norm(K2, "fro"))) + cos_sim = np.vdot(K1, K2_aligned).real / ( + np.linalg.norm(K1, "fro") * np.linalg.norm(K2, "fro") + ) cos_sim = np.clip(cos_sim, -1, 1) cos_sim = np.arccos(cos_sim) cos_sim = np.clip(cos_sim, 0, np.pi) - + return C, C_u, err, cos_sim # @staticmethod # def compare_A(A1, A2, score_method='euclidean'): - # simdist = SimilarityTransformDist(iters=1000, score_method=score_method, lr=1e-3, verbose=True) - # return simdist.fit_score(A1, A2, score_method=score_method) + # simdist = SimilarityTransformDist(iters=1000, score_method=score_method, lr=1e-3, verbose=True) + # return simdist.fit_score(A1, A2, score_method=score_method) @staticmethod - def compare_B(B1, B2, score_method='euclidean'): - ''' + def compare_B(B1, B2, score_method="euclidean"): + """ compares the B matrices with left procrustes - ''' - if score_method == 'euclidean': + """ + if score_method == "euclidean": R, _ = orthogonal_procrustes(B2.T, B1.T) - return np.linalg.norm(B1 - R.T @ B2, "fro") + return np.linalg.norm(B1 - R.T @ B2, "fro") # return np.linalg.norm(B1 - R.T @ B2, "fro") ** 2 - elif score_method == 'angular': + elif score_method == "angular": R, _ = orthogonal_procrustes(B2.T, B1.T) - return ControllabilitySimilarityTransformDist.compute_angular_dist(B1, R.T @ B2) + return ControllabilitySimilarityTransformDist.compute_angular_dist( + B1, R.T @ B2 + ) else: - raise ValueError('Choose between Euclidean or angular distance') - + raise ValueError("Choose between Euclidean or angular distance") diff --git a/DSA/stats.py b/DSA/stats.py index 35287af..8efd601 100644 --- a/DSA/stats.py +++ b/DSA/stats.py @@ -4,6 +4,7 @@ from .simdist import SimilarityTransformDist from .dsa import DSA import warnings + # from dysts.utils import find_significant_frequencies @@ -104,7 +105,8 @@ def mse(x, y): return ((x - y) ** 2).mean().item() -def nmse(x,y): + +def nmse(x, y): """ Compute the mean squared error, normalized by the variance of the ground truth. @@ -518,7 +520,7 @@ def measure_nonnormality_transpose(A): def measure_transient_growth(A): """ - Computes the l2 norm of the matrix (discrete time growth rate). + Computes the l2 norm of the matrix (discrete time growth rate). This is the maximum singular value, which is a measure of the instantaneous growth rate. This can be > 1 even if the matrix is stable. diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index eca42d9..6408212 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -1,22 +1,24 @@ """This module computes the subspace DMD with control (DMDc) model for a given dataset.""" + import numpy as np import torch + class SubspaceDMDc: - """Subspace DMDc class for computing and predicting with DMD with control models. - """ + """Subspace DMDc class for computing and predicting with DMD with control models.""" + def __init__( - self, - data, - control_data, - n_delays=1, - rank=None, - lamb=1e-8, - device='cpu', - verbose=False, - send_to_cpu=False, - time_first=True, - backend='n4sid' + self, + data, + control_data, + n_delays=1, + rank=None, + lamb=1e-8, + device="cpu", + verbose=False, + send_to_cpu=False, + time_first=True, + backend="n4sid", ): # Convert inputs to torch tensors and store self.device = device @@ -33,14 +35,14 @@ def __init__( self.lamb = lamb self.verbose = verbose self.send_to_cpu = send_to_cpu - + def _to_tensor(self, data): """Convert data to torch tensor, handling lists and numpy arrays.""" if isinstance(data, list): return [self._to_tensor_single(d) for d in data] else: return self._to_tensor_single(data) - + def _to_tensor_single(self, data): """Convert single data item to torch tensor.""" if isinstance(data, np.ndarray): @@ -49,20 +51,22 @@ def _to_tensor_single(self, data): return data.float().to(self.device) return data - def fit(self): - self.A_v, self.B_v, self.C_v, self.info = self.subspace_dmdc_multitrial_flexible( - y=self.data, - u=self.control_data, - p=self.n_delays, - f=self.n_delays, - n=self.rank, - backend=self.backend, - lamb=self.lamb) - + self.A_v, self.B_v, self.C_v, self.info = ( + self.subspace_dmdc_multitrial_flexible( + y=self.data, + u=self.control_data, + p=self.n_delays, + f=self.n_delays, + n=self.rank, + backend=self.backend, + lamb=self.lamb, + ) + ) + if self.send_to_cpu: self.all_to_device("cpu") - + def all_to_device(self, device): """Send all tensors to specified device.""" if self.A_v is not None: @@ -72,17 +76,24 @@ def all_to_device(self, device): if self.C_v is not None: self.C_v = self.C_v.to(device) if self.info is not None: - for key in ['R_hat', 'Q_hat', 'S_hat', 'Gamma_hat', 'singular_values_O', 'noise_covariance']: + for key in [ + "R_hat", + "Q_hat", + "S_hat", + "Gamma_hat", + "singular_values_O", + "noise_covariance", + ]: if key in self.info and isinstance(self.info[key], torch.Tensor): self.info[key] = self.info[key].to(device) - - - def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): + def subspace_dmdc_multitrial_QR_decomposition( + self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999 + ): """ Subspace-DMDc for multi-trial data with variable trial lengths. Now use QR decomposition for computing the oblique projection as in N4SID implementations. - + Parameters: - y_list: list of tensors, each (p_out, N_i) - output data for trial i - u_list: list of tensors, each (m, N_i) - input data for trial i @@ -91,30 +102,34 @@ def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None - n: state dimension (auto-determined if None) - ridge: regularization parameter (used only for rank selection/SVD; QR is exact) - energy: energy threshold for rank selection - + Returns: - A_hat, B_hat, C_hat: system matrices - info: dictionary with additional information """ if len(y_list) != len(u_list): raise ValueError("y_list and u_list must have same number of trials") - + n_trials = len(y_list) p_out = y_list[0].shape[0] m = u_list[0].shape[0] - + # Validate dimensions across trials for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): if y_trial.shape[0] != p_out: - raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") + raise ValueError( + f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}" + ) if u_trial.shape[0] != m: - raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") + raise ValueError( + f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}" + ) if y_trial.shape[1] != u_trial.shape[1]: raise ValueError(f"Trial {i}: y and u have different time lengths") - + def hankel_stack(X, start, L): - return torch.cat([X[:, start + i:start + i + 1] for i in range(L)], dim=0) - + return torch.cat([X[:, start + i : start + i + 1] for i in range(L)], dim=0) + # Collect data from all trials U_p_all = [] Y_p_all = [] @@ -122,73 +137,85 @@ def hankel_stack(X, start, L): Y_f_all = [] valid_trials = [] T_per_trial = [] - + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): N_trial = Y_trial.shape[1] T_trial = N_trial - (p + f) + 1 - + if T_trial <= 0: if self.verbose: - print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") + print( + f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping" + ) continue - + valid_trials.append(trial_idx) T_per_trial.append(T_trial) - + # Build Hankel matrices for this trial - U_p_trial = torch.cat([hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1) - Y_p_trial = torch.cat([hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1) - U_f_trial = torch.cat([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1) - Y_f_trial = torch.cat([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1) - + U_p_trial = torch.cat( + [hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1 + ) + Y_p_trial = torch.cat( + [hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1 + ) + U_f_trial = torch.cat( + [hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1 + ) + Y_f_trial = torch.cat( + [hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1 + ) + U_p_all.append(U_p_trial) Y_p_all.append(Y_p_trial) U_f_all.append(U_f_trial) Y_f_all.append(Y_f_trial) - + if not valid_trials: raise ValueError("No trials have sufficient data for given (p,f)") - + # Concatenate across valid trials U_p = torch.cat(U_p_all, dim=1) # (p m, T_total) Y_p = torch.cat(Y_p_all, dim=1) # (p p_out, T_total) U_f = torch.cat(U_f_all, dim=1) # (f m, T_total) Y_f = torch.cat(Y_f_all, dim=1) # (f p_out, T_total) - + T_total = sum(T_per_trial) Z_p = torch.vstack([U_p, Y_p]) # (p (m + p_out), T_total) - + H = torch.vstack([U_f, Z_p, Y_f]) - + # Perform QR on H.T to get equivalent LQ on H - Q, R_upper = torch.linalg.qr(H.T, mode='reduced') # H.T = Q R_upper, R_upper upper triangular + Q, R_upper = torch.linalg.qr( + H.T, mode="reduced" + ) # H.T = Q R_upper, R_upper upper triangular L = R_upper.T # L = R_upper.T, lower triangular - + # Dimensions for slicing dim_uf = f * m dim_zp = p * (m + p_out) dim_yf = f * p_out - + # Extract submatrices from L (lower triangular) - R22 = L[dim_uf:dim_uf + dim_zp, dim_uf:dim_uf + dim_zp] - R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] - + R22 = L[dim_uf : dim_uf + dim_zp, dim_uf : dim_uf + dim_zp] + R32 = L[dim_uf + dim_zp :, dim_uf : dim_uf + dim_zp] + # Compute oblique projection O = R32 @ pinv(R22) @ Z_p O = R32 @ torch.linalg.pinv(R22) @ Z_p - + # The rest remains the same: SVD on O Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) if n is None: cs = torch.cumsum(s**2, dim=0) / (s**2).sum() n = int((cs < energy).sum().item() + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) - + U_n = Uo[:, :n] S_n = torch.diag(s[:n]) V_n = Vt[:n, :] S_half = torch.sqrt(S_n) - Gamma_hat = U_n @ S_half # (f p_out, n) - X_hat = S_half @ V_n # (n, T_total) + Gamma_hat = U_n @ S_half # (f p_out, n) + X_hat = S_half @ V_n # (n, T_total) # Time alignment for regression across all trials # Need to handle variable lengths carefully @@ -196,39 +223,39 @@ def hankel_stack(X, start, L): X_next_segments = [] U_mid_segments = [] Y_segments = [] - + start_idx = 0 for trial_idx, T_trial in enumerate(T_per_trial): # Extract states for this trial - X_trial = X_hat[:, start_idx:start_idx + T_trial] - + X_trial = X_hat[:, start_idx : start_idx + T_trial] + # State transitions within this trial X_trial_curr = X_trial[:, :-1] X_trial_next = X_trial[:, 1:] - + # Corresponding control inputs original_trial_idx = valid_trials[trial_idx] U_trial = u_list[original_trial_idx] - U_mid_trial = U_trial[:, p:p + (T_trial - 1)] - + U_mid_trial = U_trial[:, p : p + (T_trial - 1)] + X_segments.append(X_trial_curr) X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) - + # TODO: check the time-alignment of Y and X here # Corresponding output data - align with X_trial time indices Y_trial = y_list[original_trial_idx] - Y_trial_curr = Y_trial[:, p:p+T_trial-1] + Y_trial_curr = Y_trial[:, p : p + T_trial - 1] # Y_trial_curr = Y_trial[:, p+1:p+T_trial] Y_segments.append(Y_trial_curr) start_idx += T_trial - + # Concatenate all segments X = torch.cat(X_segments, dim=1) X_next = torch.cat(X_next_segments, dim=1) U_mid = torch.cat(U_mid_segments, dim=1) - + # Regression for A and B Z = torch.vstack([X, U_mid]) # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T @@ -242,49 +269,56 @@ def hankel_stack(X, start, L): # AB = X_next @ torch.linalg.pinv(Z) # A_hat = AB[:, :n] # B_hat = AB[:, n:] - + C_hat = Gamma_hat[:p_out, :] # Estimate noise covariance matrix # 0) Outputs aligned to X and U_mid (same time indices/columns) - Y_curr = torch.cat(Y_segments, dim=1) # shape: (p_out, N) + Y_curr = torch.cat(Y_segments, dim=1) # shape: (p_out, N) # 1) Residuals at time t # Process noise residual (state eq): w_t ≈ x_{t+1} - A x_t - B u_ts - W_hat = X_next - (A_hat @ X + B_hat @ U_mid) # (n, N) + W_hat = X_next - (A_hat @ X + B_hat @ U_mid) # (n, N) # Measurement noise residual (output eq): v_t ≈ y_t - C x_t (since D = 0) - V_hat = Y_curr - (C_hat @ X) # (p_out, N) + V_hat = Y_curr - (C_hat @ X) # (p_out, N) # 2) Mean-centering V_hat = V_hat - V_hat.mean(dim=1, keepdim=True) W_hat = W_hat - W_hat.mean(dim=1, keepdim=True) N_res = V_hat.shape[1] - denom = max(N_res - 1, 1) + denom = max(N_res - 1, 1) # 3) Covariances - R_hat = (V_hat @ V_hat.T) / denom # (p_out, p_out) measurement - Q_hat = (W_hat @ W_hat.T) / denom # (n, n) process - S_hat = (W_hat @ V_hat.T) / denom # (n, p_out) - cross (w,v) + R_hat = (V_hat @ V_hat.T) / denom # (p_out, p_out) measurement + Q_hat = (W_hat @ W_hat.T) / denom # (n, n) process + S_hat = (W_hat @ V_hat.T) / denom # (n, p_out) - cross (w,v) # 4) Symmetrize eps = 1e-12 - R_hat = 0.5 * (R_hat + R_hat.T) + eps * torch.eye(R_hat.shape[0], device=self.device) - Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * torch.eye(Q_hat.shape[0], device=self.device) + R_hat = 0.5 * (R_hat + R_hat.T) + eps * torch.eye( + R_hat.shape[0], device=self.device + ) + Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * torch.eye( + Q_hat.shape[0], device=self.device + ) noise_covariance = torch.block_diag(R_hat, Q_hat) # Add off-diagonal blocks top_right = S_hat.T bottom_left = S_hat - noise_covariance = torch.cat([ - torch.cat([R_hat, top_right], dim=1), - torch.cat([bottom_left, Q_hat], dim=1) - ], dim=0) + noise_covariance = torch.cat( + [ + torch.cat([R_hat, top_right], dim=1), + torch.cat([bottom_left, Q_hat], dim=1), + ], + dim=0, + ) info = { - "singular_values_O": s, - "rank_used": n, - "Gamma_hat": Gamma_hat, + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, "f": f, "n_trials_total": n_trials, "n_trials_used": len(valid_trials), @@ -293,20 +327,19 @@ def hankel_stack(X, start, L): "T_total": T_total, "trial_lengths": [y.shape[1] for y in y_list], "noise_covariance": noise_covariance, - 'R_hat': R_hat, - 'Q_hat': Q_hat, - 'S_hat': S_hat + "R_hat": R_hat, + "Q_hat": Q_hat, + "S_hat": S_hat, } - - return A_hat, B_hat, C_hat, info - + return A_hat, B_hat, C_hat, info - - def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): + def subspace_dmdc_multitrial_custom( + self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999 + ): """ Subspace-DMDc for multi-trial data with variable trial lengths. - + Parameters: - y_list: list of tensors, each (p_out, N_i) - output data for trial i - u_list: list of tensors, each (m, N_i) - input data for trial i @@ -315,31 +348,35 @@ def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e- - n: state dimension (auto-determined if None) - ridge: regularization parameter - energy: energy threshold for rank selection∏ - + Returns: - A_hat, B_hat, C_hat: system matrices - info: dictionary with additional information """ if len(y_list) != len(u_list): raise ValueError("y_list and u_list must have same number of trials") - + n_trials = len(y_list) p_out = y_list[0].shape[0] m = u_list[0].shape[0] - + # Validate dimensions across trials for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): if y_trial.shape[0] != p_out: - raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") + raise ValueError( + f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}" + ) if u_trial.shape[0] != m: - raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") + raise ValueError( + f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}" + ) if y_trial.shape[1] != u_trial.shape[1]: raise ValueError(f"Trial {i}: y and u have different time lengths") - + def hankel_stack(X, start, L): - return torch.cat([X[:, start + i:start + i + 1] for i in range(L)], dim=0) - + return torch.cat([X[:, start + i : start + i + 1] for i in range(L)], dim=0) + # Collect data from all trials U_p_all = [] Y_p_all = [] @@ -347,102 +384,116 @@ def hankel_stack(X, start, L): Y_f_all = [] valid_trials = [] T_per_trial = [] - + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): N_trial = Y_trial.shape[1] T_trial = N_trial - (p + f) + 1 - + if T_trial <= 0: if self.verbose: - print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") + print( + f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping" + ) continue - + valid_trials.append(trial_idx) T_per_trial.append(T_trial) - + # Build Hankel matrices for this trial - U_p_trial = torch.cat([hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1) - Y_p_trial = torch.cat([hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1) - U_f_trial = torch.cat([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1) - Y_f_trial = torch.cat([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1) - + U_p_trial = torch.cat( + [hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1 + ) + Y_p_trial = torch.cat( + [hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1 + ) + U_f_trial = torch.cat( + [hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1 + ) + Y_f_trial = torch.cat( + [hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1 + ) + U_p_all.append(U_p_trial) Y_p_all.append(Y_p_trial) U_f_all.append(U_f_trial) Y_f_all.append(Y_f_trial) if self.verbose: - print("="*40) + print("=" * 40) print(f"Number of valid trials: {len(valid_trials)}") - + if not valid_trials: raise ValueError("No trials have sufficient data for given (p,f)") - + # Concatenate across valid trials U_p = torch.cat(U_p_all, dim=1) # (pm, T_total) Y_p = torch.cat(Y_p_all, dim=1) # (p*p_out, T_total) U_f = torch.cat(U_f_all, dim=1) # (fm, T_total) Y_f = torch.cat(Y_f_all, dim=1) # (f*p_out, T_total) - + T_total = sum(T_per_trial) Z_p = torch.vstack([U_p, Y_p]) # (p(m+p_out), T_total) - + # Oblique projection: remove row(U_f), project onto row(Z_p) UfUfT = U_f @ U_f.T - Xsolve = torch.linalg.solve(UfUfT + lamb*torch.eye(UfUfT.shape[0], device=self.device), U_f) + Xsolve = torch.linalg.solve( + UfUfT + lamb * torch.eye(UfUfT.shape[0], device=self.device), U_f + ) Pi_perp = torch.eye(T_total, device=self.device) - U_f.T @ Xsolve Yf_perp = Y_f @ Pi_perp Zp_perp = Z_p @ Pi_perp - + ZZT = Zp_perp @ Zp_perp.T - Zp_pinv_left = torch.linalg.solve(ZZT + lamb*torch.eye(ZZT.shape[0], device=self.device), Zp_perp) + Zp_pinv_left = torch.linalg.solve( + ZZT + lamb * torch.eye(ZZT.shape[0], device=self.device), Zp_perp + ) P = Zp_perp.T @ Zp_pinv_left O = Yf_perp @ P # ≈ Γ_f X_p - + Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) if n is None: cs = torch.cumsum(s**2, dim=0) / (s**2).sum() n = int((cs < energy).sum().item() + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) - + U_n = Uo[:, :n] S_n = torch.diag(s[:n]) V_n = Vt[:n, :] S_half = torch.sqrt(S_n) - Gamma_hat = U_n @ S_half # (f*p_out, n) - X_hat = S_half @ V_n # (n, T_total) - + Gamma_hat = U_n @ S_half # (f*p_out, n) + X_hat = S_half @ V_n # (n, T_total) + # Time alignment for regression across all trials # Need to handle variable lengths carefully X_segments = [] X_next_segments = [] U_mid_segments = [] - + start_idx = 0 for trial_idx, T_trial in enumerate(T_per_trial): # Extract states for this trial - X_trial = X_hat[:, start_idx:start_idx + T_trial] - + X_trial = X_hat[:, start_idx : start_idx + T_trial] + # State transitions within this trial X_trial_curr = X_trial[:, :-1] X_trial_next = X_trial[:, 1:] - + # Corresponding control inputs original_trial_idx = valid_trials[trial_idx] U_trial = u_list[original_trial_idx] - U_mid_trial = U_trial[:, p:p + (T_trial - 1)] - + U_mid_trial = U_trial[:, p : p + (T_trial - 1)] + X_segments.append(X_trial_curr) X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) - + start_idx += T_trial - + # Concatenate all segments X = torch.cat(X_segments, dim=1) X_next = torch.cat(X_next_segments, dim=1) U_mid = torch.cat(U_mid_segments, dim=1) - + # Regression for A and B Z = torch.vstack([X, U_mid]) # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T @@ -451,13 +502,13 @@ def hankel_stack(X, start, L): AB = torch.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T A_hat = AB[:, :n] B_hat = AB[:, n:] - + C_hat = Gamma_hat[:p_out, :] - + info = { - "singular_values_O": s, - "rank_used": n, - "Gamma_hat": Gamma_hat, + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, "f": f, "n_trials_total": n_trials, "n_trials_used": len(valid_trials), @@ -465,17 +516,17 @@ def hankel_stack(X, start, L): "T_per_trial": T_per_trial, "T_total": T_total, "trial_lengths": [y.shape[1] for y in y_list], - "X_hat": X_hat + "X_hat": X_hat, } - - return A_hat, B_hat, C_hat, info - + return A_hat, B_hat, C_hat, info - def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energy=0.999, backend='n4sid'): + def subspace_dmdc_multitrial_flexible( + self, y, u, p, f, n=None, lamb=1e-8, energy=0.999, backend="n4sid" + ): """ Flexible wrapper that handles both fixed-length and variable-length multi-trial data. - + Parameters: - y: either (n_trials, p_out, N) array, (p_out, N) array, or list of (p_out, N_i) arrays - u: either (n_trials, m, N) array, (m, N) array, or list of (m, N_i) arrays @@ -488,11 +539,15 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ else: y_list = y u_list = u - if backend == 'n4sid': - return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) + if backend == "n4sid": + return self.subspace_dmdc_multitrial_QR_decomposition( + y_list, u_list, p, f, n, lamb, energy + ) else: - return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) - + return self.subspace_dmdc_multitrial_custom( + y_list, u_list, p, f, n, lamb, energy + ) + else: # Handle 2D arrays (single trial) by converting to list format if y.ndim == 2: @@ -502,17 +557,20 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ # Convert 3D arrays to list format y_list = [y[i] for i in range(y.shape[0])] u_list = [u[i] for i in range(u.shape[0])] - + # If time_first=True, transpose each trial from (time_points, variables) to (variables, time_points) if self.time_first: y_list = [y_trial.T for y_trial in y_list] u_list = [u_trial.T for u_trial in u_list] - - if backend == 'n4sid': - return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) - else: - return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) + if backend == "n4sid": + return self.subspace_dmdc_multitrial_QR_decomposition( + y_list, u_list, p, f, n, lamb, energy + ) + else: + return self.subspace_dmdc_multitrial_custom( + y_list, u_list, p, f, n, lamb, energy + ) def predict(self, Y, U, reseed=None): # Y and U are (n_times, n_channels) or list of 2D arrays/tensors @@ -523,11 +581,11 @@ def predict(self, Y, U, reseed=None): if isinstance(Y, list): Y = [self._to_tensor_single(y) for y in Y] U = [self._to_tensor_single(u) for u in U] - + if not self.time_first: Y = [y.T for y in Y] U = [u.T for u in U] - + self.kalman = OnlineKalman(self) Y_pred = [] for trial in range(len(Y)): @@ -535,8 +593,7 @@ def predict(self, Y, U, reseed=None): trial_predictions = [] for t in range(Y[trial].shape[0]): y_filtered, _ = self.kalman.step( - y=Y[trial][t] if t%reseed == 0 else None, - u=U[trial][t] + y=Y[trial][t] if t % reseed == 0 else None, u=U[trial][t] ) trial_predictions.append(y_filtered) Y_pred.append(torch.cat(trial_predictions, dim=1).T) @@ -545,7 +602,7 @@ def predict(self, Y, U, reseed=None): # Convert to tensors Y = self._to_tensor_single(Y) U = self._to_tensor_single(U) - + # print("time_first", self.time_first) if not self.time_first: if Y.ndim == 2: @@ -554,12 +611,14 @@ def predict(self, Y, U, reseed=None): else: Y = Y.permute(0, 2, 1) U = U.permute(0, 2, 1) - + self.kalman = OnlineKalman(self) if Y.ndim == 2: Y_pred = [] for t in range(Y.shape[0]): - y_filtered, _ = self.kalman.step(y=Y[t] if t%reseed == 0 else None, u=U[t]) + y_filtered, _ = self.kalman.step( + y=Y[t] if t % reseed == 0 else None, u=U[t] + ) Y_pred.append(y_filtered) return torch.cat(Y_pred, dim=1).T else: @@ -571,45 +630,46 @@ def predict(self, Y, U, reseed=None): self.kalman.reset() # Reset filter for each trial trial_predictions = [] for t in range(Y.shape[1]): - y_filtered, _ = self.kalman.step(y=Y[trial, t] if t%reseed == 0 else None, u=U[trial, t]) + y_filtered, _ = self.kalman.step( + y=Y[trial, t] if t % reseed == 0 else None, u=U[trial, t] + ) trial_predictions.append(y_filtered) # print("y_filtered.shape", y_filtered.shape) Y_pred.append(torch.cat(trial_predictions, dim=1).T) return torch.stack(Y_pred) - class OnlineKalman: """ Online Kalman Filter class for real-time state estimation. - + This class maintains the internal state of the Kalman filter and provides a step method for updating the filter with new observations and inputs. """ - + def __init__(self, dmdc): """ Initialize the Online Kalman Filter with a fitted DMDc model. - + Parameters ---------- dmdc : object - Fitted DMDc model containing A_v, B_v, C_v matrices and + Fitted DMDc model containing A_v, B_v, C_v matrices and noise covariance estimates (R_hat, S_hat, Q_hat) """ self.device = dmdc.device self.A = dmdc.A_v - self.B = dmdc.B_v + self.B = dmdc.B_v self.C = dmdc.C_v - self.R = dmdc.info['R_hat'] - self.S = dmdc.info['S_hat'] - self.Q = dmdc.info['Q_hat'] - + self.R = dmdc.info["R_hat"] + self.S = dmdc.info["S_hat"] + self.Q = dmdc.info["Q_hat"] + # Get dimensions # print("C_shape", self.C.shape) self.y_dim, self.x_dim = self.C.shape self.u_dim = self.B.shape[1] - + # Initialize state storage self.p_filtereds = [] self.x_filtereds = [] @@ -621,24 +681,23 @@ def __init__(self, dmdc): self.y_predicteds = [] self.kalman_gains = [] - # def step(self, y=None, u=None, lam=1e-8): # """ # Perform one step of the Kalman filter. - + # Parameters # ---------- # y : np.ndarray, optional # Observed output at current time step. If None, the filter # will predict without observation update. - # u : np.ndarray, optional + # u : np.ndarray, optional # Input at current time step. If None, no input is applied. - + # Returns # ------- # y_filtered : np.ndarray # Filtered output estimate - # x_filtered : np.ndarray + # x_filtered : np.ndarray # Filtered state estimate # """ # x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) @@ -661,14 +720,14 @@ def __init__(self, dmdc): # x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) # else: # x_filtered = x_pred.copy() - + # K_pred = (self.S + self.A @ p_pred @ self.C.T) @ np.linalg.pinv(S_innov) - # p_predicted = (self.A @ p_pred @ self.A.T + self.Q - + # p_predicted = (self.A @ p_pred @ self.A.T + self.Q - # K_pred @ (self.S + self.A @ p_pred @ self.C.T).T) # x_predicted = self.A @ x_pred + self.B @ u # if not np.isnan(y).any(): # x_predicted += K_pred @ (y - self.C @ x_pred) - + # # Store results # self.p_filtereds.append(p_filtered) # self.x_filtereds.append(x_filtered) @@ -679,35 +738,42 @@ def __init__(self, dmdc): # self.y_filtereds.append(self.C @ x_filtered) # self.y_predicteds.append(self.C @ x_predicted) # self.kalman_gains.append(K_pred) - - # return self.y_filtereds[-1], self.x_filtereds[-1] + # return self.y_filtereds[-1], self.x_filtereds[-1] def step(self, y=None, u=None, reg_coef=1e-6): """ Perform one step of the Kalman filter. - + Parameters ---------- y : torch.Tensor or np.ndarray, optional Observed output at current time step. If None, the filter will predict without observation update. - u : torch.Tensor or np.ndarray, optional + u : torch.Tensor or np.ndarray, optional Input at current time step. If None, no input is applied. reg_coef : float, optional Regularization coefficient to add to diagonal of P matrices to maintain numerical stability. Default: 1e-6 - + Returns ------- y_filtered : torch.Tensor Filtered output estimate - x_filtered : torch.Tensor + x_filtered : torch.Tensor Filtered state estimate """ - x_pred = self.x_predicteds[-1] if self.x_predicteds else torch.zeros((self.x_dim, 1), device=self.device) - p_pred = self.p_predicteds[-1] if self.p_predicteds else torch.eye(self.x_dim, device=self.device) - + x_pred = ( + self.x_predicteds[-1] + if self.x_predicteds + else torch.zeros((self.x_dim, 1), device=self.device) + ) + p_pred = ( + self.p_predicteds[-1] + if self.p_predicteds + else torch.eye(self.x_dim, device=self.device) + ) + # Add regularization to p_pred to prevent ill-conditioning p_pred_reg = p_pred + reg_coef * torch.eye(self.x_dim, device=self.device) @@ -719,7 +785,7 @@ def step(self, y=None, u=None, reg_coef=1e-6): u = u.reshape(-1, 1) else: u = torch.zeros((self.u_dim, 1), device=self.device) - + if y is not None: if isinstance(y, np.ndarray): y = torch.from_numpy(y).float().to(self.device) @@ -732,28 +798,35 @@ def step(self, y=None, u=None, reg_coef=1e-6): S_innov = self.R + self.C @ p_pred_reg @ self.C.T K_filtered = p_pred_reg @ self.C.T @ torch.linalg.pinv(S_innov) p_filtered = p_pred_reg - K_filtered @ self.C @ p_pred_reg - + # Add regularization to p_filtered to maintain positive definiteness p_filtered = (p_filtered + p_filtered.T) / 2 # Ensure symmetry - p_filtered = p_filtered + reg_coef * torch.eye(self.x_dim, device=self.device) # Add regularization - + p_filtered = p_filtered + reg_coef * torch.eye( + self.x_dim, device=self.device + ) # Add regularization + if not torch.isnan(y).any(): x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) else: x_filtered = x_pred.clone() - + K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ torch.linalg.pinv(S_innov) - p_predicted = (self.A @ p_pred_reg @ self.A.T + self.Q - - K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T) - + p_predicted = ( + self.A @ p_pred_reg @ self.A.T + + self.Q + - K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T + ) + # Add regularization to p_predicted and ensure symmetry p_predicted = (p_predicted + p_predicted.T) / 2 # Ensure symmetry - p_predicted = p_predicted + reg_coef * torch.eye(self.x_dim, device=self.device) # Add regularization - + p_predicted = p_predicted + reg_coef * torch.eye( + self.x_dim, device=self.device + ) # Add regularization + x_predicted = self.A @ x_pred + self.B @ u if not torch.isnan(y).any(): x_predicted += K_pred @ (y - self.C @ x_pred) - + # Store results self.p_filtereds.append(p_filtered) self.x_filtereds.append(x_filtered) @@ -764,9 +837,9 @@ def step(self, y=None, u=None, reg_coef=1e-6): self.y_filtereds.append(self.C @ x_filtered) self.y_predicteds.append(self.C @ x_predicted) self.kalman_gains.append(K_pred) - + return self.y_filtereds[-1], self.x_filtereds[-1] - + def reset(self): """Reset the filter to initial state.""" self.p_filtereds = [] @@ -778,18 +851,17 @@ def reset(self): self.y_filtereds = [] self.y_predicteds = [] self.kalman_gains = [] - - + def get_history(self): """Return the complete history of filter states.""" return { - 'p_filtereds': self.p_filtereds, - 'x_filtereds': self.x_filtereds, - 'p_predicteds': self.p_predicteds, - 'x_predicteds': self.x_predicteds, - 'us': self.us, - 'ys': self.ys, - 'y_filtereds': self.y_filtereds, - 'y_predicteds': self.y_predicteds, - 'kalman_gains': self.kalman_gains - } \ No newline at end of file + "p_filtereds": self.p_filtereds, + "x_filtereds": self.x_filtereds, + "p_predicteds": self.p_predicteds, + "x_predicteds": self.x_predicteds, + "us": self.us, + "ys": self.ys, + "y_filtereds": self.y_filtereds, + "y_predicteds": self.y_predicteds, + "kalman_gains": self.kalman_gains, + } diff --git a/DSA/sweeps.py b/DSA/sweeps.py index 383e7ca..e23c7ea 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -1,16 +1,20 @@ import numpy as np from tqdm import tqdm from .dmd import DMD -from .stats import measure_nonnormality_transpose, compute_all_stats, measure_transient_growth +from .stats import ( + measure_nonnormality_transpose, + compute_all_stats, + measure_transient_growth, +) from .resdmd import compute_residuals import matplotlib.pyplot as plt from typing import Literal -def split_train_test(data,train_frac=0.8): - if isinstance(data,list): - train_data = [d for i,d in enumerate(data) if i < int(train_frac*len(data))] - test_data = [d for i,d in enumerate(data) if i >= int(train_frac*len(data))] +def split_train_test(data, train_frac=0.8): + if isinstance(data, list): + train_data = [d for i, d in enumerate(data) if i < int(train_frac * len(data))] + test_data = [d for i, d in enumerate(data) if i >= int(train_frac * len(data))] dim = data[0].shape[-1] elif data.ndim == 3 and data.shape[0] == 1: train_data = data[:, int(train_frac * data.shape[1]) :] @@ -18,10 +22,13 @@ def split_train_test(data,train_frac=0.8): dim = data.shape[-1] else: train_data = data[: int(train_frac * data.shape[0])] - test_data = data[int(train_frac * data.shape[0]) :] if train_frac < 1.0 else train_data + test_data = ( + data[int(train_frac * data.shape[0]) :] if train_frac < 1.0 else train_data + ) dim = data.shape[-1] return train_data, test_data, dim + def sweep_ranks_delays( data, n_delays, @@ -31,8 +38,8 @@ def sweep_ranks_delays( return_residuals=True, return_transient_growth=False, return_mse=False, - error_space='X', - **dmd_kwargs + error_space="X", + **dmd_kwargs, ): """ Sweep over combinations of DMD ranks and delays, returning AIC, MASE, non-normality, and residuals. @@ -63,7 +70,7 @@ def sweep_ranks_delays( all_aics, all_mases, all_nnormals, all_residuals, all_num_abscissa, all_l2norm : np.ndarray Arrays of results for each (delay, rank) pair. """ - train_data, test_data, dim = split_train_test(data,train_frac) + train_data, test_data, dim = split_train_test(data, train_frac) all_aics, all_mases, all_nnormals, all_residuals, all_l2norm = [], [], [], [], [] for nd in tqdm(n_delays): rresiduals = [] @@ -76,37 +83,34 @@ def sweep_ranks_delays( rresiduals.append(np.inf) l2norms.append(np.inf) continue - dmd = DMD( - train_data, - n_delays=nd, - rank=r, - **dmd_kwargs - ) + dmd = DMD(train_data, n_delays=nd, rank=r, **dmd_kwargs) dmd.fit() - pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict(test_data,reseed=reseed,full_return=True) - if error_space == 'H': + pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict( + test_data, reseed=reseed, full_return=True + ) + if error_space == "H": pred = H_test_pred test_data_err = H_test_true - elif error_space == 'V': + elif error_space == "V": pred = V_test_pred test_data_err = V_test_true - elif error_space == 'X': + elif error_space == "X": pred = pred test_data_err = test_data else: raise ValueError(f"Invalid error space: {error_space}") - if hasattr(pred,"cpu"): + if hasattr(pred, "cpu"): pred = pred.cpu() - if hasattr(test_data_err,"cpu"): + if hasattr(test_data_err, "cpu"): test_data_err = test_data_err.cpu() - if isinstance(pred,list): - pred = np.concatenate(pred,axis=0) - test_data_err = np.concatenate(test_data_err,axis=0) + if isinstance(pred, list): + pred = np.concatenate(pred, axis=0) + test_data_err = np.concatenate(test_data_err, axis=0) # if featurize and ndim is not None: - # pred = pred[:, :, -ndim:] - # stats = compute_all_stats(pred, test_data_err[:, :, -ndim:], dmd.rank) + # pred = pred[:, :, -ndim:] + # stats = compute_all_stats(pred, test_data_err[:, :, -ndim:], dmd.rank) # else: stats = compute_all_stats(test_data_err, pred, dmd.rank) aic = stats["AIC"] @@ -117,7 +121,11 @@ def sweep_ranks_delays( dmd.A_v.cpu().detach().numpy() if hasattr(dmd.A_v, "cpu") else dmd.A_v ) if return_transient_growth: - l2norm = measure_transient_growth(dmd.A_v.cpu().detach().numpy() if hasattr(dmd.A_v, "cpu") else dmd.A_v) + l2norm = measure_transient_growth( + dmd.A_v.cpu().detach().numpy() + if hasattr(dmd.A_v, "cpu") + else dmd.A_v + ) else: l2norm = None L, G, residuals, _ = compute_residuals(dmd) @@ -155,10 +163,10 @@ def plot_sweep_results( ranks=None, name=None, save_path=None, - figsize=(10,4), + figsize=(10, 4), return_mse=False, cmap="gist_gray", - error_space='X', + error_space="X", ): to_plot = [aics, mases] if nnormals is not None: @@ -168,33 +176,41 @@ def plot_sweep_results( if l2norm is not None: to_plot.append(l2norm) fig, ax = plt.subplots(1, len(to_plot), figsize=figsize) - cmap = plt.cm.get_cmap(cmap) if isinstance(cmap,str) else cmap + cmap = plt.cm.get_cmap(cmap) if isinstance(cmap, str) else cmap scale_denom = len(aics) + 3 for j in range(len(aics)): - ax[0].plot( - ranks, aics[j], label=f"{n_delays[j]}", color=cmap(j / scale_denom) - ) - ax[1].plot(ranks, mases[j], color=cmap(j / scale_denom),label=f"{n_delays[j]}") + ax[0].plot(ranks, aics[j], label=f"{n_delays[j]}", color=cmap(j / scale_denom)) + ax[1].plot(ranks, mases[j], color=cmap(j / scale_denom), label=f"{n_delays[j]}") ax[1].axhline(1, color="black", linestyle="--") if nnormals is not None: - ax[2].plot(ranks, nnormals[j], color=cmap(j / scale_denom),label=f"{n_delays[j]}") + ax[2].plot( + ranks, nnormals[j], color=cmap(j / scale_denom), label=f"{n_delays[j]}" + ) if residuals is not None: - ax[3].plot(ranks, residuals[j], color=cmap(j / scale_denom),label=f"{n_delays[j]}") + ax[3].plot( + ranks, residuals[j], color=cmap(j / scale_denom), label=f"{n_delays[j]}" + ) if l2norm is not None: - ax[4].plot(ranks, l2norm[j], color=cmap(j / scale_denom),label=f"{n_delays[j]}") + ax[4].plot( + ranks, l2norm[j], color=cmap(j / scale_denom), label=f"{n_delays[j]}" + ) ax[4].axhline(1, color="black", linestyle="--") ax[1].set_yscale("log") ax[0].set_ylabel(f"{error_space} AIC") - ax[1].set_ylabel(f"{error_space} MASE" if not return_mse else f"{error_space} MSE") + ax[1].set_ylabel( + f"{error_space} MASE" if not return_mse else f"{error_space} MSE" + ) if nnormals is not None: ax[2].set_ylabel(f"Non-normal score") if residuals is not None: ax[3].set_ylabel(f"Average residual of eigenvalues") if l2norm is not None: ax[4].set_ylabel(f"L2 norm of matrix") - ax[-1].legend(title='# delays',loc='upper right',bbox_to_anchor=(2,1),borderaxespad=1) + ax[-1].legend( + title="# delays", loc="upper right", bbox_to_anchor=(2, 1), borderaxespad=1 + ) for k in range(len(to_plot)): ax[k].set_xlabel("Rank") ax[k].spines["top"].set_visible(False) @@ -207,28 +223,39 @@ def plot_sweep_results( else: return fig, ax -def predict_and_stats(dmd,test_data,reseed): - pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict(test_data,reseed=reseed,full_return=True) - if hasattr(pred,"cpu"): + +def predict_and_stats(dmd, test_data, reseed): + pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict( + test_data, reseed=reseed, full_return=True + ) + if hasattr(pred, "cpu"): pred = pred.cpu() - if hasattr(H_test_pred,"cpu"): + if hasattr(H_test_pred, "cpu"): H_test_pred = H_test_pred.cpu() - if hasattr(H_test_true,"cpu"): + if hasattr(H_test_true, "cpu"): H_test_true = H_test_true.cpu() - if hasattr(V_test_pred,"cpu"): + if hasattr(V_test_pred, "cpu"): V_test_pred = V_test_pred.cpu() - if hasattr(V_test_true,"cpu"): + if hasattr(V_test_true, "cpu"): V_test_true = V_test_true.cpu() - if isinstance(pred,list): - pred = np.concatenate(pred,axis=0) - test_data = np.concatenate(test_data,axis=0) + if isinstance(pred, list): + pred = np.concatenate(pred, axis=0) + test_data = np.concatenate(test_data, axis=0) xstats = compute_all_stats(test_data, pred, dmd.rank) hstats = compute_all_stats(H_test_true, H_test_pred, dmd.rank) vstats = compute_all_stats(V_test_true, V_test_pred, dmd.rank) return xstats, hstats, vstats -def sweep_ranks_delays_all_error_types(data,n_delays,ranks,train_frac=0.8,reseeds=5, - return_type:Literal['tuple','dict']='dict',**dmd_kwargs): + +def sweep_ranks_delays_all_error_types( + data, + n_delays, + ranks, + train_frac=0.8, + reseeds=5, + return_type: Literal["tuple", "dict"] = "dict", + **dmd_kwargs, +): """ Sweep over combinations of DMD ranks and delays, returning all error types (AIC, MASE, MSE in X space, H space, V space, with and without reseeds) Will also compute non-normality of the DMD matrix. @@ -250,79 +277,104 @@ def sweep_ranks_delays_all_error_types(data,n_delays,ranks,train_frac=0.8,reseed Returns ------- - + Arrays of results for each (delay, rank) pair. """ - train_data, test_data, dim = split_train_test(data,train_frac) + train_data, test_data, dim = split_train_test(data, train_frac) - if not isinstance(reseeds,list) and reseeds in set([1,'none',None,'',0]): + if not isinstance(reseeds, list) and reseeds in set([1, "none", None, "", 0]): reseeds = [1] - elif isinstance(reseeds,int): + elif isinstance(reseeds, int): reseeds = [1, reseeds] if 1 not in reseeds: reseeds = [1] + reseeds def init_arr(d=3): if d == 3: - arr = np.zeros((len(reseeds),len(n_delays),len(ranks))) + arr = np.zeros((len(reseeds), len(n_delays), len(ranks))) elif d == 2: - arr = np.zeros((len(n_delays),len(ranks))) + arr = np.zeros((len(n_delays), len(ranks))) arr[:] = np.nan return arr - all_aicsx_reseed, all_masesx_reseed,all_msesx_reseed = init_arr(), init_arr(), init_arr() - all_aicsh_reseed, all_masesh_reseed,all_msesh_reseed = init_arr(), init_arr(), init_arr() - all_aicsv_reseed, all_masesv_reseed,all_msesv_reseed = init_arr(), init_arr(), init_arr() + all_aicsx_reseed, all_masesx_reseed, all_msesx_reseed = ( + init_arr(), + init_arr(), + init_arr(), + ) + all_aicsh_reseed, all_masesh_reseed, all_msesh_reseed = ( + init_arr(), + init_arr(), + init_arr(), + ) + all_aicsv_reseed, all_masesv_reseed, all_msesv_reseed = ( + init_arr(), + init_arr(), + init_arr(), + ) - for i,nd in tqdm(enumerate(n_delays)): - for j,r in enumerate(ranks): + for i, nd in tqdm(enumerate(n_delays)): + for j, r in enumerate(ranks): if r is None or r > nd * dim: continue - dmd = DMD(train_data,n_delays=nd,rank=r,**dmd_kwargs) + dmd = DMD(train_data, n_delays=nd, rank=r, **dmd_kwargs) dmd.fit() - for k,reseed in enumerate(reseeds): - xstats, hstats, vstats = predict_and_stats(dmd,test_data,reseed) - all_aicsx_reseed[k,i,j] = xstats["AIC"] - all_masesx_reseed[k,i,j] = xstats["MASE"] - all_msesx_reseed[k,i,j] = xstats["MSE"] - - all_aicsh_reseed[k,i,j] = hstats["AIC"] - all_masesh_reseed[k,i,j] = hstats["MASE"] - all_msesh_reseed[k,i,j] = hstats["MSE"] - - all_aicsv_reseed[k,i,j] = vstats["AIC"] - all_masesv_reseed[k,i,j] = vstats["MASE"] - all_msesv_reseed[k,i,j] = vstats["MSE"] - - if return_type == 'tuple': - return all_aicsx_reseed, all_masesx_reseed,all_msesx_reseed, all_aicsh_reseed, all_masesh_reseed,all_msesh_reseed, all_aicsv_reseed, all_masesv_reseed,all_msesv_reseed - elif return_type == 'dict': - return {'reseeds':reseeds, - 'aicsx_reseed':all_aicsx_reseed, - 'masesx_reseed':all_masesx_reseed, - 'msesx_reseed':all_msesx_reseed, - 'aicsh_reseed':all_aicsh_reseed, - 'masesh_reseed':all_masesh_reseed, - 'msesh_reseed':all_msesh_reseed, - 'aicsv_reseed':all_aicsv_reseed, - 'masesv_reseed':all_masesv_reseed, - 'msesv_reseed':all_msesv_reseed, - 'n_delays':n_delays, - 'ranks':ranks} + for k, reseed in enumerate(reseeds): + xstats, hstats, vstats = predict_and_stats(dmd, test_data, reseed) + all_aicsx_reseed[k, i, j] = xstats["AIC"] + all_masesx_reseed[k, i, j] = xstats["MASE"] + all_msesx_reseed[k, i, j] = xstats["MSE"] + + all_aicsh_reseed[k, i, j] = hstats["AIC"] + all_masesh_reseed[k, i, j] = hstats["MASE"] + all_msesh_reseed[k, i, j] = hstats["MSE"] + + all_aicsv_reseed[k, i, j] = vstats["AIC"] + all_masesv_reseed[k, i, j] = vstats["MASE"] + all_msesv_reseed[k, i, j] = vstats["MSE"] + + if return_type == "tuple": + return ( + all_aicsx_reseed, + all_masesx_reseed, + all_msesx_reseed, + all_aicsh_reseed, + all_masesh_reseed, + all_msesh_reseed, + all_aicsv_reseed, + all_masesv_reseed, + all_msesv_reseed, + ) + elif return_type == "dict": + return { + "reseeds": reseeds, + "aicsx_reseed": all_aicsx_reseed, + "masesx_reseed": all_masesx_reseed, + "msesx_reseed": all_msesx_reseed, + "aicsh_reseed": all_aicsh_reseed, + "masesh_reseed": all_masesh_reseed, + "msesh_reseed": all_msesh_reseed, + "aicsv_reseed": all_aicsv_reseed, + "masesv_reseed": all_masesv_reseed, + "msesv_reseed": all_msesv_reseed, + "n_delays": n_delays, + "ranks": ranks, + } + def plot_sweep_results_all_error_types( return_dict, name=None, save_path=None, figsize=(2, 4), - xscale='log', - aic_scale='symlog', - mase_scale = 'log', + xscale="log", + aic_scale="symlog", + mase_scale="log", plot_herror=False, new_plot_reseeds=False, cmap="gist_gray", - metrics_order=['AIC','MASE','MSE'], - pretty_yticks=False + metrics_order=["AIC", "MASE", "MSE"], + pretty_yticks=False, ): """ Plot all error types from sweep_ranks_delays_all_error_types as a 3 x (3*len(reseeds)) grid, @@ -343,70 +395,82 @@ def plot_sweep_results_all_error_types( If 'by_metric', columns are [aics[0], aics[1], ..., mases[0], mases[1], ..., mses[0], mses[1], ...] (grouped by metric). plot_herror : bool new_plot_reseeds : bool - If True, plot the reseeds in a new plot, with the same number of columns + If True, plot the reseeds in a new plot, with the same number of columns """ fig_axes = [] if new_plot_reseeds: return_dict_new = {} return_dict_plot = {} - for k,v in return_dict.items(): - if (isinstance(v,np.ndarray) and v.size == 0) or (isinstance(v,list) and len(v) == 0): + for k, v in return_dict.items(): + if (isinstance(v, np.ndarray) and v.size == 0) or ( + isinstance(v, list) and len(v) == 0 + ): return_dict_new[k] = [] return [] - elif k in ['n_delays','ranks']: + elif k in ["n_delays", "ranks"]: return_dict_new[k] = v return_dict_plot[k] = v else: return_dict_new[k] = v[1:] return_dict_plot[k] = v[0:1] - fig_axes = plot_sweep_results_all_error_types(return_dict_new,name=name, - save_path=save_path, - figsize=figsize,xscale=xscale, - aic_scale=aic_scale, - plot_herror=plot_herror, - new_plot_reseeds=new_plot_reseeds, - metrics_order=metrics_order) + fig_axes = plot_sweep_results_all_error_types( + return_dict_new, + name=name, + save_path=save_path, + figsize=figsize, + xscale=xscale, + aic_scale=aic_scale, + plot_herror=plot_herror, + new_plot_reseeds=new_plot_reseeds, + metrics_order=metrics_order, + ) return_dict = return_dict_plot - reseeds = return_dict['reseeds'] - n_delays = return_dict['n_delays'] - ranks = return_dict['ranks'] - all_aicsx_reseed = return_dict['aicsx_reseed'] - all_masesx_reseed = return_dict['masesx_reseed'] - all_msesx_reseed = return_dict['msesx_reseed'] - all_aicsh_reseed = return_dict['aicsh_reseed'] - all_masesh_reseed = return_dict['masesh_reseed'] - all_msesh_reseed = return_dict['msesh_reseed'] - all_aicsv_reseed = return_dict['aicsv_reseed'] - all_masesv_reseed = return_dict['masesv_reseed'] - all_msesv_reseed = return_dict['msesv_reseed'] + reseeds = return_dict["reseeds"] + n_delays = return_dict["n_delays"] + ranks = return_dict["ranks"] + all_aicsx_reseed = return_dict["aicsx_reseed"] + all_masesx_reseed = return_dict["masesx_reseed"] + all_msesx_reseed = return_dict["msesx_reseed"] + all_aicsh_reseed = return_dict["aicsh_reseed"] + all_masesh_reseed = return_dict["masesh_reseed"] + all_msesh_reseed = return_dict["msesh_reseed"] + all_aicsv_reseed = return_dict["aicsv_reseed"] + all_masesv_reseed = return_dict["masesv_reseed"] + all_msesv_reseed = return_dict["msesv_reseed"] n_reseeds = len(reseeds) - metrics = ['AIC', 'MASE', 'MSE'] - spaces = ['X', 'V'] if not plot_herror else ['X', 'H', 'V'] + metrics = ["AIC", "MASE", "MSE"] + spaces = ["X", "V"] if not plot_herror else ["X", "H", "V"] data_arrays = [ - [all_aicsx_reseed, all_aicsv_reseed] + ([all_aicsh_reseed] if plot_herror else []), - [all_masesx_reseed, all_masesv_reseed] + ([all_masesh_reseed] if plot_herror else []), - [all_msesx_reseed, all_msesv_reseed] + ([all_msesh_reseed] if plot_herror else []) + [all_aicsx_reseed, all_aicsv_reseed] + + ([all_aicsh_reseed] if plot_herror else []), + [all_masesx_reseed, all_masesv_reseed] + + ([all_masesh_reseed] if plot_herror else []), + [all_msesx_reseed, all_msesv_reseed] + + ([all_msesh_reseed] if plot_herror else []), ] data_arrays = [data_arrays[metrics.index(metric)] for metric in metrics_order] metrics = metrics_order - - cmap = plt.cm.get_cmap(cmap) if isinstance(cmap,str) else cmap + cmap = plt.cm.get_cmap(cmap) if isinstance(cmap, str) else cmap figs_axes = [] for space_idx, space in enumerate(spaces): # Each plot: rows = metrics, cols = reseeds (transpose from original) fig, axes = plt.subplots( - len(metrics), n_reseeds, figsize=(figsize[0]*n_reseeds, figsize[1]), sharex=True, sharey='row' + len(metrics), + n_reseeds, + figsize=(figsize[0] * n_reseeds, figsize[1]), + sharex=True, + sharey="row", ) if len(reseeds) == 1: if len(metrics) == 1: axes = [axes] else: - axes = axes.reshape(-1,1) + axes = axes.reshape(-1, 1) if len(metrics) == 1: axes = [axes] - + # For storing y-limits for each metric row row_ymins = [np.inf] * len(metrics) row_ymaxs = [-np.inf] * len(metrics) @@ -416,20 +480,33 @@ def plot_sweep_results_all_error_types( ax = axes[metric_idx][reseed_idx] for nd_idx, nd in enumerate(n_delays): y = arr[reseed_idx, nd_idx] - ax.plot(ranks, y, label=f"{nd}", color=cmap(nd_idx / (len(n_delays) + 3))) + ax.plot( + ranks, + y, + label=f"{nd}", + color=cmap(nd_idx / (len(n_delays) + 3)), + ) # Update min/max for this row, ignoring nan valid_y = np.asarray(y) valid_y = valid_y[np.isfinite(valid_y)] if valid_y.size > 0: - row_ymins[metric_idx] = min(row_ymins[metric_idx], np.nanmin(valid_y)) - row_ymaxs[metric_idx] = max(row_ymaxs[metric_idx], np.nanmax(valid_y)) + row_ymins[metric_idx] = min( + row_ymins[metric_idx], np.nanmin(valid_y) + ) + row_ymaxs[metric_idx] = max( + row_ymaxs[metric_idx], np.nanmax(valid_y) + ) if metric == "MASE": ax.axhline(1, color="black", linestyle="--", linewidth=0.7) - if metric in {"MASE", "MSE"} and mase_scale in {'symlog','log','linear'}: + if metric in {"MASE", "MSE"} and mase_scale in { + "symlog", + "log", + "linear", + }: ax.set_yscale(mase_scale) - if aic_scale in {'symlog','log','linear'} and metric == "AIC": + if aic_scale in {"symlog", "log", "linear"} and metric == "AIC": ax.set_yscale(aic_scale) - if xscale == 'log': + if xscale == "log": ax.set_xscale("log") if reseed_idx == 0: ax.set_ylabel(f"{space} {metric}", fontsize=10) @@ -442,13 +519,27 @@ def plot_sweep_results_all_error_types( ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) axes[-1][reseed_idx].set_xlabel("Rank") - if metric_idx == 0 and reseed_idx == len(reseeds)-1: - ax.legend(title='# delays', fontsize=12, loc='upper right', bbox_to_anchor=(2.3, 1.2), borderaxespad=1) + if metric_idx == 0 and reseed_idx == len(reseeds) - 1: + ax.legend( + title="# delays", + fontsize=12, + loc="upper right", + bbox_to_anchor=(2.3, 1.2), + borderaxespad=1, + ) # Set yticks for each row to be the min and max (rounded) of all the plots on that row for metric_idx in range(len(metrics)): - ymin = 0.75*row_ymins[metric_idx] if row_ymins[metric_idx] > 0 else 1.25*row_ymins[metric_idx] - ymax = 1.25*row_ymaxs[metric_idx] if row_ymaxs[metric_idx] > 0 else 0.75*row_ymaxs[metric_idx] + ymin = ( + 0.75 * row_ymins[metric_idx] + if row_ymins[metric_idx] > 0 + else 1.25 * row_ymins[metric_idx] + ) + ymax = ( + 1.25 * row_ymaxs[metric_idx] + if row_ymaxs[metric_idx] > 0 + else 0.75 * row_ymaxs[metric_idx] + ) for reseed_idx in range(n_reseeds): ax = axes[metric_idx][reseed_idx] # Remove all yticks and labels before setting new ones @@ -466,11 +557,13 @@ def plot_sweep_results_all_error_types( ticklabels = [f"{ymin:.2g}", f"{ymax:.2g}"] ax.set_yticklabels(ticklabels) - plt.suptitle(f"{name + '_' if name else ''}{space} tuning", fontsize=14,y=1.05) - plt.tight_layout() #rect=[0, 0, 1, 0.97]) + plt.suptitle(f"{name + '_' if name else ''}{space} tuning", fontsize=14, y=1.05) + plt.tight_layout() # rect=[0, 0, 1, 0.97]) if save_path is not None: - plt.savefig(f"{save_path}_{space}_metrics_{metrics_order}_reseeds{reseeds}.pdf") + plt.savefig( + f"{save_path}_{space}_metrics_{metrics_order}_reseeds{reseeds}.pdf" + ) # plt.close() figs_axes.append((fig, axes)) - return figs_axes + fig_axes \ No newline at end of file + return figs_axes + fig_axes diff --git a/setup.py b/setup.py index 0e1eff1..9d8f9e0 100644 --- a/setup.py +++ b/setup.py @@ -2,24 +2,18 @@ setuptools.setup( name="dsa-metric", - version="1.0.2", + version="2.0.0", url="https://github.com/mitchellostrow/DSA", - author="Mitchell Ostrow", author_email="ostrow@mit.edu", - description="Dynamical Similarity Analysis", packages=setuptools.find_packages(), install_requires=[ - 'numpy>=1.24.0,<2', - 'torch>=1.3.0', - 'kooplearn>=1.1.0', - 'pot', - 'omegaconf', + "numpy>=1.24.0,<2", + "torch>=1.3.0", + "pot", + "omegaconf", + "pydmd", ], - extras_require={ - 'dev': [ - 'pytest>=3.7' - ] - }, + extras_require={"dev": ["pytest>=3.7"]}, ) diff --git a/tests/dmd_test.py b/tests/dmd_test.py index 0c38a41..d1c28b5 100644 --- a/tests/dmd_test.py +++ b/tests/dmd_test.py @@ -3,99 +3,105 @@ from DSA.dmd import DMD, embed_signal_torch from scipy.stats import ortho_group import torch + TOL = 1e-2 -@pytest.mark.parametrize('delay_interval', [1,2]) -@pytest.mark.parametrize('n_delays', [20]) -@pytest.mark.parametrize('c', [10]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('seed', [21]) -def test_embed_3dvs2d(seed,t,c,n_delays,delay_interval): - #test to make sure 3d and 2d are effectively doing the same thing + +@pytest.mark.parametrize("delay_interval", [1, 2]) +@pytest.mark.parametrize("n_delays", [20]) +@pytest.mark.parametrize("c", [10]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("seed", [21]) +def test_embed_3dvs2d(seed, t, c, n_delays, delay_interval): + # test to make sure 3d and 2d are effectively doing the same thing n = 3 - rng = np.random.default_rng(seed) - data = torch.from_numpy(rng.random((n,t,c))) - embed1 = embed_signal_torch(data,n_delays,delay_interval) - embed2s = [embed_signal_torch(data[i],n_delays,delay_interval) for i in range(n)] - assert np.allclose(embed1[0],embed2s[0],atol=TOL) - assert np.allclose(embed1[1],embed2s[1],atol=TOL) - assert np.allclose(embed1[2],embed2s[2],atol=TOL) + rng = np.random.default_rng(seed) + data = torch.from_numpy(rng.random((n, t, c))) + embed1 = embed_signal_torch(data, n_delays, delay_interval) + embed2s = [embed_signal_torch(data[i], n_delays, delay_interval) for i in range(n)] + assert np.allclose(embed1[0], embed2s[0], atol=TOL) + assert np.allclose(embed1[1], embed2s[1], atol=TOL) + assert np.allclose(embed1[2], embed2s[2], atol=TOL) -@pytest.mark.parametrize('c', [10]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('n', [50]) -@pytest.mark.parametrize('seed', [21]) -def test_embed_1delay(seed,n,t,c): - rng = np.random.default_rng(seed) - data = torch.from_numpy(rng.random((n,t,c))) - embed = embed_signal_torch(data,1) - embed1 = embed_signal_torch(data[0],1) - dmd = DMD(data,1) + +@pytest.mark.parametrize("c", [10]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("n", [50]) +@pytest.mark.parametrize("seed", [21]) +def test_embed_1delay(seed, n, t, c): + rng = np.random.default_rng(seed) + data = torch.from_numpy(rng.random((n, t, c))) + embed = embed_signal_torch(data, 1) + embed1 = embed_signal_torch(data[0], 1) + dmd = DMD(data, 1) dmd.compute_hankel() - assert np.allclose(embed,data,atol=TOL) - assert np.allclose(dmd.H,data,atol=TOL) - assert np.allclose(embed1,data[0],atol=TOL) + assert np.allclose(embed, data, atol=TOL) + assert np.allclose(dmd.H, data, atol=TOL) + assert np.allclose(embed1, data[0], atol=TOL) + -@pytest.mark.parametrize('rank', [10,50,250]) -@pytest.mark.parametrize('n_delays', [1,20]) -@pytest.mark.parametrize('c', [10]) -@pytest.mark.parametrize('t', [500]) -@pytest.mark.parametrize('n', [50]) -@pytest.mark.parametrize('seed', [21]) -def test_dmd_rank(seed,n,t,c,n_delays,rank): - rng = np.random.default_rng(seed) - X = rng.random((n,t,c)) - dmd = DMD(X,n_delays,rank=rank) +@pytest.mark.parametrize("rank", [10, 50, 250]) +@pytest.mark.parametrize("n_delays", [1, 20]) +@pytest.mark.parametrize("c", [10]) +@pytest.mark.parametrize("t", [500]) +@pytest.mark.parametrize("n", [50]) +@pytest.mark.parametrize("seed", [21]) +def test_dmd_rank(seed, n, t, c, n_delays, rank): + rng = np.random.default_rng(seed) + X = rng.random((n, t, c)) + dmd = DMD(X, n_delays, rank=rank) dmd.fit() - rank = min(rank,n_delays*c) - assert dmd.A_v.shape == (rank,rank) + rank = min(rank, n_delays * c) + assert dmd.A_v.shape == (rank, rank) + -@pytest.mark.parametrize('tau', [0.01]) -@pytest.mark.parametrize('t', [1000]) -@pytest.mark.parametrize('c', [5]) -@pytest.mark.parametrize('seed', [21]) -def test_dmd_2d(seed,c,t,tau): +@pytest.mark.parametrize("tau", [0.01]) +@pytest.mark.parametrize("t", [1000]) +@pytest.mark.parametrize("c", [5]) +@pytest.mark.parametrize("seed", [21]) +def test_dmd_2d(seed, c, t, tau): rng = np.random.default_rng(seed) x0 = rng.random((c)) - data = np.zeros((t,c)) + data = np.zeros((t, c)) data[0] = x0 Q = ortho_group.rvs(c) - A = np.eye(c) + tau*Q #\dot{x} = Qx -> x_t+1 ~= x + \tauQx - for i in range(1,t): - data[i] = A @ data[i-1] - dmd = DMD(data,1) + A = np.eye(c) + tau * Q # \dot{x} = Qx -> x_t+1 ~= x + \tauQx + for i in range(1, t): + data[i] = A @ data[i - 1] + dmd = DMD(data, 1) dmd.fit() assert np.linalg.norm(dmd.A_v.flatten() - A.flatten()) < 1e-1 -@pytest.mark.parametrize('n', [500]) -@pytest.mark.parametrize('t', [1000]) -@pytest.mark.parametrize('c', [3]) -@pytest.mark.parametrize('tau', [0.01]) -@pytest.mark.parametrize('seed', [21]) -def test_dmd_3d(seed,n,t,c,tau): + +@pytest.mark.parametrize("n", [500]) +@pytest.mark.parametrize("t", [1000]) +@pytest.mark.parametrize("c", [3]) +@pytest.mark.parametrize("tau", [0.01]) +@pytest.mark.parametrize("seed", [21]) +def test_dmd_3d(seed, n, t, c, tau): rng = np.random.default_rng(seed) - x0 = rng.random((n,c)) - data = np.zeros((n,t,c)) - data[:,0] = x0 + x0 = rng.random((n, c)) + data = np.zeros((n, t, c)) + data[:, 0] = x0 Q = ortho_group.rvs(c) - A = np.eye(c) + tau*Q - #\dot{x} = Qx -> x_t+1 ~= x + \tauQx - for i in range(1,t): - data[:,i] = np.einsum('nn,cn->cn',A,data[:,i-1]) - dmd = DMD(data,1) + A = np.eye(c) + tau * Q + # \dot{x} = Qx -> x_t+1 ~= x + \tauQx + for i in range(1, t): + data[:, i] = np.einsum("nn,cn->cn", A, data[:, i - 1]) + dmd = DMD(data, 1) dmd.fit() - assert np.linalg.norm(dmd.A_v.flatten()-A.flatten()) < 1e-1 + assert np.linalg.norm(dmd.A_v.flatten() - A.flatten()) < 1e-1 -@pytest.mark.parametrize('c', [10]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('n', [50]) -@pytest.mark.parametrize('seed', [21]) -def test_to_cpu(seed,n,t,c): - rng = np.random.default_rng(seed) - X = rng.random((n,t,c)) - device = 'cuda' if torch.cuda.is_available() else 'cpu' - dmd = DMD(X,1,device=device) +@pytest.mark.parametrize("c", [10]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("n", [50]) +@pytest.mark.parametrize("seed", [21]) +def test_to_cpu(seed, n, t, c): + rng = np.random.default_rng(seed) + X = rng.random((n, t, c)) + device = "cuda" if torch.cuda.is_available() else "cpu" + dmd = DMD(X, 1, device=device) dmd.fit(send_to_cpu=True) - assert dmd.A_v.device.type == 'cpu' - assert dmd.H.device.type == 'cpu' + assert dmd.A_v.device.type == "cpu" + assert dmd.H.device.type == "cpu" diff --git a/tests/dsa_test.py b/tests/dsa_test.py index ec05bea..74c1ea2 100644 --- a/tests/dsa_test.py +++ b/tests/dsa_test.py @@ -3,131 +3,142 @@ from DSA import DSA from scipy.stats import ortho_group -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('n1', [2]) -@pytest.mark.parametrize('n2', [10]) -@pytest.mark.parametrize('t1', [1000]) -@pytest.mark.parametrize('t2', [1000]) -@pytest.mark.parametrize('c1', [5]) -@pytest.mark.parametrize('c2', [10]) #only these really need to be different -@pytest.mark.parametrize('rank1', [5]) -@pytest.mark.parametrize('rank2', [5,10]) -def test_different_dims(seed,n1,n2,t1,t2,c1,c2,rank1,rank2): - rng = np.random.default_rng(seed) - X = rng.random((n1,t1,c1)) - Y = rng.random((n2,t2,c2)) - dsa = DSA(X,Y,rank=(rank1,rank2),n_delays=10) + +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize("n1", [2]) +@pytest.mark.parametrize("n2", [10]) +@pytest.mark.parametrize("t1", [1000]) +@pytest.mark.parametrize("t2", [1000]) +@pytest.mark.parametrize("c1", [5]) +@pytest.mark.parametrize("c2", [10]) # only these really need to be different +@pytest.mark.parametrize("rank1", [5]) +@pytest.mark.parametrize("rank2", [5, 10]) +def test_different_dims(seed, n1, n2, t1, t2, c1, c2, rank1, rank2): + rng = np.random.default_rng(seed) + X = rng.random((n1, t1, c1)) + Y = rng.random((n2, t2, c2)) + dsa = DSA(X, Y, rank=(rank1, rank2), n_delays=10) sim = dsa.fit_score() - assert dsa.dmds[0][0].A_v.shape == (rank1,rank1) - assert dsa.dmds[1][0].A_v.shape == (rank2,rank2) - -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('n_delays', [10,[[10,20,30],[5,10,15]]]) #only need to test 1 param -def test_param_broadcasting_1(seed,n_delays): - rng = np.random.default_rng(seed) - d1 = rng.random((100,50,10)) - dsa = DSA(d1,d1,n_delays=n_delays) - if isinstance(n_delays,list): + assert dsa.dmds[0][0].A_v.shape == (rank1, rank1) + assert dsa.dmds[1][0].A_v.shape == (rank2, rank2) + + +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize( + "n_delays", [10, [[10, 20, 30], [5, 10, 15]]] +) # only need to test 1 param +def test_param_broadcasting_1(seed, n_delays): + rng = np.random.default_rng(seed) + d1 = rng.random((100, 50, 10)) + dsa = DSA(d1, d1, n_delays=n_delays) + if isinstance(n_delays, list): delay1 = n_delays[0][0] delay2 = n_delays[1][0] else: - delay1,delay2 = n_delays,n_delays + delay1, delay2 = n_delays, n_delays assert dsa.dmds[0][0].n_delays == delay1 assert dsa.dmds[1][0].n_delays == delay2 assert len(dsa.dmds) == 2 assert len(dsa.dmds[0]) == 1 -@pytest.mark.parametrize('n', [2,5]) -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('n_delays', [10,[10,20,30,40,50]]) -def test_param_broadcasting_list(seed,n,n_delays): - rng = np.random.default_rng(seed) - ds = [rng.random((100,50,10)) for i in range(n)] - dsa = DSA(ds,n_delays=n_delays) + +@pytest.mark.parametrize("n", [2, 5]) +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize("n_delays", [10, [10, 20, 30, 40, 50]]) +def test_param_broadcasting_list(seed, n, n_delays): + rng = np.random.default_rng(seed) + ds = [rng.random((100, 50, 10)) for i in range(n)] + dsa = DSA(ds, n_delays=n_delays) for i in range(n): - if isinstance(n_delays,int): + if isinstance(n_delays, int): assert dsa.dmds[0][i].n_delays == n_delays else: assert dsa.dmds[0][i].n_delays == n_delays[i] assert len(dsa.dmds[0]) == n -@pytest.mark.parametrize('n1', [2,5]) -@pytest.mark.parametrize('n2', [3,4]) -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('n_delays1', [10,[10,20,30,40,50]]) -@pytest.mark.parametrize('n_delays2', [11,[11,21,31,41,51]]) -def test_param_broadcasting_2lists(seed,n1,n2,n_delays1,n_delays2): - rng = np.random.default_rng(seed) - ds1 = [rng.random((100,50,10)) for i in range(n1)] - ds2 = [rng.random((100,50,10)) for i in range(n2)] - dsa = DSA(ds1,ds2,n_delays=(n_delays1,n_delays2)) - itrable = zip([n1,n2],[n_delays1,n_delays2]) - for j,(n,delays) in enumerate(itrable): + +@pytest.mark.parametrize("n1", [2, 5]) +@pytest.mark.parametrize("n2", [3, 4]) +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize("n_delays1", [10, [10, 20, 30, 40, 50]]) +@pytest.mark.parametrize("n_delays2", [11, [11, 21, 31, 41, 51]]) +def test_param_broadcasting_2lists(seed, n1, n2, n_delays1, n_delays2): + rng = np.random.default_rng(seed) + ds1 = [rng.random((100, 50, 10)) for i in range(n1)] + ds2 = [rng.random((100, 50, 10)) for i in range(n2)] + dsa = DSA(ds1, ds2, n_delays=(n_delays1, n_delays2)) + itrable = zip([n1, n2], [n_delays1, n_delays2]) + for j, (n, delays) in enumerate(itrable): for i in range(n): - if isinstance(delays,int): + if isinstance(delays, int): assert dsa.dmds[j][i].n_delays == delays else: assert dsa.dmds[j][i].n_delays == delays[i] assert len(dsa.dmds[0]) == n1 assert len(dsa.dmds[1]) == n2 + # def test_multiple_param_variations(seed,n,n_delays,rank): -# rng = np.random.default_rng(seed) +# rng = np.random.default_rng(seed) # ds = [rng.random((100,50,10)) for i in range(n)] # dsa = DSA(ds,n_delays=n_delays) - -@pytest.mark.parametrize('n', [10]) -@pytest.mark.parametrize('c', [2]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('seed', [5]) -def test_dsa_1to1(n,t,c,seed): - rng = np.random.default_rng(seed) - X = rng.random((n,t,c)) - Y = rng.random((n,t,c)) - dsa = DSA(X,Y) + + +@pytest.mark.parametrize("n", [10]) +@pytest.mark.parametrize("c", [2]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("seed", [5]) +def test_dsa_1to1(n, t, c, seed): + rng = np.random.default_rng(seed) + X = rng.random((n, t, c)) + Y = rng.random((n, t, c)) + dsa = DSA(X, Y) sim = dsa.fit_score() - assert isinstance(sim,float) - -@pytest.mark.parametrize('n', [10]) -@pytest.mark.parametrize('c', [2]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('nmodels', [10]) -def test_dsa_1tomany(n,t,c,seed,nmodels): - rng = np.random.default_rng(seed) - X = [rng.random((n,t,c)) for i in range(nmodels)] - Y = rng.random((n,t,c)) - dsa = DSA(X,Y) + assert isinstance(sim, float) + + +@pytest.mark.parametrize("n", [10]) +@pytest.mark.parametrize("c", [2]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize("nmodels", [10]) +def test_dsa_1tomany(n, t, c, seed, nmodels): + rng = np.random.default_rng(seed) + X = [rng.random((n, t, c)) for i in range(nmodels)] + Y = rng.random((n, t, c)) + dsa = DSA(X, Y) sim = dsa.fit_score() - assert isinstance(sim,np.ndarray) - assert sim.shape == (nmodels,1) - -@pytest.mark.parametrize('n', [10]) -@pytest.mark.parametrize('c', [2]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('nmodels', [10]) -def test_dsa_manyto1(n,t,c,seed,nmodels): - rng = np.random.default_rng(seed) - X = [rng.random((n,t,c)) for i in range(nmodels)] - Y = rng.random((n,t,c)) - dsa = DSA(Y,X) + assert isinstance(sim, np.ndarray) + assert sim.shape == (nmodels, 1) + + +@pytest.mark.parametrize("n", [10]) +@pytest.mark.parametrize("c", [2]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize("nmodels", [10]) +def test_dsa_manyto1(n, t, c, seed, nmodels): + rng = np.random.default_rng(seed) + X = [rng.random((n, t, c)) for i in range(nmodels)] + Y = rng.random((n, t, c)) + dsa = DSA(Y, X) sim = dsa.fit_score() - assert isinstance(sim,np.ndarray) - assert sim.shape == (1,nmodels) - -@pytest.mark.parametrize('n', [10]) -@pytest.mark.parametrize('c', [2]) -@pytest.mark.parametrize('t', [100]) -@pytest.mark.parametrize('seed', [5]) -@pytest.mark.parametrize('nmodels1', [2]) -@pytest.mark.parametrize('nmodels2', [2]) -def test_dsa_manytomany(n,t,c,seed,nmodels1,nmodels2): - rng = np.random.default_rng(seed) - X = [rng.random((n,t,c)) for i in range(nmodels1)] - Y = [rng.random((n,t,c)) for i in range(nmodels2)] - dsa = DSA(X,Y) + assert isinstance(sim, np.ndarray) + assert sim.shape == (1, nmodels) + + +@pytest.mark.parametrize("n", [10]) +@pytest.mark.parametrize("c", [2]) +@pytest.mark.parametrize("t", [100]) +@pytest.mark.parametrize("seed", [5]) +@pytest.mark.parametrize("nmodels1", [2]) +@pytest.mark.parametrize("nmodels2", [2]) +def test_dsa_manytomany(n, t, c, seed, nmodels1, nmodels2): + rng = np.random.default_rng(seed) + X = [rng.random((n, t, c)) for i in range(nmodels1)] + Y = [rng.random((n, t, c)) for i in range(nmodels2)] + dsa = DSA(X, Y) sim = dsa.fit_score() print(sim.shape) - assert isinstance(sim,np.ndarray) - assert sim.shape == (nmodels1,nmodels2) + assert isinstance(sim, np.ndarray) + assert sim.shape == (nmodels1, nmodels2) diff --git a/tests/simdist_test.py b/tests/simdist_test.py index 9647c01..84d4234 100644 --- a/tests/simdist_test.py +++ b/tests/simdist_test.py @@ -1,6 +1,6 @@ import pytest import numpy as np -from DSA.simdist import SimilarityTransformDist,pad_zeros +from DSA.simdist import SimilarityTransformDist, pad_zeros from scipy.stats import special_ortho_group, ortho_group import torch from netrep.utils import whiten @@ -8,91 +8,99 @@ TOL = 1e-3 SIMTOL = 2e-2 -@pytest.mark.parametrize('device',['cpu']) -@pytest.mark.parametrize('preserve_var',[True,False]) -@pytest.mark.parametrize('dtype',['numpy']) -@pytest.mark.parametrize('score_method',['angular','euclidean']) -@pytest.mark.parametrize('n', [10,50,100]) -@pytest.mark.parametrize('group',['GL(n)','O(n)','SO(n)']) -@pytest.mark.parametrize('seed', [5]) -def test_simdist_convergent(seed,n,score_method,dtype,preserve_var,group,device): - rng = np.random.default_rng(seed) - X = rng.random(size=(n,n)) - if group == 'SO(n)': - Q = special_ortho_group(seed=rng,dim=n).rvs() + +@pytest.mark.parametrize("device", ["cpu"]) +@pytest.mark.parametrize("preserve_var", [True, False]) +@pytest.mark.parametrize("dtype", ["numpy"]) +@pytest.mark.parametrize("score_method", ["angular", "euclidean"]) +@pytest.mark.parametrize("n", [10, 50, 100]) +@pytest.mark.parametrize("group", ["GL(n)", "O(n)", "SO(n)"]) +@pytest.mark.parametrize("seed", [5]) +def test_simdist_convergent(seed, n, score_method, dtype, preserve_var, group, device): + rng = np.random.default_rng(seed) + X = rng.random(size=(n, n)) + if group == "SO(n)": + Q = special_ortho_group(seed=rng, dim=n).rvs() Y = Q @ X @ Q.T iters = 5000 - elif group == 'O(n)': - Q = ortho_group(seed=rng,dim=n).rvs() + elif group == "O(n)": + Q = ortho_group(seed=rng, dim=n).rvs() while np.linalg.det(Q) > 0: - Q = ortho_group(seed=rng,dim=n).rvs() + Q = ortho_group(seed=rng, dim=n).rvs() Y = Q @ X @ Q.T iters = 5000 - elif group == 'GL(n)': - #draw random invertible matrix - Q = rng.random(size=(n,n)) - Q /= np.linalg.norm(Q,axis=0) + elif group == "GL(n)": + # draw random invertible matrix + Q = rng.random(size=(n, n)) + Q /= np.linalg.norm(Q, axis=0) Y = Q @ X @ np.linalg.inv(Q) iters = 80_000 - X,_ = whiten(X,0,preserve_variance=preserve_var) - Y,_ = whiten(Y,0,preserve_variance=preserve_var) - #excessive but we just want to see that it converges - sim = SimilarityTransformDist(lr=1e-2,iters=iters,score_method=score_method,device=device,group=group) - if dtype == 'torch': + X, _ = whiten(X, 0, preserve_variance=preserve_var) + Y, _ = whiten(Y, 0, preserve_variance=preserve_var) + # excessive but we just want to see that it converges + sim = SimilarityTransformDist( + lr=1e-2, iters=iters, score_method=score_method, device=device, group=group + ) + if dtype == "torch": X = torch.tensor(X).float() Y = torch.tensor(Y).float() - score = sim.fit_score(X,Y) + score = sim.fit_score(X, Y) print(score) assert score < SIMTOL -@pytest.mark.parametrize('device',['cpu']) -@pytest.mark.parametrize('dtype',['numpy']) -@pytest.mark.parametrize('score_method',['angular','euclidean']) -@pytest.mark.parametrize('n', [10,50,100]) -@pytest.mark.parametrize('seed', [5]) -def test_transposed_q_same(seed,n,score_method,dtype,device): - rng = np.random.default_rng(seed) - X = rng.random(size=(n,n)) * 2 - 1 - Q = special_ortho_group(seed=rng,dim=n).rvs() + +@pytest.mark.parametrize("device", ["cpu"]) +@pytest.mark.parametrize("dtype", ["numpy"]) +@pytest.mark.parametrize("score_method", ["angular", "euclidean"]) +@pytest.mark.parametrize("n", [10, 50, 100]) +@pytest.mark.parametrize("seed", [5]) +def test_transposed_q_same(seed, n, score_method, dtype, device): + rng = np.random.default_rng(seed) + X = rng.random(size=(n, n)) * 2 - 1 + Q = special_ortho_group(seed=rng, dim=n).rvs() Y1 = Q @ X @ Q.T Y2 = Q.T @ X @ Q - #excessive but we just want to see that it converges - sim = SimilarityTransformDist(lr=5e-3,iters=15000,score_method=score_method,device=device) - if dtype == 'torch': + # excessive but we just want to see that it converges + sim = SimilarityTransformDist( + lr=5e-3, iters=15000, score_method=score_method, device=device + ) + if dtype == "torch": X = torch.tensor(X).float() Y1 = torch.tensor(Y1).float() Y2 = torch.tensor(Y2).float() - score1 = sim.fit_score(X,Y1) - score2 = sim.fit_score(X,Y2) - print(n,score_method,score1) - print(n,score_method,score2) + score1 = sim.fit_score(X, Y1) + score2 = sim.fit_score(X, Y2) + print(n, score_method, score1) + print(n, score_method, score2) assert np.abs(score1 - score2) < SIMTOL -@pytest.mark.parametrize('n2', [10]) -@pytest.mark.parametrize('n1', [50]) -@pytest.mark.parametrize('seed', [5]) -def test_zero_pad(seed,n1,n2): - rng = np.random.default_rng(seed) - X = rng.random(size=(n1,n1)) - Y = rng.random(size=(n2,n2)) - m = max(n1,n2) - sim = SimilarityTransformDist(iters=10) #don't care about fitting - sim.fit_score(X,Y,zero_pad=True) - assert sim.C_star.shape == (m,m) - assert pad_zeros(X,Y,'cpu')[0].shape == (m,m) - assert pad_zeros(X,Y,'cpu')[1].shape == (m,m) -@pytest.mark.parametrize('n', [10]) -@pytest.mark.parametrize('seed', [5]) -def test_ortho_c(seed,n): - rng = np.random.default_rng(seed) - X = rng.random(size=(n,n)) - Q = special_ortho_group(seed=rng,dim=n).rvs() +@pytest.mark.parametrize("n2", [10]) +@pytest.mark.parametrize("n1", [50]) +@pytest.mark.parametrize("seed", [5]) +def test_zero_pad(seed, n1, n2): + rng = np.random.default_rng(seed) + X = rng.random(size=(n1, n1)) + Y = rng.random(size=(n2, n2)) + m = max(n1, n2) + sim = SimilarityTransformDist(iters=10) # don't care about fitting + sim.fit_score(X, Y, zero_pad=True) + assert sim.C_star.shape == (m, m) + assert pad_zeros(X, Y, "cpu")[0].shape == (m, m) + assert pad_zeros(X, Y, "cpu")[1].shape == (m, m) + + +@pytest.mark.parametrize("n", [10]) +@pytest.mark.parametrize("seed", [5]) +def test_ortho_c(seed, n): + rng = np.random.default_rng(seed) + X = rng.random(size=(n, n)) + Q = special_ortho_group(seed=rng, dim=n).rvs() Y = Q @ X @ Q.T - sim = SimilarityTransformDist(lr=1e-2,iters=5000) - score = sim.fit_score(X,Y) + sim = SimilarityTransformDist(lr=1e-2, iters=5000) + score = sim.fit_score(X, Y) C = sim.C_star - assert np.allclose(C.T @ C, np.eye(n),atol=TOL) - assert np.allclose(C @ C.T, np.eye(n),atol=TOL) + assert np.allclose(C.T @ C, np.eye(n), atol=TOL) + assert np.allclose(C @ C.T, np.eye(n), atol=TOL) From 1a9dd034f11af23c338ae7561135aaa1c6fdb48e Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 28 Oct 2025 15:35:27 -0400 Subject: [PATCH 15/51] bug fixes --- DSA/dsa.py | 17 ++++++++++------- DSA/simdist.py | 6 +----- DSA/simdist_controllability.py | 11 ++++------- DSA/subspace_dmdc.py | 5 ++++- README.md | 1 + pyproject.toml | 8 ++++++-- setup.py | 5 +++++ 7 files changed, 31 insertions(+), 22 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index b96eb93..3796065 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -676,10 +676,9 @@ def __init__( dsa_verbose=False, n_jobs=1, # simdist parameters - score_method: Literal["angular", "euclidean"] = "angular", + score_method: Literal["angular", "euclidean","wasserstein"] = "angular", iters: int = 1500, lr: float = 5e-3, - wasserstein_compare: Literal["sv", "eig", None] = "eig", **dmd_kwargs, ): # TODO: add readme @@ -687,7 +686,6 @@ def __init__( "score_method": score_method, "iters": iters, "lr": lr, - "wasserstein_compare": wasserstein_compare, } dmd_config = dmd_kwargs @@ -733,10 +731,7 @@ def __init__( raise ValueError( "unknown data type for simdist-config, use dataclass or dict" ) - if compare == "state": - simdist = SimilarityTransformDist - else: - simdist = ControllabilitySimilarityTransformDist + simdist = self.update_compare_method(compare) super().__init__( X, @@ -754,3 +749,11 @@ def __init__( assert X_control is not None assert self.dmd_has_control + + def update_compare_method(self,compare='joint'): + if compare == "state": + simdist = SimilarityTransformDist + else: + simdist = ControllabilitySimilarityTransformDist + return simdist + diff --git a/DSA/simdist.py b/DSA/simdist.py index 37dc9e6..8685b58 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -175,6 +175,7 @@ def __init__( self.B = None self.eps = eps self.rescale_wasserstein = rescale_wasserstein + self.wasserstein_compare = 'eig' # for backwards compatibility def fit( self, @@ -216,11 +217,6 @@ def fit( self.A, self.B = A, B lr = self.lr if lr is None else lr iters = self.iters if iters is None else iters - wasserstein_compare = ( - self.wasserstein_compare - if wasserstein_compare is None - else wasserstein_compare - ) score_method = self.score_method if score_method is None else score_method if score_method == "wasserstein": diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 1e270e7..778384f 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -61,13 +61,10 @@ def compute_angular_dist(A, B): def fit_score(self, A, B, A_control, B_control): - C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( - A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim - ) - - score_method = self.score_method - if self.compare == "joint": + C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( + A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim + ) if self.return_distance_components: if self.score_method == "euclidean": # sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") ** 2 @@ -98,7 +95,7 @@ def fit_score(self, A, B, A_control, B_control): ) else: - return self.compare_B(A_control, B_control, score_method=score_method) + return self.compare_B(A_control, B_control, score_method=self.score_method) def get_controllability_matrix(self, A, B): """ diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index 6408212..33115e9 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -1,4 +1,7 @@ -"""This module computes the subspace DMD with control (DMDc) model for a given dataset.""" +""" +This module computes the subspace DMD with control (DMDc) model for a given dataset. +Code is partially derived from and inspired by https://github.com/spmvg/nfoursid/tree/master +""" import numpy as np import torch diff --git a/README.md b/README.md index 4431f35..27b72fb 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,7 @@ In control problems and basic scientific modeling, it is important to compare ob on dynamical systems Code Authors: Mitchell Ostrow, Adam Eisen, Leo Kozachkov, Ann Huang +Formatted using the Black Style (https://black.readthedocs.io/en/stable/) If you use this code, please cite: ``` diff --git a/pyproject.toml b/pyproject.toml index 6a7186b..80efcc7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "dsa-metric" -version = "1.0.2" +version = "2.0.0" authors = [ { name="Mitchell Ostrow", email="ostrow@mit.edu" }, ] @@ -17,9 +17,13 @@ license-files = ["LICENSE*"] dependencies = [ "numpy>=1.24.0,<2", "torch>=1.3.0", - "kooplearn>=1.1.0", "pot", "omegaconf", + "pydmd", + "tqdm", + "optht", + "derivative", + "lightning" ] [project.optional-dependencies] diff --git a/setup.py b/setup.py index 9d8f9e0..92f9891 100644 --- a/setup.py +++ b/setup.py @@ -14,6 +14,11 @@ "pot", "omegaconf", "pydmd", + "tqdm", + "optht", #for havok in pykoopman + "derivative", #for pykoopman + "lightning" #for nndmd in pykoopman + "prettytable" ], extras_require={"dev": ["pytest>=3.7"]}, ) From 9732614237d3938aa03dc3ea36a2b88083859dd3 Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 29 Oct 2025 17:41:15 -0400 Subject: [PATCH 16/51] fix torch and device things --- DSA/base_dmd.py | 64 ++++ DSA/dmd.py | 8 +- DSA/dmdc.py | 8 +- DSA/dsa.py | 34 +- DSA/simdist.py | 3 +- DSA/subspace_dmdc.py | 851 +++++++++++++++++++++---------------------- 6 files changed, 519 insertions(+), 449 deletions(-) diff --git a/DSA/base_dmd.py b/DSA/base_dmd.py index b3c4716..781fba0 100644 --- a/DSA/base_dmd.py +++ b/DSA/base_dmd.py @@ -2,6 +2,7 @@ import numpy as np import torch +import warnings from abc import ABC, abstractmethod @@ -20,6 +21,7 @@ def __init__( ---------- device: string, int, or torch.device A string, int or torch.device object to indicate the device to torch. + If 'cuda' or 'cuda:X' is specified but not available, will fall back to 'cpu' with a warning. verbose: bool If True, print statements will be provided about the progress of the fitting procedure. send_to_cpu: bool @@ -41,6 +43,68 @@ def __init__( # SVD attributes - will be set by subclasses self.cumulative_explained_variance = None + + def _setup_device(self, device='cpu', use_torch=None): + """ + Smart device setup with graceful fallback and auto-detection. + + Parameters + ---------- + device : str or torch.device + Requested device ('cpu', 'cuda', 'cuda:0', etc.) + use_torch : bool or None + Whether to use PyTorch. If None, auto-detected: + - True if device contains 'cuda' + - False otherwise (numpy is faster on CPU) + + Returns + ------- + tuple + (device, use_torch) - validated device and use_torch flag + """ + # Convert device to string for checking + device_str = str(device).lower() + + # Auto-detect use_torch if not specified + if use_torch is None: + use_torch = 'cuda' in device_str + + # If CUDA requested, check availability + if 'cuda' in device_str: + if not torch.cuda.is_available(): + warnings.warn( + f"CUDA device '{device}' requested but CUDA is not available. " + "Falling back to CPU with NumPy. " + "To use GPU acceleration, ensure PyTorch with CUDA support is installed.", + RuntimeWarning, + stacklevel=3 + ) + device = 'cpu' + use_torch = False # Use numpy on CPU for better performance + else: + # CUDA is available, verify the specific device exists + try: + test_device = torch.device(device) + # Test if we can actually use this device + torch.tensor([1.0], device=test_device) + use_torch = True + except (RuntimeError, AssertionError) as e: + warnings.warn( + f"CUDA device '{device}' requested but not accessible: {e}. " + f"Falling back to CPU with NumPy.", + RuntimeWarning, + stacklevel=3 + ) + device = 'cpu' + use_torch = False + + # Convert to torch.device if using torch + if use_torch: + device = torch.device(device) + else: + device = None # Use numpy (no torch device needed) + + return device, use_torch def _process_single_dataset(self, data): """Process a single dataset, handling numpy arrays, tensors, and lists.""" diff --git a/DSA/dmd.py b/DSA/dmd.py index d2b7b4b..6746d67 100644 --- a/DSA/dmd.py +++ b/DSA/dmd.py @@ -130,7 +130,9 @@ def __init__( Regularization parameter for ridge regression. Defaults to 0. device: string, int, or torch.device - A string, int or torch.device object to indicate the device to torch. + Device for computation. Options: + - 'cpu': Use CPU with PyTorch + - 'cuda' or 'cuda:X': Use GPU (auto-falls back to CPU if unavailable) verbose: bool If True, print statements will be provided about the progress of the fitting procedure. @@ -146,6 +148,10 @@ def __init__( super().__init__( device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb ) + + # Smart device setup with graceful CUDA fallback + # DMD always uses PyTorch, so use_torch=True + self.device, self.use_torch = self._setup_device(device, use_torch=True) self.data = self._init_single_data(data) diff --git a/DSA/dmdc.py b/DSA/dmdc.py index 94c8c5b..7076d66 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -91,7 +91,9 @@ def __init__( Regularization parameter for ridge regression. Defaults to 0. device: string, int, or torch.device - A string, int or torch.device object to indicate the device to torch. + Device for computation. Options: + - 'cpu': Use CPU with PyTorch + - 'cuda' or 'cuda:X': Use GPU (auto-falls back to CPU if unavailable) verbose: bool If True, print statements will be provided about the progress of the fitting procedure. @@ -107,6 +109,10 @@ def __init__( super().__init__( device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb ) + + # Smart device setup with graceful CUDA fallback + # DMDc always uses PyTorch, so use_torch=True + self.device, self.use_torch = self._setup_device(device, use_torch=True) self._init_data(data, control_data) diff --git a/DSA/dsa.py b/DSA/dsa.py index 3796065..d11f5c3 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -197,7 +197,7 @@ def __init__( Mapping[str, Any], dataclass ] = SimilarityTransformDistConfig, device="cpu", - dsa_verbose=False, + verbose=False, n_jobs=1, ): """ @@ -239,7 +239,7 @@ def __init__( device : str Device to use for computation ('cpu' or 'cuda'). Default is 'cpu'. - dsa_verbose : bool + verbose : bool Whether to print verbose output during computation. Default is False. n_jobs : int @@ -267,7 +267,7 @@ def __init__( self.device = device self.n_jobs = n_jobs - self.dsa_verbose = dsa_verbose + self.verbose = verbose self.dmd_class = dmd_class if self.X is None and isinstance(self.Y, list): @@ -409,7 +409,7 @@ def fit_dmds(self): if self.dmd_api_source == "local_dmd": for dmd_sets in self.dmds: - if self.dsa_verbose: + if self.verbose: print( f"Fitting {len(dmd_sets)} DMDs in parallel with {n_jobs} jobs" ) @@ -418,7 +418,7 @@ def fit_dmds(self): ) else: for dmd_list, dat in zip(self.dmds, self.data): - if self.dsa_verbose: + if self.verbose: print( f"Fitting {len(dmd_list)} DMDs in parallel with {n_jobs} jobs" ) @@ -432,7 +432,7 @@ def fit_dmds(self): for dmd_sets in self.dmds: loop = ( dmd_sets - if not self.dsa_verbose + if not self.verbose else tqdm.tqdm(dmd_sets, desc="Fitting DMDs") ) for dmd in loop: @@ -441,7 +441,7 @@ def fit_dmds(self): for dmd_list, dat in zip(self.dmds, self.data): loop = ( zip(dmd_list, dat) - if not self.dsa_verbose + if not self.verbose else tqdm.tqdm(zip(dmd_list, dat), desc="Fitting DMDs") ) for dmd, Xi in loop: @@ -601,14 +601,14 @@ def score(self): self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]), n_sims)) - if self.dsa_verbose: + if self.verbose: print("comparing dmds") def compute_similarity(i, j): if self.method == "self-pairwise" and j >= i: return None - if self.dsa_verbose and self.n_jobs != 1: + if self.verbose and self.n_jobs != 1: print(f"computing similarity between DMDs {i} and {j}") simdist_args = [ @@ -624,7 +624,7 @@ def compute_similarity(i, j): ) sim = self.simdist.fit_score(*simdist_args) - if self.dsa_verbose and self.n_jobs != 1: + if self.verbose and self.n_jobs != 1: print(f"computing similarity between DMDs {i} and {j}") return (i, j, sim) @@ -637,7 +637,7 @@ def compute_similarity(i, j): if self.n_jobs != 1: n_jobs = self.n_jobs if self.n_jobs > 0 else -1 - if self.dsa_verbose: + if self.verbose: print( f"Computing {len(pairs)} DMD similarities in parallel with {n_jobs} jobs" ) @@ -648,7 +648,7 @@ def compute_similarity(i, j): else: loop = ( pairs - if not self.dsa_verbose + if not self.verbose else tqdm.tqdm(pairs, desc="Computing DMD similarities") ) results = [compute_similarity(i, j) for i, j in loop] @@ -673,7 +673,7 @@ def __init__( Y=None, dmd_class=DefaultDMD, device="cpu", - dsa_verbose=False, + verbose=False, n_jobs=1, # simdist parameters score_method: Literal["angular", "euclidean","wasserstein"] = "angular", @@ -700,7 +700,7 @@ def __init__( dmd_config=dmd_config, simdist_config=simdist_config, device=device, - dsa_verbose=dsa_verbose, + verbose=verbose, n_jobs=n_jobs, ) @@ -718,9 +718,11 @@ def __init__( Mapping[str, Any], dataclass ] = ControllabilitySimilarityTransformDistConfig, device="cpu", - dsa_verbose=False, + verbose=False, n_jobs=1, + compare = 'joint' ): + #TODO: fix based on making compare argument explicit # check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, # otherwise use ControllabilitySimilarityTransformDistConfig if isinstance(simdist_config, dataclass): @@ -743,7 +745,7 @@ def __init__( dmd_config, simdist_config, device, - dsa_verbose, + verbose, n_jobs, ) diff --git a/DSA/simdist.py b/DSA/simdist.py index 8685b58..9745c34 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -6,6 +6,7 @@ import torch.nn.utils.parametrize as parametrize from scipy.stats import wasserstein_distance import ot # optimal transport for multidimensional l2 wasserstein +import warnings try: from .dmd import DMD @@ -460,7 +461,7 @@ def fit_score( if ( score_method != "wasserstein" ): # otherwise resort to L2 Wasserstein over singular or eigenvalues - print( + warnings.warn( f"resorting to wasserstein distance over {self.wasserstein_compare}" ) score_method = "wasserstein" diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index 33115e9..c37a261 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -1,138 +1,147 @@ -""" -This module computes the subspace DMD with control (DMDc) model for a given dataset. -Code is partially derived from and inspired by https://github.com/spmvg/nfoursid/tree/master -""" - +"""This module computes the subspace DMD with control (DMDc) model for a given dataset.""" import numpy as np import torch +from .base_dmd import BaseDMD - -class SubspaceDMDc: - """Subspace DMDc class for computing and predicting with DMD with control models.""" - +class SubspaceDMDc(BaseDMD): + """Subspace DMDc class for computing and predicting with DMD with control models. + + Inherits from BaseDMD for common functionality like device management and data processing. + """ def __init__( - self, - data, - control_data, - n_delays=1, - rank=None, - lamb=1e-8, - device="cpu", - verbose=False, - send_to_cpu=False, - time_first=True, - backend="n4sid", + self, + data, + control_data=None, + n_delays=1, + f=None, + rank=None, + lamb=1e-8, + device='cpu', + verbose=False, + send_to_cpu=False, + time_first=True, + backend='n4sid', ): - # Convert inputs to torch tensors and store - self.device = device - self.data = self._to_tensor(data) - self.control_data = self._to_tensor(control_data) + """ + Initialize SubspaceDMDc. + + Parameters + ---------- + data : array-like + Output/observation data + control_data : array-like + Control input data + n_delays : int + Number of time delays (past window) + f : int, optional + Future window length (defaults to n_delays) + rank : int, optional + Rank for system identification + lamb : float + Regularization parameter for ridge regression + device : str or torch.device + Device for computation: + - 'cpu': Use NumPy on CPU (fastest for CPU) + - 'cuda' or 'cuda:X': Use PyTorch on GPU (auto-falls back to CPU if unavailable) + verbose : bool + If True, print progress information + send_to_cpu : bool + If True, move results to CPU after fitting (useful for batch GPU processing) + time_first : bool + If True, data shape is (time, features); otherwise (features, time) + backend : str + 'n4sid' or 'custom' for subspace identification algorithm + """ + # Initialize base class + super().__init__(device=device, verbose=verbose, send_to_cpu=send_to_cpu, lamb=lamb) + + # Smart device setup with graceful fallback + self.device, self.use_torch = self._setup_device(device, True) + + # SubspaceDMDc specific attributes + self.data = data + self.control_data = control_data self.A_v = None self.B_v = None self.C_v = None self.info = None self.n_delays = n_delays + self.f = f if f is not None else n_delays # Future window, defaults to n_delays self.rank = rank self.time_first = time_first self.backend = backend - self.lamb = lamb - self.verbose = verbose - self.send_to_cpu = send_to_cpu - - def _to_tensor(self, data): - """Convert data to torch tensor, handling lists and numpy arrays.""" - if isinstance(data, list): - return [self._to_tensor_single(d) for d in data] - else: - return self._to_tensor_single(data) - def _to_tensor_single(self, data): - """Convert single data item to torch tensor.""" - if isinstance(data, np.ndarray): - return torch.from_numpy(data).float().to(self.device) - elif isinstance(data, torch.Tensor): - return data.float().to(self.device) - return data + def _to_torch(self, x): + """Convert numpy array to torch tensor on the appropriate device.""" + if not self.use_torch or x is None: + return x + if isinstance(x, torch.Tensor): + return x.to(self.device) + return torch.from_numpy(x).to(self.device) + + def _to_numpy(self, x): + """Convert torch tensor to numpy array.""" + if not self.use_torch or x is None: + return x + if isinstance(x, torch.Tensor): + return x.cpu().numpy() + return x + def fit(self): - self.A_v, self.B_v, self.C_v, self.info = ( - self.subspace_dmdc_multitrial_flexible( - y=self.data, - u=self.control_data, - p=self.n_delays, - f=self.n_delays, - n=self.rank, - backend=self.backend, - lamb=self.lamb, - ) - ) - + """Fit the SubspaceDMDc model.""" + self.A_v, self.B_v, self.C_v, self.info = self.subspace_dmdc_multitrial_flexible( + y=self.data, + u=self.control_data, + p=self.n_delays, + f=self.f, + n=self.rank, + backend=self.backend, + lamb=self.lamb) + + # Send to CPU if requested (inherited from BaseDMD) if self.send_to_cpu: - self.all_to_device("cpu") - - def all_to_device(self, device): - """Send all tensors to specified device.""" - if self.A_v is not None: - self.A_v = self.A_v.to(device) - if self.B_v is not None: - self.B_v = self.B_v.to(device) - if self.C_v is not None: - self.C_v = self.C_v.to(device) - if self.info is not None: - for key in [ - "R_hat", - "Q_hat", - "S_hat", - "Gamma_hat", - "singular_values_O", - "noise_covariance", - ]: - if key in self.info and isinstance(self.info[key], torch.Tensor): - self.info[key] = self.info[key].to(device) - - def subspace_dmdc_multitrial_QR_decomposition( - self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999 - ): + self.all_to_device(device='cpu') + + + + def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): """ Subspace-DMDc for multi-trial data with variable trial lengths. Now use QR decomposition for computing the oblique projection as in N4SID implementations. - + Parameters: - - y_list: list of tensors, each (p_out, N_i) - output data for trial i - - u_list: list of tensors, each (m, N_i) - input data for trial i + - y_list: list of arrays, each (p_out, N_i) - output data for trial i + - u_list: list of arrays, each (m, N_i) - input data for trial i - p: past window length - f: future window length - n: state dimension (auto-determined if None) - ridge: regularization parameter (used only for rank selection/SVD; QR is exact) - energy: energy threshold for rank selection - + Returns: - A_hat, B_hat, C_hat: system matrices - info: dictionary with additional information """ if len(y_list) != len(u_list): raise ValueError("y_list and u_list must have same number of trials") - + n_trials = len(y_list) p_out = y_list[0].shape[0] m = u_list[0].shape[0] - + # Validate dimensions across trials for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): if y_trial.shape[0] != p_out: - raise ValueError( - f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}" - ) + raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") if u_trial.shape[0] != m: - raise ValueError( - f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}" - ) + raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") if y_trial.shape[1] != u_trial.shape[1]: raise ValueError(f"Trial {i}: y and u have different time lengths") - + def hankel_stack(X, start, L): - return torch.cat([X[:, start + i : start + i + 1] for i in range(L)], dim=0) - + return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + # Collect data from all trials U_p_all = [] Y_p_all = [] @@ -140,85 +149,98 @@ def hankel_stack(X, start, L): Y_f_all = [] valid_trials = [] T_per_trial = [] - + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): N_trial = Y_trial.shape[1] T_trial = N_trial - (p + f) + 1 - + if T_trial <= 0: - if self.verbose: - print( - f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping" - ) + print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") continue - + valid_trials.append(trial_idx) T_per_trial.append(T_trial) - + # Build Hankel matrices for this trial - U_p_trial = torch.cat( - [hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1 - ) - Y_p_trial = torch.cat( - [hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1 - ) - U_f_trial = torch.cat( - [hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1 - ) - Y_f_trial = torch.cat( - [hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1 - ) - + U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) + Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) + U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) + Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) + U_p_all.append(U_p_trial) Y_p_all.append(Y_p_trial) U_f_all.append(U_f_trial) Y_f_all.append(Y_f_trial) - + if not valid_trials: raise ValueError("No trials have sufficient data for given (p,f)") - + # Concatenate across valid trials - U_p = torch.cat(U_p_all, dim=1) # (p m, T_total) - Y_p = torch.cat(Y_p_all, dim=1) # (p p_out, T_total) - U_f = torch.cat(U_f_all, dim=1) # (f m, T_total) - Y_f = torch.cat(Y_f_all, dim=1) # (f p_out, T_total) - + U_p = np.concatenate(U_p_all, axis=1) # (p m, T_total) + Y_p = np.concatenate(Y_p_all, axis=1) # (p p_out, T_total) + U_f = np.concatenate(U_f_all, axis=1) # (f m, T_total) + Y_f = np.concatenate(Y_f_all, axis=1) # (f p_out, T_total) + T_total = sum(T_per_trial) - Z_p = torch.vstack([U_p, Y_p]) # (p (m + p_out), T_total) - - H = torch.vstack([U_f, Z_p, Y_f]) - - # Perform QR on H.T to get equivalent LQ on H - Q, R_upper = torch.linalg.qr( - H.T, mode="reduced" - ) # H.T = Q R_upper, R_upper upper triangular - L = R_upper.T # L = R_upper.T, lower triangular - + Z_p = np.vstack([U_p, Y_p]) # (p (m + p_out), T_total) + + H = np.vstack([U_f, Z_p, Y_f]) + # Dimensions for slicing dim_uf = f * m dim_zp = p * (m + p_out) dim_yf = f * p_out - - # Extract submatrices from L (lower triangular) - R22 = L[dim_uf : dim_uf + dim_zp, dim_uf : dim_uf + dim_zp] - R32 = L[dim_uf + dim_zp :, dim_uf : dim_uf + dim_zp] - - # Compute oblique projection O = R32 @ pinv(R22) @ Z_p - O = R32 @ torch.linalg.pinv(R22) @ Z_p - - # The rest remains the same: SVD on O - Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) + + # Use torch for expensive linear algebra if available + if self.use_torch and H.shape[1] > 100: # Only worth it for larger problems + H_torch = self._to_torch(H) + Z_p_torch = self._to_torch(Z_p) + + # Perform QR on H.T to get equivalent LQ on H + Q, R_upper = torch.linalg.qr(H_torch.T, mode='reduced') + L = R_upper.T + + # Extract submatrices from L + R22 = L[dim_uf:dim_uf + dim_zp, dim_uf:dim_uf + dim_zp] + R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] + + # Compute oblique projection O = R32 @ pinv(R22) @ Z_p + R22_pinv = torch.linalg.pinv(R22) + O = R32 @ R22_pinv @ Z_p_torch + + # SVD on O + Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) + + # Convert back to numpy + Uo = self._to_numpy(Uo) + s = self._to_numpy(s) + Vt = self._to_numpy(Vt) + else: + # Use numpy for smaller problems or when torch is disabled + # Perform QR on H.T to get equivalent LQ on H + Q, R_upper = np.linalg.qr(H.T, mode='reduced') + L = R_upper.T + + # Extract submatrices from L (lower triangular) + R22 = L[dim_uf:dim_uf + dim_zp, dim_uf:dim_uf + dim_zp] + R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] + + # Compute oblique projection O = R32 @ pinv(R22) @ Z_p + O = R32 @ np.linalg.pinv(R22) @ Z_p + + # The rest remains the same: SVD on O + Uo, s, Vt = np.linalg.svd(O, full_matrices=False) if n is None: - cs = torch.cumsum(s**2, dim=0) / (s**2).sum() - n = int((cs < energy).sum().item() + 1) + cs = np.cumsum(s**2) / (s**2).sum() + n = int(np.searchsorted(cs, energy) + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) - + U_n = Uo[:, :n] - S_n = torch.diag(s[:n]) + S_n = np.diag(s[:n]) V_n = Vt[:n, :] - S_half = torch.sqrt(S_n) - Gamma_hat = U_n @ S_half # (f p_out, n) - X_hat = S_half @ V_n # (n, T_total) + S_half = np.sqrt(S_n) + Gamma_hat = U_n @ S_half # (f p_out, n) + X_hat = S_half @ V_n # (n, T_total) # Time alignment for regression across all trials # Need to handle variable lengths carefully @@ -226,102 +248,104 @@ def hankel_stack(X, start, L): X_next_segments = [] U_mid_segments = [] Y_segments = [] - + start_idx = 0 for trial_idx, T_trial in enumerate(T_per_trial): # Extract states for this trial - X_trial = X_hat[:, start_idx : start_idx + T_trial] - + X_trial = X_hat[:, start_idx:start_idx + T_trial] + # State transitions within this trial X_trial_curr = X_trial[:, :-1] X_trial_next = X_trial[:, 1:] - + # Corresponding control inputs original_trial_idx = valid_trials[trial_idx] U_trial = u_list[original_trial_idx] - U_mid_trial = U_trial[:, p : p + (T_trial - 1)] - + U_mid_trial = U_trial[:, p:p + (T_trial - 1)] + X_segments.append(X_trial_curr) X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) - + # TODO: check the time-alignment of Y and X here # Corresponding output data - align with X_trial time indices Y_trial = y_list[original_trial_idx] - Y_trial_curr = Y_trial[:, p : p + T_trial - 1] + Y_trial_curr = Y_trial[:, p:p+T_trial-1] # Y_trial_curr = Y_trial[:, p+1:p+T_trial] Y_segments.append(Y_trial_curr) start_idx += T_trial - + # Concatenate all segments - X = torch.cat(X_segments, dim=1) - X_next = torch.cat(X_next_segments, dim=1) - U_mid = torch.cat(U_mid_segments, dim=1) - + X = np.concatenate(X_segments, axis=1) + X_next = np.concatenate(X_next_segments, axis=1) + U_mid = np.concatenate(U_mid_segments, axis=1) + # Regression for A and B - Z = torch.vstack([X, U_mid]) - # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T - ZTZ = Z @ Z.T - ridge_term = lamb * torch.eye(ZTZ.shape[0], device=self.device) - AB = torch.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T - A_hat = AB[:, :n] - B_hat = AB[:, n:] - - # Z = torch.vstack([X, U_mid]) - # AB = X_next @ torch.linalg.pinv(Z) + Z = np.vstack([X, U_mid]) + + # Use torch for ridge regression if available + if self.use_torch and Z.shape[1] > 100: + Z_torch = self._to_torch(Z) + X_next_torch = self._to_torch(X_next) + + # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T + ZTZ = Z_torch @ Z_torch.T + ridge_term = lamb * torch.eye(ZTZ.shape[0], device=self.device, dtype=Z_torch.dtype) + AB = torch.linalg.solve(ZTZ + ridge_term, Z_torch @ X_next_torch.T).T + + AB = self._to_numpy(AB) + A_hat = AB[:, :n] + B_hat = AB[:, n:] + else: + # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T + ZTZ = Z @ Z.T + ridge_term = lamb * np.eye(ZTZ.shape[0]) + AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T + A_hat = AB[:, :n] + B_hat = AB[:, n:] + + # Z = np.vstack([X, U_mid]) + # AB = X_next @ np.linalg.pinv(Z) # A_hat = AB[:, :n] # B_hat = AB[:, n:] - + C_hat = Gamma_hat[:p_out, :] # Estimate noise covariance matrix # 0) Outputs aligned to X and U_mid (same time indices/columns) - Y_curr = torch.cat(Y_segments, dim=1) # shape: (p_out, N) + Y_curr = np.concatenate(Y_segments, axis=1) # shape: (p_out, N) # 1) Residuals at time t # Process noise residual (state eq): w_t ≈ x_{t+1} - A x_t - B u_ts - W_hat = X_next - (A_hat @ X + B_hat @ U_mid) # (n, N) + W_hat = X_next - (A_hat @ X + B_hat @ U_mid) # (n, N) # Measurement noise residual (output eq): v_t ≈ y_t - C x_t (since D = 0) - V_hat = Y_curr - (C_hat @ X) # (p_out, N) + V_hat = Y_curr - (C_hat @ X) # (p_out, N) # 2) Mean-centering - V_hat = V_hat - V_hat.mean(dim=1, keepdim=True) - W_hat = W_hat - W_hat.mean(dim=1, keepdim=True) + V_hat = V_hat - V_hat.mean(axis=1, keepdims=True) + W_hat = W_hat - W_hat.mean(axis=1, keepdims=True) N_res = V_hat.shape[1] - denom = max(N_res - 1, 1) + denom = max(N_res - 1, 1) # 3) Covariances - R_hat = (V_hat @ V_hat.T) / denom # (p_out, p_out) measurement - Q_hat = (W_hat @ W_hat.T) / denom # (n, n) process - S_hat = (W_hat @ V_hat.T) / denom # (n, p_out) - cross (w,v) + R_hat = (V_hat @ V_hat.T) / denom # (p_out, p_out) measurement + Q_hat = (W_hat @ W_hat.T) / denom # (n, n) process + S_hat = (W_hat @ V_hat.T) / denom # (n, p_out) - cross (w,v) # 4) Symmetrize eps = 1e-12 - R_hat = 0.5 * (R_hat + R_hat.T) + eps * torch.eye( - R_hat.shape[0], device=self.device - ) - Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * torch.eye( - Q_hat.shape[0], device=self.device - ) + R_hat = 0.5 * (R_hat + R_hat.T) + eps * np.eye(R_hat.shape[0]) + Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * np.eye(Q_hat.shape[0]) - noise_covariance = torch.block_diag(R_hat, Q_hat) - # Add off-diagonal blocks - top_right = S_hat.T - bottom_left = S_hat - noise_covariance = torch.cat( - [ - torch.cat([R_hat, top_right], dim=1), - torch.cat([bottom_left, Q_hat], dim=1), - ], - dim=0, - ) + noise_covariance = np.block([[R_hat, S_hat.T], + [S_hat, Q_hat]]) info = { - "singular_values_O": s, - "rank_used": n, - "Gamma_hat": Gamma_hat, + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, "f": f, "n_trials_total": n_trials, "n_trials_used": len(valid_trials), @@ -330,56 +354,53 @@ def hankel_stack(X, start, L): "T_total": T_total, "trial_lengths": [y.shape[1] for y in y_list], "noise_covariance": noise_covariance, - "R_hat": R_hat, - "Q_hat": Q_hat, - "S_hat": S_hat, + 'R_hat': R_hat, + 'Q_hat': Q_hat, + 'S_hat': S_hat } - + return A_hat, B_hat, C_hat, info + - def subspace_dmdc_multitrial_custom( - self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999 - ): + + + def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): """ Subspace-DMDc for multi-trial data with variable trial lengths. - + Parameters: - - y_list: list of tensors, each (p_out, N_i) - output data for trial i - - u_list: list of tensors, each (m, N_i) - input data for trial i + - y_list: list of arrays, each (p_out, N_i) - output data for trial i + - u_list: list of arrays, each (m, N_i) - input data for trial i - p: past window length - f: future window length - n: state dimension (auto-determined if None) - ridge: regularization parameter - energy: energy threshold for rank selection∏ - + Returns: - A_hat, B_hat, C_hat: system matrices - info: dictionary with additional information """ if len(y_list) != len(u_list): raise ValueError("y_list and u_list must have same number of trials") - + n_trials = len(y_list) p_out = y_list[0].shape[0] m = u_list[0].shape[0] - + # Validate dimensions across trials for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): if y_trial.shape[0] != p_out: - raise ValueError( - f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}" - ) + raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") if u_trial.shape[0] != m: - raise ValueError( - f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}" - ) + raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") if y_trial.shape[1] != u_trial.shape[1]: raise ValueError(f"Trial {i}: y and u have different time lengths") - + def hankel_stack(X, start, L): - return torch.cat([X[:, start + i : start + i + 1] for i in range(L)], dim=0) - + return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + # Collect data from all trials U_p_all = [] Y_p_all = [] @@ -387,131 +408,116 @@ def hankel_stack(X, start, L): Y_f_all = [] valid_trials = [] T_per_trial = [] - + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): N_trial = Y_trial.shape[1] T_trial = N_trial - (p + f) + 1 - + if T_trial <= 0: - if self.verbose: - print( - f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping" - ) + print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") continue - + valid_trials.append(trial_idx) T_per_trial.append(T_trial) - + # Build Hankel matrices for this trial - U_p_trial = torch.cat( - [hankel_stack(U_trial, j, p) for j in range(T_trial)], dim=1 - ) - Y_p_trial = torch.cat( - [hankel_stack(Y_trial, j, p) for j in range(T_trial)], dim=1 - ) - U_f_trial = torch.cat( - [hankel_stack(U_trial, j + p, f) for j in range(T_trial)], dim=1 - ) - Y_f_trial = torch.cat( - [hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], dim=1 - ) - + U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) + Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) + U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) + Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) + U_p_all.append(U_p_trial) Y_p_all.append(Y_p_trial) U_f_all.append(U_f_trial) Y_f_all.append(Y_f_trial) - if self.verbose: - print("=" * 40) - print(f"Number of valid trials: {len(valid_trials)}") + print("="*40) + print(f"Number of valid trials: {len(U_p_trial)}") + if not valid_trials: raise ValueError("No trials have sufficient data for given (p,f)") - + # Concatenate across valid trials - U_p = torch.cat(U_p_all, dim=1) # (pm, T_total) - Y_p = torch.cat(Y_p_all, dim=1) # (p*p_out, T_total) - U_f = torch.cat(U_f_all, dim=1) # (fm, T_total) - Y_f = torch.cat(Y_f_all, dim=1) # (f*p_out, T_total) - + U_p = np.concatenate(U_p_all, axis=1) # (pm, T_total) + Y_p = np.concatenate(Y_p_all, axis=1) # (p*p_out, T_total) + U_f = np.concatenate(U_f_all, axis=1) # (fm, T_total) + Y_f = np.concatenate(Y_f_all, axis=1) # (f*p_out, T_total) + T_total = sum(T_per_trial) - Z_p = torch.vstack([U_p, Y_p]) # (p(m+p_out), T_total) - + Z_p = np.vstack([U_p, Y_p]) # (p(m+p_out), T_total) + # Oblique projection: remove row(U_f), project onto row(Z_p) UfUfT = U_f @ U_f.T - Xsolve = torch.linalg.solve( - UfUfT + lamb * torch.eye(UfUfT.shape[0], device=self.device), U_f - ) - Pi_perp = torch.eye(T_total, device=self.device) - U_f.T @ Xsolve + Xsolve = np.linalg.solve(UfUfT + lamb*np.eye(UfUfT.shape[0]), U_f) + Pi_perp = np.eye(T_total) - U_f.T @ Xsolve Yf_perp = Y_f @ Pi_perp Zp_perp = Z_p @ Pi_perp - + ZZT = Zp_perp @ Zp_perp.T - Zp_pinv_left = torch.linalg.solve( - ZZT + lamb * torch.eye(ZZT.shape[0], device=self.device), Zp_perp - ) + Zp_pinv_left = np.linalg.solve(ZZT + lamb*np.eye(ZZT.shape[0]), Zp_perp) P = Zp_perp.T @ Zp_pinv_left O = Yf_perp @ P # ≈ Γ_f X_p - - Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) + + Uo, s, Vt = np.linalg.svd(O, full_matrices=False) if n is None: - cs = torch.cumsum(s**2, dim=0) / (s**2).sum() - n = int((cs < energy).sum().item() + 1) + cs = np.cumsum(s**2) / (s**2).sum() + n = int(np.searchsorted(cs, energy) + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) - + U_n = Uo[:, :n] - S_n = torch.diag(s[:n]) + S_n = np.diag(s[:n]) V_n = Vt[:n, :] - S_half = torch.sqrt(S_n) - Gamma_hat = U_n @ S_half # (f*p_out, n) - X_hat = S_half @ V_n # (n, T_total) - + S_half = np.sqrt(S_n) + Gamma_hat = U_n @ S_half # (f*p_out, n) + X_hat = S_half @ V_n # (n, T_total) + # Time alignment for regression across all trials # Need to handle variable lengths carefully X_segments = [] X_next_segments = [] U_mid_segments = [] - + start_idx = 0 for trial_idx, T_trial in enumerate(T_per_trial): # Extract states for this trial - X_trial = X_hat[:, start_idx : start_idx + T_trial] - + X_trial = X_hat[:, start_idx:start_idx + T_trial] + # State transitions within this trial X_trial_curr = X_trial[:, :-1] X_trial_next = X_trial[:, 1:] - + # Corresponding control inputs original_trial_idx = valid_trials[trial_idx] U_trial = u_list[original_trial_idx] - U_mid_trial = U_trial[:, p : p + (T_trial - 1)] - + U_mid_trial = U_trial[:, p:p + (T_trial - 1)] + X_segments.append(X_trial_curr) X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) - + start_idx += T_trial - + # Concatenate all segments - X = torch.cat(X_segments, dim=1) - X_next = torch.cat(X_next_segments, dim=1) - U_mid = torch.cat(U_mid_segments, dim=1) - + X = np.concatenate(X_segments, axis=1) + X_next = np.concatenate(X_next_segments, axis=1) + U_mid = np.concatenate(U_mid_segments, axis=1) + # Regression for A and B - Z = torch.vstack([X, U_mid]) + Z = np.vstack([X, U_mid]) # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T ZTZ = Z @ Z.T - ridge_term = lamb * torch.eye(ZTZ.shape[0], device=self.device) - AB = torch.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T + ridge_term = lamb * np.eye(ZTZ.shape[0]) + AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T A_hat = AB[:, :n] B_hat = AB[:, n:] - + C_hat = Gamma_hat[:p_out, :] - + info = { - "singular_values_O": s, - "rank_used": n, - "Gamma_hat": Gamma_hat, + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, "f": f, "n_trials_total": n_trials, "n_trials_used": len(valid_trials), @@ -519,17 +525,17 @@ def hankel_stack(X, start, L): "T_per_trial": T_per_trial, "T_total": T_total, "trial_lengths": [y.shape[1] for y in y_list], - "X_hat": X_hat, + "X_hat": X_hat } - + return A_hat, B_hat, C_hat, info - def subspace_dmdc_multitrial_flexible( - self, y, u, p, f, n=None, lamb=1e-8, energy=0.999, backend="n4sid" - ): + + + def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energy=0.999, backend='n4sid'): """ Flexible wrapper that handles both fixed-length and variable-length multi-trial data. - + Parameters: - y: either (n_trials, p_out, N) array, (p_out, N) array, or list of (p_out, N_i) arrays - u: either (n_trials, m, N) array, (m, N) array, or list of (m, N_i) arrays @@ -542,15 +548,11 @@ def subspace_dmdc_multitrial_flexible( else: y_list = y u_list = u - if backend == "n4sid": - return self.subspace_dmdc_multitrial_QR_decomposition( - y_list, u_list, p, f, n, lamb, energy - ) + if backend == 'n4sid': + return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) else: - return self.subspace_dmdc_multitrial_custom( - y_list, u_list, p, f, n, lamb, energy - ) - + return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) + else: # Handle 2D arrays (single trial) by converting to list format if y.ndim == 2: @@ -560,35 +562,29 @@ def subspace_dmdc_multitrial_flexible( # Convert 3D arrays to list format y_list = [y[i] for i in range(y.shape[0])] u_list = [u[i] for i in range(u.shape[0])] - + # If time_first=True, transpose each trial from (time_points, variables) to (variables, time_points) if self.time_first: y_list = [y_trial.T for y_trial in y_list] u_list = [u_trial.T for u_trial in u_list] - - if backend == "n4sid": - return self.subspace_dmdc_multitrial_QR_decomposition( - y_list, u_list, p, f, n, lamb, energy - ) + + if backend == 'n4sid': + return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) else: - return self.subspace_dmdc_multitrial_custom( - y_list, u_list, p, f, n, lamb, energy - ) + return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) + def predict(self, Y, U, reseed=None): - # Y and U are (n_times, n_channels) or list of 2D arrays/tensors + # Y and U are (n_times, n_channels) or list of 2D arrays if reseed is None: reseed = 1 - # Convert inputs to tensors if needed + # Handle list of 2D arrays if isinstance(Y, list): - Y = [self._to_tensor_single(y) for y in Y] - U = [self._to_tensor_single(u) for u in U] - if not self.time_first: Y = [y.T for y in Y] U = [u.T for u in U] - + self.kalman = OnlineKalman(self) Y_pred = [] for trial in range(len(Y)): @@ -596,34 +592,29 @@ def predict(self, Y, U, reseed=None): trial_predictions = [] for t in range(Y[trial].shape[0]): y_filtered, _ = self.kalman.step( - y=Y[trial][t] if t % reseed == 0 else None, u=U[trial][t] + y=Y[trial][t] if t%reseed == 0 else None, + u=U[trial][t] ) trial_predictions.append(y_filtered) - Y_pred.append(torch.cat(trial_predictions, dim=1).T) + Y_pred.append(np.concatenate(trial_predictions, axis=1).T) return Y_pred # Return as list to match input format - # Convert to tensors - Y = self._to_tensor_single(Y) - U = self._to_tensor_single(U) - # print("time_first", self.time_first) if not self.time_first: if Y.ndim == 2: Y = Y.T U = U.T else: - Y = Y.permute(0, 2, 1) - U = U.permute(0, 2, 1) - + Y = Y.transpose(0, 2, 1) + U = U.transpose(0, 2, 1) + self.kalman = OnlineKalman(self) if Y.ndim == 2: Y_pred = [] for t in range(Y.shape[0]): - y_filtered, _ = self.kalman.step( - y=Y[t] if t % reseed == 0 else None, u=U[t] - ) + y_filtered, _ = self.kalman.step(y=Y[t] if t%reseed == 0 else None, u=U[t]) Y_pred.append(y_filtered) - return torch.cat(Y_pred, dim=1).T + return np.concatenate(Y_pred, axis=1).T else: # 3D data (n_trials, time, p_out) # print("Y.shape", Y.shape) @@ -633,46 +624,65 @@ def predict(self, Y, U, reseed=None): self.kalman.reset() # Reset filter for each trial trial_predictions = [] for t in range(Y.shape[1]): - y_filtered, _ = self.kalman.step( - y=Y[trial, t] if t % reseed == 0 else None, u=U[trial, t] - ) + y_filtered, _ = self.kalman.step(y=Y[trial, t] if t%reseed == 0 else None, u=U[trial, t]) trial_predictions.append(y_filtered) # print("y_filtered.shape", y_filtered.shape) - Y_pred.append(torch.cat(trial_predictions, dim=1).T) - return torch.stack(Y_pred) + Y_pred.append(np.concatenate(trial_predictions, axis=1).T) + return np.array(Y_pred) + + def compute_hankel(self, *args, **kwargs): + """ + Compute Hankel matrices for SubspaceDMDc. + + This is handled internally within subspace_dmdc_multitrial_QR_decomposition + and subspace_dmdc_multitrial_custom methods. + """ + raise NotImplementedError( + "Hankel matrix computation is integrated into the fit() method for SubspaceDMDc. " + "Use fit() to compute the model." + ) + + def compute_svd(self, *args, **kwargs): + """ + Compute SVD for SubspaceDMDc. + + This is handled internally within the subspace identification process. + """ + raise NotImplementedError( + "SVD computation is integrated into the fit() method for SubspaceDMDc. " + "Use fit() to compute the model." + ) class OnlineKalman: """ Online Kalman Filter class for real-time state estimation. - + This class maintains the internal state of the Kalman filter and provides a step method for updating the filter with new observations and inputs. """ - + def __init__(self, dmdc): """ Initialize the Online Kalman Filter with a fitted DMDc model. - + Parameters ---------- dmdc : object - Fitted DMDc model containing A_v, B_v, C_v matrices and + Fitted DMDc model containing A_v, B_v, C_v matrices and noise covariance estimates (R_hat, S_hat, Q_hat) """ - self.device = dmdc.device self.A = dmdc.A_v - self.B = dmdc.B_v + self.B = dmdc.B_v self.C = dmdc.C_v - self.R = dmdc.info["R_hat"] - self.S = dmdc.info["S_hat"] - self.Q = dmdc.info["Q_hat"] - + self.R = dmdc.info['R_hat'] + self.S = dmdc.info['S_hat'] + self.Q = dmdc.info['Q_hat'] + # Get dimensions # print("C_shape", self.C.shape) self.y_dim, self.x_dim = self.C.shape - self.u_dim = self.B.shape[1] - + # Initialize state storage self.p_filtereds = [] self.x_filtereds = [] @@ -684,23 +694,24 @@ def __init__(self, dmdc): self.y_predicteds = [] self.kalman_gains = [] + # def step(self, y=None, u=None, lam=1e-8): # """ # Perform one step of the Kalman filter. - + # Parameters # ---------- # y : np.ndarray, optional # Observed output at current time step. If None, the filter # will predict without observation update. - # u : np.ndarray, optional + # u : np.ndarray, optional # Input at current time step. If None, no input is applied. - + # Returns # ------- # y_filtered : np.ndarray # Filtered output estimate - # x_filtered : np.ndarray + # x_filtered : np.ndarray # Filtered state estimate # """ # x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) @@ -723,14 +734,14 @@ def __init__(self, dmdc): # x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) # else: # x_filtered = x_pred.copy() - + # K_pred = (self.S + self.A @ p_pred @ self.C.T) @ np.linalg.pinv(S_innov) - # p_predicted = (self.A @ p_pred @ self.A.T + self.Q - + # p_predicted = (self.A @ p_pred @ self.A.T + self.Q - # K_pred @ (self.S + self.A @ p_pred @ self.C.T).T) # x_predicted = self.A @ x_pred + self.B @ u # if not np.isnan(y).any(): # x_predicted += K_pred @ (y - self.C @ x_pred) - + # # Store results # self.p_filtereds.append(p_filtered) # self.x_filtereds.append(x_filtered) @@ -741,95 +752,74 @@ def __init__(self, dmdc): # self.y_filtereds.append(self.C @ x_filtered) # self.y_predicteds.append(self.C @ x_predicted) # self.kalman_gains.append(K_pred) - + # return self.y_filtereds[-1], self.x_filtereds[-1] + def step(self, y=None, u=None, reg_coef=1e-6): """ Perform one step of the Kalman filter. - + Parameters ---------- - y : torch.Tensor or np.ndarray, optional + y : np.ndarray, optional Observed output at current time step. If None, the filter will predict without observation update. - u : torch.Tensor or np.ndarray, optional + u : np.ndarray, optional Input at current time step. If None, no input is applied. reg_coef : float, optional Regularization coefficient to add to diagonal of P matrices to maintain numerical stability. Default: 1e-6 - + Returns ------- - y_filtered : torch.Tensor + y_filtered : np.ndarray Filtered output estimate - x_filtered : torch.Tensor + x_filtered : np.ndarray Filtered state estimate """ - x_pred = ( - self.x_predicteds[-1] - if self.x_predicteds - else torch.zeros((self.x_dim, 1), device=self.device) - ) - p_pred = ( - self.p_predicteds[-1] - if self.p_predicteds - else torch.eye(self.x_dim, device=self.device) - ) - + x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) + p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) + # Add regularization to p_pred to prevent ill-conditioning - p_pred_reg = p_pred + reg_coef * torch.eye(self.x_dim, device=self.device) - - # Convert inputs to tensors and ensure column vectors - if u is not None: - if isinstance(u, np.ndarray): - u = torch.from_numpy(u).float().to(self.device) - if u.ndim == 1: - u = u.reshape(-1, 1) - else: - u = torch.zeros((self.u_dim, 1), device=self.device) - - if y is not None: - if isinstance(y, np.ndarray): - y = torch.from_numpy(y).float().to(self.device) - if y.ndim == 1: - y = y.reshape(-1, 1) - else: - y = torch.zeros((self.y_dim, 1), device=self.device) + p_pred_reg = p_pred + reg_coef * np.eye(self.x_dim) + + # Ensure inputs are column vectors + if u is not None and u.ndim == 1: + u = u.reshape(-1, 1) + if y is not None and y.ndim == 1: + y = y.reshape(-1, 1) + if u is None: + u = np.zeros((self.u_dim, 1)) + if y is None: + y = np.zeros((self.y_dim, 1)) # Use regularized p_pred in computations S_innov = self.R + self.C @ p_pred_reg @ self.C.T - K_filtered = p_pred_reg @ self.C.T @ torch.linalg.pinv(S_innov) + K_filtered = p_pred_reg @ self.C.T @ np.linalg.pinv(S_innov) p_filtered = p_pred_reg - K_filtered @ self.C @ p_pred_reg - + # Add regularization to p_filtered to maintain positive definiteness p_filtered = (p_filtered + p_filtered.T) / 2 # Ensure symmetry - p_filtered = p_filtered + reg_coef * torch.eye( - self.x_dim, device=self.device - ) # Add regularization - - if not torch.isnan(y).any(): + p_filtered = p_filtered + reg_coef * np.eye(self.x_dim) # Add regularization + + if not np.isnan(y).any(): x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) else: - x_filtered = x_pred.clone() - - K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ torch.linalg.pinv(S_innov) - p_predicted = ( - self.A @ p_pred_reg @ self.A.T - + self.Q - - K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T - ) - + x_filtered = x_pred.copy() + + K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ np.linalg.pinv(S_innov) + p_predicted = (self.A @ p_pred_reg @ self.A.T + self.Q - + K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T) + # Add regularization to p_predicted and ensure symmetry p_predicted = (p_predicted + p_predicted.T) / 2 # Ensure symmetry - p_predicted = p_predicted + reg_coef * torch.eye( - self.x_dim, device=self.device - ) # Add regularization - + p_predicted = p_predicted + reg_coef * np.eye(self.x_dim) # Add regularization + x_predicted = self.A @ x_pred + self.B @ u - if not torch.isnan(y).any(): + if not np.isnan(y).any(): x_predicted += K_pred @ (y - self.C @ x_pred) - + # Store results self.p_filtereds.append(p_filtered) self.x_filtereds.append(x_filtered) @@ -840,9 +830,9 @@ def step(self, y=None, u=None, reg_coef=1e-6): self.y_filtereds.append(self.C @ x_filtered) self.y_predicteds.append(self.C @ x_predicted) self.kalman_gains.append(K_pred) - + return self.y_filtereds[-1], self.x_filtereds[-1] - + def reset(self): """Reset the filter to initial state.""" self.p_filtereds = [] @@ -854,17 +844,18 @@ def reset(self): self.y_filtereds = [] self.y_predicteds = [] self.kalman_gains = [] - + + def get_history(self): """Return the complete history of filter states.""" return { - "p_filtereds": self.p_filtereds, - "x_filtereds": self.x_filtereds, - "p_predicteds": self.p_predicteds, - "x_predicteds": self.x_predicteds, - "us": self.us, - "ys": self.ys, - "y_filtereds": self.y_filtereds, - "y_predicteds": self.y_predicteds, - "kalman_gains": self.kalman_gains, - } + 'p_filtereds': self.p_filtereds, + 'x_filtereds': self.x_filtereds, + 'p_predicteds': self.p_predicteds, + 'x_predicteds': self.x_predicteds, + 'us': self.us, + 'ys': self.ys, + 'y_filtereds': self.y_filtereds, + 'y_predicteds': self.y_predicteds, + 'kalman_gains': self.kalman_gains + } \ No newline at end of file From 1d3e9d30adf573d11b3007dec5c0ae0553f5eaa3 Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 29 Oct 2025 22:58:02 -0400 Subject: [PATCH 17/51] zeros dmd catch, streamlining subspace_dmdc --- DSA/dmdc.py | 5 +++-- DSA/subspace_dmdc.py | 36 +++++------------------------------- 2 files changed, 8 insertions(+), 33 deletions(-) diff --git a/DSA/dmdc.py b/DSA/dmdc.py index 7076d66..32ec2c0 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -174,8 +174,9 @@ def _init_data(self, data, control_data=None): control_data ) else: - self.control_data = torch.zeros_like(self.data) - control_is_ragged = False + raise ValueError("control data should be present, otherwise use DMD") + # self.control_data = torch.zeros_like(self.data) + # control_is_ragged = False # Check consistency between data and control_data if data_is_ragged != control_is_ragged: diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index c37a261..4de7801 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -13,13 +13,11 @@ def __init__( data, control_data=None, n_delays=1, - f=None, rank=None, lamb=1e-8, device='cpu', verbose=False, send_to_cpu=False, - time_first=True, backend='n4sid', ): """ @@ -33,8 +31,6 @@ def __init__( Control input data n_delays : int Number of time delays (past window) - f : int, optional - Future window length (defaults to n_delays) rank : int, optional Rank for system identification lamb : float @@ -47,8 +43,6 @@ def __init__( If True, print progress information send_to_cpu : bool If True, move results to CPU after fitting (useful for batch GPU processing) - time_first : bool - If True, data shape is (time, features); otherwise (features, time) backend : str 'n4sid' or 'custom' for subspace identification algorithm """ @@ -66,9 +60,7 @@ def __init__( self.C_v = None self.info = None self.n_delays = n_delays - self.f = f if f is not None else n_delays # Future window, defaults to n_delays self.rank = rank - self.time_first = time_first self.backend = backend @@ -94,7 +86,7 @@ def fit(self): y=self.data, u=self.control_data, p=self.n_delays, - f=self.f, + f=self.n_delays, n=self.rank, backend=self.backend, lamb=self.lamb) @@ -541,13 +533,8 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ - u: either (n_trials, m, N) array, (m, N) array, or list of (m, N_i) arrays """ if isinstance(y, list) and isinstance(u, list): - # If time_first=True, transpose each trial from (time_points, variables) to (variables, time_points) - if self.time_first: - y_list = [y_trial.T for y_trial in y] - u_list = [u_trial.T for u_trial in u] - else: - y_list = y - u_list = u + y_list = [y_trial.T for y_trial in y] + u_list = [u_trial.T for u_trial in u] if backend == 'n4sid': return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) else: @@ -563,10 +550,8 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ y_list = [y[i] for i in range(y.shape[0])] u_list = [u[i] for i in range(u.shape[0])] - # If time_first=True, transpose each trial from (time_points, variables) to (variables, time_points) - if self.time_first: - y_list = [y_trial.T for y_trial in y_list] - u_list = [u_trial.T for u_trial in u_list] + y_list = [y_trial.T for y_trial in y_list] + u_list = [u_trial.T for u_trial in u_list] if backend == 'n4sid': return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) @@ -581,9 +566,6 @@ def predict(self, Y, U, reseed=None): # Handle list of 2D arrays if isinstance(Y, list): - if not self.time_first: - Y = [y.T for y in Y] - U = [u.T for u in U] self.kalman = OnlineKalman(self) Y_pred = [] @@ -599,14 +581,6 @@ def predict(self, Y, U, reseed=None): Y_pred.append(np.concatenate(trial_predictions, axis=1).T) return Y_pred # Return as list to match input format - # print("time_first", self.time_first) - if not self.time_first: - if Y.ndim == 2: - Y = Y.T - U = U.T - else: - Y = Y.transpose(0, 2, 1) - U = U.transpose(0, 2, 1) self.kalman = OnlineKalman(self) if Y.ndim == 2: From 5de9f4fd890938be380e7cb3ae85c98fe90ffda1 Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 29 Oct 2025 23:54:51 -0400 Subject: [PATCH 18/51] some bug fixes --- DSA/dmdc.py | 11 +++ DSA/dsa.py | 19 ++-- DSA/subspace_dmdc.py | 10 +- examples/all_dsa_types.ipynb | 174 +++++++++++++++++++++++++++++++++++ 4 files changed, 197 insertions(+), 17 deletions(-) create mode 100644 examples/all_dsa_types.ipynb diff --git a/DSA/dmdc.py b/DSA/dmdc.py index 32ec2c0..3561007 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -115,6 +115,7 @@ def __init__( self.device, self.use_torch = self._setup_device(device, use_torch=True) self._init_data(data, control_data) + self._check_same_shape() self.n_delays = n_delays self.n_control_delays = n_control_delays @@ -214,6 +215,16 @@ def _init_data(self, data, control_data=None): self.ntrials = 1 self.is_list_data = False + def _check_same_shape(self): + if isinstance(self.data,(np.ndarray,torch.Tensor)): + assert self.data.shape[:-1] == self.control_data.shape[:-1] + elif isinstance(self.data,list): + + assert len(self.data) == len(self.control_data) + + for d,c in zip(self.data,self.control_data): + assert d.shape[:-1] == c.shape[:-1] + def compute_hankel( self, data=None, diff --git a/DSA/dsa.py b/DSA/dsa.py index d11f5c3..015fe06 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -98,7 +98,6 @@ class SubspaceDMDcConfig: """ n_delays: int = 1 - delay_interval: int = 1 rank: int = None lamb: float = 0 backend: str = "n4sid" @@ -192,10 +191,10 @@ def __init__( Y_control=None, dmd_class=DefaultDMD, similarity_class=SimilarityTransformDist, - dmd_config: Union[Mapping[str, Any], dataclass] = DefaultDMDConfig, + dmd_config: Union[Mapping[str, Any], dataclass] = DefaultDMDConfig(), simdist_config: Union[ Mapping[str, Any], dataclass - ] = SimilarityTransformDistConfig, + ] = SimilarityTransformDistConfig(), device="cpu", verbose=False, n_jobs=1, @@ -512,7 +511,7 @@ def broadcast_params(self, param, cast=None): assert len(param[i]) >= len(data) out.append(param[i][: len(data)]) elif ( - isinstance(param, (int, float, np.integer)) + isinstance(param, (int, float, np.integer,str)) or param in {None, "None", "none"} or ( hasattr(param, "__module__") @@ -713,10 +712,10 @@ def __init__( Y=None, Y_control=None, dmd_class=SubspaceDMDc, - dmd_config: Union[Mapping[str, Any], dataclass] = SubspaceDMDcConfig, + dmd_config: Union[Mapping[str, Any], dataclass] = SubspaceDMDcConfig(), simdist_config: Union[ Mapping[str, Any], dataclass - ] = ControllabilitySimilarityTransformDistConfig, + ] = ControllabilitySimilarityTransformDistConfig(), device="cpu", verbose=False, n_jobs=1, @@ -725,14 +724,10 @@ def __init__( #TODO: fix based on making compare argument explicit # check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, # otherwise use ControllabilitySimilarityTransformDistConfig - if isinstance(simdist_config, dataclass): - compare = simdist_config.compare - elif isinstance(simdist_config, dict): + if isinstance(simdist_config, dict): compare = simdist_config.get("compare", None) else: - raise ValueError( - "unknown data type for simdist-config, use dataclass or dict" - ) + compare = simdist_config.compare simdist = self.update_compare_method(compare) super().__init__( diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index 4de7801..db0b91f 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -55,6 +55,8 @@ def __init__( # SubspaceDMDc specific attributes self.data = data self.control_data = control_data + if self.control_data is None: + raise ValueError("no control data detected, use DMD or SubspaceDMD instead") self.A_v = None self.B_v = None self.C_v = None @@ -165,7 +167,7 @@ def hankel_stack(X, start, L): Y_f_all.append(Y_f_trial) if not valid_trials: - raise ValueError("No trials have sufficient data for given (p,f)") + raise ValueError("No trials have sufficient data for given number of delays") # Concatenate across valid trials U_p = np.concatenate(U_p_all, axis=1) # (p m, T_total) @@ -533,12 +535,10 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ - u: either (n_trials, m, N) array, (m, N) array, or list of (m, N_i) arrays """ if isinstance(y, list) and isinstance(u, list): - y_list = [y_trial.T for y_trial in y] - u_list = [u_trial.T for u_trial in u] if backend == 'n4sid': - return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) + return self.subspace_dmdc_multitrial_QR_decomposition(y, u, p, f, n, lamb, energy) else: - return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) + return self.subspace_dmdc_multitrial_custom(y, u, p, f, n, lamb, energy) else: # Handle 2D arrays (single trial) by converting to list format diff --git a/examples/all_dsa_types.ipynb b/examples/all_dsa_types.ipynb new file mode 100644 index 0000000..307ee39 --- /dev/null +++ b/examples/all_dsa_types.ipynb @@ -0,0 +1,174 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 37, + "id": "773aa0fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n", + "Automatic pdb calling has been turned ON\n" + ] + } + ], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "from DSA import DSA, GeneralizedDSA, InputDSA\n", + "from DSA import DMD, DMDc, SubspaceDMDc\n", + "from pydmd import DMD as pDMD\n", + "import DSA.pykoopman as pk\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "%pdb" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d452743b", + "metadata": {}, + "outputs": [], + "source": [ + "d1 = np.random.random(size=(20,5))\n", + "u1 = np.random.random(size=(20,2))\n", + "\n", + "d2 = np.random.random(size=(2,20,5))\n", + "u2 = np.random.random(size=(2,20,2))\n", + "\n", + "d3 = [np.random.random(size=(i,20,5)) for i in range(1,10)]\n", + "u3 = [np.random.random(size=(i,20,2)) for i in range(1,10)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88cad354", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5, 5)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "#TODO: fix this case\n", + "# dmdc = DMDc(d3,u3,n_delays=2,rank_input=10,rank_output=10)\n", + "# dmdc.fit()\n", + "# print(dmdc.A_v.shape)\n", + "# print(dmdc.B_v.shape)\n", + "\n", + "#TODO: fix this case\n", + "# subdmdc = SubspaceDMDc(d1,u1,n_delays=10,rank=2)\n", + "# subdmdc.fit()\n", + "# print(subdmdc.A_v.shape)\n", + "# print(subdmdc.B_v.shape)\n", + "\n", + "\n", + "#TODO: fix this case\n", + "# subdmdc = SubspaceDMDc(d3,u3,n_delays=2,rank=10,backend='n4sid')\n", + "# subdmdc.fit()\n", + "# print(subdmdc.A_v.shape)\n", + "# print(subdmdc.B_v.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "721bc598", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:364: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", + " if self.dmd_has_control and not self.simdist_has_control:\n" + ] + }, + { + "ename": "TypeError", + "evalue": "SimilarityTransformDist.__init__() got an unexpected keyword argument 'joint_optim'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[56], line 9\u001b[0m\n\u001b[1;32m 2\u001b[0m u1s \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandom(size\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m20\u001b[39m,\u001b[38;5;241m2\u001b[39m)) \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m3\u001b[39m)]\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m#works\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# dsa = DSA(d1s,dmd_class=pk.Koopman,\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# observables=pk.observables.TimeDelay(),regressor=pDMD(svd_rank=5),\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# score_method='wasserstein')\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m dsa \u001b[38;5;241m=\u001b[39m \u001b[43mInputDSA\u001b[49m\u001b[43m(\u001b[49m\u001b[43md1s\u001b[49m\u001b[43m,\u001b[49m\u001b[43mu1s\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m sim \u001b[38;5;241m=\u001b[39m dsa\u001b[38;5;241m.\u001b[39mfit_score()\n\u001b[1;32m 11\u001b[0m sim\u001b[38;5;241m.\u001b[39mshape\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:733\u001b[0m, in \u001b[0;36mInputDSA.__init__\u001b[0;34m(self, X, X_control, Y, Y_control, dmd_class, dmd_config, simdist_config, device, verbose, n_jobs, compare)\u001b[0m\n\u001b[1;32m 730\u001b[0m compare \u001b[38;5;241m=\u001b[39m simdist_config\u001b[38;5;241m.\u001b[39mcompare\n\u001b[1;32m 731\u001b[0m simdist \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate_compare_method(compare)\n\u001b[0;32m--> 733\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 734\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 735\u001b[0m \u001b[43m \u001b[49m\u001b[43mY\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 736\u001b[0m \u001b[43m \u001b[49m\u001b[43mX_control\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 737\u001b[0m \u001b[43m \u001b[49m\u001b[43mY_control\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 738\u001b[0m \u001b[43m \u001b[49m\u001b[43mdmd_class\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 739\u001b[0m \u001b[43m \u001b[49m\u001b[43msimdist\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 740\u001b[0m \u001b[43m \u001b[49m\u001b[43mdmd_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 741\u001b[0m \u001b[43m \u001b[49m\u001b[43msimdist_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 742\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 743\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 744\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 745\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 747\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m X_control \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 748\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmd_has_control\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:312\u001b[0m, in \u001b[0;36mGeneralizedDSA.__init__\u001b[0;34m(self, X, Y, X_control, Y_control, dmd_class, similarity_class, dmd_config, simdist_config, device, verbose, n_jobs)\u001b[0m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_dmd_api_source(dmd_class)\n\u001b[1;32m 311\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_initiate_dmds()\n\u001b[0;32m--> 312\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msimdist \u001b[38;5;241m=\u001b[39m \u001b[43msimilarity_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimdist_config\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: SimilarityTransformDist.__init__() got an unexpected keyword argument 'joint_optim'" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py\u001b[0m(312)\u001b[0;36m__init__\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 310 \u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dmd_api_source\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdmd_class\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 311 \u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initiate_dmds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m--> 312 \u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimdist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msimilarity_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimdist_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 313 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 314 \u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0m_initiate_dmds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] + } + ], + "source": [ + "d1s = [np.random.random(size=(20,5)) for _ in range(3)]\n", + "u1s = [np.random.random(size=(20,2)) for _ in range(3)]\n", + "\n", + "#works\n", + "# dsa = DSA(d1s,dmd_class=pk.Koopman,\n", + "# observables=pk.observables.TimeDelay(),regressor=pDMD(svd_rank=5),\n", + "# score_method='wasserstein')\n", + "\n", + "dsa = InputDSA(d1s,u1s)\n", + "sim = dsa.fit_score()\n", + "sim.shape\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26c08771", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dsa_test_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From f6f1d1af835824cc98d7dff0b4e097ed8571999c Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 09:15:40 -0400 Subject: [PATCH 19/51] bug fixes --- DSA/dsa.py | 14 +++++--------- DSA/simdist.py | 2 +- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index 015fe06..62b869b 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -120,15 +120,11 @@ class SimilarityTransformDistConfig: Default is "angular". lr (float): Learning rate for the optimization algorithm. Default is 5e-3. - zero_pad (bool): Whether to zero-pad matrices to make them the same size. - Default is False. """ iters: int = 1500 score_method: Literal["angular", "euclidean", "wasserstein"] = "angular" lr: float = 5e-3 - zero_pad: bool = False - @dataclass() class ControllabilitySimilarityTransformDistConfig: @@ -152,7 +148,7 @@ class ControllabilitySimilarityTransformDistConfig: """ score_method: Literal["euclidean", "angular"] = "euclidean" - compare = "state" + compare = "joint" joint_optim: bool = False return_distance_components: bool = False @@ -600,8 +596,6 @@ def score(self): self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]), n_sims)) - if self.verbose: - print("comparing dmds") def compute_similarity(i, j): if self.method == "self-pairwise" and j >= i: @@ -614,7 +608,8 @@ def compute_similarity(i, j): self.get_dmd_matrix(self.dmds[0][i]), self.get_dmd_matrix(self.dmds[ind2][j]), ] - if self.dmd_has_control: + + if self.simdist_has_control and self.dmd_has_control: simdist_args.extend( [ self.get_dmd_control_matrix(self.dmds[0][i]), @@ -719,7 +714,6 @@ def __init__( device="cpu", verbose=False, n_jobs=1, - compare = 'joint' ): #TODO: fix based on making compare argument explicit # check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, @@ -750,7 +744,9 @@ def __init__( def update_compare_method(self,compare='joint'): if compare == "state": simdist = SimilarityTransformDist + #TODO: check simdist config to make sure it aligns else: simdist = ControllabilitySimilarityTransformDist + #TODO: check simdist config to make sure it aligns return simdist diff --git a/DSA/simdist.py b/DSA/simdist.py index 9745c34..3882093 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -462,7 +462,7 @@ def fit_score( score_method != "wasserstein" ): # otherwise resort to L2 Wasserstein over singular or eigenvalues warnings.warn( - f"resorting to wasserstein distance over {self.wasserstein_compare}" + f"shapes are not aligned, resorting to wasserstein distance over {self.wasserstein_compare}" ) score_method = "wasserstein" else: From db4ccff7cb2fdac8ad1012b96a01248edb473db6 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 09:16:51 -0400 Subject: [PATCH 20/51] pykoopman --- DSA/pykoopman/.readthedocs.yaml | 35 - DSA/pykoopman/{src/pykoopman => }/__init__.py | 6 + .../{src/pykoopman => }/analytics/__init__.py | 0 .../analytics/_base_analyzer.py | 1 + .../{src/pykoopman => }/analytics/_ms_pd21.py | 9 +- .../analytics/_pruned_koopman.py | 3 +- .../{src/pykoopman => }/common/__init__.py | 13 - .../{src/pykoopman => }/common/validation.py | 0 .../differentiation/__init__.py | 0 .../differentiation/_derivative.py | 1 + .../differentiation/_finite_difference.py | 0 DSA/pykoopman/{src/pykoopman => }/koopman.py | 1 + .../{src/pykoopman => }/koopman_continuous.py | 1 + .../pykoopman => }/observables/__init__.py | 0 .../{src/pykoopman => }/observables/_base.py | 7 +- .../observables/_custom_observables.py | 7 +- .../pykoopman => }/observables/_identity.py | 1 + .../pykoopman => }/observables/_polynomial.py | 1 + .../observables/_radial_basis_functions.py | 1 + .../observables/_random_fourier_features.py | 1 + .../pykoopman => }/observables/_time_delay.py | 7 +- .../pykoopman => }/regression/__init__.py | 0 .../{src/pykoopman => }/regression/_base.py | 1 + .../regression/_base_ensemble.py | 1 + .../{src/pykoopman => }/regression/_dmd.py | 1 + .../{src/pykoopman => }/regression/_dmdc.py | 1 + .../{src/pykoopman => }/regression/_edmd.py | 1 + .../{src/pykoopman => }/regression/_edmdc.py | 1 + .../{src/pykoopman => }/regression/_havok.py | 1 + .../{src/pykoopman => }/regression/_kdmd.py | 1 + .../{src/pykoopman => }/regression/_nndmd.py | 3 +- DSA/pykoopman/src/pykoopman/common/cqgle.py | 234 ---- .../src/pykoopman/common/examples.py | 1045 ----------------- DSA/pykoopman/src/pykoopman/common/ks.py | 189 --- DSA/pykoopman/src/pykoopman/common/nlse.py | 186 --- DSA/pykoopman/src/pykoopman/common/vbe.py | 177 --- 36 files changed, 43 insertions(+), 1894 deletions(-) delete mode 100644 DSA/pykoopman/.readthedocs.yaml rename DSA/pykoopman/{src/pykoopman => }/__init__.py (71%) rename DSA/pykoopman/{src/pykoopman => }/analytics/__init__.py (100%) rename DSA/pykoopman/{src/pykoopman => }/analytics/_base_analyzer.py (99%) rename DSA/pykoopman/{src/pykoopman => }/analytics/_ms_pd21.py (99%) rename DSA/pykoopman/{src/pykoopman => }/analytics/_pruned_koopman.py (99%) rename DSA/pykoopman/{src/pykoopman => }/common/__init__.py (52%) rename DSA/pykoopman/{src/pykoopman => }/common/validation.py (100%) rename DSA/pykoopman/{src/pykoopman => }/differentiation/__init__.py (100%) rename DSA/pykoopman/{src/pykoopman => }/differentiation/_derivative.py (99%) rename DSA/pykoopman/{src/pykoopman => }/differentiation/_finite_difference.py (100%) rename DSA/pykoopman/{src/pykoopman => }/koopman.py (99%) rename DSA/pykoopman/{src/pykoopman => }/koopman_continuous.py (99%) rename DSA/pykoopman/{src/pykoopman => }/observables/__init__.py (100%) rename DSA/pykoopman/{src/pykoopman => }/observables/_base.py (99%) rename DSA/pykoopman/{src/pykoopman => }/observables/_custom_observables.py (98%) rename DSA/pykoopman/{src/pykoopman => }/observables/_identity.py (99%) rename DSA/pykoopman/{src/pykoopman => }/observables/_polynomial.py (99%) rename DSA/pykoopman/{src/pykoopman => }/observables/_radial_basis_functions.py (99%) rename DSA/pykoopman/{src/pykoopman => }/observables/_random_fourier_features.py (99%) rename DSA/pykoopman/{src/pykoopman => }/observables/_time_delay.py (98%) rename DSA/pykoopman/{src/pykoopman => }/regression/__init__.py (100%) rename DSA/pykoopman/{src/pykoopman => }/regression/_base.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_base_ensemble.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_dmd.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_dmdc.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_edmd.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_edmdc.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_havok.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_kdmd.py (99%) rename DSA/pykoopman/{src/pykoopman => }/regression/_nndmd.py (99%) delete mode 100644 DSA/pykoopman/src/pykoopman/common/cqgle.py delete mode 100644 DSA/pykoopman/src/pykoopman/common/examples.py delete mode 100644 DSA/pykoopman/src/pykoopman/common/ks.py delete mode 100644 DSA/pykoopman/src/pykoopman/common/nlse.py delete mode 100644 DSA/pykoopman/src/pykoopman/common/vbe.py diff --git a/DSA/pykoopman/.readthedocs.yaml b/DSA/pykoopman/.readthedocs.yaml deleted file mode 100644 index f915bd9..0000000 --- a/DSA/pykoopman/.readthedocs.yaml +++ /dev/null @@ -1,35 +0,0 @@ -# .readthedocs.yaml -# Read the Docs configuration file -# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details - -# Required -version: 2 - -# Set the version of Python and other tools you might need -build: - os: ubuntu-22.04 - tools: - python: "3.10" - # You can also specify other tool versions: - # nodejs: "19" - # rust: "1.64" - # golang: "1.19" - -# Build documentation in the docs/ directory with Sphinx -sphinx: - configuration: docs/conf.py - -# If using Sphinx, optionally build your docs in additional formats such as PDF -# formats: -# - pdf - -# Optionally declare the Python requirements required to build your docs -#python: -# install: -# - requirements: requirements-dev.txt -# - method: pip -# path: . -python: - install: - - method: pip - path: .[dev] diff --git a/DSA/pykoopman/src/pykoopman/__init__.py b/DSA/pykoopman/__init__.py similarity index 71% rename from DSA/pykoopman/src/pykoopman/__init__.py rename to DSA/pykoopman/__init__.py index b6e344d..4bbc91d 100644 --- a/DSA/pykoopman/src/pykoopman/__init__.py +++ b/DSA/pykoopman/__init__.py @@ -11,6 +11,12 @@ from .koopman import Koopman from .koopman_continuous import KoopmanContinuous +# Import submodules so they are accessible as attributes +from . import common +from . import differentiation +from . import observables +from . import regression +from . import analytics __all__ = [ "Koopman", diff --git a/DSA/pykoopman/src/pykoopman/analytics/__init__.py b/DSA/pykoopman/analytics/__init__.py similarity index 100% rename from DSA/pykoopman/src/pykoopman/analytics/__init__.py rename to DSA/pykoopman/analytics/__init__.py diff --git a/DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py b/DSA/pykoopman/analytics/_base_analyzer.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py rename to DSA/pykoopman/analytics/_base_analyzer.py index 9cdb156..dce5aec 100644 --- a/DSA/pykoopman/src/pykoopman/analytics/_base_analyzer.py +++ b/DSA/pykoopman/analytics/_base_analyzer.py @@ -1,4 +1,5 @@ """module for implement modes analyzer for Koopman approximation""" + from __future__ import annotations import abc diff --git a/DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py b/DSA/pykoopman/analytics/_ms_pd21.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py rename to DSA/pykoopman/analytics/_ms_pd21.py index bf789bb..8306b81 100644 --- a/DSA/pykoopman/src/pykoopman/analytics/_ms_pd21.py +++ b/DSA/pykoopman/analytics/_ms_pd21.py @@ -1,10 +1,11 @@ """Module for implementing Pan-Duraisamy modes selection algorithm""" + from __future__ import annotations import numpy as np from matplotlib import pyplot as plt from prettytable import PrettyTable -from pykoopman.koopman import Koopman +from DSA.pykoopman.koopman import Koopman from sklearn.linear_model import enet_path from ._base_analyzer import BaseAnalyzer @@ -303,9 +304,9 @@ def sweep_among_best_L_modes( coef_enet_comp_reduced_i_alpha = np.linalg.lstsq( phi_tilde_scaled_reduced, X )[0] - coefs_enet_comp[ - :, bool_non_zero, i_alpha - ] = coef_enet_comp_reduced_i_alpha.T + coefs_enet_comp[:, bool_non_zero, i_alpha] = ( + coef_enet_comp_reduced_i_alpha.T + ) coefs_enet_comp[:, np.invert(bool_non_zero), i_alpha] = 0 # 3. compute residual for parameter sweep to draw the trade-off diff --git a/DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py b/DSA/pykoopman/analytics/_pruned_koopman.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py rename to DSA/pykoopman/analytics/_pruned_koopman.py index d795bf4..2333511 100644 --- a/DSA/pykoopman/src/pykoopman/analytics/_pruned_koopman.py +++ b/DSA/pykoopman/analytics/_pruned_koopman.py @@ -1,8 +1,9 @@ """Module for pruning Koopman models.""" + from __future__ import annotations import numpy as np -from pykoopman.koopman import Koopman +from DSA.pykoopman.koopman import Koopman from sklearn.utils.validation import check_is_fitted diff --git a/DSA/pykoopman/src/pykoopman/common/__init__.py b/DSA/pykoopman/common/__init__.py similarity index 52% rename from DSA/pykoopman/src/pykoopman/common/__init__.py rename to DSA/pykoopman/common/__init__.py index 4badea5..bc6769f 100644 --- a/DSA/pykoopman/src/pykoopman/common/__init__.py +++ b/DSA/pykoopman/common/__init__.py @@ -1,21 +1,8 @@ from __future__ import annotations -from .cqgle import cqgle -from .examples import advance_linear_system -from .examples import drss -from .examples import Linear2Ddynamics -from .examples import lorenz -from .examples import rev_dvdp -from .examples import rk4 -from .examples import slow_manifold -from .examples import torus_dynamics -from .examples import vdp_osc -from .ks import ks -from .nlse import nlse from .validation import check_array from .validation import drop_nan_rows from .validation import validate_input -from .vbe import vbe __all__ = [ "check_array", diff --git a/DSA/pykoopman/src/pykoopman/common/validation.py b/DSA/pykoopman/common/validation.py similarity index 100% rename from DSA/pykoopman/src/pykoopman/common/validation.py rename to DSA/pykoopman/common/validation.py diff --git a/DSA/pykoopman/src/pykoopman/differentiation/__init__.py b/DSA/pykoopman/differentiation/__init__.py similarity index 100% rename from DSA/pykoopman/src/pykoopman/differentiation/__init__.py rename to DSA/pykoopman/differentiation/__init__.py diff --git a/DSA/pykoopman/src/pykoopman/differentiation/_derivative.py b/DSA/pykoopman/differentiation/_derivative.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/differentiation/_derivative.py rename to DSA/pykoopman/differentiation/_derivative.py index 52c94dc..26fc6ba 100644 --- a/DSA/pykoopman/src/pykoopman/differentiation/_derivative.py +++ b/DSA/pykoopman/differentiation/_derivative.py @@ -2,6 +2,7 @@ Some default values used here may differ from those used in :doc:`derivative:index`. """ + from __future__ import annotations from derivative import dxdt diff --git a/DSA/pykoopman/src/pykoopman/differentiation/_finite_difference.py b/DSA/pykoopman/differentiation/_finite_difference.py similarity index 100% rename from DSA/pykoopman/src/pykoopman/differentiation/_finite_difference.py rename to DSA/pykoopman/differentiation/_finite_difference.py diff --git a/DSA/pykoopman/src/pykoopman/koopman.py b/DSA/pykoopman/koopman.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/koopman.py rename to DSA/pykoopman/koopman.py index 4330a68..8b008dd 100644 --- a/DSA/pykoopman/src/pykoopman/koopman.py +++ b/DSA/pykoopman/koopman.py @@ -1,4 +1,5 @@ """module for discrete time Koopman class""" + from __future__ import annotations from warnings import catch_warnings diff --git a/DSA/pykoopman/src/pykoopman/koopman_continuous.py b/DSA/pykoopman/koopman_continuous.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/koopman_continuous.py rename to DSA/pykoopman/koopman_continuous.py index 2ba881d..b02fcad 100644 --- a/DSA/pykoopman/src/pykoopman/koopman_continuous.py +++ b/DSA/pykoopman/koopman_continuous.py @@ -1,4 +1,5 @@ """module for continuous time Koopman class""" + from __future__ import annotations import numpy as np diff --git a/DSA/pykoopman/src/pykoopman/observables/__init__.py b/DSA/pykoopman/observables/__init__.py similarity index 100% rename from DSA/pykoopman/src/pykoopman/observables/__init__.py rename to DSA/pykoopman/observables/__init__.py diff --git a/DSA/pykoopman/src/pykoopman/observables/_base.py b/DSA/pykoopman/observables/_base.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/observables/_base.py rename to DSA/pykoopman/observables/_base.py index 2d9af34..62b0fca 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_base.py +++ b/DSA/pykoopman/observables/_base.py @@ -1,4 +1,5 @@ """Module for base classes for specific observable classes.""" + from __future__ import annotations import abc @@ -295,7 +296,7 @@ def transform(self, X): # Handle 3D data (multiple trials) by processing each trial separately if isinstance(X, list): return [self.transform(X_trial) for X_trial in X] - + if X.ndim == 3: return np.array([self.transform(X_trial) for X_trial in X]) @@ -372,7 +373,7 @@ def inverse(self, y): Args: y (numpy.ndarray): Data to which to apply the inverse. - Shape must be (n_samples, n_output_features) or + Shape must be (n_samples, n_output_features) or (n_trials, n_samples, n_output_features). Must have the same number of features as the transformed data. @@ -391,7 +392,7 @@ def inverse(self, y): # Handle 3D data (multiple trials) by processing each trial separately if isinstance(y, list): return [self.inverse(y_trial) for y_trial in y] - + if y.ndim == 3: return np.array([self.inverse(y_trial) for y_trial in y]) diff --git a/DSA/pykoopman/src/pykoopman/observables/_custom_observables.py b/DSA/pykoopman/observables/_custom_observables.py similarity index 98% rename from DSA/pykoopman/src/pykoopman/observables/_custom_observables.py rename to DSA/pykoopman/observables/_custom_observables.py index 6d9cefb..541087f 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_custom_observables.py +++ b/DSA/pykoopman/observables/_custom_observables.py @@ -1,4 +1,5 @@ """Module for customized observables""" + from __future__ import annotations from itertools import combinations @@ -114,9 +115,9 @@ def fit(self, x, y=None): self.measurement_matrix_ = np.zeros( (self.n_input_features_, self.n_output_features_) ) - self.measurement_matrix_[ - : self.n_input_features_, : self.n_input_features_ - ] = np.eye(self.n_input_features_) + self.measurement_matrix_[: self.n_input_features_, : self.n_input_features_] = ( + np.eye(self.n_input_features_) + ) return self diff --git a/DSA/pykoopman/src/pykoopman/observables/_identity.py b/DSA/pykoopman/observables/_identity.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/observables/_identity.py rename to DSA/pykoopman/observables/_identity.py index 3f7ceb0..47d24c0 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_identity.py +++ b/DSA/pykoopman/observables/_identity.py @@ -1,4 +1,5 @@ """module for Linear observables""" + from __future__ import annotations import numpy as np diff --git a/DSA/pykoopman/src/pykoopman/observables/_polynomial.py b/DSA/pykoopman/observables/_polynomial.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/observables/_polynomial.py rename to DSA/pykoopman/observables/_polynomial.py index 5e852de..f749a4f 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_polynomial.py +++ b/DSA/pykoopman/observables/_polynomial.py @@ -1,4 +1,5 @@ """moduel for Polynomial observables""" + from __future__ import annotations from itertools import chain diff --git a/DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py b/DSA/pykoopman/observables/_radial_basis_functions.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py rename to DSA/pykoopman/observables/_radial_basis_functions.py index 217f485..2363722 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_radial_basis_functions.py +++ b/DSA/pykoopman/observables/_radial_basis_functions.py @@ -1,4 +1,5 @@ """module for Radial basis function observables""" + from __future__ import annotations import numpy as np diff --git a/DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py b/DSA/pykoopman/observables/_random_fourier_features.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py rename to DSA/pykoopman/observables/_random_fourier_features.py index a9ebec7..af9f690 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_random_fourier_features.py +++ b/DSA/pykoopman/observables/_random_fourier_features.py @@ -1,4 +1,5 @@ """module for random fourier features observables""" + from __future__ import annotations import numpy as np diff --git a/DSA/pykoopman/src/pykoopman/observables/_time_delay.py b/DSA/pykoopman/observables/_time_delay.py similarity index 98% rename from DSA/pykoopman/src/pykoopman/observables/_time_delay.py rename to DSA/pykoopman/observables/_time_delay.py index eb0c9db..038dd2b 100644 --- a/DSA/pykoopman/src/pykoopman/observables/_time_delay.py +++ b/DSA/pykoopman/observables/_time_delay.py @@ -1,4 +1,5 @@ """moduel for time-delay observables""" + from __future__ import annotations import numpy as np @@ -102,9 +103,9 @@ def fit(self, x, y=None): self.measurement_matrix_ = np.zeros( (self.n_input_features_, self.n_output_features_) ) - self.measurement_matrix_[ - : self.n_input_features_, : self.n_input_features_ - ] = np.eye(self.n_input_features_) + self.measurement_matrix_[: self.n_input_features_, : self.n_input_features_] = ( + np.eye(self.n_input_features_) + ) return self diff --git a/DSA/pykoopman/src/pykoopman/regression/__init__.py b/DSA/pykoopman/regression/__init__.py similarity index 100% rename from DSA/pykoopman/src/pykoopman/regression/__init__.py rename to DSA/pykoopman/regression/__init__.py diff --git a/DSA/pykoopman/src/pykoopman/regression/_base.py b/DSA/pykoopman/regression/_base.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_base.py rename to DSA/pykoopman/regression/_base.py index 6c49394..cf76532 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_base.py +++ b/DSA/pykoopman/regression/_base.py @@ -1,4 +1,5 @@ """module for base class of regressor""" + from __future__ import annotations from abc import ABC diff --git a/DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py b/DSA/pykoopman/regression/_base_ensemble.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py rename to DSA/pykoopman/regression/_base_ensemble.py index 53f7f16..41c4949 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_base_ensemble.py +++ b/DSA/pykoopman/regression/_base_ensemble.py @@ -2,6 +2,7 @@ Manual changes are made to add support to complex numeric data """ + from __future__ import annotations from sklearn.base import BaseEstimator diff --git a/DSA/pykoopman/src/pykoopman/regression/_dmd.py b/DSA/pykoopman/regression/_dmd.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_dmd.py rename to DSA/pykoopman/regression/_dmd.py index d447571..130cbb0 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_dmd.py +++ b/DSA/pykoopman/regression/_dmd.py @@ -1,4 +1,5 @@ """module for dmd""" + # from warnings import warn from __future__ import annotations diff --git a/DSA/pykoopman/src/pykoopman/regression/_dmdc.py b/DSA/pykoopman/regression/_dmdc.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_dmdc.py rename to DSA/pykoopman/regression/_dmdc.py index 9de8a5d..da37439 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_dmdc.py +++ b/DSA/pykoopman/regression/_dmdc.py @@ -1,4 +1,5 @@ """module for dmd with control""" + from __future__ import annotations import numpy as np diff --git a/DSA/pykoopman/src/pykoopman/regression/_edmd.py b/DSA/pykoopman/regression/_edmd.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_edmd.py rename to DSA/pykoopman/regression/_edmd.py index 409028b..c27d781 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_edmd.py +++ b/DSA/pykoopman/regression/_edmd.py @@ -1,4 +1,5 @@ """module for extended dmd""" + # from warnings import warn from __future__ import annotations diff --git a/DSA/pykoopman/src/pykoopman/regression/_edmdc.py b/DSA/pykoopman/regression/_edmdc.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_edmdc.py rename to DSA/pykoopman/regression/_edmdc.py index 1826a65..56e8c81 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_edmdc.py +++ b/DSA/pykoopman/regression/_edmdc.py @@ -1,4 +1,5 @@ """module for extended dmd with control""" + from __future__ import annotations import numpy as np diff --git a/DSA/pykoopman/src/pykoopman/regression/_havok.py b/DSA/pykoopman/regression/_havok.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_havok.py rename to DSA/pykoopman/regression/_havok.py index 0273ebd..ada1a16 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_havok.py +++ b/DSA/pykoopman/regression/_havok.py @@ -1,4 +1,5 @@ """module for havok""" + from __future__ import annotations from warnings import warn diff --git a/DSA/pykoopman/src/pykoopman/regression/_kdmd.py b/DSA/pykoopman/regression/_kdmd.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_kdmd.py rename to DSA/pykoopman/regression/_kdmd.py index 6e33111..550ff20 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_kdmd.py +++ b/DSA/pykoopman/regression/_kdmd.py @@ -1,4 +1,5 @@ """module for kernel dmd""" + from __future__ import annotations from warnings import warn diff --git a/DSA/pykoopman/src/pykoopman/regression/_nndmd.py b/DSA/pykoopman/regression/_nndmd.py similarity index 99% rename from DSA/pykoopman/src/pykoopman/regression/_nndmd.py rename to DSA/pykoopman/regression/_nndmd.py index 2518761..b9e6018 100644 --- a/DSA/pykoopman/src/pykoopman/regression/_nndmd.py +++ b/DSA/pykoopman/regression/_nndmd.py @@ -1,4 +1,5 @@ """module for implementing a neural network DMD""" + from __future__ import annotations import pickle @@ -8,7 +9,7 @@ import lightning as L import numpy as np import torch -from pykoopman.regression._base import BaseRegressor +from DSA.pykoopman.regression._base import BaseRegressor from sklearn.utils.validation import check_is_fitted from torch import nn from torch.nn.utils.rnn import pad_sequence diff --git a/DSA/pykoopman/src/pykoopman/common/cqgle.py b/DSA/pykoopman/src/pykoopman/common/cqgle.py deleted file mode 100644 index f91e230..0000000 --- a/DSA/pykoopman/src/pykoopman/common/cqgle.py +++ /dev/null @@ -1,234 +0,0 @@ -"""Module for cubic-quintic Ginzburg-Landau equation.""" -from __future__ import annotations - -import numpy as np -from matplotlib import pyplot as plt -from mpl_toolkits.mplot3d import Axes3D -from pykoopman.common.examples import rk4 -from scipy.fft import fft -from scipy.fft import fftfreq -from scipy.fft import ifft - - -class cqgle: - """ - Cubic-quintic Ginzburg-Landau equation solver. - - Solves the equation: - i*u_t + (0.5 - i * tau) u_{xx} - i * kappa u_{xxxx} + (1-i * beta)|u|^2 u + - (nu - i * sigma)|u|^4 u - i * gamma u = 0 - - Solves the periodic boundary conditions PDE using spectral methods. - - Attributes: - n_states (int): Number of states. - x (numpy.ndarray): x-coordinates. - dt (float): Time step. - tau (float): Parameter tau. - kappa (float): Parameter kappa. - beta (float): Parameter beta. - nu (float): Parameter nu. - sigma (float): Parameter sigma. - gamma (float): Parameter gamma. - k (numpy.ndarray): Wave numbers. - dk (float): Wave number spacing. - - Methods: - sys(t, x, u): System dynamics function. - simulate(x0, n_int, n_sample): Simulate the system for a given initial - condition. - collect_data_continuous(x0): Collect training data pairs in continuous sense. - collect_one_step_data_discrete(x0): Collect training data pairs in discrete - sense. - collect_one_trajectory_data(x0, n_int, n_sample): Collect data for one - trajectory. - visualize_data(x, t, X): Visualize the data in physical space. - visualize_state_space(X): Visualize the data in state space. - """ - - def __init__( - self, - n, - x, - dt, - tau=0.08, - kappa=0, - beta=0.66, - nu=-0.1, - sigma=-0.1, - gamma=-0.1, - L=2 * np.pi, - ): - self.n_states = n - self.x = x - - self.tau = tau - self.kappa = kappa - self.beta = beta - self.nu = nu - self.sigma = sigma - self.gamma = gamma - - dk = 2 * np.pi / L - self.k = fftfreq(self.n_states, 1.0 / self.n_states) * dk - self.dt = dt - - def sys(self, t, x, u): - xk = fft(x) - - # 1/3 truncation rule - xk[self.n_states // 6 : 5 * self.n_states // 6] = 0j - x = ifft(xk) - - tmp_1_k = (0.5 - 1j * self.tau) * (-self.k**2) * xk - tmp_2_k = -1j * self.kappa * self.k**4 * xk - tmp_3_k = fft( - (1 - 1j * self.beta) * abs(x) ** 2 * x - + (self.nu - 1j * self.sigma) * abs(x) ** 4 * x - ) - tmp_4_k = -1j * self.gamma * xk - - # return back to physical space - y = ifft(1j * (tmp_1_k + tmp_2_k + tmp_3_k + tmp_4_k)) - return y - - def simulate(self, x0, n_int, n_sample): - # n_traj = x0.shape[1] - x = x0 - u = np.zeros((n_int, 1), dtype=complex) - X = np.zeros((n_int // n_sample, self.n_states), dtype=complex) - t = 0 - j = 0 - t_list = [] - for step in range(n_int): - t += self.dt - y = rk4(0, x, u[step], self.dt, self.sys) - if (step + 1) % n_sample == 0: - X[j] = y - j += 1 - t_list.append(t) - x = y - return X, np.array(t_list) - - def collect_data_continuous(self, x0): - """ - collect training data pairs - continuous sense. - - given x0, with shape (n_dim, n_traj), the function - returns dx/dt with shape (n_dim, n_traj) - """ - - n_traj = x0.shape[0] - u = np.zeros((n_traj, 1)) - X = x0 - Y = [] - for i in range(n_traj): - y = self.sys(0, x0[i], u[i]) - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_step_data_discrete(self, x0): - """ - collect training data pairs - discrete sense. - - given x0, with shape (n_dim, n_traj), the function - returns system state x1 after self.dt with shape - (n_dim, n_traj) - """ - - n_traj = x0.shape[0] - X = x0 - Y = [] - for i in range(n_traj): - y, _ = self.simulate(x0[i], n_int=1, n_sample=1) - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_trajectory_data(self, x0, n_int, n_sample): - x = x0 - y, _ = self.simulate(x, n_int, n_sample) - return y - - def visualize_data(self, x, t, X): - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - for i in range(X.shape[0]): - ax.plot(x, abs(X[i]), zs=t[i], zdir="t", label="time = " + str(i * self.dt)) - # plt.legend(loc='best') - ax.view_init(elev=35.0, azim=-65, vertical_axis="y") - ax.set(ylabel=r"$mag. of. u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") - plt.title("CQGLE (Kutz et al., Complexity, 2018)") - plt.show() - - def visualize_state_space(self, X): - u, s, vt = np.linalg.svd(X, full_matrices=False) - # this is a pde problem so the number of snapshots are smaller than dof - pca_1_r, pca_1_i = np.real(u[:, 0]), np.imag(u[:, 0]) - pca_2_r, pca_2_i = np.real(u[:, 1]), np.imag(u[:, 1]) - pca_3_r, pca_3_i = np.real(u[:, 2]), np.imag(u[:, 2]) - - plt.figure(figsize=(6, 6)) - plt.semilogy(s) - plt.xlabel("number of SVD terms") - plt.ylabel("singular values") - plt.title("PCA singular value decays") - plt.show() - - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - ax.plot3D(pca_1_r, pca_2_r, pca_3_r, "k-o") - ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") - plt.title("PCA visualization (real)") - plt.show() - - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - ax.plot3D(pca_1_i, pca_2_i, pca_3_i, "k-o") - ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") - plt.title("PCA visualization (imag)") - plt.show() - - -if __name__ == "__main__": - n = 512 - x = np.linspace(-10, 10, n, endpoint=False) - u0 = np.exp(-((x) ** 2)) - # u0 = 2.0 / np.cosh(x) - # u0 = u0.reshape(-1,1) - n_int = 9000 - n_snapshot = 300 - dt = 40.0 / n_int - n_sample = n_int // n_snapshot - - model = cqgle(n, x, dt, L=20) - X, t = model.simulate(u0, n_int, n_sample) - - print(X.shape) - print(X[:, -1].max()) - - # usage: visualize the data in physical space - model.visualize_data(x, t, X) - print(t) - - # usage: visualize the data in state space - model.visualize_state_space(X) - - # usage: collect continuous data pair: x and dx/dt - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_data_continuous(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect discrete data pair - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_one_step_data_discrete(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect one trajectory data - X = model.collect_one_trajectory_data(u0, n_int, n_sample) - print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/common/examples.py b/DSA/pykoopman/src/pykoopman/common/examples.py deleted file mode 100644 index ae2ff22..0000000 --- a/DSA/pykoopman/src/pykoopman/common/examples.py +++ /dev/null @@ -1,1045 +0,0 @@ -"""module for example dynamics data""" -from __future__ import annotations - -import matplotlib as mpl -import matplotlib.pyplot as plt -import numpy as np -from scipy.linalg import orth - - -def drss( - n=2, p=2, m=2, p_int_first=0.1, p_int_others=0.01, p_repeat=0.05, p_complex=0.5 -): - """ - Create a discrete-time, random, stable, linear state space model. - - Args: - n (int, optional): Number of states. Default is 2. - p (int, optional): Number of control inputs. Default is 2. - m (int, optional): Number of output measurements. - If m=0, C becomes the identity matrix, so that y=x. Default is 2. - p_int_first (float, optional): Probability of an integrator as the first pole. - Default is 0.1. - p_int_others (float, optional): Probability of other integrators beyond the - first. Default is 0.01. - p_repeat (float, optional): Probability of repeated roots. Default is 0.05. - p_complex (float, optional): Probability of complex roots. Default is 0.5. - - Returns: - Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]: A tuple containing the - state transition matrix (A), control matrix (B), and measurement matrix (C). - - A (numpy.ndarray): State transition matrix of shape (n, n). - B (numpy.ndarray): Control matrix of shape (n, p). - C (numpy.ndarray): Measurement matrix of shape (m, n). If m = 0, C is the - identity matrix. - - """ - - # Number of integrators - nint = int( - (np.random.rand(1) < p_int_first) + sum(np.random.rand(n - 1) < p_int_others) - ) - # Number of repeated roots - nrepeated = int(np.floor(sum(np.random.rand(n - nint) < p_repeat) / 2)) - # Number of complex roots - ncomplex = int( - np.floor(sum(np.random.rand(n - nint - 2 * nrepeated, 1) < p_complex) / 2) - ) - nreal = n - nint - 2 * nrepeated - 2 * ncomplex - - # Random poles - rep = 2 * np.random.rand(nrepeated) - 1 - if ncomplex != 0: - mag = np.random.rand(ncomplex) - cplx = np.zeros(ncomplex, dtype=complex) - for i in range(ncomplex): - cplx[i] = mag[i] * np.exp(complex(0, np.pi * np.random.rand(1))) - re = np.real(cplx) - im = np.imag(cplx) - - # Generate random state space model - A = np.zeros((n, n)) - if ncomplex != 0: - for i in range(0, ncomplex): - A[2 * i : 2 * i + 2, 2 * i : 2 * i + 2] = np.array( - [[re[i], im[i]], [-im[i], re[i]]] - ) - - if 2 * ncomplex < n: - list_poles = [] - if nint: - list_poles = np.append(list_poles, np.ones(nint)) - if rep: - list_poles = np.append(list_poles, rep) - list_poles = np.append(list_poles, rep) - if nreal: - list_poles = np.append(list_poles, 2 * np.random.rand(nreal) - 1) - - A[2 * ncomplex :, 2 * ncomplex :] = np.diag(list_poles) - - T = orth(np.random.rand(n, n)) - A = np.transpose(T) @ (A @ T) - - # control matrix - B = np.random.randn(n, p) - # mask for nonzero entries in B - mask = np.random.rand(B.shape[0], B.shape[1]) - B = np.squeeze(np.multiply(B, [(mask < 0.75) != 0])) - - # Measurement matrix - if m == 0: - C = np.identity(n) - else: - C = np.random.randn(m, n) - mask = np.random.rand(C.shape[0], C.shape[1]) - C = np.squeeze(C * [(mask < 0.75) != 0]) - - return A, B, C - - -def advance_linear_system(x0, u, n, A=None, B=None, C=None): - """ - Simulate the linear system dynamics for a given number of steps. - - Args: - x0 (numpy.ndarray): Initial state vector of shape (n,). - u (numpy.ndarray): Control input array of shape (p,) or (p, n-1). - If 1-dimensional, it will be converted to a row vector. - n (int): Number of steps to simulate. - A (numpy.ndarray, optional): State transition matrix of shape (n, n). - If not provided, it defaults to None. - B (numpy.ndarray, optional): Control matrix of shape (n, p). - If not provided, it defaults to None. - C (numpy.ndarray, optional): Measurement matrix of shape (m, n). - If not provided, it defaults to None. - - Returns: - Tuple[numpy.ndarray, numpy.ndarray]: A tuple containing the state trajectory - (x) and the output trajectory (y). - - x (numpy.ndarray): State trajectory of shape (n, len(x0)). - y (numpy.ndarray): Output trajectory of shape (n, C.shape[0]). - - """ - if C is None: - C = np.identity(len(x0)) - if u.ndim == 1: - u = u[np.newaxis, :] - - y = np.zeros([n, C.shape[0]]) - x = np.zeros([n, len(x0)]) - x[0, :] = x0 - y[0, :] = C.dot(x[0, :]) - for i in range(n - 1): - x[i + 1, :] = A.dot(x[i, :]) + B.dot(u[:, i]) - y[i + 1, :] = C.dot(x[i + 1, :]) - return x, y - - -def vdp_osc(t, x, u): - """ - Compute the dynamics of the Van der Pol oscillator. - - Args: - t (float): Time. - x (numpy.ndarray): State vector of shape (2,). - u (float): Control input. - - Returns: - numpy.ndarray: Updated state vector of shape (2,). - - """ - y = np.zeros(x.shape) - y[0, :] = 2 * x[1, :] - y[1, :] = -0.8 * x[0, :] + 2 * x[1, :] - 10 * (x[0, :] ** 2) * x[1, :] + u - return y - - -def rk4(t, x, u, _dt=0.01, func=vdp_osc): - """ - Perform a 4th order Runge-Kutta integration. - - Args: - t (float): Time. - x (numpy.ndarray): State vector of shape (2,). - u (float): Control input. - _dt (float, optional): Time step. Defaults to 0.01. - func (function, optional): Function defining the dynamics. Defaults to vdp_osc. - - Returns: - numpy.ndarray: Updated state vector of shape (2,). - - """ - # 4th order Runge-Kutta - k1 = func(t, x, u) - k2 = func(t, x + k1 * _dt / 2, u) - k3 = func(t, x + k2 * _dt / 2, u) - k4 = func(t, x + k1 * _dt, u) - return x + (_dt / 6) * (k1 + 2 * k2 + 2 * k3 + k4) - - -def square_wave(step): - """ - Generate a square wave with a period of 60 time steps. - - Args: - step (int): Current time step. - - Returns: - float: Square wave value at the given time step. - - """ - return (-1.0) ** (round(step / 30.0)) - - -def sine_wave(step): - """ - Generate a sine wave with a period of 60 time steps. - - Args: - step (int): Current time step. - - Returns: - float: Sine wave value at the given time step. - - """ - return np.sin(round(step / 30.0)) - - -def lorenz(x, t, sigma=10, beta=8 / 3, rho=28): - """ - Compute the derivative of the Lorenz system at a given state. - - Args: - x (list): Current state of the Lorenz system [x, y, z]. - t (float): Current time. - sigma (float, optional): Parameter sigma. Default is 10. - beta (float, optional): Parameter beta. Default is 8/3. - rho (float, optional): Parameter rho. Default is 28. - - Returns: - list: Derivative of the Lorenz system [dx/dt, dy/dt, dz/dt]. - - """ - return [ - sigma * (x[1] - x[0]), - x[0] * (rho - x[2]) - x[1], - x[0] * x[1] - beta * x[2], - ] - - -def rev_dvdp(t, x, u=0, dt=0.1): - """ - Reverse dynamics of the Van der Pol oscillator. - - Args: - t (float): Time. - x (numpy.ndarray): Current state of the system [x1, x2]. - u (float, optional): Input. Default is 0. - dt (float, optional): Time step. Default is 0.1. - - Returns: - numpy.ndarray: Updated state of the system [x1', x2']. - - """ - return np.array( - [ - x[0, :] - x[1, :] * dt, - x[1, :] + (x[0, :] - x[1, :] + x[0, :] ** 2 * x[1, :]) * dt, - ] - ) - - -class Linear2Ddynamics: - def __init__(self): - """ - Initializes a Linear2Ddynamics object. - - """ - self.n_states = 2 # Number of states - - def linear_map(self, x): - """ - Applies the linear mapping to the input state. - - Args: - x (numpy.ndarray): Input state. - - Returns: - numpy.ndarray: Resulting mapped state. - - """ - return np.array([[0.8, -0.05], [0, 0.7]]) @ x - - def collect_data(self, x, n_int, n_traj): - """ - Collects data by integrating the linear dynamics. - - Args: - x (numpy.ndarray): Initial state. - n_int (int): Number of integration steps. - n_traj (int): Number of trajectories. - - Returns: - numpy.ndarray: Input data. - numpy.ndarray: Output data. - - """ - # Init - X = np.zeros((self.n_states, n_int * n_traj)) - Y = np.zeros((self.n_states, n_int * n_traj)) - - # Integrate - for step in range(n_int): - y = self.linear_map(x) - X[:, (step) * n_traj : (step + 1) * n_traj] = x - Y[:, (step) * n_traj : (step + 1) * n_traj] = y - x = y - - return X, Y - - def visualize_modes(self, x, phi, eigvals, order=None): - """ - Visualizes the modes of the linear dynamics. - - Args: - x (numpy.ndarray): State data. - phi (numpy.ndarray): Eigenvectors. - eigvals (numpy.ndarray): Eigenvalues. - order (list, optional): Order of the modes to visualize. Default is None. - - """ - n_modes = min(10, phi.shape[1]) - fig, axs = plt.subplots(2, n_modes, figsize=(3 * n_modes, 6)) - if order is None: - index_list = range(n_modes) - else: - index_list = order - j = 0 - for i in index_list: - axs[0, j].scatter( - x[0, :], - x[1, :], - c=np.real(phi[:, i]), - marker="o", - cmap=plt.get_cmap("jet"), - ) - axs[1, j].scatter( - x[0, :], - x[1, :], - c=np.imag(phi[:, i]), - marker="o", - cmap=plt.get_cmap("jet"), - ) - axs[0, j].set_title(r"$\lambda$=" + "{:2.3f}".format(eigvals[i])) - j += 1 - - -class torus_dynamics: - """ - Sparse dynamics in Fourier space on torus. - - Attributes: - n_states (int): Number of states. - sparsity (int): Degree of sparsity. - freq_max (int): Maximum frequency. - noisemag (float): Magnitude of noise. - - Methods: - __init__(self, n_states=128, sparsity=5, freq_max=15, noisemag=0.0): - Initializes a torus_dynamics object. - - setup(self): - Sets up the dynamics. - - advance(self, n_samples, dt=1): - Advances the continuous-time dynamics without control. - - advance_discrete_time(self, n_samples, dt, u=None): - Advances the discrete-time dynamics with or without control. - - set_control_matrix_physical(self, B): - Sets the control matrix in physical space. - - set_control_matrix_fourier(self, Bhat): - Sets the control matrix in Fourier space. - - set_point_actuator(self, position=None): - Sets a single point actuator. - - viz_setup(self): - Sets up the visualization. - - viz_torus(self, ax, x): - Visualizes the torus dynamics. - - viz_all_modes(self, modes=None): - Visualizes all modes. - - modes(self): - Returns the modes of the dynamics. - - B_effective(self): - Returns the effective control matrix. - - """ - - def __init__(self, n_states=128, sparsity=5, freq_max=15, noisemag=0.0): - """ - Initializes a torus_dynamics object. - - Args: - n_states (int, optional): Number of states. Default is 128. - sparsity (int, optional): Degree of sparsity. Default is 5. - freq_max (int, optional): Maximum frequency. Default is 15. - noisemag (float, optional): Magnitude of noise. Default is 0.0. - - """ - self.n_states = n_states - self.sparsity = sparsity - self.freq_max = freq_max - self.noisemag = noisemag - self.setup() - - def setup(self): - """ - Sets up the dynamics. - - """ - # Initialization in the Fourier space - xhat = np.zeros((self.n_states, self.n_states), complex) - # Index of nonzero frequency components - self.J = np.zeros((self.sparsity, 2), dtype=int) - IC = np.zeros(self.sparsity) # Initial condition, real number - frequencies = np.zeros(self.sparsity) - damping = np.zeros(self.sparsity) - - IC = np.random.randn(self.sparsity) - frequencies = np.sqrt(4 * np.random.rand(self.sparsity)) - damping = -np.random.rand(self.sparsity) * 0.1 - for k in range(self.sparsity): - loopbreak = 0 - while loopbreak != 1: - self.J[k, 0] = np.ceil( - np.random.rand(1) * self.n_states / (self.freq_max + 1) - ) - self.J[k, 1] = np.ceil( - np.random.rand(1) * self.n_states / (self.freq_max + 1) - ) - if xhat[self.J[k, 0], self.J[k, 1]] == 0.0: - loopbreak = 1 - - xhat[self.J[k, 0], self.J[k, 1]] = IC[k] - - mask = np.zeros((self.n_states, self.n_states), int) - for k in range(self.sparsity): - mask[self.J[k, 0], self.J[k, 1]] = 1 - - self.damping = damping - self.frequencies = frequencies - self.IC = IC - self.xhat = xhat - self.mask = mask - - def advance(self, n_samples, dt=1): - """ - Advances the continuous-time dynamics without control. - - Args: - n_samples (int): Number of samples to advance. - dt (float, optional): Time step. Default is 1. - - """ - print("Evolving continuous-time dynamics without control.") - self.n_samples = n_samples - self.dt = dt - - # Initilization - # In physical space - self.X = np.ndarray((self.n_states**2, self.n_samples)) - # In Fourier space - self.Xhat = np.ndarray((self.n_states**2, self.n_samples), complex) - self.time_vector = np.zeros(self.n_samples) - - # if self.noisemag != 0: - # self.XhatClean = np.ndarray((self.n_states**2, self.n_samples), complex) - # self.XClean = np.ndarray((self.n_states**2, self.n_samples)) - - for step in range(self.n_samples): - t = step * self.dt - self.time_vector[step] = t - xhat = np.zeros((self.n_states, self.n_states), complex) - for k in range(self.sparsity): - xhat[self.J[k, 0], self.J[k, 1]] = ( - np.exp((self.damping[k] + 1j * 2 * np.pi * self.frequencies[k]) * t) - * self.IC[k] - ) - - if self.noisemag != 0: - self.XhatClean[:, step] = xhat.reshape(self.n_states**2) - xClean = np.real(np.fft.ifft2(xhat)) - self.XClean[:, step] = xClean.reshape(self.n_states**2) - - # xRMS = np.sqrt(np.mean(xhat.reshape((self.n_states**2,1))**2)) - # xhat = xhat + self.noisemag*xRMS\ - # *np.random.randn(xhat.shape[0],xhat.shape[1]) \ - # + 1j*self.noisemag*xRMS \ - # *np.random.randn(xhat.shape[0],xhat.shape[1]) - self.Xhat[:, step] = xhat.reshape(self.n_states**2) - x = np.real(np.fft.ifft2(xhat)) - self.X[:, step] = x.reshape(self.n_states**2) - - def advance_discrete_time(self, n_samples, dt, u=None): - """ - Advances the discrete-time dynamics with or without control. - - Args: - n_samples (int): Number of samples to advance. - dt (float): Time step. - u (array-like, optional): Control input. Default is None. - - """ - print("Evolving discrete-time dynamics with or without control.") - if u is None: - self.n_control_features_ = 0 - self.U = np.zeros(n_samples) - self.U = self.U[np.newaxis, :] - print("No control input provided. Evolving unforced system.") - else: - if u.ndim == 1: - if len(u) > n_samples: - u = u[:-1] - self.U = u[np.newaxis, :] - elif u.ndim == 2: - if u.shape[0] > n_samples: - u = u[:-1, :] - self.U = u - self.n_control_features_ = self.U.shape[1] - - if not hasattr(self, "B"): - B = np.zeros((self.n_states, self.n_states)) - print(B.shape) - self.set_control_matrix_physical(B) - print("Control matrix is not set. Continue with unforced system.") - - self.n_samples = n_samples - self.dt = dt - - # Initilization - # In physical space - self.X = np.ndarray((self.n_states**2, self.n_samples)) - # In Fourier space - self.Xhat = np.ndarray((self.n_states**2, self.n_samples), complex) - self.time_vector = np.zeros(self.n_samples) - - # Set initial condition - xhat0 = np.zeros((self.n_states, self.n_states), complex) - for k in range(self.sparsity): - xhat0[self.J[k, 0], self.J[k, 1]] = self.IC[k] - self.Xhat[:, 0] = xhat0.reshape(self.n_states**2) - x0 = np.real(np.fft.ifft2(xhat0)) - self.X[:, 0] = x0.reshape(self.n_states**2) - - for step in range(1, self.n_samples, 1): - t = step * self.dt - self.time_vector[step] = t - # self.Xhat[:, step] = np.reshape(self.Bhat * self.U[0,step - 1],\ - # self.n_states ** 2) - # xhat = self.Xhat[:,step].reshape(self.n_states,self.n_states) - # xhat_prev = \ - # self.Xhat[:, step - 1].reshape(self.n_states, self.n_states) - - # forced torus dynamics linearly evolve in the spectral space, sparsely - xhat = np.array((self.n_states, self.n_states), complex) - xhat = self.Xhat[:, step].reshape(self.n_states, self.n_states) - xhat_prev = self.Xhat[:, step - 1].reshape(self.n_states, self.n_states) - for k in range(self.sparsity): - xhat[self.J[k, 0], self.J[k, 1]] = ( - np.exp( - (self.damping[k] + 1j * 2 * np.pi * self.frequencies[k]) - * self.dt - ) - * xhat_prev[self.J[k, 0], self.J[k, 1]] - + self.Bhat[self.J[k, 0], self.J[k, 1]] * self.U[0, step - 1] - ) - - # xhat_prev = self.Xhat[:,step-1].reshape(self.n_states, self.n_states) - # for k in range(self.sparsity): - # xhat[self.J[k,0], self.J[k,1]] += np.exp((self.damping[k] \ - # + 1j * 2 * np.pi * self.frequencies[k]) * self.dt) \ - # * xhat_prev[self.J[k,0], self.J[k,1]] - - self.Xhat[:, step] = xhat.reshape(self.n_states**2) - x = np.real(np.fft.ifft2(xhat)) - self.X[:, step] = x.reshape(self.n_states**2) - - def set_control_matrix_physical(self, B): - """ - Sets the control matrix in physical space. - - Args: - B (array-like): Control matrix in physical space. - - """ - if np.allclose(B.shape, np.array([self.n_states, self.n_states])) is False: - raise TypeError("Control matrix B has wrong shape.") - self.B = B - self.Bhat = np.fft.fft2(B) - - def set_control_matrix_fourier(self, Bhat): - """ - Sets the control matrix in Fourier space. - - Args: - Bhat (array-like): Control matrix in Fourier space. - - """ - if np.allclose(Bhat.shape, np.array([self.n_states, self.n_states])) is False: - raise TypeError("Control matrix Bhat has wrong shape.") - self.Bhat = Bhat - self.B = np.real(np.fft.ifft2(self.Bhat)) - - def set_point_actuator(self, position=None): - """ - Sets a single point actuator. - - Args: - position (array-like, optional): Position of the actuator. Default is None. - - """ - if position is None: - position = np.random.randint(0, self.n_states, 2) - try: - for i in range(len(position)): - position[i] = int(position[i]) - except ValueError: - print("position was not a valid integer.") - - is_position_in_valid_domain = (position >= 0) & (position < self.n_states) - if all(is_position_in_valid_domain) is False: - raise ValueError( - "Actuator position was not a valid integer inside of domain." - ) - - # Control matrix in physical space (single point actuator) - B = np.zeros((self.n_states, self.n_states)) - B[position[0], position[1]] = 1 - self.set_control_matrix_physical(B) - - def viz_setup(self): - """ - Sets up the visualization. - - """ - self.cmap_torus = plt.cm.jet # bwr #plt.cm.RdYlBu - self.n_colors = self.n_states - r1 = 2 - r2 = 1 - [T1, T2] = np.meshgrid( - np.linspace(0, 2 * np.pi, self.n_states), - np.linspace(0, 2 * np.pi, self.n_states), - ) - R = r1 + r2 * np.cos(T2) - self.Zgrid = r2 * np.sin(T2) - self.Xgrid = R * np.cos(T1) - self.Ygrid = R * np.sin(T1) - - def viz_torus(self, ax, x): - """ - Visualizes the torus dynamics. - - Args: - ax: Axes object for plotting. - x (array-like): Dynamics to be visualized. - - Returns: - surface: Surface plot of the torus dynamics. - - """ - if not hasattr(self, "viz"): - self.viz_setup() - - norm = mpl.colors.Normalize(vmin=-abs(x).max(), vmax=abs(x).max()) - surface = ax.plot_surface( - self.Xgrid, - self.Ygrid, - self.Zgrid, - facecolors=self.cmap_torus(norm(x)), - shade=False, - rstride=1, - cstride=1, - ) - # m = cm.ScalarMappable(cmap=cmap_torus, norm=norm) - # m.set_array([]) - # plt.colorbar(m) - # ax.figure.colorbar(surf, ax=ax) - ax.set_zlim(-3.01, 3.01) - return surface - - def viz_all_modes(self, modes=None): - """ - Visualizes all modes. - - Args: - modes (array-like, optional): Modes to be visualized. Default is None. - - Returns: - fig: Figure object containing the visualizations. - - """ - if modes is None: - modes = self.modes - - if not hasattr(self, "viz"): - self.viz_setup() - - fig = plt.figure(figsize=(20, 10)) - for k in range(self.sparsity): - ax = plt.subplot2grid((1, self.sparsity), (0, k), projection="3d") - self.viz_torus(ax, modes[:, k].reshape(self.n_states, self.n_states)) - plt.axis("off") - return fig - - @property - def modes(self): - """ - Returns the modes of the dynamics. - - Returns: - modes (array-like): Modes of the dynamics. - - """ - modes = np.zeros((self.n_states**2, self.sparsity)) - - for k in range(self.sparsity): - mode_in_fourier = np.zeros((self.n_states, self.n_states)) - mode_in_fourier[self.J[k, 0], self.J[k, 1]] = 1 - modes[:, k] = np.real( - np.fft.ifft2(mode_in_fourier).reshape(self.n_states**2) - ) - - return modes - - @property - def B_effective(self): - """ - Returns the effective control matrix. - - Returns: - B_effective (array-like): Effective control matrix. - - """ - Bhat_effective = np.zeros((self.n_states, self.n_states), complex) - for k in range(self.sparsity): - control_mode = np.zeros((self.n_states, self.n_states), complex) - control_mode[self.J[k, 0], self.J[k, 1]] = self.Bhat[ - self.J[k, 0], self.J[k, 1] - ] - Bhat_effective += control_mode - B_effective = np.fft.ifft2(Bhat_effective) - - return B_effective - - -class slow_manifold: - """ - Represents the slow manifold class. - - Args: - mu (float, optional): Parameter mu. Default is -0.05. - la (float, optional): Parameter la. Default is -1.0. - dt (float, optional): Time step size. Default is 0.01. - - Attributes: - mu (float): Parameter mu. - la (float): Parameter la. - b (float): Value computed from mu and la. - dt (float): Time step size. - n_states (int): Number of states. - - Methods: - sys(t, x, u): Computes the system dynamics. - output(x): Computes the output based on the state. - simulate(x0, n_int): Simulates the system dynamics. - collect_data_continuous(x0): Collects data from continuous-time dynamics. - collect_data_discrete(x0, n_int): Collects data from discrete-time dynamics. - visualize_trajectories(t, X, n_traj): Visualizes the trajectories. - visualize_state_space(X, Y, n_traj): Visualizes the state space. - """ - - def __init__(self, mu=-0.05, la=-1.0, dt=0.01): - self.mu = mu - self.la = la - self.b = self.la / (self.la - 2 * self.mu) - self.dt = dt - self.n_states = 2 - - def sys(self, t, x, u): - """ - Computes the system dynamics. - - Args: - t (float): Time. - x (array-like): State. - u (array-like): Control input. - - Returns: - array-like: Computed system dynamics. - - """ - return np.array([self.mu * x[0, :], self.la * (x[1, :] - x[0, :] ** 2)]) - - def output(self, x): - """ - Computes the output based on the state. - - Args: - x (array-like): State. - - Returns: - array-like: Computed output. - - """ - return x[0, :] ** 2 + x[1, :] - - def simulate(self, x0, n_int): - """ - Simulates the system dynamics. - - Args: - x0 (array-like): Initial state. - n_int (int): Number of integration steps. - - Returns: - array-like: Simulated trajectory. - - """ - n_traj = x0.shape[1] - x = x0 - u = np.zeros((n_int, 1)) - X = np.zeros((self.n_states, n_int * n_traj)) - for step in range(n_int): - y = rk4(0, x, u[step, :], self.dt, self.sys) - X[:, (step) * n_traj : (step + 1) * n_traj] = y - x = y - return X - - def collect_data_continuous(self, x0): - """ - Collects data from continuous-time dynamics. - - Args: - x0 (array-like): Initial state. - - Returns: - tuple: Collected data (X, Y). - - """ - n_traj = x0.shape[1] - u = np.zeros((1, n_traj)) - X = x0 - Y = self.sys(0, x0, u) - return X, Y - - def collect_data_discrete(self, x0, n_int): - """ - Collects data from discrete-time dynamics. - - Args: - x0 (array-like): Initial state. - n_int (int): Number of integration steps. - - Returns: - tuple: Collected data (X, Y). - - """ - n_traj = x0.shape[1] - x = x0 - u = np.zeros((n_int, n_traj)) - X = np.zeros((self.n_states, n_int * n_traj)) - Y = np.zeros((self.n_states, n_int * n_traj)) - for step in range(n_int): - y = rk4(0, x, u[step, :], self.dt, self.sys) - X[:, (step) * n_traj : (step + 1) * n_traj] = x - Y[:, (step) * n_traj : (step + 1) * n_traj] = y - x = y - return X, Y - - def visualize_trajectories(self, t, X, n_traj): - """ - Visualizes the trajectories. - - Args: - t (array-like): Time vector. - X (array-like): State trajectories. - n_traj (int): Number of trajectories. - - """ - fig, axs = plt.subplots(1, 1, tight_layout=True, figsize=(12, 4)) - for traj_idx in range(n_traj): - x = X[:, traj_idx::n_traj] - axs.plot(t[0:100], x[1, 0:100], "k") - axs.set(ylabel=r"$x_2$", xlabel=r"$t$") - - def visualize_state_space(self, X, Y, n_traj): - """ - Visualizes the state space. - - Args: - X (array-like): State trajectories. - Y (array-like): Output trajectories. - n_traj (int): Number of trajectories. - - """ - fig, axs = plt.subplots(1, 1, tight_layout=True, figsize=(4, 4)) - for traj_idx in range(n_traj): - axs.plot( - [X[0, traj_idx::n_traj], Y[0, traj_idx::n_traj]], - [X[1, traj_idx::n_traj], Y[1, traj_idx::n_traj]], - "-k", - ) - axs.set(ylabel=r"$x_2$", xlabel=r"$x_1$") - - -class forced_duffing: - """ - Forced Duffing Oscillator. - - dx1/dt = x2 - dx2/dt = -d*x2-alpha*x1-beta*x1^3 + u - - [1] S. Peitz, S. E. Otto, and C. W. Rowley, - “Data-driven model predictive control using interpolated koopman generators,” - SIAM J. Appl. Dyn. Syst., vol. 19, no. 3, pp. 2162–2193, Mar. 2020. - """ - - def __init__(self, dt, d, alpha, beta): - """ - Initializes the Forced Duffing Oscillator. - - Args: - dt (float): Time step. - d (float): Damping coefficient. - alpha (float): Coefficient of x1. - beta (float): Coefficient of x1^3. - """ - self.dt = dt - self.d = d - self.alpha = alpha - self.beta = beta - self.n_states = 2 - - def sys(self, t, x, u): - """ - Defines the system dynamics of the Forced Duffing Oscillator. - - Args: - t (float): Time. - x (array-like): State vector. - u (array-like): Control input. - - Returns: - array-like: Rate of change of the state vector. - """ - y = np.array( - [ - x[1, :], - -self.d * x[1, :] - self.alpha * x[0, :] - self.beta * x[0, :] ** 3 + u, - ] - ) - return y - - def simulate(self, x0, n_int, u): - """ - Simulates the Forced Duffing Oscillator. - - Args: - x0 (array-like): Initial state vector. - n_int (int): Number of time steps. - u (array-like): Control inputs. - - Returns: - array-like: State trajectories. - """ - n_traj = x0.shape[1] - x = x0 - X = np.zeros((self.n_states, n_int * n_traj)) - for step in range(n_int): - y = rk4(0, x, u[step, :], self.dt, self.sys) - X[:, (step) * n_traj : (step + 1) * n_traj] = y - x = y - return X - - def collect_data_continuous(self, x0, u): - """ - Collects continuous data for the Forced Duffing Oscillator. - - Args: - x0 (array-like): Initial state vector. - u (array-like): Control inputs. - - Returns: - tuple: State and output trajectories. - """ - X = x0 - Y = self.sys(0, x0, u) - return X, Y - - def collect_data_discrete(self, x0, n_int, u): - """ - Collects discrete-time data for the Forced Duffing Oscillator. - - Args: - x0 (array-like): Initial state vector. - n_int (int): Number of time steps. - u (array-like): Control inputs. - - Returns: - tuple: State and output trajectories. - """ - n_traj = x0.shape[1] - x = x0 - X = np.zeros((self.n_states, n_int * n_traj)) - Y = np.zeros((self.n_states, n_int * n_traj)) - for step in range(n_int): - y = rk4(0, x, u[step, :], self.dt, self.sys) - X[:, (step) * n_traj : (step + 1) * n_traj] = x - Y[:, (step) * n_traj : (step + 1) * n_traj] = y - x = y - return X, Y - - def visualize_trajectories(self, t, X, n_traj): - """ - Visualizes the state trajectories of the Forced Duffing Oscillator. - - Args: - t (array-like): Time vector. - X (array-like): State trajectories. - n_traj (int): Number of trajectories to visualize. - """ - fig, axs = plt.subplots(1, 2, tight_layout=True, figsize=(12, 4)) - for traj_idx in range(n_traj): - x = X[:, traj_idx::n_traj] - axs[0].plot(t, x[0, :], "k") - axs[1].plot(t, x[1, :], "b") - axs[0].set(ylabel=r"$x_1$", xlabel=r"$t$") - axs[1].set(ylabel=r"$x_2$", xlabel=r"$t$") - - def visualize_state_space(self, X, Y, n_traj): - """ - Visualizes the state space trajectories of the Forced Duffing Oscillator. - - Args: - X (array-like): State trajectories. - Y (array-like): Output trajectories. - n_traj (int): Number of trajectories to visualize. - """ - fig, axs = plt.subplots(1, 1, tight_layout=True, figsize=(4, 4)) - for traj_idx in range(n_traj): - axs.plot( - [X[0, traj_idx::n_traj], Y[0, traj_idx::n_traj]], - [X[1, traj_idx::n_traj], Y[1, traj_idx::n_traj]], - "-k", - ) - axs.set(ylabel=r"$x_2$", xlabel=r"$x_1$") diff --git a/DSA/pykoopman/src/pykoopman/common/ks.py b/DSA/pykoopman/src/pykoopman/common/ks.py deleted file mode 100644 index e356bdf..0000000 --- a/DSA/pykoopman/src/pykoopman/common/ks.py +++ /dev/null @@ -1,189 +0,0 @@ -"""module for 1D KS equation""" -from __future__ import annotations - -import numpy as np -from matplotlib import pyplot as plt -from mpl_toolkits.mplot3d import Axes3D -from scipy.fft import fft -from scipy.fft import fftfreq -from scipy.fft import ifft - - -class ks: - """ - Solving 1D KS equation - - u_t = -u*u_x + u_{xx} + nu*u_{xxxx} - - Periodic B.C. between 0 and 2*pi. This PDE is solved - using spectral methods. - """ - - def __init__(self, n, x, nu, dt, M=16): - self.n_states = n - self.dt = dt - self.x = x - dk = 1 - k = fftfreq(self.n_states, 1.0 / self.n_states) * dk - k[n // 2] = 0.0 - L = k**2 - nu * k**4 - self.E = np.exp(self.dt * L) - self.E2 = np.exp(self.dt * L / 2.0) - # self.M = M - r = np.exp(1j * np.pi * (np.arange(1, M + 1) - 0.5) / M) - r = r.reshape(1, -1) - r_on_circle = np.repeat(r, n, axis=0) - LR = self.dt * L - LR = LR.reshape(-1, 1) - LR = LR.astype("complex") - LR = np.repeat(LR, M, axis=1) - LR += r_on_circle - self.g = -0.5j * k - - self.Q = self.dt * np.real(np.mean((np.exp(LR / 2.0) - 1) / LR, axis=1)) - self.f1 = self.dt * np.real( - np.mean( - (-4.0 - LR + np.exp(LR) * (4.0 - 3.0 * LR + LR**2)) / LR**3, axis=1 - ) - ) - self.f2 = self.dt * np.real( - np.mean((2.0 + LR + np.exp(LR) * (-2.0 + LR)) / LR**3, axis=1) - ) - self.f3 = self.dt * np.real( - np.mean( - (-4.0 - 3.0 * LR - LR**2 + np.exp(LR) * (4.0 - LR)) / LR**3, axis=1 - ) - ) - - @staticmethod - def compute_u2k_zeropad_dealiased(uk_): - # three over two law - N = uk_.size - # map uk to uk_fine - uk_fine = ( - np.hstack((uk_[0 : int(N / 2)], np.zeros((int(N / 2))), uk_[int(-N / 2) :])) - * 3.0 - / 2.0 - ) - # convert uk_fine to physical space - u_fine = np.real(ifft(uk_fine)) - # compute square - u2_fine = np.square(u_fine) - # compute fft on u2_fine - u2k_fine = fft(u2_fine) - # convert u2k_fine to u2k - u2k = np.hstack((u2k_fine[0 : int(N / 2)], u2k_fine[int(-N / 2) :])) / 3.0 * 2.0 - return u2k - - def sys(self, t, x, u): - raise NotImplementedError - - def simulate(self, x0, n_int, n_sample): - xk = fft(x0) - u = np.zeros((n_int, 1)) - X = np.zeros((n_int // n_sample, self.n_states)) - t = 0 - j = 0 - t_list = [] - for step in range(n_int): - t += self.dt - Nv = self.g * self.compute_u2k_zeropad_dealiased(xk) - a = self.E2 * xk + self.Q * Nv - Na = self.g * self.compute_u2k_zeropad_dealiased(a) - b = self.E2 * xk + self.Q * Na - Nb = self.g * self.compute_u2k_zeropad_dealiased(b) - c = self.E2 * a + self.Q * (2.0 * Nb - Nv) - Nc = self.g * self.compute_u2k_zeropad_dealiased(c) - xk = self.E * xk + Nv * self.f1 + 2.0 * (Na + Nb) * self.f2 + Nc * self.f3 - - if (step + 1) % n_sample == 0: - y = np.real(ifft(xk)) + self.dt * u[j] - X[j, :] = y - j += 1 - t_list.append(t) - xk = fft(y) - - return X, np.array(t_list) - - def collect_data_continuous(self, x0): - raise NotImplementedError - - def collect_one_step_data_discrete(self, x0): - """ - collect training data pairs - discrete sense. - - given x0, with shape (n_dim, n_traj), the function - returns system state x1 after self.dt with shape - (n_dim, n_traj) - """ - n_traj = x0.shape[0] - X = x0 - Y = [] - for i in range(n_traj): - y, _ = self.simulate(x0[i], n_int=1, n_sample=1) - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_trajectory_data(self, x0, n_int, n_sample): - x = x0 - y, _ = self.simulate(x, n_int, n_sample) - return y - - def visualize_data(self, x, t, X): - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - for i in range(X.shape[0]): - ax.plot(x, X[i], zs=t[i], zdir="t", label="time = " + str(i * self.dt)) - ax.view_init(elev=35.0, azim=-65, vertical_axis="y") - ax.set(ylabel=r"$u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") - plt.title("1D K-S equation") - plt.show() - - def visualize_state_space(self, X): - u, s, vt = np.linalg.svd(X, full_matrices=False) - plt.figure(figsize=(6, 6)) - plt.semilogy(s) - plt.xlabel("number of SVD terms") - plt.ylabel("singular values") - plt.title("PCA singular value decays") - plt.show() - - # this is a pde problem so the number of snapshots are smaller than dof - pca_1, pca_2, pca_3 = u[:, 0], u[:, 1], u[:, 2] - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - ax.plot3D(pca_1, pca_2, pca_3, "k-o") - ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") - plt.title("PCA visualization") - plt.show() - - -if __name__ == "__main__": - n = 256 - x = np.linspace(0, 2.0 * np.pi, n, endpoint=False) - u0 = np.sin(x) - nu = 0.01 - n_int = 1000 - n_snapshot = 500 - dt = 4.0 / n_int - n_sample = n_int // n_snapshot - - model = ks(n, x, nu=nu, dt=dt) - X, t = model.simulate(u0, n_int, n_sample) - print(X.shape) - model.visualize_data(x, t, X) - - # usage: visualize the data in state space - model.visualize_state_space(X) - - # usage: collect discrete data pair - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_one_step_data_discrete(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect one trajectory data - X = model.collect_one_trajectory_data(u0, n_int, n_sample) - print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/common/nlse.py b/DSA/pykoopman/src/pykoopman/common/nlse.py deleted file mode 100644 index b82585f..0000000 --- a/DSA/pykoopman/src/pykoopman/common/nlse.py +++ /dev/null @@ -1,186 +0,0 @@ -"""module for nonlinear schrodinger equation""" -from __future__ import annotations - -import numpy as np -from matplotlib import pyplot as plt -from mpl_toolkits.mplot3d import Axes3D -from pykoopman.common.examples import rk4 -from scipy.fft import fft -from scipy.fft import fftfreq -from scipy.fft import ifft - - -class nlse: - """ - nonlinear schrodinger equation - - iu_t + 0.5u_xx + u*|u|^2 = 0 - - periodic B.C. PDE is solved with Spectral methods using FFT - """ - - def __init__(self, n, dt, L=2 * np.pi): - self.n_states = n - # assert self.u0.size == self.n_states, 'check the size of initial - # condition and mesh size n' - - dk = 2 * np.pi / L - self.k = fftfreq(self.n_states, 1.0 / self.n_states) * dk - self.dt = dt - - def sys(self, t, x, u): - """the RHS for the governing equation using FFT""" - xk = fft(x) - - # 4/3 truncation rule - # dealiasing due to triple nonlinearity - # note: you could do zero-padding to improve memory - # efficiency - xk[self.n_states // 4 : 3 * self.n_states // 4] = 0j - x = ifft(xk) - - yk = (-self.k**2 * xk.ravel() / 2) * 1j - y = ifft(yk) + 1j * abs(x) ** 2 * x + u - return y - - def simulate(self, x0, n_int, n_sample): - # n_traj = x0.shape[1] - x = x0 - u = np.zeros((n_int, 1), dtype=complex) - X = np.zeros((n_int // n_sample, self.n_states), dtype=complex) - t = 0 - j = 0 - t_list = [] - for step in range(n_int): - t += self.dt - y = rk4(0, x, u[step], self.dt, self.sys) - if (step + 1) % n_sample == 0: - X[j] = y - j += 1 - t_list.append(t) - x = y - return X, np.array(t_list) - - def collect_data_continuous(self, x0): - """ - collect training data pairs - continuous sense. - - given x0, with shape (n_dim, n_traj), the function - returns dx/dt with shape (n_dim, n_traj) - """ - - n_traj = x0.shape[0] - u = np.zeros((n_traj, 1)) - X = x0 - Y = [] - for i in range(n_traj): - y = self.sys(0, x0[i], u[i]) - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_step_data_discrete(self, x0): - """ - collect training data pairs - discrete sense. - - given x0, with shape (n_dim, n_traj), the function - returns system state x1 after self.dt with shape - (n_dim, n_traj) - """ - - n_traj = x0.shape[0] - X = x0 - Y = [] - for i in range(n_traj): - y, _ = self.simulate(x0[i], n_int=1, n_sample=1) - # for j in range(int(delta_t // self.dt)): - # y = rk4(0, x, u[:, i], self.dt, self.sys) - # x = y - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_trajectory_data(self, x0, n_int, n_sample): - x = x0 - y, _ = self.simulate(x, n_int, n_sample) - return y - - def visualize_data(self, x, t, X): - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - for i in range(X.shape[0]): - ax.plot(x, abs(X[i]), zs=t[i], zdir="t", label="time = " + str(i * self.dt)) - # plt.legend(loc='best') - ax.view_init(elev=35.0, azim=-65, vertical_axis="y") - ax.set(ylabel=r"$mag. of u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") - plt.title("Nonlinear schrodinger equation (Kutz et al., Complexity, 2018)") - plt.show() - - def visualize_state_space(self, X): - u, s, vt = np.linalg.svd(X, full_matrices=False) - # this is a pde problem so the number of snapshots are smaller than dof - pca_1_r, pca_1_i = np.real(u[:, 0]), np.imag(u[:, 0]) - pca_2_r, pca_2_i = np.real(u[:, 1]), np.imag(u[:, 1]) - pca_3_r, pca_3_i = np.real(u[:, 2]), np.imag(u[:, 2]) - - plt.figure(figsize=(6, 6)) - plt.semilogy(s) - plt.xlabel("number of SVD terms") - plt.ylabel("singular values") - plt.title("PCA singular value decays") - plt.show() - - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - ax.plot3D(pca_1_r, pca_2_r, pca_3_r, "k-o") - ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") - plt.title("PCA visualization (real)") - plt.show() - - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - ax.plot3D(pca_1_i, pca_2_i, pca_3_i, "k-o") - ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") - plt.title("PCA visualization (imag)") - plt.show() - - -if __name__ == "__main__": - n = 512 - x = np.linspace(-15, 15, n, endpoint=False) - u0 = 2.0 / np.cosh(x) - # u0 = u0.reshape(-1,1) - n_int = 10000 - n_snapshot = 80 # in the original paper, it is 20, but I think too small - dt = np.pi / n_int - n_sample = n_int // n_snapshot - - model = nlse(n, dt=dt, L=30) - X, t = model.simulate(u0, n_int, n_sample) - - # usage: visualize the data in physical space - model.visualize_data(x, t, X) - - # usage: visualize the data in state space - model.visualize_state_space(X) - - print(X.shape) - print(t[1] - t[0]) - - # usage: collect continuous data pair: x and dx/dt - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_data_continuous(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect discrete data pair - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_one_step_data_discrete(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect one trajectory data - X = model.collect_one_trajectory_data(u0, n_int, n_sample) - print(X.shape) diff --git a/DSA/pykoopman/src/pykoopman/common/vbe.py b/DSA/pykoopman/src/pykoopman/common/vbe.py deleted file mode 100644 index 2a3cec2..0000000 --- a/DSA/pykoopman/src/pykoopman/common/vbe.py +++ /dev/null @@ -1,177 +0,0 @@ -"""module for 1D viscous burgers""" -from __future__ import annotations - -import numpy as np -from matplotlib import pyplot as plt -from mpl_toolkits.mplot3d import Axes3D -from pykoopman.common.examples import rk4 -from scipy.fft import fft -from scipy.fft import fftfreq -from scipy.fft import ifft - - -class vbe: - """ - 1D viscous Burgers equation - - u_t = -u*u_x + \nu u_{xx} - - periodic B.C. PDE is solved using spectral methods - """ - - def __init__(self, n, x, dt, nu=0.1, L=2 * np.pi): - self.n_states = n - self.x = x - self.nu = nu - dk = 2 * np.pi / L - self.k = fftfreq(self.n_states, 1.0 / self.n_states) * dk - self.dt = dt - - def sys(self, t, x, u): - xk = fft(x) - - # 3/2 truncation rule - xk[self.n_states // 3 : 2 * self.n_states // 3] = 0j - x = ifft(xk) - - # nonlinear advection - tmp_nl_k = fft(-0.5 * x * x) - tmp_nl_x_k = 1j * self.k * tmp_nl_k - - # linear viscous term - tmp_vis_k = -self.nu * self.k**2 * xk - - # return back to physical space - y = np.real(ifft(tmp_nl_x_k + tmp_vis_k)) - return y - - def simulate(self, x0, n_int, n_sample): - # n_traj = x0.shape[1] - x = x0 - u = np.zeros((n_int, 1)) - X = np.zeros((n_int // n_sample, self.n_states)) - t = 0 - j = 0 - t_list = [] - for step in range(n_int): - t += self.dt - y = rk4(0, x, u[step, :], self.dt, self.sys) - if (step + 1) % n_sample == 0: - X[j, :] = y - j += 1 - t_list.append(t) - x = y - return X, np.array(t_list) - - def collect_data_continuous(self, x0): - """ - collect training data pairs - continuous sense. - - given x0, with shape (n_dim, n_traj), the function - returns dx/dt with shape (n_dim, n_traj) - """ - - n_traj = x0.shape[0] - u = np.zeros((n_traj, 1)) - X = x0 - Y = [] - for i in range(n_traj): - y = self.sys(0, x0[i], u[i]) - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_step_data_discrete(self, x0): - """ - collect training data pairs - discrete sense. - - given x0, with shape (n_dim, n_traj), the function - returns system state x1 after self.dt with shape - (n_dim, n_traj) - """ - - n_traj = x0.shape[0] - X = x0 - Y = [] - for i in range(n_traj): - y, _ = self.simulate(x0[i], n_int=1, n_sample=1) - Y.append(y) - Y = np.vstack(Y) - return X, Y - - def collect_one_trajectory_data(self, x0, n_int, n_sample): - x = x0 - y, _ = self.simulate(x, n_int, n_sample) - return y - - def visualize_data(self, x, t, X): - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - for i in range(X.shape[0]): - ax.plot(x, X[i], zs=t[i], zdir="t", label="time = " + str(i * self.dt)) - # plt.legend(loc='best') - ax.view_init(elev=35.0, azim=-65, vertical_axis="y") - ax.set(ylabel=r"$u(x,t)$", xlabel=r"$x$", zlabel=r"time $t$") - plt.title("1D Viscous Burgers equation (Kutz et al., Complexity, 2018)") - plt.show() - - def visualize_state_space(self, X): - u, s, vt = np.linalg.svd(X, full_matrices=False) - plt.figure(figsize=(6, 6)) - plt.semilogy(s) - plt.xlabel("number of SVD terms") - plt.ylabel("singular values") - plt.title("PCA singular value decays") - plt.show() - - # this is a pde problem so the number of snapshots are smaller than dof - pca_1, pca_2, pca_3 = u[:, 0], u[:, 1], u[:, 2] - plt.figure(figsize=(6, 6)) - ax = plt.axes(projection=Axes3D.name) - ax.plot3D(pca_1, pca_2, pca_3, "k-o") - ax.set(xlabel="pc1", ylabel="pc2", zlabel="pc3") - plt.title("PCA visualization") - plt.show() - - -if __name__ == "__main__": - n = 256 - x = np.linspace(-15, 15, n, endpoint=False) - u0 = np.exp(-((x + 2) ** 2)) - # u0 = 2.0 / np.cosh(x) - # u0 = u0.reshape(-1,1) - n_int = 3000 - n_snapshot = 30 - dt = 30.0 / n_int - n_sample = n_int // n_snapshot - - model = vbe(n, x, dt=dt, L=30) - X, t = model.simulate(u0, n_int, n_sample) - - print(X.shape) - # print(X[:,-1].max()) - - # usage: visualize the data in physical space - model.visualize_data(x, t, X) - print(t) - - # usage: visualize the data in state space - model.visualize_state_space(X) - - # usage: collect continuous data pair: x and dx/dt - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_data_continuous(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect discrete data pair - x0_array = np.vstack([u0, u0, u0]) - X, Y = model.collect_one_step_data_discrete(x0_array) - - print(X.shape) - print(Y.shape) - - # usage: collect one trajectory data - X = model.collect_one_trajectory_data(u0, n_int, n_sample) - print(X.shape) From 4327124ac77420ce9cec5cf0f9194e2d1276cb72 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 09:38:39 -0400 Subject: [PATCH 21/51] bug fixes for comparisons --- DSA/__init__.py | 5 ++++- DSA/dsa.py | 25 ++++++++++++++----------- DSA/simdist_controllability.py | 6 +++--- 3 files changed, 21 insertions(+), 15 deletions(-) diff --git a/DSA/__init__.py b/DSA/__init__.py index b830265..da9d373 100644 --- a/DSA/__init__.py +++ b/DSA/__init__.py @@ -1,4 +1,7 @@ -from DSA.dsa import DSA, GeneralizedDSA, InputDSA +from DSA.dsa import DSA, ControllabilitySimilarityTransformDistConfig, GeneralizedDSA, InputDSA, SimilarityTransformDistConfig +from DSA.dsa import DefaultDMDConfig as DMDConfig +from DSA.dsa import pyKoopmanDMDConfig,SubspaceDMDcConfig +from DSA.dsa import SimilarityTransformDistConfig, ControllabilitySimilarityTransformDistConfig from DSA.dmd import DMD from DSA.dmdc import DMDc from DSA.subspace_dmdc import SubspaceDMDc diff --git a/DSA/dsa.py b/DSA/dsa.py index 62b869b..02787f5 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -13,7 +13,7 @@ import DSA.pykoopman as pykoopman import pydmd from DSA.pykoopman.regression import DMDc, EDMDc -from typing import Union, Mapping, Any +from typing import Union, Mapping, Any, ClassVar, Final import warnings @@ -125,6 +125,8 @@ class SimilarityTransformDistConfig: iters: int = 1500 score_method: Literal["angular", "euclidean", "wasserstein"] = "angular" lr: float = 5e-3 + #class variable, set as final to indicate that it's fixed and immutable + compare: ClassVar[Final] = "state" @dataclass() class ControllabilitySimilarityTransformDistConfig: @@ -139,20 +141,20 @@ class ControllabilitySimilarityTransformDistConfig: 'angular' uses angular distance, 'euclidean' uses Euclidean distance. Default is "euclidean". compare (str): What to compare between systems. - 'state' compares only state operators, 'control' compares only control operators, - 'joint' compares both. Default is 'state'. - joint_optim (bool): Whether to optimize state and control operators jointly. - Default is False. + 'control' compares only control operators, + 'joint' compares both control and state operators simultaneousl. + Default is 'joint'. + If you pass in 'state', it will throw an error -> use SimilarityTransformDistConfig Instead + align_inputs (bool): whether to learn a C_u transformation that aligns the input representations as well return_distance_components (bool): Whether to return individual distance components (state, control, joint) separately. Default is False. """ score_method: Literal["euclidean", "angular"] = "euclidean" - compare = "joint" - joint_optim: bool = False + compare: Literal["joint","control"] = "joint" + align_inputs: bool = False return_distance_components: bool = False - class GeneralizedDSA: """ Computes the Generalized Dynamical Similarity Analysis (DSA) for two data tensors. @@ -586,12 +588,13 @@ def score(self): ind2 = 0 if self.method == "self-pairwise" else 1 # 0 if self.pairwise (want to compare the set to itself) n_sims = ( - 1 - if not ( + 3 + if ( self.simdist_has_control and self.simdist_config.get("return_distance_components") + and self.simdist_config.get("compare") == "joint" ) - else 3 + else 1 ) self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]), n_sims)) diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 778384f..bc740a9 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -19,7 +19,7 @@ def __init__( *, score_method: Literal["euclidean", "angular"] = "euclidean", compare: Literal["joint", "control", "state"] = "joint", - joint_optim: bool = False, + align_inputs: bool = False, return_distance_components: bool = True, ): f""" @@ -36,7 +36,7 @@ def __init__( """ self.score_method = score_method self.compare = compare - self.joint_optim = joint_optim + self.align_inputs = align_inputs self.return_distance_components = return_distance_components @staticmethod @@ -63,7 +63,7 @@ def fit_score(self, A, B, A_control, B_control): if self.compare == "joint": C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( - A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.joint_optim + A1=A, B1=A_control, A2=B, B2=B_control, align_inputs=self.align_inputs ) if self.return_distance_components: if self.score_method == "euclidean": From 4374db55c4b202faa55d48d7c55609534c135a83 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 09:48:31 -0400 Subject: [PATCH 22/51] add error for align_inputs = True (need to fix later, quick hack) --- DSA/simdist_controllability.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index bc740a9..43763a1 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -39,6 +39,9 @@ def __init__( self.align_inputs = align_inputs self.return_distance_components = return_distance_components + if align_inputs: + raise ValueError("align inputs is not yet implemented correctly, please switch to align_inputs=False for now") + @staticmethod def compute_angular_dist(A, B): """ @@ -67,8 +70,6 @@ def fit_score(self, A, B, A_control, B_control): ) if self.return_distance_components: if self.score_method == "euclidean": - # sims_control_joint = np.linalg.norm(C @ A_control @ C_u - B_control, "fro") ** 2 - # sims_state_joint = np.linalg.norm(C @ A @ C.T - B, "fro") ** 2 sims_control_joint = np.linalg.norm( C @ A_control @ C_u - B_control, "fro" ) @@ -176,6 +177,7 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False): U2, S2, V2t = np.linalg.svd(K2, full_matrices=False) C = U1 @ U2.T + #TODO: fix this to compute procrustes on individual blocks (B, AB, A^2B, etc) C_u = V2t.T @ V1t # = V2 @ V1^T K2_aligned = C @ K2 @ C_u From 293cd17bce4a6c28b79a146ea8cfc986d8be118c Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 10:43:33 -0400 Subject: [PATCH 23/51] add dmdc config --- DSA/dsa.py | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index 02787f5..97d77d4 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -102,6 +102,32 @@ class SubspaceDMDcConfig: lamb: float = 0 backend: str = "n4sid" +@dataclass() +class DMDcConfig: + """ + Configuration dataclass for DefaultDMDc (standard DMD with control). + + This configuration is used to set parameters for the DefaultDMDc class when + performing Dynamical Mode Decomposition on time series data with control inputs. + + Attributes: + n_delays (int): Number of time delays to use in the Hankel matrix construction + for the state data. Default is 1 (no delays). + input_rank (int): Rank for SVD truncation of the input (control) data. + If None, no truncation is performed. Default is None. + output_rank (int): Rank for SVD truncation of the output (state) data. + If None, no truncation is performed. Default is None. + lamb (float): Regularization parameter for ridge regression. + Default is 0 (no regularization). + delay_interval (int): Interval between delays in the Hankel matrix. + Default is 1 (consecutive time steps). + """ + n_delays: int = 1 + input_rank: int = None + output_rank: int = None + lamb: float = 0 + delay_interval: int = 1 + # __Example config dataclasses for similarity transform distance # @dataclass @@ -752,4 +778,3 @@ def update_compare_method(self,compare='joint'): simdist = ControllabilitySimilarityTransformDist #TODO: check simdist config to make sure it aligns return simdist - From 8b0cae8111b9bf76b9425e46b8c1450ae55bacab Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 11:20:44 -0400 Subject: [PATCH 24/51] torch compatibility, dmdc bug, allow passing config in directly without initializing (for defaults) --- DSA/__init__.py | 2 +- DSA/dsa.py | 10 ++++++++-- DSA/simdist_controllability.py | 9 +++++++-- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/DSA/__init__.py b/DSA/__init__.py index da9d373..dde8892 100644 --- a/DSA/__init__.py +++ b/DSA/__init__.py @@ -1,6 +1,6 @@ from DSA.dsa import DSA, ControllabilitySimilarityTransformDistConfig, GeneralizedDSA, InputDSA, SimilarityTransformDistConfig from DSA.dsa import DefaultDMDConfig as DMDConfig -from DSA.dsa import pyKoopmanDMDConfig,SubspaceDMDcConfig +from DSA.dsa import pyKoopmanDMDConfig,SubspaceDMDcConfig, DMDcConfig from DSA.dsa import SimilarityTransformDistConfig, ControllabilitySimilarityTransformDistConfig from DSA.dmd import DMD from DSA.dmdc import DMDc diff --git a/DSA/dsa.py b/DSA/dsa.py index 97d77d4..221140f 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -123,8 +123,8 @@ class DMDcConfig: Default is 1 (consecutive time steps). """ n_delays: int = 1 - input_rank: int = None - output_rank: int = None + rank_input: int = None + rank_output: int = None lamb: float = 0 delay_interval: int = 1 @@ -283,8 +283,12 @@ def __init__( self.Y = Y self.X_control = X_control self.Y_control = Y_control + + if isinstance(simdist_config, type): #if it's the class itself (not an object) initialize + simdist_config = simdist_config() self.simdist_config = simdist_config + if is_dataclass(simdist_config): self.simdist_config = asdict(self.simdist_config) @@ -311,6 +315,8 @@ def __init__( # Process DMD keyword arguments from **dmd_kwargs # These are parameters like n_delays, rank, etc., that are specific to DMDs # and need to be broadcasted according to X and Y data structure. + if isinstance(dmd_config,type): + dmd_config = dmd_config() if is_dataclass(dmd_config): dmd_config = asdict(dmd_config) self.dmd_config = ( diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index 43763a1..edb3468 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -1,6 +1,7 @@ from typing import Literal import numpy as np from scipy.linalg import orthogonal_procrustes +import torch try: from .simdist import SimilarityTransformDist @@ -63,6 +64,11 @@ def compute_angular_dist(A, B): return cos_sim def fit_score(self, A, B, A_control, B_control): + convert_np = lambda A: A.detach().cpu().numpy() if isinstance(A,torch.Tensor) else A + A = convert_np(A) + B = convert_np(B) + A_control = convert_np(A_control) + B_control = convert_np(B_control) if self.compare == "joint": C, C_u, sims_joint_euc, sims_joint_ang = self.compare_systems_procrustes( @@ -123,7 +129,6 @@ def get_controllability_matrix(self, A, B): # term_norm = np.linalg.norm(current_term) # if term_norm < 1e-12 or term_norm > 1e12: # break - # Check for linear dependence (rank deficiency) K_test = np.hstack((K, current1_term, current2_term)) # if np.linalg.matrix_rank(K_test) <= np.linalg.matrix_rank(K): @@ -156,7 +161,7 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False): # Build controllability matrices: K \in R^{n x p} K1 = self.get_controllability_matrix(A1, B1) K2 = self.get_controllability_matrix(A2, B2) - + import pdb; pdb.set_trace() if not align_inputs: # One-sided: C = argmin ||K1 - C K2||_F M = K2 @ K1.T From bd103d4ed09dfeec2b900c6d7ae5a21ad4319b54 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 12:11:20 -0400 Subject: [PATCH 25/51] fix inputdsa graceful switching of different comparisons based on config that is passed in , generalize to generalizedDSA as a whole (but with the option to still pass in the class) --- DSA/dsa.py | 165 ++++++++++++++++++++++++++------- DSA/simdist_controllability.py | 1 - 2 files changed, 131 insertions(+), 35 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index 221140f..329bd81 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -214,11 +214,11 @@ def __init__( X_control=None, Y_control=None, dmd_class=DefaultDMD, - similarity_class=SimilarityTransformDist, - dmd_config: Union[Mapping[str, Any], dataclass] = DefaultDMDConfig(), + similarity_class=None, + dmd_config: Union[Mapping[str, Any], dataclass] = DefaultDMDConfig, simdist_config: Union[ Mapping[str, Any], dataclass - ] = SimilarityTransformDistConfig(), + ] = SimilarityTransformDistConfig, device="cpu", verbose=False, n_jobs=1, @@ -250,14 +250,18 @@ def __init__( dmd_class : class DMD class to use for decomposition. Default is DefaultDMD. - similarity_class : class - Similarity transform distance class to use. Default is SimilarityTransformDist. + similarity_class : class or None + Similarity transform distance class to use. If None, will be inferred + from the 'compare' field in simdist_config. Default is None. dmd_config : Union[Mapping[str, Any], dataclass] Configuration for DMD parameters. Can be a dict or dataclass. simdist_config : Union[Mapping[str, Any], dataclass] Configuration for similarity transform distance parameters. Can be a dict or dataclass. + If similarity_class is None, the 'compare' field will be used to infer the class: + - 'state' -> SimilarityTransformDist + - 'joint' or 'control' -> ControllabilitySimilarityTransformDist device : str Device to use for computation ('cpu' or 'cuda'). Default is 'cpu'. @@ -291,6 +295,16 @@ def __init__( if is_dataclass(simdist_config): self.simdist_config = asdict(self.simdist_config) + + # Infer similarity_class from simdist_config if not provided + if similarity_class is None: + compare = self.simdist_config.get('compare', 'state') + if compare == 'state': + similarity_class = SimilarityTransformDist + elif compare in ['joint', 'control']: + similarity_class = ControllabilitySimilarityTransformDist + else: + raise ValueError(f"Invalid compare value in simdist_config: {compare}. Must be 'state', 'joint', or 'control'.") self.device = device self.n_jobs = n_jobs @@ -429,6 +443,106 @@ def _dmd_api_source(self, dmd_class): raise ValueError( f"dmd_class {dmd_class.__name__} from unknown module {module_name}" ) + def update_compare_method(self, compare='joint', simdist_config=None): + """ + Update the similarity comparison method and adapt the configuration. + This method can be called to switch between different comparison modes + (state-only, control-only, or joint) after initialization. + + Parameters + ---------- + compare : str + 'state', 'joint', or 'control' + simdist_config : dict, dataclass, or None + Configuration to adapt. If None, uses current self.simdist_config + + Raises + ------ + ValueError + If the comparison method is incompatible with the DMD class + """ + # Validate compare parameter + valid_compare_values = ['state', 'joint', 'control'] + if compare not in valid_compare_values: + raise ValueError( + f"compare must be one of {valid_compare_values}, got {compare}" + ) + + # Use current config if none provided + if simdist_config is None: + simdist_config = self.simdist_config + + # Convert to dict if needed + if isinstance(simdist_config, type): # If it's a class + simdist_config = simdist_config() + if is_dataclass(simdist_config): + simdist_config = asdict(simdist_config) + + # Check if return_distance_components is changing + old_return_components = self.simdist_config.get('return_distance_components', False) + new_return_components = simdist_config.get('return_distance_components', False) + if old_return_components != new_return_components: + warnings.warn( + f"Changing return_distance_components from {old_return_components} to " + f"{new_return_components} will change the output shape of score(). " + f"Previously computed similarities (self.sims) will be cleared. " + f"You will need to recompute similarities by calling score() or fit_score()." + ) + + + if compare == "state": + simdist_class = SimilarityTransformDist + # Extract only parameters relevant to SimilarityTransformDist + adapted_config = { + 'score_method': simdist_config.get('score_method', 'angular'), + 'iters': simdist_config.get('iters', 1500), + 'lr': simdist_config.get('lr', 5e-3), + 'device': simdist_config.get('device', self.device), + 'verbose': simdist_config.get('verbose', self.verbose), + } + # Validate score_method for SimilarityTransformDist + if adapted_config['score_method'] not in ['angular', 'euclidean', 'wasserstein']: + warnings.warn( + f"score_method '{adapted_config['score_method']}' may not be valid " + f"for SimilarityTransformDist, valid options: angular, euclidean, wasserstein" + ) + # State comparison doesn't have return_distance_components, so always treated as False + new_return_components = False + + else: # 'joint' or 'control' + simdist_class = ControllabilitySimilarityTransformDist + # Extract only parameters relevant to ControllabilitySimilarityTransformDist + adapted_config = { + 'score_method': simdist_config.get('score_method', 'euclidean'), + 'compare': compare, # Override with the method parameter + 'align_inputs': simdist_config.get('align_inputs', False), + 'return_distance_components': new_return_components, + } + # Validate score_method for ControllabilitySimilarityTransformDist + if adapted_config['score_method'] not in ['angular', 'euclidean']: + warnings.warn( + f"score_method '{adapted_config['score_method']}' may not be valid " + f"for ControllabilitySimilarityTransformDist, valid options: angular, euclidean" + ) + + # Check compatibility between DMD and new simdist class + # This will update self.dmd_has_control and self.simdist_has_control + self._check_dmd_simdist_compatibility(self.dmd_class, simdist_class) + + if self.simdist_has_control: + if self.X_control is None and self.Y_control is None: + raise ValueError( + f"Cannot use compare='{compare}' which requires control matrices, " + f"but no control data (X_control or Y_control) was provided" + ) + + self.simdist_config = adapted_config + self.simdist = simdist_class(**adapted_config) + + if self.verbose: + print(f"Updated similarity method to compare='{compare}' using {simdist_class.__name__}") + + return simdist_class, adapted_config def fit_dmds(self): if self.n_jobs != 1: @@ -742,45 +856,28 @@ def __init__( Y=None, Y_control=None, dmd_class=SubspaceDMDc, - dmd_config: Union[Mapping[str, Any], dataclass] = SubspaceDMDcConfig(), + dmd_config: Union[Mapping[str, Any], dataclass] = SubspaceDMDcConfig, simdist_config: Union[ Mapping[str, Any], dataclass - ] = ControllabilitySimilarityTransformDistConfig(), + ] = ControllabilitySimilarityTransformDistConfig, device="cpu", verbose=False, n_jobs=1, ): - #TODO: fix based on making compare argument explicit - # check if simdist_config has 'compare', and if it's 'state', use the standard SimilarityTransformDist, - # otherwise use ControllabilitySimilarityTransformDistConfig - if isinstance(simdist_config, dict): - compare = simdist_config.get("compare", None) - else: - compare = simdist_config.compare - simdist = self.update_compare_method(compare) - + # similarity_class will be inferred from simdist_config in parent __init__ super().__init__( X, Y, X_control, Y_control, dmd_class, - simdist, - dmd_config, - simdist_config, - device, - verbose, - n_jobs, + similarity_class=None, # Will be inferred from simdist_config + dmd_config=dmd_config, + simdist_config=simdist_config, + device=device, + verbose=verbose, + n_jobs=n_jobs, ) - - assert X_control is not None - assert self.dmd_has_control - - def update_compare_method(self,compare='joint'): - if compare == "state": - simdist = SimilarityTransformDist - #TODO: check simdist config to make sure it aligns - else: - simdist = ControllabilitySimilarityTransformDist - #TODO: check simdist config to make sure it aligns - return simdist + + assert X_control is not None, "InputDSA requires X_control to be provided" + assert self.dmd_has_control, "InputDSA requires a DMD class with control" diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index edb3468..cf1f1da 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -161,7 +161,6 @@ def compare_systems_procrustes(self, A1, B1, A2, B2, *, align_inputs=False): # Build controllability matrices: K \in R^{n x p} K1 = self.get_controllability_matrix(A1, B1) K2 = self.get_controllability_matrix(A2, B2) - import pdb; pdb.set_trace() if not align_inputs: # One-sided: C = argmin ||K1 - C K2||_F M = K2 @ K1.T From d2a9667b68960f47f037ee6d6d235c7f863b6da8 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 30 Oct 2025 14:39:21 -0400 Subject: [PATCH 26/51] dmdc ragged lists bug fix, starting to fix subspace dmdc but not quite there yet --- DSA/base_dmd.py | 16 + DSA/dmdc.py | 9 +- DSA/subspace_dmdc.py | 642 ++--- examples/all_dsa_types.ipynb | 203 +- examples/fig2_real.ipynb | 5211 ++++++++++++++++++++++++++++++++++ 5 files changed, 5548 insertions(+), 533 deletions(-) create mode 100644 examples/fig2_real.ipynb diff --git a/DSA/base_dmd.py b/DSA/base_dmd.py index 781fba0..32c5d28 100644 --- a/DSA/base_dmd.py +++ b/DSA/base_dmd.py @@ -237,6 +237,22 @@ def _compute_rank_from_params( return computed_rank + def _to_torch(self, x): + """Convert numpy array to torch tensor on the appropriate device.""" + if not self.use_torch or x is None: + return x + if isinstance(x, torch.Tensor): + return x.to(self.device) + return torch.from_numpy(x).to(self.device) + + def _to_numpy(self, x): + """Convert torch tensor to numpy array.""" + if not self.use_torch or x is None: + return x + if isinstance(x, torch.Tensor): + return x.cpu().numpy() + return x + def all_to_device(self, device="cpu"): """Move all tensor attributes to specified device.""" for k, v in self.__dict__.items(): diff --git a/DSA/dmdc.py b/DSA/dmdc.py index 3561007..99650be 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -311,6 +311,7 @@ def compute_svd(self): else: H_list.append(h_elem) + self.Hu_shapes = [h.shape for h in self.Hu] for hu_elem in self.Hu: if hu_elem.ndim == 3: Hu_list.append( @@ -352,18 +353,18 @@ def compute_svd(self): self.Sh ) - self.Vht_minus, self.Vht_plus = self.get_plus_minus(self.Vh, self.H) - self.Vut_minus, _ = self.get_plus_minus(self.Vu, self.Hu) + self.Vht_minus, self.Vht_plus = self.get_plus_minus(self.Vh, self.H,self.H_shapes) + self.Vut_minus, _ = self.get_plus_minus(self.Vu, self.Hu,self.Hu_shapes) if self.verbose: print("SVDs computed!") - def get_plus_minus(self, V, H): + def get_plus_minus(self, V, H,H_shapes): if self.ntrials > 1: if self.is_list_data: V_split = torch.split(V, self.H_row_counts, dim=0) Vt_minus_list, Vt_plus_list = [], [] - for v_part, h_shape in zip(V_split, self.H_shapes): + for v_part, h_shape in zip(V_split, H_shapes): if len(h_shape) == 3: # Has trials v_part_reshaped = v_part.reshape(h_shape) newshape = ( diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index db0b91f..0c153c2 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -65,23 +65,6 @@ def __init__( self.rank = rank self.backend = backend - - def _to_torch(self, x): - """Convert numpy array to torch tensor on the appropriate device.""" - if not self.use_torch or x is None: - return x - if isinstance(x, torch.Tensor): - return x.to(self.device) - return torch.from_numpy(x).to(self.device) - - def _to_numpy(self, x): - """Convert torch tensor to numpy array.""" - if not self.use_torch or x is None: - return x - if isinstance(x, torch.Tensor): - return x.cpu().numpy() - return x - def fit(self): """Fit the SubspaceDMDc model.""" self.A_v, self.B_v, self.C_v, self.info = self.subspace_dmdc_multitrial_flexible( @@ -97,34 +80,15 @@ def fit(self): if self.send_to_cpu: self.all_to_device(device='cpu') - - - def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): - """ - Subspace-DMDc for multi-trial data with variable trial lengths. - Now use QR decomposition for computing the oblique projection as in N4SID implementations. - - Parameters: - - y_list: list of arrays, each (p_out, N_i) - output data for trial i - - u_list: list of arrays, each (m, N_i) - input data for trial i - - p: past window length - - f: future window length - - n: state dimension (auto-determined if None) - - ridge: regularization parameter (used only for rank selection/SVD; QR is exact) - - energy: energy threshold for rank selection - - Returns: - - A_hat, B_hat, C_hat: system matrices - - info: dictionary with additional information - """ + def _validate_and_collect_data(self, y_list, u_list, p, f): + """Helper function to validate dimensions and collect data from trials.""" if len(y_list) != len(u_list): raise ValueError("y_list and u_list must have same number of trials") - + # import pdb; pdb.set_trace() n_trials = len(y_list) p_out = y_list[0].shape[0] m = u_list[0].shape[0] - # Validate dimensions across trials for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): if y_trial.shape[0] != p_out: raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") @@ -133,10 +97,6 @@ def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None if y_trial.shape[1] != u_trial.shape[1]: raise ValueError(f"Trial {i}: y and u have different time lengths") - def hankel_stack(X, start, L): - return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) - - # Collect data from all trials U_p_all = [] Y_p_all = [] U_f_all = [] @@ -144,6 +104,9 @@ def hankel_stack(X, start, L): valid_trials = [] T_per_trial = [] + def hankel_stack(X, start, L): + return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): N_trial = Y_trial.shape[1] T_trial = N_trial - (p + f) + 1 @@ -151,10 +114,10 @@ def hankel_stack(X, start, L): if T_trial <= 0: print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") continue - + valid_trials.append(trial_idx) T_per_trial.append(T_trial) - + # Build Hankel matrices for this trial U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) @@ -169,90 +132,102 @@ def hankel_stack(X, start, L): if not valid_trials: raise ValueError("No trials have sufficient data for given number of delays") - # Concatenate across valid trials - U_p = np.concatenate(U_p_all, axis=1) # (p m, T_total) - Y_p = np.concatenate(Y_p_all, axis=1) # (p p_out, T_total) - U_f = np.concatenate(U_f_all, axis=1) # (f m, T_total) - Y_f = np.concatenate(Y_f_all, axis=1) # (f p_out, T_total) + U_p = np.concatenate(U_p_all, axis=1) + Y_p = np.concatenate(Y_p_all, axis=1) + U_f = np.concatenate(U_f_all, axis=1) + Y_f = np.concatenate(Y_f_all, axis=1) T_total = sum(T_per_trial) - Z_p = np.vstack([U_p, Y_p]) # (p (m + p_out), T_total) + Z_p = np.vstack([U_p, Y_p]) + return U_p, Y_p, U_f, Y_f, Z_p, valid_trials, T_per_trial, T_total, p_out, m + + def subspace_dmdc_multitrial_QR_decomposition(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): + """ + Subspace-DMDc for multi-trial data with variable trial lengths using QR decomposition. + """ + U_p, Y_p, U_f, Y_f, Z_p, valid_trials, T_per_trial, T_total, p_out, m = \ + self._validate_and_collect_data(y_list, u_list, p, f) + H = np.vstack([U_f, Z_p, Y_f]) - # Dimensions for slicing dim_uf = f * m dim_zp = p * (m + p_out) - dim_yf = f * p_out - - # Use torch for expensive linear algebra if available - if self.use_torch and H.shape[1] > 100: # Only worth it for larger problems - H_torch = self._to_torch(H) - Z_p_torch = self._to_torch(Z_p) - - # Perform QR on H.T to get equivalent LQ on H - Q, R_upper = torch.linalg.qr(H_torch.T, mode='reduced') + + def calculate_projection_and_svd(H, Z_p): + Q, R_upper = np.linalg.qr(H.T, mode='reduced') L = R_upper.T - # Extract submatrices from L R22 = L[dim_uf:dim_uf + dim_zp, dim_uf:dim_uf + dim_zp] R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] - # Compute oblique projection O = R32 @ pinv(R22) @ Z_p - R22_pinv = torch.linalg.pinv(R22) - O = R32 @ R22_pinv @ Z_p_torch - - # SVD on O - Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) + O = R32 @ np.linalg.pinv(R22) @ Z_p + Uo, s, Vt = np.linalg.svd(O, full_matrices=False) + return Uo, s, Vt + + if self.use_torch and H.shape[1] > 100: + H_torch = self._to_torch(H) + Z_p_torch = self._to_torch(Z_p) + Uo, s, Vt = calculate_projection_and_svd(H_torch, Z_p_torch) - # Convert back to numpy Uo = self._to_numpy(Uo) s = self._to_numpy(s) Vt = self._to_numpy(Vt) else: - # Use numpy for smaller problems or when torch is disabled - # Perform QR on H.T to get equivalent LQ on H - Q, R_upper = np.linalg.qr(H.T, mode='reduced') - L = R_upper.T - - # Extract submatrices from L (lower triangular) - R22 = L[dim_uf:dim_uf + dim_zp, dim_uf:dim_uf + dim_zp] - R32 = L[dim_uf + dim_zp:, dim_uf:dim_uf + dim_zp] - - # Compute oblique projection O = R32 @ pinv(R22) @ Z_p - O = R32 @ np.linalg.pinv(R22) @ Z_p - - # The rest remains the same: SVD on O - Uo, s, Vt = np.linalg.svd(O, full_matrices=False) + Uo, s, Vt = calculate_projection_and_svd(H, Z_p) + if n is None: cs = np.cumsum(s**2) / (s**2).sum() n = int(np.searchsorted(cs, energy) + 1) n = max(1, min(n, min(Uo.shape[1], Vt.shape[0]))) - + U_n = Uo[:, :n] S_n = np.diag(s[:n]) V_n = Vt[:n, :] S_half = np.sqrt(S_n) - Gamma_hat = U_n @ S_half # (f p_out, n) - X_hat = S_half @ V_n # (n, T_total) + Gamma_hat = U_n @ S_half + X_hat = S_half @ V_n + + X, X_next, U_mid = self._time_align_valid_trials(X_hat, u_list, valid_trials, T_per_trial, p) + + + A_hat, B_hat = self._perform_ridge_regression(X, X_next, U_mid, n, lamb) + + C_hat = Gamma_hat[:p_out, :] + noise_covariance, R_hat, Q_hat, S_hat = self._estimate_noise_covariance(X_next, A_hat, X, B_hat, U_mid) + + info = { + "singular_values_O": s, + "rank_used": n, + "Gamma_hat": Gamma_hat, + "f": f, + "n_trials_total": len(y_list), + "n_trials_used": len(valid_trials), + "valid_trials": valid_trials, + "T_per_trial": T_per_trial, + "T_total": T_total, + "trial_lengths": [y.shape[1] for y in y_list], + "noise_covariance": noise_covariance, + 'R_hat': R_hat, + 'Q_hat': Q_hat, + 'S_hat': S_hat + } + + return A_hat, B_hat, C_hat, info - # Time alignment for regression across all trials - # Need to handle variable lengths carefully + def _time_align_valid_trials(self, X_hat, u_list, valid_trials, T_per_trial, p): + """Helper function to time-align trials for regression.""" + # import pdb; pdb.set_trace() X_segments = [] X_next_segments = [] U_mid_segments = [] - Y_segments = [] start_idx = 0 for trial_idx, T_trial in enumerate(T_per_trial): - # Extract states for this trial X_trial = X_hat[:, start_idx:start_idx + T_trial] - - # State transitions within this trial X_trial_curr = X_trial[:, :-1] X_trial_next = X_trial[:, 1:] - # Corresponding control inputs original_trial_idx = valid_trials[trial_idx] U_trial = u_list[original_trial_idx] U_mid_trial = U_trial[:, p:p + (T_trial - 1)] @@ -261,187 +236,63 @@ def hankel_stack(X, start, L): X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) - # TODO: check the time-alignment of Y and X here - # Corresponding output data - align with X_trial time indices - Y_trial = y_list[original_trial_idx] - Y_trial_curr = Y_trial[:, p:p+T_trial-1] - # Y_trial_curr = Y_trial[:, p+1:p+T_trial] - Y_segments.append(Y_trial_curr) - start_idx += T_trial - # Concatenate all segments X = np.concatenate(X_segments, axis=1) X_next = np.concatenate(X_next_segments, axis=1) U_mid = np.concatenate(U_mid_segments, axis=1) - # Regression for A and B + return X, X_next, U_mid + + def _perform_ridge_regression(self, X, X_next, U_mid, n, lamb): + """Helper function to perform ridge regression.""" Z = np.vstack([X, U_mid]) - - # Use torch for ridge regression if available if self.use_torch and Z.shape[1] > 100: Z_torch = self._to_torch(Z) X_next_torch = self._to_torch(X_next) - # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T ZTZ = Z_torch @ Z_torch.T ridge_term = lamb * torch.eye(ZTZ.shape[0], device=self.device, dtype=Z_torch.dtype) AB = torch.linalg.solve(ZTZ + ridge_term, Z_torch @ X_next_torch.T).T - AB = self._to_numpy(AB) - A_hat = AB[:, :n] - B_hat = AB[:, n:] else: - # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T ZTZ = Z @ Z.T ridge_term = lamb * np.eye(ZTZ.shape[0]) AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T - A_hat = AB[:, :n] - B_hat = AB[:, n:] - - # Z = np.vstack([X, U_mid]) - # AB = X_next @ np.linalg.pinv(Z) - # A_hat = AB[:, :n] - # B_hat = AB[:, n:] - - C_hat = Gamma_hat[:p_out, :] - # Estimate noise covariance matrix - # 0) Outputs aligned to X and U_mid (same time indices/columns) - Y_curr = np.concatenate(Y_segments, axis=1) # shape: (p_out, N) + A_hat = AB[:, :n] + B_hat = AB[:, n:] - # 1) Residuals at time t - # Process noise residual (state eq): w_t ≈ x_{t+1} - A x_t - B u_ts - W_hat = X_next - (A_hat @ X + B_hat @ U_mid) # (n, N) + return A_hat, B_hat - # Measurement noise residual (output eq): v_t ≈ y_t - C x_t (since D = 0) - V_hat = Y_curr - (C_hat @ X) # (p_out, N) + def _estimate_noise_covariance(self, X_next, A_hat, X, B_hat, U_mid): + """Helper function to estimate the noise covariance matrix.""" + W_hat = X_next - (A_hat @ X + B_hat @ U_mid) + V_hat = self.Y_curr - (self.C_hat @ X) - # 2) Mean-centering V_hat = V_hat - V_hat.mean(axis=1, keepdims=True) W_hat = W_hat - W_hat.mean(axis=1, keepdims=True) N_res = V_hat.shape[1] - denom = max(N_res - 1, 1) + denom = max(N_res - 1, 1) - # 3) Covariances - R_hat = (V_hat @ V_hat.T) / denom # (p_out, p_out) measurement - Q_hat = (W_hat @ W_hat.T) / denom # (n, n) process - S_hat = (W_hat @ V_hat.T) / denom # (n, p_out) - cross (w,v) + R_hat = (V_hat @ V_hat.T) / denom + Q_hat = (W_hat @ W_hat.T) / denom + S_hat = (W_hat @ V_hat.T) / denom - # 4) Symmetrize eps = 1e-12 R_hat = 0.5 * (R_hat + R_hat.T) + eps * np.eye(R_hat.shape[0]) Q_hat = 0.5 * (Q_hat + Q_hat.T) + eps * np.eye(Q_hat.shape[0]) noise_covariance = np.block([[R_hat, S_hat.T], [S_hat, Q_hat]]) - - info = { - "singular_values_O": s, - "rank_used": n, - "Gamma_hat": Gamma_hat, - "f": f, - "n_trials_total": n_trials, - "n_trials_used": len(valid_trials), - "valid_trials": valid_trials, - "T_per_trial": T_per_trial, - "T_total": T_total, - "trial_lengths": [y.shape[1] for y in y_list], - "noise_covariance": noise_covariance, - 'R_hat': R_hat, - 'Q_hat': Q_hat, - 'S_hat': S_hat - } - return A_hat, B_hat, C_hat, info - - + return noise_covariance, R_hat, Q_hat, S_hat - def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e-8, energy=0.999): - """ - Subspace-DMDc for multi-trial data with variable trial lengths. - - Parameters: - - y_list: list of arrays, each (p_out, N_i) - output data for trial i - - u_list: list of arrays, each (m, N_i) - input data for trial i - - p: past window length - - f: future window length - - n: state dimension (auto-determined if None) - - ridge: regularization parameter - - energy: energy threshold for rank selection∏ - - Returns: - - A_hat, B_hat, C_hat: system matrices - - info: dictionary with additional information - """ - if len(y_list) != len(u_list): - raise ValueError("y_list and u_list must have same number of trials") - - n_trials = len(y_list) - p_out = y_list[0].shape[0] - m = u_list[0].shape[0] - - # Validate dimensions across trials - - for i, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): - if y_trial.shape[0] != p_out: - raise ValueError(f"Trial {i}: y has {y_trial.shape[0]} outputs, expected {p_out}") - if u_trial.shape[0] != m: - raise ValueError(f"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}") - if y_trial.shape[1] != u_trial.shape[1]: - raise ValueError(f"Trial {i}: y and u have different time lengths") - - def hankel_stack(X, start, L): - return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) - - # Collect data from all trials - U_p_all = [] - Y_p_all = [] - U_f_all = [] - Y_f_all = [] - valid_trials = [] - T_per_trial = [] + """Subspace-DMDc using custom method.""" + U_p, Y_p, U_f, Y_f, Z_p, valid_trials, T_per_trial, T_total, p_out, m = \ + self._validate_and_collect_data(y_list, u_list, p, f) - for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): - N_trial = Y_trial.shape[1] - T_trial = N_trial - (p + f) + 1 - - if T_trial <= 0: - print(f"Warning: Trial {trial_idx} has insufficient data (T={T_trial}), skipping") - continue - - valid_trials.append(trial_idx) - T_per_trial.append(T_trial) - - # Build Hankel matrices for this trial - U_p_trial = np.concatenate([hankel_stack(U_trial, j, p) for j in range(T_trial)], axis=1) - Y_p_trial = np.concatenate([hankel_stack(Y_trial, j, p) for j in range(T_trial)], axis=1) - U_f_trial = np.concatenate([hankel_stack(U_trial, j + p, f) for j in range(T_trial)], axis=1) - Y_f_trial = np.concatenate([hankel_stack(Y_trial, j + p, f) for j in range(T_trial)], axis=1) - - U_p_all.append(U_p_trial) - Y_p_all.append(Y_p_trial) - U_f_all.append(U_f_trial) - Y_f_all.append(Y_f_trial) - - - print("="*40) - print(f"Number of valid trials: {len(U_p_trial)}") - - if not valid_trials: - raise ValueError("No trials have sufficient data for given (p,f)") - - # Concatenate across valid trials - U_p = np.concatenate(U_p_all, axis=1) # (pm, T_total) - Y_p = np.concatenate(Y_p_all, axis=1) # (p*p_out, T_total) - U_f = np.concatenate(U_f_all, axis=1) # (fm, T_total) - Y_f = np.concatenate(Y_f_all, axis=1) # (f*p_out, T_total) - - T_total = sum(T_per_trial) - Z_p = np.vstack([U_p, Y_p]) # (p(m+p_out), T_total) - - # Oblique projection: remove row(U_f), project onto row(Z_p) UfUfT = U_f @ U_f.T Xsolve = np.linalg.solve(UfUfT + lamb*np.eye(UfUfT.shape[0]), U_f) Pi_perp = np.eye(T_total) - U_f.T @ Xsolve @@ -451,7 +302,7 @@ def hankel_stack(X, start, L): ZZT = Zp_perp @ Zp_perp.T Zp_pinv_left = np.linalg.solve(ZZT + lamb*np.eye(ZZT.shape[0]), Zp_perp) P = Zp_perp.T @ Zp_pinv_left - O = Yf_perp @ P # ≈ Γ_f X_p + O = Yf_perp @ P Uo, s, Vt = np.linalg.svd(O, full_matrices=False) if n is None: @@ -463,48 +314,13 @@ def hankel_stack(X, start, L): S_n = np.diag(s[:n]) V_n = Vt[:n, :] S_half = np.sqrt(S_n) - Gamma_hat = U_n @ S_half # (f*p_out, n) - X_hat = S_half @ V_n # (n, T_total) - - # Time alignment for regression across all trials - # Need to handle variable lengths carefully - X_segments = [] - X_next_segments = [] - U_mid_segments = [] - - start_idx = 0 - for trial_idx, T_trial in enumerate(T_per_trial): - # Extract states for this trial - X_trial = X_hat[:, start_idx:start_idx + T_trial] - - # State transitions within this trial - X_trial_curr = X_trial[:, :-1] - X_trial_next = X_trial[:, 1:] - - # Corresponding control inputs - original_trial_idx = valid_trials[trial_idx] - U_trial = u_list[original_trial_idx] - U_mid_trial = U_trial[:, p:p + (T_trial - 1)] - - X_segments.append(X_trial_curr) - X_next_segments.append(X_trial_next) - U_mid_segments.append(U_mid_trial) - - start_idx += T_trial - - # Concatenate all segments - X = np.concatenate(X_segments, axis=1) - X_next = np.concatenate(X_next_segments, axis=1) - U_mid = np.concatenate(U_mid_segments, axis=1) - - # Regression for A and B - Z = np.vstack([X, U_mid]) - # Ridge regression: (Z^T Z + λI)^(-1) Z^T X_next^T - ZTZ = Z @ Z.T - ridge_term = lamb * np.eye(ZTZ.shape[0]) - AB = np.linalg.solve(ZTZ + ridge_term, Z @ X_next.T).T - A_hat = AB[:, :n] - B_hat = AB[:, n:] + Gamma_hat = U_n @ S_half + X_hat = S_half @ V_n + + X, X_next, U_mid = self._time_align_valid_trials(X_hat, u_list, valid_trials, T_per_trial, p) + if any([i == 0 for i in X.shape]): + raise ValueError ("too many delays for dataset, reduce number") + A_hat, B_hat = self._perform_ridge_regression(X, X_next, U_mid, n, lamb) C_hat = Gamma_hat[:p_out, :] @@ -513,7 +329,7 @@ def hankel_stack(X, start, L): "rank_used": n, "Gamma_hat": Gamma_hat, "f": f, - "n_trials_total": n_trials, + "n_trials_total": len(y_list), "n_trials_used": len(valid_trials), "valid_trials": valid_trials, "T_per_trial": T_per_trial, @@ -524,8 +340,6 @@ def hankel_stack(X, start, L): return A_hat, B_hat, C_hat, info - - def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energy=0.999, backend='n4sid'): """ Flexible wrapper that handles both fixed-length and variable-length multi-trial data. @@ -535,18 +349,18 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ - u: either (n_trials, m, N) array, (m, N) array, or list of (m, N_i) arrays """ if isinstance(y, list) and isinstance(u, list): + y_list = [y_trial.T for y_trial in y] + u_list = [u_trial.T for u_trial in u] if backend == 'n4sid': - return self.subspace_dmdc_multitrial_QR_decomposition(y, u, p, f, n, lamb, energy) + return self.subspace_dmdc_multitrial_QR_decomposition(y_list, u_list, p, f, n, lamb, energy) else: - return self.subspace_dmdc_multitrial_custom(y, u, p, f, n, lamb, energy) + return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) else: - # Handle 2D arrays (single trial) by converting to list format if y.ndim == 2: y_list = [y] u_list = [u] else: - # Convert 3D arrays to list format y_list = [y[i] for i in range(y.shape[0])] u_list = [u[i] for i in range(u.shape[0])] @@ -560,68 +374,48 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ def predict(self, Y, U, reseed=None): - # Y and U are (n_times, n_channels) or list of 2D arrays + """Predict using the Kalman filter.""" if reseed is None: reseed = 1 - # Handle list of 2D arrays if isinstance(Y, list): - self.kalman = OnlineKalman(self) Y_pred = [] for trial in range(len(Y)): - self.kalman.reset() # Reset filter for each trial - trial_predictions = [] - for t in range(Y[trial].shape[0]): - y_filtered, _ = self.kalman.step( - y=Y[trial][t] if t%reseed == 0 else None, - u=U[trial][t] - ) - trial_predictions.append(y_filtered) + self.kalman.reset() + trial_predictions = [ + self.kalman.step(y=Y[trial][t] if t % reseed == 0 else None, u=U[trial][t])[0] + for t in range(Y[trial].shape[0]) + ] Y_pred.append(np.concatenate(trial_predictions, axis=1).T) - return Y_pred # Return as list to match input format + return Y_pred - self.kalman = OnlineKalman(self) if Y.ndim == 2: - Y_pred = [] - for t in range(Y.shape[0]): - y_filtered, _ = self.kalman.step(y=Y[t] if t%reseed == 0 else None, u=U[t]) - Y_pred.append(y_filtered) - return np.concatenate(Y_pred, axis=1).T + return np.concatenate( + [self.kalman.step(y=Y[t] if t % reseed == 0 else None, u=U[t])[0] for t in range(Y.shape[0])], + axis=1 + ).T else: - # 3D data (n_trials, time, p_out) - # print("Y.shape", Y.shape) - # print("U.shape", U.shape) Y_pred = [] for trial in range(Y.shape[0]): - self.kalman.reset() # Reset filter for each trial - trial_predictions = [] - for t in range(Y.shape[1]): - y_filtered, _ = self.kalman.step(y=Y[trial, t] if t%reseed == 0 else None, u=U[trial, t]) - trial_predictions.append(y_filtered) - # print("y_filtered.shape", y_filtered.shape) + self.kalman.reset() + trial_predictions = [ + self.kalman.step(y=Y[trial, t] if t % reseed == 0 else None, u=U[trial, t])[0] + for t in range(Y.shape[1]) + ] Y_pred.append(np.concatenate(trial_predictions, axis=1).T) return np.array(Y_pred) def compute_hankel(self, *args, **kwargs): - """ - Compute Hankel matrices for SubspaceDMDc. - - This is handled internally within subspace_dmdc_multitrial_QR_decomposition - and subspace_dmdc_multitrial_custom methods. - """ + """Compute Hankel matrices for SubspaceDMDc.""" raise NotImplementedError( "Hankel matrix computation is integrated into the fit() method for SubspaceDMDc. " "Use fit() to compute the model." ) def compute_svd(self, *args, **kwargs): - """ - Compute SVD for SubspaceDMDc. - - This is handled internally within the subspace identification process. - """ + """Compute SVD for SubspaceDMDc.""" raise NotImplementedError( "SVD computation is integrated into the fit() method for SubspaceDMDc. " "Use fit() to compute the model." @@ -629,23 +423,10 @@ def compute_svd(self, *args, **kwargs): class OnlineKalman: - """ - Online Kalman Filter class for real-time state estimation. - - This class maintains the internal state of the Kalman filter and provides - a step method for updating the filter with new observations and inputs. - """ - + """Online Kalman Filter class for real-time state estimation.""" + def __init__(self, dmdc): - """ - Initialize the Online Kalman Filter with a fitted DMDc model. - - Parameters - ---------- - dmdc : object - Fitted DMDc model containing A_v, B_v, C_v matrices and - noise covariance estimates (R_hat, S_hat, Q_hat) - """ + """Initialize the Online Kalman Filter with a fitted DMDc model.""" self.A = dmdc.A_v self.B = dmdc.B_v self.C = dmdc.C_v @@ -653,148 +434,35 @@ def __init__(self, dmdc): self.S = dmdc.info['S_hat'] self.Q = dmdc.info['Q_hat'] - # Get dimensions - # print("C_shape", self.C.shape) self.y_dim, self.x_dim = self.C.shape - # Initialize state storage - self.p_filtereds = [] - self.x_filtereds = [] - self.p_predicteds = [] - self.x_predicteds = [] - self.us = [] - self.ys = [] - self.y_filtereds = [] - self.y_predicteds = [] - self.kalman_gains = [] - - - # def step(self, y=None, u=None, lam=1e-8): - # """ - # Perform one step of the Kalman filter. - - # Parameters - # ---------- - # y : np.ndarray, optional - # Observed output at current time step. If None, the filter - # will predict without observation update. - # u : np.ndarray, optional - # Input at current time step. If None, no input is applied. - - # Returns - # ------- - # y_filtered : np.ndarray - # Filtered output estimate - # x_filtered : np.ndarray - # Filtered state estimate - # """ - # x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) - # p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) - - # # Ensure inputs are column vectors - # if u is not None and u.ndim == 1: - # u = u.reshape(-1, 1) - # if y is not None and y.ndim == 1: - # y = y.reshape(-1, 1) - # if u is None: - # u = np.zeros((self.u_dim, 1)) - # if y is None: - # y = np.zeros((self.y_dim, 1)) - - # S_innov = self.R + self.C @ p_pred @ self.C.T - # K_filtered = p_pred @ self.C.T @ np.linalg.pinv(S_innov) - # p_filtered = p_pred - K_filtered @ self.C @ p_pred - # if not np.isnan(y).any(): - # x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) - # else: - # x_filtered = x_pred.copy() - - # K_pred = (self.S + self.A @ p_pred @ self.C.T) @ np.linalg.pinv(S_innov) - # p_predicted = (self.A @ p_pred @ self.A.T + self.Q - - # K_pred @ (self.S + self.A @ p_pred @ self.C.T).T) - # x_predicted = self.A @ x_pred + self.B @ u - # if not np.isnan(y).any(): - # x_predicted += K_pred @ (y - self.C @ x_pred) - - # # Store results - # self.p_filtereds.append(p_filtered) - # self.x_filtereds.append(x_filtered) - # self.p_predicteds.append(p_predicted) - # self.x_predicteds.append(x_predicted) - # self.us.append(u) - # self.ys.append(y) - # self.y_filtereds.append(self.C @ x_filtered) - # self.y_predicteds.append(self.C @ x_predicted) - # self.kalman_gains.append(K_pred) - - # return self.y_filtereds[-1], self.x_filtereds[-1] - + self.reset() def step(self, y=None, u=None, reg_coef=1e-6): - """ - Perform one step of the Kalman filter. - - Parameters - ---------- - y : np.ndarray, optional - Observed output at current time step. If None, the filter - will predict without observation update. - u : np.ndarray, optional - Input at current time step. If None, no input is applied. - reg_coef : float, optional - Regularization coefficient to add to diagonal of P matrices - to maintain numerical stability. Default: 1e-6 - - Returns - ------- - y_filtered : np.ndarray - Filtered output estimate - x_filtered : np.ndarray - Filtered state estimate - """ - x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) - p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) - - # Add regularization to p_pred to prevent ill-conditioning + """Perform one step of the Kalman filter.""" + x_pred, p_pred = self._predict() p_pred_reg = p_pred + reg_coef * np.eye(self.x_dim) - # Ensure inputs are column vectors - if u is not None and u.ndim == 1: - u = u.reshape(-1, 1) - if y is not None and y.ndim == 1: - y = y.reshape(-1, 1) - if u is None: - u = np.zeros((self.u_dim, 1)) - if y is None: - y = np.zeros((self.y_dim, 1)) - - # Use regularized p_pred in computations + u = self._ensure_column_vector(u, self.u_dim) + y = self._ensure_column_vector(y, self.y_dim) + S_innov = self.R + self.C @ p_pred_reg @ self.C.T K_filtered = p_pred_reg @ self.C.T @ np.linalg.pinv(S_innov) - p_filtered = p_pred_reg - K_filtered @ self.C @ p_pred_reg - - # Add regularization to p_filtered to maintain positive definiteness - p_filtered = (p_filtered + p_filtered.T) / 2 # Ensure symmetry - p_filtered = p_filtered + reg_coef * np.eye(self.x_dim) # Add regularization - - if not np.isnan(y).any(): - x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) - else: - x_filtered = x_pred.copy() - + p_filtered = self._regularize_and_symmetrize(p_pred_reg - K_filtered @ self.C @ p_pred_reg, reg_coef) + + x_filtered = x_pred + K_filtered @ (y - self.C @ x_pred) if not np.isnan(y).any() else x_pred.copy() + K_pred = (self.S + self.A @ p_pred_reg @ self.C.T) @ np.linalg.pinv(S_innov) - p_predicted = (self.A @ p_pred_reg @ self.A.T + self.Q - - K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T) - - # Add regularization to p_predicted and ensure symmetry - p_predicted = (p_predicted + p_predicted.T) / 2 # Ensure symmetry - p_predicted = p_predicted + reg_coef * np.eye(self.x_dim) # Add regularization - - x_predicted = self.A @ x_pred + self.B @ u - if not np.isnan(y).any(): - x_predicted += K_pred @ (y - self.C @ x_pred) - - # Store results + p_predicted = self._regularize_and_symmetrize(self.A @ p_pred_reg @ self.A.T + self.Q - K_pred @ (self.S + self.A @ p_pred_reg @ self.C.T).T, reg_coef) + + x_predicted = self.A @ x_pred + self.B @ u + (K_pred @ (y - self.C @ x_pred) if not np.isnan(y).any() else 0) + + self._store_results(x_filtered, x_predicted, p_filtered, p_predicted, u, y, K_pred) + + return self.y_filtereds[-1], self.x_filtereds[-1] + + def _store_results(self, x_filtered, x_predicted, p_filtered, p_predicted, u, y, K_pred): + """Helper function to store filter results.""" self.p_filtereds.append(p_filtered) self.x_filtereds.append(x_filtered) self.p_predicteds.append(p_predicted) @@ -804,9 +472,26 @@ def step(self, y=None, u=None, reg_coef=1e-6): self.y_filtereds.append(self.C @ x_filtered) self.y_predicteds.append(self.C @ x_predicted) self.kalman_gains.append(K_pred) - - return self.y_filtereds[-1], self.x_filtereds[-1] - + + def _predict(self): + """Helper function for prediction step.""" + x_pred = self.x_predicteds[-1] if self.x_predicteds else np.zeros((self.x_dim, 1)) + p_pred = self.p_predicteds[-1] if self.p_predicteds else np.eye(self.x_dim) + return x_pred, p_pred + + def _ensure_column_vector(self, vector, dim): + """Ensure the input is a column vector.""" + if vector is not None and vector.ndim == 1: + vector = vector.reshape(-1, 1) + if vector is None: + vector = np.zeros((dim, 1)) + return vector + + def _regularize_and_symmetrize(self, matrix, reg_coef): + """Regularize and ensure the matrix is symmetric.""" + matrix = (matrix + matrix.T) / 2 + return matrix + reg_coef * np.eye(matrix.shape[0]) + def reset(self): """Reset the filter to initial state.""" self.p_filtereds = [] @@ -818,13 +503,12 @@ def reset(self): self.y_filtereds = [] self.y_predicteds = [] self.kalman_gains = [] - - + def get_history(self): """Return the complete history of filter states.""" return { 'p_filtereds': self.p_filtereds, - 'x_filtereds': self.x_filtereds, + 'x_filtereds': self.x_filtereds, 'p_predicteds': self.p_predicteds, 'x_predicteds': self.x_predicteds, 'us': self.us, diff --git a/examples/all_dsa_types.ipynb b/examples/all_dsa_types.ipynb index 307ee39..704c49c 100644 --- a/examples/all_dsa_types.ipynb +++ b/examples/all_dsa_types.ipynb @@ -2,47 +2,75 @@ "cells": [ { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "773aa0fd", "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "from DSA import DSA, GeneralizedDSA, InputDSA\n", + "from DSA import DMD, DMDc, SubspaceDMDc, ControllabilitySimilarityTransformDist\n", + "from DSA import DMDConfig, DMDcConfig, SubspaceDMDcConfig\n", + "from DSA import SimilarityTransformDistConfig, ControllabilitySimilarityTransformDistConfig\n", + "from pydmd import DMD as pDMD\n", + "import DSA.pykoopman as pk\n", + "%load_ext autoreload\n", + "%autoreload 2\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52a2ed8c", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n", "Automatic pdb calling has been turned ON\n" ] } ], "source": [ - "import numpy as np \n", - "import matplotlib.pyplot as plt\n", - "from DSA import DSA, GeneralizedDSA, InputDSA\n", - "from DSA import DMD, DMDc, SubspaceDMDc\n", - "from pydmd import DMD as pDMD\n", - "import DSA.pykoopman as pk\n", - "%load_ext autoreload\n", - "%autoreload 2\n", "%pdb" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "d452743b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(18, 9)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "d1 = np.random.random(size=(20,5))\n", "u1 = np.random.random(size=(20,2))\n", "\n", - "d2 = np.random.random(size=(2,20,5))\n", - "u2 = np.random.random(size=(2,20,2))\n", + "d2 = np.random.random(size=(3,20,5))\n", + "u2 = np.random.random(size=(3,20,2))\n", "\n", "d3 = [np.random.random(size=(i,20,5)) for i in range(1,10)]\n", - "u3 = [np.random.random(size=(i,20,2)) for i in range(1,10)]\n" + "u3 = [np.random.random(size=(i,20,2)) for i in range(1,10)]\n", + "\n", + "d4 = [np.random.random(size=(i+5,5)) for i in range(1,10)]\n", + "u4 = [np.random.random(size=(i+5,2)) for i in range(1,10)]\n", + "\n", + "d5 = d4 + d3\n", + "u5 = u4 + u3\n", + "\n", + "len(d5), len(d4)" ] }, { @@ -52,41 +80,66 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(5, 5)" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" + "ename": "ValueError", + "evalue": "Trial 0: y and u have different time lengths", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[14], line 14\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# dmdc = DMDc(d5,u5,n_delays=2,rank_input=10,rank_output=10)\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# dmdc.fit()\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# print(dmdc.A_v.shape)\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 11\u001b[0m \n\u001b[1;32m 12\u001b[0m \u001b[38;5;66;03m#TODO: fix this case\u001b[39;00m\n\u001b[1;32m 13\u001b[0m subdmdc \u001b[38;5;241m=\u001b[39m SubspaceDMDc(d2,u2,n_delays\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m,rank\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,backend\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mn4sid\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 14\u001b[0m \u001b[43msubdmdc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28mprint\u001b[39m(subdmdc\u001b[38;5;241m.\u001b[39mA_v\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28mprint\u001b[39m(subdmdc\u001b[38;5;241m.\u001b[39mB_v\u001b[38;5;241m.\u001b[39mshape)\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:70\u001b[0m, in \u001b[0;36mSubspaceDMDc.fit\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mfit\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 69\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Fit the SubspaceDMDc model.\"\"\"\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA_v, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mB_v, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_v, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minfo \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubspace_dmdc_multitrial_flexible\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 71\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 72\u001b[0m \u001b[43m \u001b[49m\u001b[43mu\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcontrol_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 73\u001b[0m \u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 74\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 75\u001b[0m \u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrank\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 77\u001b[0m \u001b[43m \u001b[49m\u001b[43mlamb\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlamb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;66;03m# Send to CPU if requested (inherited from BaseDMD)\u001b[39;00m\n\u001b[1;32m 80\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msend_to_cpu:\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:371\u001b[0m, in \u001b[0;36mSubspaceDMDc.subspace_dmdc_multitrial_flexible\u001b[0;34m(self, y, u, p, f, n, lamb, energy, backend)\u001b[0m\n\u001b[1;32m 367\u001b[0m \u001b[38;5;66;03m# y_list = [y_trial.T for y_trial in y_list]\u001b[39;00m\n\u001b[1;32m 368\u001b[0m \u001b[38;5;66;03m# u_list = [u_trial.T for u_trial in u_list]\u001b[39;00m\n\u001b[1;32m 370\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m backend \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mn4sid\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 371\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubspace_dmdc_multitrial_QR_decomposition\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlamb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43menergy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 372\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 373\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msubspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy)\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:150\u001b[0m, in \u001b[0;36mSubspaceDMDc.subspace_dmdc_multitrial_QR_decomposition\u001b[0;34m(self, y_list, u_list, p, f, n, lamb, energy)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21msubspace_dmdc_multitrial_QR_decomposition\u001b[39m(\u001b[38;5;28mself\u001b[39m, y_list, u_list, p, f, n\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, lamb\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1e-8\u001b[39m, energy\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.999\u001b[39m):\n\u001b[1;32m 146\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;124;03m Subspace-DMDc for multi-trial data with variable trial lengths using QR decomposition.\u001b[39;00m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m 149\u001b[0m U_p, Y_p, U_f, Y_f, Z_p, valid_trials, T_per_trial, T_total, p_out, m \u001b[38;5;241m=\u001b[39m \\\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_validate_and_collect_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 152\u001b[0m H \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvstack([U_f, Z_p, Y_f])\n\u001b[1;32m 154\u001b[0m dim_uf \u001b[38;5;241m=\u001b[39m f \u001b[38;5;241m*\u001b[39m m\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:98\u001b[0m, in \u001b[0;36mSubspaceDMDc._validate_and_collect_data\u001b[0;34m(self, y_list, u_list, p, f)\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTrial \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: u has \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mu_trial\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m inputs, expected \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mm\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y_trial\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m!=\u001b[39m u_trial\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]:\n\u001b[0;32m---> 98\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTrial \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: y and u have different time lengths\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 100\u001b[0m U_p_all \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 101\u001b[0m Y_p_all \u001b[38;5;241m=\u001b[39m []\n", + "\u001b[0;31mValueError\u001b[0m: Trial 0: y and u have different time lengths" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py\u001b[0m(98)\u001b[0;36m_validate_and_collect_data\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 96 \u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 97 \u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0my_trial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mu_trial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m---> 98 \u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Trial {i}: y and u have different time lengths\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 99 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 100 \u001b[0;31m \u001b[0mU_p_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] } ], "source": [ "\n", - "#TODO: fix this case\n", - "# dmdc = DMDc(d3,u3,n_delays=2,rank_input=10,rank_output=10)\n", + "# dmdc = DMDc(d5,u5,n_delays=2,rank_input=10,rank_output=10)\n", "# dmdc.fit()\n", "# print(dmdc.A_v.shape)\n", "# print(dmdc.B_v.shape)\n", "\n", - "#TODO: fix this case\n", - "# subdmdc = SubspaceDMDc(d1,u1,n_delays=10,rank=2)\n", + "# subdmdc = SubspaceDMDc(d3,u3,n_delays=3,rank=5,backend='n4sid')\n", "# subdmdc.fit()\n", "# print(subdmdc.A_v.shape)\n", "# print(subdmdc.B_v.shape)\n", "\n", "\n", "#TODO: fix this case\n", + "subdmdc = SubspaceDMDc(d2,u2,n_delays=10,rank=5,backend='n4sid')\n", + "subdmdc.fit()\n", + "print(subdmdc.A_v.shape)\n", + "print(subdmdc.B_v.shape)\n", + "\n", + "\n", + "#TODO: fix this case\n", "# subdmdc = SubspaceDMDc(d3,u3,n_delays=2,rank=10,backend='n4sid')\n", "# subdmdc.fit()\n", "# print(subdmdc.A_v.shape)\n", - "# print(subdmdc.B_v.shape)\n" + "# print(subdmdc.B_v.shape)\n", + "\n", + "#TODO: check predictions for all cases" ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 12, "id": "721bc598", "metadata": {}, "outputs": [ @@ -94,57 +147,107 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:364: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", - " if self.dmd_has_control and not self.simdist_has_control:\n" + "Fitting DMDs: 100%|██████████| 3/3 [00:00<00:00, 132.57it/s]\n", + "Computing DMD similarities: 100%|██████████| 3/3 [00:00<00:00, 904.46it/s]\n", + "/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:408: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 3, 3)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 3/3 [00:00<00:00, 147.14it/s]\n", + "Computing DMD similarities: 33%|███▎ | 1/3 [00:03<00:06, 3.07s/it]" ] }, { - "ename": "TypeError", - "evalue": "SimilarityTransformDist.__init__() got an unexpected keyword argument 'joint_optim'", + "ename": "KeyboardInterrupt", + "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[56], line 9\u001b[0m\n\u001b[1;32m 2\u001b[0m u1s \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandom(size\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m20\u001b[39m,\u001b[38;5;241m2\u001b[39m)) \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m3\u001b[39m)]\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m#works\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# dsa = DSA(d1s,dmd_class=pk.Koopman,\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# observables=pk.observables.TimeDelay(),regressor=pDMD(svd_rank=5),\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# score_method='wasserstein')\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m dsa \u001b[38;5;241m=\u001b[39m \u001b[43mInputDSA\u001b[49m\u001b[43m(\u001b[49m\u001b[43md1s\u001b[49m\u001b[43m,\u001b[49m\u001b[43mu1s\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m sim \u001b[38;5;241m=\u001b[39m dsa\u001b[38;5;241m.\u001b[39mfit_score()\n\u001b[1;32m 11\u001b[0m sim\u001b[38;5;241m.\u001b[39mshape\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:733\u001b[0m, in \u001b[0;36mInputDSA.__init__\u001b[0;34m(self, X, X_control, Y, Y_control, dmd_class, dmd_config, simdist_config, device, verbose, n_jobs, compare)\u001b[0m\n\u001b[1;32m 730\u001b[0m compare \u001b[38;5;241m=\u001b[39m simdist_config\u001b[38;5;241m.\u001b[39mcompare\n\u001b[1;32m 731\u001b[0m simdist \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate_compare_method(compare)\n\u001b[0;32m--> 733\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 734\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 735\u001b[0m \u001b[43m \u001b[49m\u001b[43mY\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 736\u001b[0m \u001b[43m \u001b[49m\u001b[43mX_control\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 737\u001b[0m \u001b[43m \u001b[49m\u001b[43mY_control\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 738\u001b[0m \u001b[43m \u001b[49m\u001b[43mdmd_class\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 739\u001b[0m \u001b[43m \u001b[49m\u001b[43msimdist\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 740\u001b[0m \u001b[43m \u001b[49m\u001b[43mdmd_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 741\u001b[0m \u001b[43m \u001b[49m\u001b[43msimdist_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 742\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 743\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 744\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 745\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 747\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m X_control \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 748\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmd_has_control\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:312\u001b[0m, in \u001b[0;36mGeneralizedDSA.__init__\u001b[0;34m(self, X, Y, X_control, Y_control, dmd_class, similarity_class, dmd_config, simdist_config, device, verbose, n_jobs)\u001b[0m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_dmd_api_source(dmd_class)\n\u001b[1;32m 311\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_initiate_dmds()\n\u001b[0;32m--> 312\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msimdist \u001b[38;5;241m=\u001b[39m \u001b[43msimilarity_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimdist_config\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mTypeError\u001b[0m: SimilarityTransformDist.__init__() got an unexpected keyword argument 'joint_optim'" + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[12], line 27\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;66;03m#fixed\u001b[39;00m\n\u001b[1;32m 24\u001b[0m dsa \u001b[38;5;241m=\u001b[39m GeneralizedDSA(d3s,X_control\u001b[38;5;241m=\u001b[39mu3s,\n\u001b[1;32m 25\u001b[0m dmd_class\u001b[38;5;241m=\u001b[39mDMDc,dmd_config\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mdict\u001b[39m(n_delays\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,rank_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,rank_output\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m),\n\u001b[1;32m 26\u001b[0m verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m---> 27\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mdsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_score\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 28\u001b[0m sim\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m#TODO: check generalized dsa with other data structures for data and inputs\u001b[39;00m\n\u001b[1;32m 31\u001b[0m \u001b[38;5;66;03m#TODO: check generalized dsa with the other comparison metric and changing the config\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:692\u001b[0m, in \u001b[0;36mGeneralizedDSA.fit_score\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 680\u001b[0m \u001b[38;5;124;03mStandard fitting function for both DMDs and PAVF\u001b[39;00m\n\u001b[1;32m 681\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 689\u001b[0m \u001b[38;5;124;03m data matrix of the similarity scores between the specific sets of data\u001b[39;00m\n\u001b[1;32m 690\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 691\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfit_dmds()\n\u001b[0;32m--> 692\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscore\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:797\u001b[0m, in \u001b[0;36mGeneralizedDSA.score\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 792\u001b[0m loop \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 793\u001b[0m pairs\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose\n\u001b[1;32m 795\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(pairs, desc\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComputing DMD similarities\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 796\u001b[0m )\n\u001b[0;32m--> 797\u001b[0m results \u001b[38;5;241m=\u001b[39m [compute_similarity(i, j) \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m loop]\n\u001b[1;32m 799\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:797\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 792\u001b[0m loop \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 793\u001b[0m pairs\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose\n\u001b[1;32m 795\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(pairs, desc\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComputing DMD similarities\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 796\u001b[0m )\n\u001b[0;32m--> 797\u001b[0m results \u001b[38;5;241m=\u001b[39m [\u001b[43mcompute_similarity\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mj\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m loop]\n\u001b[1;32m 799\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:768\u001b[0m, in \u001b[0;36mGeneralizedDSA.score..compute_similarity\u001b[0;34m(i, j)\u001b[0m\n\u001b[1;32m 761\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msimdist_has_control \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmd_has_control:\n\u001b[1;32m 762\u001b[0m simdist_args\u001b[38;5;241m.\u001b[39mextend(\n\u001b[1;32m 763\u001b[0m [\n\u001b[1;32m 764\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_dmd_control_matrix(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmds[\u001b[38;5;241m0\u001b[39m][i]),\n\u001b[1;32m 765\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_dmd_control_matrix(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmds[ind2][j]),\n\u001b[1;32m 766\u001b[0m ]\n\u001b[1;32m 767\u001b[0m )\n\u001b[0;32m--> 768\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimdist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_score\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msimdist_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 770\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_jobs \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 771\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcomputing similarity between DMDs \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mj\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:471\u001b[0m, in \u001b[0;36mSimilarityTransformDist.fit_score\u001b[0;34m(self, A, B, iters, lr, score_method, wasserstein_weightings)\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 469\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m--> 471\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 472\u001b[0m \u001b[43m \u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 473\u001b[0m \u001b[43m \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 474\u001b[0m \u001b[43m \u001b[49m\u001b[43miters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 475\u001b[0m \u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 476\u001b[0m \u001b[43m \u001b[49m\u001b[43mwasserstein_weightings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwasserstein_weightings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 477\u001b[0m \u001b[43m \u001b[49m\u001b[43mscore_method\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscore_method\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 478\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 480\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscore(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mB, score_method\u001b[38;5;241m=\u001b[39mscore_method)\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:254\u001b[0m, in \u001b[0;36mSimilarityTransformDist.fit\u001b[0;34m(self, A, B, iters, lr, score_method, wasserstein_weightings)\u001b[0m\n\u001b[1;32m 248\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star \u001b[38;5;241m/\u001b[39m torch\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mnorm(\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, keepdim\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 250\u001b[0m )\n\u001b[1;32m 251\u001b[0m \u001b[38;5;66;03m# wasserstein_distance(A.cpu().numpy(),B.cpu().numpy())\u001b[39;00m\n\u001b[1;32m 252\u001b[0m \n\u001b[1;32m 253\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 254\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlosses, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msim_net \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize_C\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morthog\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 257\u001b[0m \u001b[38;5;66;03m# permute the first row and column of B then rerun the optimization\u001b[39;00m\n\u001b[1;32m 258\u001b[0m P \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39meye(B\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], device\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:334\u001b[0m, in \u001b[0;36mSimilarityTransformDist.optimize_C\u001b[0;34m(self, A, B, lr, iters, orthog, verbose)\u001b[0m\n\u001b[1;32m 332\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m 333\u001b[0m \u001b[38;5;66;03m# Compute the Frobenius norm between A and the product.\u001b[39;00m\n\u001b[0;32m--> 334\u001b[0m loss \u001b[38;5;241m=\u001b[39m simdist_loss(A, \u001b[43msim_net\u001b[49m\u001b[43m(\u001b[49m\u001b[43mB\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 336\u001b[0m loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[1;32m 338\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:64\u001b[0m, in \u001b[0;36mLearnableSimilarityTransform.forward\u001b[0;34m(self, B)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, B):\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39morthog:\n\u001b[0;32m---> 64\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m \u001b[38;5;241m@\u001b[39m B \u001b[38;5;241m@\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 66\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC \u001b[38;5;241m@\u001b[39m B \u001b[38;5;241m@\u001b[39m torch\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39minv(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC)\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/utils/parametrize.py:368\u001b[0m, in \u001b[0;36m_inject_property..get_parametrized\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m get_cached_parametrization(parametrization)\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 367\u001b[0m \u001b[38;5;66;03m# If caching is not active, this function just evaluates the parametrization\u001b[39;00m\n\u001b[0;32m--> 368\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mparametrization\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/utils/parametrize.py:273\u001b[0m, in \u001b[0;36mParametrizationList.forward\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 271\u001b[0m curr_idx \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 272\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28mstr\u001b[39m(curr_idx)):\n\u001b[0;32m--> 273\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mcurr_idx\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 274\u001b[0m curr_idx \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:128\u001b[0m, in \u001b[0;36mCayleyMap.forward\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, X):\n\u001b[1;32m 127\u001b[0m \u001b[38;5;66;03m# (I + X)(I - X)^{-1}\u001b[39;00m\n\u001b[0;32m--> 128\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinalg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mId\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mId\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] }, { "name": "stdout", "output_type": "stream", "text": [ - "> \u001b[0;32m/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py\u001b[0m(312)\u001b[0;36m__init__\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m 310 \u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dmd_api_source\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdmd_class\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 311 \u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initiate_dmds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m--> 312 \u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimdist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msimilarity_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimdist_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 313 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 314 \u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0m_initiate_dmds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "> \u001b[0;32m/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py\u001b[0m(128)\u001b[0;36mforward\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 126 \u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 127 \u001b[0;31m \u001b[0;31m# (I + X)(I - X)^{-1}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m--> 128 \u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mId\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mId\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 129 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 130 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0m\n" ] } ], "source": [ - "d1s = [np.random.random(size=(20,5)) for _ in range(3)]\n", - "u1s = [np.random.random(size=(20,2)) for _ in range(3)]\n", + "d1s = [np.random.random(size=(1+_,20,5)) for _ in range(3)]\n", + "u1s = [np.random.random(size=(1+_,20,2)) for _ in range(3)]\n", + "\n", + "d3s = [d3 for _ in range(3)]\n", + "u3s = [u3 for _ in range(3)]\n", "\n", + "dmdconfig = DMDConfig(n_delays=20)\n", + "simdistconfig = SimilarityTransformDistConfig(score_method='wasserstein')\n", + "csimdistconfig = ControllabilitySimilarityTransformDistConfig(compare='joint',\n", + " score_method='euclidean', align_inputs=False,return_distance_components=True)\n", "#works\n", "# dsa = DSA(d1s,dmd_class=pk.Koopman,\n", "# observables=pk.observables.TimeDelay(),regressor=pDMD(svd_rank=5),\n", "# score_method='wasserstein')\n", + "dmd_config = SubspaceDMDcConfig(rank=5)\n", + "dmdc_config = DMDcConfig()\n", + "\n", + "dsa = InputDSA(d3s,u3s,simdist_config=csimdistconfig,\n", + " dmd_class=DMDc,dmd_config=dmdc_config,verbose=True)\n", + "sim = dsa.fit_score()\n", + "print(sim.shape)\n", "\n", - "dsa = InputDSA(d1s,u1s)\n", + "#fixed\n", + "dsa = GeneralizedDSA(d3s,X_control=u3s,\n", + " dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", + " verbose=True)\n", "sim = dsa.fit_score()\n", "sim.shape\n", "\n", - "\n" + "#TODO: check generalized dsa with other data structures for data and inputs\n", + "#TODO: check generalized dsa with the other comparison metric and changing the config\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "26c08771", + "id": "57132dea", "metadata": {}, "outputs": [], "source": [] diff --git a/examples/fig2_real.ipynb b/examples/fig2_real.ipynb new file mode 100644 index 0000000..ca13ae3 --- /dev/null +++ b/examples/fig2_real.ipynb @@ -0,0 +1,5211 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "52fcf42e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shared parameters:\n", + " System: n=10, m=1, p_out=10, N=10000\n", + " Dynamics: rho1=0.92, rho2=0.82, g1=1, g2=1.5\n", + " Noise: obs_noise=0.0001, process_noise=0.0\n", + " Nonlinearity: nonlinear_eps=0.01\n", + " Model: n_delays=150, rank=10, pf=150\n", + " Evaluation: n_iters=10\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Figure 2 InputDSA Data Analysis \n", + "\"\"\"\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "# SHARED PARAMETERS - used consistently across all analyses below\n", + "# Only change these values to modify the entire notebook behavior\n", + "n = 10 # latent state dim\n", + "n_large = 50\n", + "m = 1 # input dim \n", + "p_out = 10 # observed dim (partial observation) - gets overridden in some cells\n", + "p_out_small = 2\n", + "N = 10000 # sequence length\n", + "N_small = 1000\n", + "n_Us = 4\n", + "obs_noise = 0.0001\n", + "process_noise = 0.0#1\n", + "nonlinear_eps = 0.01\n", + "input_alpha = 0.001\n", + "g1 = 1\n", + "g2 = 1.5\n", + "rho1 = 0.92\n", + "rho2 = 0.82\n", + "seed1 = 11\n", + "seed2 = 12\n", + "n_delays = 150\n", + "rank = 10\n", + "pf = 150\n", + "n_iters = 10\n", + "backend = 'n4sid'\n", + "\n", + "print(f\"Shared parameters:\")\n", + "print(f\" System: n={n}, m={m}, p_out={p_out}, N={N}\")\n", + "print(f\" Dynamics: rho1={rho1}, rho2={rho2}, g1={g1}, g2={g2}\")\n", + "print(f\" Noise: obs_noise={obs_noise}, process_noise={process_noise}\")\n", + "print(f\" Nonlinearity: nonlinear_eps={nonlinear_eps}\")\n", + "print(f\" Model: n_delays={n_delays}, rank={rank}, pf={pf}\")\n", + "print(f\" Evaluation: n_iters={n_iters}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a08ecb20", + "metadata": {}, + "outputs": [], + "source": [ + "# in this analysis, we are goign to look at how to appropriately compare partially observed systems\n", + "# we will look at the following systems\n", + "\n", + "# 4 systems, made up fo 2 pairings (1,2) (3,4) same intrinsic dynamics, (1,3) (2,4) same read in dynamics\n", + "# we will look at the behavior in the fully observed setting of DSA and AgentDSA, and then in the\n", + "#partially observed setting of DMDc versus subspace DMDc\n", + "#we'll looking at clustering capability across many instantiatons of the data, \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4b891d5e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "# Updated to use DSA package imports\n", + "import sys\n", + "sys.path.insert(0, '..') # Add parent directory to path to import DSA\n", + "\n", + "plt.rcParams['pdf.fonttype'] = 42\n", + "plt.rcParams['ps.fonttype'] = 42\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f3cdd518", + "metadata": {}, + "outputs": [], + "source": [ + "from DSA import InputDSA\n", + "from DSA import SimilarityTransformDist as SimDist\n", + "from DSA import ControllabilitySimilarityTransformDist as ControlSimDist\n", + "from tqdm import tqdm\n", + "\n", + "def compare_systems_with_InputDSA(Ys, Us, n_delays=150, rank=10, backend='n4sid'):\n", + " \"\"\"\n", + " Compare controlled systems using InputDSA from DSA package.\n", + " Uses the new update_compare_method() to avoid refitting DMDs multiple times.\n", + " \n", + " Parameters:\n", + " - Ys: list of output data arrays (p_out, N)\n", + " - Us: list of control input arrays (m, N)\n", + " - n_delays: number of delays for DMD\n", + " - rank: rank for DMD\n", + " - backend: 'n4sid' or 'custom' for SubspaceDMDc\n", + " \n", + " Returns:\n", + " - sims_full: joint similarity scores\n", + " - sims_control_joint: control scores from joint optimization\n", + " - sims_state_joint: state scores from joint optimization\n", + " - sims_control_separate: control scores from separate optimization\n", + " - sims_state_separate: state scores from separate optimization\n", + " \"\"\"\n", + " # Transpose data for InputDSA (expects time_first=True by default)\n", + " Ys_T = [Y.T for Y in Ys]\n", + " Us_T = [U.T for U in Us]\n", + " \n", + " # Configure DMD\n", + " # dmd_config = SubspaceDMDcConfig(\n", + " # n_delays=n_delays,\n", + " # rank=rank,\n", + " # backend=backend\n", + " # )\n", + " dmd_config = dict(\n", + " n_delays=n_delays,\n", + " rank=rank,\n", + " backend=backend\n", + " )\n", + " \n", + " # Create InputDSA with joint comparison\n", + " # This will fit the DMDs once and return joint comparison results\n", + " inputDSA = InputDSA(\n", + " X=Ys_T,\n", + " X_control=Us_T,\n", + " dmd_config=dmd_config,\n", + " compare='joint',\n", + " return_distance_components=True\n", + " )\n", + " \n", + " # Fit DMDs and get joint comparison results\n", + " sims_full, sims_state_joint, sims_control_joint = inputDSA.fit_score()\n", + " \n", + " # Update comparison method to 'state' without refitting DMDs\n", + " inputDSA.update_compare_method(compare='state')\n", + " sims_state_separate = inputDSA.score()\n", + " \n", + " # Update comparison method to 'control' without refitting DMDs\n", + " inputDSA.update_compare_method(compare='control')\n", + " sims_control_separate = inputDSA.score()\n", + " \n", + " return sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate\n", + "\n", + "\n", + "#strict comparison metrics, for when we fit and compare separately\n", + "def compare_A(A1,A2):\n", + " simdist = SimDist(iters=1000,score_method='wasserstein',lr=1e-3,verbose=True)\n", + " return simdist.fit_score(A1,A2)\n", + "\n", + "def compare_A_full(As):\n", + " sims = np.zeros((len(As),len(As)))\n", + " for i in range(len(As)):\n", + " for j in range(i+1,len(As)):\n", + " sims[i,j] = compare_A(As[i],As[j])\n", + " sims[j,i] = sims[i,j]\n", + " return sims\n", + "\n", + "def compare_B(B1,B2):\n", + " csimdist = ControlSimDist(score_method='euclidean',compare='control')\n", + " sim = csimdist.fit_score(None, None, B1, B2)\n", + " return sim\n", + "\n", + "def compare_systems_full(As,Bs):\n", + " csimdist = ControlSimDist(score_method='euclidean',compare='joint',return_distance_components=True)\n", + " sims_full = np.zeros((len(As),len(As)))\n", + " sims_control_joint = np.zeros((len(As),len(As)))\n", + " sims_state_joint = np.zeros((len(As),len(As)))\n", + " sims_control_separate = np.zeros((len(As),len(As)))\n", + " sims_state_separate = np.zeros((len(As),len(As)))\n", + " for i in tqdm(range(len(As))):\n", + " for j in range(i+1,len(As)):\n", + " all_sims = csimdist.fit_score(As[i],As[j],Bs[i],Bs[j])\n", + " sims_full[i,j] = sims_full[j,i] = all_sims[0]\n", + " sims_state_joint[i,j] = sims_state_joint[j,i] = all_sims[1]\n", + " sims_control_joint[i,j] = sims_control_joint[j,i] = all_sims[2]\n", + " \n", + " for i in tqdm(range(len(As))):\n", + " for j in range(i+1,len(As)):\n", + " sims_state_separate[i,j] = compare_A(As[i],As[j])\n", + " sims_control_separate[i,j] = compare_B(Bs[i],Bs[j])\n", + " sims_state_separate[j,i] = sims_state_separate[i,j]\n", + " sims_control_separate[j,i] = sims_control_separate[i,j]\n", + "\n", + " return sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7ba785c8", + "metadata": {}, + "outputs": [], + "source": [ + "def make_stable_A(n, rho=0.9, rng=None):\n", + " rng = np.random.default_rng(rng)\n", + " M = rng.standard_normal((n, n))\n", + " # Make it diagonally dominant-ish and scale spectral radius\n", + " A = M / np.max(np.abs(np.linalg.eigvals(M))) * rho\n", + " return A\n", + "\n", + "def simulate_system(A, B, C, U, x0=None,rng=None,obs_noise=0.0,process_noise=0.0,\n", + " nonlinear_eps=0.0,nonlinear_func= lambda x: np.tanh(x),nonlinear_eps_input=0.0):\n", + " n, m = B.shape\n", + " p_out = C.shape[0]\n", + " N = U.shape[1]\n", + " X = np.zeros((n, N+1))\n", + " C_full = np.eye(A.shape[0])\n", + " C_full[np.where(C == 1)[1],np.where(C == 1)[1]] = 0.0\n", + "\n", + " if x0 is not None:\n", + " X[:, 0] = x0\n", + " else:\n", + " X[:, 0] = np.random.default_rng(rng).standard_normal((n,))\n", + " Y = np.zeros((p_out, N))\n", + " for t in range(N):\n", + " X[:, t+1] = A @ (X[:, t]) + nonlinear_eps * C_full @ nonlinear_func(A @ X[:, t]) + \\\n", + " B @ ((1-nonlinear_eps_input) * U[:, t] + nonlinear_eps_input * nonlinear_func(U[:, t])) + \\\n", + " np.random.normal(0, process_noise, (n,))\n", + " Y[:, t] = C @ X[:, t] + np.random.normal(0, obs_noise, (p_out,))\n", + " return X[:, 1:], Y # states aligned with Y\n", + "\n", + "def smooth_input(m, N, alpha=0.9, rng=None):\n", + " rng = np.random.default_rng(rng)\n", + " w = rng.standard_normal((m, N))\n", + " U = np.zeros_like(w)\n", + " for t in range(N):\n", + " U[:, t] = alpha*(U[:, t-1] if t>0 else 0) + (1-alpha)*w[:, t]\n", + " return U" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "87d14512", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def simulate_As_Bs(latent_dim, input_dim, observed_dim, seq_length,rho1=rho1,\n", + " rho2=rho2, g1=g1,g2=g2, seed1=seed1, seed2=seed2, input_alpha=input_alpha,same_inp=False,n_Us=n_Us,\n", + " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x)):\n", + "\n", + " A1_true = make_stable_A(latent_dim, rho=rho1, rng=seed1)\n", + " cov_matrix_B1 = np.random.default_rng(seed1).standard_normal((latent_dim, latent_dim))\n", + " cov_matrix_B1 = cov_matrix_B1 @ cov_matrix_B1.T # Make it symmetric positive definite\n", + " B1_true = np.random.default_rng(seed1).multivariate_normal(np.zeros(latent_dim), cov_matrix_B1, input_dim).T * g1\n", + "\n", + " A2_true = make_stable_A(latent_dim, rho=rho2, rng=seed2)\n", + " C = np.linalg.qr(np.random.default_rng(seed2).standard_normal((latent_dim, latent_dim)))[0]\n", + " cov_matrix_B2_rotated = C @ cov_matrix_B1 @ C.T \n", + " B2_true = np.random.default_rng(seed2).multivariate_normal(np.zeros(latent_dim), cov_matrix_B2_rotated, input_dim).T * g2\n", + "\n", + " # Random partial observation: select p_out of n states\n", + " idx_obs = np.sort(np.random.default_rng(seed1).choice(latent_dim, size=observed_dim, replace=False))\n", + " C_true = np.zeros((observed_dim, latent_dim))\n", + " C_true[np.arange(observed_dim), idx_obs] = 1.0\n", + " \n", + " X_trues, Ys,Us = [], [], []\n", + " i = 0\n", + " if same_inp:\n", + " U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1+i) \n", + " control_labels = []\n", + " state_labels = []\n", + " for a1, As in enumerate([A1_true, A2_true]):\n", + " for b1, Bs in enumerate([B1_true, B2_true]):\n", + " i += 1\n", + " if not same_inp:\n", + " for j in range(n_Us):\n", + " U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1+ i + j) \n", + " X_true, Y = simulate_system(As, Bs, C_true, U, x0=np.zeros(latent_dim),rng=seed1+i,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", + " X_trues.append(X_true)\n", + " Ys.append(Y)\n", + " Us.append(U)\n", + " control_labels.append(b1)\n", + " state_labels.append(a1)\n", + " else:\n", + " X_true, Y = simulate_system(As, Bs, C_true, U, x0=np.zeros(latent_dim),rng=seed1+i,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", + " X_trues.append(X_true)\n", + " Ys.append(Y)\n", + " Us.append(U)\n", + " control_labels.append(b1)\n", + " state_labels.append(a1)\n", + "\n", + " return X_trues, Ys, Us, control_labels, state_labels, (A1_true, A2_true), (B1_true, B2_true)\n", + "\n", + "\n", + "X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out,N,\n", + " input_alpha=input_alpha,g1=g1,g2=g2,n_Us=1,obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x))\n", + "fig, ax = plt.subplots(1, 4, figsize=(8, 2),sharey='row')\n", + "#plot Us and Ys against time\n", + "for i in range(4):\n", + " # ax[0, i].plot(Us[i].T[:100])\n", + " ax[i].plot(Ys[i].T[:100,:],alpha=0.5)\n", + " \n", + " # Remove spines and ticks\n", + " for spine in ax[i].spines.values():\n", + " spine.set_visible(False)\n", + " ax[i].set_xticks([])\n", + " ax[i].set_yticks([])\n", + "# plt.savefig(f'{folder_path}/data_examples.pdf', format='pdf', dpi=300, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "# X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out,N_small,\n", + "# input_alpha=input_alpha,g1=g1,g2=g2, same_inp=False,n_Us=4,\n", + "# obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "728cf5a2", + "metadata": {}, + "outputs": [], + "source": [ + "from DSA import DMD,DMDc, SubspaceDMDc\n", + "from tqdm import tqdm\n", + "\n", + "def get_dmds(Ys,n_delays=1,rank=None):\n", + " As = []\n", + " for Y in Ys:\n", + " dmd = DMD(Y.T,n_delays=n_delays,rank=rank)\n", + " dmd.fit()\n", + " As.append(dmd.A_v.numpy())\n", + " return As\n", + "\n", + "def get_dmdcs(Ys,Us,n_delays=1,rank=None):\n", + " As = []\n", + " Bs = []\n", + " for Y, U in zip(Ys, Us):\n", + " dmdc = DMDc(Y.T, U.T,n_delays=n_delays,n_control_delays=n_delays,rank_input=rank,rank_output=rank)\n", + " dmdc.fit()\n", + " As.append(dmdc.A_v.numpy())\n", + " Bs.append(dmdc.B_v.numpy())\n", + " return As, Bs\n", + "\n", + "\n", + "def get_subspace_dmdcs(Ys, Us, p=20, rank=None, backend='n4sid'):\n", + " \"\"\"Fit SubspaceDMDc models using DSA package.\"\"\"\n", + " As, Bs, Cs, infos = [], [], [], []\n", + " for Y, U in zip(Ys, Us):\n", + " model = SubspaceDMDc(Y.T, U.T, n_delays=p, rank=rank, backend=backend)\n", + " model.fit()\n", + " As.append(model.A_v)#.numpy())\n", + " Bs.append(model.B_v)#.numpy())\n", + " Cs.append(model.C_v)#.numpy())\n", + " infos.append(model.info)\n", + " return As, Bs, Cs, infos\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "db4d50cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000)]\n" + ] + } + ], + "source": [ + "X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out_small,\n", + " N_small,input_alpha=input_alpha,g1=g1,g2=g2,same_inp=False,n_Us=n_Us,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps)\n", + "print([i.shape for i in Ys])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3ef1f7f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot examples of the inputs and the outputs\n", + "fig, ax = plt.subplots(2,2,figsize=(4,2),sharex=True,sharey=True)\n", + "ax = ax.flatten()\n", + "for i in range(4):\n", + " ind = 4*i\n", + " ax[i].plot(Us[ind].T[:100] + 10*np.mean(np.abs(Us[ind])), color=plt.cm.Set2(1), label='Input (u)')\n", + " ax[i].plot(Ys[ind].T[:100, 0], color=plt.cm.Set2(2), label='Output (y)')\n", + " #remove all ticks and lines\n", + " ax[i].set_xticks([])\n", + " ax[i].set_yticks([])\n", + " ax[i].spines['top'].set_visible(False)\n", + " ax[i].spines['right'].set_visible(False)\n", + " ax[i].spines['bottom'].set_visible(False)\n", + " ax[i].spines['left'].set_visible(False)\n", + " \n", + "ax[0].text(1, 0.4, 'Input', transform=ax[0].transAxes, color=plt.cm.Set2(1), va='top')\n", + "ax[0].text(1, 0.2, 'Output', transform=ax[0].transAxes, color=plt.cm.Set2(2), va='top')\n", + "plt.tight_layout()\n", + "# plt.savefig(f'{folder_path}/input_output_examples.pdf', format='pdf', dpi=300, bbox_inches='tight')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eef05f5d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[legend.py:1217 - _parse_legend_args() ] No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use SubspaceDMDc from DSA package to analyze singular values\n", + "\n", + "\n", + "fig, ax = plt.subplots(2,2,figsize=(9,6),sharey=True,sharex=True)\n", + "ax = ax.flatten()\n", + " \n", + "for j, (Y, U) in enumerate(zip(Ys[::n_Us], Us[::n_Us])):\n", + " # Test different numbers of delays for subspace identification\n", + " nds_all = [10, 25, 50, 75, 100, 125, 150, 175, 200]\n", + " \n", + " for k, nds in enumerate(nds_all):\n", + " # Fit SubspaceDMDc with varying number of delays\n", + " model = SubspaceDMDc(\n", + " Y.T, # SubspaceDMDc expects (T, p_out)\n", + " U.T, # SubspaceDMDc expects (T, m)\n", + " n_delays=nds,\n", + " rank=20, # Use fixed rank for comparison\n", + " backend='n4sid'\n", + " )\n", + " model.fit()\n", + " \n", + " # Extract singular values from model info\n", + " singular_vals = model.info['singular_values_O']\n", + " \n", + " # Convert to numpy if needed\n", + " if hasattr(singular_vals, 'numpy'):\n", + " singular_vals = singular_vals.numpy()\n", + " \n", + " # Plot singular values\n", + " ax[j].plot(singular_vals, '-', label=f'{nds}', \n", + " color=plt.cm.Blues_r(k / (len(nds_all) + 4)))\n", + " ax[j].set_yscale('log')\n", + " ax[j].axvline(x=20, color='k', linestyle=':', alpha=0.5)\n", + " \n", + " ax[j].set_xlabel('Mode Number')\n", + " ax[j].set_title(f'System {j+1}')\n", + " ax[1].legend(title=\"Delays\", loc='upper right', bbox_to_anchor=(1.5, 1), \n", + " fontsize=12, title_fontsize=15)\n", + "\n", + "ax[0].set_ylabel('Singular Value')\n", + "ax[2].set_ylabel('Singular Value')\n", + "plt.tight_layout()\n", + "# plt.savefig(f'{folder_path}/singular_values_subspace_dmdc.pdf', format='pdf', dpi=300, bbox_inches='tight')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3636fc5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n", + "========================================\n", + "Number of valid trials: 150\n" + ] + } + ], + "source": [ + "dec = 0 #can change this to look at the efect of using the incorrect ranks\n", + "A_dmd = get_dmds(Ys,n_delays=n_delays,rank=rank- dec)\n", + "A_cs, B_cs = get_dmdcs(Ys,Us,n_delays=n_delays,rank=rank - dec)\n", + "As, Bs, Cs, infos = get_subspace_dmdcs(Ys,Us,p=pf,rank=rank-dec,backend='custom')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5ae5efa9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N4SID - A matrix shapes: [(10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10)]\n", + "N4SID - Ranks used: [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]\n", + "N4SID - Backend info: ['unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown']\n", + "\\nEigenvalue comparison (first system):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\nComputing similarity matrices...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 548.06it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 123.68it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 608.27it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 135.77it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Custom backend silhouette score: 0.685\n", + "N4SID backend silhouette score: 0.669\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "As_n4sid, Bs_n4sid, Cs_n4sid, infos_n4sid = get_subspace_dmdcs(Ys, Us, p=pf, rank=rank-dec, backend='n4sid')\n", + "print(f\"N4SID - A matrix shapes: {[A.shape for A in As_n4sid]}\")\n", + "print(f\"N4SID - Ranks used: {[info['rank_used'] for info in infos_n4sid]}\")\n", + "print(f\"N4SID - Backend info: {[info.get('backend', 'unknown') for info in infos_n4sid]}\")\n", + "\n", + "# Quick comparison of eigenvalues (first system)\n", + "print(\"\\\\nEigenvalue comparison (first system):\")\n", + "eigs_custom = np.linalg.eigvals(As[0])\n", + "eigs_n4sid = np.linalg.eigvals(As_n4sid[0])\n", + "eigs_real = np.linalg.eigvals(A_trues[0])\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(eigs_real.real, eigs_real.imag, alpha=0.7, label='True', s=100)\n", + "plt.scatter(eigs_custom.real, eigs_custom.imag, alpha=0.7, label='Custom backend', s=50)\n", + "plt.scatter(eigs_n4sid.real, eigs_n4sid.imag, alpha=0.7, label='N4SID backend', s=50, marker='x',c='k')\n", + "plt.xlabel('Real part')\n", + "plt.ylabel('Imaginary part')\n", + "plt.title('Eigenvalue comparison (first system)')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)\n", + "plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)\n", + "plt.show()\n", + "\n", + "# Compute distances using both backends for comparison\n", + "print(\"\\\\nComputing similarity matrices...\")\n", + "_, _, _, _, sims_state_custom = compare_systems_full(As, Bs)\n", + "_, _, _, _, sims_state_n4sid = compare_systems_full(As_n4sid, Bs_n4sid)\n", + "\n", + "from sklearn.metrics import silhouette_score\n", + "silh_custom = silhouette_score(sims_state_custom, state_labels, metric='precomputed')\n", + "silh_n4sid = silhouette_score(sims_state_n4sid, state_labels, metric='precomputed')\n", + "\n", + "\n", + "print(f\"Custom backend silhouette score: {silh_custom:.3f}\")\n", + "print(f\"N4SID backend silhouette score: {silh_n4sid:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "79bb2540", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 490.65it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 138.91it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 525.72it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 134.68it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 604.50it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 126.83it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 620.90it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 135.16it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import silhouette_score\n", + "A_type = [A_dmd, A_cs, As, As_n4sid]\n", + "B_type = [A_dmd, B_cs, Bs, Bs_n4sid]\n", + "names = ['DMD, Partially Observed', 'DMDc, Partially Observed', 'Old Subspace DMDc, Partially Observed', 'Subspace DMDc, Partially Observed']\n", + "for Ai, Bi, name in zip(A_type, B_type, names):\n", + "\n", + " sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate = compare_systems_full(Ai,Bi)\n", + "\n", + " fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + " \n", + " # Define data and titles for each subplot\n", + " sims_data = [sims_full, sims_state_joint, sims_control_joint, sims_state_separate, sims_control_separate]\n", + " titles = ['Joint', \n", + " f'State (Joint) \\n {np.round(silhouette_score(sims_state_joint,state_labels,metric=\"precomputed\"),2)}',\n", + " f'Control (Joint) \\n {np.round(silhouette_score(sims_control_joint,control_labels,metric=\"precomputed\"),2)}',\n", + " f'State (Separate) \\n {np.round(silhouette_score(sims_state_separate,state_labels,metric=\"precomputed\"),2)}',\n", + " f'Control (Separate) \\n {np.round(silhouette_score(sims_control_separate,control_labels,metric=\"precomputed\"),2)}']\n", + " \n", + " # Loop through all subplots\n", + " for i, (data, title) in enumerate(zip(sims_data, titles)):\n", + " im = ax[i].imshow(data)\n", + " cbar = plt.colorbar(im, ax=ax[i], shrink=0.2, location='top')#, label='Distance')\n", + " cbar.ax.tick_params(labelsize=10)\n", + " cbar.ax.spines['top'].set_visible(False)\n", + " cbar.ax.spines['right'].set_visible(False)\n", + " cbar.ax.spines['bottom'].set_visible(False)\n", + " cbar.ax.spines['left'].set_visible(False)\n", + " ax[i].set_title(title,y=1.8)\n", + " #loop through all of them and remove x and yticks, then add System as text label for each\n", + " for i in range(5):\n", + " ax[i].set_xticks([])\n", + " ax[i].set_yticks([])\n", + " # ax[i].text(0.5, -0.1, 'System', transform=ax[i].transAxes, ha='center', va='top')\n", + " ax[i].set_ylabel('System')\n", + " ax[i].set_xlabel('System')\n", + " ax[i].spines['top'].set_visible(False)\n", + " ax[i].spines['right'].set_visible(False)\n", + " ax[i].spines['bottom'].set_visible(False)\n", + " ax[i].spines['left'].set_visible(False)\n", + " plt.suptitle(name,y=1.1)\n", + " plt.tight_layout()\n", + " # plt.savefig(f'{folder_path}/{name}.eps', format='eps', dpi=300, bbox_inches='tight')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2b529073", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 523.63it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 110.19it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 474.72it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 133.29it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 594.62it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 95.83it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette Scores:\n", + "DMD State: 0.132\n", + "DMDc State: 0.143\n", + "DMDc Control: 0.002\n", + "SubspaceDMDc State: 0.669\n", + "SubspaceDMDc Control: 0.521\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the similarity matrices for each method\n", + "sims_full_dmd, sims_control_joint_dmd, sims_state_joint_dmd, sims_control_separate_dmd, sims_state_separate_dmd = compare_systems_full(A_dmd, A_dmd)\n", + "sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc = compare_systems_full(A_cs, B_cs)\n", + "sims_full_subdmdc, sims_control_joint_subdmdc, sims_state_joint_subdmdc, sims_control_separate_subdmdc, sims_state_separate_subdmdc = compare_systems_full(As_n4sid, Bs_n4sid)\n", + "\n", + "# Print silhouette scores\n", + "print(\"Silhouette Scores:\")\n", + "print(f\"DMD State: {np.round(silhouette_score(sims_state_separate_dmd, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"DMDc State: {np.round(silhouette_score(sims_state_separate_dmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"DMDc Control: {np.round(silhouette_score(sims_control_joint_dmdc, control_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc State: {np.round(silhouette_score(sims_state_separate_subdmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc Control: {np.round(silhouette_score(sims_control_joint_subdmdc, control_labels, metric='precomputed'), 3)}\")\n", + "\n", + "# Create 2x3 subplot\n", + "fig, axes = plt.subplots(2, 3, figsize=(6, 5))\n", + "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", + "\n", + "# Column headers (bold)\n", + "column_headers = ['DMD', 'DMDc', 'SubspaceDMDc']\n", + "for i, header in enumerate(column_headers):\n", + " axes[0, i].text(0.5, 1.75, header, transform=axes[0, i].transAxes, ha='center', va='bottom', fontweight='bold', fontsize=16)\n", + "\n", + "# Row headers\n", + "row_headers = ['State DSA', ['Not Available', 'Input DSA', 'Input DSA']]\n", + "for i in range(3):\n", + " axes[0, i].text(0.5, 1.55, 'State DSA', transform=axes[0, i].transAxes, ha='center', va='bottom', fontsize=12)\n", + "\n", + "axes[1, 0].text(0.5, 1.55, 'Not Available', transform=axes[1, 0].transAxes, ha='center', va='bottom', fontsize=12)\n", + "axes[1, 1].text(0.5, 1.55, 'Input DSA', transform=axes[1, 1].transAxes, ha='center', va='bottom', fontsize=12)\n", + "axes[1, 2].text(0.5, 1.55, 'Input DSA', transform=axes[1, 2].transAxes, ha='center', va='bottom', fontsize=12)\n", + "\n", + "# Data for each subplot\n", + "data_matrices = [\n", + " sims_state_separate_dmd, # top left\n", + " sims_state_separate_dmdc, # top middle \n", + " sims_state_separate_subdmdc, # top right\n", + " None, # bottom left (gray matrix)\n", + " sims_control_joint_dmdc, # bottom middle\n", + " sims_control_joint_subdmdc # bottom right\n", + "]\n", + "\n", + "# Create gray matrix for bottom left - use same size as other matrices\n", + "matrix_size = sims_state_separate_dmd.shape[0]\n", + "gray_matrix = np.ones((matrix_size, matrix_size)) * 0.5\n", + "\n", + "# Plot each subplot\n", + "for idx, (ax, data) in enumerate(zip(axes.flat, data_matrices)):\n", + " row = idx // 3\n", + " col = idx % 3\n", + " \n", + " if idx == 3: # Bottom left - gray matrix with diagonal lines\n", + " im = ax.imshow(gray_matrix, cmap='gray', vmin=0, vmax=1, extent=[-0.5, matrix_size-0.5, matrix_size-0.5, -0.5])\n", + " \n", + " # Add diagonal lines from bottom-left to top-right\n", + " for i in range(matrix_size):\n", + " for j in range(matrix_size):\n", + " ax.plot([j-0.5, j+0.5], [i-0.5, i+0.5], 'k--', linewidth=1)\n", + " \n", + " # Set axis limits to match other plots\n", + " ax.set_xlim(-0.5, matrix_size-0.5)\n", + " ax.set_ylim(matrix_size-0.5, -0.5)\n", + " \n", + " # Remove ticks and labels\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_xlabel('')\n", + " ax.set_ylabel('')\n", + " \n", + " # Remove spines\n", + " for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + " \n", + " else:\n", + " im = ax.imshow(data, cmap='viridis')\n", + " \n", + " # Add colorbar on top with only 2 ticks\n", + " cbar = plt.colorbar(im, ax=ax, shrink=0.4, location='top', pad=0.02)\n", + " vmin, vmax = data.min(), data.max()\n", + " cbar.set_ticks([vmin, vmax])\n", + " cbar.set_ticklabels([f'{vmin:.2g}', f'{vmax:.2g}'])\n", + " cbar.ax.tick_params(labelsize=10)\n", + " \n", + " # Remove colorbar spines\n", + " for spine in cbar.ax.spines.values():\n", + " spine.set_visible(False)\n", + " \n", + " # Set custom tick positions and labels (every 4 positions)\n", + " tick_positions = [1.5, 5.5, 9.5, 13.5] # Middle of each group of 4\n", + " tick_labels = ['1', '2', '3', '4']\n", + " \n", + " ax.set_xticks(tick_positions)\n", + " ax.set_xticklabels(tick_labels,fontsize=10)\n", + " ax.set_yticks(tick_positions)\n", + " ax.set_yticklabels(tick_labels,fontsize=10)\n", + " \n", + " # Set axis labels\n", + " ax.set_xlabel('System',fontsize=10)\n", + " ax.set_ylabel('System',fontsize=10)\n", + " \n", + " # Remove spines\n", + " for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2edb4f13", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 287.19it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 39.64it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 380.73it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 41.32it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette Scores:\n", + "DMDc Full (state): 0.028\n", + "SubspaceDMDc Full (state): 0.377\n", + "DMDc Full (control): -0.001\n", + "SubspaceDMDc Full (control): 0.435\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the similarity matrices for each method\n", + "sims_full_dmdc, _, _, _, _ = compare_systems_full(A_cs, B_cs)\n", + "sims_full_subdmdc, _, _, _, _ = compare_systems_full(As_n4sid, Bs_n4sid)\n", + "\n", + "# Print silhouette scores\n", + "print(\"Silhouette Scores:\")\n", + "print(f\"DMDc Full (state): {np.round(silhouette_score(sims_full_dmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc Full (state): {np.round(silhouette_score(sims_full_subdmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"DMDc Full (control): {np.round(silhouette_score(sims_full_dmdc, control_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc Full (control): {np.round(silhouette_score(sims_full_subdmdc, control_labels, metric='precomputed'), 3)}\")\n", + "\n", + "# Create 1x2 subplot\n", + "fig, axes = plt.subplots(1, 2, figsize=(6, 3))\n", + "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", + "\n", + "# Column headers (bold)\n", + "column_headers = ['DMDc', 'SubspaceDMDc']\n", + "for i, header in enumerate(column_headers):\n", + " axes[i].text(0.5, 1.55, header, transform=axes[i].transAxes, ha='center', va='bottom', fontweight='bold', fontsize=16)\n", + "\n", + "# Data for each subplot\n", + "data_matrices = [\n", + " sims_full_dmdc, # left\n", + " sims_full_subdmdc # right\n", + "]\n", + "\n", + "# Plot each subplot\n", + "for idx, (ax, data) in enumerate(zip(axes.flat, data_matrices)):\n", + " im = ax.imshow(data, cmap='viridis')\n", + " \n", + " # Add colorbar on top with only 2 ticks\n", + " cbar = plt.colorbar(im, ax=ax, shrink=0.4, location='top', pad=0.02,label='Joint DSA')\n", + " vmin, vmax = data.min(), data.max()\n", + " cbar.set_ticks([vmin, vmax])\n", + " cbar.set_ticklabels([f'{vmin:.2g}', f'{vmax:.2g}'])\n", + " cbar.ax.tick_params(labelsize=10)\n", + " \n", + " # Remove colorbar spines\n", + " for spine in cbar.ax.spines.values():\n", + " spine.set_visible(False)\n", + " \n", + " # Set custom tick positions and labels (every 4 positions)\n", + " tick_positions = [1.5, 5.5, 9.5, 13.5] # Middle of each group of 4\n", + " tick_labels = ['1', '2', '3', '4']\n", + " \n", + " ax.set_xticks(tick_positions)\n", + " ax.set_xticklabels(tick_labels, fontsize=10)\n", + " ax.set_yticks(tick_positions)\n", + " ax.set_yticklabels(tick_labels, fontsize=10)\n", + " \n", + " # Set axis labels\n", + " ax.set_xlabel('System', fontsize=10)\n", + " ax.set_ylabel('System', fontsize=10)\n", + " \n", + " # Remove spines\n", + " for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d85b184f", + "metadata": {}, + "outputs": [], + "source": [ + "#collect statistics now: \n", + "#sample random systems from the set of 4 pairings\n", + "#sample 4 input drives for each system, making 16 diferent systems in total \n", + "#compute silhouette score based on A labels and B labels\n", + "\n", + "def get_silhouette_scores(n,m,p_out,N,n_iters,\n", + " input_alpha=input_alpha,g1=g1,g2=g2,same_inp=False,n_Us=n_Us,\n", + " n_delays=n_delays,pf=pf,rank=rank,process_noise=process_noise,obs_noise=obs_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=lambda x: np.tanh(x),\n", + " y_feature_map = lambda x: x, u_feature_map = lambda x: x,backend=backend,\n", + " use_joint_control=True):\n", + "\n", + " silhouette_state_dmdc = []\n", + " silhouette_control_dmdc = []\n", + "\n", + " silhouette_state_subspace_dmdc = []\n", + " silhouette_control_subspace_dmdc = []\n", + "\n", + " silhouette_state_dsa = []\n", + " silhouette_control_dsa = []\n", + "\n", + "\n", + " for i in tqdm(range(n_iters)):\n", + " X_trues, Ys, Us, control_labels, state_labels, *_ = simulate_As_Bs(n,m,p_out,\n", + " N,input_alpha=input_alpha,g1=g1,g2=g2,same_inp=same_inp,n_Us=n_Us, seed1=seed1+i,seed2=seed2+110*i,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", + " Ys = list(map(y_feature_map, Ys))\n", + " Us = list(map(u_feature_map, Us))\n", + "\n", + " A_cs, B_cs = get_dmdcs(Ys,Us,n_delays=n_delays,rank=rank)\n", + " print('dmdc:', [i.shape for i in A_cs])\n", + " As, Bs, Cs, infos = get_subspace_dmdcs(Ys,Us,p=pf,rank=rank,backend=backend)\n", + " print('subspacedmdc:', [i.shape for i in As])\n", + " A_dmds = get_dmds(Ys,n_delays=n_delays,rank=rank)\n", + " print('dmd:', [i.shape for i in A_dmds])\n", + " sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc = compare_systems_full(A_cs,B_cs)\n", + " sims_full_subspace_dmdc, sims_control_joint_subspace_dmdc, sims_state_joint_subspace_dmdc, sims_control_separate_subspace_dmdc, sims_state_separate_subspace_dmdc = compare_systems_full(As,Bs)\n", + "\n", + " sims_state_dmd = compare_A_full(A_dmds)\n", + "\n", + " #compute silhouette scores\n", + " silhouette_state_dmdc.append(silhouette_score(sims_state_separate_dmdc,state_labels,metric='precomputed'))\n", + " if use_joint_control:\n", + " silhouette_control_dmdc.append(silhouette_score(sims_control_joint_dmdc,control_labels,metric='precomputed'))\n", + " silhouette_control_subspace_dmdc.append(silhouette_score(sims_control_joint_subspace_dmdc,control_labels,metric='precomputed'))\n", + " else:\n", + " silhouette_control_dmdc.append(silhouette_score(sims_control_separate_dmdc,control_labels,metric='precomputed'))\n", + " silhouette_control_subspace_dmdc.append(silhouette_score(sims_control_separate_subspace_dmdc,control_labels,metric='precomputed'))\n", + " \n", + " silhouette_state_subspace_dmdc.append(silhouette_score(sims_state_separate_subspace_dmdc,state_labels,metric='precomputed'))\n", + "\n", + " silhouette_state_dsa.append(silhouette_score(sims_state_dmd,state_labels,metric='precomputed'))\n", + " silhouette_control_dsa.append(silhouette_score(sims_state_dmd,control_labels,metric='precomputed'))\n", + "\n", + " print(silhouette_state_subspace_dmdc[-1],silhouette_state_dmdc[-1])\n", + " print(silhouette_control_subspace_dmdc[-1],silhouette_control_dmdc[-1])\n", + "\n", + " # print(silhouette_state_subspace_dmdc,silhouette_control_subspace_dmdc)\n", + " return silhouette_state_dmdc, silhouette_control_dmdc, silhouette_state_subspace_dmdc, silhouette_control_subspace_dmdc, silhouette_state_dsa, silhouette_control_dsa\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e32ce5f0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "methods = [ 'DMD','DMDC', 'Subspace DMDC']\n", + "state_means = [np.mean(silh_state_dsa),np.mean(silh_state_dmdc), np.mean(silh_state_subdmdc)]\n", + "state_stds = [np.std(silh_state_dsa) / np.sqrt(n_iters), np.std(silh_state_dmdc) / np.sqrt(n_iters), np.std(silh_state_subdmdc) / np.sqrt(n_iters)]\n", + "control_means = [np.mean(silh_ctrl_dsa),np.mean(silh_ctrl_dmdc), np.mean(silh_ctrl_subsdmdc)]\n", + "control_stds = [np.std(silh_ctrl_dsa) / np.sqrt(n_iters), np.std(silh_ctrl_dmdc) / np.sqrt(n_iters), np.std(silh_ctrl_subsdmdc) / np.sqrt(n_iters)]\n", + "\n", + "# Create bar plot\n", + "x = np.arange(len(methods))\n", + "width = 0.35\n", + "\n", + "fig, ax = plt.subplots(figsize=(6,4))\n", + "# Prepare data for violin plots\n", + "state_data = [silh_state_dsa, silh_state_dmdc, silh_state_subdmdc]\n", + "control_data = [silh_ctrl_dsa, silh_ctrl_dmdc, silh_ctrl_subsdmdc]\n", + "\n", + "# Option to create either violin plots or bar plots\n", + "plot_type = 'bar' # Change to 'bar' for bar plots\n", + "\n", + "if plot_type == 'violin':\n", + " # Create violin plots\n", + " violin_parts1 = ax.violinplot(state_data, positions=x - width/2, widths=width, showmeans=True, showmedians=False)\n", + " violin_parts2 = ax.violinplot(control_data, positions=x + width/2, widths=width, showmeans=True, showmedians=False)\n", + "\n", + " # Color the violin plots\n", + " for pc in violin_parts1['bodies']:\n", + " pc.set_facecolor(plt.cm.Paired(0))\n", + " pc.set_alpha(0.8)\n", + " \n", + " for pc in violin_parts2['bodies']:\n", + " pc.set_facecolor(plt.cm.Paired(1))\n", + " pc.set_alpha(0.8)\n", + "\n", + " # Set the color for violin lines (edges) as well\n", + " for key in ['cbars', 'cmins', 'cmaxes', 'cmedians', 'cmeans']:\n", + " if key in violin_parts2:\n", + " violin_parts2[key].set_color(plt.cm.Paired(1))\n", + " # Create legend manually\n", + " # ax.plot([], [], color=plt.cm.Paired(0), alpha=0.8, label='State')\n", + " # ax.plot([], [], color=plt.cm.Paired(1), alpha=0.8, label='Control')\n", + "\n", + "elif plot_type == 'bar':\n", + " # Create bar plots\n", + " ax.bar(x - width/2, state_means, width, yerr=state_stds, alpha=0.8,color=plt.cm.Paired(0))\n", + " ax.bar(x + width/2, control_means, width, yerr=control_stds, alpha=0.8,color=plt.cm.Paired(1))\n", + "\n", + "\n", + "ax.text(0.1, 0.8, 'State', color=plt.cm.Paired(0), fontsize=18, ha='center', va='center', transform=ax.transAxes)\n", + "ax.text(0.1, 0.7, 'Input', color=plt.cm.Paired(1), fontsize=18, ha='center', va='center', transform=ax.transAxes)\n", + "\n", + "\n", + "# Add labels and formatting\n", + "ax.set_xlabel('Method')\n", + "ax.set_ylabel('Silhouette Score')\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(methods)\n", + "# ax.legend(loc='upper left')\n", + "\n", + "plt.tight_layout()\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c085ce64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [00:50<15:50, 50.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999995829788267 0.9994804238352938\n", + "0.863046118997211 0.23133393565678578\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [01:38<14:41, 48.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999996460530998 0.5761319024802469\n", + "0.8701154730521196 0.24099690133052715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [02:26<13:48, 48.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999912817283558 0.9521479914270492\n", + "0.16003234487022538 0.16403266188793597\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [03:14<12:56, 48.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.999997826126348 0.9976338825933455\n", + "0.3814445884235741 0.2529392671562286\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [04:03<12:06, 48.46s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999679564451 0.9920394705518483\n", + "0.010578386107770881 0.04765377864976594\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [04:52<11:21, 48.69s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999889902481 0.9689650322969088\n", + "0.5630268469649073 0.3016799456824357\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [05:40<10:29, 48.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999998497630886 0.3183726653904416\n", + "0.9534753079734178 0.2617349582738815\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [06:28<09:39, 48.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999993846554156 0.8273921704738043\n", + "0.9949309508072234 0.21925306644298592\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [07:16<08:52, 48.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999392047036 0.9954893728664165\n", + "0.8926091704516487 0.1903970895833016\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [08:04<08:02, 48.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999896719519 0.995444964889423\n", + "0.9961439015917473 0.2041291174096036\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [08:52<07:14, 48.22s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999238686303 0.9972320906387236\n", + "0.9583486457958001 0.2825033975417309\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [09:41<06:25, 48.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999384251308399 0.3684689139358635\n", + "0.47414138222768587 0.0851508391625842\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [10:29<05:36, 48.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999348885965 0.7527879372104045\n", + "0.6306063443490444 0.2672479104166636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [11:16<04:48, 48.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999951190598705 0.3610613497907184\n", + "0.8961250841720869 0.2641135351952263\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [12:05<04:00, 48.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.999998341385793 0.6230706090075946\n", + "0.9248202840122726 0.17706479248767715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [12:53<03:12, 48.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999674326947 0.9994709308073931\n", + "-0.1067841427238009 -0.09112366530336576\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [13:41<02:24, 48.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.999999868783956 0.20194098857734308\n", + "0.7239155278059701 -0.0724678271629539\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [14:29<01:36, 48.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999997066328019 0.819120040107554\n", + "0.8702333799674973 0.05895311655939994\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [15:17<00:48, 48.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999998800189802 0.9349864382675056\n", + "0.5766529970474021 0.14812653792397995\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [16:06<00:00, 48.32s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999876386543 0.9989465989638291\n", + "-0.10880975421142923 -0.041194873224640466\n", + "0.7840091887055854 0.9999959305984649 0.8177832037795628\n", + "\n", + "4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [00:49<15:31, 49.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7148854335890451 0.3570867373101759\n", + "0.254784330813526 0.2564970447924318\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [01:37<14:32, 48.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9991213701183851 0.9338003716720993\n", + "0.373621258031336 0.192136675493342\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [02:25<13:41, 48.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6355829754026776 0.9872634331292893\n", + "0.1854906962368728 -0.03767345531702448\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [03:13<12:51, 48.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9995839406566759 0.9953287380325818\n", + "0.6123764433477282 0.08684510901067677\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [04:03<12:12, 48.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6963230455649736 0.845687225356722\n", + "0.4016672245447243 0.058871525818189774\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [05:09<12:48, 54.92s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9992640993428434 0.998645561471499\n", + "0.8038460988934154 0.2454871038684441\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [06:15<12:40, 58.47s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9987683545735093 0.0736808970230497\n", + "0.8285925196418789 0.2732293212884245\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [07:22<12:14, 61.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9915730805336032 0.994797192140245\n", + "0.5981192746869755 0.1964379017215781\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [08:27<11:25, 62.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.16730169440098075 -0.050823293824917536\n", + "0.856633281362433 0.7165541780129958\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [09:33<10:33, 63.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9955512573222484 0.4421153238515224\n", + "0.7824419645630796 0.27359514600465207\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [10:36<09:30, 63.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999171575551626 0.3104755396741338\n", + "0.4001872470668205 0.16345363658381468\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [11:40<08:27, 63.42s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9483586189931417 0.966822117653678\n", + "0.7168567181733992 0.12511920485220757\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [12:44<07:26, 63.78s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9561742831184827 0.9966754990231261\n", + "0.9029807911758108 0.2610828125429131\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [13:49<06:24, 64.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9990568101519974 0.7746559801011399\n", + "0.9337617390487356 0.3075022066959726\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [14:53<05:20, 64.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9998411060381232 0.2569602675253595\n", + "0.8390945275201664 0.22370357604102423\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [15:57<04:16, 64.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9997865367342857 0.241318053358768\n", + "0.6837142493572079 0.07254009908039336\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [16:59<03:10, 63.47s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8785750042711452 0.810468321924495\n", + "0.570785198489913 0.27891043801749216\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [18:04<02:07, 63.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9995900377560776 0.9195043770087221\n", + "0.9833055223571778 0.3036383897052762\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [19:01<01:01, 61.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2812199039990566 0.3239224658462285\n", + "0.6939734888761797 0.2935816367842393\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [20:04<00:00, 60.20s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9660441509081211 0.42782272440222124\n", + "0.8648016287642502 0.4537986269330362\n", + "0.630310376634007 0.8613259430515268 0.6772214951028864\n", + "\n", + "6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [00:57<18:09, 57.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6829675131066244 0.4223460413096838\n", + "0.8854467748170356 0.2616686133906402\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [01:55<17:18, 57.68s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4778190008236387 0.17609356285751082\n", + "0.6598414498361063 0.22278253995276884\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [02:53<16:23, 57.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5471160613933711 0.08871996231037635\n", + "0.4259459201932812 0.1866660821930045\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [03:50<15:19, 57.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8016038453841238 0.9988028414222979\n", + "0.8509811383108216 0.2604414799956156\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [04:48<14:27, 57.83s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7321304877045927 0.9301852495572647\n", + "0.8173496247672856 0.12185147255399653\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [05:48<13:37, 58.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6365979901030729 0.4041255920722771\n", + "0.7579932786817185 0.18545833884321933\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [06:45<12:36, 58.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9195536285180825 0.9806066331854593\n", + "0.7777951467327848 0.28973384255619494\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [07:41<11:28, 57.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.984003610143904 0.9995813967756805\n", + "0.8788713016811251 0.2749585482464467\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [08:39<10:33, 57.58s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5158567945640098 -0.07237010093454069\n", + "0.9126702269824578 0.49939973342165545\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [09:35<09:30, 57.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7923416282245809 0.2817045952973056\n", + "0.7779161159103634 0.24577059528112646\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [10:30<08:28, 56.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7312936187732099 0.9473852533471532\n", + "0.7597158791730374 0.18176727052706398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [11:24<07:25, 55.64s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6469929404560593 0.3729713725848219\n", + "0.40568443893046857 0.2157982900886147\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [12:17<06:24, 54.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7282137874227994 0.381613387917653\n", + "0.7096534869397652 0.32360433315080395\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [13:09<05:23, 53.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8932251993393823 0.9698401650825509\n", + "0.7012288905220221 0.240646029051426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [14:02<04:29, 53.85s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8119149687546602 0.2780525694562858\n", + "0.7676685570825138 0.24978632748796964\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [14:56<03:34, 53.63s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4208085507139975 0.19105960199501956\n", + "0.4335780142580806 0.16747429030574595\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [15:49<02:40, 53.50s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7648091158857311 0.8826299558795999\n", + "0.5728535489842801 0.15178372322416311\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [16:52<01:52, 56.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7153545536283132 0.8906240461622843\n", + "0.9652633954881787 0.2609344859351437\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [17:54<00:58, 58.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5778547187917267 0.44230974875355167\n", + "0.8466528891503173 0.07585444605775558\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [18:50<00:00, 56.52s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8191002897878881 0.368712975313898\n", + "0.8319921385680488 0.28762059488907493\n", + "0.5467497425173066 0.7099779151759884 0.5484566045827914\n", + "\n", + "8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [00:53<17:02, 53.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9248303386842245 0.7146369776756394\n", + "0.7451216619675085 0.23952590552851677\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [01:48<16:13, 54.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7832002042045016 0.3089931254863645\n", + "0.6649420392703927 0.11572462988981133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [02:41<15:13, 53.73s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6435735655396131 0.20445585902685298\n", + "0.872934293916127 0.2747311850562459\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [03:35<14:18, 53.68s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.706631097080003 0.9684960879289083\n", + "0.48356213906831524 0.20405758550928416\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [04:30<13:33, 54.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9661794181953494 0.32230796996366945\n", + "0.8934327360343968 0.35701384353475246\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [05:23<12:34, 53.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9553748648518876 0.39828794838648274\n", + "0.7830886629530971 0.22893819637325005\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [06:18<11:44, 54.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8147103362485131 0.0988428621121708\n", + "0.9470716284359546 0.3104522087632273\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [07:11<10:47, 53.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9767647013433851 0.7556305630672474\n", + "0.943084645089665 0.10792093436819339\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [08:05<09:54, 54.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8085664544760404 0.34372255960639364\n", + "0.9022105132439618 0.21804741703514957\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [08:58<08:56, 53.63s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7606182512852901 0.4256418262830215\n", + "0.8894219397963725 0.2948401293001088\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [09:52<08:03, 53.72s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6282569085372263 0.3089051839947159\n", + "0.8012605799820862 0.24923431995121953\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [10:46<07:09, 53.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9255080438194763 0.8188655274348823\n", + "0.7987398983988274 0.14982915606986894\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [11:39<06:15, 53.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.917964256305034 0.935502457207692\n", + "0.6930882697627829 0.22298600961410608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [12:32<05:20, 53.42s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6367458407978331 0.35127711063627737\n", + "0.5818592184667145 0.27120945643360456\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [13:26<04:28, 53.63s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8304468291687427 0.18779258604062105\n", + "0.6704730508807738 0.24147650357533848\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [14:18<03:32, 53.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9894151988315718 0.9953587181268179\n", + "0.24522148086447199 0.2299362315813862\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [15:10<02:38, 52.78s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6041337842499772 0.33126028917602063\n", + "0.9598960458391113 0.3595816525605222\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [16:02<01:45, 52.59s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9685427305295512 0.9324988048230214\n", + "0.4098858470516994 0.3098063660817312\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [16:57<00:53, 53.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8142915376417594 0.34116724781207\n", + "0.9629912195463708 0.16932229722168923\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [17:49<00:00, 53.50s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8214845853326898 0.23004491704025687\n", + "0.7719468109436691 0.25361105460709327\n", + "0.4986844310914563 0.8238619473561336 0.5526251265224809\n", + "\n", + "10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [00:53<16:48, 53.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7991433678090709 0.565793146732338\n", + "0.6580735402758165 0.2469688530509827\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [01:47<16:06, 53.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6407325038895381 0.40472342435440967\n", + "0.42905662200774763 0.06822521009658045\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [02:40<15:09, 53.52s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8461176454032904 0.3138150886305985\n", + "0.6417382914134774 0.3695419197033751\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [03:34<14:19, 53.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5371381446176151 0.3640210948047854\n", + "0.47543343188655235 0.3412147377093789\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [04:29<13:30, 54.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4817741069115222 0.3312604718736136\n", + "0.921089351917504 0.28936051553243025\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [05:23<12:37, 54.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9687073854918788 0.9991191759574398\n", + "0.9241084179945119 0.12928319716867753\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [06:23<12:07, 55.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4295218657374844 0.11410334626856197\n", + "0.894517240546653 0.2000469265578521\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [07:21<11:22, 56.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.33677496103480126 -0.08890655024206669\n", + "0.8852859753982001 0.32121996122835905\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [08:18<10:25, 56.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8001191065128971 0.8390420933339114\n", + "0.8682404172168996 0.31176429277749024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [09:13<09:23, 56.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6306414649718846 0.760817453744526\n", + "0.7830045461575633 0.25697639413796286\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [10:09<08:26, 56.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9700886369661625 0.3402876141906415\n", + "0.479714946691821 0.21419923744792801\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [11:07<07:32, 56.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7112346911590584 0.8115064155105561\n", + "0.892931950721412 0.15764011379775023\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [12:03<06:36, 56.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7012834016157923 0.14910716991895367\n", + "0.8036564778741786 0.2426703326352978\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [13:02<05:43, 57.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7875423195769864 0.7459283517299533\n", + "0.6840405260414184 0.12612654890845015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [14:02<04:49, 57.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5680739236743386 0.6798750591982248\n", + "0.7685265107130248 0.21111568535663267\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [14:56<03:47, 56.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8969783486575266 0.8201654338199273\n", + "0.6419161613136062 0.3102890006181207\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [15:50<02:48, 56.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2102115990246819 0.681500023791654\n", + "0.9457387099496892 0.27367950454988077\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [16:48<01:53, 56.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7230200609338846 0.4987655547588908\n", + "0.8993263982985391 0.32930054005012344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [17:43<00:56, 56.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4811909979021496 0.34295258004093626\n", + "0.984001565270018 0.17301095039273662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [18:41<00:00, 56.09s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9145787220471548 0.47275372687986705\n", + "0.9310953047402001 0.22434178009172623\n", + "0.5073315337648862 0.6717436626968859 0.5167306060806733\n", + "\n", + "20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [00:57<18:21, 57.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9892640331231699 0.8594591384334251\n", + "0.8254778135215022 0.214267756737885\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [01:56<17:26, 58.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9512447101134738 0.4068049229052108\n", + "0.736197252981335 0.1987269496108924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [02:53<16:23, 57.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8785697149599488 0.6235207265603029\n", + "0.6158978028372307 0.24119758793689644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [03:50<15:18, 57.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7442104757416566 0.2526657447637686\n", + "0.7914724527675518 0.3287430462844653\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [04:49<14:28, 57.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8749731165405094 0.38901877685785274\n", + "0.9143839901122117 0.3008742080828827\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [05:46<13:29, 57.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7524401849433755 0.5273911397333929\n", + "0.8560878537175243 0.27101413652478457\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [06:49<12:52, 59.46s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.18044896982307718 0.14029720452084493\n", + "0.8081506503339186 0.19824224783168232\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [07:50<11:56, 59.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9770507781642589 0.7183770834927682\n", + "0.26385329595023455 0.115051332187116\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [08:49<10:54, 59.51s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5358649236504333 0.6741896151072617\n", + "0.8652764268463012 0.2600824214341021\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [09:50<09:59, 59.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7370445733058059 0.21205111557687406\n", + "0.9575139770925202 0.5804208804017441\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [10:49<08:58, 59.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7010619836064139 0.8787181635255477\n", + "0.39316111137823206 0.22912150415632226\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [11:46<07:50, 58.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.511356583372921 0.9090642506020197\n", + "0.8585437451244906 0.3032818384153309\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [12:41<06:44, 57.78s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8422170048715416 0.4655938834297251\n", + "0.9246601826856204 0.25795015987507086\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [13:37<05:42, 57.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5393678866134317 0.16183292650561076\n", + "0.6668216456383955 0.19683088749074412\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [14:36<04:48, 57.69s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9385038404707957 0.7075567029351021\n", + "0.7926214453281066 0.2651271505385519\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [15:33<03:50, 57.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9396540889153789 0.71283293556484\n", + "0.955523845385363 0.28787200438430793\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [16:29<02:51, 57.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7483994134243397 0.9725720264591999\n", + "0.7723355923572701 0.23929991033336254\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [17:25<01:53, 56.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.963901587135688 0.725603976138003\n", + "0.874380533643646 0.39667421074578557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [18:20<00:56, 56.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8335779478889345 0.429612405947956\n", + "0.6335114677482351 0.32923557189268776\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [19:16<00:00, 57.80s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7048793856690092 0.5371596636189394\n", + "0.9764039741453683 0.2923650669525318\n", + "0.5652161201339324 0.7672015601167083 0.5580053587875079\n", + "\n", + "50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [01:12<22:54, 72.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2860380003458474 0.3105522329810055\n", + "0.8752166267181785 0.5155899527565754\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [02:26<22:03, 73.51s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5898848214821798 0.45556156918402146\n", + "0.6069604392366142 0.2936238949125084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [03:37<20:29, 72.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7320529918600682 0.8521377298136814\n", + "0.9029918902655901 0.2876787842363736\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [04:47<19:04, 71.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.539977020978684 0.4945501601133633\n", + "0.6153494078059176 0.24901310001351387\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [06:00<17:56, 71.78s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21960990625785626 0.18522784750233728\n", + "0.5309055215391791 0.4288068204167372\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [07:11<16:42, 71.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6459410466940635 0.011299983501322868\n", + "0.9483473503631741 0.4318358565300766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [08:22<15:28, 71.45s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.42576715973064605 0.31801706152072473\n", + "0.7561012171300019 0.34173896506185514\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [09:34<14:18, 71.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8848059959184817 0.688873283915466\n", + "0.8467319580550701 0.2723758348586194\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [10:47<13:12, 72.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6394936234771974 0.27199690137762766\n", + "0.9632065247896976 0.3683824099393246\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [11:58<11:57, 71.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8243466273351014 0.39518703428173496\n", + "0.9016127395936266 0.5168346307232419\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [13:10<10:45, 71.73s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.666926006575496 0.6990843787631436\n", + "0.6746058253840981 0.4336576557230802\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [14:22<09:35, 71.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8956944324512491 0.23953877668101403\n", + "0.8504315319655691 0.4273766175223321\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [15:33<08:20, 71.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6499095153580638 0.2245850900849572\n", + "0.8056497448834813 0.24283914573402143\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [16:45<07:10, 71.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.887792229639151 0.6347844805856808\n", + "0.8796551535411032 0.36216678946757896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [17:59<06:01, 72.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5086444268624157 0.0936516339750865\n", + "0.7878271994226096 0.42504508357141196\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [19:14<04:52, 73.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.11948895738930862 0.31070889043209277\n", + "0.5937901505822004 0.382057515121027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [20:27<03:39, 73.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.49807007753376553 0.5953937744140247\n", + "0.5051521673419727 0.3233819925076515\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [21:41<02:26, 73.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3383236736143306 0.6032253506345908\n", + "0.7233016813318316 0.37123212471933364\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [22:51<01:12, 72.35s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7190588170171746 0.7969780119901608\n", + "0.8585962210786311 0.2878671355020555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [24:00<00:00, 72.01s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.34565097190956035 0.10234097838994428\n", + "0.8181598910705421 0.4034857434846065\n", + "0.4141847585070991 0.5708738151215321 0.41546844901558033\n", + "\n", + "100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [02:29<47:28, 149.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8446268725815469 0.7256464342912119\n", + "0.8273507722373987 0.5603376456698084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [05:01<45:16, 150.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5457822603798255 0.21750971297207908\n", + "0.8546880341433041 0.35635946004801594\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [07:33<42:57, 151.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6715401504742341 0.33921036794768644\n", + "0.7607462917806747 0.40100202095421456\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [10:08<40:44, 152.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5267314701678696 0.6466412902454441\n", + "0.9278811439470444 0.425815857095872\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [12:46<38:40, 154.72s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4643429036975759 0.190965385996421\n", + "0.9294583058441246 0.6218037387658151\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [15:20<36:01, 154.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.709206644599262 0.33229187867188287\n", + "0.6681369604804535 0.5088500240453075\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [17:55<33:29, 154.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2314738406844464 0.06774352764780177\n", + "0.916137156986661 0.4823204525486465\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [20:27<30:46, 153.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4078497168933002 0.5483546343845598\n", + "0.9390646310432331 0.5249700522658651\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [23:10<28:43, 156.65s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8576657585702796 0.27128668076026385\n", + "0.8870119230779476 0.5507856621345018\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [25:41<25:48, 154.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7253773211988085 0.2804275006355139\n", + "0.9014721499938876 0.5419448466702601\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [28:00<22:29, 149.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.33641812436974 0.35422686708680384\n", + "0.877598941516769 0.49945679860528824\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [30:34<20:10, 151.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8753192957665168 0.280436722323244\n", + "0.87155131343598 0.4605904753540729\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [33:14<17:58, 154.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0788372675369562 0.356938915948146\n", + "0.9434898139880066 0.5660042178199005\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [35:51<15:28, 154.83s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.13548756460266684 0.3020333447007765\n", + "0.8355524739767075 0.4803127179691466\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [38:28<12:56, 155.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.15113425915118855 -0.012416282573434669\n", + "0.9499796252950421 0.4505210752534833\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [41:04<10:22, 155.73s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7603783923118979 0.3960604328259445\n", + "0.5260696835489838 0.2634785255655468\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [43:23<07:31, 150.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6931923903264781 0.5476441672681036\n", + "0.5774190372196778 0.37382427961108844\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [45:51<04:59, 149.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8499123123044735 0.5544635520573259\n", + "0.869813808721149 0.4762205555314316\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [48:09<02:26, 146.25s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5867010922012843 0.10158268344160948\n", + "0.9031706778944122 0.6281068800498706\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [50:38<00:00, 151.92s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4224749726743423 0.24078994145418864\n", + "0.9225045347541461 0.49925414194469775\n", + "0.3370918879042787 0.5437226305246348 0.38753305360921275\n", + "\n", + "200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [02:38<50:05, 158.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5909926793101823 0.5267353297787027\n", + "0.793287839335513 0.42577658486413167\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [05:17<47:44, 159.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6247010938533479 0.2711818540152699\n", + "0.944896066035209 0.5541491013249726\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [07:53<44:35, 157.38s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.40754480344278765 0.12368201193512694\n", + "0.7442620102045194 0.48312609484057234\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [10:36<42:35, 159.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5789496801447473 0.26461895585748385\n", + "0.7904986694139292 0.5211463345792007\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [13:21<40:23, 161.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.658181489951501 0.4111157930411643\n", + "0.8767443415128332 0.41738304427727346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [15:46<36:24, 156.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5890209837764785 0.31261881183448553\n", + "0.7431785673340168 0.43313114828135746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [18:22<33:48, 156.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.25878407195050107 0.248673711901176\n", + "0.960555865133256 0.602995612582953\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [20:56<31:03, 155.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1831344683291642 0.7502605606731848\n", + "0.7419020251917682 0.44774711485528707\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [23:39<28:55, 157.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6156212189531662 0.30370286626147514\n", + "0.8113055539834164 0.5869938172389021\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [26:22<26:32, 159.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.25602000113544043 0.20566905280002584\n", + "0.8723014637982822 0.40689361063820395\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [29:03<23:58, 159.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.08782627932844758 0.21599346406778525\n", + "0.9338566334595068 0.7108388099126532\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [31:25<20:35, 154.38s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7509720423118675 0.31559635433883176\n", + "0.8671199750284003 0.5852102479633505\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [33:59<18:00, 154.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.23497824333432582 0.20581158461935417\n", + "0.8292549170886632 0.4671277111079004\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [36:30<15:19, 153.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21076681207816744 0.05435857097436688\n", + "0.8983166829817066 0.6088961437819176\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [38:59<12:39, 151.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.43216414491713195 0.2700225343287927\n", + "0.9219818012435689 0.5448139659231047\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [41:39<10:17, 154.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.35107496005046335 0.17495664975537167\n", + "0.8019340960503707 0.4185433604322402\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [43:57<07:28, 149.65s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7667975097980471 0.41876674952603615\n", + "0.4005731630535587 0.3527487793499603\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [46:30<05:01, 150.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.48806800421228 0.7464100466923176\n", + "0.9245962301647113 0.5186315236551856\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [48:51<02:27, 147.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.23529197058614706 0.2865792918700654\n", + "0.8240179717146053 0.47096734519534117\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [51:25<00:00, 154.26s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5023233858774772 0.3795988310852768\n", + "0.9255917812733652 0.6415014495916215\n", + "0.3243176512678147 0.4411606921670835 0.32947940422530647\n", + "\n", + "500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [02:52<54:44, 172.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.22043632221253617 0.1553981097516287\n", + "0.9015436071811085 0.5472704301810019\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [05:46<51:59, 173.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6025273736285195 0.19152691356660215\n", + "0.8385417110841888 0.4769818571042821\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [08:31<48:00, 169.45s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5742814715509301 0.34682026258812115\n", + "0.9061019555563466 0.5823313202283038\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [11:23<45:28, 170.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.26261340789480214 0.2719860300390877\n", + "0.9001388681520854 0.5518161850508868\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [14:10<42:21, 169.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21261855977293215 0.6854052550690519\n", + "0.7678151017058328 0.28790413421616146\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [17:01<39:35, 169.69s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1527939370789289 0.25347613159299026\n", + "0.7390842568896852 0.42379904680922015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [19:44<36:17, 167.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2861601938983629 0.3523174081703131\n", + "0.8983865080718274 0.4778147328195415\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [22:25<33:07, 165.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1473331275960964 0.2616190097172466\n", + "0.8477978341974416 0.3867557529999165\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [25:15<30:35, 166.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8111390724509978 0.37228173553201405\n", + "0.8776929228510219 0.4795653764782277\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [28:05<27:59, 167.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4085765746438009 0.34948545998649555\n", + "0.8007255529314821 0.3891526031748061\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [30:40<24:34, 163.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.13740835750248043 0.20976463111068544\n", + "0.9424595808849461 0.6339189675854268\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [33:37<22:22, 167.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5112216206695892 0.23838856619317703\n", + "0.7904138275111404 0.4297397739791532\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [36:22<19:28, 166.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0990374510279309 0.19216912255339327\n", + "0.9358155844669447 0.5563190397561102\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [39:10<16:45, 167.52s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6601977913749432 0.27982790995797213\n", + "0.8684212521301466 0.5335795085482751\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [41:40<13:30, 162.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5956458226808542 0.24524113278914392\n", + "0.7972147740858228 0.4332194784851243\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [44:25<10:52, 163.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5122700595630902 0.488491597606007\n", + "0.8265298610883107 0.5350677727259068\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [47:18<08:17, 165.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7476222074587422 0.6771672929832568\n", + "0.8479695857330589 0.4960150918510703\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [50:06<05:33, 166.51s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5302998066361749 0.2871918771799252\n", + "0.8765691515631118 0.47461433287297644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [52:54<02:47, 167.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.15639471147498035 0.44150693921106593\n", + "0.8473852661332886 0.6010330942129157\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [55:32<00:00, 166.64s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8169119290035589 0.3552092297921594\n", + "0.8893471350212314 0.44209055341031084\n", + "0.33276373076951693 0.4222744899060126 0.33110059858440477\n", + "\n", + "1000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|▌ | 1/20 [03:20<1:03:20, 200.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.21599824061235723 0.2122759472603924\n", + "0.7939899099574769 0.47536600422017516\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 10%|█ | 2/20 [06:50<1:01:46, 205.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1772414590625133 0.1638066071548832\n", + "0.7768398756044337 0.5351219512328911\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 15%|█▌ | 3/20 [10:20<58:53, 207.86s/it] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.20305987719615948 0.31641285252240126\n", + "0.8275996865695451 0.4554359223321068\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 4/20 [13:51<55:47, 209.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4365103362894593 0.21617428873080619\n", + "0.9339548743077184 0.5467185377035322\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|██▌ | 5/20 [17:14<51:43, 206.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5446757682556929 0.37759894045670706\n", + "0.9053551309392543 0.5450234643659914\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 30%|███ | 6/20 [20:44<48:33, 208.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3956405273624292 0.7379086544620574\n", + "0.9555669816927188 0.5676020992068349\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 35%|███▌ | 7/20 [24:13<45:08, 208.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6897428707916682 0.5966675741110706\n", + "0.893383950275017 0.6036722976049932\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 8/20 [27:53<42:24, 212.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.402043882408865 0.2152717511761012\n", + "0.8068825670591858 0.5761876966524075\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 45%|████▌ | 9/20 [31:27<38:58, 212.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1932406826463367 0.691683731087698\n", + "0.840336073582292 0.4572776129603895\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 10/20 [34:48<34:50, 209.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6452371929978948 0.6364881125494939\n", + "0.8706150369494879 0.49482891283103936\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████▌ | 11/20 [38:15<31:15, 208.38s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6798123405096732 0.29606565488857894\n", + "0.33811609109222995 0.22316664135652803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 12/20 [41:53<28:11, 211.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6521372440734303 0.500413621081764\n", + "0.783705095460566 0.39231804266732906\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 65%|██████▌ | 13/20 [45:22<24:33, 210.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6152243737606016 0.18487729125383087\n", + "0.9151161076602892 0.5136816998547024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 70%|███████ | 14/20 [48:48<20:54, 209.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5863428471516422 0.26471775040865647\n", + "0.9251590994184722 0.5257523396494801\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|███████▌ | 15/20 [52:19<17:29, 209.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.25925966794872307 0.42358410823229564\n", + "0.90824545757701 0.5961194479231974\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 16/20 [55:54<14:05, 211.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.18580617952186845 0.44905640372446726\n", + "0.7375453310329729 0.41519043266013644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 85%|████████▌ | 17/20 [59:32<10:39, 213.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.35446445789725217 0.33174072035690144\n", + "0.7717447035468411 0.39792695627207353\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 90%|█████████ | 18/20 [1:03:00<07:03, 211.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4703759666641165 0.738175762691752\n", + "0.9178287956011302 0.5468846777749655\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 95%|█████████▌| 19/20 [1:06:36<03:33, 213.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2850865276468535 0.29375256722749515\n", + "0.8114035929558596 0.5211518240095194\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [1:10:08<00:00, 210.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1226260966699091 0.4394821713598579\n", + "0.748719768120352 0.34339422686100335\n", + "0.40430772553686045 0.4057263269733723 0.4372786707655439\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "#sweep partial observation fraction and compute silhouette scores\n", + "\n", + "n_iters = 20\n", + "\n", + "\n", + "silh_state_dmdcs = []\n", + "silh_ctrl_dmdcs = []\n", + "silh_state_subdmdcs = []\n", + "silh_ctrl_subsdmdcs = []\n", + "silh_state_dsas = []\n", + "silh_ctrl_dsas = []\n", + "\n", + "# p_outs = [1] #+ np.arange(2,22,2).tolist()\n", + "p_out = 2\n", + "n_uses = [2, 4, 6, 8, 10, 20, 50, 100, 200, 500,1000] #[::-1]\n", + "for n_use in n_uses:\n", + " print(n_use)\n", + " ss_dmdc, sc_dmdc, ss_subdmdc, sc_subdmdc, ss_dsa, sc_dsa = get_silhouette_scores(n_use,m,p_out,\n", + " 5*N_small,n_iters,input_alpha=input_alpha,g1=g1,\n", + " g2=g2,same_inp=False,n_Us=n_Us,n_delays=n_delays,rank=min(n_use,100),pf=pf,\n", + " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps)\n", + " silh_state_dmdcs.append(ss_dmdc)\n", + " silh_ctrl_dmdcs.append(sc_dmdc)\n", + " silh_state_subdmdcs.append(ss_subdmdc)\n", + " silh_ctrl_subsdmdcs.append(sc_subdmdc)\n", + " silh_state_dsas.append(ss_dsa)\n", + " silh_ctrl_dsas.append(sc_dsa)\n", + "\n", + " print(np.mean(ss_dmdc),np.mean(ss_subdmdc),np.mean(ss_dsa))\n", + " print()\n", + "\n", + "\n", + "silh_state_dmdcs = np.array(silh_state_dmdcs)\n", + "silh_state_subdmdcs = np.array(silh_state_subdmdcs)\n", + "silh_state_dsas = np.array(silh_state_dsas)\n", + "silh_ctrl_dmdcs = np.array(silh_ctrl_dmdcs)\n", + "silh_ctrl_subdmdcs = np.array(silh_ctrl_subsdmdcs)\n", + "silh_ctrl_dsas = np.array(silh_ctrl_dsas)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2662682c", + "metadata": {}, + "outputs": [], + "source": [ + "#for efficiency (if you desire)\n", + "# silh_state_dmdcs = np.array(silh_state_dmdcs)\n", + "# silh_state_subdmdcs = np.array(silh_state_subdmdcs)\n", + "# silh_state_dsas = np.array(silh_state_dsas)\n", + "# silh_ctrl_dmdcs = np.array(silh_ctrl_dmdcs)\n", + "# silh_ctrl_subdmdcs = np.array(silh_ctrl_subsdmdcs)\n", + "# silh_ctrl_dsas = np.array(silh_ctrl_dsas)\n", + "\n", + "# # Save data\n", + "# np.savez(f'silhouette_data_n_use.npz',\n", + "# silh_state_dmdcs=silh_state_dmdcs,\n", + "# silh_state_subdmdcs=silh_state_subdmdcs,\n", + "# silh_state_dsas=silh_state_dsas,\n", + "# silh_ctrl_dmdcs=silh_ctrl_dmdcs,\n", + "# silh_ctrl_subdmdcs=silh_ctrl_subdmdcs,\n", + "# silh_ctrl_dsas=silh_ctrl_dsas,\n", + "# n_uses=n_uses)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6a705b2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "methods = ['DMD','DMDc','Subspace DMDc']\n", + "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", + "p_frac = np.array(n_uses[:len(silh_state_dmdcs)])\n", + "\n", + "fig, ax = plt.subplots(2, 1, figsize=(5,4),sharex=True)\n", + "\n", + "# Plot state silhouette scores\n", + "\n", + "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", + " ax[0].plot(p_frac, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", + " ax[0].fill_between(p_frac, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", + " ax[1].plot(p_frac, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", + " ax[1].fill_between(p_frac, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "ax[0].set_xscale('log')\n", + "ax[1].set_xscale('log')\n", + "ax[0].set_ylim(-0.05,1.05)\n", + "ax[1].set_ylim(-0.05,1.05)\n", + "# Create custom legend with colored text\n", + "from matplotlib.lines import Line2D\n", + "ax[0].text(0.5, 0.5, 'DMD', color=plt.cm.Set2(0), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "ax[0].text(0.5, 0.4, 'DMDc', color=plt.cm.Set2(1), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "ax[0].text(0.5, 0.3, 'SubspaceDMDc', color=plt.cm.Set2(2), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "\n", + "# Add subplot titles\n", + "ax[0].set_title('State', fontsize=16, pad=10)\n", + "ax[1].set_title('Input', fontsize=16, pad=3)\n", + "ax[1].set_xlabel('Number of States')\n", + "fig.text(-0.05, 0.5, 'Silhouette Score', va='center', rotation='vertical',fontsize=16)\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5f1c041a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/2 [00:02 11\u001b[0m silh_state_dmdc, silh_ctrl_dmdc, silh_state_subdmdc, silh_ctrl_subsdmdc, silh_state_dsa, silh_ctrl_dsa \u001b[38;5;241m=\u001b[39m \u001b[43mget_silhouette_scores\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp_out_small\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mN_small\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_iters\u001b[49m\u001b[43m,\u001b[49m\u001b[43minput_alpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_alpha\u001b[49m\u001b[43m,\u001b[49m\u001b[43mg1\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mg1\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mg2\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mg2\u001b[49m\u001b[43m,\u001b[49m\u001b[43msame_inp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43mn_Us\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_Us\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_delays\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\u001b[43mrank\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mr\u001b[49m\u001b[43m,\u001b[49m\u001b[43mpf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[43m \u001b[49m\u001b[43mobs_noise\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mobs_noise\u001b[49m\u001b[43m,\u001b[49m\u001b[43mprocess_noise\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprocess_noise\u001b[49m\u001b[43m,\u001b[49m\u001b[43mnonlinear_eps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnonlinear_eps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 15\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m silh_state_dmdcs\u001b[38;5;241m.\u001b[39mappend(silh_state_dmdc)\n\u001b[1;32m 17\u001b[0m silh_ctrl_dmdcs\u001b[38;5;241m.\u001b[39mappend(silh_ctrl_dmdc)\n", + "Cell \u001b[0;32mIn[32], line 32\u001b[0m, in \u001b[0;36mget_silhouette_scores\u001b[0;34m(n, m, p_out, N, n_iters, input_alpha, g1, g2, same_inp, n_Us, n_delays, pf, rank, process_noise, obs_noise, nonlinear_eps, nonlinear_func, y_feature_map, u_feature_map, backend, use_joint_control)\u001b[0m\n\u001b[1;32m 29\u001b[0m Us \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mmap\u001b[39m(u_feature_map, Us))\n\u001b[1;32m 31\u001b[0m A_cs, B_cs \u001b[38;5;241m=\u001b[39m get_dmdcs(Ys,Us,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[0;32m---> 32\u001b[0m As, Bs, Cs, infos \u001b[38;5;241m=\u001b[39m \u001b[43mget_subspace_dmdcs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mYs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mUs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrank\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m A_dmds \u001b[38;5;241m=\u001b[39m get_dmds(Ys,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[1;32m 35\u001b[0m sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc \u001b[38;5;241m=\u001b[39m compare_systems_full(A_cs,B_cs)\n", + "\u001b[0;31mTypeError\u001b[0m: get_subspace_dmdcs() got an unexpected keyword argument 'f'" + ] + } + ], + "source": [ + "rs = np.arange(2,25,1)\n", + "n_iters = 2\n", + "silh_state_dmdcs = []\n", + "silh_ctrl_dmdcs = []\n", + "silh_state_subdmdcs = []\n", + "silh_ctrl_subsdmdcs = []\n", + "silh_state_dsas = []\n", + "silh_ctrl_dsas = []\n", + "\n", + "for r in rs:\n", + " silh_state_dmdc, silh_ctrl_dmdc, silh_state_subdmdc, silh_ctrl_subsdmdc, silh_state_dsa, silh_ctrl_dsa = get_silhouette_scores(n,m,p_out_small,\n", + " N_small,n_iters,input_alpha=input_alpha,g1=g1,\n", + " g2=g2,same_inp=False,n_Us=n_Us,n_delays=n_delays,rank=r,pf=pf,\n", + " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps,\n", + " backend=backend)\n", + " silh_state_dmdcs.append(silh_state_dmdc)\n", + " silh_ctrl_dmdcs.append(silh_ctrl_dmdc)\n", + " silh_state_subdmdcs.append(silh_state_subdmdc)\n", + " silh_ctrl_subsdmdcs.append(silh_ctrl_subsdmdc)\n", + " silh_state_dsas.append(silh_state_dsa)\n", + " silh_ctrl_dsas.append(silh_ctrl_dsa)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a65665b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "methods = ['DMD','DMDc','Subspace DMDc']\n", + "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(8,3),sharex=True)\n", + "\n", + "# Plot state silhouette scores\n", + "\n", + "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", + " ax[0].plot(rs, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", + " ax[0].fill_between(rs, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", + " ax[1].plot(rs, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", + " ax[1].fill_between(rs, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "# ax[0].set_xscale('log')\n", + "# ax[1].set_xscale('log')\n", + "ax[0].set_ylim(-0.05,1.05)\n", + "ax[1].set_ylim(-0.05,1.05)\n", + "# Create custom legend with colored text\n", + "from matplotlib.lines import Line2D\n", + "ax[0].text(1.4, 0.8, 'SubspaceDMDc', color=plt.cm.Set2(2), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "ax[0].text(1.4, 0.65, 'DMDc', color=plt.cm.Set2(1), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "ax[0].text(1.4, 0.5, 'DMD', color=plt.cm.Set2(0), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "\n", + "# Add subplot titles\n", + "ax[0].set_title('State', fontsize=16, pad=10)\n", + "ax[1].set_title('Input', fontsize=16, pad=3)\n", + "ax[1].set_xlabel('Rank of DMD')\n", + "fig.text(-0.05, 0.5, 'Silhouette Score', va='center', rotation='vertical',fontsize=16)\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1ac349b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/2 [00:15 27\u001b[0m ss_dmdc, sc_dmdc, ss_subdmdc, sc_subdmdc, ss_dsa, sc_dsa \u001b[38;5;241m=\u001b[39m \u001b[43mget_silhouette_scores\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp_out\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[43m \u001b[49m\u001b[43mN\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_iters\u001b[49m\u001b[43m,\u001b[49m\u001b[43mrng\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43minput_alpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.001\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mg1\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[43m \u001b[49m\u001b[43mg2\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43msame_inp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43mn_Us\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_Us\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_delays\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\u001b[43mrank\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mpf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[43m \u001b[49m\u001b[43mnonlinear_eps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnonlinear_eps\u001b[49m\u001b[43m,\u001b[49m\u001b[43mnonlinear_func\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtanh\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 31\u001b[0m \u001b[43m \u001b[49m\u001b[43my_feature_map\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mY_feature_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu_feature_map\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mU_feature_map\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 32\u001b[0m silh_state_dmdcs\u001b[38;5;241m.\u001b[39mappend(ss_dmdc)\n\u001b[1;32m 33\u001b[0m silh_ctrl_dmdcs\u001b[38;5;241m.\u001b[39mappend(sc_dmdc)\n", + "Cell \u001b[0;32mIn[198], line 40\u001b[0m, in \u001b[0;36mget_silhouette_scores\u001b[0;34m(n, m, p_out, N, n_iters, rng, input_alpha, g1, g2, same_inp, n_Us, n_delays, pf, rank, process_noise, obs_noise, nonlinear_eps, nonlinear_func, y_feature_map, u_feature_map)\u001b[0m\n\u001b[1;32m 37\u001b[0m Us \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mmap\u001b[39m(u_feature_map, Us))\n\u001b[1;32m 39\u001b[0m A_cs, B_cs \u001b[38;5;241m=\u001b[39m get_dmdcs(Ys,Us,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[0;32m---> 40\u001b[0m As, Bs, Cs, infos \u001b[38;5;241m=\u001b[39m \u001b[43mget_subspace_dmdcs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mYs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mUs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrank\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mn4sid\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 41\u001b[0m A_dmds \u001b[38;5;241m=\u001b[39m get_dmds(Ys,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[1;32m 43\u001b[0m _, _, _, sims_control_separate_dmdc, sims_state_separate_dmdc \u001b[38;5;241m=\u001b[39m compare_systems_full(A_cs,B_cs)\n", + "Cell \u001b[0;32mIn[186], line 36\u001b[0m, in \u001b[0;36mget_subspace_dmdcs\u001b[0;34m(Ys, Us, p, f, n_id, backend)\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;66;03m# N4SID identification\u001b[39;00m\n\u001b[1;32m 29\u001b[0m nfoursid \u001b[38;5;241m=\u001b[39m NFourSID(\n\u001b[1;32m 30\u001b[0m df,\n\u001b[1;32m 31\u001b[0m output_columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(Y\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m])],\n\u001b[1;32m 32\u001b[0m input_columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mu\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(U\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m])],\n\u001b[1;32m 33\u001b[0m num_block_rows\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mmin\u001b[39m(p, f)\n\u001b[1;32m 34\u001b[0m )\n\u001b[0;32m---> 36\u001b[0m \u001b[43mnfoursid\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubspace_identification\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;66;03m# Determine rank - use n_id if provided, otherwise auto-determine\u001b[39;00m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_id \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/Desktop/Projects/AgentDSA/AgentDSA/n4sid/nfoursid/src/nfoursid/nfoursid.py:90\u001b[0m, in \u001b[0;36mNFourSID.subspace_identification\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 87\u001b[0m y_past, y_future \u001b[38;5;241m=\u001b[39m y_hankel[:, :\u001b[38;5;241m-\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows], y_hankel[:, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows:]\n\u001b[1;32m 88\u001b[0m u_instrumental_y \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mconcatenate([u_future, u_past, y_past, y_future])\n\u001b[0;32m---> 90\u001b[0m q, r \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m matrix: matrix\u001b[38;5;241m.\u001b[39mT, \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinalg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqr\u001b[49m\u001b[43m(\u001b[49m\u001b[43mu_instrumental_y\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mreduced\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 92\u001b[0m y_rows, u_rows \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39my_dim \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mu_dim \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows\n\u001b[1;32m 93\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mR32 \u001b[38;5;241m=\u001b[39m r[\u001b[38;5;241m-\u001b[39my_rows:, u_rows:\u001b[38;5;241m-\u001b[39my_rows]\n", + "File \u001b[0;32m~/opt/anaconda3/envs/iblenv/lib/python3.10/site-packages/numpy/linalg/linalg.py:952\u001b[0m, in \u001b[0;36mqr\u001b[0;34m(a, mode)\u001b[0m\n\u001b[1;32m 950\u001b[0m signature \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mD->D\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m isComplexType(t) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124md->d\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 951\u001b[0m extobj \u001b[38;5;241m=\u001b[39m get_linalg_error_extobj(_raise_linalgerror_qr)\n\u001b[0;32m--> 952\u001b[0m tau \u001b[38;5;241m=\u001b[39m \u001b[43mgufunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msignature\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msignature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextobj\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 954\u001b[0m \u001b[38;5;66;03m# handle modes that don't return q\u001b[39;00m\n\u001b[1;32m 955\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/Users/mitchellostrow/opt/anaconda3/envs/iblenv/lib/python3.10/site-packages/numpy/linalg/linalg.py\u001b[0m(952)\u001b[0;36mqr\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 950 \u001b[0;31m \u001b[0msignature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'D->D'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misComplexType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'd->d'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 951 \u001b[0;31m \u001b[0mextobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_linalg_error_extobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_raise_linalgerror_qr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m--> 952 \u001b[0;31m \u001b[0mtau\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgufunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mextobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 953 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 954 \u001b[0;31m \u001b[0;31m# handle modes that don't return q\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] + } + ], + "source": [ + "#varying eps and observing changes\n", + "\n", + "nonlinear_eps_range = np.arange(0.1,1.1,0.1)\n", + "n_iters_local = 2 # override for this analysis\n", + "\n", + "Y_feature_map = lambda x: x #np.concatenate([x,x**3,x**5],axis=0)\n", + "U_feature_map = lambda x: x\n", + "\n", + "silh_state_dmdcs = []\n", + "silh_ctrl_dmdcs = []\n", + "silh_state_subdmdcs = []\n", + "silh_ctrl_subsdmdcs = []\n", + "silh_state_dsas = []\n", + "silh_ctrl_dsas = []\n", + "\n", + "for i, nonlinear_eps in enumerate(nonlinear_eps_range):\n", + " print(nonlinear_eps)\n", + " ss_dmdc, sc_dmdc, ss_subdmdc, sc_subdmdc, ss_dsa, sc_dsa = get_silhouette_scores(n,m,p_out,\n", + " N,n_iters_local,input_alpha=input_alpha,g1=g1,\n", + " g2=g2,same_inp=False,n_Us=n_Us,n_delays=n_delays,rank=20,pf=200,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x),\n", + " y_feature_map = Y_feature_map, u_feature_map = U_feature_map)\n", + " silh_state_dmdcs.append(ss_dmdc)\n", + " silh_ctrl_dmdcs.append(sc_dmdc)\n", + " silh_state_subdmdcs.append(ss_subdmdc)\n", + " silh_ctrl_subsdmdcs.append(sc_subdmdc)\n", + " silh_state_dsas.append(ss_dsa)\n", + " silh_ctrl_dsas.append(sc_dsa)\n", + "\n", + " print(np.mean(silh_state_dmdcs),np.mean(silh_state_subdmdcs),np.mean(silh_state_dsas))\n", + " print()\n", + "\n", + "\n", + "silh_state_dmdcs = np.array(silh_state_dmdcs)\n", + "silh_state_subdmdcs = np.array(silh_state_subdmdcs)\n", + "silh_state_dsas = np.array(silh_state_dsas)\n", + "silh_ctrl_dmdcs = np.array(silh_ctrl_dmdcs)\n", + "silh_ctrl_subdmdcs = np.array(silh_ctrl_subsdmdcs)\n", + "silh_ctrl_dsas = np.array(silh_ctrl_dsas)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7b0352b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/opt/anaconda3/envs/iblenv/lib/python3.10/site-packages/IPython/core/pylabtools.py:170: UserWarning: Tight layout not applied. The bottom and top margins cannot be made large enough to accommodate all axes decorations.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", + "methods = [ 'DMD','DMDC', 'Subspace DMDC']\n", + "\n", + "non_eps = nonlinear_eps_range[:len(silh_state_dmdcs)]\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", + "\n", + "# Plot state silhouette scores\n", + "\n", + "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", + " ax.plot(non_eps, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", + " ax.fill_between(non_eps, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", + " ax.plot(non_eps, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", + " ax.fill_between(non_eps, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "\n", + "ax.legend(loc='lower right',bbox_to_anchor=(1.5, 1))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "jaxenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 839143a29538c42c8f4b0c11f2418569f884dd3b Mon Sep 17 00:00:00 2001 From: Ann Huang Date: Mon, 3 Nov 2025 11:11:48 -0500 Subject: [PATCH 27/51] fixed prediction function & delay issue --- DSA/__pycache__/__init__.cpython-39.pyc | Bin 0 -> 846 bytes DSA/__pycache__/base_dmd.cpython-39.pyc | Bin 0 -> 8329 bytes DSA/__pycache__/dmd.cpython-39.pyc | Bin 0 -> 18690 bytes DSA/__pycache__/dmdc.cpython-39.pyc | Bin 0 -> 15331 bytes DSA/__pycache__/dsa.cpython-39.pyc | Bin 0 -> 26920 bytes DSA/__pycache__/preprocessing.cpython-39.pyc | Bin 0 -> 10398 bytes DSA/__pycache__/resdmd.cpython-39.pyc | Bin 0 -> 5768 bytes DSA/__pycache__/simdist.cpython-39.pyc | Bin 0 -> 12712 bytes .../simdist_controllability.cpython-39.pyc | Bin 0 -> 6329 bytes DSA/__pycache__/stats.cpython-39.pyc | Bin 0 -> 14707 bytes DSA/__pycache__/subspace_dmdc.cpython-39.pyc | Bin 0 -> 17995 bytes DSA/__pycache__/sweeps.cpython-39.pyc | Bin 0 -> 12913 bytes DSA/dmdc.py | 6 +- .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 682 bytes .../__pycache__/koopman.cpython-39.pyc | Bin 0 -> 19495 bytes .../koopman_continuous.cpython-39.pyc | Bin 0 -> 6336 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 390 bytes .../__pycache__/_base_analyzer.cpython-39.pyc | Bin 0 -> 3340 bytes .../__pycache__/_ms_pd21.cpython-39.pyc | Bin 0 -> 12954 bytes .../_pruned_koopman.cpython-39.pyc | Bin 0 -> 5478 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 482 bytes .../__pycache__/validation.cpython-39.pyc | Bin 0 -> 2548 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 338 bytes .../__pycache__/_derivative.cpython-39.pyc | Bin 0 -> 2980 bytes .../_finite_difference.cpython-39.pyc | Bin 0 -> 762 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 582 bytes .../__pycache__/_base.cpython-39.pyc | Bin 0 -> 12894 bytes .../_custom_observables.cpython-39.pyc | Bin 0 -> 9876 bytes .../__pycache__/_identity.cpython-39.pyc | Bin 0 -> 3250 bytes .../__pycache__/_polynomial.cpython-39.pyc | Bin 0 -> 10395 bytes .../_radial_basis_functions.cpython-39.pyc | Bin 0 -> 10514 bytes .../_random_fourier_features.cpython-39.pyc | Bin 0 -> 6841 bytes .../__pycache__/_time_delay.cpython-39.pyc | Bin 0 -> 7618 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 616 bytes .../__pycache__/_base.cpython-39.pyc | Bin 0 -> 5446 bytes .../__pycache__/_base_ensemble.cpython-39.pyc | Bin 0 -> 13641 bytes .../__pycache__/_dmd.cpython-39.pyc | Bin 0 -> 12168 bytes .../__pycache__/_dmdc.cpython-39.pyc | Bin 0 -> 14310 bytes .../__pycache__/_edmd.cpython-39.pyc | Bin 0 -> 8341 bytes .../__pycache__/_edmdc.cpython-39.pyc | Bin 0 -> 7728 bytes .../__pycache__/_havok.cpython-39.pyc | Bin 0 -> 10095 bytes .../__pycache__/_kdmd.cpython-39.pyc | Bin 0 -> 15216 bytes .../__pycache__/_nndmd.cpython-39.pyc | Bin 0 -> 43155 bytes DSA/subspace_dmdc.py | 91 +++++--- examples/all_dsa_types.ipynb | 217 ++++++++++++++---- 45 files changed, 238 insertions(+), 76 deletions(-) create mode 100644 DSA/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/__pycache__/base_dmd.cpython-39.pyc create mode 100644 DSA/__pycache__/dmd.cpython-39.pyc create mode 100644 DSA/__pycache__/dmdc.cpython-39.pyc create mode 100644 DSA/__pycache__/dsa.cpython-39.pyc create mode 100644 DSA/__pycache__/preprocessing.cpython-39.pyc create mode 100644 DSA/__pycache__/resdmd.cpython-39.pyc create mode 100644 DSA/__pycache__/simdist.cpython-39.pyc create mode 100644 DSA/__pycache__/simdist_controllability.cpython-39.pyc create mode 100644 DSA/__pycache__/stats.cpython-39.pyc create mode 100644 DSA/__pycache__/subspace_dmdc.cpython-39.pyc create mode 100644 DSA/__pycache__/sweeps.cpython-39.pyc create mode 100644 DSA/pykoopman/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/pykoopman/__pycache__/koopman.cpython-39.pyc create mode 100644 DSA/pykoopman/__pycache__/koopman_continuous.cpython-39.pyc create mode 100644 DSA/pykoopman/analytics/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/pykoopman/analytics/__pycache__/_base_analyzer.cpython-39.pyc create mode 100644 DSA/pykoopman/analytics/__pycache__/_ms_pd21.cpython-39.pyc create mode 100644 DSA/pykoopman/analytics/__pycache__/_pruned_koopman.cpython-39.pyc create mode 100644 DSA/pykoopman/common/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/pykoopman/common/__pycache__/validation.cpython-39.pyc create mode 100644 DSA/pykoopman/differentiation/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/pykoopman/differentiation/__pycache__/_derivative.cpython-39.pyc create mode 100644 DSA/pykoopman/differentiation/__pycache__/_finite_difference.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_base.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_custom_observables.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_identity.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_polynomial.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_radial_basis_functions.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_random_fourier_features.cpython-39.pyc create mode 100644 DSA/pykoopman/observables/__pycache__/_time_delay.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/__init__.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_base.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_base_ensemble.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_dmd.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_dmdc.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_edmd.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_edmdc.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_havok.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_kdmd.cpython-39.pyc create mode 100644 DSA/pykoopman/regression/__pycache__/_nndmd.cpython-39.pyc diff --git a/DSA/__pycache__/__init__.cpython-39.pyc b/DSA/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..951b9747a7023ebe1ff6aba5df18b772b0791e24 GIT binary patch literal 846 zcma)4&5qMB5RRLq`Dxnima@ADxFMth+t^rMU~B}jF%2ws0f#hH5sg$#W9#$42f4_#wl60tp^3#~IaM<{vpA4P zYEI`Chw@l0=)&Si-cw7uv^bXcudrtKD=rhohwUZ{_U}7irdpBFZ?w`M@t5(-i zvTGqlyITt-B-4PdG^@;})+!UGg{+O(_OrLV;+jeEiI>O@-&IZ5B6|E!VoLgX#y6~! zZFZUMi=}SAXm;=Gx>2n9i?%Fi0;NU8Tw()PAj`SGD*DmfrV28^Ll!pnRlS4At zr+=9WLQns1amXakKBN!&0Jc0Y4b%AYw!QWc`6%p20iZsDN%m9g5F-%^{FR0Rs?-y( zXlTo+vd{^d$7q^i^Sng=6iE~77pjCe&@;?@c;Ly4KOavYAt$mKEo%*pE&RxNWA-f? z%^O`8+!#@9_hHQq^t*HP36QP${$y3HZfeCZE>`TOW7T#Ab?letq7rSMpEtWce4*;H Xll&zCqB#Tch$Li5<{*FGkl_6R*x=^2 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/base_dmd.cpython-39.pyc b/DSA/__pycache__/base_dmd.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6124923bcb3dc6800554d7a81ed444d00e842978 GIT binary patch literal 8329 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/dmd.cpython-39.pyc b/DSA/__pycache__/dmd.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2be194bed064633e1acbfb5e00ce8abe9bcbb09e GIT binary patch literal 18690 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 BX}tgd literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/dmdc.cpython-39.pyc b/DSA/__pycache__/dmdc.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9533bd2f75f1e39a42a2698d3771a31d046a2b4b GIT binary patch literal 15331 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/dsa.cpython-39.pyc b/DSA/__pycache__/dsa.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2842a34905ae7eef57477a9b7ffe08fbb0d964d GIT binary patch literal 26920 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/resdmd.cpython-39.pyc b/DSA/__pycache__/resdmd.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..739410ca5d8a8a488e27839efcada6d350d730c5 GIT binary patch literal 5768 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/simdist.cpython-39.pyc b/DSA/__pycache__/simdist.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a17978e8c78cec264e3208a4079d262387141786 GIT binary patch literal 12712 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/stats.cpython-39.pyc b/DSA/__pycache__/stats.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..08967db9ccf0c2fd6403600d2a0846b410fbd394 GIT binary patch literal 14707 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/subspace_dmdc.cpython-39.pyc b/DSA/__pycache__/subspace_dmdc.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c4763aa8c1936cd2dfb70d438c2db6c5f42a047 GIT binary patch literal 17995 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 literal 0 HcmV?d00001 diff --git a/DSA/__pycache__/sweeps.cpython-39.pyc b/DSA/__pycache__/sweeps.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be6992b3b06e7a111aa0472e55d93fe8c92af800 GIT binary patch literal 12913 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 1: if self.is_list_data: V_split = torch.split(V, self.H_row_counts, dim=0) diff --git a/DSA/pykoopman/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0f7d10241b80f2651a3e55b4f200fb3e34cfab8 GIT binary patch literal 682 zcmZ{hyN=W_6o&02JGo~rY{?5uvzZ4#2*ij6X`3w&ZjL--Pd039M^3U*X!lJhkmz`x zv{d^FR2*kUXd7(#=sOqt_py1NCj>|PE38M4kl)UEIU;o45kk8k2!aUO5JefKj=jcH zKJ#bxkpmV`@~x18yn3Qv7cBft^d=zEANQ2F`Gsh2M?@g5nn=Yg#+`v!G>J-CI&;`$ zDrfo35puzbnPcQ7Th5#yuh?ql6nV|olvG4y-znRO{ElpkXV<}&PAS*g^t`W)?$Ev7 z*IjSx!{7q9rvGRLEik^SWDnv+?wOwVho6jT71vm^zTgL=`&tiXa0f1qMk(XcOHrRr z(n?Iuau`a@p_BHJ9~$Xu6Dun#yAGw%i@D~_*w@Ey8`=e`+0YsH+BSB^{fbSU$dT h;}pG7MhuO7>t4HijVALlnt2{AXhs)~eO%}1{RJpTt7`xN literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/__pycache__/koopman.cpython-39.pyc b/DSA/pykoopman/__pycache__/koopman.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e90f78f96d4be1277e46d326c22bb6fe022fea1 GIT binary patch literal 19495 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/analytics/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/analytics/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ab5adcfe56b69f3367abd069369628976a26b8a GIT binary patch literal 390 zcmYjMJx{|h5Ve!0NlOX?zak51J26yt+$0{x4xWq2Fa>z+yWVgB;~!5h;l+6aJ(~v! z$v|3Y*>VxYjl5_f3}%}Jj$^<(H{cjV^078 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/analytics/__pycache__/_base_analyzer.cpython-39.pyc b/DSA/pykoopman/analytics/__pycache__/_base_analyzer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1a6539a9da43facb3ab6c475f5c47e23b885280 GIT binary patch literal 3340 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/analytics/__pycache__/_pruned_koopman.cpython-39.pyc b/DSA/pykoopman/analytics/__pycache__/_pruned_koopman.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65135340eee983210a5b595302963a235ae111cf GIT binary patch literal 5478 zcmcIo%X8dF8P{tb9*@VGs6kZ~QGBb>%|-0tzn6?`ui(^2Di7K~vNE)aw5F*WbIv7Zw@@ zuIO(y?_bvq;~(@ee%W~V+%U}e0SIAq3}Fh(H~Ut{GKsc*yW`;Q_?3ROQ`LPHzt*pJ z>Zb7vLsUiWl_6>`t+mmR}h!%}xXKinylfdC=Fz2bykz zUKKYqy#V^AxTWbu&}-thrk6n95g%%L8T5C=N19#{cOe#*Ej)oNq$qaC|6VZ+-NTZe zWQX1}8L&`!hhD(_p}6+7y!IJS*na$6%EgRPf> z++y1S^MW|xL07WyfbB=8$GI}v<-HgSuEc<@v9;KG5VZrrmExzZEw(Ft*@Zg5Q+Qn& zUMR*y4i{WMf#!bhC3@%N z*3ewOvz#YO6a+)QE_lM(J{hUDB{Y$eFqWLflbp^4IJPv|IC(-KPe9}r!uwI-8I$Z{ zZ~esWhCUE|L1G8;oZo~(Mq3AKUNF+zoI=+dvAcI~Crp^vk9^se0qp$Vz0o#OwZ*O+ zu>F?z58m?r;TC(M!bqy*w9S4ilT^Xd_JQb^BS2p$6{<1W?#-G*f*dznZ6MV779$yI zj5If9Ff1O^)JP!OZ{D=NnDQUQp5f{<9VYie9cbRfa~1=}V`%q>kC>i00!Oau1!&EM!_)MY~BhKNh#T&R8ZR+QR=KW#RiE2G+oEje&{Q z6z0J8h(h0yd4%M4?5Ix?=Z{Et=&c9?$;IBuERiS^b6Zta!!28!3_qDeh_mYf+$Km= z=(`7!!@gwfX4hvJSY~azEhlpz@B>u^L(NsyL49MWCEWh=v&~?$7xv}-`QarNBlfZyl%Yd<{`r^b53-c)m>yWFLB*_U>7&h7*^G)nhm>YI@Z~ZiG0~E z2X{$S2s6B+8AiDp8a!Xz{``h4s(T*Aw1<7nfzvym50`|F}#LdCv1xaX+JtG zlk4ye@pw8BOsSGmlIkFeujI#NjQ`ze*&<#H*%V6-pGlQib3&@am)dszU5d55x8^fD zioMKynpr`VRedT>4zr3MC-GOAwdZCIdAXXy1oToC&8@GRdtA#=i}cDo>8zBl>uTSR zdR|tA^`(BIttoGoX|Rob{scs<>(<3ZbJ1!#%syM0K;FivOQt~PpuOlb5HJJOug8|U zF)+{JN5X;;kfPy9=QiFt7v{3@g8Zs7ut3>K^}IH)sh@m`--JJv*=jugy){#fbn-q- zVRtO_QsSbDONGxjo_nzzt@JkSpXj`LmB~%4Gdmd%&E++Pn%CdrYSl9bm0&-sL7P2} z+;tnT6iyn3`T$L4?x|I}J4$lDFbMS_dODRu!jx4sv}r4-6*a?eFtV_OhS@Z)Sq<}S zb&l#@gJ6KbW{KTMUBF%r1=OOuiz6lv|8ZRVy?RHh=t0R;z4 z*5l74PCh+vpW!gU!oWYpW9;pJV=7|PvUH$QpMsu(i3r&9evkfGCm!n(#GcnBZzwOK zuY`E_Du}7tSL@&aTogH{u~@141G-Bn%ae|fs&_;3h^A9U(ei-vMmU2ax@gU9#1Zex zHrov$L8{yi+S?=H>E}G)6I?|pd>X8|{gSY1?OK*;eS5YviFfz<oFW_GjO7?4`1$1=<43Cc-X#9nQ+8U{ zsMZefsmOJ+hD#qL@O=(+({;Z}xnI1gxvmJiuB%oE(?`^NLXFPlEl^oKDo&^B`}E=m z)ND}GriLsjSApKykLZz33S$jfs-l9OwjI;_y6N0qUZ~%$uj1!eDE{%U6n~=2KG1q* ztD%03d9;s%luj@JOdgX}bTyq98>={qw1>x#@KuZi3M literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/common/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/common/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f60137089be86dda8f3b4f7309ba050654ecb63a GIT binary patch literal 482 zcmZ8dJx{|h5ViBIwyC=CBeIYR!B!!VIwF>CUQQ-<+bI4Bc9JUm95yxveoa=U{sktS z2qDB-etP$GXTLj|rZeQCeviu!jL_$p{0+|~cL-s-afBg;1(KLxjF`uK;YpwP6Av5@ zNHFox@sNZV9T1CNF^O2bLs@bj-_7tar%LIDHle2%s4=v6B`Gty21OMZ zeX>qic2ty%HXKS-w@tP(fonA32$2I4Fk>ybpsb^+;2=uHsR7&DhD)++v}rA{UQt;V zmPA4uu3kvou^O~3h;OQEk{I3ra}rrSOzl_O-;UG@eF8~Uxz~b`Kncr<-#u{>7S9L4 z2d}b^Sv<@D_HEM|4q(RB4YMEPZrFd8hZukg0q};*e4Jy1ubW)uM=kk!ozr7W)gj;R r?x$P#mDaVhkQZ7?t#WX?C>wywx*w8_)T|Z!cHE~;94x#AcE|e$_Y#K_ literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/common/__pycache__/validation.cpython-39.pyc b/DSA/pykoopman/common/__pycache__/validation.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..311f5df999b16a344ca7e8ce4a2d6f3ee2ed9b85 GIT binary patch literal 2548 zcmZ`)&2Jk;6rb5$f5c7Fs`M)rpasFfRqIqB0jjD(p{L6trAjO~rrv+m3| zi6iGiiU0{JkT@VtE#lG(;=~d0XP~`uArc29Zd}UmjqNxEb*$Ze^ZY)3^S(wbEL0d) z|EE&&-66()r_I3?V)F)L++G7AndB+!@ioqg4$@#P#5YW%USX}snJVqFwX!O=xQt}s zE?=9IMOnJb)(WyL=kTq_V3k!Xd*q?Y^Fu=G%n6rd+TNgjv!j~bx-dozn*j+;7NIEO zd5e%d%NcWQ#2jA_b^{xGI`mW|`7ZyM>$j&ov*HS_IAXitUtzaS>;$efVxwS*jreXr z)J1mZl@VKoz4fvTx`FA8*!?*f%HTn;!(4@QcOdN!4ft2woE~w>2F!fnA{lvK_Z+`p z9`OfU7NGqrJaab>G(UQ3VHZ5;6uR8}0-d7QS@ZvS{IGcx2!Rg>7G+_Hbp!hcBugX- z+lR@c3_tOhWgr<*UG@NI>}klAy~Xkr51pktcVqkPR@@s{7vEN~kLS5G>8kkMl~}}S z0)Eyyz~4hi+1?|p?dRM~FSbpQ3KM7MfNaf>@b=M}TtBmkOE%Q@3)huyyAIiQvF&7o zRK`8wnw@y7W;>#+8xtsMXSFc@u|N6~5Oti}jtuzz(c#%95X<7|)zLj&A^W-5jr=axDtIK-1ll9d3 z^UI<$fWzf0tC#)LA9k~>-xGSdne}>^UYRL zm!k?V^Gfi%e=qW*_{P|m1FzYn=ucM!qJ-xi>We=?ICdX(^njahP)&j4sK|BjLgJzJ zBXA26_2awYwVjZ9V-zm2^-_x`sN5g;JuYWlbn=vYjGaWcj6(Fw*%7*!H2<%){vVB1 zrf=>e`R$2Fo}M9@d7OCrdFpNU&nl)5syw=}N9ptRI0SKE{q=fv&QN6X`NSd%{Zwsb zx7W=gu`1ijWVTKXVKDQUd5XA)Z8xnS7(jW15=`?b>4|nVGRH}#*xeMSZSx|^XOKE` zlC-HB#;+x!2vQY~J%bmcNzkSZbW|hm2pc!*x?j^mH)5sHmCDvC-pYHzh@NuFSie2Dzx)>J z@r76qdi`N-(w?4A{x8#1ho8(&KnSB^A8#c+1bCY{BMn-Y^>7TinQ12yO(Ow<76S=p z{E?t-vR>Tq;2W{fGN!{JQG*`9kAae{zOWX)HWJ~5+qTiDd3a|isQ|tqOd@WlD#qZT zIW{%1KQW(hGAS|tGA+m{4vB~opm9iDHi7AnG4@Abt_s9^-@#;9b_6oyIx4mZGR5(> z!t`y8BS2YcP=bKk!(LHtVDw{&m}Y@MT!`HObx-*0XmZsSzrD;+)`vu^IeW<5#H&ouZ_am`|EF_o=`<2h1DEX3eI58(@b3}B;d#vWdTF+=U2 zFFa=PO|UGTk{v(F4GsM2p}bPBw+2X^s@Dx2G%xu4jQuQN3@KrBZQzpB`l(=^A)zAX smufn51RH-7cykA)kDo&xL-}GalY>-UqLA8oyyk;4pAU-Rd|Y1o7guYdvj6}9 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/differentiation/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/differentiation/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f30cf1995ee178433546d00e0379099e34f94dc4 GIT binary patch literal 338 zcmYjMOKQU~5S8R#>Nrq(3vVhPAcPi7m)&Hi%^)f{5z)uUb|5Dz-Ss@)c9ko1Rmr8F zfq8l}ym^}8n@x#A^zVgw4ev)R{s#%g144Lc0ue}HjSOZOBSA!>iAh+p@KmQJV_D#t z$Pa|&qS&K)b&Xy%p4Z%3H}X+AJ6!R1uWY4P=g>RLptyZfR*kY%T_?S?FVd$$=Cc6L zbupI!-84>K0{FPoyaw?*zDU^}bc+RuKaV&*7XVyqfH&lCqGyE99kul6jBFapj}x~C s+U_5h>@O$hdc!UKF&fpfIR%Ix0NnSNd9^i8Oj_>ZHA5btA{DO47t`NYj{pDw literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/differentiation/__pycache__/_derivative.cpython-39.pyc b/DSA/pykoopman/differentiation/__pycache__/_derivative.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..489e8936c4a0684c00fe5e68ed81968c99a6cc9c GIT binary patch literal 2980 zcmcgu&u`l{6c%OKmK7)M+O1emBhX=}hR*JFMo_F>iXI9SMH6g*FES(2v1&=wNGgc~ z_p$`&Y5N;GV3z_r?7!ImpzBUOZ>OF19_83h+M(NJ48-s^-}~PCKALTA1`d?s*LLzp z$8mng&U*2n^OfTey$22M3>{9mo07~Ox&+&ew2^s3&$hj^nYD&3+is@q%pdyDZt-^7 z$%0`(oJS7#dFRaG9pRrgh8sNCb;6C4U%pkWD1@SM%Cr`mj-{eJ8IOe$xk;EwWKJ_- zCX&OPk{LA454A}$ zW~6%K*4wtgj)XHKq9iX$6XR*?1@VSL^fuJO84|$UP;|8zG8xdtywX2mSskxIHBphgA@B z-AiO&71!sr0=Z7_q*Vq{}fCJjy)Cy zfW@&W4BJlyoz@uXo}G+|rAS>Nt?+w{oIxp@lerUtQUL?V6C~vH2%y!WTX|ZfV+A7T zymr(E{QK*EKkrXKB<|krvq=fO?eFZ~w_h=vN?Bwq?_bKHezb~iub5SS1Vm0u6nzE< zYP7^5C)anD#Os~Uzh!j;mRhSnhQ^#|e-1X!o#)OgGABO~0&Vo+q-F*Ne^&sdK>3Pg z_E9;85#Spzq1Ks2tZ?}=VM>+P5ySo>NiBxhM>v+9(6z`^t+GIMf-Zttwd`Hm!c|vY z91gTFQ9TtxU;9uwzUO*w*FE`Y&HL55z1V_-3!$L%i;w8r&@s;G!tocbaRG*g@lIX! z>D+zQ#GVDjwSZiC1URfP=!LDSsY`f2s^DO0Ruv>V$+cm5ENag@q@mh^yTV58oX3SI z)D;+cO{xx19iN{lTKTE2!Q7Yd)eeGlU2@66)r|_%GG6F6G#wD)`uqC){WO@Jpyofg zFNlGbaZO|Ff}7hg>P{W?x$$`8lzdN2b55SOxO>w%g>@e~07@J8j$Q7}8wuq2bN^@Z zBLP5~>`%CP8OWzX0edo<0|!+C>h;!3x<8{RYDs=jQ`c(B=#s)=f;`1MTZ$ZxT+}%n zIUdlw=;fR##X#QlgcX9`&LhzIA{F`$&7-kkkcdKuOB-?H4l`^ab?X!pyhoqOBMm3X zGUYUu3bqz9w^F!VdEux+Ca9b6Y6A)2se!ezOv@~{TDsgr&kb4QhjUNMvO+sqtV(O@8jWd#N~VKco&SIZp7HMI|&WVN^S7rU|^t5@D~xF zU>RU2%4rTy48*AN*m0u6j%q`8s_Rfy4S=s|j#J4@6?}uglO8GsxMThTwJ@X#$!d8N zdNp~-u|nZeH?cxBUC{=ma6ag|Tf~RIYwjg^tXGC)FC^BNu!H+^cweKa z3Zf{JyiBp(jiT>LmM&)65x^D$TQ~9Ut5_jh)hAF@n+r0>0w3=+^KRf0G)SRjA@%K} z;S=wM-|(+)b?o?)u&Zvt99};zF?rz-l&>mSslSD!Y68!SSq)WJPgB8E-rI*?eyWM< kTd~YCnb% zV+$y` z?--VK?{N>3q-@~w2isA$kffC>~(gveKVbI zciXmIqim+1XZvbWnaOgZBoFn%Y`WbTOUY#^W5Vqxe)#?TU-p|rSHX)o7{`46D)4ZR zd;E!8a0{vvbz!?PzIIAi#`-jHJY~dhBl=0m>{vV#DO6occ}m&;h|FEIAQ$nB=PP0W zs~RKaxRSDI^-y!1NcnY8_58&#wmW0TYdmsH!SVCrE%zM6xC*99x@5p|@Pi{j$155m sJ2c(SB^)RHZEcjZn=kZ&9PeZL?Ff9DHH&;T6MN0Cq30bXBE}^614qND$p8QV literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3736b70de496ba45d757df35f93e0f102b434e50 GIT binary patch literal 582 zcmYk3J5Izf5QgpSBd=W$LI|#~4WUK|@mQ@y0|=xJ(X9ONThI*mCDqzA zv=K(T56=~58>g*njJjAlZlCB)zb^NKR>PN)-Z(dxU9 z<;PoBR5PO%rnQ3G1*c7GV^V%26rXcRyV=+d{YpCuG7gdk$%5ow&S&d=0kCSrRR9~l z5!r;hhzI76FUIsah#$t7*q2cMa>jVF4K}jEGQj%aZ(0}kk{y2FU8KzPDG=hnDL5YJPnj-@1D=rdCu}|IjM{p+y6* YTX%hSpbTpzKMa4ug}6yF!M{)P1&lzQwg3PC literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_base.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f38a1a29ecc6e8794f638f8039b45ab03550305 GIT binary patch literal 12894 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 w11Hjf9)NQrj3ikhk)+_5GP^8MpF literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_custom_observables.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_custom_observables.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2211bba18c13a6d111c4dc38d582ec7ec37e66f GIT binary patch literal 9876 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 XW|>X1iJ+&B6A@LaocXcQsaO93)yl!Y literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_identity.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_identity.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98a67135214f1c47d11d7c3e7a86c15606e135e0 GIT binary patch literal 3250 zcmb_fO>f*p7@o2BE6ye%1xic#80D0e7AIUdgs38=rBp%z(TKxJ$epZbvrhcgnQ@w3 zZ7(EJ&z!4DEw|qIJ-))FXKq}|``T--cN4?~Cw9i;nR&mS=a~s#S+NLQ@$XGeqsQLjKF6j}Mx`s~!qi0ZTo4(nr!QYx+4;sA&^wr&l-way47POmg%U=qt zo<+%h;x4(?1#vB5otwR7*L+Ai%j1uO$W45~29adnd7rs-OLDEcRkr<{SOwQ%1U`MA|n?t3oR!tug5(Qjzpy>^Ey@%?PsJ}z6m z%>0F_U1$i>qY$a#(w_N@3?N?Dyl6p`%NW}Q?bR`^3({-2?JOqRYd#}2(rZCPD{1S2 zD?;t*(fE$V;M!wu5(J}aSgh}JrI;Ra&6F3!{)kDT6B#PzX}HmMJDc3c2#O2a7$|s4 z)qBv;uuLxFRLL9?2zyovqTQ(JKKL|bTK}yB~j0skFmfN?ja@@htQ>+ik)iUX8 zD1}!}L^l^_vL{2YKm1qM%VnPoMaZ<|p@Q-T!p&ns#}4*8W?ENCEM(eppjw`GoOHzt z`+njIM?tLx)V-#JKY)5KIZl=`$9YZu{&Fka8b*QG-rnNFgoj64cOUL$cRV_YqB!8; zRs};_jyElc9gienoUFsG5ZI(?(eZkb6}#|bzdywT4#8|gaS8bvvo4{b$%LNMr&QAk z)yBD@b|&=Lbm>hP234rRUDu75&7$`eJ#InYQfN;AOE<~YV`pEA@vZ^0tO>!I@;{;Y zWnRDWbXFDMj_{d|vX@v!rx2;j0>M=xMF1#dzy)5Z^PW6XJLNK1h%>gyrR1Z}eD6eb zcGv+FdvO7@a0nFjw9Ou979>iuAwLz2Gd1L~V9{W1O~bQA|<3)N*|&PHb-IDlNJ z&I|`Qbi_9IqcArPFpRn6fzSd#sE`&MRKd;kL7n)Z45Q3)Tr0w248$D@j+{YZ;>Gf@a6E`Y`Y9>-pIgb@J7 z<4A%=Wg++;*@MpUY+z> z=tPMI^(b@gq(&I0rWlEo9;EM9O6vq%OYbb3gw#)fphe9(rd&bW^em+#`3}02J&-x6 z2`Rh<4TW7~twk+*jb1md(;G&^7`Kaj*)Xh+a#dVY>B@<;3cWxi5Uz9BNG23OZt!6h z5PIisG{svJjtj$6<&Z9 zeg%R72lIBeXOu>A-&j7!0}amf9X7!k^W^(b0g2+)F|uOIkFaB*)=Q-aU%=N~G}|DW z*NVE><$z1IE=BV@m|Cs1Ya~Q&x~5yZARwaT*f^(m2}&w>YNEJe--#)|)it+{?dQa8 zyfDw{FCe*qlqMfkk#b+;au`BBRKe+-2dvPX3VAP!V3xd+GHkP8DQt(p;x3C~Jb7?` zs*ia$%gy1zWlv3tod9ru?sLy?M z8ydyLad)ABvmI(NV-DLKTOB6+Y${{byp ztFje+i20Y(WY(lAIo%W;s5{u literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_polynomial.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_polynomial.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..218dea4fa29e5ae449d923bc76302761d63d7c16 GIT binary patch literal 10395 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_radial_basis_functions.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_radial_basis_functions.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bc819d07cb9276a82918ee4aa3f926f5de04fab GIT binary patch literal 10514 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 OZC;}TLHud>=Kcrmm4AT% literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_random_fourier_features.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_random_fourier_features.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..340fc0ba5975f2d0847b1847090293d0d0281e43 GIT binary patch literal 6841 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 Gb?ZOM-$R@L literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/observables/__pycache__/_time_delay.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_time_delay.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ef6abd0a296320ad834e51c1f5c2940c50fb048 GIT binary patch literal 7618 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96d5c9a71de456bbf5a70b340a6b8b6a93589d65 GIT binary patch literal 616 zcmZ9Jv2NQi5Qa%vvSdqg>coBsFHzP4MbQ)vP#}mCG(ZO~1Z^_5VUjW^JAn5-Nw#d= z`zBgD1^xW~J5qNzsj}=dSld78`Y&hfADZJ8f%(Q5Z+-)4rnzN~3(lF2 zbjL=nBRa&fja?!V;>31cDpKOE&0J6Ph*R5lxyXq#Tewn`#63H3C*p*-Z$G)A7!v39 z)SZbl&X!CUPh5<2dCw+;7wm7s+gy2H@6>Kx`{o6D$5{DYHRh*T2GcZkfWY|5H^$Aa z`Is2o9i}(aDV_y?L1ND&qM!xOy%m~@fZ literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/_base.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_base.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e232c90eb7e82e28e790e99ae2b60d8d2f6ba90d GIT binary patch literal 5446 zcmbtY-EZ5-5$EzlqGZ{z9be)ky(`-*aM3ljeJPq2X^_Ubq}RJ1j3NmNN4Nt`YblEk zMJl^g5(zR;oZUVY=ppDsABy6T^eu0F>R-`^KJ&Fj(LDF9K#~4tNlBDr2RVc^N3*-L zGdr_0v$OVQXR8{X?qAA5e@WB+L5<>Lp>a*qn7jpqYYmMvu7|9nH*`k05gHw{VJh4N zZZ#~0TVbhD#&{{TJC#O-X&-64%+kVA2_svF?Ter1(W$^7z%zL5lv|{0Gd(wBB zp(mviw;bW`2w%!rJf{`aSvuoIQJi>55JwVCWBvMv_?h#zWg@(0((#ja%s0?AdmW5! z$|UG`Ni3Q)z4#btTqC9a1jN@G42tQTH4LtE<3MYe{2gxb(gAB&*`gaI{!L!xGw3Pv z8lMFX)Zlac#DTWY8dc!)d_mzez!&*Rh1Y;D@wXH{3;Yy6t?)VE%lwSOPXIs5&nbK! z_&5053SZzAn8(Rfxizwcw}cI;I(SIK+*D+_U-W+-$K8$>O{^wYs*3VXJCHeLSHuqj z?n}pW9tyA9^@TF~*wE7HNuN7G9??cn?)w8HwtV)>Zb?Sl0{>a==Mld_|O zzn$QLA35Ahyn>Pw#`5(U%hzDs6O#oN7S(gbu}b!k%tePB$LB6>t~{DWflT>;IvZ#! zN46(tXzGOoPq>NiL(1`=07c`X*W?;9vbB*K$X6A7mY9VJo@wF)e*SxDHCk=Q z9e-_Y)ob^>XlM1t?RE8a`}eXVWHsjiM_P4N&h7S7+jS|>U3U#!ztc2`Hh-wtDB)8(^LM6cLtWUMMLO5_4B$)LP`F7ulCWJJd-Crg z+cmgxPZyVm?1@Q5$5VX|dxBmQy! zvM}pkYF0*@&!jm-na#}bmO&gcJmWLz*R?&iXJu<5ZrnVhJ=KR6t#N3L+9Wmlr_!gg zuRmtuZ%LJxc=-T)Z=ibEXOEezeWHEAb~JhoP1m5o489t^S?YtN(q5V9KfkqS549(A zL;ETFOy9HjD#Ox~6VzhbunerCFl~1RxVD@1Yr8eoD&=Fds#T`eV|ITHcAg)WxXmlS zgI!e%rJ8D4$pW~{?34f73a=@=r0`jVV_idwwB-2e)xp8|8-*$`wV^ht!J1SB@PiJ)|AUm%qA3T47XX80M zOnXl0;5m6=lbWMvlq4i2iL>Y(YM(DceQZnSc)!$`c3-EUf5tZIMp_MIRwOk2RFAr8 zIpUrWULRqmudJo)kqWR3%!6NAxq=hLf7BIMsd)Ym2_CE+iW06&x<$vnqry28GzJ`c+g49`TW#UY|?7vN{`Ad>81-20vGmnTc}fd zAav78;Y#I0>yTq1Q^@VNL*s`uOy#JfGs>}vO74ID0MS@6Mc=f^CuiTEQLxs{- z8J|jBe+2?h!3}6%mzR(N5FophIJ8~ksiBgS$&or#g1U$V0-SnpBbfJa$=EXzD?z&2 zEmHzOSa0o_2qOb8`i4j(__gVGNjt4k@gacV;6AVcSg=}0ocfs>XUd=1^2l8 zP+SXTKrDitAo9XV8rYmn74N~AVvzv(x;P22QJ)bNYB&VGL*QKk-vUT2fny7975Y&& z_dE^N349lzUQ(_mR;c6q0BH#a>H{}PS&$l=Zg9x4(nW+H6`?LI(^a|$m?qx=(BM7f zF*Y*|lbOIBf;jT3>?|9oYgpmXdx_D;)bU42h;&pwWCKZ%_9?@NQ)oP6=}BB)J|5kZ ze6CLPx{>KaVIh7%fDZCWo)P4gzrrU~4a5cu(@u>lWXh3=>i9*7D;Tcp1(AoO(X#go z(%zbume(#*sg|UTB~oEFR#|EBjAhcM1*Mj{Dg0(EN*|n@7Ny3&jv#Rr%nn&Eot?Tz z{I($O+_bnUx;GbFyiK@Y9xrx^?v2IPGIrVhUFw(RX?S*;=h#y{i9Q{I%;*PeI>KZ TRZ3%$)@kZBDk5~7)r|iGX+C&T literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/_base_ensemble.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_base_ensemble.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eec5a218fefd3cbf00ab0c46ca6d9edd297ae56d GIT binary patch literal 13641 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/_dmd.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_dmd.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6efb8a85a3899f1fd3b5fe9eb4c22e6b413e634d GIT binary patch literal 12168 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/_edmd.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_edmd.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36e5eae24465f85e223c0181f388f48080bd1d76 GIT binary patch literal 8341 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 VLTkYcnslm!iW6nt>SvTv{{e;)*sTBn literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/_edmdc.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_edmdc.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..417e6ef6fba8880c33fb5702b262b0765d4b8d8a GIT binary patch literal 7728 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 literal 0 HcmV?d00001 diff --git a/DSA/pykoopman/regression/__pycache__/_havok.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_havok.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a27fa9a9a6cffb29f98a3305887e0d3f87e2130 GIT binary patch literal 10095 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 n3uD!>r$?>PyGD 100: @@ -188,13 +208,13 @@ def calculate_projection_and_svd(H, Z_p): Gamma_hat = U_n @ S_half X_hat = S_half @ V_n - X, X_next, U_mid = self._time_align_valid_trials(X_hat, u_list, valid_trials, T_per_trial, p) + X, X_next, U_mid, Y_curr = self._time_align_valid_trials(X_hat, u_list, y_list, valid_trials, T_per_trial, p) A_hat, B_hat = self._perform_ridge_regression(X, X_next, U_mid, n, lamb) C_hat = Gamma_hat[:p_out, :] - noise_covariance, R_hat, Q_hat, S_hat = self._estimate_noise_covariance(X_next, A_hat, X, B_hat, U_mid) + noise_covariance, R_hat, Q_hat, S_hat = self._estimate_noise_covariance(X_next, A_hat, X, B_hat, U_mid, Y_curr, C_hat) info = { "singular_values_O": s, @@ -215,13 +235,14 @@ def calculate_projection_and_svd(H, Z_p): return A_hat, B_hat, C_hat, info - def _time_align_valid_trials(self, X_hat, u_list, valid_trials, T_per_trial, p): + def _time_align_valid_trials(self, X_hat, u_list, y_list, valid_trials, T_per_trial, p): """Helper function to time-align trials for regression.""" # import pdb; pdb.set_trace() X_segments = [] X_next_segments = [] U_mid_segments = [] - + Y_segments = [] + start_idx = 0 for trial_idx, T_trial in enumerate(T_per_trial): X_trial = X_hat[:, start_idx:start_idx + T_trial] @@ -235,14 +256,19 @@ def _time_align_valid_trials(self, X_hat, u_list, valid_trials, T_per_trial, p): X_segments.append(X_trial_curr) X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) - + + Y_trial = y_list[original_trial_idx] + Y_trial_curr = Y_trial[:, p:p+T_trial-1] + Y_segments.append(Y_trial_curr) + start_idx += T_trial X = np.concatenate(X_segments, axis=1) X_next = np.concatenate(X_next_segments, axis=1) U_mid = np.concatenate(U_mid_segments, axis=1) - - return X, X_next, U_mid + Y_curr = np.concatenate(Y_segments, axis=1) + + return X, X_next, U_mid, Y_curr def _perform_ridge_regression(self, X, X_next, U_mid, n, lamb): """Helper function to perform ridge regression.""" @@ -265,10 +291,10 @@ def _perform_ridge_regression(self, X, X_next, U_mid, n, lamb): return A_hat, B_hat - def _estimate_noise_covariance(self, X_next, A_hat, X, B_hat, U_mid): + def _estimate_noise_covariance(self, X_next, A_hat, X, B_hat, U_mid, Y_curr, C_hat): """Helper function to estimate the noise covariance matrix.""" W_hat = X_next - (A_hat @ X + B_hat @ U_mid) - V_hat = self.Y_curr - (self.C_hat @ X) + V_hat = Y_curr - (C_hat @ X) V_hat = V_hat - V_hat.mean(axis=1, keepdims=True) W_hat = W_hat - W_hat.mean(axis=1, keepdims=True) @@ -317,7 +343,7 @@ def subspace_dmdc_multitrial_custom(self, y_list, u_list, p, f, n=None, lamb=1e- Gamma_hat = U_n @ S_half X_hat = S_half @ V_n - X, X_next, U_mid = self._time_align_valid_trials(X_hat, u_list, valid_trials, T_per_trial, p) + X, X_next, U_mid, Y_curr = self._time_align_valid_trials(X_hat, u_list, y_list, valid_trials, T_per_trial, p) if any([i == 0 for i in X.shape]): raise ValueError ("too many delays for dataset, reduce number") A_hat, B_hat = self._perform_ridge_regression(X, X_next, U_mid, n, lamb) @@ -373,40 +399,46 @@ def subspace_dmdc_multitrial_flexible(self, y, u, p, f, n=None, lamb=1e-8, energ return self.subspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy) - def predict(self, Y, U, reseed=None): + def predict(self, test_data=None, control_data=None, reseed=None): """Predict using the Kalman filter.""" + if test_data is None: + test_data = self.data + if control_data is None: + control_data = self.control_data + if reseed is None: reseed = 1 - if isinstance(Y, list): + if isinstance(test_data, list): self.kalman = OnlineKalman(self) Y_pred = [] - for trial in range(len(Y)): + for trial in range(len(test_data)): self.kalman.reset() trial_predictions = [ - self.kalman.step(y=Y[trial][t] if t % reseed == 0 else None, u=U[trial][t])[0] - for t in range(Y[trial].shape[0]) + self.kalman.step(y=test_data[trial][t] if t % reseed == 0 else None, u=control_data[trial][t])[0] + for t in range(test_data[trial].shape[0]) ] Y_pred.append(np.concatenate(trial_predictions, axis=1).T) return Y_pred self.kalman = OnlineKalman(self) - if Y.ndim == 2: + if test_data.ndim == 2: return np.concatenate( - [self.kalman.step(y=Y[t] if t % reseed == 0 else None, u=U[t])[0] for t in range(Y.shape[0])], + [self.kalman.step(y=test_data[t] if t % reseed == 0 else None, u=control_data[t])[0] for t in range(test_data.shape[0])], axis=1 ).T else: Y_pred = [] - for trial in range(Y.shape[0]): + for trial in range(test_data.shape[0]): self.kalman.reset() trial_predictions = [ - self.kalman.step(y=Y[trial, t] if t % reseed == 0 else None, u=U[trial, t])[0] - for t in range(Y.shape[1]) + self.kalman.step(y=test_data[trial, t] if t % reseed == 0 else None, u=control_data[trial, t])[0] + for t in range(test_data.shape[1]) ] Y_pred.append(np.concatenate(trial_predictions, axis=1).T) return np.array(Y_pred) + def compute_hankel(self, *args, **kwargs): """Compute Hankel matrices for SubspaceDMDc.""" raise NotImplementedError( @@ -435,6 +467,7 @@ def __init__(self, dmdc): self.Q = dmdc.info['Q_hat'] self.y_dim, self.x_dim = self.C.shape + self.u_dim = self.B.shape[1] self.reset() diff --git a/examples/all_dsa_types.ipynb b/examples/all_dsa_types.ipynb index 704c49c..d1cc01c 100644 --- a/examples/all_dsa_types.ipynb +++ b/examples/all_dsa_types.ipynb @@ -2,13 +2,36 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "773aa0fd", "metadata": {}, "outputs": [], "source": [ "import numpy as np \n", "import matplotlib.pyplot as plt\n", + "import sys\n", + "import importlib\n", + "\n", + "# Remove any local DSA packages from sys.path to force using the installed package\n", + "paths_to_remove = [p for p in sys.path if 'Degeneracy' in p and 'DSA' in p]\n", + "for p in paths_to_remove:\n", + " sys.path.remove(p)\n", + "\n", + "# Also remove the current directory's parent if it contains a DSA package\n", + "# This prevents importing from /n/home00/ahuang/DSA if it's in the path\n", + "# Uncomment the next lines if needed:\n", + "# if '/n/home00/ahuang/DSA' in sys.path:\n", + "# sys.path.remove('/n/home00/ahuang/DSA')\n", + "\n", + "# Force reload to ensure we get the installed package\n", + "if 'DSA' in sys.modules:\n", + " del sys.modules['DSA']\n", + " # Also remove any submodules\n", + " modules_to_remove = [k for k in sys.modules.keys() if k.startswith('DSA.')]\n", + " for k in modules_to_remove:\n", + " del sys.modules[k]\n", + "\n", + "# Now import from the installed package\n", "from DSA import DSA, GeneralizedDSA, InputDSA\n", "from DSA import DMD, DMDc, SubspaceDMDc, ControllabilitySimilarityTransformDist\n", "from DSA import DMDConfig, DMDcConfig, SubspaceDMDcConfig\n", @@ -16,7 +39,7 @@ "from pydmd import DMD as pDMD\n", "import DSA.pykoopman as pk\n", "%load_ext autoreload\n", - "%autoreload 2\n" + "%autoreload 2" ] }, { @@ -39,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "d452743b", "metadata": {}, "outputs": [ @@ -49,7 +72,7 @@ "(18, 9)" ] }, - "execution_count": 7, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -58,6 +81,7 @@ "d1 = np.random.random(size=(20,5))\n", "u1 = np.random.random(size=(20,2))\n", "\n", + "# n_trials, n_timepoints, n_features\n", "d2 = np.random.random(size=(3,20,5))\n", "u2 = np.random.random(size=(3,20,2))\n", "\n", @@ -75,39 +99,10 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "88cad354", "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Trial 0: y and u have different time lengths", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[14], line 14\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# dmdc = DMDc(d5,u5,n_delays=2,rank_input=10,rank_output=10)\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# dmdc.fit()\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# print(dmdc.A_v.shape)\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 11\u001b[0m \n\u001b[1;32m 12\u001b[0m \u001b[38;5;66;03m#TODO: fix this case\u001b[39;00m\n\u001b[1;32m 13\u001b[0m subdmdc \u001b[38;5;241m=\u001b[39m SubspaceDMDc(d2,u2,n_delays\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m,rank\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,backend\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mn4sid\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 14\u001b[0m \u001b[43msubdmdc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28mprint\u001b[39m(subdmdc\u001b[38;5;241m.\u001b[39mA_v\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28mprint\u001b[39m(subdmdc\u001b[38;5;241m.\u001b[39mB_v\u001b[38;5;241m.\u001b[39mshape)\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:70\u001b[0m, in \u001b[0;36mSubspaceDMDc.fit\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mfit\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 69\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Fit the SubspaceDMDc model.\"\"\"\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA_v, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mB_v, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_v, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minfo \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubspace_dmdc_multitrial_flexible\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 71\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 72\u001b[0m \u001b[43m \u001b[49m\u001b[43mu\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcontrol_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 73\u001b[0m \u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 74\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 75\u001b[0m \u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrank\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 77\u001b[0m \u001b[43m \u001b[49m\u001b[43mlamb\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlamb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;66;03m# Send to CPU if requested (inherited from BaseDMD)\u001b[39;00m\n\u001b[1;32m 80\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msend_to_cpu:\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:371\u001b[0m, in \u001b[0;36mSubspaceDMDc.subspace_dmdc_multitrial_flexible\u001b[0;34m(self, y, u, p, f, n, lamb, energy, backend)\u001b[0m\n\u001b[1;32m 367\u001b[0m \u001b[38;5;66;03m# y_list = [y_trial.T for y_trial in y_list]\u001b[39;00m\n\u001b[1;32m 368\u001b[0m \u001b[38;5;66;03m# u_list = [u_trial.T for u_trial in u_list]\u001b[39;00m\n\u001b[1;32m 370\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m backend \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mn4sid\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 371\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubspace_dmdc_multitrial_QR_decomposition\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlamb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43menergy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 372\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 373\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msubspace_dmdc_multitrial_custom(y_list, u_list, p, f, n, lamb, energy)\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:150\u001b[0m, in \u001b[0;36mSubspaceDMDc.subspace_dmdc_multitrial_QR_decomposition\u001b[0;34m(self, y_list, u_list, p, f, n, lamb, energy)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21msubspace_dmdc_multitrial_QR_decomposition\u001b[39m(\u001b[38;5;28mself\u001b[39m, y_list, u_list, p, f, n\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, lamb\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1e-8\u001b[39m, energy\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.999\u001b[39m):\n\u001b[1;32m 146\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;124;03m Subspace-DMDc for multi-trial data with variable trial lengths using QR decomposition.\u001b[39;00m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m 149\u001b[0m U_p, Y_p, U_f, Y_f, Z_p, valid_trials, T_per_trial, T_total, p_out, m \u001b[38;5;241m=\u001b[39m \\\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_validate_and_collect_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 152\u001b[0m H \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvstack([U_f, Z_p, Y_f])\n\u001b[1;32m 154\u001b[0m dim_uf \u001b[38;5;241m=\u001b[39m f \u001b[38;5;241m*\u001b[39m m\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py:98\u001b[0m, in \u001b[0;36mSubspaceDMDc._validate_and_collect_data\u001b[0;34m(self, y_list, u_list, p, f)\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTrial \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: u has \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mu_trial\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m inputs, expected \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mm\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y_trial\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m!=\u001b[39m u_trial\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]:\n\u001b[0;32m---> 98\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTrial \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: y and u have different time lengths\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 100\u001b[0m U_p_all \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 101\u001b[0m Y_p_all \u001b[38;5;241m=\u001b[39m []\n", - "\u001b[0;31mValueError\u001b[0m: Trial 0: y and u have different time lengths" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[0;32m/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/subspace_dmdc.py\u001b[0m(98)\u001b[0;36m_validate_and_collect_data\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m 96 \u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Trial {i}: u has {u_trial.shape[0]} inputs, expected {m}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 97 \u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0my_trial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mu_trial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m---> 98 \u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Trial {i}: y and u have different time lengths\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 99 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 100 \u001b[0;31m \u001b[0mU_p_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ "\n", "# dmdc = DMDc(d5,u5,n_delays=2,rank_input=10,rank_output=10)\n", @@ -120,21 +115,145 @@ "# print(subdmdc.A_v.shape)\n", "# print(subdmdc.B_v.shape)\n", "\n", + "# Testing the case where n_delays >= trial_length / 2 in subspace dmdc\n", + "# prob_15 = 0.8\n", + "# prob_30 = 1 - prob_15\n", + "# n_arrays = 10\n", "\n", - "#TODO: fix this case\n", - "subdmdc = SubspaceDMDc(d2,u2,n_delays=10,rank=5,backend='n4sid')\n", - "subdmdc.fit()\n", - "print(subdmdc.A_v.shape)\n", - "print(subdmdc.B_v.shape)\n", + "# # Generate the list\n", + "# d2 = [np.random.random(size=(np.random.choice([15, 30], p=[prob_15, prob_30]), 5)) \n", + "# for _ in range(n_arrays)]\n", + "# u2 = [np.random.random(size=(d.shape[0], 2)) \n", + "# for d in d2] # match the first dimension from d2\n", + "\n", + "# subdmdc = SubspaceDMDc(d2,u2,n_delays=6,rank=5,backend='n4sid')\n", + "# subdmdc.fit()\n", + "# print(subdmdc.A_v.shape)\n", + "# print(subdmdc.B_v.shape)\n", "\n", "\n", "#TODO: fix this case\n", "# subdmdc = SubspaceDMDc(d3,u3,n_delays=2,rank=10,backend='n4sid')\n", "# subdmdc.fit()\n", "# print(subdmdc.A_v.shape)\n", - "# print(subdmdc.B_v.shape)\n", + "# print(subdmdc.B_v.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b7b308b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 10)\n", + "(500, 9)\n" + ] + } + ], + "source": [ + "#TODO: check predictions for all cases\n", + "\n", + "def make_stable_A(n, rho=0.9, rng=None):\n", + " rng = np.random.default_rng(rng)\n", + " M = rng.standard_normal((n, n))\n", + " # Make it diagonally dominant-ish and scale spectral radius\n", + " A = M / np.max(np.abs(np.linalg.eigvals(M))) * rho\n", + " return A\n", + "\n", + "def simulate_system(A, B, C, U, x0=None,rng=None,obs_noise=0.0,process_noise=0.0,\n", + " nonlinear_eps=0.0,nonlinear_func= lambda x: np.tanh(x),nonlinear_eps_input=0.0):\n", + " n, m = B.shape\n", + " p_out = C.shape[0]\n", + " N = U.shape[1]\n", + " X = np.zeros((n, N+1))\n", + " C_full = np.eye(A.shape[0])\n", + " C_full[np.where(C == 1)[1],np.where(C == 1)[1]] = 0.0\n", + "\n", + " if x0 is not None:\n", + " X[:, 0] = x0\n", + " else:\n", + " X[:, 0] = np.random.default_rng(rng).standard_normal((n,))\n", + " Y = np.zeros((p_out, N))\n", + " for t in range(N):\n", + " X[:, t+1] = A @ (X[:, t]) + nonlinear_eps * C_full @ nonlinear_func(A @ X[:, t]) + \\\n", + " B @ ((1-nonlinear_eps_input) * U[:, t] + nonlinear_eps_input * nonlinear_func(U[:, t])) + \\\n", + " np.random.normal(0, process_noise, (n,))\n", + " Y[:, t] = C @ X[:, t] + np.random.normal(0, obs_noise, (p_out,))\n", + " return X[:, 1:], Y # states aligned with Y\n", + "\n", + "def smooth_input(m, N, alpha=0.9, rng=None):\n", + " rng = np.random.default_rng(rng)\n", + " w = rng.standard_normal((m, N))\n", + " U = np.zeros_like(w)\n", + " for t in range(N):\n", + " U[:, t] = alpha*(U[:, t-1] if t>0 else 0) + (1-alpha)*w[:, t]\n", + " return U\n", + "\n", + "\n", + "latent_dim = 10\n", + "input_dim = 2\n", + "g1 = 0.5\n", + "seed1 = 123\n", + "seq_length = 500\n", + "input_alpha = 0.001\n", + "nonlinear_eps = 0.1\n", + "observed_dim = 9\n", + "idx_obs = np.arange(observed_dim)\n", + "A = make_stable_A(latent_dim)\n", + "B = np.random.default_rng(seed1).standard_normal((latent_dim, input_dim)) * g1\n", + "C = np.zeros((observed_dim, latent_dim))\n", + "C[np.arange(observed_dim), idx_obs] = 1.0\n", + "U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1) \n", + "\n", + "X, Y = simulate_system(A, B, C, U, nonlinear_eps=nonlinear_eps)\n", + "\n", + "X = X.T\n", + "Y = Y.T\n", + "# U = U.T\n", + "\n", + "print(X.shape)\n", + "print(Y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "e59db62a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DMD prediction MASE: 0.0001704487077985564\n", + "DMDC prediction MASE: 0.6608961494400851\n", + "Using 1 out of 1 trials with sufficient time points.\n", + "DMDC prediction MASE: 0.4358238354387466\n" + ] + } + ], + "source": [ + "from DSA.stats import mase\n", + "X_auto, Y_auto = simulate_system(A, np.zeros((latent_dim, input_dim)), C, U, nonlinear_eps=nonlinear_eps)\n", + "X_auto = X_auto.T\n", + "dmd = DMD(X_auto, n_delays=10, rank=10)\n", + "dmd.fit()\n", + "pred_data = dmd.predict()\n", + "print(f'DMD prediction MASE: {mase(X_auto, pred_data)}')\n", "\n", - "#TODO: check predictions for all cases" + "dmdc = DMDc(X, U.T, n_delays=10, rank_input=10, rank_output=10)\n", + "dmdc.fit()\n", + "pred_data = dmdc.predict()\n", + "print(f'DMDC prediction MASE: {mase(X, pred_data)}')\n", + "\n", + "dmdc = SubspaceDMDc(X, U.T, n_delays=10, rank=10, backend='n4sid')\n", + "dmdc.fit()\n", + "pred_data = dmdc.predict()\n", + "print(f'DMDC prediction MASE: {mase(X, pred_data)}')" ] }, { @@ -244,6 +363,16 @@ "#TODO: check generalized dsa with the other comparison metric and changing the config\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab0dbe0a", + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -255,7 +384,7 @@ ], "metadata": { "kernelspec": { - "display_name": "dsa_test_env", + "display_name": "py39", "language": "python", "name": "python3" }, @@ -269,7 +398,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.9.18" } }, "nbformat": 4, From 7f4f644b92194a363cad32ca9bf6409cb1c7faaf Mon Sep 17 00:00:00 2001 From: Ann Huang Date: Mon, 3 Nov 2025 18:49:19 -0500 Subject: [PATCH 28/51] checked gDSA with various data structures, metrics, and configs --- DSA/__pycache__/base_dmd.cpython-39.pyc | Bin 8329 -> 8329 bytes DSA/__pycache__/dsa.cpython-39.pyc | Bin 26920 -> 27422 bytes DSA/__pycache__/subspace_dmdc.cpython-39.pyc | Bin 17995 -> 19805 bytes DSA/dsa.py | 12 + DSA/subspace_dmdc.py | 150 +++++++--- examples/all_dsa_types.ipynb | 272 ++++++++++++++----- 6 files changed, 326 insertions(+), 108 deletions(-) diff --git a/DSA/__pycache__/base_dmd.cpython-39.pyc b/DSA/__pycache__/base_dmd.cpython-39.pyc index 6124923bcb3dc6800554d7a81ed444d00e842978..a7657d2844e5f6c098e7fa73accd739ca9d4e83b 100644 GIT binary patch delta 726 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 PtJg+vt1AWSnlJw!Q@7#F delta 4774 zcmaJ_Yiv~45#Fz2$=1fHGv};d{H^%*uSJDcULJDMPv%;{EPMKT#XsC4S_pb(d&NBUU_h^$M?Blx zlTIf_U2-W6eckI|fkc!u2GsxpCpvZ-*hqR}gA)dw?L;!{LnvelK)`!Jwr zdM1Wb1!M&=O!`=51Y~qZnNV+3)D=dnG>=%V!ZkaNPGzzc`idJ}i(vrJ4&dEx05t

n}+hdwqevDAJ@Eu;FQ}t1(>qO=?Pxx@RL{G3(Hd`L9fgSmJHyL z+PAk7Iv%NYyEt95;pVFZbQI_y@Gr^Ng8ETIKcf2aREf2T&CS}$tJhX#QN{oV=x#o2 z^DAgiCDdiOlS_J$668DB*B>mE;qbpxNHUOb?)n}=Ug`{w7Ox!9bm*~ zt{aeYF`U{-cO})U-db7!<1SeMb4y}fhsi+gx7=2(@9uSL^UWxBiyUgcVYVN;woY;1 z$D0eL4bUDTUT{C5$2w!;>& zL}Sinwm#sc;G?tzbGmr&@AxJJ3y6FNBK+T46I<~5-yb{O)|0L0+t0K%TU+g?TMgM- zUSeBC?s72GK6!o**qEze;j)Dc@M@K-`U!{_8UEB1fA4lXvR3ZrA5M6#5?k{W^t_YT z+j$CBQF8i>0z;1dC-R5jer&h~Gy{tfnUd54l>&N=kzi_@% diff --git a/DSA/pykoopman/regression/__pycache__/_dmd.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_dmd.cpython-39.pyc deleted file mode 100644 index 6efb8a85a3899f1fd3b5fe9eb4c22e6b413e634d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12168 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 diff --git a/DSA/pykoopman/regression/__pycache__/_edmd.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_edmd.cpython-39.pyc deleted file mode 100644 index 36e5eae24465f85e223c0181f388f48080bd1d76..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8341 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 VLTkYcnslm!iW6nt>SvTv{{e;)*sTBn diff --git a/DSA/pykoopman/regression/__pycache__/_edmdc.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_edmdc.cpython-39.pyc deleted file mode 100644 index 417e6ef6fba8880c33fb5702b262b0765d4b8d8a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7728 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 diff --git a/DSA/pykoopman/regression/__pycache__/_havok.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_havok.cpython-39.pyc deleted file mode 100644 index 7a27fa9a9a6cffb29f98a3305887e0d3f87e2130..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10095 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 n3uD!>r$?>PyGD Date: Tue, 4 Nov 2025 09:39:05 -0500 Subject: [PATCH 31/51] changed subspace dmdc code to work with (n_timepoints, n_features) data without transposing --- DSA/subspace_dmdc.py | 28 ++++++++------ examples/all_dsa_types.ipynb | 71 +++++++++++++++++++++++++++++++----- 2 files changed, 77 insertions(+), 22 deletions(-) diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index a5c245d..918c81b 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -148,8 +148,8 @@ def _check_same_shape(self): def _collect_data(self, y_list, u_list, p, f): """Helper function to validate dimensions and collect data from trials.""" - p_out = y_list[0].shape[0] - m = u_list[0].shape[0] + p_out = y_list[0].shape[-1] + m = u_list[0].shape[-1] U_p_all = [] Y_p_all = [] @@ -159,10 +159,12 @@ def _collect_data(self, y_list, u_list, p, f): T_per_trial = [] def hankel_stack(X, start, L): - return np.concatenate([X[:, start + i:start + i + 1] for i in range(L)], axis=0) + # X is now (n_timepoints, n_features), so we transpose for slicing + # then stack along axis=0 to get (L * n_features, 1) + return np.concatenate([X[start + i:start + i + 1, :].T for i in range(L)], axis=0) for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): - N_trial = Y_trial.shape[1] + N_trial = Y_trial.shape[0] T_trial = N_trial - (p + f) if T_trial <= 0: @@ -306,14 +308,16 @@ def _time_align_valid_trials(self, X_hat, u_list, y_list, valid_trials, T_per_tr original_trial_idx = valid_trials[trial_idx] U_trial = u_list[original_trial_idx] - U_mid_trial = U_trial[:, p:p + (T_trial - 1)] + # U_trial is now (n_timepoints, n_features), slice rows then transpose + U_mid_trial = U_trial[p:p + (T_trial - 1), :].T X_segments.append(X_trial_curr) X_next_segments.append(X_trial_next) U_mid_segments.append(U_mid_trial) Y_trial = y_list[original_trial_idx] - Y_trial_curr = Y_trial[:, p:p+T_trial-1] + # Y_trial is now (n_timepoints, n_features), slice rows then transpose + Y_trial_curr = Y_trial[p:p+T_trial-1, :].T Y_segments.append(Y_trial_curr) start_idx += T_trial @@ -435,11 +439,11 @@ def _convert_to_subspace_dmdc_data_format(self,y, u): for y_trial, u_trial in zip(y, u): if y_trial.ndim == 3 and u_trial.ndim == 3: for t in range(len(y_trial)): - y_list.append(y_trial[t].T) - u_list.append(u_trial[t].T) + y_list.append(y_trial[t]) + u_list.append(u_trial[t]) elif y_trial.ndim == 2 and u_trial.ndim == 2: - y_list.append(y_trial.T) - u_list.append(u_trial.T) + y_list.append(y_trial) + u_list.append(u_trial) else: raise ValueError("Invalid dimension. Only list of (n_trials, n_timepoints, n_features) or (n_timepoints, n_features) arrays are supported.") else: @@ -449,8 +453,8 @@ def _convert_to_subspace_dmdc_data_format(self,y, u): else: y_list = [y[i] for i in range(y.shape[0])] u_list = [u[i] for i in range(u.shape[0])] - y_list = [y_trial.T for y_trial in y_list] - u_list = [u_trial.T for u_trial in u_list] + y_list = [y_trial for y_trial in y_list] + u_list = [u_trial for u_trial in u_list] return y_list, u_list diff --git a/examples/all_dsa_types.ipynb b/examples/all_dsa_types.ipynb index ad52778..6615607 100644 --- a/examples/all_dsa_types.ipynb +++ b/examples/all_dsa_types.ipynb @@ -10,7 +10,6 @@ "import numpy as np \n", "import matplotlib.pyplot as plt\n", "\n", - "# Now import from the installed package\n", "from DSA import DSA, GeneralizedDSA, InputDSA\n", "from DSA import DMD, DMDc, SubspaceDMDc, ControllabilitySimilarityTransformDist\n", "from DSA import DMDConfig, DMDcConfig, SubspaceDMDcConfig\n", @@ -41,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 4, "id": "d452743b", "metadata": {}, "outputs": [ @@ -51,7 +50,7 @@ "(18, 9)" ] }, - "execution_count": 28, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -78,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "id": "88cad354", "metadata": {}, "outputs": [ @@ -121,7 +120,7 @@ "\n", "\n", "# passing list of 3D arrayss\n", - "subdmdc = SubspaceDMDc(d5,u5,n_delays=2,rank=10,backend='n4sid')\n", + "subdmdc = SubspaceDMDc(d1,u1,n_delays=2,rank=10,backend='custom')\n", "subdmdc.fit()\n", "print(subdmdc.A_v.shape)\n", "print(subdmdc.B_v.shape)\n" @@ -129,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "b7b308b7", "metadata": {}, "outputs": [ @@ -188,7 +187,8 @@ "seed1 = 123\n", "seq_length = 500\n", "input_alpha = 0.001\n", - "nonlinear_eps = 0.1\n", + "nonlinear_eps = 0.0\n", + "nonlinear_eps_input = 0.0\n", "observed_dim = 9\n", "idx_obs = np.arange(observed_dim)\n", "A = make_stable_A(latent_dim)\n", @@ -201,12 +201,63 @@ "\n", "X = X.T\n", "Y = Y.T\n", - "# U = U.T\n", + "U = U.T\n", "\n", "print(X.shape)\n", "print(Y.shape)" ] }, + { + "cell_type": "code", + "execution_count": 22, + "id": "8c4c9ea2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 9.00000000e-01+0.j -4.27762264e-01+0.34055831j\n", + " -4.27762264e-01-0.34055831j 5.72126042e-01+0.47528717j\n", + " 5.72126042e-01-0.47528717j -2.56600620e-04+0.50116322j\n", + " -2.56600620e-04-0.50116322j 3.46246199e-01+0.30316658j\n", + " 3.46246199e-01-0.30316658j -8.50722948e-02+0.j ]\n", + "(500, 9) (500, 2)\n", + "[-4.27762263e-01+0.34055831j -4.27762263e-01-0.34055831j\n", + " 8.99999999e-01+0.j 5.72126042e-01+0.47528717j\n", + " 5.72126042e-01-0.47528717j -2.56600504e-04+0.50116322j\n", + " -2.56600504e-04-0.50116322j 3.46246198e-01+0.30316658j\n", + " 3.46246198e-01-0.30316658j -8.50722947e-02+0.j ]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Check that subspace dmdc works with (n_timepoints, n_features) data\n", + "print(np.linalg.eigvals(A))\n", + "print(Y.shape, U.shape)\n", + "subdmdc = SubspaceDMDc(Y,U,n_delays=10,rank=10,backend='n4sid')\n", + "subdmdc.fit()\n", + "print(np.linalg.eigvals(subdmdc.A_v))\n", + "\n", + "# plot the two sets of eigenvalues as scatter plots\n", + "plt.figure(figsize=(5,5))\n", + "plt.scatter(np.real(np.linalg.eigvals(A)), np.imag(np.linalg.eigvals(A)), label='True', s=100, alpha=0.5)\n", + "plt.scatter(np.real(np.linalg.eigvals(subdmdc.A_v)), np.imag(np.linalg.eigvals(subdmdc.A_v)), label='Subspace DMDc', s=100, alpha=0.5)\n", + "plt.legend()\n", + "plt.show()\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": 28, @@ -319,7 +370,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "id": "2ea88dc2", "metadata": {}, "outputs": [ @@ -397,7 +448,7 @@ "# sim.shape\n", "\n", "# Should return a 3x3 distance matrix\n", - "#TODO: when doing cross-comparison and using a list of arrays, gDSA treats each array as its own system\n", + "# When doing cross-comparison and using a list of arrays, gDSA treats each array as its own system\n", "dsa = GeneralizedDSA(X=d3, X_control=u3,\n", " Y=d3, Y_control=u3,\n", " dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", From e8c93af17fb9c359a5ce5f2228d2d6d26de53efa Mon Sep 17 00:00:00 2001 From: Ann Huang Date: Tue, 4 Nov 2025 09:40:47 -0500 Subject: [PATCH 32/51] changed subspace dmdc code to work with (n_timepoints, n_features) data without transposing --- DSA/subspace_dmdc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index 918c81b..8fe7d6f 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -160,7 +160,7 @@ def _collect_data(self, y_list, u_list, p, f): def hankel_stack(X, start, L): # X is now (n_timepoints, n_features), so we transpose for slicing - # then stack along axis=0 to get (L * n_features, 1) + # then stack along axis=0 return np.concatenate([X[start + i:start + i + 1, :].T for i in range(L)], axis=0) for trial_idx, (Y_trial, U_trial) in enumerate(zip(y_list, u_list)): From 7b3b9240f9cfbd8e16285c5f8b4555944fb8b160 Mon Sep 17 00:00:00 2001 From: Mitchell Ostrow <35669245+mitchellostrow@users.noreply.github.com> Date: Tue, 4 Nov 2025 14:40:21 -0500 Subject: [PATCH 33/51] update readme --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 27b72fb..6866721 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# generalized DSA +# Generalized DSA Computational techniques for Dynamical Similarity Analysis. First introduced in, 1. "Beyond Geometry: Comparing the Temporal Structure of Computation in Neural Circuits via Dynamical Similarity Analysis" @@ -8,9 +8,10 @@ https://arxiv.org/abs/2306.10168 Abstract: How can we tell whether two neural networks are utilizing the same internal processes for a particular computation? This question is pertinent for multiple subfields of both neuroscience and machine learning, including neuroAI, mechanistic interpretability, and brain-machine interfaces. Standard approaches for comparing neural networks focus on the spatial geometry of latent states. Yet in recurrent networks, computations are implemented at the level of neural dynamics, which do not have a simple one-to-one mapping with geometry. To bridge this gap, we introduce a novel similarity metric that compares two systems at the level of their dynamics. Our method incorporates two components: Using recent advances in data-driven dynamical systems theory, we learn a high-dimensional linear system that accurately captures core features of the original nonlinear dynamics. Next, we compare these linear approximations via a novel extension of Procrustes Analysis that accounts for how vector fields change under orthogonal transformation. Via four case studies, we demonstrate that our method effectively identifies and distinguishes dynamic structure in recurrent neural networks (RNNs), whereas geometric methods fall short. We additionally show that our method can distinguish learning rules in an unsupervised manner. Our method therefore opens the door to novel data-driven analyses of the temporal structure of neural computation, and to more rigorous testing of RNNs as models of the brain. -and now including code from the following: +and now including code from our new paper: 2. "InputDSA: Demixing then comparing recurrent and externally driven dynamics + Abstract: In control problems and basic scientific modeling, it is important to compare observations with dynamical simulations. For example, comparing two neural systems can shed light on the nature of emergent computations in the brain and deep neural networks. Recently, (Ostrow et al., 2023) introduced Dynamical Similarity Analysis (DSA), a method to measure the similarity of two systems based on their state dynamics rather than geometry or topology. However, DSA does not consider how inputs affect the dynamics, meaning that two similar systems, if driven differently, may be classified as different. Because real-world dynamical systems are rarely autonomous, it is important to account for the effects of input drive. To this end, we introduce a novel metric for comparing both intrinsic (recurrent) and input-driven dynamics, called InputDSA (iDSA). InputDSA extends the DSA framework by estimating and comparing both input and intrinsic dynamic operators using a novel variant of Dynamic Mode Decomposition with control (DMDc) based on subspace identification. We demonstrate that InputDSA can successfully compare partially observed, input-driven systems from noisy data. We show that when the true inputs are unknown, surrogate inputs can be substituted without a major deterioration in similarity estimates. We apply InputDSA on Recurrent Neural Networks (RNNs) trained with Deep Reinforcement Learning, identifying that high-performing networks are dynamically similar to one another, while low-performing networks are more diverse. Lastly, we apply InputDSA to neural data recorded from rats performing a cognitive task, demonstrating that it identifies a transition from input-driven evidence accumulation to intrinsically- driven decision-making. Our work demonstrates that InputDSA is a robust and efficient method for comparing intrinsic dynamics and the effect of external input on dynamical systems From 1412ce8a0a3473dc102cbd88b8d7c127fcfd34e6 Mon Sep 17 00:00:00 2001 From: Mitchell Ostrow <35669245+mitchellostrow@users.noreply.github.com> Date: Tue, 4 Nov 2025 14:41:05 -0500 Subject: [PATCH 34/51] Add abstract for InputDSA paper to README Added abstract for InputDSA paper explaining its significance in comparing dynamical systems. --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 6866721..d240ce2 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,8 @@ and now including code from our new paper: 2. "InputDSA: Demixing then comparing recurrent and externally driven dynamics +https://www.arxiv.org/abs/2510.25943 + Abstract: In control problems and basic scientific modeling, it is important to compare observations with dynamical simulations. For example, comparing two neural systems can shed light on the nature of emergent computations in the brain and deep neural networks. Recently, (Ostrow et al., 2023) introduced Dynamical Similarity Analysis (DSA), a method to measure the similarity of two systems based on their state dynamics rather than geometry or topology. However, DSA does not consider how inputs affect the dynamics, meaning that two similar systems, if driven differently, may be classified as different. Because real-world dynamical systems are rarely autonomous, it is important to account for the effects of input drive. To this end, we introduce a novel metric for comparing both intrinsic (recurrent) and input-driven dynamics, called InputDSA (iDSA). InputDSA extends the DSA framework by estimating and comparing both input and intrinsic dynamic operators using a novel variant of Dynamic Mode Decomposition with control (DMDc) based on subspace identification. We demonstrate that InputDSA can successfully compare partially observed, input-driven systems from noisy data. We show that when the true inputs are unknown, surrogate inputs can be substituted without a major deterioration in similarity estimates. We apply InputDSA on Recurrent Neural Networks (RNNs) trained with Deep Reinforcement Learning, identifying that high-performing networks are dynamically similar to one another, while low-performing networks are more diverse. Lastly, we apply InputDSA to neural data recorded from rats performing a cognitive task, demonstrating that it identifies a transition from input-driven evidence accumulation to intrinsically- driven decision-making. Our work demonstrates that InputDSA is a robust and efficient method for comparing intrinsic dynamics and the effect of external input on dynamical systems From 1c4e9b0b5e2a3a156259bf4d5b5f3be29c2f7e88 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 4 Nov 2025 17:07:35 -0500 Subject: [PATCH 35/51] precompute eigenvalues for wasserstein distance before comparison, resulting in further speedup! --- DSA/dsa.py | 50 ++++++++++++++++++++--- DSA/simdist.py | 108 ++++++++++++++++++++++++++++++++++--------------- 2 files changed, 119 insertions(+), 39 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index 850b07f..3604559 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -703,16 +703,43 @@ def fit_score(self): self.fit_dmds() return self.score() - def get_dmd_matrix(self, dmd): + def get_compare_objects(self, dmd): + """ + Get the comparison objects for similarity computation. + + For Wasserstein distance on states, returns pre-computed eigenvalues to avoid + redundant eigendecomposition. Otherwise returns the full DMD matrix. + + Parameters + ---------- + dmd : DMD object + The fitted DMD model + + Returns + ------- + matrix or eigenvalues : torch.Tensor or np.ndarray + Either the state matrix (for angular/euclidean metrics) or + eigenvalues as 1D complex array (for Wasserstein distance) + """ if self.dmd_api_source == "local_dmd": - return dmd.A_v + matrix = dmd.A_v elif self.dmd_api_source == "pykoopman": - return dmd.A + matrix = dmd.A elif self.dmd_api_source == "pydmd": raise ValueError( "DSA is not currently compatible with pydmd due to \ data structure incompatibility. Please use pykoopman instead." ) + + # Return eigenvalues directly for Wasserstein distance on states + if (not self.simdist_has_control + and self.simdist_config.get("score_method") == "wasserstein"): + if not isinstance(matrix, torch.Tensor): + matrix = torch.from_numpy(matrix).float() + eigenvalues = torch.linalg.eig(matrix).eigenvalues + return eigenvalues + + return matrix def get_dmd_control_matrix(self, dmd): if self.dmd_api_source == "local_dmd": @@ -757,6 +784,16 @@ def score(self): self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]), n_sims)) + # Pre-compute comparison objects (matrices or eigenvalues) to avoid redundant computation + if (not self.simdist_has_control + and self.simdist_config.get("score_method") == "wasserstein"): + if self.verbose: + print("Pre-computing eigenvalues for Wasserstein distance...") + + self.cached_compare_objects = [ + [self.get_compare_objects(dmd) for dmd in self.dmds[0]], + [self.get_compare_objects(dmd) for dmd in self.dmds[ind2]] + ] def compute_similarity(i, j): if self.method == "self-pairwise" and j >= i: @@ -766,8 +803,8 @@ def compute_similarity(i, j): print(f"computing similarity between DMDs {i} and {j}") simdist_args = [ - self.get_dmd_matrix(self.dmds[0][i]), - self.get_dmd_matrix(self.dmds[ind2][j]), + self.cached_compare_objects[0][i], + self.cached_compare_objects[1][j], ] if self.simdist_has_control and self.dmd_has_control: @@ -777,10 +814,11 @@ def compute_similarity(i, j): self.get_dmd_control_matrix(self.dmds[ind2][j]), ] ) + sim = self.simdist.fit_score(*simdist_args) if self.verbose and self.n_jobs != 1: - print(f"computing similarity between DMDs {i} and {j}") + print(f"finished similarity between DMDs {i} and {j}") return (i, j, sim) diff --git a/DSA/simdist.py b/DSA/simdist.py index 3882093..d027d0b 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -193,9 +193,9 @@ def fit( Parameters __________ A : np.array or torch.tensor or DMD object - first data matrix + first data matrix or pre-computed eigenvalues (1D complex numpy/torch array) for Wasserstein B : np.array or torch.tensor or DMD object - second data matrix + second data matrix or pre-computed eigenvalues (1D complex numpy/torch array) for Wasserstein iters : int or None number of optimization steps, if None then resorts to saved self.iters lr : float or None @@ -205,23 +205,55 @@ def fit( _______ None """ - if isinstance(A, DMD): - A = A.A_v - if isinstance(B, DMD): - B = B.A_v - - assert A.shape[0] == A.shape[1] - assert B.shape[0] == B.shape[1] - - A = A.to(self.device) - B = B.to(self.device) - self.A, self.B = A, B + score_method = self.score_method if score_method is None else score_method + + # Check if we received pre-computed eigenvalues (1D complex array) for Wasserstein + precomputed_eigenvalues = False + if score_method == "wasserstein": + # Detect if inputs are 1D complex eigenvalues (torch.Tensor or numpy array) + is_A_complex_1d = ( + (isinstance(A, torch.Tensor) and A.ndim == 1 and torch.is_complex(A)) or + (isinstance(A, np.ndarray) and A.ndim == 1 and np.iscomplexobj(A)) + ) + is_B_complex_1d = ( + (isinstance(B, torch.Tensor) and B.ndim == 1 and torch.is_complex(B)) or + (isinstance(B, np.ndarray) and B.ndim == 1 and np.iscomplexobj(B)) + ) + + if is_A_complex_1d and is_B_complex_1d: + precomputed_eigenvalues = True + # Convert to torch tensors if needed, then to (n, 2) format [real, imag] + if isinstance(A, np.ndarray): + A = torch.from_numpy(A) + if isinstance(B, np.ndarray): + B = torch.from_numpy(B) + + a = torch.vstack([A.real, A.imag]).T.to(self.device) + b = torch.vstack([B.real, B.imag]).T.to(self.device) + # Store for compatibility with score() + self.A = A.to(self.device) + self.B = B.to(self.device) + + if not precomputed_eigenvalues: + # Original logic for matrices + if isinstance(A, DMD): + A = A.A_v + if isinstance(B, DMD): + B = B.A_v + + assert A.shape[0] == A.shape[1] + assert B.shape[0] == B.shape[1] + + A = A.to(self.device) + B = B.to(self.device) + self.A, self.B = A, B + lr = self.lr if lr is None else lr iters = self.iters if iters is None else iters - score_method = self.score_method if score_method is None else score_method if score_method == "wasserstein": - a, b = self._get_wasserstein_vars(A, B) + if not precomputed_eigenvalues: + a, b = self._get_wasserstein_vars(A, B) device = a.device # a = a # .cpu() # b = b # .cpu() @@ -448,25 +480,35 @@ def fit_score( score_method = self.score_method if score_method is None else score_method if isinstance(A, np.ndarray): - A = torch.from_numpy(A).float() + A = torch.from_numpy(A) if isinstance(B, np.ndarray): - B = torch.from_numpy(B).float() - - assert A.shape[0] == B.shape[1] or self.wasserstein_compare is not None - if A.shape[0] != B.shape[0]: - # if self.wasserstein_compare is None: - # raise AssertionError( - # "Matrices must be the same size unless using wasserstein distance" - # ) - if ( - score_method != "wasserstein" - ): # otherwise resort to L2 Wasserstein over singular or eigenvalues - warnings.warn( - f"shapes are not aligned, resorting to wasserstein distance over {self.wasserstein_compare}" - ) - score_method = "wasserstein" - else: - pass + B = torch.from_numpy(B) + + # Check if we have 2D matrices or 1D eigenvalues + is_matrix = A.ndim == 2 and B.ndim == 2 + is_eigenvalues = A.ndim == 1 and B.ndim == 1 + + if is_matrix: + assert A.shape[0] == B.shape[1] or self.wasserstein_compare is not None + if A.shape[0] != B.shape[0]: + # if self.wasserstein_compare is None: + # raise AssertionError( + # "Matrices must be the same size unless using wasserstein distance" + # ) + if ( + score_method != "wasserstein" + ): # otherwise resort to L2 Wasserstein over singular or eigenvalues + warnings.warn( + f"shapes are not aligned, resorting to wasserstein distance over {self.wasserstein_compare}" + ) + score_method = "wasserstein" + else: + pass + elif is_eigenvalues: + # For eigenvalues, different sizes are handled by padding in _get_wasserstein_vars + pass + else: + raise ValueError(f"A and B must both be 2D matrices or both be 1D eigenvalue arrays. Got shapes A: {A.shape}, B: {B.shape}") self.fit( A, From 788918d0d54a334ddb73aef39e63cf42b6f7f6f6 Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 5 Nov 2025 13:48:42 -0500 Subject: [PATCH 36/51] add the koopstd tutorial figure --- examples/dsa_koopstd_fix.ipynb | 505 +++++++++++++++++++++++++++++++++ 1 file changed, 505 insertions(+) create mode 100644 examples/dsa_koopstd_fix.ipynb diff --git a/examples/dsa_koopstd_fix.ipynb b/examples/dsa_koopstd_fix.ipynb new file mode 100644 index 0000000..98bfc7b --- /dev/null +++ b/examples/dsa_koopstd_fix.ipynb @@ -0,0 +1,505 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ef5fb65a", + "metadata": {}, + "source": [ + "In this notebook, we'll apply DSA to the setting of the Lorenz attractor, with different parameters governing the behavior. Zhang et al. (2025, ICML) used DSA on this setting with limited success, but we'll show here that it actually does work (and my pull request on their repo for an explanation). We'll also use this setting to illustrate the number of different ways GeneralizedDSA can be applied with different DMD operators. There's no control data here so we'll focus on standard DMD models" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8b92fb80", + "metadata": {}, + "outputs": [], + "source": [ + "#default imports\n", + "import numpy as np\n", + "import torch\n", + "from scipy.integrate import solve_ivp\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#dsa imports\n", + "from DSA import DSA, GeneralizedDSA\n", + "from DSA import DMD\n", + "from DSA import DMDConfig\n", + "from DSA import SimilarityTransformDistConfig\n", + "from pydmd import DMD as pDMD\n", + "import DSA.pykoopman as pk\n", + "\n", + "rng = np.random.default_rng(2023)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35270a13", + "metadata": {}, + "outputs": [], + "source": [ + "#lorenz63 class from Zhang et al code (thanks!)\n", + "\n", + "class Lorenz63:\n", + " \"\"\"\n", + " A dataset class for generating Lorenz system trajectories with different rho values.\n", + " \n", + " This class simulates the Lorenz system for multiple rho values and generates\n", + " trajectory clips for each value.\n", + " \n", + " Attributes:\n", + " rho_values (list): List of rho parameter values to simulate.\n", + " initial_state (tuple): Initial state (x, y, z) for the Lorenz system.\n", + " t_start (float): Start time for simulation.\n", + " t_end (float): End time for simulation.\n", + " dt (float): Time step for numerical integration.\n", + " period_length (float): Length of each data clip in time units.\n", + " num_clips (int): Number of clips to extract from each simulation.\n", + " data (list): Generated trajectory data.\n", + " \"\"\"\n", + " def __init__(self, rho_values, initial_state=(-8, 8, 27), t_start=0, t_end=800, \n", + " dt=0.001, period_length=20, num_clips=25, random_seed=None):\n", + " \"\"\"\n", + " Initialize the Lorenz dataset with specified parameters.\n", + " \n", + " Args:\n", + " rho_values (list): List of rho parameter values to simulate.\n", + " initial_state (tuple): Initial state (x, y, z) for the Lorenz system.\n", + " t_start (float): Start time for simulation.\n", + " t_end (float): End time for simulation.\n", + " dt (float): Time step for numerical integration.\n", + " period_length (float): Length of each data clip in time units.\n", + " num_clips (int): Number of clips to extract from each simulation.\n", + " random_seed (int, optional): Seed for random number generators.\n", + " \"\"\"\n", + " if random_seed is not None:\n", + " np.random.seed(random_seed)\n", + " torch.manual_seed(random_seed)\n", + " \n", + " self.rho_values = rho_values\n", + " self.initial_state = initial_state\n", + " self.t_start = t_start\n", + " self.t_end = t_end\n", + " self.dt = dt\n", + " self.period_length = period_length\n", + " self.num_clips = num_clips\n", + " self.data = self.generate_data()\n", + "\n", + " def lorenz(self, state, t, sigma=10, beta=8/3):\n", + " \"\"\"\n", + " Lorenz system differential equations.\n", + " \n", + " Args:\n", + " state (list): Current state [x, y, z].\n", + " t (float): Current time (not used but required by odeint).\n", + " sigma (float): Sigma parameter of the Lorenz system.\n", + " beta (float): Beta parameter of the Lorenz system.\n", + " \n", + " Returns:\n", + " list: Derivatives [dx/dt, dy/dt, dz/dt].\n", + " \"\"\"\n", + " x, y, z = state\n", + " dxdt = sigma * (y - x)\n", + " dydt = x * (self.rho - z) - y\n", + " dzdt = x * y - beta * z\n", + " return [dxdt, dydt, dzdt]\n", + "\n", + " def generate_data(self):\n", + " \"\"\"\n", + " Generate trajectory data for all specified rho values.\n", + " \n", + " Returns:\n", + " list: List of trajectory clips, each with shape (period_length/dt, 3).\n", + " \"\"\"\n", + " data_list = []\n", + " t_span = (self.t_start, self.t_end)\n", + " t_eval = np.arange(self.t_start, self.t_end, self.dt)\n", + " \n", + " # Calculate the index for starting valid data (after transient period)\n", + " valid_start_idx = int(300 / self.dt)\n", + " \n", + " # Store valid data for each rho value for later visualization\n", + " self.valid_data_by_rho = {}\n", + "\n", + " for rho in self.rho_values:\n", + " self.rho = rho\n", + " \n", + " # Define a wrapper function to fix the unpacking issue\n", + " def lorenz_wrapper(t, state):\n", + " return self.lorenz(state, t)\n", + " \n", + " # Solve the Lorenz system using solve_ivp\n", + " solution = solve_ivp(\n", + " lorenz_wrapper, \n", + " t_span, \n", + " self.initial_state, \n", + " method='RK45', \n", + " t_eval=t_eval\n", + " )\n", + " \n", + " # Extract solution data\n", + " solution_data = np.vstack([solution.y[0], solution.y[1], solution.y[2]]).T\n", + " \n", + " # Collect data after transient period\n", + " valid_data = solution_data[valid_start_idx:]\n", + " valid_length = len(valid_data)\n", + " \n", + " # Store the valid data for this rho value\n", + " self.valid_data_by_rho[rho] = valid_data\n", + " \n", + " # Calculate clip size\n", + " clip_size = int(self.period_length / self.dt)\n", + " \n", + " for k in range(self.num_clips):\n", + " # Randomly select clips from the valid data\n", + " max_start_index = valid_length - clip_size\n", + " if max_start_index > 0:\n", + " start_index = np.random.randint(0, max_start_index)\n", + " end_index = start_index + clip_size\n", + " period_data = valid_data[start_index:end_index]\n", + " data_list.append(period_data)\n", + " \n", + " return data_list\n", + " \n", + " def visualize_data(self, time_range=None):\n", + " \"\"\"\n", + " Visualize the generated data with trajectories colored by rho values.\n", + " \n", + " Creates a 3D plot for each rho value showing the Lorenz attractor trajectories.\n", + " \n", + " Parameters:\n", + " -----------\n", + " time_range : tuple, optional\n", + " A tuple of (start_time, end_time) to plot only a specific time range of the trajectories.\n", + " If None, the entire trajectory is plotted.\n", + " \"\"\"\n", + " import matplotlib.pyplot as plt\n", + " from mpl_toolkits.mplot3d import Axes3D\n", + " \n", + " # Determine number of unique rho values\n", + " n_rho = len(self.rho_values)\n", + " \n", + " # Create figure with subplots\n", + " fig = plt.figure(figsize=(4*n_rho, 4))\n", + " \n", + " # Create a subplot for each rho value\n", + " for i, rho in enumerate(self.rho_values):\n", + " ax = fig.add_subplot(1, n_rho, i+1, projection='3d')\n", + " ax.set_title(f'ρ = {rho}')\n", + " ax.set_xlabel('X')\n", + " ax.set_ylabel('Y')\n", + " ax.set_zlabel('Z')\n", + " \n", + " # Get the valid data for this rho value\n", + " valid_data = self.valid_data_by_rho[rho]\n", + " \n", + " # Apply time range selection if specified\n", + " if time_range is not None:\n", + " start_idx = int((time_range[0] - 300) / self.dt) # Adjust for transient period\n", + " end_idx = int((time_range[1] - 300) / self.dt)\n", + " # Ensure indices are within bounds\n", + " start_idx = max(0, start_idx)\n", + " end_idx = min(len(valid_data), end_idx)\n", + " plot_data = valid_data[start_idx:end_idx]\n", + " else:\n", + " plot_data = valid_data\n", + " \n", + " # Plot the trajectory\n", + " ax.plot(plot_data[:, 0], plot_data[:, 1], plot_data[:, 2], linewidth=0.8)\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e75af356", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB84AAAGmCAYAAAAd9K7EAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQe4FOXVgA9NEBCkiTQp0qUrig1rLDEaYzf2llhjNPmjJhqNxhI1JsYSU+w1UWOJmqixYVcEFAUURVGQpkgvIvA/70fOzXeH2d2Z2dm5u3vPm2dy5d7dndkp53ynN1i7du1aMQzDMAzDMAzDMAzDMAzDMAzDMAzDMIx6SsO6PgDDMAzDMAzDMAzDMAzDMAzDMAzDMAzDqEsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YEZg1a5ace+65sssuu8hGG20kDRo0kOeffz7n61955RXZYYcdpHnz5rLpppvKj370I1myZImda8MwjHrAM888I8cff7z07dvX6YFevXrJiSee6HRJGKYzDMMw6gdxbIqdd97Z/T247bXXXrVe9+abb8rpp58uW2yxhbRo0UI222wzOeSQQ+SDDz7I6FsZhmEYdWlTLFu2TG644QbZY489pFOnTk6/DB8+XP74xz/K6tWr1/vcNWvWyJVXXik9e/aUZs2ayZAhQ+Tee++1i2gYhlFl5LIn2Jo0aVLrtT169Ah93cknn1xnx28YdUmDtWvXrq3TIzCMCgCHFg6uPn36SPv27eXVV1+V5557zimgIBMmTJBtt91WBgwYID/4wQ9kxowZcvXVV7v3/+tf/6qT4zcMwzCyY6uttpL58+fLwQcf7PTGtGnT5Prrr3cOL3QECVWK6QzDMIz6Qxybgt999NFHcvnll9f6fefOnWXXXXet+fdBBx0kL7/8stM5BD9mz57tdA5Ju6+99poMGjQok+9mGIZh1I1N8e677zr5v9tuu7ngeatWreTJJ5+Uhx56SI4++mi5/fbba33ueeedJ1dccYWcdNJJMnLkSHnkkUfk8ccfd8Hzww47zC6jYRhGlfD000/LnDlzav1u6dKlLhj+7W9/28l+P3Depk0b+clPflLr9SRvbb311pkds2GUCxY4N4wILF68WFatWiVt27aVBx54wBkuuZxcKB6MmClTpjiDBf761786owTjBUPGMAzDqF7GjBnjuo40bNiw1u922mkn+cUvfiG//vWva35vOsMwDKP+EMem4HdffPGFC4jkg64lBFc22GCDmt9NnTpVBg8e7ILqd911V0m+i2EYhlEeNgW6gsAInUd8qFa/9dZbnU7o3bu3+93MmTNdpTlFHgThgXoqPvPjjz+WTz75RBo1amSX1jAMo0rBNjjqqKPk7rvvlu9///u1Auck3D722GN1enyGUS5Yq3aj7Lnvvvvcwr5x48bSoUMHOeuss2TlypWZHgOtrnBwFWLRokUum+vII4+sCZoDWb4tW7aUv//97yU+UsMwjPpNOeiM0aNH13Jw6e/QI5MnT675nekMwzCM+qUfotoUPt98803ekU/bbbddraA5UJlIAMXXOYZhGEZ12hR0MAkGzeF73/ue++m/lupyErhOPfXUmt/RiveUU05x3RLphGIYhmFUhx4J45577nHjnb773e+G/v3rr792VemGUd9pXNcHYBj5oKXUscceK/vuu6/89Kc/de0Gf//738uXX34pd9xxR973MueJrRBk09KKJA0mTpzonFtUffjgzBo2bJiMHz8+lf0YhmEYlaUzCHqw4dhSTGcYhmFkQznrh3wwpxzHFg6sjh07ug5Wv/zlL9ebSRiE6sGw6kPDMAyj+myKXDC6A/zX4pNCrzBa0Efb8PJ3qtwNwzCM6tMj8+bNcwV/hx56qNMFQZ599lk3DmT16tXSvXt3F+w/88wzY+3DMKoFC5wbZQsOIuZq7Lfffi4rFk477TRXyX3jjTc6xcMcp1xceeWV8qtf/argflAEtKNKg1mzZrmfnTp1Wu9v/O7FF19MZT+GYRhGZekMjCSOEQNFMZ1hGIZRespdP+Ri8803d/PQablO1Qet3WnLSzD9b3/7W9730nqRdrwXX3xxasdjGIZRH6hEmyLX9+C1VDsyx9y3P0jEosrcR31Yn3/+eexjMgzDMCpDj2BDUPB3xBFHrPc3jonEqX79+rkA/2233SY//vGPnV74zW9+Y5fYqHdY4NwoW/7zn/84QY1y8TnjjDOconniiSfyKhrao0fJlN1www0lLZYvX+5+Nm3adL2/NWvWrObvhmEYRv3RGcwixPA55JBDZNddd635vekMwzCM+q0f8nHzzTfX+jezCJlJ+5e//MVVf4waNSr0fVOmTHHfddttt5Vjjjkm1WMyDMOodirRpgjj9NNPl0mTJsnjjz/u2gT79kcuf5X+3TAMw6hOPUKbdtrGf+tb31rvb48++mitfx933HGy9957yzXXXOOOvWvXrrH3ZxiVjAXOjbJl2rRpNTP6gtUXzHkqlFXVq1cvt2WJKq2wmSUrVqxI3aFmGIZhlLfOIIDBfMFBgwbJX//611p/M51hGIZRf/VDEqheIXCOQy4scE5b3n322Udat27tKtRp4WgYhmFUt00R5KqrrnK64pJLLpFvf/vb69kfufxV+nfDMAyj+vQIx/Xqq6+6xCo/oSoXdCYhWffJJ5+U559/Xo488sjUj8kwyhkLnBtly/z580N/H2wpVWj2UyFwKJFtlQba3krb7/rwu86dO6eyH8MwDKP8dcZnn30me+yxhwtgkFW80UYb1fq76QzDMIz6qR+S0q1bt5zfaeHCha4qZMGCBW48lNkdhmEY9cOm8KG17jnnnCMnn3yynH/++ev9Hfvjueeek7Vr19b6TurDMt1hGIZRfXpEq80hrE17EtvDMKqdhnV9AIaRizVr1rifU6dOrfX7Dz/80P2tR48eeU/e1Vdf7YyCQps/76lYyP4la2vs2LHrzTeZMGGCDBs2LLV9GYZhGOWrM2jNhYOLig4ydDVI7mM6wzAMo/7phzQqWIJOMioF9913Xzf//LHHHpOBAweW/FgMwzCqkUq0KRRm6Z544olywAEHyA033BD6GnxSy5Ytk8mTJ9f6/euvv17zd8MwDKN69IgfOKfqPde4pzi2h2HUB6zi3Ch7WPBjKCjXXXed+0lFRT7qYh4hGcC777673HXXXXLBBRfUZALfeeedLlvs4IMPTm1fhmEYRnnqjKVLl7q2iDNnznQVHcEWXYrpDMMwjPqlH6KyaNEiN4PWn0NLdeCvf/1r99977rlnze9Xr14thx56qGu9SNCE2eaGYRhG/bEpdP75YYcdJqNHj5a7777btQMO47vf/a5rvcuc3euvv75Gv9x0003SpUsX2W677Qoel2EYhlEZekQZP368S5giVhEGFeX4p/wxT6tWrZIrrrhCNthgA9lll10i78swqgULnBtlz8cffyz77bef7LXXXs4hRFD6+9//vgwdOjTTmSDqqHrvvfdqguEvvfSS+2+/Bdall17qjI2ddtpJfvCDH8iMGTPkt7/9rVOWfAfDMAyjunUGra/eeOMNOf74451x4ld0tGzZUvbff/+af5vOMAzDqD/6IapNMW7cODn88MPd1rt3b1m+fLk89NBD8vLLLzv7YsSIEbXmnj/66KOu4hynF9/Lx+YRGoZhVLdNMX36dHestAE+6KCD5P7776/1OUOGDHEbdO3aVX784x+7OegERahYfPjhh92IDwLuftDEMAzDqGw9oiDf87Vpx5bARkGH9OzZ09kUVKi/++67ctlll8mmm26a6vEYRkWw1jDKlAsvvHAtt+ikSZPWHnTQQWs32mijtW3atFl7+umnr12+fHnmx8Ox5NqCvPjii2u32267tc2aNVvboUOHtaeddtraRYsWZX7MhmEY9YVy0hndu3fPqS/4WxDTGYZhGPVDP0S1KaZNm7b24IMPXtujRw9nTzRv3nztlltuufamm25au2bNmlqft9NOO8WyUwzDMIzqsimee+65vHqA7+SzevXqtZdddpn7jA022GDtFltssfauu+7K9LsZhmFUK+WkR1Tmd+nSZe2IESNyvmbs2LFr9913X/c69ELLli3X7rDDDmv//ve/Z3qshlFONOD/6jp4bxhhXHTRRfKrX/1K5s2bJ+3bt7eTZBiGYeTEdIZhGIZh+sEwDMMoBrMpDMMwDNMjhmGED70xDMMwDMMwDMMwDMMwDMMwDMMwDMMwjHqCBc4NwzAMwzAMwzAMwzAMwzAMwzAMwzCMeo0Fzg3DMAzDMAzDMAzDMAzDMAzDMAzDMIx6jc04NwzDMAzDMAzDMAzDMAzDMAzDMAzDMOo1VnFuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrLHBuGIZhGIZhGIZhGIZhGIZhGIZhGIZh1GsscG4YhmEYhmEYhmEYhmEYhmEYhmEYhmHUayxwbhiGYRiGYRiGYRiGYRiGYRiGYRiGYdRrGtf1ARj1i7Vr18rq1atlzZo10rhxY2nQoIHbDMMwDMN0hmEYhmF2hmEYhlFqzDdlGIZhmM4wDCMXFjg3MoNg+apVq2TFihUueN6wYUNp1KiRC6Cz8d8WSDcMwzBMZxiGYRhmZxiGYRjmmzIMwzDKIZ4xa9YsmTNnjvTr18/iGYZRD7DAuZFZJu8333zjlA0Bc35HkJzfoXw0YE7wvEmTJu4nG681DMMw6g+mMwzDMIw4OuPrr7+WuXPnSrt27czOMAzDMBLbGRR5vP/++zJw4EDnlzLflGEYRv0lqDP4uXTpUotnGEY9wQLnRsmVDIFxFA1gmPDfGCb8twbGeR2bBdINwzDqL8XoDF7Hf7dp08aSrwzDMOqRzliyZImMHz9e9thjj7w644svvpAPP/xQttpqK0vYNQzDqGdEtTO+/PJL800ZhmHUc8J0ho6atXiGYdQPLHBulAyysagA0UxeFAyKJwytOM8VFAH+5rd1t4p0wzCM6qFYnbFw4UL54IMPXEAETGcYhmHUH52RS1+A39mK1/PT7AzDMIz6Qxw7A/g7ficw35RhGEb9IpfOCNMdFs8wjOrFAudGyVqZEPDmv/2srKjkUjx85rhx46R79+7SunVrC6QbhmFUOGnpDNUXtFT0dQYGj+oUS74yDMOoPp3h2wv58J1euewM0xmGYRj1x85Yvny5+13Tpk3dv8NsENMZhmEY9QO1B7SrYdrxDLMzDKOysMC5kVkrE4ircMIUz8qVK2scY6rQ9DV+UISfSfdnGIZhVJ7OUN0QZqyQLWw6wzAMo/p0RlRdket1pjMMwzCqU2fQdh1atGhRy87gbx999JHb+O+NNtrIjXuiOEP/ngvTGYZhGNVrZ0ycONEVY/Tt23c931ShbiVhmM4wjMrFAudGaviZvPmcWGkFswmOK35QJCyDS4PpFkg3DMOoTp2R73XaolcxnWEYhlE9OsMPhBTSGVGcXaYzDMMwqkNnTJ8+XTbYYAMXAFFWrFgh77zzjvs5cuRIZyMw8umrr76SqVOnute8/fbb0rZt25pgum9HBDGdYRiGUV12BoTZFIXGQ0WhkM6YPXt2TTKXxTMMo26xwLlRNDojkA3iVH4kIVf7rEJBERQcryFzTGekWyDdMAyjOnRGnOxf0xmGYRjVpzOitGpPgukMwzCMytUZvm6YO3euqybs0KGDjBgxoqaV+6abbuo2/v3cc8+5/168eLFMnjzZ+ZNatWrlghgaSNeuVmGYzjAMw6he31SxgfNCOmPevHnu3y1btrR4hmHUMRY4N4pCg9P8hHwGRJpEcYxFCaQH591aIN0wDKP6dEYhTGcYhmFUrs6I05kkDWeX6QzDMIzK0Bkq9/nd+++/LzNmzJCBAwdKly5d3Gt07F9QnxBY79atm3svc9CpRl+wYIF8/vnnLsBC8HzjjTd2VelUBqYRSDfflGEYRt3bGchk/V2QrGIG2kEXTGcYRt1hgXMjEb7g5mdwLm0pSbIf31hRhxnHjaHCzHQzVgzDMCpbZ6QVECmkM2idtXTpUunevbs5uAzDMMpAZ/it2qN8dtqYnWEYhlF35NMZ/GT9/tprr7l/b7fddm7eeZTP1Pc3b97cbQTb+f2yZctcIJ2NQDz7JJCuFelUCUYNpJtvyjAMo7zsjHx+pTR9TrkI2jymMwyj7rDAuREblAQKhpZWEDcAkkawpBhFpfsvZKxgEKmRZBXphmEYlasziiGoM9ARtG7ke1nylWEYRt3rDD9wXihYUWqi2hlWXWgYhlF6nUGy65dffimbbbaZ9OvXbz0dkWsMYL6gCYF3tq5du7rXsQ8NpDNTnd9Rje4H0nPpH9MZhmEY5WVn5Ks4T2PGedTjDMN0hmFkiwXOjVhoVhZKJmnFYJgCGHzpGPdz4i9GF3x/KaoUgw4uNlp5YQzRpgvMwWUYhlEeOqOusn91P2E6g42ACIERMJ1hGIaRjc7wA+eF9EAWesLHdIZhGEb2OoN26swnnz9/vrRr104GDBgQWSfETfAlMM6mrd2XLFlSE0j/+OOP3WsIoGswnaB7nEB60M6g+xWfxdx1GztoGIaRrp2Rz69EohTv5+91XeABZmcYRmmxwLkRCZQCygEDJOvW7LmOp1TwvXTTSnPfWPErRZo0aeL+jsFS1+fEMAyj3HQG7QtnzZolw4cPz0Q+Zh0QAdUX4OsL0xmGYRjxdMbUqVOlffv2bl5sks4khXRAOazTTWcYhmGU1je1aNEiefvtt2WDDTZwhRC5KgcL7SMJHAc6jI0qd/ZNpyqC6FS+f/TRR85e0Gp0AuB0OMwXwAnaGcxZxw/VtGlT800ZhmGkHM8IC5zzPuwUuorw3y+99FKtziL55Hg52hl02CXhq1mzZhbPMIw8WODcKHmb3Uonn+JZsWJFzWs0kK5Zv/XtPBmGYQR1hramzbI9bl1jOsMwDCOZzpg5c6YLNlBFF1fu6mcVel1dJFgl1RnLly+XiRMnysCBA12AxOwMwzDqO/l8U/zt008/lQ8++EB69uwpm2++uXz44YcuUFBXNgXHx/xzNsA2IrBPIH3OnDkuEIP/SIMvbAQyCgXS1fdkvinDMIz0R0D59gJBZpKxkN+syadMmSJDhgxxHU3mzZvn9ExQjm+44YaJL0uaOiiXnfHee+85HcmxWjzDMHJjgXMjLygXlExWVea0bC/Urr2ugyNRgyJaiW6BdMMw6qvOUBmZFeUWEAHTGYZhGKW3M9TJxVqcz8vlsCpHPZFLZ3BOFi5c6P7b7AzDMOo7+XQGibrvvvuuk5lbbrmltG3btuCs2rpIsuK4qVJkI7jPd9JAOl26GBdIpXwwkJ7vWM03ZRiGkZ6d4esARmOgWzp16iT9+/evWZf7CVFhcpyEV1+O8+84lEoH+TpD4xUWzzCM3Fjg3AgFwUkbEzYot+rpcnJ65TJWUM4WSDcMoz7rjCyr+8pJR6WhMzTxAOeZdTExDKM+6Ax+JtUZvI+KdebJIk9pmei3wkWWVoqeUPRcqD4wO8MwjPpIId8UwQqqAelYsv322zt5rySV+1nZL37bdg3ALFiwwG3oNCobCZz7M9LzHZv5pgzDqO8UG8/QhKtJkya50RiDBg2STTfdNLIcZ78E2NFNn332mfucMLukHDCdYRj5scC5sR4oCM3KCgrSYiETmJYgfLY/C4Qqc6rNo1CObRajKh7ahBEYQXGzWUW6YRjVrDOyltflrBvi6gwMLZxlW2+9tekMwzDqjc5IMouWzwOcU8OGDXPV5lr5QSB96dKlbo4fQRV1prEGr0TMzjAMoz6RT2cgz5kZjpzv06ePdO/efT2/VRJbpC6TrLAF2rVr5zZAXxFE9wMwHB9Bdb5XoQCM6QzDMOoTacQzeP8XX3whLVq0kO22287FLOLoFGwMX47zeSrHP/nkE1myZIn7bD+QzugNfx91hekMw6hNZXoMjJKgwV0EOQt2MqrSFNjM/yATmLmFOK+Cs0CqlaCi1qAI2cRsKGQcel26dHHKUlu8p5mwYBiGUSqdka/9VbVWnJfyO/mzC/mp7bNUZ5CA5c+hMp1hGEZ91hk4oiZMmOD+e/jw4c7GQFZ26NDBbZq4y+uwPeDFF190QXR1WNFqEVlajXaG6QzDMCpZZyxevFjGjBkj3/rWt5zeUChGeOedd9zPbbbZxvmYwkgaOC+XZFzsgPbt27sN0KFvvvmmO0ZNDMsXgAliOsMwjGpEdQZyUWViEv8QSUnTp093nT7QLb7eSaofkMlhdgmBdJK/mKHu2yW6li81Uc6P6QyjvmOBc8OBUGYRjoMF4c38DWZ4pIGfCdyvXz/3uewnONNJofL87wd0yDkLpNKDyX5QBJYvXy5z5851iQpkFOvfgzPSLZBuGEY56ox87a/ScDwlmUVVLajc93WGHxQxnWEYRn3VGbwO2wIbo3fv3jXJuGGfSzXeJpts4gLkc+bMkVGjRtU4rCZPnuwcWPxNbQ8CMEFHWV0St72k6QzDMKpJZwT1Ar6TiRMnuiDEiBEj8nYQKaRXcsnXcrUpCMDwfTt37uy+f64AjLZ152eh82M6wzCMatEZrPORjW3bto31GfhV6OhBki1FbSSehtkCxYyVCtolbMC+kOFszEcnIQxZjnxXu6RcEnxNZxj1DQucGzXVHygZbSGelqEQlgmsc0aCs0C27r5Y3pi+sMYg0FZUwQzacjZkkqJVhX5QhPPEdckVSC8nh55hGPVXZ+Rz6FdjMDsrcp23XMaK6QzDMOqLzsCRhH1Bpd3IkSOdfTBt2rTI+kYThNl4D0msGnig0gR5qoF0HG9UsVfqutt0hmEYlawzNFig1YQffPCB8xMNHDjQBTcKUWmt2tMMwEydOtX54bSSEV3Jli8AYzrDMIxKj2fEhWI+uuNiH2y//fYuOQvZmRXsl0I6naM+fvx4J9uxT5ixjl1CLEXtEmR6sXZJWj66fDoDHUTlPoleFs8wKhULnNdj/Io1v2ViWoFzWpDj1GKuR6FMYLj5yKE1c86pHAnOAsEhhoNMg8YoEpxalTqjMJdxFsdY0Ta9Fkg3DKOudEY+eE2SebVJqMYgfZz2WaYzDMOodJ0RRY5/+eWXzr7A+c/cQW1JG+W9uarcmV3IhmOHz6DKQwMPn376qfudJvGykdRbSYEVH9MZhmFUmm8KmAn73nvvuf9G9iOHo1DprdpzkUsHBQMwBH9Un02ZMsUlnmkAJkolo+kMwzAqSWewRfU/8RkkYlHlTUfczTffvOYz8hUxlFo/IJOJdXTt2nU9u2TGjBnu+/mdsgikl4td4usM9I12A7N4hlGpVH7E0Ui9ZWKxigAhTrtE5oIMGDDAZQIHA8OFWL1mrTRq2GC9WSBk0DLHkOMm2xhDIM7CvxzhXBeqvskXFAH+5lejWyDdMIy6aLNbl63ao8rUYikXoyQXpjMMw6hUnZEv2So4+qlbt27r2RdR1tT6WfleQ0CGTR1WBGxwVs2fP98l8nKc2gaXjaB7KXRDVvMNzc4wDKOcfVPwxhtvOJmM/I9TaVdtrdrjQrWf32HFD6QHKxmjjCqJqjN4Db48LfSo1K4thmFUls6IWgjI+999911XqLflllvWau2eT2/4sq+UfiHdf5hdQkGhyvFPPvnEvca3S8opwVe7AFg8w6hULHBeD0G5oCRyVX/wb1VAcaGVCC1OWDgzP5DMpyQMu/xFmfiL0aEZtFSad+zY0VWF+K0VyUD2Wytq5lW1LdJzGStcUzK6wALphmFkpTMKyausHE/lYhykRanbZ/k6g6DQhhtu6HSmJV8ZhlFuOiNs9FPU9xYrX/lcZCPbZptt5r7X4sWLne3BHESdre5XpCNPKxWzMwzDKBedoTNnIWpr9vpScZ4Evhf6ic3vsKL+NCoZuR7a0j2KPy2XzkBnE4giYG++KcMwsoxnFJLfyDziFoxiojU7MYaon+En4ZbK/1QoCZjjZiOJmPOgCb505SLJ2B+Jq3ZJXfjKws6h2RlGpWGB83qEZoKy8d+5nFlJW7UzB2TixIkuqE2leZLK778eMVhOvHti3tf4SkwX/v6MQs28ouUKSsTPvEK5lFtwpViFG6Z4dM6LZv3qDHWtSNd2KYZhGMXqjFI7njCOdGZVoX3pcVeLfCvF9wjTGWQqt2/fvmb0iekMwzCS6gxawbIuT7LmDtMZBKexL5BRhUY/JWnVHhdkJ0m6bD169HD6idmI2B6zZs1y7R5J9PUdVvy7GOpSp5mdYRhGXdgZOnNWAxp+NWAcqn3GeTH4lYwkJfiVjASWdFRJHH+a6gxQv5P5pgzDyMo3la9Vu/o9mL3dp08ft47P9RmVkjzFeSChmK179+7uu6tdMmfOHPdd6fzhy3FN8M1C10UZ02XxDKOcscB5PQHhiYKJ0jIxrpLgs3ESkaG6xRZbuOzVfGgWahjb9GhTcH/5jltnFAYX/my0duQ1viOrVK0V6xK+j5+04AfSaS+J0sShqYF0DaZX23kwDCMbnZGPYo0O2uLiNNN5fDjNorQRrAayrtRX55avMzjvasyYzjAMI4rOIHjcrl27onUGn4mzB8d9lEpDfW8+O6MU8tWv6gDOw8KFC2uSeKmWxN7w7Q+dy15tdobqDCryNRhjdoZhGHHsjLCZs0899VRiuV3IFsmlMyolaJImwUpGf1SJ70+L0hJYE5mj6AyzMwzDSMs3lasQEHlDJwxiBFtvvbWTY/lkYZa2RJqfr+Ok2NChnDO1S/wEX2QwvjaC6MUm+OYiSUGL6Qyj3LDAeZXjL0z9xWs+8mVoBaG1E0ENXr/ddtu5hXNa/PDeifKnwwcnViK5WpigHHK1VmQGVNYB5Czm8aqxQkW+njvfWEG58hqdQWWBdMOonyTRGaUInPMeEn3Yevfu7Sr7NHN25syZznDynTa0EYwyu7bSyEof+XooirFiOsMwjHw6o9gAhz/6adttt3Vr+SjvTeM1xYJtQeIAG3ButA0uQQfmKfJ9VH+hy/JV0Zc7YTqDNpEkUvtVJGZnGIZRyM5gncn4veDM2TT0SqnfU42EjSrxWwJjp2mQJliYksvHZXaGYRiljmcE5TfyiqA5Moq4RaEE1qit2isB1t/oUtWnmuCLPULXYCrw/QRf5HmwdX1S0jhHhXQG/+b6UhzIcVs8w0ibyrXSjYL4rUwgagAkaqv22bNnO2GLY6Rfv36JWrPn45VpX6Xq9PJbmNCSBWEblnmlCiNq8kAloS1togRF/Gp0C6QbRvWTVGfkA1kSV5auXLnSGTYETphly0Ie+USgQefx+d1Epk+f7t5HcB34mx9IN4pL4Irq4DKdYRj1i1w6I+nIJ/0MqpUJMG+66abSv3//yPZFlEBHXTi7cM516NDBbYDcVP1FRT1z29FZan+gy/Q7V4pTLuwcoxP47qYzDMOIYmcgE0mYQh4GZ87GKewIk0nWqr10LYHR2WGFKdhzfrAr3/UxO8MwjLR8U76+4DOQSwSHiVlQUBf1MwoFzktJKfehCb78xM6i+NFP8MWXlmaCb9rfJagzsKMmT57svhM6x3xTRtpY4LxKUae2zoWNI6wKGRd8JvMLCTYPGjTIObbSZPx5O8rwy1/M+5o0HEmcF7+1It9LFQbtwcim/eCDD9y/08688slyHm/YvnzF47fHxLGHwWOKxzCqn2J0RprOKm3NjswdPny4W6SrsVSom8gXX3zhsk3HjRu3XjcRneNUSWQdMIl6zU1nGIaRT2ckrdTTmXx0sxo8eLCrHIhDnP3WZUAaW6Jjx45uU4ePBtJx/LD+JniuY0kqkVxdTMzOMIz6ST6d4XeZYuYsAdngmrTYhKxc70XeTpw40SXr6jgoTcStxMSlrOG6cL70nHF9tUMYdhndR/Cr+QGYQjaZ6QzDMIrxTfF63sf6Wkf+jRo1yiVlRaWaKs6LSfAl6QC7zE/wRY5HTWrOOlFZsXiGkSYWOK8yEEwoCQINCIskAZB8SoLgBMqHz6XFCZWAadO44f+Od/ClY2TiL0ZLFiD8/daKb7zxhjOgOI+lyLyqC6Jk/II5uAyjfpCGzsiHb1jk+1zfaRYnG9ivfkAfkU1MW18W+MFuIuoQYytFElQpqMukqiiYzjCM+kUUnZGk0whrbOwLEjaZZR43aB634rycYEwU35dN29Srw2rGjBnuNXT4Uh1WCR1V8rXoBbMzDKN+6QzW5zjlWY/7soHABl2m+MnMWQ3ABilFq3ZN1mWfXbt2dZ0IsRnQQ+ixOXPmOF8Pf+ffRmGQ7WprcX45r9hcOmqL4hu/wyNbvtm6pjMMo36RVjwDX9DLL78sm2yyiRv7EddvX8kzzuMQdm5zJfhSZIgMJ7CO701lOP+dL5BeaptFz5O/H7MzjDSprKifUVBgaFYWJA2A5GqF9fnnn7uZUwQ0+vbtW2cGRFbOIvaDEkDZxm2tWEkV5/nIZ6xgVHJOwNr0GkblwfPMApgWeziz0g6aRw2cB1uzJ62w088PdhPROU7a1h09Rksq32kT15iqlgzjtPVQFJ1BMgMBIPSnjQMxjOqzM+K21EUmEBjGwc5aOmlSaqVUnBf6DiSBsZFAwPl+8cUXncxEj+loEn+eLPqs3ALpUXWK2RmGUT90Bt00kFckCim09mb9jw0yYsSIvLI/zcC5n6yLT4sxUNgK/ATskfHjx7t1K7qJ4/dlbiUkL5XTiMCw2bra4XHSpEk1s3X1HOdLbjadYRjVSxrxDOwPOhDS+YLuVSrXkx5PXVWcl5OOCSb4+p2yiBEh17VTlupIjRVlEetQXROG6QwjDSxwXiVoK4o0KgaDrbAQhBg7c+fOlaFDh9YEkuuSunB4xWmtqJlXUZILsvwuxSouX/Gw8Xm6BQPptErhNRjBpQjIGYZRvM5Qx4XKtbQpZFhg2OA0w6GirdmLJbgvneOk3UQwyFR200IQB1kaSVBpk7VuKAVhOoOKEwwwdKrpDMOoPjsjaktdDaZQ1af2Bf8uRh6V44zzYtDjJYhO+2KOm2Q39Bf6k8CPnyymo0nqes2dRhcTszMMo3p0hq8X+B3j8LA/Bg4c6ORbIdKacc4xYXfQ5UQr3IMjoZChrFFJ5kIv8Vq1G6ic5/N8mUvgN2uZWwk6LEwPhNlkJHGzhSU3E0z32+8GMZ1hGNUB8p3xDsjYIUOGJJKpVJnTRQQ/PQlZxQTN89kyWRa9lRt8d3QkG+eXY9ROj+pX5FpqIhQyPovK/DgjB8HsDCMOFjivklYmKpDSCFD6xgXOmQkTJjjjYfvtt6+VJVzM5xeC9uy0aQ9r117XzqCorRXjZCeXa8V5IfgsX/n4gXQCUgTTN99885pAulYXWiDdMMpHZ2SRLRvch8oIxmD079/fOaeKlY9RX4cswhGmSWDIKdoJhiVBaWV0tXdYyarzia4v0AVcB19nYOTqa0xnGEbl2hlRKgMZ/YR9gSxg9JPOPE2jqjDK8VUKwXOh3bDYCKTjnMJWQ4eRgEBHLGSrH9RJw3aLC8eVVheTXHaG6QzDqBydoSM8cLAj+/kbo5UYgxeFNGaca2t2/DPoHQ3I5uqcovqEY2Sj66LKXGwGKuaZ/4oeU5uhrmRuORJFH4fN1iWIrsnN3C9xRiWazjCMytUZmkiTZP1I9yoSbwjmIk9IeErj2MLwq6nrO1wrkp3Y8OdxTrDxtLU7+hLbhGTfUnXKKsaPZTrDiIIFziuYtFqzB+Ez+EyyhZhh0aNHj5rgZ7lQbkoq2FqR4/Ozk/O1VqykivM4igfDUrPMzcFlGOWpM3BEJ63giILqDX8fBKo1G3jUqFEuMJ0mcWUqs/XyJUH5WbNsWcnsatINuQIqZqwYRvXZGflmnGvXCZKUCPz27t27ln2RVlVhpdkRSeHckejF1rNnT3ettA2uzpMliOMH0vO1wS13nWI6wzAqU2fwk0Az1YQENvr16xeru1OxPhMCsm+99ZZrzb7ZZpslTrDyZS4+Mr4rLYEJytelzC1X4uoBzlUwuVkD6ToqMRhILzRbt1DyFQEdPlNHxViRh2HUjc5I4pfivchdAue0ZqeLIoUZxa7zy2HGeakpxfFz3vDtsaFr0bsklaE7kbUkRHGd0+yUlabNkU9ncPzcW9xnVuRRv7DAeYXiZ/L6D3caaLsNFqe0zm3fvr2UE5VQKRLMTg62VvQVBtdSg8tZzP/IsoJRW7MVqhTRlu5mrBhGtjqj1Mk7wYpz5B9Bc/RKoXmGSfdVqiQonGJqiCGzCKqXukVjtVWcF9pX1KCI6QzDKF87I1fwm3a4VIOgB3LZF6wZ2W8S0u5OUokgG3PNk/30009jt8GthC4mpjMMo7x1BnKIjTU0LXiTjIdKmlRFwJy28BwfyboER6MSxT7yAwDA99RAr7Yej1MxXU2koQdIbg4blcg5fv/9911gnQ4sem4LjdsK0xkkPJA8zb70NWZnGEb2OiNf4m2+7lU8r3TH9btXFVsYUshHlpUPrRrgumy66aY1nbJINkOO0ykL/UzCVDGdskppc/g6QwtswgoDTWdUN/Vj1VZF8ICq8QFpB81xriC8EGijR4+uWUCmSZLjDbZrr7TsrrDWiqowyI5D6L7yyislb62YdVVhsEtBLgcXr8Xw4TxosN0C6YZRep0R10CJi9+BgmQsKk0GDBjggtJpBzlytYUvhrAWjTj+5s6dW9OisVRtcau14lyTqqJgOsMwskWThZgziKM6iZ0R1lKXNS/OLeQjLXJzycmsWrVXoh2RhFzzZLE/mI/OtaYqRPWXVtxVkk7xMZ1hGOVlZ+jYP143aNCgREHzpK3atTU7yUKs1XMFzfO1ao8L8pOkME0MI3CvXay0YhqZq23d8Q3FqbyvJEqhZ/1RieB3CcOnho7TQLqe33w2hwbYgiOkzDdlGNnrjKhy3u9eRVVznz59aj3naYwizLeG1WMutS2Rha2SVZKrf21IcmLL1ynL7/ZYKCaVlc2h+wkrDDSdUd1Y4LyC4GFkMahBjjRbp/OwU4lA0JzWSDi4ShE0j4M/57zasq98hcG5J2iMIVnq1orlFhwJGteqeFCgbJwXVU4WSDeM9HVGVoFznGYYSKVozZ6lkcH5ImuWbdiwYXnb4uIUQ8ZXQovGumrVHhfTGYZRep2BDUAllzqm4+I7k3z7olevXm4r5IwqNnAehUoLnKdFcJ6s3waXa0RQh0CDOqwKVe+VW+A8iOkMw6gbOwMZwNg/dAktzWfPnl1Ud4u48p3EIDZasyPHxo0bF3t/aYAN4FdM+4Hezz//3NlGHJ/aDdhI1dI9JQs9oDYZ7f/Dxm1hp+n5ZeP8Bu1h/zhNZxhG3fmmolSK+92r8MXoejb4OVm0ajeK1wNhnbKwS9hYQ0yaNMl1d/TjIsG1RDG+pTQLA8HiGdWJBc4rAM1gYfHPwpAM1jQFA8rr3XffdcJpyy23rJnVVEqKPf5qUmKqTMIUht/mK43WilkHR+JWrfhteoKKh3Oifw+2Qkm784JhVIPOUMMk31zaNDJy80HVIpCINXLkyMSVbOXqRMq12Ed2U11PC7FiWjRm+X3KKakqLZ3B/cffcFiazjCM6DqjmIQqfX/QvlA5WeiZTiNwXig4b4S3wSXooDqMSh6/ek+DOlHkd7kEzuPqDL47P0kaMZ1hGMnsDF/2M5aJjhd0aSpGr0RtvUuF9zvvvOO6aWy99dYuaIpfq5BeCZNXpbCPgoFexiPqOCiSzMCvtMP/U46yNApZ64GwcVt6fnVcCb/T4hUNpIcFQ/zPNN+UYWTjmypkf8TpXmWt2suDuHo02LXF75RF10fWFkHfWpYV51ELAy2eUV1Y4LzM4eFEWGDQk1WFYAjLqkoKQgjlw6KRuSBkxbKfcgxMz1ywQrpsnH778nIgKOjD2nypwmA+OkaA31qR+yJKRUilVBUWUjw4tXguLJBuGLl1BuQLmuszVoqKcz6TNuYk/rCPfv36ZTbTLwv9lWsfuWQ3DjG/RaPfFjeX7K7mVu2lnkOlOoNuANqq2HSGYUTTGdp6rpjnkAAsI4hwbqh9EfW9VnFe+/pkiQZ1CByHVe+h24NBh1wBp0oI9gR1Bm2l0dPY2qYzDCO+nYGsoD2671vSZ60YeRYl0VdbsyOfCKpokUGSfWdRbcg+CIyzde3a1e0PGcQ5xB+Hz4c1rF9ppzN8K4G61gNh55eEZp2RToKz2sEk2nKvsmaJ0qLZfFOGkb5vyn+uglW8cbpXpdWqPddn+F21Skk5xmSSUIweCHbKCht/gl7kHmMNkLRTVqniG6YzqgMLnJcxmpWFktG5z2kFOBDCLBYJbPTu3du10PJbFJWydW9S9rrhDde+vT62TWEhTwt9Nm2tqAqDFmj8OzjPKUxhVHpwJJfi4Tl56aWXZPjw4S7zkO+OkuUnW5pjDQyjUnRGlOevFK3aWcDiuOJYaM3+2muvZaZTys1RH5TdnBuV3bSe8ls0hrUQzFJeZ7WfrBO4tENJoeQr0xlGfSOXzihGL6hjmqQVWuT69kUUil3jR3lvuemJciWseo8qTtVhGnQIq46s64BJUjhu0xmGEd/O0PboBHuR/d27d19vrmmxFef5ghh+a3Zm3vr7Tho4zxr2iQ+HjfPH+dJxUMzvxudDlxBkra5jy51y0gMcC3YWG/eIJiqMHz/e/aSdv45TVJ2G/ksrkG52hlHfiOub0udI7Xfg/RMnTnSyMIvuVYU+A18OhYd8J2QyAd18iaTlTF0Wm6Q1/oTrQUt3dCSdsgis+3ER/GxpxQLS6JoYRWcA34N7SvWGxTPqFguclyF+yzi/lUlaLXV5CFE+OLZoncvi0KeUgWm+DzNgyQbyZ8DmygrKNee8mkjiXMJo2nTTTd1WaF6WH4wptxnnxeK3aOe+JjjCv4PGit9u0RSPUV90RhTSTpSiFSMtEgkUDxgwwD13pW4H71PuiVUk9lDJp9V8uVoIohuRYVkGtLNqcQVZLf6D7RejOrhMZxj1WWckDXCofYEDmvVpz549Y39GMcEVlf/6TOeqci93PRFGOTjjOAaq8di6devmrpNW72l1JGts7A7Or1aBlMOxJ60mMZ1hGIV1Bs86a39+brPNNs4HESSNwHnY+8Nas6cl8+taT3DO1JcDnH+CR/jRWLOSgEtnL9+nllV3ryiUewKVJipwnkm4QLdpxT/2LAVGnE8/kF5Ip5nOMIzkvil9jcreXB1MonxOKVq105mC48HPxfoX2YBMRg6DygnkcaWtf0tJKc8DvjWuA/cKsS1/5FS+uEgSSjFLPUxn8OxQeMR6iriP+abqnvJZWRkFW5mkURmYq4WVT6mCHAQIyM4C2iWhZLRaWoVZlPl5lejwKjW55mUFgzHcWyiTLAyZfPOiSrEv0KB4WEU6hjXwNwuKGPW1NXsueV+sTPBbsw8cONBVpykms+O3EERXswGznKI6bMrduaWyOsuK80LriVxdTExnGPVVZyTRC7594cv/uBTbqh2b4vXXX3dzELEnsCvCxmKYHVE83CfB6kjOu+ou7gecnH6b4VzzKMsFv8opDNMZRn0DWclzjT+BLoVBnUGAkYQpRuIwzzxX4LYUrdqj+LWS7rscbRcdPcTGd9eOLtgN2GD4eKKOg8qCcg+cB4s92DhnbJxbrfgnCDNnzhzXJlp1mgbTC7XON51h1DeK8U2pPc570TnItbAOJlE+J82Kc35yLHRaojAEnzu6j2pz5AWyIph0gz7S+AY/CYDG3X81kIUeUBnud8oqFBdRPVloPEfYfkqJfyzcMzo+zXxTdYsFzssIFAQPRK6srGJbJ2oLK2bNUimQS0CUwlBgsYlRhQBD+ZH5o8Is1/w8VTI+VJ8/cNC6thzVQtrKJF8wRg0r7gPfkVWoDVUSsm7HC0FFls9Y0fZmlsFlVKvOiEKuWVJJW7Nvu+22bgFaV86ncnR0JW0hOHPmTJcpiywPOmzUEItrhJVLxXm5dj4xnWFUM1F1hl/xUehZ5TVUGn/88cc19gUz55K2kC1GhhM0x2HF2pcELg3i0rqP49EkXV0LGumiLW4JpONcZFSL2njoMzqOETj37Y+o1UNZwbORK/gWhukMoz7oDNb5OJzx4fjPCutSWqQib/Hr5NMXabZqL9SaPd974+yv3NFAetg4qKDeK7bSLgmVomdzVRH6Ff900OF50Nb52Gd+63zdCtllpjOMaqZY35TKJ4rt8nUwybJVO7YFfi5+sq5FjqrM8Dvp+Uk3vqxAR9IdBH+OLyuidAfJQoZmEdQuNbns1UJxEWxXXhM1LlKKivNc+wF9hiyeUfdY4LwM0JaCbJBLyfB7zdyKA0KeFlY4L1A+ODSyat2rRhUB8UGDBrnWjf5nh83PC7b9G9quobz9ZWUuxMstGKPGLfdSsA2VrzAKZc+Wa8V5IUUWpnh09k6uQLq2fzeMStMZUQi2xEramp05Q2TghlU2VHIwu67BgY+zJuiwIQiBUwzd6cvuOA7/+tiqPS6mM4z6qDP8GYP5np9ge161L4qxI5LoC7U1kI/YGf3793cdI5CP/FuTdAmiIz9Z7+EE8ytBSpFAmgaVqDv1mFk/c351HiX3n7ZPpDvNe++9V8uRSNA9qQ5LC9MZhrG+zmBt78t0KriQofwuLGG2lIHzKK3Zw96bZK1bafI3zjgoZC7yt5R6r9IqzgvBcxDUacHgGD60OMlhZmcY1UBavintWMT6MV8XkaxatcPLL7+cs6NKLh3hy4rNN9/c2R2sf/l+xDf87iC8JmwOdyXIznIKzkcdBeAXqYR1Csg3niOr+Ea+2IbpjLrBAud1jAbt/Icj10PPQxq3goM5HBgXCPvhw4dHymxKq1U7CgGjCmc/RhWL8yTCbOjQhTL6xok1r5k9e7YTYHPnzi0qUFAuZNHyI7ivYEYcVTkojFmzZiXKnq3LjCzdV5IFGq8Ptu7UZxLDXIPsvIb7TGekV9NCxqhenREFP0ASp50fr6eqEEfMFlts4SpNcmEV58nxr22Yw8bPmKWlO85LvzVxnFmH9bFVe1wK6Qyqn2gnxxrFdIZRqTrD1wtR7IugM6kYOyKuviBoT2UKa1laJoYFcPwkXSoOcIKx/uW8BFsqpt3Noz6Sq7MI90j79u3dBpx/1WE4EgnyBNsMZz2vN2udYXaGUQk6ww+c4ysg6YV1P11GotoOxdoCvJ9gOfK7UGv2sPfGDeRWetJvvko7LU7h2gULJ9Jen5e7z6SYcWV+6/x8yWF+EKbQPVtIZ/C5PHt8rtkZRjnA/aldGBjnkcQ35Y/8473olmJ8/MXKb96rc8sJfId1NYnzHfku2Chswe4gyAmdw60+HNbC1UIWejRp3CFsPIfGRcK6PSKHswqcR41tmJ2RDRY4ryP8RVDUByNO5pSvfKgCpJo7S0MhShViFLRFkg+CjfOmgQLfycLCtC5nOZU7YYaBbzTlyp5NUtWYZUJAWo6uqIonOCO93I1Co37qjChECZDkSopCVkSpNMna+VTJjq44IIN8IwwZpUYYCVB0m6EC1A9ChMnJNGbcR0X3U6mB83w6g+9GJwAclKYzjErWGfn0gp80lcu+KKayMM57Cd6ji9TWYL0aRf6zD13XBlsq+t081IEVtaViKamkdWbUkRzYErQY1jbD6Kx8Ooz/LrWNl6XOALMzjErQGfpMMHaPwoXBgwc7uRuHYkcOEjSnMoyOIoVas6fRXavcZW6S1vPB4pRggCCNwongMZb7ecw17i8JuZLDCKb7Cc7qs4zSZSWoMwhOYveZnWGUk84gEMy96Y/zSDLyj1bor7/+etG+nGISeLWrCYlGgF2fq/I36T5ydQehIl0D9sgTkpn4WymSmuq6jXo57kNHTrGFdXtEZyKPGT1VypFTxdgiZmeUBguc1wE6Y1nbrkd1ZkVVAAQ1EPaqfOJmLKkSSCKAeA8Be2bb0RIch1raHPX4IvnHIZ2kT58+tZwsCDAUnc5ywuGV9SyncjcqouwrmD2rrWWCVY1+skKYQzHrGeeluM7BoIjuC8Md58GWW25Z087dAulGuemMUjiTcJhx78dJiiq2PWMcspA5WcrrOLBw57qoM1Nny2oWuGYz+/rR/y5ZVZxn6UTLcmSIXi+cYOgDX2ewNmG9YslXRiXoDE1uCcrtqElTxTiTorw3l60RZ7/+64LdPAq1VMwigFvJRA2cByFIQ2t9tkI6rFTzerPUGfnsDNMZRjnpDBz3QPCaSu8kI92S6gW/NTuynq4+SfYNcfdfzYm4YQEC9feEzeRNMkqjEgLnpRwhFUwO8xOck3ZZ4TqZnWGUm85gHZNEXvp+JZKidERmGm3WkxwPzyZ2Ds8iI6heeOGFnJ+TVmFIsDuI+ppJUkZGvPHGGzVdsTSht9K6YlVK4DxI0D7Ua8LvSzlyKk1bpJCdQYIIzzF6yuIZubHAecZoVhY3Z1xHVpTgQ5KgRth+kgggHjwUDT+TBOzz8dyZo2SXa1/L62TRGYaarcWin9/5mbOlnuVU7iRRKsHWMv6iH+VBlmBw0a8t3Sqt4jwfet70meI+R7mYg8soV51RTIAk7DioRkCuFmrNHrYPqzhPfn2SgmOTjWsVNusQ1GmWFVk70bIM1PsO5zCdYUERI0udMWbMGNdCPcrs2TCCeiGOfVGM06uQvihka0TRNVEqoeO2VKzPtkVagfM4Ooy1CPeY3wKXe73YfWYdOPcxnWGUm53Bc8ezRnECDBs2zFXKJSFJEi3POqM4eM7x9RQz7zZJxXk1B86DoNPDCic0gcwP8upM3nzrgLT0QDWNkAomOId1WQnzqSla2KS/M51hlIvO8Md5RP0M7vkZM2as51dKY2xsXDtEW7Pj26Y4jwQtteuz1gPaPpwkXf6bxKZgN1g/WFsOXbGqpeI8Ctgl3CPBAkPG9ZHgF6XAsBD6bKVNmM7g2LFzOVYr8shN+T5hVQY3JQ8AzpakbXbzGRzFBDXSMC6YlUQ2MAvp4KzDNGjfsnYLjLBj82cYkpGss5xY8OssJ47Lz9ZKavxVciCh2H0FF/2+Q5H2llr1z0+UB+e51E6orB1dwYViMCiC0uH7g7V2N5LA/cR9hPxiIVOKoHlUZxYJSTiueA2VJizW45Cl86ncHTRxSPOchc06JJtZZx0CGc2+fkxSUVROIzwg6wQuyLW/fA4u0xlG2naGP6M2Ceq4UucWLeqwL2grGPW9ScinL9CHBM2RT2G2RlRdE1cnRWmp6M9HT7OlYiUGbkpxzPnm9WobXF7jOxKxB5N0TiuXTmWmM4y69E2hQ+gyx/OFvB07dmxmgQyOjWca3w2tf2ktTvC+GL2inxv3PfWVYAKZBnnRe76/xx+l4cvOStFdpaw4T9plhWfOP8eaIKb2t9kZRrnpDP5bA82FYA2NXwnC/EppdCqMY4eg60gMpg33yJEjawoKCumNrPxbftUz89Z1BIR2rgh2xco1mi8XWQS1S02WIwf9cxumJzWQnq/AsFz8V7ou0w665pvKjQXOK6jNbi4lgvLBkZQ0qFGMccFryK5ho71KrhkgafPUtGVSaISKP8uJrDHOjz+jAgMMZ5g/wzCYyZyVAM6KUiiVoENRF/0oC9poYvgGWyumfQx1ETgPKj3fwaXtinQLBkW4z1RBlTIgalS2zkBejR8/XnbbbbeS3iP5Fv5aZYhRj4xP0sXEKs6Luzal+lycXGwkmlGdShUpwfRZs2a5QFnasw6rvVW7freo+zOdYZTSzojjxAqD92NfIP+B1uxR7Yu0K879IEq/fv2kW7duOecNRqWYAExYS0XWvehL1r4kmPq2RRqys5LWiWprlHrdEpzXq8nS8+bNc638NVlaN+yVQseUtY6KQyGdwfNKNxkcq9yDZmcYSX1T2q6W52v77bev8Y8Um4wVRSf5rdm33npr50PQ+z/rwHmlBH+zIFeXRzaqRoMdQDT5tlzlaVDml8NxBrushI0rAQql6AxQaFyJ2RlGVjojarAbHwOdm/A9sJ4Pu3+zbNWOr40gPlXCxFH8edXlEDgP+/zgCIhK6IpVLRXnGmTOpyejFBjmSjirK/9VWBcTi2fUxgLnJQblolUfxQbIwhTS7NmzXTYwCyyUTxoz9/QhLaSw1LDBUGcGCA9+VvzprUVy+l7xv5cKqV69ejmlooJMZ3f72VpZGktZKbNSKxW/6p9zOmjQIOe40vNMIJ3X+IZVGu3zsw6cR9mfb4QFFQ9KVF+jgXSdKWKB9PqNrzP0vim1fAjTLdrFRFtoRakyzEUxhoUmZ6HrkBvI5nxtj7JydFWTM02/C+e1ffv2JZt1qPuq1sB5sW21TGcYadoZxVZs8Kyyxic4nMu5lUXFObYGwXuCon4QJdd7o3znNGWQtlRk69Gjh7seOOJ0ZJQvOwvpr2qhLubach00GYzroMnS6DHWD5oMpvYH1yIsoaEuW7UXqzN4VkgMJ3BudoaRxDflF0Rou9q0dArvZ79RW7MTxPDXmcUmZEGYXsplZ+R6vZG7y6PvV9NzznnFtkizE0ualGuyVNg51q47JJUg6zl2PwhD8K9QIN18U0Yp4hl+/CDsHuQzCBzOmTNHBg8eXBNYDCOLVu06hoS1IWsmfB/B71XXgfOocimsKxayAllc6q5Y9a3iPK6NkKvAUBPOeC5UhnNtVIZn7b/K51c1nbGO6rbc6xAeDAKzbNrSodiH2VcA3OAIerIPCU5qi580iJKVq5nIPOhUoSSdORWHib8YLYMvHZPa5yEg8rWg4t86q0KztUohwLIyyjRom2WQHkcOCoCNCiGtCNH2wFQP8Rq/IiSJMq+LwHncJBVTPEZcncE9hqwv9XMbdIb5XUziVBnmIqlh4SdnIT+QHdr2COe4LjL9bM1ydH5Ugm4Inrtcsw79GU5+6ymcjFFkYtZtcLPcXxK9UKzOwOgicRLHmiVf1S8K2RlJgxzq3OKZ7927t9viUkyAwz9uZA5BFGR8MIiSa79R5Wap5KvfUhH8lop+2z6tBInbUrESqIvAeb5kaU0G87uOcY8jN30dRqVRJQXOc+mgsEoRC6QbhXQGfg/W3Dh2w5KUig1m5NNJYa3ZgzIkSuC9EMHjD7Mz6FbBOUDf4PRGD+WqCqtr6lrO5usAovqbDiBcV+SrH7xJoxNLGpTTeI5C55j7kWMl8MhxY4vp+oIAGb/zi1Pwv+W7R8w3ZaQVz8gXOKcrE34l7FTW8oVGwZW6VTvfh4I5npstt9yyZr2eRqeSusbviqW+93xdsbL6btVScV6MvghLhkKGq3+NjlEqw1nDc+2y+F5hnXTzfYcG9bQw0ALnJYCbHIFcbGv2XAqAB4yFKP9G+fDwpUmhrFwWZgjdYCZytbWgYt4rRiPKRgWZv+BPMjsvF1m2hK/L6na/IkTb5zNPBmVBBiIVrr5hFXUOfV3NOC+GKIqHRebFF18szz77bNU8Z0Z0naH3WBadIlQ+8BxS3Zd2F5O4BpA6XJDBdDTxF6qarUmSk2bca5UI/12ssVVOZPnc59tXrlmHbCTx8W/kuhpi+VpPZamDKqniPK7O4LvhaKZVm+mM+kUUO0PvkTgQNEDuYuji2MpX3V3KinOOmw5F2BoE7qkgjiI36qLivBBhLRW1EkRbr6r+CnN0V5LDrpwC54USGjjv6qziXuPe59wTSMMu4b+zSAovpfPL7Awjqs4guMnan2TJ4cOHh1YfFRvMyJXYlKs1e9T3R9138P357AzktBZRcF78NuTIkDS65VUznEeC6DBs2DD3M1/iUti4xPpecR6lpa5fnML9i89S9ZpW/fvJYYXuW9MZRtJ4ht6Xvo7gntTnHb8v6/kodnJardr1GPzj5hlhDCI2DnGUQgk8+fROXbVqT7MrFv9W3a+yIu2uWFnYBFklQKWpL3wZTnc3v3MLIw1YE7300ku1kqHSjD+lUfjRoB7FMyxwXgInLdmwpZjvhjBgAf/KK6+4BRIZuaUQEHrcQYXF9yI7C2E7cuTImjZWdQXV51ShlwINWqFECBToYhRB9sUXX7jMWZSKP8MwSoC33KoKS0mUgAV/5z5ii1MRkmRfdZWZVYzioSofx2olKxkjuc7wjZBS3t98NsYRzxvPXSm6mMSpAiRRiSQaDZjwOxxruWbA+V0s0JHMd0J2q3xOKpvrC0l0g59oFkxm0NZT/kJf52tlWdmh36tSK86jfj90Ig5H0xnVTxw7I47jyXduUS1GYuyrr75adPC7mJaQOH232morJz/i7DfKMWfh7MoF+gjdpfpLK8aQnXxnv1I6zncvJ8oxcB4EG472wWzAGoOAA+sHngXsvCRdVeqSQraJ2Rn1V2dQ9IDjPBg4428kKLHuHjBggKuCyldRWGyr9uD787VmT1tu6/t9O0OLQIJ2BnIaZzbni9cgpzXhia5LyA8NopudEY5/rcI6sfgBXn9cYtbytlIqzgsl6HJ/a3GKVv2r75LEGDopxO3yaDqj/pE0nhEc9YpfifUUvhmSsXStlST5duWq1fLxl8vkw3lLZdbCFTJ/6Sr5atnXMn/p17Jw+Tey2sl1kbWy7j1NGzeUVk0bybIFDWWCfCBtWzSVrm02lA2/WSxLZn0s/Xv3cD6mqAm5dRk4T5ugLH7++eed3sePw7qXn/7o2jS6YlVTq/ZS6gu/cwv/jexmfeLLcF17+PGnYr93moUfDao4nmGB8xK0MoG0g+Z8LkYPQYERI0bUVC6UiqAiIJiJYYMRgWETFrysZvzFKAIMAUNFglY8+gFenY0VJ3O2vlScp1URokaVnudynHFeLJw7Fi9pd5QwKkdnBI2QUjJlyhS3GEujNXtSw8JvneUHTPK9N9gekGAPAQlkNLKZ74VjwE9yqpT5slknVRVDMJnBbx+I7NaqB859Vq2n9LnJMnCedQIX+NUnpjOql7h2RtSKcz6POdwkhVIZpl0ligmSJK04Z11N5QNsv/32sW2NcmjVHodgxZg6urEt/C5MwL+RoZVgf1VC4DwI5xXbmmdh6NChTleFdVXRdUQ5ttiPm7xlOqP+6Ax8SCSoI2tyjWXy/xZGmhXnUVqzl2L/BIP4zlHsDD1eX05rQNJP8lc7I6kPqFrJ53eK2sUqbCRX2lRqxXncStNgl0cSZoJBmEIttE1nVDfFxDP8wjvkI3KW+4m1fJyxDKvXrJXpi9bKyxPmybQx82Tq3KXy6fxlsuEGjaR3hxbSufWG0q5FExcIH9KltWzcvLE0athA+N+64xBZsWqNfLlkhYx/b558/c0amTxrkTzy1icyc/E3svybBtLh3VnSt+NiGdyllQzt2lqGdGkl7Vs2TWRXlNKWyCIwzz50tjZQJazJvCQ+aFesYCFEkv1Ug92Rlb5QWR+U4br2oCIdXcmz5V+fJMVCpSz8aFBFvqnK8B6XOZqVhRPTb6+bFjoXhM/m4Sh10DyYlUsbDx7MXr16ua0uF5dpzzlPip+xGcycxQjEGA3OMMwlkLJ23mUVpE8jIytXRUjwPLMftlJUgoeR1X40UcConzoji8D57NmzXZCTZ4ykrFJ1MSkk59BzJGex4IvSOisXHD/PDBXn6CuVzRgAfiZtpcyXzUpep5nsFxYMQpZpMAi5/fLLL8dy1lRC4LzUrdrD9he8bqYzqpMkdkaUIANOVF/u+gZ3MUGKuM4eXkunCgIQVD4QjEgaIC73ivOojm7twsRMQpJzCXzhxNLkUU0gLcdEsEoMnCtqu+TqquK32Oc6+c7Eul5LJNFBpjPqh87Qyh8FpyvyJM5YprQqzqO2Zi+F3MafhgM3qp0Rtj+/Kwh2BrJAZUMl2hmlJoouyNfFivWA38VKgzxp6Zisk16LoZhjzdXlERs5ThDGdEZ1kkY8g/cRN6CjR5y4wRdLVsqTk+bKSx9+KWOnL3AydUjntTK6f2c5dKuu0qdDC+nYqmmsZ57P2HTRFBk1qpMrymjSfUMZMmSILF/TSKbPXyaTZy2Rd2YulKuf/lCmfbFUumy8oWzfq63s2KedjOrZVjZq1rgqK87D8M8rz3ynTp3cxnfDZ6PdVrBDwO+2UqhrBWRxjrIMaGfVEj64H3/tAcFOvdjQXD/fvxbFli61/2pJlcQzys/ariAQAtxoCGa9udN8YINzQQiYjxs3TrKA74LyxLBBWG655ZY1VcCGRMqcVSXD9eNcqoOF8xjM1qq2inM1rNPel1aE+LMiOccs0hDKY8aMyaQiJCuliVMh7epfo3J0Rq6xGWnAZ7LAwgGME4lgRSlbD+VbNHMMOPDIpozaOivqvoKy2c+kVee3yotym1uYZcV5Kb8z95V2bGFBz7oGYzqYMet3BUijqrJUeijf/rJs5asJXP73M51RXRRjZ2gyYa7P1aRYHKibb775ep9bjO6JE2DxK95J3kIWICOSUC1OLIXnGyc234sAkyaPor+oRs+yKq8+BM61G0rYOQx2VcGZqMEynMT8zg84pBnYKWVSr+mM+qEzVB+w4ZcgiXHw4MHSsWPHyJ+dRuAcmUXiZJTW7GnKd9b7fHeSarfYYouiW/T6kLxUyM7g++oaty5kQ11QzBo8aherNOa+Vkur9riEdXnMFYRR3cb6zHRGdZFWPIP1qcYuooxZWrR8lTw9ZZ48PnG2vP7xVzKsW2vZpW97OXWnXrJy9lTp0L69i3/4fLN6jcxYsMIFvr9a+rUsWEbL9lWyYPkq+WbNf/3c/31tk0YNZP6shvLinDel+6btZIvNN5MvV4h0at1Ehnfb2G3fl67utYtXfCPjPlsgL3/4pfzumY9k+pcTXSX6twZ0kJYrc/tjsvTf1wV8P/xibH5XLO1aoV2xfP9NroS0LCrOs5DjWVa2F/o++Tr1arI1185Ptg5bc5Xaf7W0SuIZFjgv4qHRdk8E8TA80m7NHpwLgqDK0pFO0JxFazHVf5U857wYOF/BbC3fwQIqxHSGTDUFzrOaLatZcQhkFn0odVUYwYoQzVBO45iyqjjne1VDhpbxP52hgYyohkm+4EdSkEdUGQLynda4paxqz+V84nthmFP17rcILiXBTNqw+bJqAPAzLNs+S4dXtRllagj4GbPqrOEahC30k7bX1+zjrK5XXVScB/dnOqN6SKozCrVL5zOpvmCtRKCaQEKu95e64pyER3QRhrxWvKOfitlvmsdXDvjHGUweDVblcd78qry6SgSr1MB5VNvFdyZ27drVvY97We08XUv4gfRiAjulDpybnVH9OoP7AtnKOCPWU8jbuJ1+itEJHBszOvFlMUs9Smv2NOS2b2fwvfETxNETpbIzghV71UoaMi/XSJPg3Fc/eBOnXW21tmqPC+eQ9aCuCf0gDL7LJ598Uq666irnV+OeJdkxztxq+OMf/+g2kh+AJJZf/vKXsvfee9cknfzkJz+R++67zyXZ7LnnnnLjjTfWSvDhWE455RR57rnn3D1xzDHHyOWXX16W3XfKHV27AOcvadCce0S741LVnS9o/v6cJXLbq9PlsYlzXCX5PoM3lUu/O1A6tf7fMzthXiNZsWq1jJ3+lbz5yQKZNGuRTPtimQuYs49ubda1a2/TfAPZeMMm0nrDJi5QrqxZu1Y+nzNPvlopsqjRRjJtxmq5f8r7MnPBCtfWfbM2G0qPds1lYKeNZEjX1jK4cyvZqU97t8HnC1bImKlfuCr41z4WuX/GJPnO0M6yz6BNpV3LDTKzJcpNLgXHP2jFM7qNZGySoMP8N1nYBOUU0K6r/UTt1OsXGPKeUsc1llaJnWEaJgHaZoqfKHWMlDQfVG2dGJwLUqrKwyA4X1gssUgZNGhQSYRQuSmCUhLmYNEZhiz4EWb8G6GihlQpEhXqInCedaUfjim2fBUhvjJP6lRkf1ks0KslQ6u+4+uMJMGPNOU+ziOCJlSY055RxxyUcuEf9h00eM+5iOLAK0VAJMwZg/5FNmsldF3OLayWivPgvoKGQNBZw5oqrO2lv9CPssDPuv1iXcw4D54H0xnVAdeWxFnWMzwfSZ7PsKQrDGicW6wrCs0QL0YvRNFb2mmEihI6jeizU4wjyn9voW4u1UBYVZ52u6rLAE2lBs6Tjvfgu6Kj2HQGclhgp9TjSazivP6Sz87geSQgxb1Itx86jCRZqyS1R7Q1O+tr1tvBKsJS7T9oZ7z22mt5dUuYzCp2HR7FziDI6wd9q2U+eqn0QFjwRs9psFJabbd8a51KatWeZYJuMAjTp08f97vrr7/eVZqqn3iXXXaRiy++2HW8KQR+0CuuuMJ9FvfH7bffLt/97ndl/PjxLoh+1llnyeOPPy7333+/u76nn366HHDAAa5LhX7/ffbZx7X0f+WVV9wzdPTRR7tn5rLLLiv5OalGnYFNwLVk7RIXruG0adPcxjUlISLs/uR1L300X259Zbprxb7/0E7y0A+3lt6b1A6mTZ27xAWrn5m4UKbO/1JaN58hW3XfWIZ121gOHNFFerVv7lqqE/wuKPd7NpCFbdfITjsNrVlvraJi/avlMn3+cvn4i6Xy7ueL5OG3Z8mn85e7QPrI7hvL9r3byXa92sphI7u67ZEnn5Uvm7WVpyfPlSufmiq79usgh2zZRUb13LiiknBzUczxByuec/lv2AcBduIbpZJfWdkdWVW2pxFrCCZbE7fU68Pag39zfbhu2k69FAH0pVUSz7DAeYJWJlohzEPDzZVWUIPPJLjHYiRsLkjaAZQgfvsuFiAEVkolgIoJrP7ziM1k37vXVW1XInxnbVvLgh9jEkWCcGTGI9cAZ6lvRKURpM2ybW3Ws2XDlEu+ihCMKxZ5fuVj1Dkt+qyk0Uq4viia+kqYzoj7/KWlYzgOFkkEK4LtGUutW4KGBTNbqXKnGqN///6R5EQWyTj+/Dc/217no2OMIbd59rmmleRsKafAeaF9sf4ILvT90ScY+sHRJ2HXoRwC2Vnvz3RGdegM7nEqA0ePHp3Yie7LdT4Xh9bUqVOdc4u1Z6HnsFQV576tEdZpRI8riVzy91tIZ1S6sytfgEaDt8EATSlGYlRj4LzYYw8GdvhcbYHrXwvf/kgjYTpJNaLpjOq2M7TDCPYvCTbI/6Qk0Qnc8wQxWFdTaU5CT1LiBCnC7IxC7w/qjFIERfLZGZwbrlVwPnqW68pK1AOcn2AXK62yY92jAQG/Xa3vM6okfZX1SCgfzt0RRxzhnivO2UUXXSTPP/+8vPTSS5F9Vfvuu2+tf1966aWuAp2kFnx1N998s9xzzz2y6667ur/feuutTm7w91GjRslTTz3lqlr/85//OD8Ga8hLLrlEzjnnHHc8Wfjmqk1nJPUzYZvjwyY4yighZBVVx8HPenXafLnqqakya9EKOWLrbnL1gYOkbYv/XacP5y6Rf703R/793lyZsWC5q/oe3b2Z/Hj7VjJ6eP9Yz2awOOTpp5+uPb6vUUPp2b6F23bu+79uCfOXfi0TZy5yx3rj89PkJw+866rQd+nXXtqsbiDfG9JBjt+pr0z/cpk8MO5zOeeh92SDRg1lh05r5cAW30gpqSRbJei/0bEl2CLYnyQ1+Z2YgqNrK6XivFIr27EzSDpiA55ddCU2OesPrpE/8jat8V9LqySeYYHzIttfpRVw8Fsn5ponrtUfpRAM3NAYNihPqlDeeOONshXUwe9O1lj3tpXd5kqDu2SBcy/4wRq/2k5nGCZZNGdpGNTFbNkorRXDKkI4zzhwURYofN+wylURkpXhwnOpiw+jfrXZVdLQMdxH2kKLqgsSc9LeRz7U+cQ+qLyiHTeZ5TjxSrWvUmTbawCX5AOC6GPGjKnVFrcUcwuzyp7NUlbH3Vdw9Im2J2Yj2cxvT+zPj8x6bmE5BOpNZ1SHzkjDvtD3E4TH0cl6B+eWOuyjvr+YfQdBblJZxN9zdRpJK3CexuvKhaRrh7AAjT/7DlmpARpel9a6tpICEVkk/QbHk/CM67XQ9pasy3z7I0kAIEk1oumM6rUztH0uzzmO0mKTM+LoBI4NRyx+jL59+zq7m9bOxei0KHKbz8eepxCFaljWjcHjirO/UpPLzuDaIRd05JxW9fl2RrnrsLo6vrB2tWozcG8QzPGDA5zjSkmCznokVD6dwXbIIYe4Lel3obKcz9t2223lrbfecvJs9913r3kNSS/IDhJJCZzzM5j8Tzt3WrezpmG8qRFPZ7DuizsSEFlO0JxOcZxzTUTxdQQB8aue/tC1W//hjj3l6FHdpFmTRjWzyv8zZZ7c+fpnLmBNEPu0nXu6oHmLpo3dtWzSpFFkGcw+SUik4wRyXwODUXUWgfyd+rZ3G8xZtMJVyFNl/uIHq+XOaZNk3yGdXVv5n3yrt/xo117y7JR58sdnJsmjD34m3xv2jRy1dRfXQt74H3T+4FoQmB05cqS7z1S/kdTE9Q12xUqqd61Ve3w431wjrg/xR86h71/jeqWR6LC0SuIZFjiPgJ+VFZyXmUTZBNHWiSyG87VO1IVS2kE7zc4icItxEyUrt5z4zh/fLMs550kheEsFjlbhaLYWGwsJ34iKI8Tquh1vuQUs/IqQnj171sxp4TwHW30Fq3OyMlxQNFxfo3p0RlyKDZ5Q3YTc8FuzB8liRhPnY+zYsc6BgYFcylk3pfouGsDV80UWvG8ApN0WN0sdXCm6gePUkRzc07naE7PQVydxlsZUOVScm86oDp1RrOzn3uB+oMUlzwP2RZzq9WLGQ4XplLAxIbnem1T+xQmc1zdyBROQndqyL0onj2oPnGextufZDI4n0UA6OkznAeaqkMwnR+IGR01nVJ+doUFrElW1wwg2bbEJslF1grZm597SSkRIKxksF8gwikA4L2F2RpLxI1n7woKJoiSbhdkZbFmMbyyGctED+G4ItGqw1U++JRGa+wX5yvlV3VcOxx1GOXQ6K1ZnkMjJ84l/k2f0oYcekoEDB7pnl2sVTO7kurF+BH76QXP9u/7NiK8z4lSc+wUQ+ECC3Wm5NxctXyU3PjZF/jH+c9fS/PL9B9ZUmC9e8Y3c++YMuefNz6RhgwZy5Nbd5MbDh7oZ5Ul0Dd/li4VL5JW33pFFK9dItx4D5ZPlG8jH0+a7v3+0qIFsMm+pdFrbxM1C36BxtGenY6tmcuDwzm771zPPy5dNN5EXpy+U656fJlv3aCMHjegiu/ZtJ+1XtJI5q5rKU5+uku/+aazs0rednLxDd+mzSTrVtVnJoVLux+/kop1gdWyJjjSigI2Oyzz/flesOOvZrGIPWe0nq1iDPmfoQHwEQf+a6srp06e71/mB9Kgjb6vFzrDAeR64YQhSskFYAKQYI0BbJ6KAmO9XqHVi2oFzPgdDKqx1bynnqWvLbB62JN+jXBezpTIsCN4GjSh1dqkQUwGGssmVrVVu7XjLzZAIzmkJq87hnuU8s9jPAq51sDrYqGydkcac2ijwHuQ7hmRQvofto5QOGJxZzOsl23DEiBGpjJ4oByMjzAAIzi30A+lJWi5bxXn89sRqiNGqk3uPOXh+AhTXpRTwzJXy3g7bX3ANZTqjenRGMWM6dJ4cz4FW7MSVJcVWnGuHLLawSpB879XvEJc4SWCVkhycRTAhXycP1V9RHSTlFDCplKBEMGFakxqwQfAR+J3H8rVvTjIuxHRGddkZ2j6X67rNNtvUCloXW+gRRSf4rdnpKuKve4v1LeWT76y9KUJBXlE5lWstFrfivC71RD47A9uOa01VOslQxdgZpaQc9QB+Mja6nnF96YrAOaWdMJ0KwO8mhh+mXL5HXbZqT0tnkDiJjGCN+sADD8gxxxwjL7zwQqrHaETXGVHX+qxDkLF8Tq4CiEnz18htL02VzTdpJY+cso1riQ4rV62Wu9+YIX968RMXVD7/2/1kl74dcs4qDyY5UaE+afZimfT5Yvn4y2VuPvm0L5bJrIUr5Js1a4WPadN8A2kx9WPRT+Q7Llwi8qfJ78myVeu+X6tmjaVb2w1lszbNZbO2G0rvTVrIFp1aSc92zaVhjmNp0aShjOzfRo7coY/MW7xSHpowS37/zIfyq8emyA6dG8qBQ5rLlfv3dcdy86ufyeG3jpfRvdvKyTt2l74pBNCrxVYJi6H5I420gA1ZrJ2Y1O+OHC6UQGqt2pPhd5/I5V9j/bE2x8hbP5CeS1dWi51hgfMcoEB0hinkMqSTGiJ+60RaV0RpnegHzouFGxjlx0OQq3VvKQQ135vFEg+dPmwarIyzML1nvzby/Ue/kvpGcG53MEhACyqcYX6wxs/WKqfW6eW+v2B1DvJAnYosHsmMI0DmO7LSDproXC6jenRGXJIEL3T0Rr52uD6lSpTSqpd58+a5Z2TIkCGZBYKzJtjBwk+8STq3MKvvUU1JVf51QE9y7klMDOskooZYWjPxyqFVu+mM6tEZSe0LDZywNmT90r1790THV4wdoM84tgbHwnfE0RZlxpm+t5ikgaj7qASy0ANhnTzUQULSG4EF1rd+km6+BKSsZgBWYzVfWIWk33mMlorY0todwJ9DmCSoYjqjenQGa218S8H2ucB9wX1TKnskrDV7mKO8GHkWFsj290tADgdvLtkTd//lJsOCdgZJoQR/uSd8O0NldF3PR6+EBCqOj+eEtQkjxDhm9avRjjqo+9LoJlYMrAnrOjmiWJ2BfsMuA5Jc3nzzTbn22mvl0EMPdTIK29n3i1ONqgmX/GScqA9/178Z8X1TUWwNzjHyhTUJlebrdTtb+Y1c+dRUeXj8cjl5VEc5+VuD3LO1es1aeWjC53Ldc9Nc1flvDxok22/etrBcaNBAJs9dLs/MniZjP10gb89YKI0bNpBBnVtJr/bNZcfe7WT3bo3km4XLZKvB/aVPj66hn/ncc885Xdi8ZStZtGKVzF28Uj6dv9xtn321XO5+fYZMnr3YBfC36LSRjNhsY9m2V1sZ0a21NP1vW3lf73TYqKn8YMcectIO3eX1j+fL9U+9Kyc9MlO+9f7XrlX7+Xv1kRO320xufuUz+f6t42XXfu3kzJ17SpeNS5OwXwlE1bnBAjbf7+4nkPp+NP9+zkrfZFVxnpU9EtVv3SDHyFuuD2tPrlEuXVktdoYFzgPoHFZVMoXm0vKQ89o4aFZs3NaJac00IsCKYUUFM5UoWbXuZSFEMAdBx/fGuRd0yqjAZMvlzA67HoMvHVOx7dqLEfRxsrVKVWVXLRXnheA51ZlOnGM1zrmHtc2lPzMr6Sx6H5zO1dDapJqJqzPiErfqkA4idEfg/tTRG4UoRaIU5wM9QwY/xizPT9LzEud95eKkCZtbqFmaOL45P1FGblRbokGWYzw0iJCrkwgdf3QxH7clbr791XXFuemM6tAZSSrO/bmDrAkxapNSTIWiPuOvvfZaTkdbLtJo1V5IbtZ1JWG5E+Yg0Q4GrDG0o4rfUtG3ZSshYFLOgfNCncdwIKoeIyEMvYbu4vfYfHG+h+mMytcZ/lzvsPa5aXWWyvUZuVqzR31/VIJyW+0M9Fy+/frkkvu51t/lrCc4PnwNur5VO0MTbNTO8MdvZCmXK0UP+Mep55SNpENf92k3MQpSfN2XVvJtpeiotHUG34l7lyA664hnnnlGDjzwQPc3zjdyjcRL4Oell17qfNk6M/fpp59214t270Z83xRrc61Gz9edlsQS1iBB3vt8kfzo7xOlc+tmcsXOrWSLHq3dvqbMXiy/eGSyLFy+Sn62Rx/Ze4uOOau61+1rrQuSPzVprjwx8XNZvmqN7NyvsXxrQAc5d88+0neTlu79JBISR1nVaJUM2zX/6D+V4bRob9+yqdsGdmpV6zVUs384b6m8+/kiefOTBXLOQ+/JgmWrZMvNNpZd+rWXjVeGfy4t23+8VQtZvLaZvDinoZx4z0QZ1KmlqzT/+Z6bywnbdZXrXpgu+/9prBy+VWc5cfvNXMV7HCpBfpbqu/h+dz+BFD8a96Oue/3RJVmN5ctqP1m1hEcGJOlK1zoQg8Ln6+tKOolQaIi/LW68VBkzZoxcddVV8tZbb7nPZbTH/vvv7/7GZ55//vnyxBNPuAp4jmX33XeXK664wiUVKtwzZ5xxhvzzn/90x41+IVkrbjDfAuceCFYugN+yoNBNFMexxOdzUdlyZePmQ1urJDU6fMOKdolhyq8UFYh8b/bJg8OsLb435xmBqE4Zf760H/BVhzeC0Xe6lbMhE5c0v0u+bC3OK0qGOcO5srXSohoqzqPMEeQ8aoZrcGaWzqJXhZ5kXiROiGpobVKtJNEZcYnqaOIYcJSQFTx06NCahWaa+4gKspwkKRYkVLwXs2BS4pzXctQPyAtkBVtw5Abnh+/ndwrJ8rnPOpidZeeT4L5yzfllY32EYeZX7MRJgMpqHlW+QL3pjOrRGXHsi7C5g6y7i50nG5TbX3+zRr5evcb9hGZNGkmzxg1rOcPYJ8mwoGv+OBQbOAfOG0m5PMu5kkbLUU+Uq/PMn6vbq1evmgQk9FdYpSPnv66PuVKDEnG6A2irYV1P4F+gzT6bX/WRr82+6YzyhutLUEnXF0GdoR0EtatHLkdgqQLn+Vqzpx2I9vfv2xl87yjByygVVZWsJ4J2Bn4JZDSbtiD37Yxco/3SolLOXT657+u+fGP89JwWk3wbhSTjONKmGJ1x3nnnyd577+3WhSS83HPPPfL888/Lk08+6XxmJ5xwgpx99tk19hfBDp7vUaNGuffvscceLkB+1FFHyZVXXulGFhA4Oe2002LNQ65m4vqmctkaXGd0C4R1p4VH3p4lFz02RU4Z3VNO3L67vP32BFmxarX8/pmP5NZXp8ux224mp47uWVO9HQZB6gfHf+5mny9Z+Y3s3r+DnLlte+ndao1sOWxwrdeyrueYsOHzjeSIo3MaN2oo/TfdyG3MLnfxmi+WySsffSlPT5knb36yUvq9/4HsM3Sp7DdkUzf/HDnAupdkZc7fvl06yAF9u8uTH6+UMx+YJH06NHcB9F9/p68cObKL/PaZabLPjW+43x0yopM0adSwbORoVp9frK4JG12LbtNCCE0UgVLqt2qsOE9jP40aNaqlK9UO5Brhmz7zzDPl+uuvl1122UX23Xdf+fa3vx3pc5FD+LWPP/54OeCAA2r9jXtg3LhxcsEFF7jXcC+wn/3228/Fu5QjjjjCBd1JsuIeOe644+QHP/iB0z9xsMD5f9GHTQ2TqA9a1IoQbZ3IIpaZUywGkpDU8KnJzlq1Kq9hlXaWLYqFRSUPzVZbbeUeprDP9QO+m2++eY0zm/dpNa9W5/GZfMbBwzvJ/eNnSTVQKsPFz9bCkCIzG4dqWLYW55b7Io1jybpNYzm0yA3OzFJHliYt6LxIVSqFzjWfgbKw6sHq0hmlkPlUzSLfuSejtGYvlbznM3DYkp2Mc51NE76ycqCUe4VIvpEburgkyQwHANcTZyD6sJQVDdVccV5oX/la4rJ2iZMAlXXFOcfmP+umM6pLZ0S1L7ArsC/4bJyLumZIWjFOK8Mdr37xf7+4f7YkoXvLRnLXqHVJnFkGznkuaOXJs4zsDEvCrcSgbjmRq6OK30qc84wzK2niaF2QpX4qxXqC6nPWXTgYg3MINajjzyE0nVEZOoOW3PhGgq2IcQSyTsHupE15vvVHWjPOtTIxSmv2UlSc835sauwMzgkty+PI8zj7rwQ9kesY/QSb4Gg/387wA+lp2xmVVHEeVe6HJd9qID2YfBt1LFclJXcVqzOoFD/66KOd7OLcMMKNoPm3vvUt9/ff/e53NRWBrCv23HNPufHGG2vez7l87LHH5JRTTqkZ/8OM9Isvvji171jffFNhtoZ2L0R2oFuC9xxV2lc9/aFrw/6HQ4e41unw8cLVcuNzn0qrFs3kbyeOdMHoXEz7Yqn89aXp8tjE2TKkSys5e/ferrqcoDK6heQo/75D1/D7sK4qBNy/XPK1+7n069WudTxMnr9Wln2yUDosbuBmoLdp3kQ23rBJ3sp3PnfzDi3cdtSozeTJ51+WGWvbysvT5su1z34kIzdrJYNbLpWtu2zo/OucG9Zc87+YLYNksfx6m2by2pdr5KcPTpL+m7aUn+6+ufzl+4PlxQ/ny2+f/VjuG/u5nLdnb9mu17oAY7VTCh+Tv+6lwyb3L4FSroPqN/SZ3xkkjcQavku1Bc5LlYzVqFEj2XnnnWWnnXaSZ599Vv7whz+478N/s6aNGjgn0YotDHQIwXAfgvN0ICJZkHUpNum///1vNxKEWCRcd911bv9XX311rcr0QtT7wDk3PzcMhkCSNrtRjAC/dWJw5lRckhgd7J+gCsKdLL0oD0carXtZWI0fP94FbwnmxBFYvjPbz5rV1u787oDNGsn946XiySpoofe3n63FNVJnV1jVY9JsraydT+VW4R4MjPnzInXmsZ5r3dSR5cP1qYaZINWoM6juQz6VOmO/kMxX44bFAdV9SZ6DsMrCuHBOOA70zYgRI5y+U7IOnFcawbmFnEscMTi8kRsvvfSSkwN+RUOai9xqmnFerF4Iy2hWuc0inN9x/vVa+JV85VJxbjqjOuyMKIEOHb0U1g49qr1AG8Wtr3hB0mb6kgay4+9eq/W7V/5vtLRrWdg5n1RnIC9pFce6C3uL8xeWhIu+w86oFMd+pVU6Yk9wbxKoUbnpz0cPW++WA3UdlCgW7nd8DFHmEOJkRF7gnE6qMy6//HL5xz/+4YKYrIWx9X/zm984R7tCIOknP/mJ3HfffbUCIZqsBtwjBEKYR8qxEAjhs0tZuVlJOiMY2NAOU1RbDh48uNa5zEWS0R9BVKdEbc0epFhbQPdNgDJoZ0Tdf1zKPRG3mLaqwcrptO2MStGvxRR7sI4IayfMRvfMNLoPBo+1HCrOk+qMm2++uaANdsMNN7gtF7TQpzWvkU48w7cVeD+6hfVbru6Fi5avkjP+9o58ufRruf+kraV7u+Zu/38bO1MuG7NADh28sZyz3whXyR3GzAXL5frnp8ljE+fIvoM3lft/sLX069gyZ+dbv/iw35AR8vFikUfHfCxTZi+RGQuWy8yvVsiC5aukSaMG0rJpY7c134AEWZFFi1dLo09myOq1M2X+sq9lxao1Qsy8Y6um0qNdC+nRrrnbBnbayM04b9F0/TVHq6YNZZ+ebeSEXQbIOx9+JneMmSL//KSJ/P2jFbJzt9WyT79WMvC/xSLYFsjVLvPnyzZtVsg/P/pKjrx1nGy/WXM5bXR3uf+E4fLA+Nnyk39Mkh17t5Wf7b65tI9gE5WaLOR0qX2lyMUOHTo4OyTf6FpNok6yvtR7stpatZd6P0uXLnXXheJhqs1LCded68M1hldffdX9twbNgXbufOfXX39dvve970X+7PppkaTYZpeHNJdjK6x1YrEPWpzAOd+P/ePAYP84kqJSbKt2jDlamLDPqHN28x2LnzVLRSOfjwAUmV9rzvkzJ/Vfb9ZeJZDVHFt/P/w3C182zdYKVj362Vr55s4X2lepKYeARdx5kWGOLH9eFg4BgjaFjBM+hxYlzPxgoYuzmLkdI0eOzPke2mLRCktnYdPm6thjj631GowWZorwrLF4JjsLBwlwj1x44YXy1FNPOYcXCxXmjVxyySWRHSiVrjNIfsiipXau4EkxrdnD9lGMvA8mSQVb42ZdBV7pji5kC88/8oHrgpNLE8dwUOM41A4sacwtzDqYXc6B86gJUMFKPjYcDnXd+SSKzjAqw87IJ5f5PYFg1sPMHQzLmM73fqpFtrj4Wcma7a4aU/PfT/5oO+ewSkMnaTUK9hYBPJKEkZN8TlgSLq+jOhf9GUwWLTcqTZ9xf7MW4FwS1OP4db1LYh3XifWub1uUS4vVrLtlZWGb5JpDSMXHww8/7JxMBx10kAto77rrrm4LVjbngvmFtMjF3kD//fznP3etdNVJCWeddZY8/vjjcv/997tjOP300127xZdfftn9nePZZ5993D45JioRqUjkHrrsssukvhGmM3xfE88SxRA8Q9tvv31kmZVWq3YCg1y7KK3Zw96vFVtxnzPWXtisvDfMziiFb6sSOlgVa2do8oHf6TFNO6MS5CnXOK1gdJTk26hjNMrB3xWG2RnVFc9Q/YJuYfwFPkh0S5iMnb/0aznhzvEu2HvfiSNdkHrZ16vloscmy8sfzZfzd2wrQzu3CA2ak6R73XPT5O9vzZQ9Bm4ij506ygXd8+mKz+d+If8Y845MXbqBTF7QSKY/M142a7uhDOrcym3fHtRRNmzSSNaQOLBmrXy1bJULoi//erWsWSvy2WcrpE3b1rJJm1ayUbPG0vi/leZUnK9ctcYF8V//eL7c8sp0mbd4pasyH9a1tWy3eVsZ1bOttG2xQY3ecAkFM2fK/+0zxPncXp02X254+j05+bHZsuvUb+T4Ud1ki84bOZ8oG/mD241cLpM/nSN/fW22HH7XZNmps8ihg1vLTft1kdveXiz73fSmnLlLTzloeCdpFFIFXwnysxBZ6VB/XZFvdC0+d2xBdFrc0bX6XbKqOM8iSSqL/SzLyDfF+vScc86Rww8/vKa7N3GMoI9cbVD+Fod6GzhHQfAQJakyj2KI+K3R/daJxRJ10a/ZWRxHkv0nNRZ0jjrZPcxRj2p8xz02DDUq80Q+q/U3HNlJhWF9Uihxqh7D5s4XmuOUddVGlhXu7KtYJRN0ZPF5OK841ziNmM+BMOdeJjjN+c7VSuTEE090SSp33nmne81dd93lMqm4XiTrBCHgi5Pq5JNPlrvvvlueeeYZ9xkYeTjO4G9/+5sLrN90000uO+z3v/+9+xuOepQPVc5stDjBQY0Tms/jdw888IDUB52RRvVGUh2DAwnjhucvSWv2NJ1DmiRFAkauivdqqzjPsjobMGLD5haqIwb8ar64XRCyrjgvp1btcQhLgCIAoa0vuS4Y1jgiswgIBR1o/Jtj0ICFUdl2Ri4dgwGK/Afkf67rHfZ+nES7/m5dwKqu2fMPr9T898QLdpUNGjdMpDO0+pHzgg7KZQj7Sbg8t8hJnlFkKesu1jc4CtXZwjNcXytei8XXKfzEgcFGpZgGbjnvJC8gM7kmfiVIXSU/V0PFeaHj1zmEP/vZz2pmyf761792QclrrrnGJUGSNBsF2h/63Hbbbc5GeOutt2T06NHOrqHCkDmCBOTh1ltvdcn8r732mvNPYONgr/znP/9xCS7Dhg1zSbg4vy666KKSjqmpFJ2hgQ3We8gpnqPevXvHuleLtVl4prXrH9cvSmv2IHq8cW1o5DN2BvcHCeJJguYQ93irIWhRTKdHDaQntTPqQ8V5kuRbzinPEUlk/lxYPa/lXHFudkb1xTN4D887OhmfJCMwwnTLnEUr5bg7xkmfTVrIVQcMcmv2z75aLqfeM0FabdhEHjp5G/lyxrT19Az3PdXll//7A1fZ/cAPtpa+gQpzn1Wr18hrny6VhyYskImPzZc2GzaR3Qa0k3O2aS8bN28i0+YtlXGfLZCnJs+Vj79YKktWFhhB8vFc+nOF/qlT66bSZ5OWsv/QTi5ILmvXypzFK+VPL34iP3ngXddqvk/zlTJs/gfSbaNGNeMBYNtebWWj7dvIvOVr5eV5TeS4u96WEd1ay8k7buaC78DzPKJfD7mxXw+ZNGuxXPXUVPm/5xbLIX1XyL7tlsmAZk3kz2OmyQNvzZCL9ukrW3RZVyUbPH+VTFozzqPsJ9c+/NG1fmeQsNG12hkk7LOs4rx8dQZy8JBDDnH3wR//+MeS7KPeeQQ4mTwcOqOp2Nm0YdWA2jqRhxPjIk3HS5SMYYQAQXse/KSt4ZO0aidYjzNPkwVKmVmix/bGz7aXra/8nxOQ/QaFIddHW6uWa4vArI4nbgain43sZ2vpHCccYf4cJ98ortYZ535GZ1r4VYvA/Ca2U0891QXEf/rTnzqHMJXlRxxxRM37UEQPPvigPPLII85JBTia/vnPfzqlgTMsCMFwEiN++9vfun8jo2gFzVwpDZzjPDvppJPkuOOOq3kPFSO33HKLnHvuuS4phv0qLLIvvfRSOfLII51srSZncy6dka/bSJoEZT6OZpyMxbRmL7SPKGjFI8dTqFVksR1M4lLpRoZPUI4GO7BoNR/6jrUHsjlJpxCrOE/23LC2YEOmvvjii87pQCAvGBDSLc2AkLblVXDIQVqJmkYydAwOa2Kuf1I7I8y+8Gfa9u/fv+DIGJW7n81fJrtf+79AdRwu33+gfGvAJq5aw4e1ILYGaz/WBNzbtHDEmfWLRybH2sfgS9ZVv//jh1vLFp1bRQ6cE5jD7uCex6GFHIwj//1kUXS8rnFxaPtJuGysd+sqqFpuNksxDiw/UADa2lLPOwkQQdsiq0BBJQfOtVVrnHOlOuM73/mOa4+un5MUnUmqVT4E0Lm+JPMqyC3Wr7RPxGbnZ3ANiS1C63ZkHX6M+u6b4r/pLsK5TNKiXD8zqc2iyUlcX9Y7BO6ToN8p6j3m2xnMQkafss5NShJbpJrsiaj4dgYJ+L6dQZe8qHZGJQXOs5D7fvItz5CffEvCnz93Ptdc3rrWUWZnVFc8A51CYgw+XVoZ59ItM75aLsfePk5G9thYfr3fQFcdPWX2YjnxzvGuevy8vfq62eRfBfTMp/OXyUWPTZEP5iyR87/dT/beYpOcx8k+7n7jM3n47Vmy9ptvZOsOa+SmQwbK4jWN5T+T58nPH5kkC5aFjxWkNXvXjZu5wDpV8NgrTRs3ktlz5kjzFi2lSdNmsnjFN/LVsq/dZ3y+cIWsWr1WZi1c6bYxU7+s+axNNmoqW/doI3sN7Chfr1wuL09eJP/6uIF02riJ7P31LPnesM413bL4Lh1bNJRzhm0uJ23XTe58Y6acfO+7skWnlvLDHbrLyO6ta74vSQO3HD1cnpz8hVz59Ecyrm0bOWPbTWS73kvkznHz5Kg73pbv9GoiR47YRDq0b1d1HTzrMnAepTOIFqTkG12bdcV5NVS2L8nAN6VBcwr5mKGu1eZA0VFw3Yjc5HrHLfCtnuhGxBtDs7KAB6DYh9jP4OUnix6qc3O1TiyWfAFtfk81KY4H5otRAZj0+8WtEETQ4LxCwGy55ZYlDZz5x0Z7Fp+V36xZTxjiwPSzO7U9g251nc1eLhXnhQhma2k2MhtGrZ+gkEVAsa4MCX3eS7k/zqNWZ+BU4lyPGTNmPZmC4OdcB7PvUfAEw8Pg83wnljqpfvzjH9c4SHB2nXfeeTV/57vyHt6bCxwqKKpqCprn0xnFOKHiwH70OhMwR/lTkUMbqLSI60zifkTe8x4qHgu1q6+2ivOsiCKz/Wq+4NxCjGHuGZLY/Gq+4AK5WivOs9yX7o/zrEmDfkCItRkVU/4MSYziYuRlsLoQww+sVXvd6wzWRKw5CXIkfbb85Cx+0j6VwHmcmbZff7Na+l34n8j7PGBYJ/nVvgNcJQnfgWDNNsNrrzt0hjXt7kjewgGs35Gqk4NGdHEb3Wxo4Yyx/MyUeXLafe8U3v+f3nA/jx/QQLYqoDM4NpJTmCvIpvo5iq4JuyY8i9piEXAkYjtoZTTX1neklGMSbrkQJ3kW28I/7yScqAOL68vzpDNi0xhNUq2Bc13DxXGAhemMpOeW/WNH0OKVRBogGISNrbMGFeSXdobgZ1Ce6b/jtlGsRt8UawhGHBBAY72dtItN0lbt6t/hGpIkTeA0KX5yfVQ7Q1uzI29xwBaThFvo3sbW4vnxu2WUc+A8S7sqaGcE58f6doaubcv53NWlrZAr+TZXp0cNovO6uMlRaWN2Rt2DDEQncB/oOjSJ3tbEUx2tkytoPmvhCjny1rGye/9N5Od7MX61gYyd/pWccs/bcvx23eXk0T1q+cbwI8Ijb8+SXz0+xc0x//3Bg519EMbkWYvlry9/Ik9Omis7bb6xHLn5apFGTeTFmavlpL9Ndi3XfQZs2lIGd2ktvTu0cPPKF6/8RiZ8tlBe8ILftVkQ+ts2zZu4duztWjSRZatWy9S5S2XizEUyd/FKeWzi/9Yem23UUPbfYmPZpN3G7jXfueFVGdKltRwwvJP0bLhWdCw6Feu0XT92VFe5Z+znctaDk6Rfxxbyk916ufnpwHnaa2AH2WHzNnLDmOnywwenyZFbd5GLDhklh85cIBc8PlXeeXquHLH5LOnQdJ1/l3OK7os71iEqpZbTWcY5kshxvzOIP7pWuwn6o2u1ajqLJIBqmXG+rMS+KQ2ak9D33HPPrSfHSKpHrxLbIEYJBNc5v3TVjUP1RDgi3HxptGbPZYhwU1B5oYGEUrUjyGX4oKSockewMoe42CylqIEUzi3ZHdyszDJP0rorTbb6zUsy8RfrKm+Dc7w5Nl3sh7UfzxVUqNYZ58XCIouNYK4mKGilPxsQKIjafqoSlEupKs7D4HyiqFnQ4ijZb7/91nuNVlnR1pDKcZxN9957rwtw08YvjFxOKrKeNRmC7xj2Ghz3YbCA5xh+8IMfSH3RGVm1amc/3AtcU+6FXHOniiFOhxGuNbqO+4F7Loq8TNLBpBiy2Fe5JgLkmlvIRuUOQYlgECLrwHmlzDgv1vgIBoTCrkWuri1R9+cH3n2dYdStzuC6FNt5R9f7rOuRufw7SqKSsu214yK97vy9+8qR26yfaBtmb/D9sDVYLxAUDwbEwt7P5+4+YBN5/1frEvaYhzj80ufyHtMtk9fKLZPflN8csIVroRi87wmo4tAIq76MKpsLvQ49y/pW17jaYpXAEUkDPGd+W/e6TsItJ4qR86x3w2bEFtMyOCr1LXCeps5g1jk2X66kXSOeneEXQ7BOQ9YWM/olbuDc37/6d+jiV4zdEzVwjoylwj1oZxRrS+TybfGZOMf5vv64jiw7ZVUSwfmxrG1xTCOjfTsD2cI5LHe5mnWXxCSdHrUbC8epxSpZdmNRzM4oD52BrEIvkMyU5HM0+ZX3cx+xrg+D6myqykf3bi+/2Luvu/9IhP3pg+/KeXv2lUO2qj0SkuecNf65D70nz33whfz2wEGyS7/wQo+P5i2Vq5+eKq9Mmy8HDOssV+/dRZ585zO5d2YTmbd0XfAdOrTcQEb3aV8TfL7hhY/dnPRiYR76v96bs97vu2zcTLo1XyPzl30tHywQ+XTxWvl04le8w7WpP3Lrbu51t7/6mcxasFS+1au5nNZppatUh9YbNpFTduwuR47sIre8+pkcd+fbskvfdvKjnXu6zwaq4s/51uby3cEd5ZJ/T5V/T5onF3+nr+u6dcMLn8iVb30uJ27TTbZutliWLlkiY8eOrSn8y2IUXLW1ai9mnKqfKEbyOrz++uu1ClLSLhrLsrK91MlYS4u0M7C9kVUKsk+LdbETDzroIBk3bpzr1Mt30YRbLY5lDbnXXnu5Trp00EV+nn766XLYYYfFLnKu+sA5Nx4nyA92pfnguoqOr7+WV155xZ18Kr1LefOFGT4sVrmBcMDiVEvDAI5inJCZi5HMgo72Ltp2r9QUkwHsL/ZZLKgjO7jY16rpagrAlDJg4ScokK1FUgKVsSQlaLaWtp9K28mYRQV4cH9+RnqpiJpdSCv3448/3rVT47hwJB9++OEusyoLcKAzM51Z57SJry86I6tW7WQ94kQiGz3uTMM0HWqcFwx3Fixca+63qFjFeXnMLQSdj66VIlxXAg/cyyxuS11FmaWDSgOYWcB5ZMu3/gu7FuoU0xlbcSorg4H6UmakG/F0Rhr6gc9gfU/SVJzRHMwhHP3bFwu+bsIvdpENN2gU2Q7Q6hTWedgahdZwueQ+LRU1iE5lx45X5z7Wc/7xntueO2sH6bxxs5r57nw2xxBMyIx678fVScEWq35lGMnDtJTmb37FXVq2YKVU7ZXC3gjOiNVEkmACg29bFONMLPcAT9pJvWnpDJxQOK3ojMV1UmiDqEE1P8kGu1BbJPLzjTfWdZrw/65/q0YK2Rn4IggcI+8ohsARmIY+ifoZ2pqdNaFfjJG0aj1qq3Z+zzNNUCfMzlC5nVS+hL2H70pimrYqVr8Qtg7fn/M2bdq0Oh/XUc6wFgh2JNQgA//NGCM/2ancurWUq9wPdnpELuBvxlYgeZB7NWgzlPp7mJ1RHjojafGGFtrhW1LfPWv7sM9asWq1nHLvBNeW/MLv9HfP7HPvz5OfPDBRrjpwkBvhFGTm4m/kwme/kq7tN5JHT9lGOrZav9Bj/tKv5frnp8kD4z6Xg0Z0lnuPGyE3P/uu/PStFbJqDXLhG2nSsIFs2bGBfHeb/q7K+5ZXpsuD4yUTZi5YITO9IvWOzRtK97YbytiZS92xsMFOfdrJgDZr5ZMFq2TvG96QPQZ0kKO27uJasgPt4qlAP3TLTnLdC9Nl/z+NlcO26iwnbb+ZtPrv6Kv+m7aUO48ZJne/OVNO+9u78r2hm7r3EGg//5/vy7ON18opwzaS0dsNrgnearetcij8q+YCwbDYEWtS/Ov4ZFknsF7xx3olKYKo69hGqfXfkiLtDJJGdtlll5p/n3322e4n46WIOzz66KPu33Rj9aH6fOedd3b/fffddzs7ZbfddnPf9cADD5Q//OEPsY+lqgPnmpWlzsW0HyY+l8U9CxguVhYGnm+0+NXeBFTIiknrOxZyKvEQjB8/vujWYWlAhfngS8ckeq/vyOb76mIfYYjBimIiAFzqquksFErWGbWcWxRLsP2UOhm1rZe2n0oa4MgyKyuLliZBRVMIEkBeeOEFZ+ATxCb76tBDD3WtS8NATqlTSuHfOAS4v1kgsIW9JijjWHiTxcWC4aGHHqr4Ssc4OqPUrdrRK3TEoMKbRRgVH6WikDNMHUvIR2ZSxp1Tk3XgvBIDDWGU4nvwjOOM9OcWIpORzW+++WaqQYi6bomYpc5LErQIdm3Rykptsw/oRtWTQcMjmCUcVWcYpdcZxQbOkf8EBtHrzPiNOppj52tedPP68jH5QgzHBpH1AvcmSTYkl/pt0dPoXEWFhgbRj7t9nKs8CWOX362rYr1+R5Eueea7F9OqvdjOHpqQpO3FdXSRjm8op0BBpTqwuOZhLYNztbZli2NblGsAJQpJfB3F6gyu8xlnnOHW/88//7yz93xoi8iagrENOKoAOYJ+o1sW8PPSSy91trYGiJ5++ml3jQmeVhuF7AzW/AStkR10mOL+5dxo+9ukRA16+63Zg8UYaXSPytc5sZCdUaxMCeokLTzBxmKf+rf27du7nwQouFc5JoJNOq6jXAPA5YLaGdy7yGWKitCN3NskYJfazqiUVu1J/GocK/4AzpmffMu9yv3p2wylWHeYnVEeOiOJjcEziIzlHkG3qGwPk8nfrF4jZ90/URpIA/ntQYPcTPPXP54vZz/wrusEFRY0f+OTr+Tsx2fKzps1kd8csaV7jw/37iPvzJbL/vW+jOi2sdx9/FbyzwmfyUF/GSur/6tWOrduJseM6iarVi6Xq5+fIa89PEnqmjnL1sicZUtrEn8Hdd5I3vhkQU1r+A7NG8q+gzvK0q9Xy7F3vi0ju28sp47uXlMhv2mrZnLpvv3k6K27yNXPTJN9b3pTfrpbL/nOoHXz3hs2aCBHbd1VRvduJxf883056K9vuerz+0/cUn750Nty7vOL5JJWX8q3+ndwzzV+X+1GEVb4l2SkUSn1WFY+uSx8Pmoj+AlNJN3ptdAiCJXDXIskcjjLwHmpK86XFGlnEPzOdw9Fub+4Dvfcc48US1UGzjmB3ATcuGm3ZldwZunsJT47q6xoVW4ITKq9cRiUoto7n8OLDFL2TdUFFTBZGw2F9kfG1g2HDkr0uRhBbGTMkwFPQJ3zQLY3VdPawksXpWkECquh4ryQ8ylf+2ASP1A62rI2blZ3XVWclxqCKHGUrVblcE6ffPJJufLKK0Nfh5PqiSeeqPU7nFTqxMIww9mFo2v//fev+c78m2wthSA9s9Ex3sj2Srt9eLnrjFJWnBPMRL9wLQhScE1LSb5gg+9YwomWJMGl2GA2OocxAdzfyBCdM1QfHFal/I46t1A7rDA7OTi3UDOai01wqquK8yz1AiTdX7CyUpMaePaZlY2zkXPvt3UPVrjH1RlG6XRGMfpB5T+fi7yLEjTnePpf9Eze10y8YFc3uzwqfB++A0EcZALrAm3NGoW4QZZbjxnhft7y8nT5zVNTQ19zuitO/1ze/9XAonVNmmtvdDV2IJsmwWggncpFzoU6tCqpxWK52xvBLmLB1rZxK0EqJYCSlvOrWJ1Be3acUY888og7z9oikfNM8IyfJ5xwgqsQUduOQDv2BoFK2GOPPVyA/KijjnJ2C59x/vnnu8+upuekkM7gd9jDBGppLUng0U/EKrZtuJ8IFXa9w1qzRxnfkYZ/SYP1PKMkiuVaZ/qt3pPY4X7FO4FG7AotPIFgcgJynW2LLbaoNa7DDwDbuA4pKE+D3VpyJTuVqu1tpbRqj2Nn+D5LTYTm/lT9p+sOP4ksjbEmZmeUh85A/vH7qJ+jHQPDZHuYvXLFk1Pl0/nL5Z4TtpJmTRrJOzMXyqn3vu3ate85sPYoR3j47Vly0T8nyymjNpERrZevFzSnu9Qv/zlZ3p25SC7bf6CsXLVGTr5rnHyxbN136NW+uRsZNeOr5XL5k+Hr/3KANvQEzYHA+Myvlsq8ZWvkwQnr1j4Ew9esXSvH3vG2bNurjZw2urv067hutjM//3z4YHl6yhfym6c/cu85f6/eblY7UNV+61FDXfX5qfe9KwcN7ySnbN1O+m8scuHjtLT/Sn72rc1lwyaNanWjCBb+aeK939a9VIV/9aHivJCNgP87OF5KrwUFthyTnygWRQ7r85hVYWUpde6yKvJNVV3gvNSt2YFsEipmaUnNRguirJwE7IMbkNaNLJaitEtMQpjDiweLrCZm6wwZMmS9GchZBlLyvXfMh+EVK3HRRSlOS7LoWaDoDCfadqXZmqNaFEpUIyRXy1rOLfdXnKzZLJWL7i8Lx5q2TS4EQXKuLRndtIz5v//7P1eNddxxx7m/n3feee6c3nHHHe7fJ598slx//fXys5/9zLV4f/bZZ+Xvf/+7PP744zWfiZOLFigk5dCm7/e//707Hv1MguY4u5BFd911l/s3G/C8lHO7oLR0RilmnHMsXCsq1nDk4AgudqZgFMKcYX5HExKkcHgkfcaSyntf52DscZ00EMH514WoH4ioporzrFDdEJxb6Gc0+wlOfkZzXFmYdcV5lp1IIK39aVIDG88e3wUZy/UgkYTnApD5BFdZn0TVGUFor3vVVVe59mN8NtWDmjSl3UbOOecceeqpp9waaPTo0XLdddc5uZCLv/zlL07nkGQJBF0vu+wyp08qnSg6I0mAwa/sRv7jGCFpohBLVn4jW172fM6/P3DSVjK4a+5Z5LngeWejkiFJZ6koFedhHL99d+m79jN5Y/HG8qfX1jmjgvS78D/y2jmjpU3z2vaPL//z6YJSJyRpEgw2IudAAwWq3+MGCirN4ZClvZGvtW3cSpAsx3uUQ+A8qc5Q/vjHP7qf2g5RufXWW+XYY491//273/2upjUisoSE2xtvvLHmtRwzbd5POeUUF1Dn2cD+uPjii6VaKKQzsKWoBOTvnAPuy7Q7XOm9EfZs5mrNHiSNwLnvX4prZxRq9R41GYx1CR1dGG2mCf16XvzPDuqTsHEdyBZ/XIeuj9No11rphF2nfMlOQTsDOZ1Fe/xKSZjKl6Dr358ERnktSZjcnzoyEd9bsZX+xeoMIx2dwXOEPi0EzxOynZ/bbLONe55yyWSVgY9NnC2PvD3LzdtmXjezyE+6a4KcsXMvOWjE+mP6/vziJ/Lnlz6RGw4fKj03XOnsGB/au5/z0HtuTvlfjhwuv3nyA3n143UFIa2aNZLTduolXy5dJRc/vs6urRTem7W45r/7btJCPpi7VB57d67792792gni74jbJshOfdrKj3fpKd3arAuY0tJ9+15t5I8vfiqH3TJevr9VZzl5x+6ump2Eg6O3ofq8rZzz8BR5eerXcsqwZvLAiSPk3IenuNdfuX//mmB8WOGf/+wHC//U5siyQ2hW9kAW+ykU3wiz/7QIwpfDfhFmmBwuVeFvGMiYUsQSq1FnVKZ1mAMdCM/NioAoRWt2HB7c+EOHDnWGuSqtrLJcUHxkupIhG7VdYhKCxgP7JRtYjbq6bAca5Tszn6TLxulWwOJMoX2XtvAKOmQ4N9qasVxbeGV1PHGfh2DLWoSsZmv5WbN+tlZdKBfdXxaBYTKHg86TMHDIEhwne57zg3OKtoe6KCIQotmHQBIIQfKzzjpLrr32WrfI+utf/+qcWQqt3nEq/PKXv3QylVEU//73v2sSHcaNGyevv/66+29kkQ/XS7P3yx2eWQyTJPdQ2q3a/dbsVFyonClFgL6QM4xjoS1hWh1NkjjbkK84EjkWdA73M7LBD0SEzXpCJ5c6szZLOZrVfsK+UzAI4Sc4aVvAuG0r67LzSRb7KtV347NZX7Ahw9GRyGAMLp4TZDbXAePn4Ycflp122inyc8tnsaYlkeqAAw5Y73oRROdeoKoQp8s111wju+++e02lUBi07T388MNdwJX1+G9+8xuXbIVzOTi3tJKIqjPiVpzzmZwbni915uszlo/PF6yoaWMexrXbfiMDNi28jghCgJfry3ccOXJkovu6mLa+7O+AAS1ly+ZN5Dfj1shHC9Y/l6N+s25Ek7Z6j9uqPSv56ld9Ybf5gQKcKNpi0e+4VG62Q6UEzoMUqgRRuaq2Bc9spY4cSmKbRLUzchHlGeIa3HDDDW7LBYHIYCesaqGQzsDGIpCL/UsCdNg1TKPDla6Fgsnf+Vqzh31GWpXvSeyMYgPnfHfsYe5JXZsUIte+gp30kOO6PkaX8/18v0V96ZIVVw9EsTN8GV2K81hpFedR5DzPGesKNh2ZGKz0x2bzK9Kj6L5idYaRjp0RxTeEHw8Ziz8Ju6JQJw/2+/H8FXLBo5PlmoMGSbe2zWXR8lWu0vzgEZ3l2O26hwbNb35lutx13JbSf9N1XWf0uNasWetmmd/66qfy6/0GuN8dcctY19Lc/fdWnWXzjhtVXMA8DILmfgD9mffXJT3v1LutrFi1Rr7357fk8K06yw+238zNPm/RtLH8dPdest+QjnLJv6bKgX9Z156dNu/AXPm7jh0mlz46US4Ys1DOa/6V3HLUUPnTi9PlqNsnyM/37C37D9000rPvF/4FOzHF6SJWqb6stPcRx6/kXwt/vFSws2MwkTpr/1WpW7W3rBKdURWBc25ihAIbi1VaKqXtOCdbBOckiwoW2/r5eqOVugpVgyo4OHE6kqVZSvxKER5ujCoUL+e2HKpJg0I4OOd8rxvecL/L0iGjwV6/rarfwitXZmc1ZWIpxQh8jhEBy6ZZs8FKO86lnleeySwzhbOsOI+SoHLIIYe4LRe33Xbber+jOmT8+PF5P5e27H5r9uD7K7mq19cZugiK+2yk2apdW/NyXwedOWk4quIEETgW7g10XFodTeIGKdSRh0MKncM5wIgMC0T4FQvIXmQFi1I2lb+V2iIoS5kdZT/BBCdtWxnUeWoA5MqirQQ9lGRfWa+N+G4kLrERgDv33HPdiBkSqfg3CThUj5Nsko+9997bbWFQAfTaa685xz7PolYZ0pL63nvvlRNPPDH0fXfffXetf5Oc9eCDD7qRH0cffbRUu86Iox+QVcg79L1f2V0oOWvizEVy0J/fCP3bTd8f6ioWGMMSR3/4CcLaxSbrTiOATOceRr4/PrqXq9wY8KtnclafT/jFLrLhBv+rqIxCXa1hwgIF2tZdK3X8biqVuNYqxwq+XJUgfkWevoaAAue+lFUY5WCbRLUzjPho+1SCF3TiCuoMrhetwrFrBw0alHfkX1qt2kE/J0pr9rDPSKNVO/cdVZBx7Yzgd4gD14HEZBKTqLyM8qzE0X3obX9cRz6fUKXJlixtmDA7I2xkUZpjT7K0FYoBmcH5TLImC6v0J5imBSqs8QmmqW1NACfMpjGdUR52Rj4bwx/7wRiUQsnKep0XL/9azvjbO3L0qG6yS78OsnrNWvnJg++6IO5Zu9UukoG/vPSJ3PzydLn92BEuaO7rCALuvJd277cdM0LufuMzeeTtdR2kOm3UWH6yRz/56YPvSbWhAfRNWm4gc5d8LS/8twvurn3bydjpC+WRd96U00d3lwOGd5LGDRu4QPttRw2Ve8d+7kbNEkg/e9dervq8SaOGcsJWbaVPq9Xyh+c/kZenfSUXfruvDO/WylWjT5ixSM7dY3PXSj9p4R+JFYDdx99LVfhXLXGOYn1YuTo7smFva1KDVmhnoZtKHddYWkV2RsUHzjVrVZWHZmmUonUuGdE4KP2bq5hFfFRYNBLIYJGNoyWLWcJ8L1p3sZjiQcaBhqOhHIIP5XAMhYK9uWY4+W1SsnayZxmESdNpFqy008w5zi3t0Xg++F4sErU9WilbLSZph1jMTBCjtDojaZUo90BwHl5c/Dl7ZCKiX0oxU7AQug+tMsx1LEmJGkDhNRh6OLB9R16h9/qBCL4H/2bRiVGgVWX1ab5sFrohrG0lSQs6biNXO+JqbtWepeMtGKjn3iewzXVh9AZdcBjDkc8ZHwXtqhRM5uEZeumll3IGzsP0GQZiFtnt5aAzNNCR79nSNrXIO+Qt6xv/tflk/1OT5joHVxjjf7GLc7qo3IyqPzBuCeBz7AQz+L4cW1KS6C4N3HPfUZ2tScKcFirL3/t8kRzwp/WTBYZd+pw0a9JQxpyxZdlVnBeCIAGOTZ1TGtZelfMyd+7cyFVhdU25VJzHrcjj/ue4g3abBhLKuY17MTPOjdLoDJ5lCjp23XXXWs+DFmNwP22//fYFiz3SSNTV/fM5UVuzB0nDHuH9nBOV73HkRJKKc17LeD02nmEScqOu1ZLqiVw+IeQ6Ng6yhb/5bd3LoSil3PRAWPtxPY9qZ2iSkwZ8k8jockz0KnWCLusIEnrY/I4JbBSo8O+wlvmmM8rDzsiVWFto7Eeuz0LMXfj4B7Jpq2byo13Wrbv/8OxHLvB9/0kj15tZfusr0+WvL013QXENmutnzV++Wo689S3p2KqpXHfoEPm/f7wrU2YvcX8/cHA76dZh46oMmvsQNAe639IF99kPvnR22ZbdWsutr82Q+8fPkl/u3UcGd2nlzu2RW3dxLd1/+dgH8r0/j5Vf7dNXRvVc14VlcIfG8uBJg+T8f74vB//1Lbniu/3l/hNHyE/+MVmOvv1t+e2BA1wb+CSFf9x3dIjj+SaxjOQkZIOfnFRskld9rjhPOl6Kzg3IA0bp5RsvVQmFH8uqyM4oXwswwo3LhcYRpw+KzuhMqwpQK9jJcvRb5+YyREqBzlPXoD2LxFIHUYB98L3Z4hhVWRFFCFOBXuqq86iZnRipmt2lC1LOKX/nPsuCSg2cF8qcw5nIOeU85lvsV1owhoSAasnQKmedkZRidY2vX/w5e0GyCJxzPnhuCODTll8N6bSI4nzSuYPIyGLaw3O+WIgygkBnPYUFdOsyiakas3R15rxeN61mCM5H5z7DWct5r6a5hVlXnCM/gvvzdQbVOkceeWTR++nfv79zWFLF/qc//cl9PjNrSfihUi4qzEjnmGjxXh90ht+NKsyRy5qQTH8CKLRCD5N3uaoMX502P2fQfMpFu9Ucox5vFP2h7YKRmSQt8dzwnBaje+LOOMe41sAlsiJs/bNF51YugE6VeRDaIW59zZty4+ho16hcAuc++t3ZSGDjOccOJOijVWH8TZ0o5TpHtxIC52HPG88qazGeA60ECeowv6V+OZ37JIFzszNKqzO4n7RKNJgsG1aMUepKb+4PHRERpTV7msehSVHoPuaZJ+mcGDdwznUgQYD7nCpzgtZx5X4aeiJYZcY50JERnBOO0x/1V01t3dP8Hn63saCdEWxBzGui6sdKadVeygRdv2OC3wmHexSZxfrjzjvvdH/DR5DEF3b55ZfLP/7xDyf/tNsEY5wozgIS3UliC4OE4IMPPtj9d9i1ogPWYYcdJpVGUjtDdUvYOp6AKLZb1PUA+5swv6G8/tkCefz0bV0g98lJc+SuNz6Tv5+0tbTasLaO+Nd7c+S656fJHcduKQM6/S9oDp8vWiVXvPm17NCvnRyyVRc5+rax8tWyb6RJQ3Htxa99YbosmLiujXma7DlwE2nRtJFMm7dMJsxYGPv95AWsKYFJQNAcWjVrLItWfCMvfjRferVvLh03airH3/WOfHdoRzlz556ufTvB75uPHCJ/f2uWnPnAJDlo+KZyYO91575diw3khkMHyd1vzpQf3jtRThvdQ249cqj87tmP5dCbx8mv9+0nu/ZbP05VCL3XWPMiA0qV5FUpvqy6jgFoUgPJCvjLBg8eXGu8FN8vOLq22O9c6oLAJVUUz2hc6a1MwFcyaQXOcbTjwCk0B0kNkbQDG367RD+QkUUQBUceiyT2RSZ0ubWTqoTFbRDOIfOh2bR9mwpCBCMLHZw1KgxLMaM361btWVVm8Pxh+A8YMCB0sZ/2fKysKs6rqbVJOeuMpBQz41z1C885MjZfBXTas9TDghUsjDlH/hiSLAPnHANdVZAZfqvipPj78jtW+PNl/SQm32FVTm3dKzlLN1jNoHMLcdjigNHqH9V5pZpbWI3V7bq/oB4qhc7gOuLoOuGEE9x1Yp8Ev2ntHvX+vOKKK+S+++5zWe1ZdEwqB52RrxsVzwEVIQTe8rWpDZP9Mxcsl2NvHxf6en/Wt/8Z+WwG/oYTk+AsBjprVP+9nIek8iHOjHPa6BLgUIff2LFj876X7/rxF0tlr+teXe9vp45ZK29u9400y7NMKxcZXwh0olY6E/hBX2lbdxLvuD98/VWKFov1JXAelOO5Zu+ykfSitoUGcup67ZAkecvsjNLqDO2CqH/jmeX+yZcsG0Yavi2V5RwDgaoordlz6ZO4z7efFMUaheBmqROydOyUjkDheY5bQV6q5xmd77d15/yoXGd9rImoUbpklbOcLbUeCNoZJDep/4dEaV9G57MzKqVVe5bHGeyEQ2ANn9odd9wh48aNc+d8l112kd122811noqSgPPCCy/Iaaed5pJFkYc///nPZY899qjp7kJn02BC7p///Ge56qqr1hsndeutt8pee+1V82+uc6VRjJ3h2wf8xJ/BOr7Q2I8wvlzytdw/raGcv1cPad+yqcxauELOf2SyXL7/FrJ5h9o25YTPFsrPH57kZqAP6tyq1t8+nLtEfnj/+zK8fQPZY+AmcsTNYwVp23mjxnJ2yq3ZD92qi6xavUb+MX7d/fLkpLlFfV4pguY+BM1hI4L7Xyxz29bdW8s7MxfLfjeNlXP22Fz2HNBeGjZoIIdt1Vm26bmxa8f+0tSv5eQhTWWIC+43kKO27ipDu7Ry1ea0ar9k374ytGsr+fmj78shWy5yQfhgd4Bik7zUZ6ZJXlr4F9VnVk0jabNKstL1fNh4Ka6H35HM77iSxH9aar2ytIriGRUXONesLM3gDV7oYo0Lv1UsWW9R2kilHdjQdol8bjCQEbeCI2mFuzpqyi1oroQZPsE55+UK1xDnFhsL0VdeecUZsNzXZAty7+Fc9gVhGq0Zs54tW1dzbIOLfZ2PpRnJuijQcxs3UJiV4YIhjRPZKK3OSEqShCm/2iSOfimVzKdbA8EKDGAcDqUImkM+Z5UeA88rzrxir08hx5jvDPeTmOpzW/csAvQ6t5CAOQE6nh91cPE7f24hP9MIsFZzq/awBK5S6Ywtt9zSrUnJQseIRl4QxKMzRCGuvvpqFzj/z3/+I0OGYPrXD52h7/FtA79lbJSZskEds2TFN7Lr716OHDQvpD+QfVxXTZrSmWrB75DUGRElSMHfWZcRLGDUAF0Jor63Z/sWOavPR17xgnx/q85u/l/SYytH0EfaYjFsjm7aLRbrc+C80OxdPfc6I9avhixVAnTaOsjsjNLqDNXR3CckyGsQN+66sljflrZm5zgJrOB7SEISnYCDl0QTXeO//vrrRdk0URKy1JcVtLOSyP1S6wlNJvCd41rxh71YaV2yfLLWsdgNyOd8MlptDH6qnVEfW7XHvUd5lgh082yRYHnAAQe4cVBsJ598cqTP+fe//13r37fddpuzxd966y0ZPXq0+27BoO9DDz0khxxyyHqtfnkOih1FVcl2htoH+DhJxNWYQXAdH4WLn5gifTcW2aV3a1mzZq2c9/Ak2X1ABxf89pnx1XI59d635ezdNncz0H0+m79Mjr1jnOw/ZBNpuPBz9zoY2rmFHLp191SC5ntv0dEFhR+bOFv+NnamVCKLV/5Pj78xfV1l/Pa92shlT34oT02eJ+fv1VvatthAerZrLncfO0wue2yiXPDiQlnc7HM5eEQnd68M6dJK/n7CCDn3kSly2C3j5XcHDpR7jx8uZ97/nrw/Z6lcuX9/aR3oEpBURgcL/1gzqk9dfWa+zRHmu8lCD+g+qqWTYZgt4o+XoiOZ3x3AHy8VHJFY1wWBy6oonlExgXNuVC4sWVl6M4Ut2osxLlBgGDa0/cFRGHUWY5oV52HtEn34dylae2vVCZl+VLiz2EQwliOV6IwphAo6f4Y3ghAHa9LWU3Xdqr2uAueF5mNp22budTI0UfK+kinkaLSK8+rSGUmJq2s4DmR73GqTUnQ04fNoPUqSGE40ng8C2KUiLHjD9fnwww/dwtsPmBRL3HmJfhJTsK07OlHn59WVw6pasnQVfRb9+Y/qKNQqEW3j58vlJMljWVecZ3lvhOmhUmf16sgeZAcVwZdcckne11955ZVy6aWXypNPPhkpyF4uOoMgJI7+HXbYIfFzERwdRaUwgQvWc1HHH/lJuTiztrz8+VhB8+Bn+CDv+Y44HnO1dPSr5pMmD+TTXRrMwageNWpUrSrEOAEOvv9dr38mlzzxfq3f3zP2c7flGtlUiYHzqHN01YmiLRZ1RndWMqpSAhFBot7rwXOvawedTUgCNMFRP0m31EkMSWyTaqoEKUc7Q+8lAkO0J8fZmbR7R1I7gHuSBCmef03+SEocneDbGSRLapCr2AKQfLoh6MsKjp1KUnGetZ7wE3AI+muXLNYlfDf0pnYZ0er/cqUuE6hyyWj0I8Ff/D9qZ/AMl7KzW6Um6ObSGazVWLOxFQPrFcjlb0duIrtuuOGG9f5G5TqV7nSSI3B/3HHHVYR/OC3fFLoeWfDqq6+6hJuwmEEUaLv+2sdfyfkjGrtjoz37p/OXyfWH1k50XrlqtZx239uy9xabyFGjNqv1t7mLV8pxd4yXvQZ2lM1aN5SLXlv3+537tJUBnVq7CvVi+PlefeWyf3/gjrUaeXnaVzJw05Yya+FK+d6f35IL9u4ju/dvL00aNZQTtmwnfVp+I3966VN5adpXbvZ5m+ZN3HbjoYPkpheny5G3T3AB93uOGy7nPfK+C6Zfe/AW0neTFiVL8gr6zNSnjkz1170auM1i9ngW+8my4rzQ8xzsDqBrBTb8q1HjR6XWK0uryM6oiMA5D4NmZUE+JZM0cE6gkowtLmzc9uRpVATyfgQOTuNgu8TgvtJeJPtVJ9tuu60LFODIKufFeFTqcs55HPz7OTjDm0pQze5isV9Ma8ZyCGbX5b78ts2gSQqajYxwL+RozCpAosdilFZnJCVOpxG/NXvcapO0K86RJ+g6zg/ynnsMeV/KTiZB51O+gEkaJNVdUdu6sz5AdpTaKVTJrdrz7SssIVCNLM4751YX/5Uyt7AcKs6T6gwqFjCyFHQh8orzjcPx/vvvdw5o/ptg65lnnin777+/a7GoHH300a6ijBmGwNzCX/7yl3LPPfe4YAHBJFBHZjnrDO4ZnvVi7x21R7744gsn7zifw4cPjzzGxk+aGvCrZ2IHzcP0hx/MKJSwlK/dfLFBBxym3GM81+ihYGJM3IDFkdt0k/2HdgpNLgizAyrBwapEPQ/5WiwScEnSYrGYY66kc1xswN9fO2gCtCYxTJ8+3VW/cr792fRpj7NKGjgvR3lcDXaGJksB3VaKqY5M4tvi+NDlrKG0w8nLL79cdLU3FPqMMDvD/4xi1ra5Au/sE53CeVJfVth7y6FVexzydclCxrMm80f9ldM4nHLSA0H7zrczOE6CtIzP8WV0XQepy6XivBQ6g+/y4x//2PncSeAP4+abb3ZjGPGb+Fx88cWy6667umf8qaeeklNPPdXZMT/60Y+kPvimuHcprOInhX7BBKGoLF7xjVzy+Ptywbf7SesFU+WjeUvlmv98KH85cri0bFZ7ffKbp6ZK08YN5dy9+q73GSfcMU626r6x9GvTUM7/93T3+wOGdXJt2v845mNJyj7dVsvjnzVyQfNqZ9LsJe7nVpu1ll8+/oH85/0v5Lw91nVL2aJ9Y3nwpCFy0RMfyEF/fUuu/t4AGd6ttau+P22nHq5VO9Xnb89cJL89YID89ZVP5ajbJ8iv9+0r3+qf7N5I6lNXmwOfAjoZmcpzyvNeythAVoHzuqw4L0RwvFQwfsT18UeXqA1Yar2ytIrsjLIPnHMxWRhGzcqKa1zwAFDxhiMpaTZwsa3aC7VLDO4rzQAHGazsm0A9ixN9cErZEp5AJZUQmo2vwd84VENQP+p3wQjK15oR54uex3zzLeo6OFIqilHEwSQFZI229dJAGcaTKhmcvDzrWbS/xAioFkVTzjojKVF0Dc8BlV/cSxjqbEn0SzFzZn2QGTizuN8xttRxm+Y+wvCdVSQRMHcwV8AkjX2V2mFFZi1B/5deeim07V+aVFvFeZR9cV8G5xaGLf713OcKAFV7xXnwuyXVGVSPM6tQOfvss93PY445xrVS5H7nd7RcZR1CkPyCCy6o9RkEYv3j+eMf/+jk8EEHHVTrdRdeeKFcdNFFUs46g/svjeoj7kmCZpw3qrrJ0I87J51jCmtFHiVo7n9GoWBGruOHpLZALntF28/m04lJKv1w9I0/ZzsZ/ptXQoPn7/x8x1r7qiY7olQtFqshYBKHpDpj2der5ZF35sh1L3ziHMnK94Z2lGNHDZJhrRqvl4SHQ1F1GP9drK5KYpuYnVEaO8NPltI5lcWga/So96cmp+Iv8DucFOtDiqITfDuDTjPBdVGxxxAWeOe5wpfFPkkIy7UWi+vbKreRHsEuWSRCdO/e3V1vv4ra75KVdoJOtegBtTO4Z1iTYBOrjiTRKaqdUd8qztPSGVSM04UPOzoM7G0Sb4O2Bvi/IxkVOccc9HIOnHPtmE+Mji7GN8VnIOv0uU4aNJf/BrV7b9JC9hnUUV5+5SO54tnP5PCRXWVkjza1XvfUpLnyz3dmy0Mnb+OqoBU6Yf30wXelY6umMrLdN/Lzf6+bN75V+zXy9eo18tjEZBXix267mdz26qcuaF7fGPvpQumzSQs3A53q8zO3bSc9mops3LyJa8lOF60f3jvRBcyP3rqLu4922Lyta91Oq/aT7nlHrjlwoPTr2FLO/+f7Mnn2Ejl9px5uPno+0pBtQd8Nz7B2YcLufPHFF2vZHOiqtGRqfaw4L0QwfoR+0xgHNiDfg+uBrsMmYZ1aiu+2pIriGY3LvZUJD5oG4aJcTBbLvCcKmqmJEho5cqS7eZJQTCvdKO0SSxE492ctEjAPzrsqRWW77zDT2Y58f5IWdKa3LlDzLfTz3QeVMuc8SJyK8bDWjAhBf75FWGvhcguOpEWawREWtDyLbBoo04xk7l0NjuDkQhGUSskACi7tStxqhuuF8keu67yoUt6DheQ+egjjm3snzuiPfBUeSQNzfuVJWACn2Fm2UZ1PdFRBRiVNIoh6fKXQXb7DCjnBopMqHr/tH3/z53QXG0itxorzJEZHWPKYBiH82bJ63rUVaX2ccZ5EZ+y888557zWcUYUcUs8/X7vSl+ej3MllZ3Be4wQpwiBIzedyjybtqsFxvL8w/FmZfOFukT+D76GBnGDSVD7SrjjnXLP+J5Gg0LiSYmyda7f9Rn73QSv55MtltX4/5LIX5bWfbictmjYuu4BIIYqVz8W0WKy2gEka+mnpym/kW9e/UStIHsZDb89xm/LS2dvKgAFNapLwfNvCD9IksS2SrBHNzkjXN+V39MC3QhcWdGOxiVh6XaPoJL81O8UYfnJqsbPS8+kE36+UL1GsWNnrv5+fJKdxzpmfTsvifM9NlH0HZVe56wn8QWFdshgXocn/6hNiHZK1XC53PaD3MvqPcxXXzqhvFedp6IzTTz9dHnvsMRkzZsx6/mflgQcecPsiUbcQ22yzjRsdxf0ep6NfljqDWAPfl05dSZ4JvxCDIj/O2wsvvJDYTmEm+d1vfCb3nTDSHc9rs9fI3CWr5YxdNq/1upkLlssvHpkkl+w3QLq2qX3PX/vcRzJt3hI5pl8DueDZ5e53u/ZtJ4vnz0scNN+i00YuaF6fmTp3qfu5c592culzs2WXzZrIwEFrXNLCESO7yODOG8lP/jFZxn+2UC75Tj/ZqFlj6dy6mdxxzDC58LEPXKv23x80UO46Zpic+cAkN/f8iu/2d6/LEh0Nw4btR2cJ5Om8efOczuZZ9QPpxRTSqBzPInBerhXnUW1A1kl8PjJJrwf+AXybvg2YlixdVkXxjMbV1sqEBQUOq0Jwo5ARyyKJNjHFPKxJHDxx2iUWu68gnFseEAJ/LDYIAgZJ26nEMavDjOxA9snvUP5cZ12caltWzcTHsRa20I9zbOXuwCnmPPutGXUWlrbw8ium+TvPRVaZx+Xaqj1poAznB9eJZ4ZgKEqAKj3OpyqYtCt2MNridmKor6jOIAkJWU5As9TPfL5OIySzoF+StGYP20/SNpxBeZ9rtq5fRVKKZ0mTGmgXGzZ3ME2ykvXsJ6ytO1uaDqssv09Wuq6Ye8xPHtPFfzAAhBxGJmvws9p0Xr5W7aYzirczdJ2UNBlCE2K5PuiipAbj6rUiN05aX+a/8n+jpWHD6MmWJPYQONdATtyq96RrVL+6jzUTwRx+h04s5HROaoPod/vX6aPkyfdmy48fqD1bcdTVr8gjP9xKGpWxTZAFUVss+vorzrNQ7nZXEjm+avUaGXFFeHVcVHa45lX5Vv/2riKIZ9G3LXSOsXYSU9siapAmibwynZGebwoZx7pfW4VrhU2xwWr9DOBzctnxYa3Zg89gGj6ksM/QQpR8dkZax6C6AZlFxSpdDCl+UVkW5b1x9lVJBFu1+l1G8DeCX6RS6uBvuScd5LJLctkZnEvfzvCDDGl3TyvXivNidAbn+owzzpCHHnrIJRQx1iQXtGnfb7/9IvkLWFumGegphc6Ik/wUhM9QWadJp1okmNT2vOrpD+U7gzeVAZ02cgmAf3//azlzh07SfINGtY7/gkcny15bdHSbz5OT5sidr30qJw9YIze909DZK6N6tpGe7ZvLzR/EP56jtukmd77+mbw3a3Hs91Yrz0/9UoZs2kzGzflajr79bbnye/2lW5sNZUiXVnL/CSNce/ZDbxkn1xwwUPpv2lI2bNJIfrN/f7n1tRly3J1vyy+/3cfNPT/34Sny/VvXzT3v1T57v7ImGWJTsGnsh/vZH2fkj+RDn8e1ObJq1V4pFef54LNZpxFIZ92IXa4djf1CTI1vFNO9ZmkV+abKLnDuZ/JyY8a9OQsZKJoRi2FBdmqYYRGXuEZR3HaJaRoc2iaXfQYzkX3SbNXO92WfOkOdxabfFYDz57fL1ipffXj9hT5b3OtFlUm5zzlPSwhzPf3WjH5VA45T9oOB67dJKQVZzpbNKmDB90GpszCnIp1zrNX+WnGaliGl2c7VkqGVlc5AqWd174VVnHMMOCcInCatqk6z6k/nyBaS98VWFhaS/xh8Kv+zWDzVhbMmn8MKo6CUbXEraWYTRHkmCFJMmLFILnz8A/nsq8LJkP8Do5/1xdx1S9xXx0V+55k795Ajt+4izZo0qohW7f7zbDojPTvDD1LE0eHcA8h+1q0kxOr6NSnDLlu/e9Iv9u4r7VpGa8dM8g7rCNaBuZJkS2lzaNBds9mp5KISMYqsKTZwznt369denjtzG9nl2tdrvea7fxorp2/TVrZPPnK46sjVYhH9pRXRcVosVlPg/M3pC+T4u9bNqk6Dp6d84TqjqV2qtgUbPgmOQW2LYDKY2hdhcilucqXpjPR0Bq1IWeeqjPOvQxqBc91nrs/J1Zo9SCkC59yr+HjQL/nsDP+7FBs4Z32NY5cKKeyKqAGzJIHzSgj+5sJP/vcrzPwuI75cSbu4IsuxfaW0S/xEM4K9JG1o0IegA8++H/Th+SuFPZB1gm7aOoP27LRff+SRR9xnIDeB8+X7I0neozr7iSeeWO8z/vnPf7oiLDo5oReffvppueyyy+SnP/2plLPOULnIvRPnOeM+I2ZAEItCPx3HEiWZKhdvfvKVvPjhl/LUj9bNjr/++WnSdaNGskP32iNFHn1ntnwwd4lce8iQWr+f8dUyOfcf78r3N18jL81vKfOWLZXN2m7ogusXPTZF4rJLv/YuaG6szzuzV0jrpg1kg8YN5JCbx8n5e/WRfQZt4lq333jYIPnry5/J0XdMkAv27iP7Du7o7rXjt+0mfTdpIT97eIpMmb1Urj14oPzxxelyxG3j5fL9+svOfXN3+yoFYTqU+5cEEO08hr2qNge63R+VwVaoC1OWrdorseI8334A+aTnGvxiIOQxNuFGAR0X5fiqzc4om8C5Zo+yQZKgeSEDhYcSw0KdSPkyYuMQxxBJ0i4xLYMjTpvctFq169wpnDEDBw6saYGZD23rQRU+rw1Wk7Fo4D7hXIa1wz1tdHe5Ycx0qRRKZZQFZ2Fx7jhv/JvFKg7eUmXMVsqM82IyfjUQxsbzlMuQUqM0riGFY6DYuXjVTJjO4Pwi57NAdY0aRX5GcDGt2YNoVUscue+39KITBYZ+ofaFpQicq/znGcBhk0XQPAtHV5S1SRSHVaE5hNXWqt2v7JizaKUcf9fb8mmsoHhpufb5T9zms1HTRvKv07aW1hvm141xg6zFwv6CyRemM9KxM3TUR5xgh1Yb8qwTPEB3k1CXNGByVw4n0tGjNov0fm3Xy/dgfZIkaJ5GoEUr3eJ01kojcK60bd5EJpy3owy7/MVav7/+9fnySscmcvsgKXvqInATtMP8ln5RWixWQ+D8njdnyuVPfVSyfR1zxwS5/ehh6/3ety1AbQue6aBtoZU5uh5N0qrd7IzkOoNzTicl1nW0ISWpOkhagfNcsjhfa/YgcfVars/gOHw7o3fv3q6KLMozX6x/iX3jy2K2d58+fWLZ/0n0SiUHzsMqzNg0+Jur22OSLiOVeu6SdMLCXvMLfvygD9018Qf4Hcf8+ehRx0mGFfyUS6v2pDrjj3/8Y814KJ9bb71Vjj322Jp/33LLLc5vSVvzIMi3G264Qc466yx37ZA911xzjZx00klSzjojrl3B5zDyivUWci4oX9U3FFee87lXP/2h/GCHHtJho6by4dwlct/YGXLp6HWdYJX5S7+Wy//9gVy874BaLb6XLV8hp93xumy1SQNp0r6bvD5lhvv9aTv1lHMeqt3hKSrPvf9FovfVFxauXCvjPlsko3u3lSue+lBe/+Qr+fmevV2S/w922EwGdd5I/u+hyW6e+dm79ZLGDdfNPb/3uOHyo/vfc8kPV31vgPTv2FLOeWSKnLBtNzlp+3VjTbKS0YXWBlqUpqNSg6MykHu+zRFMlktacFvOhSb+GM03py+UO9+Y6boQFOLYUV1dLCxKEQjyQ2VTvmIgiqC++u/1wLehiQ16TXwdV812RlkEzrk5WGSowC7mhsxloGjAmotLq/A0syqjKEJuehamPPxJ2iUW48Ty5wry3XWhl49ihWncuVP5jiO40MdQ06pOFqt+RhIP7sk7VlbgHLJyMOFo5zwGM2bpwpA0m6i+VJwXMlxyGVJsPH9UBKghxfktZJRWU4ZWVjqDa8B5ywK/7RbtCXFcBTOC0yKO3Oe5puURLT+jBvD9Kr00CMp/ngn0TxaUY4VI0GHFvauyl3PEgjRXW/csA9pps3D5Kjnor+Nk9iI/mYUq8FekUli8crVrr6v85fuDXTu6cm3VbjojHTsjTrBDqw0JMiLv9LokDZjwPF7yxPvr/f79X+0e2dlGhjjterF9iiFpsi7rHYKsnPMkM96LDZxTBYkexPinouHlM4bJ9tdNqPXacXNW1ar8NXKf01wtFrnX/BaLmiRaiYFzHe1x7/i5cu0Lpa9+whH66fzlrlIrH/lsC4K2aluwjmCLo4tMZyTXGSSTkCzF9SFgnSsxNI3AedjnRGnNHvYZaVSc6wgoZEDcROGkyVg64pB7nHU0ujYu1d6qvdguI9qhULvlBLuMxKUS9ID6q4o5zmDQx+849p27kvkjNcDur0+SjmxLk2J0RtRnjwpytjD22msvt1WizoiqC4IdRHKNoUiiW177+Cv55MtlcvSobu7f1z77kRw0vLNstvHXteTyb56cKltutrHsMXBd4AzwK1392ARZsLKhnPGtgXLa395d99rvDYwdNKe1+JTZS2K9p74z5sP5MrJ7a3lv1hLXuv2agwZI1403lO16tZH7jl8XJD/53oly9fcGuIr07m03lLuPHSbnPfK+HE6r9oO2kDuOHipn3v+eTJmzRH69bz9pmoE4iWvLhY3KwKZDnlIEik892EY8yxbqWcjgBcu/kbvfXSrP/D13ohUJEm1bNJFOrZoJX33NmrXyzueL5bbXZrht177t5OoDBkiTRg2LHv9B/KhTp05uUx2n6wXsQM69373G70pWTXZG43IwUlXJxJllnougEuFzMSq4qLTPIoMt7QerkCHiV7oncSAVk6nLPmmhFXWuYBqV7Zx/DdxstdVWNVnzaS30EZBkd/N99MFVBw7nJ8yAK2fnWFZBnmAwO+iMCWYTcR39pAScAlGfnawrzrNukRvluwUNKb/1JYkf/M6fj+6fX2QicqNaMrSy0hlpOaiioPcAcofEkyiV3cXsK4o81gA+wQLkY9R24PmqWeKicwe513XuILKlUpwoWcD1CXNYqWzQBSi/z0IGFHtdCJD7weVq5qR7Jtb8N5Wsjf47azprh1Zwf6Yz0rUzOLdaMZLvGuSrNkwqU/tf9Mx6v/vnqaMKvk+DGQR0tF0vcriYNWaS76AjQjjPZKsnsXmKDZyPHTvWVSRyHQnyoqf/uFMjOeWFNRVlH5Qj+VosYvvx3HAdsAHRX4VaLJYLOJTPfBW3SPSg+eDOG8nBwztJ8/96H1+d9pU8OGFd+9ko7PPHN2Pfe7lsC4KKBFLZctkWPqYz8lcM4qDFPsZW9s8ff2d8AbIfGUPFYz6bMIouiVukEbU1e9hnpLHO5znnvsLOiDtXOIl/ie+LTlG7OGnHyPrWqj0O+Acp6mHzu4yQ9EyhCtcZmR+3Q2G5y/60Cz34rA/mfyNH3zEtlc/z1ycca5adrYKYzijOzojio2LdhGyP0kEkic/rxhc+lqNGdZMWTRvL5FmLZYxr2b69zPt0as1nvT1joTw1ea786/Rta74ffq6XJ06TJz5tKDccPljOe3iy+xsB+LhB86FdW8nbMxbFeo+xDiqP27fYQHpv0lwOvXm8XPHd/rJj77Zu9vndxw6XXzz6vhx2yzg3z7xfx5bSsmnjda3ax0yXo26fIJfu20/uPX6E/PQfk9y/f3dA/0xObTEyNtiFSduIo5+0iJIgu3Yp9otP0qaUMnjZ16vlD89/LHe/+Xno39v8Nxmi68bNXGJEk4YNZNWata6D49S5S2XGghWye7/2cvy2XeX3z30sz37wpYy44iV55Sfb1eoaEfw+cX1XDRo0qLHtNLGB9QLXRNcLFJC99NJLLuG6mHgGIzuuuuoqeeutt5yv5aGHHpL999+/5u9c8wsvvFD+8pe/OFuf4jU6m9ClQ+E+OeOMM9yYD+6lAw88UK699tpYo7LrPHDOF+XGVyGdRtA8qER0ljgL7mID1kkrzrWFFg97GpXucYwenSuIcU2Ve6nbWQGBbAL1XAedZ542/n3ityLnvCAwWXSEUQ6ZmnVtWOTbTzCbCIMcYcP5JPmEe1eD6NzP+YzlLANkWRsSSZWM37pZjVKdPa/nl/OK04vXQCGZxWdccMEFTpHMnTvXyRiUAQHLXDz//PNy9tlnO8cHCu/888+v1SILaIOFoqKSbujQoXLdddc554zy5z//2c2pGjduXM33yJURm6XOyDJwrnKYQGfaCUJJ5D4LCgLWVJ3EbV+YloMImYH8Z8HkO9T8ivZSy4VKdHT5Diu/rbsmhPFsF2rrXgxxrssr076SH977v+BxfUbbP7/z8x3rvOKcpBmolqzeurYzCukSzjf2BZ+Zq9owiT6auWB56O/7dmwZKViNIcjxaNeTYlvzxk3WJaBENQDt4XkmNGkqyX7jBld4PW2DYciQIU5e8jt/bvTDnebL/vfNrLjgeTkHH8JaLPJs8JMEBl3b5mqxWNfESfy6/eihMqJb7qDdngM6yEX79HXngc5nf3rp04KfSUvUti2SdSnybQsc29z3PDtB282vBFG73HRGbp3Bxj2800471bIv+T22E+c3age/NCvOkWNxWrOnHTjHzkCmd+zY0dmGSdY8cXUKzlD9viNGjHAyJekavz63ai+my0i+DoVsvC7sXqiEGedpHmPUNuxJPpf1SV37MU1nFGdnoItzJVHxOXSKwuaP2qk17vp+3KcL5L1Zi+T6w9bNLL/u+Wly6JZdpGOrpjL/v/qF47jqqalyzKjNZNPWzWqStLj2/5rXSg4f2UaemjRP5i5e6eySb1bHk4+0EH/po/mx3mPU5oulX8sXH38tO/dpKz/5xyQ5bttu8sMdNpPmGzSSaw4cIH9xc8/fll/t01f2GthBGjZoIKft1MO1av/FP9+Xo7fpIjcdPliu/s80OeL2t+XIng1kxxLaGGn7/oJtxNFHrE20eCiNbilZfRdtw37C3e+s97dWTRvKwM6tZPbClfLJ/OXy1bJVbpvw36QTEnd/unuvGptk+vzlbsTUcXe9IyfvuJmcOrqHHHvn27Ldb1+RcefuEFp5HrUYMGpXzR7/7UqGvf3vf/9b7rvvPveaPffc02277babW1dHHR+HHcla8/jjj5cDDjhgvb9feeWV8oc//EFuv/12V7xGTIT9MM5HbZ0jjjjC3R9PP/20k9XHHXec/OAHP3BxjIoInHOTIIj1YqV5A6qBgqN54sSJ7qFKMks87j6DhkiwXWKUFlppGT1+W3jmimsQLu5+4hoLBAAxNAm8Ut2f60FM4zyEHRv7w7Bie/NnPWTklS/X+vuLL75YU0FN1myhCuos58tmtZ+o595vk8K9q0JQW3ghkMge8oM5/mI+yyBCXc04T8sopWKBzyTpA6OUTKmXX1537/785z93M56YBxUWmD3xxBNdsPTOO+90bWLvuusu2X333d31CXvukQn77LOPnHzyyXL33XfLM8884z6DZxZFA3/7299cYP2mm26SbbbZRn7/+9+7v+GQ1kUKCTLaLuu8886TctEZaVV2FAIHArIOcJ6VOmkgn3HE/U/lC10iWFzoNUqyj2IcauhcjCuSmNB5/jNSbCv4uDqjkh1d/gKUADo/0VVR2rqnrRswbk+5b10rNiM3Qy57UX61fXPZZJO6qzhHJkOSDNpqpFg7A5shl8ylEhEdWyhJKUnAZNff1V63wkunD837PXV0Udic2WLletT3+yOhCG6wxsYOSbrvuAEOMtpxmGAUQ7DzlF+xMPEXm4c6uPndv47pVeNoKZdgdSXpM7UdcGzhxOBcaotFTapQ20GvR10FAjivyO5C/Onwwa4VZtzzcPpOPeTIkV1kx9/lD8ofdst4eeqMbaRYeAaRW5xf1gXYFsEWl6wVubdxIGnVblKdUagSBCfmueeeKw8//LAL4nM//OhHP3L2h8J65ic/+YlzrvEMY2vceOONLjBblzqDezK47tZ1v45kipoAkkZ7dOB4WOcjY5P6lZIG8dXO4Dpz/2AzJrWDowZ7cs1QLyY5Nt97+Y46SzWKj6hcyOIYwzoUanIvcoVzFwxU6LmuDxXnUQLmJNiG7QeZo+fy0Ie+KFjVXJeJCGZnFGdn5JK/fqEffreoQaW4uuWmMR/LESO7SesNm8i7ny+SVz76Up4+c/tacvn5D76QD+ctlZu+P8z5fDku1goLWveWGQs/lmO3by0/+tu65Pkf7thDfvJAdB9Bn01aWNA8RZ6fOl+22qy1PDRhtkycuVgu/24/d22Ze953kxZy3qNTXEv2M3bq4brj7da/vRsNdIabe75ULtuvv/Tt0Fwue3KqNO80S47cJtlY3bq2YdA3dHBEF+2www7Od8aa0++W4hf+FVNsl5YMXrV6jWun/ofnP8n5mkUr18hrHy/I+feJny+WY+5Y54tusUEjee7Ho+S8PXvL/kM3ldP/9q4sWbla/vz9wfKDeya6TgRXfm9A6PdJ2wZr1KiRO9eXXHKJ/PCHP3SxyIsuusgV7rHeP/30050tEIW9997bbbnuK2IUFAB+97vfdb+74447nP2A3XHYYYc5m5MA/ptvvumK3IBiwG9/+9ty9dVXu9hJ2QfO9aFMO2iun43iQdAnDRonnfeksH+C9hiNcVpoRd1XPiWpmWEsboqpso/TSsufsxX1nBdz3aO8t1mT9YXAGS83lCeObueEKRmzCE4VpGx12f4oqzm2SfejQpCNltTc77rQx6jF4eEHc1h81bcZ58XA56kT8fHHH5fXXnvNBbgxVn/xi1+4c4wyIGtKIcPuwQcflEceeURGj15XKYViohUJwfdf//rX6+2HYDjOq9/+9rfu33SioJXK7373u5rA+TXXXCMnnXSSy8jS93BMt9xyi3OCwY9//GP3EyVYTjqj1BXn/uxuHDkkRmVx7+WS+9wDBAs4rnwzFovZRyHYN+eD8zJ48OD12hWnNUM9TtJPtcD54p7O19YdfIMg6RzChSvXlKxaoj5w4cvLZJ8v58oVB3aqk8A5Wblk15ZrV51KszPCdAlJWRhhJAkNGzas5pnM9xm+bVCIFz5Y32l61IAmOeWyPxYj15zZLALn2Bvamt0fCZUkATeJDUJAi04nfH+C9iQEFqoi+/exm8uh906ThStrH9/et0+TP2w3tcbRoq1pS5l8XY2oveEnLKjtEGyxmHYiWBQeenu2/PKxD/K+Zvx5O7oZgsVAO8WXf7KdbP/bV3K+ZtailVIsGlQJyv9gi0tkBuefSguSZ4FnloRbtjgj3QpVgpCA++yzz7qEXoKeTz31lJx66qnOUbXffvu515x11lnOvrj//vvdfYBDjc/S5OG61BmqA7QQgnUuiVLB5KRCpJHQi2+HtR/PSzF+paC/Kgq+nUEnQXxMxeiUKIFvzjvJaXRODOq2YkYJ5tq3jjXkb8h69RFxnrUFc136iMoN1po8x2ycM/ydyHSuF8+J6s+sxk3VVcV5IZspShcbugNpx5Z3BqyVI28bL+98vv7sZ5K8bt2zeZ0Gzs3OKM7OCLMrtDss9kTcQr84Pq8psxfL6598JZfvv4X79/XPT5PDR3aVDhs1rfms5StXym+f+1BO3amnzJv1mfNxofPaduwiZ1z/qpy9e2+57F/r1k1n7NwrVtC8aeOGrp20kS5jP10ovTs0l0UrvnFJmNcdsoX07tBCdu7bzrVuZ575+3OWyJX7D3DtukleuO+44fLThybLEbeNl98fOEBOHbhabnltpkz9Yrmcv1cf2aBx+jKm1Ot6tTn8wjT83X63FGJV2Mz8TRO90PFxZGqxHUq4Ttc8My3ySKdv9W/vRhsQGNd27bRq37xDC/lm9Rp55v0v5dxHpsjSr1fL1le+LDceOsi17r/5yCHufhjRtZUM3LSl/GvSPPnlt/u41v1pFwNG0RkHH3ywHHrooe53aSSSAteTzrjYLgrXk+SjV1991QXO+UlxmwbNgdfznV9//XX53ve+F2ufdeYJSGvOUtB5QwstPpeMk6wqb1A22o6QzG4W3xj/cVtoFXvedN8IBIybYvYdNaMXgUSSAPtOO0kgH0mdcbS+YdMKagQpAR/uG7/tVFbfo1wrzgvBvUVGD5vO2ONc4pAhmMN9geFJ9WvabVLqMnCeyzmVNpxfnmPaj3DNqDIIjj3gHHMfB3/PuSYYHgYKxFcwQMBcA+E4Z6ge8avIObe8h/fWJVF0Rr4qwWLBcYKsozOAtmbHmZZFa/iwrGJ/FAcdPoq9J5NUcWiSGs8/OieXzlW5k7bOr0uZmpXcDsrsXG3dqQQiwYa/F2rrzrHf/Opncu1zfqartU4rlsenLJRld70hv/hWdycftF12Vq3aK2WWcCXYGUGHFM8ZwQOuKdWGUcYQ+bZBFH5w97oWcz6792ga+h04Htb7PO/55swWm0xWKEiheiis01SpKgN9qEikEhLnHhW2+p5C7+Xzr999I7ls7BqZPKe2k/pHrzSS50/uV9PqGv3GesxvS2vPWTJ7I9hiEbtdA+maCFaqFota5cHMvySVgUlp1ayx/HzP3nLZkx9KqdBntNA6kPUADnpsC9b6BKmp/CDZhJFNVGCoc6uYShB45ZVX5JhjjnEds4DWiH/605/kjTfecIFzbPCbb77ZBfF33XVX95pbb73VJfSSPEzyf13qDM4V8ptAoM4ST9JdimvCWjkp2pqdYyP5pBj/RFydGGZnlDoZSxOxdAxKUNcWm5AVfC+yh/0hk9Aj/J0NZztJcoBNjY+IRCrTAeufU86NdrlgvaGBCh3lxrPu+9fKqX17korzfAHzYka+cBx3HzfCBboO+uu49f6O/4H1CD81WbqUdkYQszPWJ4489NfjvIfkQdawSQv94qzv7xs7U/YZtKm0a7mBfPLlMnnpwy/l4n0H1PoeL01fLsu/Xi39G8+T6dMXu7GP6Dxat/fq0EJmL1ohsxetlB7tmrtW7XFY+U02/p/6yIfzlkmTRg1kx83burnll+/X3wXOe7VvLvccN1zOeXiKfP+28XLdwVu4a0dC57pW7R/Jkbe/LUf0bCB3HT1YfvrwVDn+rnfkdwcOqEmoqCSfXJgcD3ZLIflQi0+I/fD8aDdi5GkhP0rSDiUEzH/z1Ify6MR1a4p8bN29tbw7c6GsXC0yadZimb9slTT7bzLDl0u/ls++WiGNGzWQnfq0k+NHdXU6552Zi+SI2ybIqX9711WZb9uzjZy9a0+5+plprmvWHte/Ibe+OkPO2LlHrX2VevzHkhDfVFr6n6A5BDtU8W/9Gz+DnVh19LC+piIC52k7HfjyZJFwclioZZnhqO1NCMDmapeYFrmcSeo8wqgiw6bYfUcxTHSeLQ47f6ZiqUnjvPoV1EFByn2kiyAcZ9xLpW7bWO4V51Fn7Omsedri82+eS54JDF+/NWOaCSVZBs79GUalhGfLl2FhrUQwUglW0goFRxOK4t5773UBbmRQGFyPMAWjxhgGLt8x7DXIl7okaTZvGuiMPU2IUlmXVgvGOIaZPwcrza4qcZ1hmqiFE4Rzki9LWp+XLBbP9Smg4bd118xaDUJoW3eCPBu3aSOHP/C5LF9VXobrMdt0lSO37iKbbLSBm8GVJtoNBef7jAUr5McPTHKtyUrNc9NXyHbvfCybNHrPJZKo3guOMymWYAJXUGcYxckCv9qQFtPoP9b1rLGj6v84MvUPz3603u+ePnM7mf3hu+vpNG15zTPP8eT7nkkqDIPvD5Pb/kioLbbYInSNUkyApVDgnM+lItFvDR88vkLwmr+fOMJVXbwzc3Gtv5312GdyxzHDarWlxR7A1gK/W1WUJIr6RlR7Q22HYCJY0HbQRLBibIcLH/tA/vF2bkfJq2eOcMHkUqwhDt+qc97A+fJVq2XDkE5ppbRN0BmsaY888kg56qijahKD04J14aOPPuoq0pEPdKjimtLhCjjXyCY/mZfgLC3IsWPqInDuX3vOB8myOFyLKYRIapf43fxozc44vGKJeiy+nRGU78UGzvMlY+VLxPLfn0bg3O8gxr4oqtBZxdqunTUVSanY2uojMh2QHz13bFqpz1o4LFDBVtct8eP4kEoVMA/Sr2N4EvqZrzaWRw5fpyu16Idzq8lmadsZQczOWJ8k3UdIDqLogOuYr+ggLXm+dOU38ug7s+S2o0e4f9/1+mey58COsokXHOV7PPz+Utmps0ijBhvW+LrmLV4pd7/xmVx90CA57d51c5hP2qG7/OKRyYmO2SgNq1avlWc/+FL2HNBBznlkipy0fTc5YdtursqcKvRrn/9Yvn/bBLlq//6y/eZtXTelc/foLb3bbyiXP/mhtOg8X247eqhc/MQHrlL59wcNlMFdoo0MKEQWIzuiBrSJWbG+YOO4kGlq37HW0qCqbsHYVtyYw+IV38iVT38kD78zJ+/r2rZoIvOXrrPVmWG+YSOR9i03kBWr18qn85e7LgCdWzeVrbpvLGft2sbNs//nxLly6C3j5YiRXeRHO/eQl87eVna45lXXmn3sOTvI94ZtKn9++VOZMmed74v/DgbOS10MuLTKfFMV33sOhYFzlIrMQYMGuYUa/62zvrJAM1PZtBKxVAQNFr+dVZjzKCmFDBOdZ4uhkW/GY6mIYjSxiI3aejYoSMmQYVFDcIhWDvxdM40rtW1jVrOm1NHKvYFB5LdJoQqdAK1W93Mui80+znqeelaBcxbSha4Xs81xSuF0RPEhAw4//HDnkKqPpD3jXFs04kDKNT82i4pzlfsk+CB3ceQXM4oj3z6ioIGbqIlaabRqr9aZsGl+D60m27htOznIVdWxGGbBnH17tAEdWzpjrWOr/xnm6FMc0XQEKjWqF7j3urXZUB48actaf/9iydeyy7WvlWTfl77xtbz1fzvUJDEQdKXiLK2WxNwXYa3ao+gMI16VIOtArmOS9XWcgMkNL3y83u82a9tc5nnJWf56f/jw4TUZ9PkoRXVg1JFQpWipC+g/basbbC0dVdf4zwntDL/7p7Ey7YtlNb8bP2OR/PWVT+XE7TZbry0tiYY819ia2J+sc/3gbimcEJX2XCexN8ISwdR20Mp/vzMYSWFR1uKFqswnnLejm/9I0L6U53l411buvgrj3c8Xy8ju8auZiw2c+zpD25OnBXMEqTInoZq1Ccf2l7/8pWa0FMkROCWDVdx+tUhdgMxizY+c4dgJHBebhBVXDqqM1Up3nglNbC6GKPqgkJ2Rhk4JyucoiVhp6hXOI0FHnOX5/HZ63fEBhekA7fSUhQ6oVAic5wtU+GMTs66gjtN6N5c/Mc2AefBzw/aJLNC1KHJC7Qx/bKIG0nl20/RXmZ1RHOhB7GB8ociSfv36FSUrovqgHp84RzZrs6ELhC5Z+Y38Y8LncstR64Lo+gyMmfqFfLV8tRy8VU/p3+d/Cbl/evET2aF3O3nyvXWVst8e1DFW0JzALcFDIxuenDxPRvduK/eO/dy1xv/VPn3d+Nqzd+0lfTq0kLMenCSn7dRDjt66i7vG+w/pKAs/e19ufnWmfDhvhVz47b7yt3Gfywl3v+Patu83pHYhVbm3ao8Dr2cNzEbCpnYjRqaSIIe9HUxMirqfZV+vlhvGfCJ3vD4z0rFo0By+Xr1Wvl4tsvC/nYo2bNJQNtmgqSswmbNopfz80felXYsN5Nw9NndB8zMfeE9mLVwhv9m/v9xx9FA5+o63Zfc/vCYvnr2d7Dmwg7ww9UvZrlcbeWXaV+sdfxat2luWyDelo0FJoGd9ofBvxunpa7RzkIJtic4MGy1aiMqL/gUuBk4t0PmuvoMpi+Ami2cCK9yIO+64Y8kXfL7BUqidVTHkMkz8LORc82yjfn4xx5YUFqGFFrnadoprifMGYYnzplRtG7MKaGe1n+C+gm1SMMZ1oa9JLnHapNSXivMo86oJXL7wwgvu9cgiFAdtFnv16hX6ep5XFIoP/+YexvnMAp4t7DVJn/Us4V7TqplirxEGKUE+nKnaripIlhXnHAfVOjwjBE3S1m9Rqjj4rgTMcWpGDdzoZ2c547xaAudRv/eatWtl6GUvSl3wxKkjXWC6HMdq5NsXmby6FsCRsO3VuWfQJuG6F2fIT3brVWucSVhLYjXI4nS1CWvLG1VnGNHAsELvaUeNXK3Q0wic/2fy+q3b3jh3p1qOMZI5We/jZI6z3k87cI5TQbuvFBoJVUxL3VzHzTNE0BzdQ4AlzOnoBwLz4R/bIz/cSra84kXnsFAYZUEwc6hXdcFn+sFdf2Y3CTL8Wx3bPNdpjE+oRH2Whr0RZjvoSCjWZtwfhSoXb3jhE7nppXXyNsh/ztimVmJXqfXTNQcOzJms9f6cpUUHznkW4pzzUusMAue0XKfqnBbOY8aMkdNOO80FDIIjo8oF/CrIF+Q/zzH3V7H3cdyEXm3Nzr79Svc07I1C+kD3nc/OKEauhx0DMpNAPTqO2ZTYo4XeX0zFOc8KBRF8DjrM16W5rrUvz+pCB1QqQT2QK1ARHJvoBypKbTMUqlTMOmBeCP984KcMjk3Ue1E7I/j+tWKr+83OSI6OMEDHDBkyJBWfWlSdcN9bM+TQrbq6a//IhFnSs10LNzcZ0E10Wn3g3YWye/cmMqDv/zpWfr5ghfz9rZly+f4D5ez/zjPfrldbeeLd/NWzCnOYP5pnc82zZsyH82Vw541k6rxlcuydb8u1B60rYth3cEfp2a65m3v+wZwl8stv93XlFT03Ern76CFy9kPvu4D57w4cKJu3byH/99BkmTJniZy9Wy9XoV6JrdqTdiPGvx6WmIT8Re6i18MKIFavWSsPTpgll/wrvdFM+KtG9dxY3pmxWN6esUgOHL6pbLxhEzntb+/KT3fvJbcfNdR1CbjjjZmukyMsWP7NuuTynm3kkn9/6LoPEDj/atkqadtig0wrzpuXyM5g/YUcZdSUBsqJhbC+O+WUU9y/WeMhdyko3HLLdQU0zz77rPverDfrTat2Am4ssMgGJmNLFxJaYVTqKkBuxpkzZ7ogAkY9D1MWWZJqMODQw3GAAZqrnVUa+/FR44aHoNhqx0pyBPltp3znjb8wZUGqRlK5tm3MMkCfL2jB+YnaJoXzWshhnXXFeVznVBJwIMRp3YQCZ0PBP/nkk3LllVeGvg4F8sQTT9T63dNPP+1+D8gwFAtKaP/996/5zvz79NNPl0po1Z5GBh3nkaQsHDjMs80VHChVa3gfnhFkDs+HtrEsxf1XyKGWr8ovi4A235/3F3KkVJODKt/5uujxD+TBCdlVZRFYYl5WpSRvxZEBLZs2dk6wNBMQbnttXeA8OM6E7iCcB21JTPUwrUKRvarzwtqDBb8bBGecJ233V60kude0fSsZysh/qtGS3rNR9cNp961rf+jTesP/BUtwLJOwiuyP2+EpzcC5dhohMY8tSqeRtGbR8t+st3Fe0LY4nx7U9+bbd9ixvXXujus5yY+8bYI8d+Yo57gIw5/ZzefhFFX7gKqiQm3/qpVSyPpg5T8yj/NMC2u/ctGNxmjTRkZe/Xro5/TbpIU8EOhAkoUtkesegs++Wl7UZydxfpVSZxDA+fnPfy4PPfSQ7LPPPu53BAsIyjJHncA5Di8ckzi1/MTUukzURcbh22Ctjb8jjQ5Wcdqj+63ZgzIuDXsjV4Wi312rkHxNo1W7yl6cnNgV3IdR2+EXo1c0yRzfISPOgs978HOjyLBCOsCvqGZLc1RdpeuB4NhE5IGeO6r9eP785KhSJCHkkvtxA+aFOly+8/MdUxs1GUYhO4Nnm3tPbYwo/rUgZmeEn/co5w3dhx+dJIe09FsUnfDu54vk4y+Wyb6DN3X3xJ1vfCYnj17XKZD7A/k7e+UG8unSBvKjLWuvUf7y0ifyrQEd5OnJ89y/D92yi5z/aPRqcwua1x0TP18s7Vo0ke5tN5TDbx0v1/639fqgzhvJfccPd+Prjr/zbblq/37u9QTWbz96qFz4OK3ax7lgO6/70f3vySn3TZSrvzegxi6tlorzQoQlJvG8qD8UveHL07dnr5CT7pkoacNM87+9Ncv99yXf6Sv/mDDbVbRf/J1+8svH3pfOrZvJpfv1c9eKDgJX7t9ffvbwFHnxo6+k7yYtXAJMtzbrYlPBwHmpK86XFGln8H50l8IaGVnKOWed+uMf/1h+/etfO98IgfQLLrjA2Ygaw2Cdt9dee8lJJ50kN910k5PBxDMOO+ywvJ2NqqbinAuM4wbDaujQoesNfM8imMFCjgUdxjrtG7kILI6zQIUCBl2hdlbF7sc3IFS5smgtVGWSBXUZeA86bzg3BHW0ZRcBJb9lV6HK0GqrOFeDOsq+orRJ4Z7L1wIt64rzLPaF4R1lJghBcq4ryUMolv/7v/9zDp/jjjvO/f28885zCT533HGH+/fJJ58s119/vfzsZz9zLd7Juvr73/8ujz/+eM1nnn322XLMMce4gAEtAn//+987Z4N+JlBxzKbKjCQenE1cQzWA6wI/cJ5ERvnOI5QwVTKFjP5S6hp0C5nA3A84ejieUpHPGYZ8I5EAfcsiJEl2YtL2iryHSnscmvoZfqJSWAC/khKzokLLrQP+UvoRDJ1bNpSfDV0jTRquSwhT2Rs3UaKYlohpkGRftMHCKfbe54vlsFvHF30MBOLDZrdzHxOUZWP8g191E9YejOolfx3B6/kMXzZF1RlGbnDaIm9xrOvM5WLWTFHaKNJ2LcirP1vnmGX/3BcY62RTh9k7aRxDPvj+WpGSa554vn2n0ardb1FPYl+hNUaUwEqu6xrWHpUq4XHn7iBNGjUs+JmaxMioIr67thqnywTfwW81XuyYonKm1PaGdgZjY13ky9Bn3v5Erhj7QezgRZa2RBCcYFnbJqXUGaxd2YLH5FfI8SyzTicx98ADD3S/w4bmWdFk3qwhaOwnpqWxvo/yOWGt2YOkMRoqrEJR7Qyen1zdtZQ1a9bKwQ9qh5R140We+tF20r1d9KRK1QtaABM1EauYwLkmxOF0xYeD/yzqvvT9UV/v64Cwiupgx8Jq1QEQ9zoRqCCoyKaFFVrxF0xESxL4zXWMwXsvLAgeDJgXGgESZMh/k3KpBL3nuOGR3hO2Hol6v0SxM9S/5pLNIvgrzc5IXmSHfwz5yz2dFlF0y6Nvz5K9Bm4iLZs1lgmfLXRjyvYeuElNIiz3xlOTVsme/TaQ5o3/l8C3YNkqeWjC53LJfgPlpw+uqzbv1cFszEriy6Wr3EbrdirJL9i7j6s677BRU7nlqHXzzI+84x05que619PS/Yrv9neJ/8fd9bZr237XMcNca3Aqmv9w8BbSZ5MWZVtxXkpdqolJyEieGeSmJia9NXWm/H7sVJm7ovQxlgse+0COHdXVPce3vfaZnLlLT/n1v6bKP08ZKf06tnSz1I8c2cUFzn/1xAfy9BnbSONGDVzAHBavrJ0MWuqK82VF2hljx46VXXbZpVaMAohT3HbbbS6egUxlLBT2NqMg//3vf9cqYr377rtdsHy33XZz9wj2xh/+8IdEx1NRgXNuUJz33LT5Kt5KGcwIa5eIMyeLdr06bxFKPUvdr9ggQIZRRSYHrSvquqIvzv7DFp0Im3yZ/3GPRRemOpNPF/lUkZGVpHNNcTYG5zxkGeDJMkAPSRRYsE0KBr22ZvTnN/lzYkst9H2y2hdKIIqiwQgiOM4CmPOBMrj00ktrgsYkc2hbYOAeJUh+1llnybXXXuuCsX/9619lzz33rHkNrd6Rab/85S/ds4/DHiVExp1C1tavfvWrmn/rzMJbb71Vjj32WKkruL+575JUiWhrdmR8LsdVkFLOOCd4g65hocbc6jQcBHGdUX4iAQkZOILS/PyoOo/nHoceThUWYQTyCeIQUEcHaxAdnZiFjMskAWntWjn6icWsfEQkvZZPPsxNYgbSe+9MqOkCAn6lgn+efYdVklEBxQYi4+4rqRG1ReeN5LWfbiejimzf/un85dIjgkM5rOpGA25hcwv5XsHOJ1F1hlG4ywhre5z6/K7UbRRH/3b9Dgdkg+soJtZAPJdJguZpVAfyXtYXPP9xO42kUXGuGf78O2qL+qj7zfWaMLsBB3ncijHOvf9c8xxrNR02lSaB+a3G832nSiLL7iK+DN3pj+scvEEO3XyN7NOvtVsP87qwmXt1GThnDmgxaKv2OBSrMwpVguy0004umReZQXIDY6VI4r3mmmvc69FpJ5xwgnOEaRDxjDPOcEFzutrVBcEK7ywqznO1Zg/7nGKPJ6gPfDuDfWtHjH4X/ifyZ+7xh9zrpDfP3UlahVSpce8QtMG+xL4pZRKuP8+8d+/ezq6NS1I9Flzb+TpAx0341ehxE1TLPUm4GD3gF1ZoIlpYgqkf+E3in/HlfpQq80KV5VEqQaOMjcxFUh9U8F70Rwxg43Fv+kkdYfPRzc5IVmSncg5/Spo+I64p1y1fotOTk+bKxfsNcP9+bOJs2WNAB/lgyrpEVMZxbLjRxvL431+U677XW1Z/sS4ZCv42doYM6dpanv9gXbX5kVt3lcv/HZ6QGKRNs4by1YrSx0WM6K3bd+jVWi5/8kP56Itl8qOde0jTxg3l1/v2k9te/Uyuf+Fjadt9nnx3aCcnd4/btpv07tDi/9k7DzApqqwNH3LOSFJEMIJEARFBBXNc4xrXnHNaA67+uibE7JpzRtecVxEEEZGkmBUVjKDknNP/vLc5w+2aquqKPT1Dn+dpcWa6q6pv3TrpO+c7ctlr38mkGS3ltkM7yEOjfpVjn/xcbjhga9ltm2BjGvMZD+QT40Av8qpWq648/8NMGTyBgpP8xTsUNpzfbzNzLxk1WKNaFXnnmxmyT4eN5H/fziyha5+xcIVp3qAgYsXqzPNYzaHTozaaBZW4NqNfv3452eOuvfZa8/IS7NngwYMlCala3iq2CL5wfP2C27SAc62OddIlpgmeqJBEJbjR2U9pJ0j1uzGvibX36u4vK4kTLNA9ktZsIsAEnCMNBG3KLqqN7USaTdtYkTrO9d4kcS6UuZMmRYF0BYR59nBMWcskuiILoeMcQxOE2uTwww83Ly+hGsvNCJGI9hMqs/yo2a+55hrzKkThGQyrjxU00Xm2QZ2ItGacayWwFisRfKVdnOVMqGmXIbYnaCFBruOH0dtK4YjNI7jjs9xX7TKj4tMuVNLAH2AF3UNirrzNFvxy6gI55onPUzv+a6d1NzPHgswhtDsVWGcFcqERRQ/nSrCUNZgSF6SvU6OqvH1mT9nv/vGRjzHx9wWBgHOnYMuU+hOx7R4JQ74ba4me4Llknwe1GbYwc/aWW24xs58osoJWV+mtEIomLrvsMhkyZIi5/xRIMbcW/9dL8JEpuuKY+Dx33HGHodIqVGEd6WTiZbOMJBFH5DoGSS2nvHBqz6xRTHGB7zg2isQaL/YVs8BCMzjE7DhHn3/yySfmOejQoUOoTquoHed+4DkdY3FiB4rf7DFFSjXOWAAKbfm7XQQWpThpQwXOl65cLdvf/LHr374Y0DdLh5K81lhMCxfwG/LJiOKUzRrXKhPgPA6FYq5OkOeff94U9h5zzDFm7dGtFPbCfKWCfdAOEJ53injvu+8+Ka+xRBg7kIuaPehx4o7e0Dhjm2uGSdLS86YPSz2L2Fp8SsZgRZl9GSaW0AI0PkNsB/AaJg5JWoc5bYAWqALmE8PYjIXopnw1BaQpSa2h0uLycs6ftWfL6/q5FUe5iep9vy7z/e8fL7/OiTdOwylRwfOkbJQ9YgCxbSS6QQv7tCghapyhMnDgQHnllVfMvWKf8zwOGjTIMCba+SkKrGw5/fTTTbOGCrk/5tcOHz7cXAv2hmMXkr+kBUlacKoFn0nZFJVc+AM5BdhserdtLKtWr5G3v/pLTmqPXlx/XS9PnCatG9WSDi3qyJczMrZhxao18sy4P+TMndvKv9/+3vxu08bBdXURNC88GTVlvmzVUOSNz6fKd1Pnys0Hd5AGdWrKP3q2lCV/TZZB70+RybOWmg7mKpUryU5bNJZnT+wm573wjWE8HHRQe9mqWV3515uT5IcZi+X0nTZ1ZdTzkooCnGtu6YNJs+T8l76VfMpe7TeS99aNTbhrxC9y+6Ht5eq3f5R/9GwlQ76bZcYD3jp0imm8saVKJZFFyzN6olrVbPuRjxnndSvQGMGCn3GOc62VokErU5MGzjkWhh7H1g1ATgs8cc71o2CAwJMkZtogCg4oAiBJ9XchdTKVJyBE5w3R2cs9w5nCMdVCEF1XktJNmzZNVXnlm6o96QSUPb9J15Og87PPPiuhwtSuSHX2k66iymfHeUUyNElI0L0bRv/biasg1OxxzhVElJKWRDpgMToBiQuehO3iIKEPaK1BXxJzWcN0HwLiAdrbFI5qk7wKlbSwhnuJPiWpq7R+CkaU9YgRN9ntP2NMVWga3eSj/9lHqlYOljjy2/esI3tR9yNMKloQhn+CBKF1z2dHXxLn2jQmmLFgWfxuNYT1hDpc5xbiP5B8BtR8+eWXDXsI9oLkO35q0Pl52Bl8WsZ2HHLIIVl/4zyA6Dwzr7/+uimUoFOQ2bRK8eiVqOaZ/fvf/26YTcpSculygBrocblmZ3FQPoDz9v8uDVTUWPSnfPn779KxY0eTXAdQddN9QSWK7eDeo0exjTzXQQtjkuo45zPoFkAOKHWjMJ0EAc5zvYcOc6VXVYnTKeZHNe5VnITtQv8WemdhWQLnw76fJRe8XDqBdfFubeWEHTJ7x0mhr7EYBfE6YgtQi+eVe5HvJHzbpuEBxLIGznN1gmCHYKHyE3zMe++917wKQZwd537dfEHFDSwJQs3ulCTiAO1apzAL/+GcUZVERv0iIrzSly4Dldq6kkzaI9qeD2pXyBsCXmFHYcxi/cLapLBU7WHErUDVWQhsz/cOCgRvKHbAOX/WblSxi6P05cXats+TpUdtKrtM3O7yNCStHJQzztDCPp4jAG/G9mmcgd0MOyoUQPzss8827HHs9SuuuEL23HPPUvEEs2jt7kG7uAY9ut9++xnbMnr0aJMrOO6440yccuONN0pZiJNFlFwkz68bS2vSOaNcx3v3m+my+zYbSfWqleW1MT/I6lUrpM+WrWWbrbcq8elf+myqHLZdq6xjDfluhtSuXkX+WrDM/LxXh2ZyY8Bu86IUrvwwT6R1/cry++zFcvhDY+XCHrVki5aNpX3DtfLUsZ3kwlcnyY8zMyB5/ZpVpW2T2gY8p/P8mCcyVO1PHd9Vzn/xG/n6z4Wm+7xh7WoFQ9WeD/s4c8lqueWFH+WnWZlnI58CaG6D5/eN/FXq18iwD372+3wzx5wRIs4RcMtXrTFsy0ijWlVjxw4bMp5ROOVZISq2ckmShkmrVZUm0C0hnBaoYdNL2XP9os6KDSokqwAjERycoOueTylvSSTdJwRBvEgskwzl3uI0khwFSLeDpKS7JQtxxnnc9dRkA8lVgihNPAIqkHjUeZIkf5OYJ5nPjvOynBVeniWo/o+SuHJKkmwjXAe2huunE8PWu/lgNdEuDh3NQYLZZlaJK0ESVvydgBMwNizLiRbW8Kyjgzp16lSiDwpptiAObI9BwefiBZX9OjaTgX/bOhYtYlBhb5I04ZWL1h2bpgUL+e44T+L+Trisb+T7tflG8cAQN2H9SACyxhTXkMTCn2B0BvqMpBfduXTu0U3ut9777LOPebkJPsmYMWOMLtB5oPfff79JWD333HNyyimnuH4On5EXcvnll0uhCr4X64W+cGMZyQdw7pSuzaqYYlWuRxOJcQtzw8YnaheJfaBLpkgj6vmjxEasF3uOdcB/iwKaB9UxQcD1zwfsJF0HpgOe+xUnafeXJq5ZR9ZFi8DSHt0SV/Kl63e89WNZuK6TwhY/Wn23WAxfAb+Ddf/oo48iMarEkc1jAudRinqLcUZ+cklO/z0oNXsa1wMYi44/7KXpUtaidPCT/r17qM/lyoHZI6bat29vCu2TKOZKW/wYC/k+NtW2zVhYyJIvO+CcLa+07jxrdqOKHZewnl5d5vkCzKP4EvmIW52FfcQZNG9dffXVJfkBilH23ntvufXWWwPdY0b+2QIrCTE+7FQ67g8hjvcq/qVxjJzp0KFDTcEEDXXXXXedYcaCBbEsnwn8CGXps3P2tiQ1/iOITeDZg6adudbkP17+9E9D5dyh/TYl7/ll9hL5auoCue+oLlJlzYoSvfrKxGlyYJcW8uBHmYKqHds1NscqSvkWGil+X7BK6taoIlttVFduGLdEzu++QNip0yZ9Lldu31Ae/HK5HP3YZ3LPER0NYx4A+j2Hd5S7Rvwsxzw+0YDqz5/UTf7vrR/k749+Jrcc3F66bpJhQ67IVO0A0k+O+UPuGosvkH/QXEVBc+SnmUvk8O1ayuzFKwyzBPPsYUucv3RVFhvX0pVrZOq8zDU3cYwqTruhZXEFwzMKEji3u6yjzNVOKthRAIFEJFQyXhsrDVCDjUbHHwEVHd9OECUt4Fypu0gmkDgtK9o6PwmrGN2c4DQSX2GFe6sBklZgapAE8Gt3S5LcjesQ5nv+Rz6Ec/HimXfritTqbapjeUa1MIH1jFKYUGgzzosikQIT9gTU7GETV27nIgkVV5Sa18vW8HOcrsMgwrPAdQCC0u0YtGs1zPH9kk86z5znFsAmaoWiPtN+82VZa65Fu6TRsWkWiP0+d6nse190ym83ObBzc7lu/60S0elx5xDmonXXAqa0WRPSCAaYAxZVuuUIJqOKXSGMnTjggAPkpZdeMskapTCkgCHO3tBOO6fvCWA3atQoT+C80IV9wb4kEU3ij6S62zolNU+WZ8ttL85fWlqfX7lzU1P0YPsYceOLMPECiWYAHZ5X4g7sIp+Pug5hQQqAAuIevj9FW1Fm0ep5c33nwAw2lSvJJ//cUXrfOjqvMYTd/UURAfEwCWU/EKBQRP3ytJNYzJ13k7D3RWMxdB5xBHvPHo2BKIuVMqok/d0aBejaSbqotxhn5I+qXUcNUcQZlJrd7Thxrgd9usv9Xxdc6k8B9O+v2S3QevjZRC284vklr4JutCVqx3lZiJNhT+d709EKeIidxjYTs+WjuKc8NbnYtO5aHKX5IGzp6cNXudoNuiqDguZB7EwaAHxZ7En2IZ3eL7zwgokzzjrrLBkxYkSsOIP9jDhBlWeffVaeeeYZk4MgtrnqqqtKus4Z3UNRPKC5CkXCxD2AwxQTl4XouD+eQxofvPK1aXSce/m6X09bKAuWrZQqs3+SOZUqybfzq8glB7bNes+Qb2dIn82bSKPa1WXJklXmWH/OXybjfplrwPJlK9fINi3qykOGlaQo5V1WrVkr1atUMrTdn/2xUPpu3kgGjZsvh7apJKfvmWk2ObPjbHn2qyVyxCMT5KLejWS3Di2NHr1o13aydbO6cvEr38qJO7SW2w/tIIMnTJXTBn8pZ++8mRzXa2NfXZC23oo7ns9PJk1fZMYo0vhSCLLFRrUNaI7UrVHVXF+9mlVl7pKVUr1K5ZJ55gigOsSTjG1AnPT6+eg4r1OB8IyCo2q3K7a22247k9AOK3ENEw8fjhUJiiAAghqupBIFCqLgLBNcuYEoSSegOR7JGAIr1h0lCXCeltMbd53KY8e5n3BPndWyzm5JBR94Remezvf8j3yIHy08CX97lhjKW7t3SFxoYYIC6UE6ePLZcc79Lsp6Cbqn/JJd9jzbKIkrp8TtBuSzBJ4ULPnZmrQ7zgGteTaQOKC1n/glrHTkggI2bjSpQe+T13ncZguiC+zZgtrNlwQQMfyH2XLei99IUoJT/PFFvVPRrUnaBj9adwAgzkVHq+reKDMug0g+aeG9hMrfNMQt0FGbwZoyLzauACqjH5lR++CDDxrfhHm06CroEcuDOPc0e5HkFvoOPednY5PqOPfai9s7Zr8iJATdjpGPjnO7aFbHY+jno/rbYWIVdAP3Rml1iYOinlevPZdOC3p8EhMvn9pdDn3401I6vv9W4WPUsML3QK/qvVEQAPuls13TZKsKK7quaV3Dz7OXyN8emFDq9yMu2EGa1KkeO3ZxUtYqo4o9i96OHZIYARN3raJStRfjDO/7kFR3oPqz+LhuY0GCStQ4QOOMA5/7I9TnvDrBKTpD//iBVAqGhxGdsZ6rA93Lx9fCK9abgmi3mD4XcO58DtOkao8731tnexPPktOwxyWl5VeHlXyyTAWd5+0GZt/dZ00gkDtsUVYa3etluZ5qM9hrBx98cOTjoJMuuOACAzKT+1A5+uijTYc7bGbEiXSSk4+HKh4hXrdBc0R/jlpomQQ7LqPhgoz7S3rGuV+c8u7nv8gWdVdLsyaNZUHNZlKj6jfSsVV2Mff7382QI3psXHIsntfXP58mvds1lo9+mm1+v2f7ZvKf4aXHGRSlfMqK1ett2ajJc2WHzRrIKz/Pk2qfzpELdm1nGla7dV0lL4z7RW4d+ad8P22+7NRspTRq1FA6Nm4sDxy2pfzfe7/JxD/my8ADt5EuG9eXf77ynUz4bZ5cf8DW0qBWtQpD1U6B7r0jf5VHR2cKaAtF5ixZX3j/xdQFptu8VrUqprt8+eo1WQ0fv8xeKps2qiW/zFlaJrjG4goWZxRU2SlAIYkTgn6/iq1cEifhRXcUHRcY9aCzvXXDxX1oOSdBOdWkJND8QJQkgXOSifqdlY5elVwayo5AlOII/lWgwmsmqpsUghOelHitr7NbUoMkXoDo7G/nTNkgScKK1nEedJ463xswkBdgAOunNF50lOiMpVwdPGlXZtkJgIpUoZVP8dL/Os8WHR81cZUkoK16Fz2Yy9bEBU/8hOdAu/ywOWnNovFKWBHsUigWhV0mDgWvdklzXrsbwQlEYKNIQjmvy+0cT439Q24ZmlyAee+utWTrdpuWShQkLWnaBpvWHd8GgIx1TxOEyLcdyre42aGkbQb3gWTVySefbO4N52O+OdTuZZ1EjiLMc0X/kzilYybXDOMkElx6jzhOrvP995QMvb1T0u4459gA5gDVbsXKYeONNWvWyoc/zpIzBn+x/pcfZkCULTaqI8+d3EPqW4kVL1rdqJS6QT8bVt9t1ayOXLpHO7n5/fX6ncKosZf0MbMgywoEcM52BUTh7zalb1I6tRCA85uG/CTPjp9W6vdJdP+7Fbg4GVV4XrSo+eeffzaxbNyi5iQkSmxSjDP8JSmQQzsrdeRfHIarsHEAccb6ueL+8r9ze0u7psFyXrmu48MzOxq/nngbQKn9vz9IjMLdTb87C6+8nsFCpmoPI+RHidewmwCP7A1ncY/m1/Crc/kfFR04V3GC2Iz06HzjR3Lux946++juLWXA3ltGPmcc8Nz5uebBU6WpSFI2g1nn2E7Yq2w57bTTSv6fPDjP82677WYKQ8gPFKLgG5DDCZI7Sbrj3C0+0Oa/kZNmyH6dWxq/+rb3f5K+WzSWyrSerhM6y7/9c6HsuvVGVpGsyKuf/ylH9dxEBr73o/k9oFxRKq6M+WW+bFYXCvBZBly96cBtTNH/0TtuIZ03a27mmS+p3khO37yezJ8/TxbO/UXOb19ZXvhltRz60HgZdODW8uIp28mVb/5giosBz3do26jUecobVfs30xbKkY9PlEKUOYvXA+e/zlliirtXrV5rOssXLluVVbwwedYSQ7nPvd2zfaahJZ9MuksqGJ5REMC5Jk5w9pihQiI7bhdgFMOkiTWS1BiaoBvJTo5FDZgBdbQTJpcBTnLGuc7awsFmjqV+F86Rxiz1RYsWGZCGZDrOhs5ETbrbr7xJrv2uQRIvnhfWkSCJPUvgxN9zgQ/5BM7z3XEe9nz2rDCccYAypWbE4eR5JAFmzzjU56HYcV7Y4tYlotTsPBvMxEoqkRwV0KZTjOuBHtRJzesmaY3noGgEoBi7i3OTpji/A3pCC8U6d+6cGDgcRfd4ARHcJxuI0LEZttz/0a9y38hfE7n2Gw7YWv7Wef06UMWeL52dL8FWAUA4ad0BIZzMKnHm0AcBK9OUNME0v47zJAWAGf+QxD++KfqqV69e0qNHDykvot126Dp0LV2kQSSJBBd7l+fXeZyffi89X7Zra/dCrjQ7ztFz3F8FdNwKWHMC72vWSod/ZzoFc8lPMxdLT5dO+wf7Vy1VzJYP4Dzs8Y/dfhP5z/BfZJlF19frlo9952nne7arFoU62ao0voqjU8sSOF+zdq10uTF71rxKUpT5Qfx7nkfWUgtM7BEwrDU2zaZ1z1f3P9ce1t5VtE6QpCWuDeA5wK8B9EEAdOPEHmGvB/91x//kTvyGnTHuZxO0AQR7a/v1eo4wneheALp9fr955m4Slaq90IBz53rY86jdxiW55TM2JODcC7gGNPeSlw5rbtZw2bI/5LPPFhqdjt6Psn5JdZ7/u1fZ5kaTsBnnnHOOvPXWWzJy5MiczyvxBsLzTa6OHOi4ceOy3kMeGUl6vFxQ0cacMDo8qefCaRO0+Y/O058XVZK9u2Wo2SlmPX2nzbI+O/S7GdK9TUNpvI6lh2NNWyIyfeHyEh93rw7N5JGPfy01JxvK76JUHPllUSXZtFElmTp/uRz71Bdy99+3lY0b1pSOrerJcyd1kwte+lau+mC23HFYB+nYsZqJMdpuMlte+mKmnPXfb+TAzavJeds1k4//qmEKig/r1lLO79+2pPO5PM04h479ruE/y9Pjpkp5kFmLVkqtSqtl4bK1MnPuQqlSSaRWtcy6H9q1haFx12U5pEtpHVnsOC9nVO0k46hKhQqNeUTOpHQ+ggsccIwySQbAYzqjwogG2lGTWwpe893p+MgV/MahTlTh8wAWJBS9KIvjJK7cBJAXsIjkDg4Qzj1FEvxrzx5iTwCea6InaLdfeZxzHmV9WQs7SHJ2QDgTZTr7Kp9U7fnsOOc7xT0fyQwCfF6sE86nAuk8JwjPJ3s1CKV7XKEwolCo1gpFAs8ktfS/Tc3O7HB0T5LPQFhbY19PkCRPWsC5dhnSnaBdhvyc5gxq255QqIItALgJSg0f5r7FsVteQARJSNWvY2ZXl8GTVosMjZ8I+ezyvlKtirv+yleyrqzGePjRujMqh/eHZVYplI7zURf1zitwnqbNUECThDjFHNddd52UB0HPjB07toRBKgybhtIWxvVnnPYIHbLfk8FZKZLoOHf7vBYKB+nQc7MLz477Xa59e5IkIWbe6PDxWSBJEsB5UlTttoy/rG+pWILke5qxRJjrtItCncAusbbq1ChsX2GvNymbsnj5KtnBMWMeeeesntK6UXLXH+VZd46A0ZFQ2v3vHAnlJsyGjCs842FZ+opxRnpU7eQx0K/sB4qCsJtx/eugcYDGGfs+9XOigHkum2A3gHj59ZyTfB92+WxvzLIUgG5fq+p3ZS8k/xGURSwsVbvX7wpZnH615jO0mMpmNOSVdk6jrNfPaa+3bVlXvvlzkef7nbbcXj8KQhBnXJIvKeumojg2g+fu3HPPlVdffdXMRyf/m0vIjSPYVwQ//oYbbjC5Cwrdkffff98UBFIYWxYSZn+HYaEKejz17+3mv1XVm0vTut9Lm8a1ZPqCZaZolVnmtnwwaZbsvs1GWd/j67mVZMe2jWTIdzPM77Zr3UDe+zbz/ypF0LziSa0qa+W3ucsM4Lp187py9OMTDUjO/W9Wr4Y8fmwXufadH+SoxybKXX/fVjq2yhSHXr7FFrLXr3Pkkte+lykfzpIj262Uf3ZeI4N/+EtG/jBDrt9/S+myaZNyQ9X+/V+L5O+PfiblTapUqSrLV6+Qr3+YIk1qijz1QYbx7YguTeXC138yc+2R7TZtkPeO80UVDM8o045zQCmcbAwe3Q5RqdmdwgYgYRZE7JmHYRNrubpKgjzkOLEkI8PM240LonCdJP8BAugc8grmkwLO7aprKKVwgOy1wnmgk4mXs9uPzwBqaoU/12pXAJe1Q56UxGVYsDsgbPDBdvIJMtnnFW3GedLgCNeOkucFsMk5dMYhYA56CyBNE2FJ0gsj+gwUO0Hi0Sva1OxULWNnkpYwwLkm0ri3Ya8nSeCc9YD1Q7sMYf/Ixxx1tSc8S5wfYBqbmzSNbNK6R4GI7+aKnDGU2c44mNHXiQrQa/bbKvD7KxJLSK7z2LTuyqyCH0BCICyte1K2YdHyaIlzr2KIJMQZ6ES1GawvRaMq+Gkkqlhf/NEXX3zR+GX8P6Db+eefLwcddJDsueeeJZ857rjjTBf3wIEDS/Qco0/0/7GZHBPfGmaLfAr7g72EHQ8bGCbBJKXH4X5pkTBr7pR3zumdmu63C3u1gBK/mnsdpFDYef7xv8yVfzyePevblr9v10ou2G1zaVq3htmTdBXtvffeWe+Z+OMfcuQz3/t2GY48u0vk751Wx3mhF+IGAXbVl1W2L3SusqlQsJxEMjdJ4PyX2UvkAJd55mmsdVyb4RwJxfG0+59YbMKX6MXS63tan03zTtVejDPSo2rXZgieJ6VmT4LBJMgxNM445s15nu+5q/cq2WWXXSJfh5tNArzW75yrAUR176R/7xG4C93uPufzWhTHeYgjgoK/FYWqPYwA7OKj8eK+MZMZnfTHH3+Ygmn0lT2mLsmcSlnn6dy6vL1Acy+bYq8f30fXjzFjtg3NBy1+WRYDx7UZ0LMPHjxYXn/9dXMMnUlOwQtrjF/K3/fdd1/jj6DHLrzwQtl5550NewVC7AFAfuyxx8rNN99sjnHllVeaY+ejqSWu6N5IGjin6YwmH/Xpbxnyo5lTzrM3avIc6bxxfWlYe328vGLVGvn0t3ly5b5bl/yO9341p7Ls17WWDPshM9/8V4+5yEWpWLJ0dSVpUqeazF68Uj7/Y4H02qyhnPHcV3LFXlvIQV1amM5xKNifGjdVTnrmC7lqny3lgE4ZNplubRrLy6f1lKvf/kEGfbFArth9U7lt65XyxLi/5KTB38g+barI/ptXlxrVqhocIi39GMfWwJz28Me/mXnm5VHWVKosjWpXk0Ybb7m9v90AAQAASURBVCJbL58tD32+wPz++6+/kGnzqoh6L1UFv61K3kbQrq2AeEaZAec8PDjZ7dq1CwwYBxU2AOBhULpcqjKDzDz0k7DJLa2UJcDyA6+TOJcbaMIxCDYUNEn6PCp2RXAQsMit289JOaUPIAmgfFJOpSFpBGNO8EETZcwAo2CCSnQ7SEraiOV7xnna5+L4OPa82H845/y/dpRgFNjXGjQlMeOQLoWKNBMkKQmS9ED/k6wcPXq0uR/dunVLzVELCjZrUklnYYUFi5MCznUOIJRmdLzb+5T/D1pwFvXeYe8IhqHpBkRLS3cnpVf/WrBc9rh7bOzjvH56D2nXtHArLguRjcRmVnGbLZuL1j2pAq7eLp2OQe53moJf5exyiWIz6ILr379/yc8XXXSR+ff444+XJ554Qv7880/zO0A2gDdA8quuuirrGCRr7HWfNm2a0bkqt956q3mRqKfLJJ/C/WfvRNEHNnAep7iHtcEe4XezR7ffobfIB9nJ3M038r5vSVC1IxyDfaPFW3QEBglmbYYrL4DjoWO6yi5bNfU8t+oX7YSc9csUGX76etB+zM9z5Pgnsqv8d743UzH/bZ+1UsWay1goQMcXV+xUijo8TfA8CV3mnNetlL7EwhQmETcnQembFHD+0sQ/5d/vZOZs2pLWGnPdSSaQ2P9aXAvL2uOjScqVTszNnT5VKsWkUI6S/CrGGe6iuiosra7dJOBshsgHcK5xhmHw8BCA5yFDhiQ2/oPvTFEIwA2zzGHBy7VWzniGaxrxwyw5/dlMd6mfYINeObyl0VmsL0xiYeLtKMB5ec4xOYW1Iu/Di/wrhRbK+EjBo46aUBvgxvhYHoDzMLToN/VrINtunJutAOG7aD5IGTOdOUrNB9mMj1GEjuBC6ziPYzPuv/9+82+/fv2yfv/444/LCSecYJrnhg4dKnfeeac5DzngQw891ADj9veH5v3MM880uRSuhXjl2muvlbKUoHolaqOdl7D/0KV04NvNf+N+mSvH9Gpt/v+z3+ZJ900bZn3u8z/mS/1aVbPyEsw8n7qYZzXzPfpt1VQGj/8jkessSuELoHnNqpUNTf/YX9gzDeTmoVPMjOwL+rc1cdjxvTaRLZrWNh3m3/61SC7ata1pEmCm9h2HdpDXvpwuV/1vsgHVrzikpxz610K5+q1J8umY5XJEu6Uyf/5HJfox6tiLpLGH3+culSMem2hmg5dHoeBhxeq10rZJLfnij4Wy3WaN5aOfM8C5tNhGNmv8m/w8Z7n0alFZPvroo1J5s7RxlMUVDM8oM+AcIIMqsjScgFzBhd1xAUUh3ShxH9ww3Xp0nBDc4CRQjRy2Si4qiEKgwXndQJM0Os5JzpEs5F47GQU4bpBj293UBGUkdkjiUvGpBQBKOcjLj7Xg8j03l5uGZGaNFZqkFVjYiTKC206dOpXM804yUVaROs5znY8kupNeWANPQAP0AEGpAulRZhxiaKKwX2zogk7RIJaq5CR0u5/kAjXspBJAMcnqKNcTtxvcTuh5UcR70S8mIZyf50TnmUeZRRbUZsS939CQdRsYkEPSR+7sW0mqrF2d6YxeOlsYIR+GarwiUrXHOY/fbFmbglhtWdpzm/wk7SIJN2qtKDaDBJbfHjvvvPPMy0+cYHhUoLrQREfARKXqRVgH9uH3339v/FfWxq9bOw3dr/sE8J4iVny8MMVbnH/OklWuoPmQ83aUNk1qBwLtWQueU67DWUS7Q9vGnjNwdX56GFphm5XKay/GjW8qV6okQ8/tJbs7Cqu+nLrAdPeUZ0pfYsU4lL5xgXM+v8+948y8RWdn9rn9sud0JilR6M7DyO3D3btZiGd1vdWG8W8YCuCowHkxzkimO9BJze6kDU8CONciJmfca4/eO2eU+zP3+b/6S63qVRJjMeHzyl5IQS7NJzoeIuj3sP1BQBp0fJDu80Ne+FMe27OuiWXCSi6972Yzkh5bWEiCvrPH1OmoCe4p8SJ/D8ry5CZlsW5hQHOKsPCLosYKfuOmiP35/qrTw8r5L2WYm1TeO3GLknneZSVxbEauvQBQ/uGHH+Y8DsU577zzjpRXScIW2Dl9BJ9afRe6yb+fvki6rPNDP/99vly4++ZZnx0zZY7xu20fbfikWbJ5A5GvpmUYGaDppqCpKBuO6Gx75NPf5ss2zevIu9/OlJ9nLZGbDtpG6taoKn02byzPndhN/vnKt3L8U1/IzQdvI5s0zOS2Du7SQnps2kCueGOSHPHoZzLwb9vIS6f1lDv+96Xc+/UCOaBjSzm6bR1ZvGh+CSOuHWP4NXMmnV/i/S989qdc/+561r3yKBQ7LFy+WrZtWU/e+WaGHNkjM9aCDvSPJs+VSpUzft+/DtpOWtWtUjKGFt+N/AbrAHMH7IJR8IoNLc4oU6p2HI40nCo/oxSHLjfXOYMEImxOkkdUypJIi+KshQ16WONffvnFUHKGmasbJ1hQg55rfmJYQalyTBz6Pn36lFC5ooCplrVnezs70I7puXEp4Lys6RXzGVRwLp45QF0UZFqzr/LdcZ7PamY3MEb3pHPGoY4acM44zLWm6CiKGyoStUk+ROfroRPY4wRhaYufrcEhwTFhL4RJKnmdJ2qii+tQwMJvDqDdWZiksJexufxL8UAU0DyMRLVbYZItXjJxwE5SdV13pF8SSseOBGFCyJd+yxdwnpRtcFIQ89yz1krrrucj0Rd1nMboKXNCf2bEBTtI2uIESYo2o/ASXOg7ErL8S7epznOc8Gs2he51B/gn/5PqOP/000/NddBlFuZZH/rTfLl++JKs3918yLZyYJdMcO4neh6eTWwAvlKusVxeALpN1ZsUVXtcaV6/hvxz93Zy69D1M+uPeeLzLDtQESh9GbfgpPTFj/ACajWBFWWNV65eI9vdNKrU70dfvKPUq5luyqIsuiM7b1zPFBPaI6Fg+qDYMgwFcNg5hUWbkVt0PXPRi7pRs7sdK4mOc8QGzm32Qi/Q3Kkz416LFpSNGTPGHMse+RRE/Mbteel/p5w0ZKnIkOzZ50FlQ6NqjzpqwmZ5ginG2U3N/+fSl/nWqUHjODvvl2QeyYvxkY7guJL2LNpcUrQZyQj3MG5Brjb/wbiho7FUfpq5SKpVqSRtGteWBUtXyuRZi6XbJtkd52N+niuHdMv24cf+Mke2bFRZ3vl5vvl55eqKr/OK4i/fT18sLevXkN/nLZNjn/xc7j58WwOSt2lcS545oZvc8v5kOfzRiXLdflvJbttkiodaN6plZqI/Ovo3OeHpL+TIHq3kgK3qSs8WVeXZSSvk9NfnmQ72/fp2kEUOnxeGE5sRN+z4oaB6fNaiFXLys1/KlFnZsW15lOkLV5jZ9DWrVZYlK1abe4bcc/i2curgr8zvkLbritztvBl54c8++8zYeTAgxSu02Cvu+IsVFRDPKFPgPK0qTq+gwA5ukp6tmgvM5m9UAzNTiCCZ6s6oEqYz0KZK9wNN4p7HbW57GJA+LuUUCUEeUAUsAYq00lOB9DiVTGlLWXX7+SXK6JKKYsTy3XGez0AiV4e7W+CJYUL3aHEHFV1+awrYhlSkCq20bYaO3eBZB5jV2Vlpi1c3IEABjBg4HVFYRdzOEwU80esIAlgkOUfdeX70DLYnzW4uW4L6FW98OV3+9eakWOf68oqdXPWdVxJKC2o0CaX2qSzHjuSTqj0NfW3TutONwFqPHz/enIvkAj5QlHEapz/3dehraVKnet4LuIo2I504I+qMW/woYg38J/adX+fo37vnnjEehi7YFj4H4Ikw+xA/L4xc+fq38uJn0zw7F3OJXi/PIoVsYYqFx17Yw9iOM0Zkrz+ASi6wRKkw+e4USdMN5kY7m0T8CXWhDZwjMJYkWZBbFqCNk9JXmap4sa787EXpG9WezFm8Qna5c0yp3+eruDnNeMLrHt53RMdSI6GUApi4gZc9psxrNElYhpWizchtM3LR6vpRs6cJnGsHPKAcdob4wqknVdx0ZVxfH/tGoTKxVliqdD1/rng6aPd5EHvgPLefPiVmwWbwjOm1VSSq9jDixvhod1MH7RbMx/oFBcwZsQJbTD6aPZyjUeR/7teo4xOdOr2sGRadUrQZycQZUeMKBL1LESr+AM1/+ATkFe3jfTNtoWzbkr1USb6YusAAnU3qro9Ll69cLV9OnS+DDu5Q8juuHXr3vs0zz8ZmTWrL3SOy/dqibHjSuE41+XPBclMI3L5FXTnqsYly04HbmK5z5p5fuc+W0qNNQ7nyrUky/rd5ctGu7aR61crm/af3bSO7bd1Urnn7R/nfV4vltG715OGjO8n/vp0pd3zwswyeMFUu22Nz6da2rfF5iSmUvRUQHUwHf1hzZLm6oYPGHcO+nyUXvJxdbFKeBZZMwPEVq9bKDm0blcSjUO8DqPO3nbco3bjFWmluokuXLuZf8ArWH6ySOC8XXrEh2owyBc7TEmeAYndcB53BFPectuBsAuqgFHQmSxwJGvSwYUk8KSV8WNAibAci3x8DTndd2LntUcR5bXw/AjledqWnXcm0IUsuo+KWKMOIAfQAovOzUpD7GbGKNuM8Dh0i79X1orhDk4+sK3sSJ9hJlU/gjvjpCfY2s2ZfffVVU8nMTNm77rpLevbs6Uupy7xauqBJYjM3irlSttx7771yyy23GOAZQ3r33Xebghtbl1188cXy/PPPm2vfa6+95L777otVCBRH2GvodfS7jt2Ayiyp+VFR9D50/awxdgZ7k4StiZLoUnaToNeRdCEb+5IAj71GUpGOx3wAALm+5/JVa6THoNIdbWFk+OkdTLKUwDUq1bgf2wfvwZ4VqdqjCWvNetL1AbuKTetOUZhN686/bnMc3/xqeqQiinyIkzo2iM0oSngJC3bwvBJw4i/hQ/FC7+kxoFAMq6/U3wgLRpL8B1RRyvkwRbPIS59NLQWahwEoFFRCFFQKI2qPOCfr1um6D7LAknfP7S1tm7rvdz5H8S46FF2qxUr6M899koxnALvOxH1Zs1klLRSau1H66tryd7VdAHlh/R46Pw58cEKp3+dzDdMs+v3k52ymCRVmQ7oJ+xPbpexgNmjlZsMA2sPEJkWbIbFADpK6+NesY5CmhCSAc92bHEfjDAC5xTXZI6WfHS99HXX8h3Y6AvTxfaJQpSN2gY2fcP0wCPW954tEwXOv82K7yWHpPbcptjeEjvOw3dTaaMFe9OoWzEdRbpQu80ICpIkF7XFTvPZ9KuM72deOP1WW11m0GclIVFvAswaWwP4g56cxoFOffzVtgXRspTTt86Rr62zbNGn6IqlTo6ps0mh9Qe/kmYsNwLZ6LT7Eatl+s0byy+zy341blHgyZ/FKad2opvw+d5l8NW2h7NC2oVz48rdyYu/WcnrfTU0R0t4dNpIOLerKP1/9Tv7xxOdy44FbyxYbZWIz/n3q+C5y73tfyq1j5ssX8yfJhbu2kzfP6CFPjv1DTn/uK+ndtpGctXMb2bp5XWnWrJl5YTeIYdXnxeew2VvdRvPmsjXs7yvfnCTvf1/xxg902ri+TPxjvhzYqbkM/2F2SQ5Lcw4D9soe1aCC3tAcAaL2R/EKu5DBDa+olMO2V0SbUeGBc248DgkOHqASzlwa4gVsqKEjmQCYnEQ1exBAW0ELgCSSVlGcrTBACkE9ID1CcUCa3d1BnHBnpacqgGcOmi3/eG1m1nsXLlosdeuUTpznQ+LOAgx7rjDnIREWxYhV9BnncZ5hZ/JRwTP2JjPqLr30UmOMeB8/k3h3k1NOOcV0UT799NMmiH3mmWdk9913N0G/W1cZAdd+++0nZ5xxhjz77LMybNgwcwzoWgC/kf/+978GWH/ggQcMIHjnnXeav2Ew2QPIhRdeKG+//ba8+OKLxoCec845csghh8jHH38s+RZ0DjoOY77DDjuUUMEkNT8qiGhiQF9U6GnRga5ZEhIGOI/KbpJUx7lNI9apU6cSavZ8zgl0O8/2N4+SpSujf7/PB+wkVdbR7wIWxBU3tg+Oq5WeVGiSnAWgsLtfyvuM83zpa/tcfrTuFN4o6KMvfmZGVxgZuFvTvNk9t45zkpZlmVSriBLGlgBcaeHodtttV1IgY1OtX/JKeAYDvadhOkrZ19hGHZU0fPjwULr9r/nL5F+vZzrVVcIAEzqeQ4NmBf/CiG2P6GBwdiDuffcnrteFL0VhIcF/165dzboRA9iMHzzz+A8IRUvcq7iz3Sia6XzjRxUaPA9C6Yvd1y4D4gTWFt/Mb++O/HG2nP3CN1m/a1qnugzPw9iLfMUTJAiTBK2cNoxrJ2bAH2bv5yqUL9qM6LS66BjyOsRAXtTsaQHn7E/8e/QY+g3d6taZ7aevo4z/UJ3OviGuIK8WVeyOcy9hj6M/eA0/fVvp/+C3iYDnem7b5+U6iHMBgFlT9Br2gTUml8b957uz1uizKJ1XaUlZAfqsnc2Q4dVowb+sZVoxRhDQPJcNzvfIP1v+1qmZbLvtNlk6HR/SKcSCZU3VXrQZZVeQ68ds4tTndJyftGOmUPXbPxdKr7bZ3aZfT1soHVtmg15jf5kr3Vo3lF/mZ2jaW9SPx5JYlIojgObN61U3lOBjfp4nfdo1kte/nC5fTl1gus8p/twU6vbju8q9I3+Vox+faIDwY7ffxOTMANf32aKOdG9RXV6avEb2v3+8nNKntZywQ2s5pEsLefST382Iq502byxn7LSpAdDZm8RkvGi+YX/TDY19wc/V0bz26Cg//chzcMRjGYyqIkmVSiJMVGjbpJa89fUM6bpJpmDmkWM6yVnPfy0r1o1bgHXCTfzWzIkBOfEKxGYdc2PWq4g2o8yp2tM0SjxkdFzgBEfpuA4jzoovu8sdKise/KS+rx/AYYMWHTt2NImzqBKUql0p8KFD7NChQ94cuzABg60AxAGc73jXp/Jg/6olnShBZ88mIfkEkuIELl5GTCm7bCOmFUwVteM8qfOxRhgUXhS48F0GDhwoTz31lOlSQ2/QLbzHHnvIBRdcYH5GMF4vv/yyvP7667LzzpmA8JprrpE333xT7r//frn++utLnQswnOD2tttuMz/TKTBq1Ci54447SoDz22+/XU499VQ58cQTSz4DSP7YY4/J5Zdfbu73o48+KoMHD5Zdd93VvOfxxx83x2LWHeB12qL7isCSRAY6B5DCfl75/zjzo8KI7gUCXk0kUTiUNLtF0A4RnfNOkB2W3SQJ4FwTTAAXdjFDPoFzW/f8tWCZ7HH3uMjHGn9pH6lZLX175jV2hGQewA6+hJMWtzzaoXwmqLx0tRutu4I+rDNdXOd/Et7+d2iWv1Ewbh3ncYG/iipx1iToLELWHx8YP9M579VOkr37Tfacy2dP6hHoGpAgutn2/6FmB2QL22HIMXa5PZuR44F+4TpZmZmGjmItPvjgg0j6xc1eAIxA59375pGugAm+KEl7Ani+u/29nYwfAI486zz7rBfPk/4dXRt2lBfXO+KCHaSfg2r8u78WGYrDuFLIz7ZzbUluUdhJsS3d0To2yy3BcsvQyfLU2KlZx3vsH52lZ5t0itwLKZ54+vgMPWJYcbNhI0eONHsWf4F9zd90zd3m0Rdthv/6unWch6FmTwM453lSNj10K89RWNA8iq9PUSeNEeTSiCsUxIsqNmDtJthc4iliToq4aYCY9O9WOanbw3Seaz6E70LMROzEdyNPCNirhUE8Xx999JGJ0QGAlUIWX11zRm6MRRuaeDVaYF+xyUpHbhenFgJonu+CXqfc8LdtSun0Bhu1EnknUxioQr6GNcO3JOcadNxUklK0Gd4S5vkPM+M8CLOJbVvWrFkrP8xYJNu0qFfSSf6PXq2z3v/Nnwtk23Ud6Sqf/z5fum7SQB6YMidz3tXJju0rSvkWQHOVj6fMle1a1zfdzEc8+pncfmgH6dCynilwvnDXttJvy8ZmBCKdz9cfsLWZeY6ObVq7itx+6FYy4bd5cvP7U+Slz/6UC3ZtJ5fusbmcuENreWR0BkDv1rq+Ad37bt6oZKwGuk67oRF7NC+xBr4E+hFbjO3RHNmatWvl4Y9/k3s+/FUqoqzDxWXR8tWm8EBjqckzl0jt6lVkxdJVZp58XEzDDa9YuI7VmWYxijmxTTbjDPejItqMCtlxzibgoRo3bpxJQgMYpX3T7Iov2+lPo8vdK+ixK4KdoEXU8+RKeGl3XNggMo6kcQ5ASXv2LM4Je4j/T7sbL58KJcniDZvSQ42YdkCgjAlG3eYfbsgd537C9+jfv7/5F+Cc9SMZ9v7772c52fw/6+tkdSCJQnDlJp988onpSLcFwBxAHuH+cc4BAwZkXQ+f4bMIf0fH2Mehm43nnvfkAzhn/aFgBeACsKdb17mv8t1xjowdO9Yk6lmPNPaj6mI/XUSCguQWz6SzmCCIxAW2sTsAJuxLTUAlefwwcvL7y0TeD0bf55T3ztleWjXIDYKm+V107Aj7HJp9fka30v3C/lcHVbtf4hZ6VfSO8zCgz6e/zBb5JLv7MZc8d2DjvHaCOIMdAsWKRIVVKBLEltijObbYYotSe87vGMyGC0PP6yfYcPx/9oLT/w8DlGxzzbCsn8dd1FMmTChNAxx0PEjQAlyneNmLxnWql+o+5/9fPaKVGcvUvXt348fnEvwl1gV2GK7P7pjmfgLWqI4NQkmHNKlT3czsG/T++vMf/uhnWWwlG4KQMGHfU7xtj83SBAtrj59y/BszZfGK7L3x6WV9TQKuLCSteGLekpWuvydRnaR/CEMV7Cp2PEZRMzGDjtli3QEE49oMYhPGOhEX8NwxNuqggw7Keg+5gcsuu0w+/PBDcw0U1lP0q2MbCm30k5uo/g5Lze51nKiC78f5udesI8/Qhz+W7kwN2nUdVCdT+MIe0tEj6EHuZZxifLULbvrdb8Qg3+2hj36R24b+FBk8t59v9BIxC/odm+lVdK2FrdxzGxR2GwGSz8aLQhW70YJCHor4WDe7OFXta5DZ3k7pfMNIyRV9hWF6yUdBb1A6eWSnOz4p9V3Qj6wbORj+ZZ86i6nT/g7FOCMZCWoL8EkpyEU/+TGb2Mf7a8FyWbV6jQErl61cLb/PXVpCm63yzbQFcsbObUt15DLXnOeqQc0qMnjcH7G+Y1EqrhDKfPb7AtmscS0zU/uEp7+Qi3drJ4dv19LooG6tG8hLp3SX24dNkcMe+Uwu7N9WutZbWxID9di0oTx/Ujd548vpcsv7kw2wDe07dOJn7rSpvDjxT7n6rR+kTo0qclDn5rJ/p+alGBCco3nxyyjQQkeRjyVHtrZWA7n8g7kyd2l+8sFlJds0ryPfT18kp+64qXzww2xpXLuaPPfpNJm3NOPL/GP70iy0UcfPquj4N2WcwR5pDI1PxH246aabjF/Ee7FbcZuXuVaaBGHYJZYk5864WcbO2uN/rr76ann44YfN9fTp08c0FJKPSEoqnHfHzVPaMoIbnU+UtmhnA444ho6HNq0ud7egh/MSbOCoAlokUc3pB3RwfpQUAbNNSxnm2HElSeDCbfYs+4gqWSgpNIGWVKWsSr6pi9NyrG0jRmCEwsKppzNYA0t18KN081TEjnMv0Qotgsn999/fvGzBieYZv+666wx4TJLpueeeM+A1iXs3wcg4k1H8TCcB+50KZr6b23t4zvUY3EdnIRDv4W/5EK6FBJJfYVC+gHP2niboWXfoYNMSu+vQ6eTwbNNpRycEzgGgRZTnPE7HuT3PnGvw6vSNo+9yfaf5S1dK39uzEw5B5Yy+m8rZu6R3/+KIs7tMHVSSdoDoJJ9xXtU+kRQPe//zCZwXMhsJ1cknPBsONAcU++brTEI7X+IMdipiVW8hiJ8t4fcAQ9OnT/cdzRF1nqwK9zQXta6ya6lv4PSvglLznjH486yfP/9Xf1m1fEnOz+pMcZLk9niOoAW4bpLLXjjB84P/O00mXrajSSBjl4PoGj0+16j+KbZc50krLaD+XXWsX1xHksIGzpGuAz+KRdle3ubr2mvvHJuF/Zo5e47s+UjGr7Rl9HndpBrcg2UkacUTTiAkaVH9otfuTCraY7YoXDj77LPN3wCDieGVmSKMAHCi90466SQzrskpPIN9+/aVk08+Wf7973+b+w/gYxf8FtLoJy9Bd6JfiT3CULO7HQfwK8qeJBehAKTqNuS0Z7L1dZhryWWT7BwP83Rh9/KjO08i3qDonoJxvxGDp+20mRy8TR3fuedBOs+JWXVGPDrf1le5cig2+549AsRuvNCc0obul7Fu7DcFyllrngO1r7kYSdLqMi+kGedBhIIoXqwPcSD61y7eyDX/NwkpxhnJiM1i4iY8D+h7fGrNLfnpEFuf/zpniWzcsJYpPvz+r4VSq3oVaVZvPehIl/CPMxbLti3X58+WrlgtU2ZlxusgWzWtIeP/KM43L4q7rFkrhrr9lzlLzeuEHTaRhz7+TUZNnivX7r+VNKpdzXQ7X7nPlrLr1k3luv/9KP+ttFpO79FAFL6kk/ygLi1kn22bySuf/yU3vz9Z7v/oVzm1z6ZyUu/WpgP9gx9myWtfTDf07z3aNJD+WzaRfls1KdXYojkybC22A7v85sTf5P/e3jCKP9o0ri2f/DxX/v3OD+bnK/beQq56MzNqsNdmDaWGTyFyUs2AVatWNT6i+onYigMOOMD49uBA+EI0BsKge/TRR4fGDJFBgwYZEPzJJ580vjAF/TDk4m+dd9555j0333yz/Oc//zHvAdC/6qqrTEEuxZ9JjZCuUFTtCh6rw6CUDvkQnC6cZwyd0xFPWpwdHNrlkfR5vRJXBNusMwmQNGiJg1xXHMGpdjrf7347U/busFHW7FkcehxU9hPOKY6MTUnOg08wEPd68gVY5PNcrBldBW7zD5VG0O7miRq0VKSOcxUColydIMw2J2HFPuV6KF456qijTPdHRRb0GwwHfhX9ChKkuTeUEp1/OYedVEpD7JmA9v7j2eJ5wjGh0y5OoVgU4NyeQ5hrNEjUzsNccurgL83cpShS6PNn3eyv00G1k+IULbE/wiRQ8mkb8knVHuVcXRwzinPJgC6r5LNPJ5hqWvyGfNgjzqHJyDA2Y0OVOPvNK8HFM4cPzL1Wylwv4T6ZDtDF66nuktTNyvpkdwSG+bwtwyet72C858jOJum2eKU/8M3exxayJsQDFO7YErfj3A+cGX/x9rLjHeNk5brDdxs0Wr6/ZrdARVp+77HnSXPtFBgSA9hjiRQYcfNf3WKMijrv3E387hlNEG6g+bMHNDTdnzwvxO5BihRsIel238jSdIwjL+xtEnlBrztf8cSzJ3RN7Fj2OAKnOIE+nte77rrLJKAA0fkdTEkktBjJZBe9+Mk+++xjXl7yr3/9S/bdd1+TyFLBd1cphNFPXmJ3r+Dj41cpu1ZUexKloNeOM1S3ci0cJwpFe1B7QOEQ9o3v75bjseORqM+LXVBlxxH2iBEv4R48snsNOWXo8tDgud4/4iZnkVcUW+FkLAI4x1bY/nicESAVQZzPDAAwsSIvL0YSu9FC9Vou0DyMri8EqnY3f8D5Hd8+s2fJ/+vzxnrqKAHNsenoRJ3/y9/s+b9J5K2KcUZyVO1etgD7DPU0OdMePXoEwjHs4txfZy+RNk0y+vqnmYtNt7l9bVPnLZXKlSsZcF0FanfmVC9YlulQ3bRBVRm/YWCORYlB3b5po5ry29xl8sSYP+RvnZrJ3CWr5NCHP5Ub/ra19G6b2bc7tmskr57WXQa9+bn864PZ8vm8n+TsnTeTejUzOVxA3aN6tJJDu7aQ1774S+4e8Yvc8v4UOaxbCzmsW0vZu0Mzmb5guQz5fqbppr5l6BRp27S29GrTUDptXE86b1xPNm5Qs8RGL1+9Vi58ZZKM+HH2BnFvaeKft3SlHNi5uTw9LkPT/uaX02XpuqCYGfRl0QxYt25dOffcc01j3YMPPigPPfSQYc9lpCyAehTgfPTo0XLggQfKfvvtZ34G86RpEHZxhPt/5513mg503ocw+pZreO211+TII49M5LtVmI5zTR6xkICdzNVzzoFMS5TrH4e5a9eunp0nSYkGPUpbTDKnc+fOidObuSW8SCCR3KDrFKCmLCmpkuzCuOTV70qAc1ucczXsSln2HKLOKYqAgGBD7Dh3nss+jzOwjFNtXJbAOdeZj/MFCU5IQEF/yHt5JglAjzjiCJM4dxOSA3TG2cLPFH6w3twjXm7v0cSCdqjg0Ntd5/Z70haer1yzoVQnpeUQsHdJZiklOvch7Q53O1GlAlBBl6GCN3Gr6cJ2hOtIEvafziH0k6idh16dwWFBTpVRF/U2QWJ5kVw62zl3yJlAcRZ6OZ+JfNuGfOnrsLo6DJUicvKOreXQHVsZtg78MCi7eSklblr0iW4gSTGhlY64JbhI7pLYomiNET+59pgWcl3w4ldZv99+s+CFvW5d63bHey7WpyDAuROI2aN9s6zPuoGhSnWrs2/dQIE4Hed+ogXDr/+jnXwyq5pct67aHqp5QNi4x3fS9PLSsUQKjMCywndziwFgoqDT3JY+t42Wjy/eUTZU4JwE2O53j/UEEGz7pUUKCgCwtvZcV87ROYAPsPO6bu8gRQtp+IyzFrkXzHTe2N9fCiNcN+sd5Np5Rvfee2/TSYxAnT58+HCT1EqqI4P7SCf5pZdearo9AGHp/mAUlNK5F8LoJz9RanZAZHwr8kpxJCxwrnEGe98eveSly4OC5n7HQNBtnHejjTYylPBugJtbPBI1vxQ2jtDP8vw7WUdygeecC52NhCk0DuPDEU+zX9QfT2IESHmWXKwEbowk+NTKjkG+CNt73DsLfc8Tpygt7YLesLGFLZs2rpWzccMulkZ0VAfriI+InrXjkqgsCMU4IxnxsgXoQHI66BAohoMWDdqMUr/OWSpt1u2ZKTMXy+ZNs3OJ/H3TRowpqpRF086M6p9mLDI/1yhD1p+ilB8BNKdQae6SlfLGVzNk62Z1ZL+OzeT8F7+Rw7drJefs0kZqVqtiXkduW1f6ta0jT3+7RPa9b5ycsVMbQ+1erco6lqSqleXw7q3ksO1ayseT58rzn06Tfe4bZwB4sJmDu7Qwc88p7hg9ZY5M/H2BPD12qqEor1mtsrRuWEtmL1wiM5ZsGIC5SsdW9eSz3+dLg1oZ//C6/beSf7/zY8nfm9atXqbNgIsXLzYxHNgor0suuSTyschzA8DjF8BIhJ/KeNrbb7/d/B0fi7yAHVMQM+JXElMUgfN1gvEhuIYqVumk1IDkAzgnqMLQ4ahQJZs2aK5BC84kgSfnJ8B0dnkkdR474aWzHJOYG19Wn40rzkpZHB0cVNYGqmQS5dopgaMaJJFR0TrOcwEWXtXGJIBRiGHm9+YTOFe9ko+O86DPs3aSECC99957Wd0dtpDUfuedd7J+R6KM3yM46CQShg0bVpLY4vvyM/SJCH8n6cbvDj30UPM79jwAnR6nEETvD/o/6bEKdBBAmwhgQqdOEBrdJESfWz0PlIYkgHiGkpqrHqbj3J5D6DbP3E2SoGqHYuzvj4Wnp9x5i8Zy7xEdpbxJ2PWyC72cIA/JSe6v3Y1uFylVpI5z7VQN+lworVVQqVWtslzQPzMjjqIhQB4S69h/mz4R/WN3ziRBn+gFnKfhA27owhqTdNS9i72j2A92jaDFYpokG/vz3Kzf33rotqGuw61oimcpV8d7EN2+crVjzvSAflmfdUuAA7xRQEAsgK7xeq6j6n0vlhWlhcfvUIp8Glk7b9JA/v7QePOeY96cJ++d2DQwVXsY4Rl2+q887xoD4I+p//r8iV3lyMfX2yuSPtPmLytFNRhEyhPA4gaWTJm1RA58cELW79o1rS2vn97D134pmwqxpxmHVrmeDBiZSfCGkSAd/2kUdvW/a4ykLVGSX2ozWGvo0d3o1qMK+RioGplxeP311xuKxXfffdecA5B+l112KYjRT15CPEV+haQbej6JOCIocO4VZ9jH6fdAuHEyQQqx7PMSU3Bev88jceIejsEeJI4h5g8aR+hn9dxBwXNsJkVeei+9/KVcVO1hJMkRIOVVwtL5k++haIMXn6Uhqdcd2XbDKXGZXMqq4zwswB60sMtvVAfggrK66N4M2vBTjDOSEefYDu4RjViMxvBjjgpK1d5rXVHun/OXZXWWOzvSVaBp33yjOvLuNzPMz8tXVuyZ0EVJTgDNkY3qVpdJMxab1yk7tpaxv8wz883/vd9W0n3TBmaPb1K/mjx89Nby0eS5cscHU2Tw+Klybr+2smf7poa6HeHfnbZobF5/zFsq734zU54c84dc8/YPpnudmerbt2koe7XfyDwjy1aulp9nL5X/e2uSzFiSbh62EKVq5UrSb8smMuS7DFscBQWr4NIXMXPky3r87OIEc1MwYoG54Z+qzrvhhhvkmGOOMX/XuMFt5GySMUW5pmonMCN5hCNMdZZWS3NcXml3AdqVuUlQdgcVkgkEphQJEGykVRxgUyUCaJIcpmKE77uhSK5KWQJrXiQPSbCqc0oxB/vPdk7dKO0rasd5UEXsVm2sFdoE8DovTNfQWaGdT+DcOUcwLQlS1QtIzjqTWGGdqOLCmDDvA6GzgwQ/NCXIGWecIffcc4/pAIHiHUaOF154wXSFqFx00UVy/PHHG3qo7bff3lCecC16TO4D8wp5H/eCewYVCzooX90hQfavdt7k6kwPIzzb2hXRs2fPrGRfPmaq298JQA5KQ7pB6HpMSoIC5zqHMGjHZRLA+REPj5fP/5gf+nMTLuvrO9+noosbyGMXKQG4KZtK2sUf+Zxxrt8lyN5kNtRrX2YzbeSScZf2dZ057kWfyJgXe0SJ0idGsSUa6NjrWOwE8ZY4+417SrIbP4RYg32FvQtDi+9lH5rXrxkJ6IhSNJVLt3e89oOsn+uuo9HTz9q+ls105TfbPei5g9Alq2D/sD3sd2fBcOeNG8irZ2wvBz+QoW3b6/Gf5LurN815/Dhi+692DEBsqEDvlo2qyo9z19//ve4ZJ19esVO5AsLj6vlPf5svJzydPZP49kPbyx7bbBQYALjzgyny6CewfJUGzYeduo0rDbITiMhlf/IVT4z5Z7KsA1GSX2naDH3eoUtkjjlC7gCqxQceeMAA54Us7BGeZ+w4xTBJ+PdB4gQ7ziAGw0dwitt9DtNtrtdi62Tt+sZf8TqvLZpji+Mz8ll0JGu85ZZbhtq/zlgiCHh+386VjM2kU2no0KGhrj1u0W9SI0D8rq9QJc665WIUuav3KrNOxMRxfOp8jpAKA/Y73xOlQMo5qsNmdVGmVi3204Yfr3MU4wz/dY4yAgrdy7PPuL1czFFBbMu0eUtl40aZkXl/LVgu222aXZgGsK4d6Sq/z1kqXTZpIDMWZsD872csDX0NRdmwZeaiFdKxZT35+s+F8sjo3w2Yy1zyM5//Sg7s3EL2abVaGlavbp4TGlkAwV//4i+5dehkuW/kL3LKjpvKPttuVNKBjmzSsJac0mdT8/p59hIZ8cNs+einOXLX8J9NF/vWzetIo1rV5H/fzpQNUdo3r2uaiTbZOvM8H7FdS3n58/UA8bYt6+U8Rj46zuskFGeAWTz77LNmvBMjfcjJXHDBBcafArvIl5RbqnbtdnBzurULMC0wA0eQqj2cNeZxQclEEhpAO20BDOOl1AdpOnscm0COymsSh2EThkGOX1YOeRozCEnaUNnCi2tDYRAUkegk0UjQpJXF9tymitZxHqd61zm/l32nxQhUaHP9WozAWqL08zUuIJ/Aea4KLQIfwHECH9aCDnAqrzRxiH5kvVRIAgGSk8RiviE665FHHjE0iipQvbNX/+///s9UZ6Ff6BKxq7fuuOMO8/05HxWzfP6+++6TQpMk9T/JDbqruSd09zm7Aty6N9IQ9j4BFkBOUErDsMf306m23QsyhzDs8d3ELxnmJX3b1pdjN1ti7lVakq8kS5JAsxclIgE7ApURSRO1UVHp/AqhsyMocE5F/mmDsym0c4mbj+AGuHjRJ2r3JOvvLKwLst4K0ttS7ARJR1hnunUAfLCD+Pthg8wkbJEegyI5dHBY/esHXjt18tf/l5k37MZ2wh4GuMYGBY0H4sw4t6+PPU7HoHYnunWBdmhZX148taf8/eFM53n7f38gXwzILnJJs3DVGQNQ3H17m9lywLPrfTEFBD6/vE/q7EVlJbbdevOr6XLFG9mMHiMu2EGa1AnWXelF7/7fE7tK8xorXWmQtbDTGeed9+I3cvfhHfMGoLz1tXtBVp0aycYsbjYhl6RpM4jfiMso7rQF/Qm1YqGMfvIS7LKujRZPxZVcdoCYjkSgV5yhcvQbc2OB5k57gI4ivkGv+p3X7xhhdQMxBPeezkqA7LDiFkvkAs/PGgm1e4dAOt+pA9Lw96OOAClvEjWGydV9jW5Xn5p1Ix/MfszVrJLvgqmgNO3auZl2d6CT1YUcL3Ega0jHMz/bzSroI71/xTgjGVFbQCE7Oh+dG2fcnm1bZi9eKU3rZHTF9IXLpVn9GqWo2nd3FCz+NndpCcDeuGYl+WZ2seO8KOEF0Lxpneoya/EKM2P8o59ETu/bRsb/Nk8u+nahnLTdWmnbNmMP6JQ+tFtL+Vvn5vLGl9PlgVG/GgD9yB6tDNAOBbwtbZvUlra9a8uJvVsbhrRv/1okD3z06wYLmiM1qlU268L6IavXri3pNh98QtdAxyhPHeeXXHKJ6TpXyvVOnTqZppSBAwca4FzjBmIIiiRV+Bk8Y4MFznFwqJADGPLrdkgLONeKYAyeXZmbNl0vx8ap4XsDeuEwpp2855wkJHDs0+xsDyuFXF1rX6N2n0Hhqp3UOKf23CYSj9rVn+b3yjdVe1J7hY5IOlt5cVwnLSbPHcERv/OrlE1CtDIr7TUMYmgOP/xw8/KSJ554otTv+vXrZxIkfgItu1KzuwmO/b333mtehSx2RW+cZ4YiJeyNH31WPjrO2fc6Z5YAK0kK+iCJMPQXiQl0WJCOlDgACk6xswMyiHx4bndpXL+OuUaS6EUJRomI3sSvgGlC2T5gNLBpxnklsefySdWO+AUE0CbveU+mOzWoeBXWBanaddInouedtO520s8rgV0EzvMj3FOKSngmOnfuHLpQKC7A4BT2CMeh05ouq6SugZngttgV//pZLSBTcDJMPBB3xjmf5T6QYCT2AWjxe66hbL9w+/pyx7gF5ucuA0e5Prf28dPQSRyT+8TryyvalOqe63rTx/LM/g1KgBF83SRpgstSdE1vHzZFHh9Dl/h6+eKKnUpoGaOADs57qR1aSoOs89ER1vaJw9rICS/9an4e8eMc32tOGkAZ8HrpESDX7hceKCxvwDm2C2YmYjRbiH11Vnh5Gf2URCzhFyfEpemNIuxxclkUSJPP4p7QgBLmvFHsms4YJ54hbnfS9Mc9d5iZ52GvPW0d7DcChL3Bs6q2ImpndVlJ2P0cBDR386kpAkH/w8ipzSr2qCQvnyXfVO0wzjhl5zs+iVSgG1fQweTReSk1vtpRRjco0x2+H3GiDUiEEcCNV155xexlfB3yGIzwgLUO4XxXX321DBkyxNgAYlPGBl533XVZ+Qa3vfTcc88lNr82nwW5Y8aMMbqXMQ5x7qs2b3D/5ixeIY3rZGL16QuWSfN62cA5XeUtrVFBa9asld/nLhVZk2Fo3KimyJz4dWJF2UAF0BzR7vP7PvpVdtmisey2WU155NN58sHvX8rle2wu27SoWxJvAqAf2KWFDP1+lrzw2TS5e8Qvskf7jeRvnZrL9ps1NCC7LYDDj43+XUZNzi4i3JCkeb3qZvwVlPZfTlsoh3RpIa9bzImdNg7WWJWvGedJCDrTrUFFfTkaBPEFiCkUKCdvMXbsWDnzzDMlKSkMJDSg6Fw/BKPrV02YBpiBIwvwBNjpnMeUVHLMTQBZ+d44L5yXJBKdoWkKFRo4Mjic0McUIlhdnpJJzk5qnTnEOrNP6WjSoMiNcrC8UOSmCY7wjCk1PskFAn+tzCbhQjEJf0urYzLtyizb0OSiPy2Kv8TV/3yW7m70bC76rLSLppRdhfOQ3EoDNPcDtu3ZgNifqJ0PuYBzun/73Z7pRgojbx6zaWZsyqfjjE+Ak8Z58jnGIU1JW2+rHWXtAHmUzk9BdJIndjdfWBpJ57nycU/02fdau6UrV0uf20aHOqYfG01Y22AX1jlp3UkaoXs0Uar0iV4zn5GizUhWAOHorEb3sdejguYI92rFyuhjQ9gXxB4ad0TR/0FZUcZdXppCWZ8hbAAdSmGBnag0t3oOKsrRQWFGk+zYuqa8NXmZ/Dh7hSebVD5jGs714QU7yC53Zs+7fvXntXLgmlmGSQC7qjS9PO+FUqgcRbjfN45bLj/NywbNgzJ6uQEnuQB3mwaZ85MwQZ8un5NhVFHxKrINUmwVRhYtd3/mD+7aomCA8zhxBiAV+1aFInvyFNgrbBrdIbBY7bzzztK/f3/DXvXmm2/KiBEjCmb0UxBhXZMY++QWk/AzvlVUmt4o3ea6x3k2iC0oCnPOhAx6jDBxj93Zzj2eMGFC5ByOn00JAp7/Z8dwuj/f+a8gI0DIE7FfCjkPFqUpxA809xtxYheq2c0qOvYPn85t7F+ajSte38V5rvlLc3eb5wPk4LqIA3lRpKjjBD788EN55plnTBOB7rk999zTjNwIykLKMc4++2xTUMW9ueKKK8wxiHU4BgUivG699Vbj6+H3MWKQ37300ktZx3r88cdl7733Lvk5agFOWQjPLg0ZFCig85MYfaq2hWJwQMXGdaob/2PR8tXSwjESavai9cA6MnPRclm5ao38+ssv5udNm9aVSfMWxr6momzYAmjedZP68vkfC+TDnzIFq4e0rye169WVY5/8XPbdtpmcvtOm0mpdEQfg+N4dNjIvAOGXJv4pV745yTTS7LZ1U9lp88aG+p3xA8xO39ClYa1q0rJBFXn76xnm5yqVK8nK1etmm5+Ye7Z5nNghjCSZmzrggAMMsy7xBax7+JO33367GT+r9gvq9uuvv97kyvGdrrrqKhMTUoS1wc04B2CkMpYFCDLXL2ngHEOHgedGkDxyXntadL1Q6BCM4qywUbTjNS2gRmm0CILVySw00Nxt9mF5E3VOCYy4v1DYuVEOKkiRBK19eaQX9hMSyBSv4DTj5GulLMEl62hT5fp18AWVfAFxxTlS3hJ0X8XR/6w/Bpn9FYQ+Ky3dz36jIATbA7sK/5+mznPrDCShB4CE3Q0zzzxMsmv4pJlyxuDs+ae55Ma/bS0HdFqf7IN6XJNLdNHw/x999FFJcolXVBq0spR82Dg3NhLus+pNquEp3lMaSbqjEFu3Bl3bfNkGBejdzgVovv3NH4c6Xi7AJ25Cy4/WHb+TRBN2Tv/ufA6LNsNbwu43U4TzxRdGZxCgwb4QR7i3vy7Itg+bNQlGIaozKOnQQQdHLZryAjlmrptpqNKgVjVXG4Tgo1JUk9S5c4l+hu5hkq1hk6N37ttK9ns6kwx0A8/T7jh3CsnMC/q3lTuH/1zyu5e/WSAX7tVb6lavbGI9nnc65Ujy22Mz8um/xxWudbeHvy/1+yCgOftx1/9k07Jv1ayOvHxq91DXwFppkS2+gby7vtuf/ayMXxpjkbgPOt4jqPS+tXRhlp2wTlKi2J+4NgPgE0BcBQAcgTIRxquDDz7YzDOn0/C8884z/uPLL78sffv2LfjRT/azllbHedg4I+roIqewzsQU+Mhxxu+F0et0AFPkjv2AMYT1jdNs4gecU2j2QL8qcsYI73t23ugq8mmf/M84T3IECH4KeVGdTw8Al2tGdVlJUNvlB5qHHaPoNfaPdQOU1RiHGBHJV5H1vtuWBkr73p672zyfzRvOcQIHHnigeVEIxXqhQyhyYo2drCJeQuGULdgIABVGgVJc1bFjR2MfVMizA5L84x//MHvcLiTkmsp6nEeUPY7OJ9+L3qNQMgnQvKQ4l1EPi1dIjaqVpU71KvLbnKVSrUolaVBr/bqtXrNW5i5ZUULlji757LvJUrvqWqlWn+dktgHkilKUJATQHOm1WUMZ+8s8eeW7hdKqwQo5Z5fN5Nu/FsoB9483VO2n9lkPoCPtmtaWS/fYXP65eztzjPe/myV3jfhZfp69tHhjzOz3mjJtwXLpuq6rfL+OzUyhgcq2rYIz0mFT0izSXpzgjPO7777bAOFnnXWW8SnJiZx++ulmvKzKpZdeas552mmnmcI54g1sT5L534IvacfAQO9F8gTDGpQmJingXKnhdeavl6FLuusQg8Z3ximhcoIKSjXMaXW3qwNOhSEV33R5pBksxDl2EkmkNOacRxEnSOGkHOS72iBFlI7PfHec58u513O5VcpqBx9raHfwRaU6S7syS0W73IqS/y4R9Dzd3UEoYe1zJa2PbZYRZVchoZ5mZ7vaFdXL6H8q9cN0+uU6vq3z7xj2kzwwcj2wEUTG/rO31K5RzTe5BMiEDcNekyThnuJDsIb6/NsdvIUu+eo49zsPNsfu5lMaSTqW8FF0bXMl7vJF1e5lg6jCdwM04oLmSXfSe9G68wJgQ7BpCLYsis0YOXKk3HLLLSZxxX189dVXs6pyScpedtllhjqRAITkFoEL/qifvPjiiya4QX/wXugY9913Xyl0YZ0ByXlRnIsNYL2TmE8++PtsW3TZXv5ryDmJO7gHdKXgw8Txl71ihr63rgcUT9pxU1cbBMDCd4ja1RMFdMAH1rEy3bp1C31uPed3V+9q5pz7+ff5BERO3rF1FnCuSXM66dwYqdCx7Ef1cUkWoGMLtRudbqduA7Mp6ZEgMVUQWvYocsADE0r+v/PG9aR3765ZIAp6yt7f+FxxWX289tQH56XTSR0FUIkbZzD6KdezQyeIdoOU19FPSeWS7OMoRTqFWdjIKL7DpwP6hf4Mdhy9ij9HPBwnoRkkD2U3Yjjzd3EaQLw+S3cqjQfkUb6/ZrNSY0hsufbdyXLzYV0Cn7NQGjXszmqKgvDj8FV4nnVGtY78yTUCJG0JMyIwSdA8yNg/ZSShiAThudBCtSTiQ6/vM+ig9lk/010ZVNLuOM8lynqq4/xYv6hCfg7RYmCv99BE5PR36Fw/5ZRTDPsRXeknnnhiwRcW2rklCgYozk1K1LYoTTtrQaxbp0bVrHUBNGcEcpM61UoYO3+etlA2ql9LllfKNBYVhpYrSkUSQPMtG1WR+StEps1fLrcOmyKdWtWTi3ZrJ19MXWAA9L06bCRHdm9lfl+CdVWqJNu1biCbNqolb3y1noZ8Q5e6NapIs3rV5aPJGf27ePmqkuf27TN7hjpW2jZlSYJ4Bse58847zctL2DvXXnuteaUlhRl9rxOCW4wLBgHwIIyTn0Sww/lJHOlcWRwvL0kSzLZpgpkD5nQsos4M9BOtfiagUhr6tKpsdc4VSQt17nlFpQAuz+K2vjbloD3XW+ctE/Cqgx8UAM53x3m+gXOn8DuCR15UrtodfATW7EF7nizAT671yVfQUuwejC9hu0Ts7u5OnTqFoi5Mmt1EWUbYlySbdM+lOQ4E0f3Ps4H94TqizjP3Oj664bz/finvfZuhFwoq0C/y3XmOg5wHsZNLBIl8H/Qo382mOmSd/Wx7oSfS8pnc8qKR1LXVxJ3dLWnr1nzZBjeA3q2bMZcESdgl3amYi9YdKncANHy0J5980oDZ/D86j67gPn36BKquxc7AZAGwccghh2T9jfsEiA6A9Prrr5t7DSXW7rvvXkKt6CaMnDnqqKNMl+H+++8vgwcPNseB5htdVqiCXsEnJcjr1auX+b5J6Xb2xc8O5sM+7RrnHEnFfde4A0AgznUE+R4X7rZFVsKSeIDnmBgEms2oties3VL7B4hMcjsKU5D97H8xoK+Zc+70hcsq0epWsMv8c1vX2EWg3DeAJxKvNiOVxk3ohUJIGq9YtUa6DxoVWod+M22hHPn4xFCfCSO/zlnfpXL/kZ08i2zRqcgnn3xi/AaNDaIU2To7CFWgU0xDolK1J9UJUpElSap2dA/2E30eliLd2W1et2bVyI0Y7GeKsuJILr2uwAz7jEYMZ/I0Th5Ln0fV5fyrDTZ2g8uWzerIjzMWux7j9a9mys2HBTtfIehXv2sjlsE3ZB3wH/DFYQtzjgDhffkEXoPc36DzzNPopFa2wlGjRpn1w/dQhqew+aGocuCD6wu7/L4va1nW48ecNsMP9PYTvgeUusQqXnEB+5f55nQO2gIgsuuuu5p7QlEv3YcwMMBqUojCdyUuRudrbomcbpI5I/Xv5y9dJfVrZor+Fq9YbTrPbZm9eKUB3ZYvzeT70cnNN91Cms79SxYuy9i4qlXKR0NBUcqX/Dg3s9/3bN9Uhv8wW76attC8um/awADov8xeKqcN/ko2a1JL/t6tpey+TVPDgDbyx9ly9gvflPXlF9Rsc9aq9rpn+/hem8iTYzMskO2b15VNG4fLZabNYrK4AsYZBUvVDmiM042RIRkY1tmLm/BSilo6fjh/vqjhFaxHvOi7kgZQ9LtSiWl3WaZBCa/zcnHmcSJIWGjXGg9XmI7gigJc+D0HzrneTgA4KABUEanakaCBhFcHHwEmFfEABLlmzOdzxjnJ0KLkh6qd7jZ0Lu+PQl2YlO5nXwKKkQBCDxPIO+mz06CEt4+PjBs3zoBwceaZu8lF//tTJs3KpgZOa4aj0zbwPFPlzctJdch6ozft+bKF0o2eL6r2OPraubaauLN1q9on9m9ZdJxPmr4o9FysoAk79ZHylZBkjfEL6aoisXTmmWcaQBvfEZpc7Br0VdDg+sk+++xjXm4Cu8WYMWNMhwQjgpD777/f2M/nnnvOdHu4yV133WVmDzLfFuH63n//fbnnnnsMbW9ZSK79RrIU/xcfyzlDPAnd7rYvalSr4hv30Jlnj6SKy2rCcQAybFlD64kl1atWzqKHZ39RdKS0umnMo3WKnltZtgCLo85Htz9HRzfgtBtIXRZxxITL+koPB8jsxXbFvccfxEZRxKDd0rygnE16JFEUWbJitfS65ePQOjStLnMvqe8CNmqRLb4OyW2S+W4xlq5vkA5OZo065eOLd5S0JCpwXowz8kfVrvqXfaUsUvkQnaOOP6aNGOzzuLkdvzwU/jV5Hr6j06YG+XwusQsxATmx3+hFZ/z21tm9c847DxJjlDVVu5/Y18V18v15ET9y77WolThHR1SoP8770vTHcxXlpt1lHuYa8W3xu+z8ELlRYhhsqm1jczG+eH0v53fKVTRQlnFGmjaDjnFiCwoW3ISCyf3228+w3V1zzTVZf4PNSgU2Iq4J5qyyBs7d9rgWwSK2ztdirKRypZobWr5qjdSsVrmkC5WOc1sWLlspdapVkrFjx5p8Mq8vPvlNGteuJvPX+SzVisB5UVKUId/NMv/u37GZvPX1DPn0t/nmBT37GTtlWM9emviXXPPOj8X74CI8n7ts2UTe+26m+Xncr/NK/vbYsZ1Dr1naDYGLK2CcUeYd506HlP+nShL6tDgUsVETXjZdY5jzJwFm62xFEtCc2yt5nxRwznf1o+NNurOd74cTQSc1iTEcB5xQ7VpTIBOHiu/n141eyBXAYSTs+joBYDcAyKYjVoVYiGB2WZ3L2cGHnoDCTmfMs/90xjwv/l+fubSDFg3aKlqFVpISJIkRVP9r0VDUAq2kAG07udWjR4+SuWvO86TZcc4zgLDfAcuSeoYPuPcT+cGj68NN9t62mdx1eHgHUCWXnnNSHWKH1PYA2ijVodqeKN3oSUo+9HZS53BL3Nm6lbWm+p6OINaWe5DG97PtwptfTZcr3gg2hw/p0KKu/Pfk7QK/X5/9fNlXJ0hCsg8gHbAaIJw9rM9yVCHBitiFm6wnfhjJLi/gnG5NnXWrwtza1157TQrNZtj+r3McktOOxPGfgtgUm9IW3YuPnKTud/t8+38Pc+2MoZCVhKTShsc9f5DPKuMLgA7U9OiGOICF83P8/MSxXeSEp78oSVhPvCw9IDOXMIfyoaM7mQ4LW4ZNmiW7bb1+3YNQzupIIoru6JZT35U15P/T1kvzl64s1WF9dJdGsm9r73vOvdFChjSBkmUrg/tlyobiFmOxvhS1UFCkHZw6H9cJolzz9g+BQfukJGxsUowzguuQJDrONc5A0K1xQfNnDwg2ugLghs5CvgOgstrzJGIJr2OQi7Bp6L30T1yqdoTOTdYVf5OudjeAHmA8CfC8UIFzP+G+O0eAEOegz8hx2kWtaY4AcdsDhQCaI7oH9Rr98kOsmTK+qI1NMobx+95pM1vly2ZA8/7WW2+VjBhwCs80xbesK+Ojco1NgSGKAl1ilrJmLbX9ThhsKILFl996662z7LM+Z0nlFDVOWbFqtfEt3TrOzfinH6dIpTWrsnzseUtXms7eP+Yty1xT7KspyoYk1apUkpWrw9tGQHPkwM7NZch3M83IituG/Sxo0vYtKhbQmpS0aVxLZixcXgKan9ZnU3no49/M/x/Ts5XUdRTKBJE0GwLXVlA8o8yBc1swfDjB/OtG7ZQ2cG5TS9l0jWmDJ3YCjy6T1q1b5zxX3KCHawUg9KPjTbLKlqQOiTHAKaXHc5tPy8ueoUoiTbvRbXpyJIlrK4Q551GdbjcAiPuJg8+a0Z0OeJ7vLpR8zbHVc8VV+ugKBckQ9I92nJAA0CKOfAXP6J/ijPN4kivZZQMVqpPSOlfQ5JZ2eXvRLKcxS13Xgs41Cm8QgrwkHKkznv1chv+QqS4NIlfv3U6O7t1OkpAwzynrbndM8/xhewh8SZRrN3qu+d0basd5GN06YsQIA5oDRkCrqTSTur5JJT7ULhz/1Ofy2e8LAn/uqn22kMO3axX6XHzPsgLObZvBNVAEGVfwQ0kaDhgwQB588EHjf9HBTkcwwKqX0CHspJ/lZ35fSIKvj22ns6Vnz56eM7SVXjdN4NymifeKe9jLQcZURI0ZXji5m2EaUdYVJ7ATtzvQT4/xvSio5V/nuZMCzhEoAW3pNmi03NW77ACR3m0bSbO61WXGovX39YKXvpVxl/aRWh6MBLlGEqnviv3iWUU0wZ+kflUhibObY/wFBQrNKy/0nH+azy7znjev74K/9/AMc0aYWMKOsSis0Q5Ovhv+I12uThDl5c9L67r3ztle0hSuK2yMV4wzgkmc4ilnnEFhSxTZ/97swpQguSYFbiiwcfr0SRT7Om2C3fQCmyCFJ7k+H5eqHZvFc+kH0CcBnhdyx3kY0REV5BgNtfP8+cZW2IBwkiNAvDrOCwU0D5JDsmMY9hkMdWpjiWEQLTzgPT1uHZt4tzmiz2tZU7VHzU2xF84991wDhhMH0jDlFPxxCm3xU954441AI6fwHZUxphCE/aRjI6Chp7DZKyaIwhTjlxtasWqtVK9apVTHuXa+z1+0WhrVy+TS7RE7NatVKWHJWbaq/Ou5pOQf228iZ/drJ43rZHyrd98fJhu17SBHP12kDleJAprb8vqXmZExf+vcXL77a5EZrfLtX4ti3rmKKUtXrJIdNmsow3/MxFYvfDat5G+X7L55pGPmo+O8XkIzzgtFCgY4xwnBycf5oBoqbuVjWOAcBxLDgrPoRS2V63xREksALgpg+yXwkgTOCfYBajiOHx1vElTt2sVC4tRtXnvQGarObnReBIZU8xWKwxRFkgzGeGYAJXgpZa4CwLz4Hfci7erifM44T6Naiv2Es6u0XdrVTxEHQRNddbqGbh0ncaUiVmjlW7gn2jUZdJ5tVIlD50sXk47JyAVYp9Fxbne6Y3+g8Ip7jv98MFnu/fDnwO8/v3ttOXWfnqFtrpfESfbY3QYk5LQYyZ7fzTNPQJ9m97/zmtKUfI/xAEjFrrN+WiA3depU0ynNuqtujUOZz7FPGcrzH3w0wJBztpeWDXInaspqhId9PuezkrTN4PivvPKKnHzyyeZeoOOgg6ejvbwnkNXXZ72gT/QDnDSgRA9ELT702xt6LQSWfnFHElTtfp+f9dMXslHTpqbb3S2Ijtsd6PVZnn8ofbHBbnFfHHDF7XNuhbJluZ+Hnb9DqevZ/uaPDbW8UycH0dFO35VEtFO/2gXIcfQWs8P3v3981u8+vGAHk2T8/fcFgboMv7hiJ6mcJ9uz85brk8VRC36dHZw2bT6J8tc83J5WEexK2jaoGGcEk6jdgcQZSiGuBVEUtEeJFZxzuv10sQ1gu7GXJFWEa+v1XPPMk4xntNEECdJoEhQ8B0DScSVOqSgMh7bYIz4AhFWXYS/sESBqL6LEZ27AeSGB5lHyVcR+PFO87BhGm3xESuuIl07JzWCV67srwF+WezGOzYCeffDgwfL6668b/aDFtPghFKfjq+y5554mL/PMM8+Yn3kh5DTZj2+++aZhtEDHcB8YA3XjjTfKP//5TykE0VGrxAv4814Uxbrfkhq9pzmo5atWS/Uqmf2xavVa8//2+Kc2dRpKrdlTXfReFVm1OqOLl60s9px/cunOJWC5LXTzb960VkmRFSOKut0wPJF7uKHLG+sA9KK4S9NalWX1qpUloPmeW9aTIT8uNP9//5EdpUrlaHahOOO8HALnWpFLxSPAAU5wEo4BhsQ50y/XXD2d+RHl/FGCAJ33jUNKAi8oAByn+hXHGMOu1MS5gJqga+jXScIxcCKiUt66daN/+umnxiEggHJ2oxfKfNqgkoYjbFPm8kwpDTHPhbO6mHVLkm4qnx3naYP0dscJ3wvHmH3o13ES57trx2tFmwmSb/ECs6FcQye5zbONKlG6N3JR83qdJ0mw1llARSAaByB595vpcv4L2dSzfnJqB5H9OucuGIgiSYEhzmIknX1H0E9hBkU09mz0spw/F1XyBRxp567ea/7lOeSF36UFcrzozCL5YHejB5ktq7Lbw9+HurbPB+wUOfDI52gSBF1jd2KkZTModDRdCvPnG1+OZ4BCI0ZJeAldZiS2bOHnXN1n+RDWCXCL5GZQX9/uDIkqXnsjTNwRt0Mw1+c3b9fOlao+qe5At8+yL0joUURDt7TbuaPaI7/PAdZ2WUcTfv4nVeXTvlKmYl+PShJz2FkDW7/yDKt+tcdhqe8apLtL5Zs/F8qRj0301KHOYqzVa9ZK14HpU7PH6eiLosedtPlnf1R6Zuu9+2xk4q80/YOwnWvFOCM8cI4/EnSNveKMOEW2KqPO6bIOoIvGXpI0VbvOMyfXECamipLHYu1gitFRNLBEhZGje24ig8dnmDic0um6D3y7zst7wWAucRsBoiC6k5486AgQ55oFnf2dT4mTr3LGMF7fr9byObJ4cSXT7c+5nO/DdhZagW7SNuP+++83//br1y/r948//riccMIJRodQuI9sscUWWe8hTwKrJrrl3nvvlQsvvNBcD++7/fbb5dRTT5WyFq5n/Pjxxs7D+uVnK9gDSYwAKUXVvnqt1FjXcb5W1sqixYuNHdIc0zefTi3FZsRn6tZcT7e9oTech2EeqV29inn/8pWrpPP1I/J0hYUtrepUkmmLN/BNlLDUqlZZFq4UaVKnhsiy5bLDJrVKQPPaVUWarZ4ls2atMfmysDFGUqwXG1KcUabAOYtK4p6qMi+68KjCRqA71E/MzI/vvjOdy/bMj6jnCxMQhek0TCLosZOGnA8azjQBeg2mCNySYBCwrwmnnfXGOaHYwO5G53rt+bRBihH+vd+WcvXbP2b9DpqbfEi+gjHWjXtAZbHSTemsKwIj9pRdXRyH2j2fHef5nqeO4+7XcYJoMpJXmGQkAhiHHqlo1CZlMePcDkp4P+MioNDymmebL90fpTsjaeDcq4AqClDx04xFst+9YwK//4I+zWSLStNjU+R7SVpFO3Y3OvcM34HA3TkaQ21P3DmWFYGq3XkexOtczgI5LVIIOlsWWbN2bSkQKpfETdqlGXgEOV/aNkP9cu7BhAkTzDxBLyFxPmzYMLngggtKfkdXCL8vS9GEO/spjK+vCa6kOkNU8FUBjoNeS9Id5yR6bCEpGebzcc5tF43lovRNkqq95HoYZ9CibgkdYPdbxpRp4p7reffs7WXve8elOjLKbXY3MQBFYPhF2CuNAXjmvXTa6Clz5fTnsgvknB3yNhjhBAk6tqwnz53UTfIpXF/ascTNQ6e4/r5Z7UolbDU6OosXQGNSdjesDSrGGcF1CP/yCmIDdOwRttItzkgCLPHSxeTRyKflYi/xO0bY6wBc5btiP/CFw+znsNeghb6sIXETdM9hv8PV+2/jCZwjdKRPvGxHoxftLuuKQtUeVOwRIEjUESC2z1+IoHk+8lXvHNe2hA6f/VSvQWZNbQlStJvvAt2kbUau5wdAPdd7mH3OqxCFPU5hcdDcKfFr0h3nFCiylchFkI8kz2vnmFatWStVHXtt5eo1Uq1KZdOtrt9jQxU/0NzPDrB+D+9WXSo1ai2nvDRZNmQpgubJS70aVc3c9w9/ynSbz1u53g48d8xWsnLxfBPDoaPtGCPIuJU0qdqXV1A8o0yBc24oAC5AaFI0rSq5kl0684NroNs7LMDlFQTkSkLzdxwoXkE7Db3OFVR4Lx1cFAjQLaTOcC6JGizobC2CxrDBVBjh2oLORtcqWTfH85CuLUsB5zvcOloe3SNdej2VfIEW9nnY73Z1sVI64myxV1B0dnVxGIc9n9S/+Qwm3JJTzipt9h8BJnNg2X+ajAw6HxmwCKloFVr5Flv/2+Mwwui/MOcKqo81uRVlJEgScwntAgI3msMwnYUUF213Y/Aq213a1pWj2iyVtWtnSbduyd8HW/KR5ELHOUdjoENnzZplqDLRsTbQG9U5rShU7XpPguhru0gBH9Fttizgjtoo3vfz7KVy4IMTQl1TEkm7sug4t/dSVJsBcMY+VQHIxCdmTVnzF1980ext/h/Q+fzzz5eDDjrI0CmqHHfcccb2DRw40PzMe3bZZRe57bbbZL/99pPnn3/egO0PPfSQlKXAUMT+C8PspJIGcI6fwLUEZWGKq/ttG0Uy7c43skHaIOdPYsY5tlhnywcpGksDOEf+e/J2oTuS05SNG9aU43ptLE+NzabRZOYfCZM0mZQAvQB1dSQJBWE6kkTtlxaBQaf4rzcn5dShalOca+xGQZ+GOM8b5Jxx9fiz49fPG1R5/9ztpUX9mqVGZxH/kziPS4VsX3sY/6IYZwSXoMVTQeKMKAVQA17Lnqfqdi2MYiBuD8OkEseeaOEN+6hr164m/xJWwhTpaqEvHeY0TChldRTbkIuyvdug0fJg/6oleRCeT51xv6GKPQLEpidX1hwdAeLMF7Fmfy3JMKgUImieJEOilz9BjG3PlN/l/q+z/v76UZuY37PX/OxPvgt0nVK0GbklzAi3JOMKjQ+gZl+6fIVhwqtcqZqxQbaPDWjuHElNsbmNpa9jbN/g5Nurd8v5Hj+bw982b1LDsEc42ZU2VOm2cR2ZODV7zExRwknL+jVk0fJVJaD50T1ayeAJmVjj7J3bSLtNKDzPFJ/bMQZszPY4Fq+GyDSZTBZXUDyjzKnaScylMSvUzyjZMz8AD5LYNOrQ+AWwJCNIGuF0xpmtGyaJRcUHQA3vD0uXHjZZprOnSMZ27NjRrG9a4kXr6JyNrl3VrHuUbvSKRJPrR8MJqMsLykyldGTtnOsWpIs6313g+QTO/apJbdou3X8K9gCiB6kGIxnB75LoVt2QRat50bUkXNizUUCTJEENinmgvPOjps11nji2kmskGQSw65XYC3IO9ME21wwLdW4SJNCwLVu2Svr27Rt5bEcQKYuKaXs0BkAjSVToJNGhFCnY3egKRBRSZXchdJxHmS2rVJJ3f11JJmXYOwPJtftvJQd3SYY+PM2K3SAJtKg2A0C7f//+JT9fdNFF5t/jjz9ennjiCVP8xe/ojMaXAyS/6qqrso5BEY5tf9GxzDG88sor5YorrjBdd6+99prxB8tS6GxG90fde0kD5/j/YfyWpDrOFYB4/Jv1x+q+acPAn48iCpDoaCp8KGKRIJ05cYDzXD4iIK4m9JPu7o4il+y+eSng/PBHP5NPL0ufSx7QFlCKlxvbB/7TsOk15L/fZLr0VbzWjGMc8eqsQO9NWuigCtttHjeW8CrYAjR3G53FufAPlPELvzBOsXLY5FcxzggfT/h1ihNnkGfBr+3Tp4+nbotiS16Z+KfnMdhHAJewRnTr1q3EP0pTnxPXwpZIARZFc1FAc72GILqdYn4YG5xMiXG6wGmKOPn9Zb72mfuNf8mLQi+eGf5NotClPIuTntyZL9IRIKzTXo//5JlmLmt7m2QOKUg3Pc+tEzRH8IsofNE8m9folLLuOC/ajGQlybiCY5nGsQXzZcbsOdJ6x81laq1qMuXH2dnvq1ypZJa5SvUqlQ1Ne1WztzJd6xuiBGF9yAWc8zeOw3NfSIW5ZSVF0Dy+zF+2Slo1qCELZy6RxnWqyXPrQHPk9L7ZzNHkgHjB5KnjVpQNl9yvFrjpWGONzdPKXy2qoHhG1YqasHUzSig1QF3A3ajd3l6iDo3XJlTqcjZQ0KSR37l0Xqjf+vHQcE4eFL5v2IcjTGDCWhP84zwnTbsfVQhsbGpCv270spSy6DgPQ+no1UXtRemYrxnnyvCQT5A+zDPkTEbatO5e1WAkLJOkcKyIEmRtdFTHmDFjItEIhpFcoAZ/I/HD80N3BsViUc8TleaRtSCxh+g88yg6369Tw6u7A/0xevRoA1yRHE4TNM8nraLfOUi0KtBrd5thf+iY5llX2+PXjZ6P75FPfY0kcS6b6SNsgDru0j6l5rzFkXzPHnTrOI9iM3JRI5533nnm5SfQpTrl73//u3kVkrA+UZNUcel13dY47H6JWzTF3qBwj857AAj58IeSvx3fu3Wgz8ehakf/0QVDzBVmNFUc4JzrpUCawg/8VNW3+qw4n5dPf5sv3Tct27jFLeHWfdAoGXLSlnnzCZ1sH+z9i1/+Wj74aUHW+94+djOje5xFYPOXrpQDn/ujzECS7W5aP2e8eb3qgdctKjBhWORmLSn1+9EX7+j5GR2NxcumQtYib67FBlFy+UxhuxGLcUZuCUqxrt3eQeKMuLYEf5p7x/1Wn16ZVMI2RfC5sHteCwTQoeQH4ozg47yA8F5iFwV079695FlJwibl0gldb/rY6CzsFS8KBYiZuH/E7txvilvUpgShRE1TyvLcbvki4pwMaF5amtWrLsPO20EKRfKZQ3KK2kV73XR0Cs+z2ghsQb4LdJ1StBnJPodpFOTOmTVD6tStbwpaxs3+w3STZ52TjnMHMF69amVZsWqNmdc9b+lKqZFgbFxe5ONLdkokHrH/VgTPs2WbxlXk+znJ7veKLvVqVJGtmtc1sSnSumEtmbM44zO9c1ZPX31jj1uxGyJ5gdWhexSnI/6I2liwIdqMMgfO0xKnUWLT4PwCXoWZKxtU1PHinM5KVBwhgmGoy+nAibuJcoH0djBHIEdAF+WcQZNWQUGZpCVMQs2rG12rZO/YUeTC0dmfefq7lXJ1O6nwHedB182mdET52pSOdoInX4GIBs3lobtdq678qsFuueUWY8hIRqCv3J4j9Ms111wjzzzzjNErBPUnnHCC6fDzu7/33nuv3HPPPSboJxn6r3/9y3QQqnAfodt98sknje4guT1o0KCseVIEdnQcvvrqq2YcAx0Od911l/Ts2VMKSVgjOiFxBki4RAWqkwiA0I10+PF3dGOcyruo4AnPK/qZdaCAym8Pe51jh0Efytwl3kkup3x/zW5mP6rtI5Dju7P/8iX5HBnhJ85uM6Ud1250ZaKwZ6Pb152P71BoVO1BOwttkCSIjLuoZ6KgeSF0nFfU4KRQJE6CCzsOeBtX4lC18zm6WrkWOukyTCPrgfPNmtQJdP4oviqfoUsPfYftwfcJI1HPy3emW5rngjnympRmHAHxGQVN+Kx39V4l53+SCYNPePqLguiCG3tJH+l1y8dZv9vzsR/lqX3LZk7cwY9MlF9mLy01t1Upx1lPtV27PvRdqkVKucRZdDA0BEAT1b/3oiGuV7NqJCpke/48frZ2/NsgihOwLALn+bcB/EwMTGFO0ILYJMAS7S6kGJWi7Pbt24f2P+wcUtA9r768FghQRB+3mMtLt2OriFkoMvAqCohqG/TcI8/qJDvf95Xne2wWEs6FX47/zncnrtP8EbaV9VcdyDMap6CgPIvmi/rc/bnr3+/uQ0FQLUPxHqQgKB8St3A46Ox25/vsvzvzk+x7Z4zIWnGt2Iay8PeLcUayEreISoWiVM2/b9Gurfy0jnqtVvUqsnRFtq2Bqp05586O8xWr10jNahk7UK/mhsek0bRuMCbKXB3nTimC5+ulCJqHk9pVM/tMQfPDurWQlyb+Zf6fsV6tG9WKVeCGPidGJo6jwZYYRHEctxgjiiyuoLmpCuvd2YkmACoMC6AUTngaTq3OXLIDCTYnQS+OdefOnSNTWjlFN6FbwpbfEdDQVR2GusvrPLkCk7hd7XGuLeludBmd7eyP+GO1/HPxYqNM0gRnC63jPEwXtT3XVzsplaYYRz/NADJpICafnYXOajACI5K6//3vf81e5HliVuxee+0lxxxzTMlzDJh9//33G4Cb5w263RNPPNHoNq/uQN4/YMAAefjhhw3IPW7cODn11FPNuQ844ADzHoB3wHjew/iK9957Tw4++GCTnEGPIKeccoqZ4ff0008bwJ7377777gb0p/OzEIT9CFCNHmTvpQ2a+yXDcEgo1kpKN0YZnUFRBvaAQgiSPrl0gPMcwyfNlDMGfxH4nJ9curM0rlO9hN2FPa22jwRjvmaPF7I4acdVh/ICiNBudOxOGmNsyqrAIMmO8xc+nSbXveve0eIm7TeqIZf3qGYYKOzZ8xQsxLVRhTDjnOCkKOmO/Qgr+MbYoiSKdKMCLhQK66gm9IrbeI5a6xJmSRdt8X4q21kHdF1Y0DxqVyHno3CO78tIEvxR/CPOzxrqCA3sE3J7v1py0YilBUPZTufP3X/fVs59MXu28XHvLJSvMq5YXgS74AYK6/poEZhSjjtB8+cObCw1q+ZRLzoSwq+c2j3U56MU/C5d6f5MfhGQHj7I/HmNp1hjYiyeafazAum8L8qM86LNiG4DNM7gXoXp9o47coM9CuiIEDfSjBF3tGCQcwLeEUvYeSyelTjAj5dNodCKnBK+GYXPXv5ZHGYpZWB5bM9actKQ7KIgL7HPhQ+pjEc6dkH9d2yeG8PJhiJeQDIjM9A7zoIgXSfud1l0VMfx3yf+ngE1woLmuURzF7yUrZC9BZgOa1CQ2bVJS9FmFEZc4TV2lrxhzepVS0bVULi3cHm2fq62DiR3dpzTaa4FjjXy6LOVN/GyOegznlHy4E5WxSJ4XpQosnKNyCaNa8rCGYulUe1q8urnGdAc+edu7RJhFUMHkaPdaaedShr5NMagiEuBdPZ0FB9mcQWNM8ocOE/LodSZVCRQAA7idF5HCQS004QNSKchmzTJ8yBOBc45Ceb4N253o57HL7CCehggLR9r6yZJgTBa7ekmdEhS+KAOatKz0Qu94zzMXF9NogEWEmSTmNQA0mumd3nqOA/b1RFG2FMnn3yyKUi48cYbDYA+ZMgQeffdd2W//fYrAdkAsg888EDzO4Tn7rnnnjNguJcAdJ9++ulyxBFHmJ/p/h0/frwB4RU45z10oe+7777m5zPPPFOGDh0qt912mwHI0WMvv/yyvP7667LzzpmgkM73N9980wDz119/veRLvPYQzis6F1CfpC7UsPkQZzcgzxo6g8RAUMA66HmCJt14HwUNrIkbzWGuwGDZytXS5frhga/t8r22lBN3zCTxsLt0ppAAs9ld8kWhXmgd57lEmShsIMIGduhqIoHi1o1entYpKSaSsEmoURf1lga1MlX02slBgGB3+6t9j2Kj8k3V7gRJ6EBJY19UJImzNlFAa8ANnltsLS95fVjk80cFXNAhxAMUh5LgJ+HqJnScJA2c2yxU6DVikigS1mZoTKLFrs7n0u4MRIYPHy7tWmAb188WRy+UZSIf6bdVE1PQsJTsiSVDvpspe7ZPvxgQis8uPqC5cz37PZAN8j/Yv6pJ6n788cclcVPac4G7Dsy+3i2b1UkdQNn+5mxmAKTflk2kcoK62B77gtgjn8hv8IzoPGbWN0h8WrQZ0anaNc5Ap4YZO+E8ThRBn5PgRABLoordce4ndh4LX97OY8UdH+L2edXfajf97HYcqnbsOXo+s4bewLkWUuWiRFX/EUZJ1koLYZXhxB7LVJG70XN1X+sIEAo+bF+cHC17TX3xtGKdpOOf454KXlRuS5jiPGUrJJfGtVKEjw5gf6H/ifOJsXUP8r404pGizQh2r4JKHPYRt7GzNMvVqFJJlqzrMq9bo6osWp59fAOmL8u2P7zvj7lLpeY64DyfOZryKPb6mDE9U6aYF/eTnBfF+QDndkEQhZRu/nRRiuImdatXkeY1V8sPMxabnzduULOE8XPIOdsnZhc1d4VPovsVH4b4XWMMsBzELtSqGZBVuqLajIrrwa1z+jEuYYCDOKKGEOVJ0ghnBgA7aUfZLeih2owqXQBgqAmTOKdX0kqNNuBQly5dDNiXb8nXg9ihQweTiNDZ6MwqxvFXJcN6x3VSCz04CCqaROM82qWsc33tmd5JJdF41txmVaYl+aDkpZMBvYEzzOvCCy/M+jvdDQ899JAJ+rfaaitTpDBq1Ci5/fbbPY8JOOQ0dDh2gO1QtHMfvN7DsRGCXNbb7z1lJdwXQGqCyI4dO5pkCIaf3+ejG9QGNVgnOg7Y93S7uXX4pU3Xa88+xP6EnX3Y954vQs9dVCFphB3C/nBuuxI+X8B5eXbSnMDOBx98YPYQCSYnLW5SSbh8AudxzrN81RrpMWhUrASV3cmB6Ox5XraNCtPJkU+qdtbQWcDFd0iyMLMo0RNcNn0vfrg+x3ElDEhhF27BHgNwTQDr9Xm6UJI8v5OFimvBv4giQW2GMyah0p0CpCDfi8KCL69oV9JdfeiLf8mD/WeZ+BEdq/o237Sy4y7tWwqIuPiV72T0xY1C0YAnMQLjgE7N5Ma/beP6fjcKWoAQ1hawV+mMNcGv6xm1iyHoNaRN2Ttp+iLX3999+LaSprAP7W5XZdRD59AtQiGzxliAKG62qWgzwokC3uxrO84IK3Gp2rkG/GoKfuIcR+NmP52uOSWeU0BzZ7weFzi3dbuyM7K2QXNKUanaKWrDHgI2YZ8m/Xtb2frqob665fmDmgQ+F88n7CZOhhPt5PIby1QRQfP7dq4UqKtafXGbeStp6lg3iZojiErR/tIp20kckMNmK0TwU1gz1o6iE76Pc3xiElK0GclKVFugxUzcD7sxgePVr5HpHkfqGeA8GySnc3X+ur+rNK5TzYByDWplnq/KlSuGPkpDbJvFveN5IzcDkydxHzYFfcbv6D7H5+V9PI/PHt5Gjnnh17L+CkUpcGGcQs1qlWTygszPf+vcXN74crr5/7N2aiMtGyQ3Ctkrd0Wen73MS8etYV8obJw0aZLxWzRH5ldgXlFtRoUEzkma0PHGDQdoytfMbRwaqpFJwAapmE0q6NHZU8zGgb4rqXO6Ja20m5CgylmBnG9JGoRxo1SBfpDf6+whnBZ17nWP2WBw2G708txx7nUe7SxkLZwJHtaOJBrgok0Fwv+Hvb6yoMhN+3w6v8pLLr/8cmPESIir433DDTcYOncvge79kUcekYMOOsgk8+k842dAc5w7EkC8B/CdbnJ0yLBhw+SVV14pcey1COi6664zM/Wg66PTna5uGCfKSgCJKR7gu9jMHmrI83HPdOYgOpFrIcGE3UmSmULPkytRhcNOV0oUevjDHhonX01dEnqOuX1uErjsDfaIc93zDZxXlMppnk98CbckXBKUkPlapzizBC986VsZOmlW4Pf/batacnL3JoG7/Ulyqo1ydnKobfcqkstnx7k+/86O84pIh1XeElxR6XuTLJrSZA5+Fskcglr9vJftWB3g+Q/a3Td16lTz3NgsVHE6A4PYDL4zvjjPLjPceWaJwYLqNTffGF9CR2jQOQ2o4+wiycczD72tky59x9tGmw6WJLuaVWCa6enoon7kmE7Sa7PSBYA/zVwsBz+0nsUAenk65RGNAewEP8UTmuCni4E1t5m8otLNOmO298/tFek4YeOJwx75rNTvbj2kveRTuF71efHtWXedjUsiF7/YrYuzaDPCCWvGntWC0Kh5D2wJ9ySo3DlsctbPFONyLUnNSvc6hnZ+++WU4swY18/zzJFTIm4ibxcmpxQ2nuC9JH2xUerX2cW/fuC5fj5uIawbOGwXwpYVw0lc8QKRPz63qwH5wrAXOpm3kox1kmLCOvP5ryJTtG/dvG6iIAd7iBiRF98F3e6kw1f9H2c0VdFmJCtR2Ee0SI5YFDtkFzOxh+tVr2RAcPZB3RpVZNGyVVn+LcxrC5atMmNtqqwDyBvVri5zlqyQzhs3CFxIu6GK2hx8WYrKEL0PusbOgiB9HmfPDp6/KMqGKWrRZi/O6IWum9QvAc2RM3baNNHzBcldsa+xvbzwB1euXFmKKcZmFrZtc0W1GWUOnCcN5imNFl0EOKlJgxdeogEACZuuXbumPltXE2l0noap0g17DjvhxXpitDESBDj5mKvjJWVVpct3ds5GxygSjJGoiNKNXh66/eLOsXWb6a0BpM5sC0uHn2/gPB+dhSQP/BIHL7zwgjz77LMyePBgA4ySqL/gggtMZdjxxx/v+pmrrrrKFNfwzLIPADZ5780331yyfnfddZeZew4gz73jHjE7/bHHHis5DnTuJ510kimEYB1I1B111FGeFLBpie4t9o7OEHfOwrOB8zTpQRFdw7FjxxoADiaANPZlrg4PEnswYnB+RicEfd5/n7tUdr+zNOWol7x19g6yZbO6rueGupJzu0m+qdoriuh9dCbhvCghVY8GTZAUMlW715xdP/ns8r7yw/ffhT6XG9Cj3ehaJGd3cmhBps6Pzodoots547wiVvUWElV7rgSXPWsQG5q0/tfiLL9nVf1znntn4ZaCHG4+09J11I5+kgsk4bjEIvhyzvgnDsCSy2ZQOEcCi/WxGU6C2hp7Le3CWXQOP+sYIqWVVUCSn+1u9LSKs7m+T/65o/S+dXTW76F9THoWOxSegPK2DD9/B2lat7RucwICAPz2WrrtU/ajdjGwXzR20rEGSjcbJnaauTCbyYBEU4v60WL+MPHEgQ9OcP39Xnmg0fcrpmLNyQPwcuvixKY99dRT5r1R/eKRI0fKLbfcYvx+ANZXX33VFOW6yRlnnCEPPvig3HHHHSZOUeGazj33XDPqiTU/9NBDTQxSSHbMjjPo5qdwhhgqTudrGMCb+3r/yJ9drylut7fXMex55rlySkl0nJOEpfga/ekEgoJ8Puj5FZzXLk2Ku8LYpCNfmy1vHB1v9KGzUNMGh1lzpSq3u9HLg7iBw1pEBdAXxffyinVsZig71okT40cp6B01eW6kc8Wx2UFBDuwoLwoX2fe6xwDR8ZcAOdTOhhlNVYwzkqdqD1NEpTkWcnMAWM5zacf5ilVrDF07IPmqNWtl8fLVUncdQxG/Q+3h6zWsXS2r47xJnbLL55e1zF60Qpq4+LlOYc2xIehr/H+YZ7ShxS3mcD6Pn3ZaId1vGZPiNylKeRaKWXpt1lA+npKxL9PmLyv5G3Fg0nm6KJhGtWrVXGMMXsQY+MfYlQkTJhjcIUmfHpztsssuk//973/mvBToP/7446agFOF6rr76ann44YeN3evTp48ZJQv9fIUCzpPcAErV16lTJ+MUEJDjbKQ9U4hgFACLa6DTLm3QHOEBwvnn3Gl1ftuGgIeCpFySicG4SqCsQRidjR6nG70idpwjufYHa2FXyWoSDTp8pQLRdfPq7klqZm5QyUdnIcGJX4XWJZdcYrrOjzzySPMzug6dN3DgQE/gnIQPADgJLBJArDl07zhzqqv497XXXjOBFfeB5CbnMfNZ1wkO+4cffmiuka53jsPcdPs9+RCdK0QlutcMcaU0i9uVEeRaAC0RBazTEq9EFb8j8YyTEoYemGvf5pphkWnZ9dwEcyRQc507iWRfEB1WUTrOc12/kxJSu6V5NmD0CNqhUahU7SN+mC3nvpg9OzdoYioJ2+Bmo7DvPGcEztqBigOfT+DcOZ4kl80oSjwhsPSa0c2+wA5hA3TWYBqie9krnoE5BmDAyz+3xzs5/6YzEXOd3yvJx++Jf/AdAD+cezFOwZSfzSAwJibBd2Gkkv297Ocj15xcr2tjzndljy4SnjkF1NAF6q/ySnrGKDMoB+7ZUgYM+dN1/m4SMmvRCul/V3ZC7/MBO5V0JTnPa4vbNeTS9ayPdjHgP7rFTlqY4DVTj/uz63/GZv3u6eO7SlQJCpxDZT9lVmlmnlEX9ZayEI1LnOvt1sWJriKeeuutt8zzA0PDnnvuaRinKLYJ8v3Z+4CqFNEecsghnu8DUGfep5tOhCELn/H99983+oMi3dNOO80UBBeK2HGGMiLEzSUFBc41pxT3OGF0K88gNgQ9HiSnFNefZx/hszLvOkqxcdCCLPwziqvw55Ry3k3v5+o6/9vg3+Wrf7WVpMQGh0nsagIaW04uE51nM5x4JbjLKs5xYydx2oOkYgs71mHPobsURCcParMXhh0BErYBIypF++iLd5Q4wnWG1T+8n3EpvLQAQe0seSO+d1DWl2Kckaxwb4KySLHHKc71y7GgH2Bbx2UDCN+4YU2pVa2yTF+4vAQ45+fqVSvL3CUr1gPndJwvXmEAdGT5ynRzZoUoO94yslRuy03wVfAJyIU6GYWDxDk8X8duv7E8PW5qItddlIojtatXkS2a1i4BzbtuVFk+n5nJOzxwZEcTBxYaplHJEWMoayN+5L333mueFXyXK6+80sQZYYsjbaFwHSC8f//+BjgnFqcYzB6HSjPgf/7zH3nyyScNJkfTILEN+jPJ4vYKAZwTZHCj+FdptNShTxs41+QNjkc+uhuV/oBz8R3jbMRcooYgSDdhFFEjE8WxLsS5ULm60b06KgoRtEi64zxMAYJSgbB2KDy7u4f100rsfFLkFkrHOcG18zsHofBG0BMEnsjzzz8v+++/f6ljYVzoKOcevPzyy3L44YeXOo4aSu7Re++9Z4xVPoUAAp20/fbbm8RrmsmloLOmEA1O0xK3RBU2D/vD78PQAx/7+Kcy7pe5kWnZ7USb2t1cHRJJdJyHsRnlHThXCfJd7dncJOGcHRr4QHYRl+0T5dM2BD2PV3LKS0hK2XN/k2YjsW2UdnKojaKIiGCBlxtdVZKi882dwHkhdepVNPGyI16zBtO6BsStQxDQHnAH8BjbHebzyIxFy6W91IsEkhCLAEqw37EBbrFWHIDFy2ZQYElxELoO4MUNNLTn5+rv3MQ+vt117tXVzXF43nhxbttf5ZrYK6prg7In5ZJurWrL9i2ryrg/VyUOnsM4s+994307yO3z2eJ17rA2xSt2smfqOQtpuT9BriWosEeDxNLO+e8I80Hp5ioLUZuQS3gPACUJLeIpfIM99tjD+PCnnHKK2btBZJ999jEvPyHmpaOcY++3335ZfyMWfvfdd2X8+PElnSJ333237LvvvnLrrbemVnwUJ85QOx9XgsQkOm6JvS6y0PU9SRQF29fCdyOO0JFcQXJmUfU6zzc+KUyJxCsUekWRIPEE9421ZE+Rv7JzLm6fDULZnoY4E9B2pzC5N2yMzXCS5BiYKBIUPE4jBrPBXjrOKPRQMJg9pX9Xe5GrqDWMrYoKmiN2fBJFeFbjFuiyb+zxiTz3NusLPo09u9aOoYpxRrISxBbo+CfuQ66xs4aVas0aA4hDvb5Jo1rSvH5N+WvBMtl8o0wxK/u8Zf0a8uf8ZdK2aeZ3zEymM12fgBkOFp+irC+iI95BPwOcu0kQfXfpHpsXgfOiZEmd6lWkapVK8uW0jL/Xr109GTEl8/87b9FY+myOL1j4mEbldayN/fr1M/7k+eefb/ITFGn9/e9/N88HsXsUTHbQoEHm2aPDXAW8SIVj33nnnQakP/DAA83vYNeCYZemQG02rBDAedzkogLX3CyqsfSGaFdOmsCJAsqavBk3blzqHY5KRc8GJRBIG6gnAU9HRZhOxii0o1GS3Gk45W5zzqMkp4J2o7Nf43ZhlseO8zBUINrdo7MmdWaTPVcmbfGiOU1a+K5+YPABBxxgZppTwEKHG7qP2eR0f6gMGDDAJK4wGgjPL7qJ7hKSMryf+XVUZalAM85noFnl32uuucZ830svvbTkPSTBWAf0DhXxdL+T9KBbJJ+CIaTyLJfxjTJDKqg4E00jRoxIXfc7E1Vq+8LMM5+3ZKX0GvRh4HM+dExX2WWrpp6ACYF2UPrKJIDzIDYjHzohn7o0qQ4NpXQnQY5d0iRcnNnjYSRIF/hXUxfI0U94d1q5fsbFNqf9newOVKU/5HdKV4Vt0uQdvmlSfppbsVgum1GU+FTtTt1OkQQJLdX/+RoHYl8Htg07zrOdq4jM7jh3yrtfT5ddtmwaGiTRWARfhBjIa42TnHHO/yuzmN9ILPtzfjbD7ZoBQecvXRXYb3b6q9hGugYV9AUMCTu+yU3O615H/vHW/FK/jwOef/vnQjnisYlZv/M6VlDQPC7jR65CWu7nOaOy7wkz3+NKEP9+1OQ57r+/KF43YRyJUkCMzWC/HnfcceaVZHzIOh577LEmPsAvdQrU3IAyCpoju+++u/kOxCEHH3ywFILYcQb6Pgn/3g8s4R4A/BGvlbBXveLOCBW0WDqITg8yz9zv82GE747/ybPMubAhUSVXPKH5OWJUEq5hPqvy+mnd5cCHPk2F5SNopzB7AQDNzoEo2xGvfBcIBwWP85V3Ih9kjwBRMJj7j73Qefbaje7UlUHzOvOXujPu3HlYh6yfASGdksSeSTr/xLHQw7x4FjVHyUvtLH8DrMfXxK/h5ygCI+Irr7xinkf2LiAwQAi5JBXiqIsvvtg0dVCMT6fgfffdZ/SwCvrxzDPPlOHDh5vcAyyLHDttVtm0qNr98lNhxz+pbWlWr0YJ+M3Ymr8WZAPhGzesJVPnraeApgOdzyi70rT5GyZw/uaXf8kBnVuU+j1rin3EB2X/+xVIa0NjrntVs2plWbYq/bx/UcqHwN6yeh2pXdsmtUpAc+Tuw0v70ElJ2s2HlStXNtjhbbfdZp4L8o9RdfUbb7xhbAIAPMy3FH+dddZZZsQswrFhgySWUCEnAu5BzFGhgPOoYgcZbl0H/H9aHYdsABwLnH4bUE4imMlV8cSLuRo4z2k6zCQrSFCxfjvttFOi85ZYI01s62x4ROnmeAWZ5VOexNlRoc49DzoOI9X3JNoJlEgYJf39Crnj3E+c3T12JTaVSzj7Ch6m2elnzxFMUwiQvbrGtDMD+hEMBvqHYPH000+X//u//yt5D4kQdKMKzzCGiyQuSV6oTkaPHm06J1XYg1RqoV9Ya7o/mGluB0okjwDlqU5mrZlLCIifD5YNpwQxvkGpsMIKhQXof6ialK4pTd3vlqjSCnGvjjs3CdtJ4UVdpYAJ56XiP+jzFgc4j2IzKkrHeZIdGm50fbp23NckQd6wYHbYLnOv+bt6rnyxkXAuknckOJQSV2nztVBBk3fcgzj23a27MJfNKEo8cdoR1b22/k9b9BlV/Q/whd+DX0kSMlcnkupINxv1yud/ysCD/YNz+7POWIR97ydJzThH51N0SjdyLiphvd5cNkO/jxMEdc46D3O9OtNQQV/0gNv4plzUqEELe6MCOqOnzJXTn/uq1PHjguZJxxvOwgTuiS239a0qP/34Y05K41wSxGac+fzXpX732D86S1lK0I5zP5uRpA4DEEFnnnfeea5/J+Z1zs5WRhz+VkiicUZSuSSv49iAMgUFNv1kmOOEEe454CKAQK555kkA58SY2CyEYjNyIHHut5c943fEuuQHunfvXuL3Oj/rZpP47DdX9ZNtrxthfrZB87ISuxudYgqb7Qg/hGsmDwrAiA5MkpI0Dmiez7yTHxiszFvErGp/1QbDBhO0yKvv7Z+4/n63rbOLDrsNTJYJJV+Mh84cJT4m6wY7CGP70IWwGjGCY9dddw1VrAvQcfbZZ0vPnj3N/r3iiisMdS95FB3tc+GFF8rbb78tL774ojn2OeecY0aBfPxxZhwA+g72Eq6P/BV5Loq+8A9uvPFGKW/ipcO1OBRWjjDjn5SFpHWjWvLHnKXmd80Bzq05yQgU7n/My/xdZZOGtURbzr/9Mz6zSnmUf778dSngnAIOGkTUZgGguz2X5FvJS+NTBclNjf7njq7MRUXZMKVDy3ry1bpu88XW6LQRF+xQUtCShqRtU5ZYcQbPgBdTQxAh38C88osuusjYDzAzYgzsFgVU6kvahVb6c9JxRbkEzlFMBBkYdb8gIw3g3On825RJac3UtTtLqJ4g8Qo1Y1pAjXYTsiFxLJMCzXEIeOkacXz9WTt6beBVDY+XU1tegRG+k873Y/8AxNEZiINvO/dRk2tl3XGeJmBhV2KzfjgsdB3pbF/+ruuWdKcfko+Oc7/njYQsdCS8vOSJJ57I+rl9+/YlOstLdtllFxPE+Am07W7U7YUqSet/e5Z4t27dsqjZ06aF13NgC7hPQWaKq3w8ebac9JT//bfl2b9vKj06blXq9zYtcBDAJAngPIrNyJddyNd5ktbbTro+7ifV7W7d6IBTSZ3fyzaM/GmOnP3f0gGpn+RKRuUbOLeDD5s2H1EqSV4kqhFn8i4OSJLLZhQlnqhu54X+Z651GgxMQYEKnlVGZOAzhpkNawMdF+22udw+bHKoc/P8usUiaRZM6Wcp9iEmwZ8DNPfzifVcPBcUOWCnecbcbEaYLpEowvU6KcjpRtfiC7sbLmhBTRLg+ZtfTZcr3phU6rhuc8RtSvSbDtxG9uvYrMziDSdo/ujRHaVt3dVGtwKWAZQAmthjnYJeR67YxQs06tkmWhdeWSa/0rIZn376qdx1113mWS1vxe35YK9yixNILhKfEbuSUwoCfMaNN3hOOK+OWVLwKi3gXNmx0MWAQXwWXRgnh+Xm61OoBBNMrvFRbkwmdpxhyyGdmsorX83K0gOfX94nUINH2mxHXDOgJH46fgkAuo614EWOJKlrDAuaq5SlHsBPIE7lZY8AoaiC7mctviMm8vMB4lC0JyX5HE1oN6ycdtppctRRRxn6W/woQAsat2AGAeQOIoDvzhwVhTrYi5133tkUGj/66KMyePBgA8ojUPKSuxozZozx+YYMGWJyH0OHDjVgCIxD1113nVx22WWGITGJPGk+xa2xI874J23eAARn/A7SwlC1l+44/2nm4qzfbdKopsxdvNJ0n69YtUa2b1Vdxk1b1wK7AclRj46X507uaf6fwi78GPxIZXR0FhBz//A7NSeI7xkEz6hWJf92oyiFJ5UriWzXuoFM+C3DJLZD24Yy5ud55v8v26GuNKlTveCKbssqzuBZAu/VIimeN3IRDzzwgAHO8ynlDjh3dlr4JR2TBjMIznHKMfgYdOeGS6PrUIMqEjB2Z0mcuYF+okk5OqdwzPn/JMQGOxCtxLKDD76Pvo//t+8d79H3qQGqKMK+cetGj5Ncc0ohzrFN4lw6t9umJOY5dXb6KU1XnE6/fAHnxXm1yUiSVO1aMMVz5DZLPB/AOd+Fc9BtEGSmeJQu85cOay61alb2pavKRQucFIAS1WboPSeJph1DZZHgKg/APOvCPiJxStcR+1w7NOhGVxBYgYg4hUhuNihsomncpX2kVrXcjn4+gfNcCS2bSlLtO+tL8k7n9+oa81z5BTJewHnRZqQnrDe6BBph9q+b/s+HsMcoFGTfhOlEsT+vMcM/erUODZzrGqBTg3S5u503rLDexEBQrZEsJe7ye9bUFvA8EcOQ0FK6dC24xA/kfYAM/KtUpHqtvL4Y0Fe6DByVKD2vTUEOU4F2w6mvz9/tgllb1zptAdTkzhnfQa/1gY9+lXtH/pr1O7fPPDt+qtw0ZHLWOYN2PyQdb7h2mh/SXrZvmylOUhCJvaJsKhSEcW/tkRl+TEV+NuO7vxa5/v6zy/tKWUuU5FdaNuOjjz4yzDWGZty6Pih4Kfali44410nRzfPHfeNvhShJsVc54wRlb6KI0Z7BnaZO1TFTHANWjCigeZhr8GLHilvk6own2NMAHfhTucZH2Z91izO+/b/+0uHa4eZnGzRX6XrTx/LpJTu45qbyKRoP4QvwPNtjLch/qC1UmxKmSDOXn37LwdvI3h38i6jy3XEedgSI5opYL3SXzpFnzdTHiwOaJ0nrn8+Yxin4TMQmgOV0jhMbosujCkA5osXFAOjcD5tmF3py7Ai+H88z/3bq1CmroxDqXqjb2esAKeVJnLaANUEvs87412EpjfV4dJyP/Gm2+V2bJrVl4u/Tst7H7PMRP2TrtM2a1JbJMxfLti3rycTf50vDaGqi3Mtnv82XxctXycK5swxDFB2y6ArVYTZLFcVZvIeiXpgU1I4GxTOKsmFLtSqVzLOqoPk+224k//tmpvn/PTevI91apP8Qpl2MtTjBOIPiNxhPbCEf8PLLL5v/19iBAkK7qYufKbKqUMB5GKeKJAjJexIiOOFBZ37EFZQfjgJVdgQ3nN/tupPuOMeZA6h3m3ESZ25gru+oSTkMeRLJe9t4+IHe+v00CaDGRg2QJrf082l13Cc15zyIONfX7kbX5JomguJ0o1eUjnO/QMKmJIZC2tnpp4lJfYUJInPt3aSkCILklqD3ICn9z7NHAZFXwVSabCPOmboInX65gqrHPv5VBg35MfDxJ/6rv9SuXsUEoE69ynNEQorvCGAfNfkSxmZFtRkkzglmqPwFeLBtRi4Gk0KVtHWObRsAee1udKUcxzeg2p+kk9qfsIVIdlHVgNe/l7e+Dj7fsl3T2vL66T1Cnaus7JCf2PbdOb+X5DI/k7xTG+XsmCwC5/l/hmBgwi6TxAsyazANfww9xosgMGint5+NqlOjaqjrQa9SlEjsE3YN4nSck5TivJpE9btG22ag+5VKX+nS6fTGjquPyrFgDiCwd4sz8tkNZ89mpTjCLpgF7HeuHwD22Ev6SK9bMjSmQWOVC1/6VoZOyk6aur03LDV7mvEGHVDdB2XTWl6x1xayZ/uNPCmNdWSGjnUCRGcvoXc1dnKOdfIq+uW7HP5ohq7Tlgt3bVsQnUNRZ5ynAZwz29wGPxTc4Pcnnnii+RkfkvsCWAKVNvLBBx+Y9Ue3FYrYeyHpjnObjjcKe1PU2IaiK3x89CL3IM4zmgs4tynT3Rha4jZ/2PEEup34iOceFpZc30ttklecwe//vVsLuXqYN8UnMZhbbqos4wznWAt8F/QfDGVaQGY3YQS5xjiAcCEB525rBQhLfojCK9aMtdLOfYDzU4e5d90+eFTHUswsTkk6X5h2d2AYm0EBDK8owjNzwQUXSJ8+fYzu09w+/pBzhrpNs8u/bjS8+rdCkDB73bYFFBfBgEDekhGKUZ4ZPd4mjdd3nG/etI5Mnrkk631bNqsjP85cJGvW4AdnzrNNi3ryztfTpVvrBgY4X7Ucevey923KQra7cYTc03etdO7cudR+U5uDXsXekC+hkcStoSAXnvHCiZ3l8Me/zNO3Kj9g8srV5ZNJOIzUqFpZqlepJFNmZZ7N3m0bloDmyFk9GxrsJ21Jm6p9cYJxBvYCH8YW7LTaIfJpgOfDhg0rAcqJqSn2p7iqQgHnQRIrOsMH4+KsOPOTJMAM7bTLRQufZMe5DWID1NBN65QkO87NXKdvvjHBB5VT6rzESXiFBUDcxK7ktau3CPgAcxCUi76vvAEiKn5r4jUbPWw3ekXtOA/a6cd7laYLanzWDoWu1cW5KM3SNjC2oYnaAbAhSRDdFLdLhOOT2CLBReKepIyXpDnjXGeqE1CRAM7VcbfNNcMizzJ3gttuFItRJag9iWoztLiAJAj3y3ksNwaT8mozkhSve8La4O+oz0OFtXZIAu7wd9Wfzg5Jr/OsWlspdJf5l1fsFNqmlCVVe5xEp84V9OqY9ALOizYjHcYL7oGOgHFWO8eRn2cvkXZNg9l5kjToYK6feCAKaJ4rZpi1aIVsVK+G6xpQdEg8gj8VZQ2ixCraEY79Id7LlaT1sxk2Xbp2JfJ3nqNx48aZ9dRudH2OOBYdhd1vGWN+RmdNvGzH1GyGczarU9ci7EE6VHUEEYVuH16wg+xyZ+Yac4HnzF5dtWZt6qB5kvHGl1MXyDFPZAoGVa7dfys5uEvuzmTur8ZGCMC5sqng1+nftUjJy2Y4O91VTurt7Q+Wh47zqDYDfYRPrELHJn4Xa0hxixMg1eePpgMEHbb33nvLqaeeamgWKWxhnu2RRx4ZmkUjXzYj6Y5zigai0PFGzW3ZOTSSivjI3LO4VOlenycvQ5GSH2V63PySdqxjm/hu2Cadp5lLNM5xsxkK+DdblV3YWataZVm6cv33hZGEzvQgTIllEWfwfdhbvIgdtcMaHUhxsd2E4dVIELeLujyMU1T/3V4rnSMvw75z/Uzvttl5YCf7CzFLGtdZlvFqUnEGHevk1EeNqpgznoPqNWWyYi1geo07/onjoW9bb1RL/pi71ADjm29UR2YvXiFzl6yQRrUzTVbEHctXrpGp85eZjldk6+Z1ZcrMJdK3ZWZ/VauJvs6ejb4hyTmjKsmkPZq73lueA3wefJqwo7JsPGOrFgUBvxWUbAigObJ6zVpZuCrjSzSqXU0+WUfPjoy/tI/88evPecEb8kHVXichPOPCCy80TBxQtTMyltj9oYceMi99NinIuv76601jNUD6VVddZWKKgw46SJKUgn9yMQQ4+BiYsLOY4gY79uypXLTwSYHZXC8gNs6tDWKncS5dX74jx3LO14rb1a4zPpLo1lWDA7jP+pBcwtnXquFCqfgNK2ECC7dudE0EKaW+Vzf6htBx7ie8z7l2TkozN5qufM6XUqrJKImUoiTbcW7PcvXTw0mcK0jHBjRk7F2AHK99f/+HP8udHwSn3x13+S7SoFY22GnTJypg76RYjCp6zX66KKrNoEtAO2mc12oXNXgxmBSizcjnrPYg64z/YxciUaiA7XF2SHp1o+/5WHAGBO3q2LFdhsovrBQSVXuUuYIAEFokyBprxyQ2HSCCAjq1E2FtxsiRI+WWW24xyXs6kV599dWswAJg5PLLL5fXXnvN2EcCkPPOO0/OOOMMz2Pinw8cOFCefPJJozcASQYNGmQAkvIo9qxBOg9INMeRQftvLpe9tV43P/HJb3LtAe1zfk6pfCnawveNs8/8irvoNjm+93p6ZYT3ov+5BvQqyb0oEhYgQS/zndmHJKdyzfwNajN4logl7YSXjqZgbRVMVRDdWSSdT5vh1LUAlVynjiCyO6eHnLO97HnPOE/w3I3mvF7NqjL64h1dP5NE11wS8YYbaPPYPzpHnimOT+821on7zj7netkHgHxqv8b/uj6hVWgU7VGTX3HjjAkTJkj//v1Lfr7ooovMv8wZZHZtEHn22WcNWL7bbruZ5+fQQw+V//znP1KoYncHxtnX2HCEY5BvyVVs+OZZO8gB942JVaiLLUPv8a+dQ4sbs3jloChQpziJ/eVHmZ5EDgv/hb2cq6nFK/elz47eU/wYbA9rRSfht7vUKqFst0Fz5/coD3GGdljzsud946/pvG+7CcOtYKgsmUfymbNiz+76kDto/p8dVxvacF2r/g9+W+o9aXznsuw4Tyo3hc5/6623TAxiN4Thk/HMYZPtXAtxvVLw8i9giS38Xf9W3gRdo+AS+EIuPzdoMRVgOAwIv81daijYm9WrYbrOe7TJ5IOZYw6D2w/TF5UA542qr5XqVdbK6pWZeei/LtgwAMxcYw7tphL0uebc8RHxJ7HnUYBB7lX1Aso1FSW/0qpBDfltbqYwpeo61gfkf2f3lJrVMn5EPnwEzhOUtbis8YyePXuaXNWAAQPk2muvNXkpxj8dc8wxJe+59NJLjT497bTTjC3p27evvPvuu7F1a7kCzgG2tJIZSq+wMz/idJyTJMKBdqNJ9ztfHHoFnaOLOEFst3PFTayTfCXAIeCAMsfplEU9h02BpceJ60hq9yeJI1gHqJh2S5ylWfH7y+wlxhFJWqKujU31mKsbPV+d4IXUcZ5r7ewgUinNbJouLULAkc9X0MJ1FOfVJiNR6RW1w4/kddBZrklTtTuTXTjqeny3ZFPYWeZ2QOBmwwDs6TQEsAdESEJsGkSnjohqM2y7gA2jc9fre9n/5stmlDeq9qBid6PbHZLOsRjoz1HTVsm//zcl1PHj0hzmu4ArDdtgd0xSvIJ/SIKTYATd8OKLL5qiGoBNZeAJIgQWzLM/6aST5JBDDin1d4AQqHOfeeYZ030zZMgQOeusswyI97e//c31mFdeeaV5/8MPP2z85ffee8/MQxw9enS5mz2ozBX4T+heElxxQZNurbODx/9OmOoLnLtR+RIPpQF0IDe++0MWcK4Fy5yPNSDJrknKsBKmAJdEFDEJNhfQhYIRrxgkjM0AYAEcBTC3mWOcoykIton9OC/P2dU71pN/j87Q6a2WylKjWuW82wyOif3nGaeIQ8F+XuwP4uJ79m4i57ybmWuZC3y+67AOsuvWTVMDzZMATNyu+60ze0qbxtkFrVHFbawTgLDue64d23bS63NKffbKvbcoCIr2OPYnTpzRr1+/UHkBt1m4rPvgwYOlvAjry3eOY+uJy9FBCDo9F2iObNXc/R4FBb3tubl0NNo5tLjAtdvnsRHkzfAbeK78dECc8yvIpgUIzkJ3L1GbwXoQ53O9Og4DHUtREsciSeuWb/zmqn6y7XUjSn4GVKfr3P5OZRFnhNW1znnfzpGAZ41Mhnq8PADnbjkrv7nm3EN8MdbLDTRPo9tcr7MsY9I4NoN9cO655xrgY8SIEWbP2UJ+H30IzS5FVAg5CIqyeb4R/r3hhhtMvKNx/vvvv2/2cJJsUPkQLYhFiI+ijr+zRQt38E22alZXvvtroclXb7ERdO2LpIdVcLhV83oyafpC2W2bjcw+xudp27CabNpmM5Fvf5DvZy2XjetVkakL0xs/WB6EvNr31+xWwtiCPWWvoQMosoQVmBgCPEKLbQslb1SUwpRtm9WUb2Zk8jWdWtWTr6YtNP9/7+HbyiYNM34M+y0s3hlF0m4IXJQwnrH//vubl5dgxwHVeaUpBQGcOzsSgs4UzyVRKmo5N9SMvMJQP+n5ogYCWiSA8uW8uYKzuEEPM2HootE5gG7rG4VKS4NLvTaOEddx1s4XDDwBjbOCxY3SXa8hasWv25zzAx6YkPjcoqS6CnN1o7MWGHitKk6zyqgQO87DUJopTRdrh/POWipwCejgnDubpBRnnCdL1U4iNIyQSEEvYnMAq4LuryQ7zr2SXXot9nk+/GGWnPZsNpWpn7x2Ri9p37Ke7zNFQMD3CcvwEgY4T8Jm8H4KhNBzdJyEoTBOw2ZU9I7zMB2SFHH9OWOW7PHoD6GO8/mAnaSKVYFb6Ekm3Tf5OBf2G9uDDcfGc04SUSSbAMApKGSe7FFHHVUy48lN9tlnH/PyEsBuugcBSBCqdx988EHT7eEFnD/99NPyr3/9S/bdd1/zMzOlhg4dKrfddpsB1MuLzdCiQ9sv1s/EAU2a1A1e8axdb/gCNpVv3HEgzpjhmRO7yz8e/9TT/tgFtVxL1HMHLcDF5+K8dA9psbLXPQtqM5Run2IeikX8isBsMBUBOMcWyugMU0DPmz+WVw5vaY6ho33yZTPsNXAD+7GBN+5YTa4Yneli8pL3z+0lLernpuRNonApik1hZED/u0p32E64rK+ZC5iWsKbscxL6FMpiv3a6133+5N+7FVZ3W1Sq9mKBbjiq9qhrrfkLYgv8eQo04nZaB2nS0HnmFDayr53PY9xiX9XrqpvQs9rYEKQDNCpVO8lYiqs4PzowDGiu+lobDnjO0fHK6IMfi27n/3k+uEaAce06t0HzihJn2CMBl1arL0e+VroA6/G9apucKLbPjU2qPAPnzpyVH2iOKCuNG2h+d581xn+2KfCTAkDyNS4wDZsBPTuFUq+//rrZPzqTnGeN55d/Tz75ZFO0y5oRywO0k4PAB0b23HNPkxs/9thj5eabbzbHoGCXYycBPCclfnrNLohl9B1+flJxvp2DYmb5938tlH22bW6Kr777a1HWe7dpUVe++H2+uQ5wFvztHVctk0nTF8lWzerIDzMWS+dm1TZ44Nys1TXD5In9GsqKpYsN/qDPgLLCKWMVthZ9zv5V1qqkO12LUn4FK9ihWY0S0LzbRpVk4jrQ/PheG8vOW64f05DPjvPyMuO8kKQggPM4FLlJUrVzbkATEkfQNGHMw0hUMJukDp1EdEOgjIM4mlHPpYkkAhy6F/zmxasDENT5tec8JRUAkEQE+OXecE9yGSKbNgvRKl8NWAqxszCNwMLZjc6+Zi3DzkavqB3nufQGFYS8lG4EBxMHafz48aYy1p6NmFRgpDNui/Nqk5EwYLbOVKXCOWjix3muJEZn+CW7VKfqeZLqMldh70HbxzkIVoN0xMQFzqPaDJ2hyGeD2IWkbUY+k0GF2HHuJ6yPF+iQBi27m+STYQXJV0ILP4hEE2sMDRWMGI888oiMGTPGJDbp9KYA0w84zyUc84033jAd6RRC0CGCbrzjjjs8P0OBkvMZ5DrLyxxDnnH8IgU37FmDem/jsM4E/ZyCAvgATirfJIAO20b13Cyb2nbhslWycM4MV/sTp1A3yGd1LAiF0sRAft3qQW2Gjr0CHLETXkGFIpXMtUzOOjf7BPtjJ8hI3JZFnGGD/RT6bd91oex+X4a1zCk7bd4oL6B5VJuSC7DIVzzB6//en+r6nnt2EqPTdKwTr7JO2rPXwsQgxTgjvOizi/0NU3QOAIs9VruKTUyiyNYv3rBHPOk8c6/vFIWRS0Wfb3Qhuhs9G2Zmu9qFMLoCNhD8fvQyLBFhAFw3m0F+kfge/4UOeewtIAj5Me4zz7dz/Wwg3a3r3O/7FnJuykv/fnrJDiUMJ8rGYY8EzBUnFjpwbscKXmsw5p+lx5p4daOTP2at8MfxP8iv6VppMUZY0f1bVrnKuDbj/vvvN/9qMa7K448/LieccIL5f+ILHdvB80gR8H333VfyXp4baN4pytWifgp80+4uTEo0Z4HeUj0J1hFHB3sD53Xl48kZtpwum9SXR0b9mvXezq3qycMjp8iU5pmmA/yZ7RbPlFvf/1F6t2tsgPPqxcbpEjnh7XlyTI+W0tcRQ7DmsB/wUuZS7Ae2V8dfaIwAnmQ/+9DpF2XDEOjYGY/wzYzF5uc9t2kiQ77PFKhtUkekR9XfZeLEBSV2Il+6Ps3zrK3AeEZBAedKkUsCLihFrp+ESTQlce6wAREOG8oVGkFnsi6XRElkaWFA0ABHH6gggY0dmCQFLPDQ4ajz4EFnEyVp6Vbxq9dpd6zoNee74jcfXYV8J/azdqppN7rSumsgpMFQnOcu3x3nSYN7TmFt2H84lqwbxSY6G1HnTWpgxPqFqcZ2S7KwfsUZ58lIUH1sBzQEZFEq5OKCGkoFxfOYK9k1a+Fy2e7mTwIfe/vNGsrTJ/bwfQ/OvtIT6xzlpEWfC9W5UW0GdgFbzbW6jRiJK0FsBkVI+vtCm40eRZJKbh3y8Kfy47rgIKg8tmctaSLzZP78KokUcWmxXz7AbNt/yIc4K4TVZrRp08YUkBx55JGxz3H33XebLnNmEALI8N2gYN95Z28AiyTX7bffbt4D6EoX/CuvvJLo+Iq0RKnv2XcKbtjixvQRVoLsRWWB8qK5Tbrj3CmX/3e8HLzxYlf7Ewc4z9WBo3bPLQbivDoLMozNUMpt3sNzEcentel5T3tnjoy8qK+xQdhM7hkgFT6iJsjUByyLOKN5o3oy9NxesvvdY0v97aPJcw0w8Paxm5VQE9tAAcmdiQOSoZkNA4b9Pnep7Hvf+DIFzRHdU3OXrJThP8x2Le7q3bZRyWxgkqPce9ZRE17KRJBPCVvQU4wzwgt7OWwjhgKNNCe0b9++5B7FAc4/+mm27LRFE89joPeIZewRT17CMeKMFtR9TjE5+pXzhdGzfqObnGKzUNKpSUEfoFOQ/ImXzdDuT4251Pbg9ygdNzqeZ5xO4nM/znxfGzRXeemzaXLYdq2kvOam3ABjm/1JmzCUTYq9TZG5swnDmf/IF2tWHNF94QWaI3VqZKfKne+9bI/NS54pu5ANXasU+Oxf++9Big6c61hWHedxbUaQfUDu/d577zUvLyHOeeedd6S8ic0iiJ7UQrewNsVPbJvQvkU9efTjDFjeeeMGppN82crVZn4y8c6yqd/L4hVrZNMOgOaZ5sRurRvIz7OXyLG9MoWrUxckA+hXFHl2wp/mNeHynaV29Sq+zKU6/kK70bV4TmMEnv0Zi4vruyEIJrRp3eqmGAXpt+V60Bx567y+stwav0XBFcL+IRcB9pAWbXuaI2iXVmA8o2CAc8BjHGEMIw5HEoncoDNubXpeur6jnjtMckkTO1xfrgAn7txA3cQYbqXgDRLgeFHr5gM0x9mExgYqrlyzsoKKV8WvTaGFaIBy8rZV5dFvVpVymJNO5uSjItcOTsPMRg8LZFSEjnM/A2PPnUV03iT7lcBIO4AUSA+TSCAZi1REapOykCD63yugiXKuqAGQAvfYhFz06APGiiz46LPAx54woJ/Uq1k1UEIKGjRAChJGaYhdiBXVZujoCZJbSdmFsDYDW0rRDM+p3vO06XkLveN84u/z5binvgj1Geyoc6QIYnezRAG8bDuettjzlfMhzkAnDZsBcE4HO13n+OMjR440dIgkq3ff3Z214q677pJTTz3VUP6x7oDnJ554ojz22GNSyEIHG34mvpDSgzuF7xM0lvASt+Pqc8e/6F8S0X4sUEl3nDtl6JTFMujQHVz3UlRaXf2s23lZT555EnkU8rrZPfu8QW0GwCaxFQkHbFrcZ9M+z+zFK8zPrBEvihywmZog4/twnTo3l5cmR73ijKA2I4g+8wOhVfZ7+hc5rO0Ueenn9ed864zu0qZJcp0BQcGwzjd+5Pq3x/7RWXpaMznzIVr02+cO96JEZUSxZwNz7xUYoYiW+6zd6NixoDTS+aRbLMYZkqqPzz7CP4TZD8AcXzUpPX7K0xMNc5SbLtdYhi5q5zxzN4lTDIVQQI4QOwFmh9WzdjzgJ1wjzxb61WahDHL9XjaD35Hzo2GGwiqn7VE6bl7KOicfjyv5+yO715BThq4fA/Z/b00KDZzHyU0lGWe4AcZeOS7OyfrzwscjZtWEP/6LAsOq//LZSBFVuMajn8+AFW7iXAu39frH9u4jPdH/9lgVnlHsBWsFSwN2RNfLL9eW7wJdpxRtRvS9BaMsxTfkK/AX7Xuc5Ig/265A1T594XKZuXC5bNywpjSoVU2++XOhtKmd8bmJdzpuXE2++muJbNEio08b16luZqJXWbfFJkxfJQ1rV5N5S/zH/2xo0uOmzPP/9VX9pLKPj2vn2bXgiHgT3wCs66nJ6YxLLUphCc/eXwsyvsJ2revLiB/Xg+afXtZXqlSubPA/XmCQPMOffvqpeZ51hAw+ltrUqKwl+aZqX1yB8YyCAM5JGqFMmEEH5UVSkmvGrT1vJAo9r1OCBkR2gANNStRO6qBBj84OZG3DJJJyAecKgGh1bFKgOZX8ALjQNjqDziTFr+KXfdOj6Rp5VNKVsgZHvGajO7vRgwLB5XHGedBzuT2nznmTWoSAs0xgRBGCHRj5XS9BPOcozsXJLUH0TK5qXi0UcQtowkrU7g32C7qZvQGrhl+yK2lqdreEFAF9EpTzbmInraKA5twvAlAALp63shAtQENfkhS1OwvdqBb1/ysqVfvi5atkh1tHh/qMPa82SBFXUP1ZFkmmJP2eKNRaSdsM9vcVV1xhZqfvt99+5neAuQCRt956qydwTofya6+9VlJIBsh++eWXG5+iUMTZCaUji7SDzU/iJrjcfIfxv86Trq3qGOCedQc89gsy0+g4/+CcHrLrPRNKfq5awx3oi0vV7hz5BBABJT00135jQRQ4t7vw/J43ElMAIoCacW26LQ1rVZN5S90TiFw7sSMv1WHYVHxAZSRSEEbvbxo24/M/FsixT2Y6W3KJDZrft0tl+fmr8TLPoh+PC/jmsil+3X1fXLGTb0IyLeF+9L7LvSjRC0ji3lPowkupOgFGKMaHSYF1VPuFf5VGkips10gxzgguTpAjV/FUkHF/SXQZOu2RjrrwmmfuJlEBfPY5cQL7GyF+iqKv7NyL1/4lpsLf5jopKrb9nFxMJl65KXwU/BnuQxA2EmWdsynabdBchb9NvGzHREY3+OWmnDbDBtbTBM3dhO+K78RLgWH8P3Kq7EfuF+tHMVuSCf8kZcbi1TLTo/szCGgedL24VxRV8dKiAy26It5B7FybvY/yXaDrlKLNiJbn0PxK9+7dzT11SpLAuX0smiW2bl5XJvw2z8w5h659+Jc/S5cas0qKubb7/Uf57Lf5cnDX9bHPDm0bG8a4TRpUlz/mr5CDu7SUxz/5LZHrq2jScR0L1fjLdirFSOFXcERjKDbovNHBWSOLUj47zWtVq2IYrJCW9WvIF38sKPn7qIt6S/V1eTBbtEGPnBgxJbkBbS7BrmrznjKXxGEHTZOqfVEFxjMKAjhnE7BJwnZdxwkMdHY2CZyo9LxRElt+M2zDSNBEliagw8xPt8+BuJ3HDkr0vUlQrJLMJOFkU2flQ+yKXxQVycwMxcT8Uu9Nmp433x3nfuKsklNaQhsI9utGr8gd57nO5azGJujXwIhkCtdr03Q5DQq6CB1Y6BXa5UW8ghK/ebZJnysIywrgEi+v52byzMWy7z3BnezOG9eXF0/b3vc9BO0kpEyy2EpIxe1C8RNNchE04OwFtRnakYntpLjALQDNh2hXNFWhPN967V5dIppkjdolUtZFVVG7Bb3k5t2byuaNqpaA5kGKuGz9yTm9EktlBZzne+6gc55t0jYDv5iX83hBQVstJOMYL7/8shx++OFSaMK+wr/TTucgVGJxE1zs7Uu7rJGbv1i/rsc+/qk8tGs1c/4gbCdJd5wDMn+3juVB5ao3vpNbDu2Y87NhxEnJyzON7SHZTnGs397VbnU7ceymqxTMIX6gEMKraz+qjL6kbwlo4jfT1tZhdkceyVOuj+tXEB0dpvsql83IZQte/eIv+b+3MkCWM6H/1Ng/5Jah3h11Z324RoaftZ0sWThPZsyYYWwtgK/6+fizYfWLm01ZtWatdBvobTMu3LWtnNS7tZSFcL3PZC9fiYy+OPd8WydVJ0wd3EuK1rn/jGRDJ7KWdnFCErFSWOC8GGdEk1yAN7Eyeg177DfuL6wtefWM7eXgB8a5HsMe94dvjF4JKlEKsXg/eQD0BE0f48aNi1VQhXjpNtaTziueGRpbnHvcCzj3y00B7AKas04ASHH8JuescwR2HrtQKonRQ37d6HwftR3qtwWNM+KC5n7AMMUUxHk0JsFMQJGczdaH7UuLfjasXDZqeeqguZsQv7jl2iiCIT9BTtpuWCnLkWBFmxF+vZThFVvgBR4lDZzburhnm0Yy4Ze5ssfWTaR5lSUy/uelcupx64u5GOF3w/+ynR7GgNw85Efp07aB/PfzmVJ53aiGonhLz0EZn3a71g3k6RO6BdL3c737OYtSAYSxV4w5Wbxi/bPN/69e5668dWZP04keBNsgTqDQhRe/11GxWpxms5aEHRWbZsf5kgqMZxSE58INT2MWopdRwkHBkcMxIWGV1DxXv+SSzvJTUNhrhm2Yc/mtGeejOw8nLCo45NVxrtWv+vskHgytzqNbg+7HsqJ30A5QuvNJ6slbH7peq7MyOOoaFDI4wncK242+oXWc+wnrYXcioXcweMzF1G4UezY6FVp++559d80118gzzzxjjkHi+YQTTpArr7zS994yM+qee+4xhpbimX/9619y3HHHlfydgHvgwIHy5JNPGn3Bvh80aJDsvffesc9dluKm/7Vj2GuebVQJA2rYtiAXy0q3G4bLEsv5yiVDL+gjrRvVCsR4QoLDOSM87AiQoKLJLPY6MxHZ7ySWsIN+zh7JZ4oLoP3BLvjR2KcpJCZxUv1YUJxdIvYrSZuRtIS1QX7dgm4CjSEzANnzYXSFm/50Syw5u9HzSdWeTxvk1XEe1lfiMyQ0Vei6JpnMs4l92GWXXeSSSy4xuhEA6MMPP5SnnnrKzDBXwX4AkGM3kLFjx5r7gm/Lv9gK1ubSSy+VQhJNnCtYHdT3T6JLsE390vuENbSLcPyE+x6XLl79dqUSBmSWj74tec8bX/6VOHBuAyRayAtrCAVIQXxWnnl0B7YCm+VWrAl4RCEAnT1uXZ5lJc6OPJIegOisPcVAgEIKsvC82aCPvd8UHHGTi17+Vt7/fpZnQv+4XpvIYd1aSq9bPva8zv73ZTrVnz2hq+zUuXZJwRI2z6Yfdyv4zBVvPDNuqgx6f7Lv+8uqy1zlrwXLZOzM0s/nxbu19R11k0tnsGd5Kd2zxk/cf+yb+v9x5hiGLd6KYjOK4g9yaBEsLBe5RgiFBUs6tKxf6nfcb+I2fOmo4/7C6nS72FbBoCQKqtw+DzBPkSrNJV720S1W8ctNUShNjolcBn5NFP/QBsvdZp2f/0lVGXpKa2OLnIVSPOtJgMUaO7BG7Dk6GImLwsQZSYPAbsL+wBZzL/AzsH06w5X7oPSzvLj+ssgjeMUyaYPmQXJt2GBe3GO1//jWQW1wklK0GcGF5xI9iW+fqzA07ggo57Hs579Hm4Zyz/DJZuzW1g0ry1tTqkiduuuLhHu1bWz8nl9mLzEU7ZnfNZKp85ZK266ZAqwxP89J5No2BPns9/my7boudOSds3uVrKtTdrur2G1eUaV6lUqyZq3Iav6zTjZuUEOmzs9USzxyTCdp07hWpLwSv9PmOy1O01iNfHJYhuC0O87rVtA4oyCA87QcJrdklwY4fg55VPEKiAhwSNaxyXPNsA0qfgGLdtMr/WPU87kB52nMMycg43o5VhDqrLREaR7twOqzATvLdgOznebut4yRLwb0TayzsJA6zuN0owNe8Aw4aTkr0ozzqMJa6GxEnYtJNwpGjyDy+OOPNwk2AiYKXnC4nesHmH3//fcbgJtAdMKECWaOLMHWeeed53pe3j9gwAB5+OGHDfBIhwCzaEnUHXDAAeY9gN8A4ryHhPZ7770nBx98sIwePdp0MUQ9d5oSZG85gxL2KnoYIC5ut4HbuYIkkHSeObYgFzVvWGr276/ZLee6qP3zYjwJ0t0WVmybQREXex/wwE4usfe1C0+TS05KxaQK3MJeOyATc+Apcgja0eNGtaiASFibUShU7WEBc6puJw7YKes8UZ85W3+yb9260RXcAYDKF316XLsQ5Xx28pWCkrD+Hbq7f//1HbMXXXSR+Rcb9MQTT8jzzz9vbMYxxxxj1hhf6IYbbpAzzjij5DP63KrwrGJHSIqi0/bdd195+umnS+aRFoKg+9C9uRg+0uoMydy37CQZwW/a40Dsz6N36LbH91Aq4U8HNJPuA9cnfH6fs0RaN67tCXKEfYb1s/g13IMghbxqM/A1AZ95zrFb/I7Pqr3g2HwfbEqvXr0KmhbOTnrAAEZ8hh1UIB3/WkEW7fJmvXWONuvA/bdtRpeBo7LO0bFlPXnupIzPZosfaG7LMU+sp3offEJX6bPNNiYBwvprwScAnQIe7B/nfiBhNOjTVTJl+Jc5zzf03F7SvH58auM4smbtWtnzHve58CfskEwHvNI986I4iX2s/j9FTOhP7rkmvcIASWFtUBSbsaGKfQ/Q306Qg+dTGxSCjhqMa0uIC4actKXRH/hDFAtFAWTDFPtScEazCfvTLraNC5w7wW+7qCvX+EQtHsiVm9JjUjjOtSc5DtKt69yvUAofVXU8ejSqj4r/hd6wv0/QOMNpM9IAzZ2xhW37APqVfpYX94bYTm1KnCKiNEDz17/8K+d7khZn0bDaXtsG2yNA0s6DFW1GcNFCEXzXfBTkOu2KPnNt666Wn2YukRr1WsphO2wjd04cJV9PWyhdW2cKS2tXr2K60kf+OEs2a7Kp+V3dGlWl+6YNZdmqTA7om2kL5dBureTlidN8zw3l9IpV6TAVllfZ996xpX5XvUpl2XnLsmFMLEr6Umld/FOtSmVZtu55aNuklvw8e6n5/+sP2Ep6bdYo53GCxtnEu7a/4TYqVu0q/+88ZtozzutU0DijIIDztMQODNggOBx0PCQ9S90+nzOIUPouNlAQOsY459LNSoBD8thvdmCUwMZ2xJNKTJOU0XnvzF/PZxLaFhQN+wOHxw7WalZzvx5d17idhYXccR6mQlbnNbGO7MFRo0aFqnwqDx3nSX4H9g86iBdJ1FdeeUXuuOMOo5/o2mMP0vFN557uR4DsAw88sGT2LAD8c889Z8BwLwG8OP300+WII44wP3Ov6FIACFfgnPfQhQ7YgZx55pkydOhQue222wygHvXcZS12IKHJGJ3vlNa5/ESZTnJR8y5dsVq63lC6myHOPHPWgESLAsBe9i9pqnY3m8Fz5EwuAaJDEUtCBX0B+AbIkgSlYlTh2uiOxBGFljIIpXNQqsUgNiOftsFvfcMC5l6JJb5rUsUPXt3o0PkTPCDsdy9wp6J0nGNrwyZg+/Xr57u3WNPHH3/c9xgjRqwHWhG61AnUCllYp6jsS0kA514U40HvXVyqdvYqiVeNRXTUQV1HR+3ud40uZU9y0er6iV4zAEKQQl7bZmAj7RnSPOf2/HCui+QBsUMSs2X95Our+pXMNfz89/klCcioQoxG1z0vBVL5bnTPA5BjB4mLuGesA4CDFuitXLVKet6anZiD/s+tk8Gpvydc1ld6DCoNnjjlaAtEV2lRr5Yc1KG+rJ61QJYumSZfzxb5fHb47/708V2l6yalO2nLQrp4jBxJExzhPiqAhtCNroVgCiRp/ASQ5Gc3wya/otiMopS2AcS8FHYC3oZpiEjClgDWo/vw5aPex6DFvjpekCIv4j77fHHjBTu/pKyDPAde8+Gdn1V75JWbUmp5dCuF41F9eFueOr6bHPfkRM+ucx3l4SyU4hnXQil8U+yVsm7xjAfxI5WtjNjIya4SJM6g6SOfetjLv7HpZ7ku7UYnRicGtEdapKGrgoLmXP+Vb2bTWd9y8DaST+G74+NgA7jn2nTBehGf8rPNCJMUi54tRZsRXIifgnaRJ03VjnA88jy/TZkimzSsIQtqNJNqVavIDu0ayceTZ2f5rTtv2URG/jhbjtshA5wj/bdqKsO+ny7bNRX5bJZI4zq5Y/YiaB5MVqxeI0Md7FBFqRhCowhFuA1rV5PZizMFfVs3qyOTZiw2///P3drJgZ29CwHj5pXcRsXqbHSKy3XUocYV5NDSBs5rV9A4o0ID52qUtKOZjZRUx7ff+WxqKDZsEPqusOIWsOCQ8z2VIiaJ82lgY1exJgWac71U4VKBH7YDKClRQEkp7XFAw4hbZ6GCdUE7C8tLx3mQeU10TvB8sQed3egobALFsHM4ysuM86jCcens3meffQzN0/vvv29mpb377rtZugp6vIceesgEzgTiPOsUKNgUuk5B9zm7sAisALwJuAjGvN7DseOcu6yFZDN7hMIcwLQgyZiokgvUIPmNrsvFdPLO13/JhS9+Hfi8rRrUlOEX9fV9j3YZUqSUq8vda25gWFH9l8tm2MklbBbOFp0hBH7a6YJ+trvw8iE8G6wZPgP7JslOxqA2Q7tp8sHe4Xb87jd9JCt0KFNA8QMb0voezm50AgWeNe6d0hzaRVxJ3ss0A48g3YU8LxWVDitpQX9EpUWMS6mIHsM3EsneK29/PV3279QitZm0KiRaAUDY++gzpx7dslkd+XFdgI8sWLpS6lsz2Gx9FXaeMnNqEfxrv9grl82wn3PuJT4I9pzrwcZj721a3KSfS5tK/OjHP/Occx4XSFU7yP2CwYH1IAGBL83fa9SuKz1vzaZ6HP/PXub6nHNunQCB6mf+nbFwuez2n9JdMX7y18IV8sDYmZG/5yundjd7rVDEC0AZe0mfvF4H95eXPcdQQXTARPa8PdbJfi6idJwXbUY8G4A+1fEmYTu+o4All+25pQwa8mPJzzCDUWgax5/KBXoHGS8YFzjXAlFiUIqKEWKUID5artwU/h/3iN9j85IqrIICOVfXuZvwfJPrUsYJ/FQKhnm+2VeaH+Hl9v35DP4scRzfJxc1vx1nrFy1WrrcmK3rPr1kh8zfQs5GDyNBYkl79rmziAj7pyMttIgorl0PCpojnV2KqvbukHzTVZhcl910wfqiz1krckfoBPaOPQIkCT+oaDPSkSSBc90f+MUUmMLA1G/ln/LhD7Nkt202kr6bN5FXP/9Tzu7XruQzO2/ZVO4YNtmMA6QDHdlr2+Zyy/s/yaGbrZHPZlWWz36bn8j1FaUoFZmenU5zxmT+OifTXd6pVT35atpC8/8n9W4tx++wSV6xDZsh2NlcQnG2xuLkxrEXSdv+xRU4zqjwVO04hZ988olJtJC4SZMCSIMIBWMBAHLRTUUVZyc41E0EOXReAFomeR4Muxr3pEBz7fDmeoNQ2qQhzrnqcQsq3Cp+FRDx6iwsrx3nfufh+9uVT9qNrlTZYedwlNcZ51ENDQEx3eb2jHHk8ssvN3uVpIk63FDoQqnrJXvttZc88sgjctBBBxn9RxKbn5Uum2eP9wCA77zzzuZ+DRs2zHTA2/s1yrnTlCB7OQNUZIBjgP80R0B4BUA8DwSz6OfOnTubzrmkqNnvObKz7NHeP4gnCUFCiqQRCalca5BEx7lNF6jHDHK/+BzBPwVndNKgG9AZWmDF8ZSmVysm0xD2DUAMa4ZdSNtn8LIZfHc7WZvWbHSnbdj1rjEyc1E4Sugvr9gp5z3Olw1ifbhn+BacU6mG6dKhUysX1XChFFQ5RX3LInAeTeLsvTgJLooyKR5Enzx/dFs5cvB6AOTil74ODJxH7TjH1yZQ1jEYbvv1rbN7Z9mfnjd9mNV1bgPnQUX9PZhF8G38/KcwNoP15PsAMCt7DJ/Tjm3iCnxOpcXFXqTRhZWW8L3R+SQ4AFkovMZ/5rt9NOFLGTAmO2b4+spdXOMMZ3ehExhoVq+G+d2i5auk962jU/s+tatVlg/P7yk1U2YECCu3Dp3i+vt7D9+2JIlcFmIXEyL2HEMKCvXvCiSFtUEVOaGVD6p27oEWEPN8hrUrUWzJMT1aZAHnezz6g9zdJ56f7mdP7HF/fs0mSXSck9BlPdnLNg18kM/a+s62GcpkiH8Hi2CasfvyVas9u869hOvBLvFSHxX9jo+KbeP5VBCd76DjHhFikjCxz9/uHyc/zVxfFOdnM5KOM6L4/HYRkd2Nzh6hGMLZjZ4EaP7hOd3KZA583PwTa8te4cVIJfSTjgCx10vtRdQOwKLNCC5hR0AlNeNc813oCs137br1Srns1W/Nc9hn8yZyzVvfy7wlK01XLNKuaW1p1bCmjPhhluzbMZObatmgpmzbsq6sXDPP/Pzpb/PkqJ6byHPj/0jkOotSlIokNatWllVr1kqbJrVlyqwl5nfbta4vn/2eYT48uEtzuXDXtmWKbTibS9AR5FrJh+FvcD5lLcFWJBEvL67AcUZBAOdpCY4ojgMJFifFVBqiQQQOO8EAQEUS1FB+51IqKh4C6GTDdkwHcXpxxEj6JUGz6qSaKqsZmBqIaDWyXyDiVlGcKzDy6yy0q6RxmvT3aVT85hu04Ds5z6Pd6Dob3Z7DAdWUcw5H0OusKB3nKgTPfsUbL7zwgjz77LMyePBgkwxg/15wwQUmMc18Wje56qqrTLczuog9AHDLe2+++eaS73PXXXeZueeA4qw94Dnzyx977LFY5y5L0Q5vhOKlNEFzr25ATT4BXic9z3z0JTtLk7rVAwMX2MAg+9c5czCs2N3TSNBnxkmLjoOH2DS96A1sOolL7cLSWbesbRL6jXNgvzkuz0O+KeI1+acsKHT66N5yA5aSsBlqGzrfMFLClnEFAczzra/tJBPXhk3hhQ+o84LZZ+wh9qpNcxi2Gz2fHeea3LTPl8tmFCUZiQJ26PxbAFCeYwppN6oTfa+E7TjnvQTFOlcc3Ubne1BZuGyV1FtH425T34YB63U0CoVjXkWiQW2GFiQzzgaGHgUW9TP6DGvHNraCjj6dCaq2Ik6xzEW7tZPbh7kDrkkJhWPoJqjZoXFHsIG/Lq0uA8bMyHrvXb1XGfYg2w66Jf3pLiTWcLMZzLVUQGD8r/PkpGdyzybPJZvUWSsPH76VrFiWmWU7+uOPS7qmw/r5aQgJrifHlk4Eb9WsjqEvLSTxmmPIM6XjMXgm6EBkjXOta9FmRBPWlTwLuipOriWsLQE4xCd1iuYUkqZqZ39QbItfkWvcX9zifz5LFzWMjCR0g34X/d74ctgE9B96nd/lg8nQzgl1u3Fk4K5zN7F9VNZAKVb5Hpqj4sX9oKA4TCzrdk2at8qVm0oizoibd7K70Z2z0bnv2l2ts779fHEv0PyCjqulVvWqBQuah8k/UdxjF2S4de/bRVdBi8KLNiMdYf0p8owr2CUY8hCKj1RH9GjTSJasWCXf/rlQtm1VX7ZpUU8+mDRTDunWyvydZ3PfbZvLu99MLwHOkb06bCSvjp0vB3dtIa9+/pdUq1Lx6JaLUpSkQPNm9aqXgOa9NmsoY3/JFJ303byRXLv/1qGPm3auTEdBIX369ClhLSFvTrwMcG43l0TJcS2qwLmpCgmcaxKehBGGAWc0H6IGkAQFVbppgjU8VJyHecU4VZwvya4KrUQl6UXCj4eJh8iPSiqXcL0ENDi/Qaim0hKcSZ07D6iWj8S3W2chgRFJVYI7DaT9KN3LS8e533U753DY3egkW8N0o+cbOE97n7Av/QzNJZdcYjq/jzzySPMzexcQceDAgZ7gNToBAPzBBx80CVmKF6BcJ0hX6j3+fe2110zFKveBBB3nYV/GOXdZCHuCDm/2Eh3eANdJzuwO2r1hJ5/QzX7Jp7Cg+Zv/2CwnaE5SFdAG8FeT70EkTiLM7hoMw0yiBQbYBy9adI6FA8cLvcFe1XmBOhNUbRN6I8qzCsiCfWLfU71fFol9LYQjWepkQdHOEE106b6OazMOfyU89W4YwLwQirdU2Cd2MYZ2o2vAoN3oOl8413rm2wYh9t7OZTOKkoyEBTt0/q3GAkq1HYeWMUzHOcl3fFz7/Ox1P1v4/TW7yTbXDCv5ucfAESVd55o8z2VL7WIBCmM1OPfqTAxqM/je6GYCfGxErj3P33mhx7VYBv2OneGcait4hSkIPqVPmxLgfNB7P8ple20pSQp2G0CA5CdAqMqlr34rb301vRQAwn1WO8hnWb+zRmbb7y8G9A1sM3q2aVgCEPD+Cb/Nl0FDJpfM6XOT5vWqy00HbSPdNmkgVSpn7t+IESOkccMGUrt2S2NP3fx8TcywR5Ioyg4qS1eulgMfnOD6t5dP7S6FLM74iedh7NixJePoEHuOoRs9ddFmhBcdnaCJxji039gSntsgQkEEuSyAZZHJiRbuuelkBWAAnQEqc/lrUTvO0S3Ms8Y+cR471gzyWc4JkyP5AR1RiBA7YOeIe5SNpKwkSHNFLopV4gCNI/nOjEcjBlLb5Vcw7AeaB2G9SirOSMrn5zjajU5MyzXqrG98Dp4pr1nfXqD5g0d1lGW/ZFgQCxU0jxpn8J3UD9L1cs6SZy+pDfbbS0WbUZhU7apHyYHgM5I7sPVx9aqVpe8WTWT4pFkGON+rQzN579sZJcA5sk/H5nLog+MM8xBFlOZ327aQ24ZOlhNaNzDAOZ8JIhD1rEiGeb4oRSloqVWtsqxcvVbq16oq0+ZnsL+ebRqUgOZdNq4v9x/ZKfRxtVAubbxBfUfsit1cgk+msRq+J/Gz3Y1eOyBuV5FtRkEA50kmU5VmlY1HVfCYMWPykrDVpAwStio0ihAo09VOcgWDmSSdrF19SsDGi8CR72hTSWmXQ5Aqd+4LiUQSJAAC+UyU2ELHDfuDoASqtbLqeiBApauEjhwCQHvN06DNyidoEUbhe3WjkwTM1Y1eUana/QyR8/sG7ULjedNEwvPPPy/7779/qWORdGDMA4by5ZdflsMPPzyRc6chbntZk4cE0EovmOQMKT+x14ICBZJPOCHoTq/nbsWqNdLpug9Cneelw5pLJZ++YC0a4xps4CKoxEmEqf4KA5qz57EL3Cu6CIM+Y+xV9rPS+SlNLwkU9oHOC8RGBSny0tEhsCmkMVoliOCwsn95/rCRzuSsH4NJFJvhlUxKGjAPWlSVlAS1C27d6JqIIwFhd6N70Vflk6pdz2Wvf0Wmw0pa4vg/YTpD1McE3LLn33oB369MnJaVyPKSoPYWH4pkO0nRIOf3W5/pC5ZJ8/o1AxVVaQEUvr6C9faxnZ8NajM0duB7AJqHjR2cxTKsD7GMMpcoEIGtwA4F3Sd0LCcFnDuZuLgmLwCk/1ZN5d51CRniTLsbueP1H2Zf4z51DfjG99P7EdRmsA4A6S9FAJOd8YaXn889QNfa3ehJscd4Xdf2N3/s+rf7d8kvu0wSov4SfgvCupL00jmGrKWC6Mq0EMdmjBw5Um655RYz8om9+uqrr5oxUPr8X3nllfLOO++Y7kbOt/vuu8tNN91k9qcK13fuuefKm2++aa7n0EMPNaxXhWjHtMscf549ynrHnZUdJCZRP56CPthCuH+T/t02q8j2/E+qyle7Ri/otn19ngvAF0AY8klBx+dFiRe0CAoQD988DOugbTPQ6/jqvPSY6BSOyd5n7VSvR6Wo9hO7y1xB8qhd527CvtNufAoZEC0Yxn5pB7FbwXBQ0NxNkowz0sw78V31u2t3NfeftaF4XrvmDnnhT9fPP3hUJ9lhswYy4pf1xQOFCJon1bjhnCWv3fvoY5qj9O9aeGX7WcU4Iz2q9qj5KewtOs9mtyX/4Twe/uJTY36Xc/q3M8D5f4ZPzmKT2rJZXdm0cS0Drh/QOZP7aNmwlmzdYK38MW+ptGpQU6bNXybn9Gsr94z42feaiqB5UTYE4dkhfwtoPmfxyhJ69vG/ZhjdOreqJ08f3yXSsW22lzTFK3dFnA2uyAu7iu7XwnPsas11LC/YCPJjXnapItuMggDOkxKSnkqzynxLNSD8m9acUjYWTgddAoCgOLppz60GFOF8ODaA9Ek6pjZVk53M0jk6SiVldznwPg1QdI5iIdHfOgMRKvXpRIkrq9esLemwCCMkiwhQuXesm4pXxa/OwInTWVgoHed+EqYbnVe+gfN8ULVrUOMmBxxwgJkrThBNooxnitnkJ510Usl7BgwYYCien3rqKfMzyVioPHv16mX0I+/nGXjyySdLPkPHitJC8+8111xjvu+ll14a6txlKSRhSK6zd0g0qQ7KJ3DOeVhvnm868v0AWOZM9RqUneTOJXT/OSuK/boMozCQREmEedmMXMKzDdAC+O1XYBA2gaI0vSTOCCQBQ9Q+KZ2jcwY9iWb2TZKjTsIIuo57RyKMgr9c/kquLhEvm8HfOt/4UejrSyJ55NcJXgi6Gn/KDhi0Gx1/y0lfpd3o+aZqd54rl80oSjIS1I7YHYLO8VB6DMZs7HjL+gTtgNe+DQScB9HNOqKEDj4nTW2Qz2NjbHBm59tGlXSd+30enQtYD0BBEs+pv5yfDWoziB2w6+xx4qu4PpjNXMI9splLbCACW+GXFEhS2BMA+HxXm4lrxeo10vWGbB9h/OU7SR0HrayKEzSHnl2BBP1urKPGaaxF0nGG3THhdU+dfr5zhred4HeLJ+OIl+1799QO8utPP0h5E7UJuta6t3WOoT2WBBtGQSwAE75OFOE5J27F7z/kkEOy/sZx0QGMh+I9xBvnn3++/O1vf5MJE9Z3+B9zzDEGdH///ffNNTIW6rTTTjNjoApNeCbxUQGTWWvtOk/TlqgvyHPJrFo/Pz5ObKOFWDz3xITEUOgfu2gn6XiBZ509wrmJUWBMDPp5L5vBHqKwgfhH1wtQUPU6uRaKHbTRA72er7xB1K5zL+aRXAXDfLd/vJU9juW4XpvI5RELvKLGGfnOO9nd1eQodNb3rg9959lpvmO7RiXXzzUXKmieVv6J50T3Esfn+VcQXYvZsL3oQMBZO1eZVLEV4rU/GCcI0yGCL41vYAtsh7AglmeJOuNcGQ3xFW12W7fi2P5bbyRXvvGd/DJ7iWzWpLZssVEdGTZpphzUZX1x1P6dWshrX/xZApxzT3o3XyuvfzldjurZWm4b+pP86MM65OzEXbqybBpqilKUtKVBjUomNmN8gYLmXTdZP9O82yb15anju0Y+fr6A8yC5K/SAYn9qV+etYy0hnsDnUtYSXnaBYkXOTVUI4BznDEeTG8l8O2hplFowTeCc4xJw4KBpwEGAmlYXJt+TBAgvHAmA4KScUk12qNH1S2Y5uxx4kLQahcAI512DFBwu1qgs6W/tQATQj86TsOJWTdzp+hGhgiIbpHF2lfhV/NqvqN3ohUCTG1b8utF1th9ALwBl2jMT80HVTlJKK8vd5O677zZJqbPOOss8+zx/p59+uvzf//1fyXsITFgf+7pvu+02E1gDDPXv319Gjx5t9IcKzyydIugVDOS+++4rTz/9dFYnQJBzl4Wwrymq4PtB+efUMVEDkyjXoeuv1b9eMmXWYtnn7k9CHT8XeIGeJZAi2LW7DMOKW2dgEjbDKTy3dIVQSAXLQVJiO3raRWzPC0QUZGd/4zOgV5y06PkUBZ2wmxT8RXGYc9mMpStWS9+7xoc+bpKJo3zaoCQANj/6Kn7mfvFvlLE1SdmgXDajKMlILrDDrUPQ7Ri8L9eYjSjXoPO/SXoCWtnJduf5c0nz+jVk+oL13fUPj/pFTu27maft4ZlAt6LHib/cnnG1K2Fshs76TjN28AIiuJckBQBuNZZJ4znHPukcW2JITYBOnbdU9vjPmKz3+sUazthE35sLZLFHbyURZyDqPwS9X84Z3jA2sKfogFVGAE3MhGEECMqw8sLJ20nNKsvzVgCVpPgxnjiZFtAJ+Pj49gCz0D7vvffest9++8luu+0W6Hz77LOPebkJ9wkw3JZ77rnH7GtiEuwUz9W7775rAFMKBDW2IOa49dZbszrTC0Hwp3feeWcTi6LbkyjC9dPjOs+cvU6uwrknnYVNXW/6uCQ2CCu6byicJl4AgAnbTR8GOOe5xs9F3/DdVKfk+ryfzaBYA/0JCIgPr3EPP5MHVIpq7ZhCn+CzaQER1xKHHfL+ozrLmc99WaKDv76qn3S8bkQqzCNBOq573jYu6z2vHbmxNG2aXJNB2NxU2k1EXjJ7yWrZ3QM0P6P9aqky80f5aU0T83wj3QaNLljQHEm7QJd7pZ3mWlDIMzNkyBDTjIEvRKyOb7nXXnuVjPmLW2yFsNdt+d///icnn3yyYSKx5dprr5VTTz215Ge/HEt5EfRVWJuijIb4xM5xGm4+foNa1WSXLZvKm1/+Kef231z22ba5vPnlX1nA+cFdW8k9I6bIH3OXyiaNMoVaXZpWkVd/Xy2tGmb8XujaD+3WSl6e6F88VgTNi1JRpXGtKmZ/L121/hmju/zzPzKgeY9NG8jjx0brNFexR6OkKVEwDfRVU8vnsFlLiC2IOYhpaSAg3kwjNwWDFTaJotw777zT/A57dfHFFxs2XWJbbNR9990XCesrN8B5nA2i1frcPAIxu2PMBs6TFjYMAY5WzmrAEWYOYVSQnu5RHBkCuSREgxJ1csM42LbDRdJMu/0w7gAjCAF7GDquJMUOREholtV1oAzZpwSPYea7u9FmaaASpksknx3naZzH2aXC8/fJJ5+U0HjqzETtSE96FEA+KHlzzQQhUMBQqLFwkyeeeCLrZ7q00FN+sssuu5QUIsQ5dz5Fu6W4bhIiXrTkUQKTqNW/CDbI7x6O/XmOHPdE5r1BxU6MsQdxTNwCKbqMeDbiPH9BE2FRbYYCPDhWULOHpZIPKzadI+dG/2oHHrYK+00AmqtLLm2mBMCNuPfOzWaMnjxbTnk2k9gLKltsVFtePS2T1E5S8sUQksZ53OirlAmFe0jxhT0bPY0kl1vyrCLPkUpa4jxbfmCH+iC5OgT9jjF70YqcgLqXbsYHRP9jh/yKtoLq9pEX75QFztz6/k9yVM9NXD8PIAYQi5/hN1NW46IgNkNZvHRuo1sRQBpiAxF2LGOPp+Jv/zu1k+zz8FexWKfsGJJYAIYafbbv/fBnuffDX2KD5rlAFqX8VTYN/buyskSJM6IA57ZwTGJ4XiTw7cQM+wF7riA67wlaIOgFmp/fbzNp36KuzJy5tMyKuvOR/OK7MZrs+uuvN74PICPPFiD2o48+Ghg4Dyv4W5xb425iNv5fQXMEOnfuOwDuwQcfLIUkXLvmdpJir/I6Dr4EesatADite4MAHiqQHVaC2hSaBch/OJlYchXq+sUZ5MJgA8g1do/1BujjxXEoMkb3sd7aWassI2HHROyyZXaBXGWXzwbtOtccH3Y8TI6oZKyGAzQffnoH8z1hoDEFe02alOj4JEZJBslNEavqfo/KYBJWjnl8onw5baHr394+s6e0rFc1azY6Iw8KGTTP90gou5jthBNOkKOOOsqM9iPOIP9z/PHHGwD8xRdfjF1shTiZ+V5//XXT4EHBpC34tWU1Rq0QqNq18cqP0dDreHSS3z70JzmnXzs5qGtLuXvEFJk2b1kJKE6x7E5bNDFjo87bdXPzu2pVK8sB2zaVt7/KgOx0pNdmiHkAqVq5kqxaUzZFM0UpShpSr0YVE+8tXbV+X7dvXrfE1vTarKE8ckznxJoP89FxHucclSpVMj4KLy1QJBdGsdWNN95omqPISxBbUqDbuXPn2D4tBbcPPvigOZYtF154obz99tvGJhG/nnPOOcZGffyx+1iuCgGcRxWtNuXmA147OwK4SWlQ9RLEc16qGZz0gWnM/VV6K/2eBHJcQxLnsZ3dMB2DXoJzxYNC0okAgABQ59gi6rinAW4mGYjkc3ZtXNosvYd+XSLlqdsviOje4fljPcLMRi+vM86Lsl54lki0cV8BK7y6wdKmatf5hzgOJHb99siIH2bJ6c9m9GBQcXaT2IVZNgNJLmr4oKJdAn76IqrNUH1M4gp9nG/ATxO46A6KDXQuoNLToZdtmt609ZiODiFRyv5JUna5/WOZuWhFqM9ctntbObrnxql97/IwLiQsqwE6m31D8hX7Q+Ib3WTPRk/K7/DqOC/ajPTFi7mEBKxSibt1CDqPQcErctYubeW+D9fPC4S6PVfnoFtRLvcf8JU9CGjulxAP0x0IeL7zbetprbvfOEIe3q16CYDBcXSOrLNg2U1sWnA/m8HfATPQyRxXO8LyLW7MJUr9C+Bis059MaBv6FhGx1cRQ2qXPmu7rUu3oh/o0vOmbEA4CEBj09oSnymbBiA69oj7pCAL/7KngsYZcYFzPzpZTcygZym+Iy7GnrvRBNqy1z1jXY/drG51OaVPpiMin2OfkpQocQk6Ax+HxJJbB2BSwv257LLLDPCizzH6wlkIQ/EDdjKpRoC0hOtMgr3KGZMEYSvxEwCRi3bfItRn0GGcE8H/jDNezc+maKEsYA+jwJydqn6f94szAOK5fnSnX8GWUzgGe5EXwBzdSarXiQG4x9qJbs8MDyM7bdFYPvppTqjP4BdojowcURhge/7SldL7llGudkDZJrA3arsoYLCLBZLIj7jlpkicE+PYYzOjMJiEEa8CKeTLK3Yq+Z5aBOv2/kf3qGno/XkOWadCsAv5HAnlFHxLbOthhx0mZ555pomdnbTpSQnHBgCxRwnanYbXXXed6WI8+uijDViS1gjWfEnQ/BT+JzlkMA8wAK+Yz+t4zDn/1+vfypdTF0iXTRpI382byCufTzNAusrfu28s/37rezm7XztTDMqxDuncVA574hu54++dDHD+9NjfzezzSfP99UURNC9KRRIKRhrVria/zV1W8rtNG9WU76YvMv/fb8smcvfh2yZyrnzFIkmz6FZZN2ILf5/XHnvsYZq5KJalYBfmJnR7VAHHY8zTww8/bI5nF4BS/Muop1133dX87vHHHzfY0JgxY0xeJGkpGKsThiIWwQnUalO/udlJdhzatMA47G40BFFmxPqJUnfZ9FZ6nrg0SFrNmxRo7pw3xYZVQMvu9gNgIkFD0kODlKRBlDiBSBjJVU0cdnZt3IpfO8FlU34oGFbeQQu3OSDObnTWXLtUdDZ6nG50Xc+0v1cRBAkuPEfoX6qi/e5LWlTt7AmCa3SZgtYEk1625sMf44PmdmEW56GTAPsAA0lSAIPaAC+QM6rN0K5M7ptNSZtv0Q5v9o3SnAEeKJ0jfoXSOaIvbCrbJAW9RPV4kh2VXsBLLrm2VxXZs3dXoxeTmnPrdX35CgjyleziOdBkq3Y0occViOIes3fs2ehRg5UicJ7/OMMrIWXHAnS7YYty6UIb+D6vf7ss4DzoNaifx7k0BoIinWvItefDxCZ0oDjl0W9Wya3t15TQi+Nn4ePnKgz5f/bOAsqOKunjlcxM3N2FhAQIECwJEsVdF4fFLTjL7gIfLLrowuLubotbgEA8ISR4IFiIECPE3b/zu0NN7nS63+vu1/JmeHVOn0lmnrTcW/av+tf6P/Y9thI7yT5xKx7FZ+d6OEdsRFIjEPwIutEeGyTDN8wTHzp0aLlYxgvAVeG5ESPZFPTLVq2VHRwg+OeX9ZXqxd664pNf5svSVRvWZJhZum5sGtqRCfABOKWd9hzKZuAVZ9hrPOoiKXv2OUISGT+fw57hrt3ovP62jybJjIUbxg7YMvj8DQmVigqch0l+JRFnoCOOOOIIs0buu+8+qQw2I46Oc79sJZno2h8YPtk3cG6D9OQjgswYD2pT8CWJUQBtsRNua87r/V5xRtSMVdgh7CcH30UhHH6bjrPwM6rDHuOn+SAnC0imPBF6jBwR94d4IMh+dn6Pno8t3Du6sDg0P6LFAsSsNhsJujOKHBW+EfExxRLo4ky5qajijEyguVsHudvrP/vHTmUjmVi7nK/mjfgZtuklV4lr3GgYm6HjP+IQAHN8DGdB13nnnWeKingGjBqEqhcmoNtuu00qcpzhJz+FP4Z+IEcOaJ4pf+llo6qXFMleWzSX17+caYDzv2zXSq5/7wcZ2LejVP2DMalv51K/6uPv58jumzcz+7FxzSLZu1tzGfXzPNm+VU0ZP2O5bNOhiXz/5dys11a/ZrEsXB7/mMSCFCQuYWvUrlYk7RvVkm9mlnaWN6tdJOurFJWB6Eds11Ku2GfTyL4zSeA8zu9Zv369GcF0/PHHm9jeOZIjqJx99tlmrBQMVTZwPn78eBNv8HsVMGFyMoD2lRo4D/IwSMDglGWjB4ySOl07IaigzNRhESVVu9JbuVF35QrQ27OJogLNveZN2d1+HFwPFHxKFUggRFCiFbC8JpcNzXnQoY8DFjQQySRuAVHcs2uj6EanUodgCUHBaJASx/lEOeM82/cgbtdAcGPPTMy1G12/K+6K3wLtrn/hmdGlmy04iaPjXKlxCWhsalwv3f/Z1AVy+tO5g+Z63dptz7WRbIsShLYLcZx7K6zNYP9pV6aToSVJIVmIPQVkcnZ423SOOF3oTOwTNlhpejWBRpFCWB2nBRck/qIaHfLdrMVy2IPjAr/vqf3ry6qVK815oDO9GEy41ihsRlK2IUnKfWcniN2piuOOriAZSzKOZCwBBP6AJuOCdKO7gSQFm5GM2HbEjgW8RoRk+wy39blkxRqpU8M7JNO9x2egPyjKwK8k6e9HgsYMToBmzKx1MmH6fKn6B5iK7cuWzFV7gR+Or6/6FJup+pbPUvAgap89DnHqwF122aVcLIMuVVvhZC4BjOb6eW6A8MjH3/8uZ79QSv3uFwSft3SVnPTUFzmD5tk6MtFX+M5cnxYi25S/JHGdNkNHydi+QhzipAlU+l2o5znvb5bUkse+3NAhkglIqcjAedDzjttmKGgOKPfRRx+VK+qkcAa9aYsyHuQ7DW9URbhqB4KwlWQT9HQ2xhL2BDqWa1CQPtc8ktf7ye+Q+0A/APZ4xShuAJNXnKHFwuRV4mCsMkDRH3kBLYB0G9WBbs8lBrCFZhKeSTa6+bCguZ9iAYqJ1XZxf7FZqt+D3mMtbMDOOWe0Z2NKzCXOiAI019cpMKxFZNgUtdusAS2ojmoN+JG07VNSccajjz5qugqdRSoXXXRR2b+h6UWfnHHGGXLDDTekVswQhWTLT5GzYE/CesSYi2zrLdPnHbZdK9O8cfEem0q/Lk3kyrcmyuhf5skunUoB8+KiqnJcr7by6KipBjjXQt3je7aW4x8bLyduXiTjZ4i8NmG+dGtZVyb8ASR6SQE0L0hFlppF6zFK0rZu1TLQvFvTEvllwRpZtrp0j53dt72c2ad9hR1pGGecvcyyGehrMMywwuxy/EkKPd10JJ/vzKViw+NisapQwLlWsOqcaNspixM4cVYFZ+qEiIKqXedyU7XpRm+FhA14tPNY70lUoLl28vkNAAjaSHho0kOTM7nOY3LrKExDNCAiOPHj8EQtGnxwHkoljWJxVvzq84+qszDJjnM/a9erG13n02o3ulYUu1Vz2nslLtFA3Ws+aUHCSdQzzrUYBhvgTAi52ZrJc5fJ0Y8EAzW/vdJ73iTrlyQjeiWOYhzdT7ZtycVmKB05lD32bMMkxZ6ZS9DtZk9t4RzZhxyct4IHJJcovuH6w3RoKOBGwpTCslwTEUGKuGyBWhjbtG7tWlMEqDrPi8HETmTmYjOSHBeSFPCWDbhwdqNrlyS+jhYMqu3RLkm/31WwGcnbEWIB9g6SLRbIFhts1qKOTJxVSvWGbH/DkIzgh64N9KnqkCCFN2Fihs8u6y/bXb+BxeKMV6fK84e3lm26bZZxLzttBgln9KkbPS7nRWxHxzM2LZ9Bcz+xjLJNKHOJxjIUY1E4oJ2SYajZEd7X+9YNs9smXNFf4hL8G7vTXil/eW5cHzG42kJAbK6XAiFABXs2etRxRrYZ7sO+nyUP/O9H19d+cckueQdMJNVxHrfNUNCcop6PP/54I9pxfGZidLpEANYQwHXuP8xJ+W4DomAf43lxn8aNG+ebrSRbUVM2Yd8St2AvuO/qs8YBnGObdAxFtkJZ+/2Z4gwnY1XcY/4yjerQsYl2DGDLuCkLfHWda2xEfsiNvTKTOD87bOEU14Et4oBFE/9Ur1PZkryKwLzYDLB/meKbqOOMKEFzryIyjQO1G52cmt2NriNNKiNVe1JxxvDhw43v8MILL2R9LbYC3wI/hHVbUQV9ZrNIuWEA3bt3981Klwnv2K5tfWndoIa89dUsOWKH1nL4dq3lyTHTyoBz5MjtWxsmrK9+XWj2HAVQi3/9UTZtWCRr67WSHu0Xy6dTFkifTRtnBc4LUpCKKnVrFMuqNetki+Y15fPpS83vejZdJ+N/Xy1r/6jzu3LfTeUv25YWP1dExsQ4v2d9hDYDHXj++efLBx98kDcsdMUVhdpEZ/nhnATpsssVOFeqdL9VwbkGIjoPm+v1orcK+z02XRKiTmmuQkUuDnPYWa3cUydVIIknNgxAA46rOu/cD69zZj6OduhHPTM2iHDuFACECYiiFBx81pLzPLTKVx22KGmzkuw4D3OOXt3odEew1ty60TN1t0cpBar26Omwouw4t+eZu80FdAIjS1aukb3uHBXoO0b/o6+ZL+UmdBkSKJKoxxbFsc/0mvS+hrUZvJ49BYUq5xoXtVs20Vm86OSwM3Od4AE+AYklOsftDg1slFcHsbIUkHwh8Re2Sn7B8tWys2OeoR/5175d5KgdWpsEJFWbnCcjBrz8GS8Gk1xsRpJFVfnYCWLPFtZudJ3Zq12S9sxe9rl9HQWq9nSp2nle0ESyz8MAvE5b9OoZvWTzqwf7fr/OR9c5h0GDyDAxQ+3qxXL0Dq3luXHTy3531EvTZcLmXaW4yH2PZbMZdscbhUisfXQoRZ7QnrP21d+vaN1ENnOJsj3hNwBCAL6w9wGWFq5cL/s99FW59467pK+ZpZdNbLB98Pk7Jabr7CJUYgpsiYIsFKVx7Vwz65LiAO1GjyPOyCTfzVoi53iA5vf0rWoS9Db9Lno2KduULzPOw1K1s54p+FLhuQNoch/xj5iDC7D41ltvmWevHR/8HT8KIHXvvfeW0047Te6//36zJ8455xw56qijTEyW71TtCHYgLEjG88Jv5PPCzDMP03WuXYsULXHY+iLX+MjJskVnLnG034IAja8z2QzsAmtM2aDS2KfOUR06dlBjgKf2ayjHv73IvPavT3yeFcjG7rGPwoxqigo0dxPiAp6b+qd+x1fx7IhvsAmA5n59k1zjjChA8/v7+9Of7HlYMTh0bjy+O3E5+U9iS70/UcyNT2v8VFq5KebUUtQDUJxN0Afcj6jGnKVJ1e6k4teRReylTBhAUB+fczqmRxt59tNpcvj2reTYnm1k19tHys9zlkqnpqVFLvVqlhgad7rOD2+91vit+OmXHdhSTn36C7nl0G4GOH9w+GTp2aGBjJ28wPe5FaQgFUHqVi8qBc1b1JHPfy216cfs0EqeHTej7DWnb75eWi6bJN99t6CsqCyqURqVpeN8aUQ2gyJbYmj8ZRX05bBhw+Tuu++WQYMGGZ1JLs1uJAAPjIvFKm+Acz+ABbTsfmb52ZJLYKBBgBtVehzfpxTjJIuyzTLRGed+u7jimGfOZwKMEATQyYcCyVXsKk97HpPORueeKEihHVqcB+dAEBPlzFi/YlcSK6UT55EWWKRKg2pmmxLST8WvvXb1dUG7CisKOJKpG107S0lsaLFG3AnKAnAevaAfFHDIVc9xsK+d+8ktibRu3XrZ3urU8yP/OWxLaVS7mutapxKbbjUq30lmxLUW7Y7zsDZDOw/Q22HB6ihEwWr2NRXqUVQr2h0a+CLODg2S8M6RI3w/xXfYLu5HGAc7bHe5PSdX2RI496CU+VHYjCSLqpLsOA/7XawDu0uStaQdLfgyzpm9BeA8HeHZAD6wrgAMKZwKs46dsYHOFrTFTmK5FfAi+NphdFkY4JzXH77JOnnOQZrS7ZqPZOJVu210H/zaDO2ooeiWZKnOQdURGTpf20npnhaDlFPOG9BR7vw484x6zhV7AMhCTEfgz/Ud9tQPsnDl1HKv/eqyPlKcYZ65lx1oWT+9CnzWIDE5B7aFBAc6DbsLOG1T/io4HVWc4SXsnyMfLd0nThlz8c6mMIFzRccSI7EGAYs4b90fFQlAT3rGOV3SAwYM2IhC94QTTpCrrrpK3njjDfN/mPJsofu8f/9SZoRnnnnGgOW77babudeHHXaY3HnnnZLvYoMcYUTZSlQH5zqm59kDG8oxb8z3/Dv7DZ+UWNarazGKjnOKH+wOSYpm/OaC9Pu9bIY2QxCfh+nMj0M4R3Qbhx0DiJQm2RHuxchzt5Fd7vpiI/396pGtjN0LM6opTtDcKehEu6HFbXwVz5lrIDbm2dgMVmHEb5zxvy9/k+vfn5QzaD5s4FbGzwgq9tx4e6QJB6Auf7e70XNlSEiz4zzOYitt6KEI4aWXXpJbb711o/czp5bRdNgd/EH+f+GFF8pxxx3nOTK1oohdjMV+4z7oyCIwgKC5gmz4wwFbt5Sb3/9RPp+2ULZr10D237K5PDFmqlxzwOZlr/lrr7ayz92jZbuS1dJ9k5Ymh6wd619NXyS9OzWSET/Pk67N6xaA84JUKmlcu0TWradgvGoZaH74ti3Lgea37t1Sdt+2U1nTA7kamBnspgdiirC+SmWZcb40IuCcOIHiRFtOOukkU0T5z3/+0+RjsK+DBw82sQRCvhy/Fx36pwPOdV4OXXaZAIuogWwbqAgSBOQSiKjDRdU11DPZFrQNcGRzqOIAzfk8igpQHlSYxlWNaHen6FwwnHecXZxVnC9+j3PmnKkUh3jNOece4xDSZalUjGkJFbAEbn5oie2KX123dsWvUi367RLJ947zIN3oJDwBMkjici9IDGowFHVFMd9XmFcbveTaUWGPBwF8zQQC23soSCehygFbb1wdR1IKuwD4ihMAG0dpkiYe0QKRTMmsTML5Ui3NfYsKrM4lSQn4mGsyJ2iHhjKOcO+wRwTDBPh0eAfRWd/PXiKHPLDxTB8/4kyo6egQQA6SkLnorrA2I8miqripPO3viuKa7G50r5m9XBPrjYCEn2FsBlW6t9xyi7FlJG9fffVVOfjgg8v+jh91ySWXyGuvvWa+m0Kd8847T84888yMn3v77bfLfffdZ4IV/GU6D5k/mC/UWmGF50DiXnUufmjYvePszkOu2n8zueqtiWX/3/fu0Rt1DWpHEwW8rIUwHfP6/UGohllz2B5jgy7ZRba5cQM9OLLZVYPLged+4wy1qSQbYN9Qlg63ERlaNEsMqGMPWF/4YWkmkg/bpmUZcL5m3TopdrmfSi/MviVGWrWuiux++/iNXvfQbtVkyJAh5br53JhLkgRNggg6g4IsABZiV56jgtNulL/YRN0LYeMMN/ll7jI5+MGN7y8y+Lxehj0BUQpmiuHVZrO+8K3sbnSOfGc8CAqc5xpnAH5n0j9+dBP399lnn5WKJqzJsPGE0pezB9gj0NPnUnSH8N73Tuwkez/+80Zd53EyFzrfz3ex//kuYpQga4t76mYzNJ/CvsRvzpbHSFM0BphwRdsyNpCDn58u9/Wb6fp6dKJt9+KcZx6VeI2vorCB58Tf0f/8LgqgOFOc0f2GzIxbQejZOd8o/He3kSbagKEFgE4mw4rScZ6rzchUbPX444+XzbBlzx999NEbvR8bzN8pzCIPwvoDOLfnnldUUZ3H8wVvINZwYwaJqlGEwsFDt20lT30yzQDnJ+zUTo58+FO5YNdOpmnD5D1nTJIeTdfLx7/VkD7bbMh3nTugk5z05Gfy38O3MsA5nwGL3fMWG1VBClIRpU71IqlRXCQNa5fIj7+VUrMju3VtLC99vsGO37l7Pdm0ec1yDTTE5XbTA0VkzqaHoD56UnmyqLrk48QzsJfgv7bwudxb/f0pp5xi7AHPgxz9ueeea3xRfN9KDZw7jQTJGrrF1PEPy5UfNNDRZBE/ufFBnNsw34fgXAHU0wVGYjsMpa6X2HODogLNlUqGz8yFdjaXOXYEnzinOBok4LTLUZMzbJ4kq5PtDsu05lTb4H2YamZdU3bFr3346RJJEhyJM3FqV5WjoOneJyhydqNnmo0eRDAy3LvCjHP/4md/5zLjPOh4ENX9QWYPqrhRLGpCGicBG8i1cE65JLqCJMNY00FsBueG7eR86TiKyynLJiTAdbxK0M7qKDs0tDOD3wP+kEBQ++WVPPGae+tHBp27o7RtWNNzZAeAOWBBlBLEZihIErck2TWYa/Lbj6+j9gFfR6n2H3vsMdfZeH72KN1nJ598shx66KEb/Z3gg6T+008/bWZ7vv/++zJw4EBTTHbggQe6fiYgCGD7o48+avQk4O6JJ55ozuu2226TfJIg9wq/Ej3CWkL/UnSAXgz7vJ2jPJCje7QpB5wj+kztAl6l9SUoD6v/bTrUbPtDbQ96iu9Ghz1/cGM56rW5ruC5AvLZ4gzuKTYCWwqYnMlv4jV2ISPgE3oUnUoMorPD8fmTBjib1NngC7z2xSxDb+m8f6wd/Ec6dg59cJz8YCVknMAH+1KLBLQLWvc/fvzMRSs935umUDjN86TYx072OkdSZKL85TkHjTOcQrLr0IfcQfO3zuohzepWz2iziSUB9Flr2EuKith7mqDhIKbMt270oPanEGcEFye1uRZ5+BH0Il3YrCVyFvYIuVxHSHmB3sQfD+9e3RSr+GEuzLWwmH3N3sn2XU7h3GGiwKax55RZhN+RT0HfYyMqSkzstHl9+/aV0dsskp3u+Kzc708bvErGdvfvu+VjwRQ6G31IYxN5EdWb5J/IlbAe1DajQ6NgB0S2vG5oxteN//uOZk3aNiPTTPM48lXZmAzRIfaoED97Jk0mlFxtRrZiK+T00083h5vgf44ZM0YqkgRZ76wH9hG+H3mTXIqE/OAPJ+zYznSUT5m7TDZrUVd2aNdAnhg9VQb2aVvGiPJ/B29vihAnz1shHTuWvm+btvWl76aN5f1vf5NDt20pr3w+U5asjGYMYkEKkmaXOdTsnZrWlE8mLzS/KymqIps3ryODv59bjrHqx+++cd3bxGsc4HduTQ/ObvR86TgPO3Io3+KM//73v2XsVdjbvfbaS+69997Yvi9vgHO3xDcOV1BnPBcgW2lScAg1WRRUglTw6vxVaCABXIPQztiJajdRGne99qhAcwWTuEd+Zr7HJRRWcO+0m4NrRVHhfCiwqY47zmncII523hP0pSFKlaZrKQqF5Uabpcktry6Ritxx7iU6f8itG11no+t8q7AVxewrJO45Un82Cdshgh4BbKTD0A8DiH7XPaNKZzoGka8uH+D5/SSeqWjU9ZRroiuTqM3AmdKZgjbleCZhL1Doxv6wzzdpIYlHNyMAMZXpaZ0Hz49kKfeCZ6gjRzi0e1KBA3TGNtcPl7UhQeVMiTTsAWCF28iOOMTLZgD+aZKKQCLOObdJ2oakvotgC3CQmU3sMXzkF154wfwNyqo+ffrIPvvsI0ceeWTG4ktew+ElzPCmE0RpdUlmPfDAAzJ27FhP4Jz37LLLLnLMMceY/wO40zkCvWJFFWWA4n5TfKN6JBfd69cWnfTk5/Lg0Vsa/a9MIxps59IhmC1m8GN73vlrR9n3yV82As+/vKyvFFXdsKfdRGfVamdy0FERmnjgvfhLnKcWJ+Fzqb8fNRuQm9if/6+3vi8HnGML9f41a93ONdnv1NkKNGsXtHZrK3PJ2cM3vPbry0v3ZtrC+WHzWSM2IOiX8hdwmmfHdeuzUzr+bHGGvXa+nr5Ijnm8PCWyyv9O217aN6rpW49rVyU6jBhTu0h4DpyL3Y0eV9IpzuRXIc7ITYIU4iorH3oKNjybhS5XJiz7Myi6dRbrspf8jDV0K+byK+wNci2sP67Prz63c1PsM/wZLRoCRNf7jJ6PomMpLVE6bzfBN8Kfs8cOut2/fATNbQYr4mPG1yg1ObaA4jiNdbT7TmOdXJhiMo2r+uyS3lJURcrZjHXr10uP/3ySsSM9iXyVG5MhNoU4UHNHalO8xtHEVaDrRwo2Iz4hFmZNkD8OytbhJn7sSpuGNWXfbs3l4ZFT5NoDN5ez+28ipzz5mWy6bpq0bd7IdHHyOQM61JRnvpwvA7bf8N6Ld+8s+987Ru46cmsDnL/19Sw5t/8mctcQ77EJBSlIvkrTOtVk0Yo1smOH+jL0p9KxN3t0bSxfTF8kX81YXNaNPvyinaW4ahVfhVZ204OO4NN4jgIZMCItmiK36tTrSQLncdmUpTHjGTC02UKR6D333GOOJCTvgHOCaSoWcajVIctF/AYoJJgJjnOhSQkCbNg0iBjMoIBrpiSYDXAiUc1nZvOTKCFJkivdaxTgPUEJ4L3eC5sqCUdEaQJx5LXDQSuac5E7Dt9Szn/pm3K/O/XDlfLtzumA5lyvTZsflCUhKG2WfifrXNea/e8gdKAVBRyxDYzdjR5VRTHGlWRBvlNDVjQJ0yFC1Txza9AtBLt+ZcVakf994z1z0E326dZcqpcUlft+AmocLLfvzyXRlUlsmwHFuo7E0MQ9a1nZPJzrGfCCDhESXX4ZU+IQKI0Bq5MCiTOdB0VMPL/mzZtvNHJEuyefGDVZHn55QqjveO+cHaVdFkCATifsHx3GQcbNRCWqnxl1wX7iPLBNts2IY85tUqwnac1T5zjggAPM+nrnnXfMHh00aJC8++67ZkxMLnuQjnHm1NKRju4hQGEtU9Gb6T10qAOuw0BEspTzOv7446Wiia1/nQxQuYIdXu8f/Y++stPNG7qiRk+aZ+Y4klDledpFn7kUTvkptqUQEJ3hZnuU6p0Oc8ByW7pfP0zGXdJHalUr9oyv8FFzmRGvwnuVbttJ6c75a1GSFs0mmXDWQiWKWfZ45Af4xAIDH5w/doPDjYFk/LhPy2xxWnPfwxZkOSl/iX95dlqowvXaBWX4Gs44w16PoycvlIEvuNvQZ07cRro0qx16vAf/t58DxUqcJ/bMSb+bNMOZfd5BO84LcUZ48WsDdFSQ2kfnyJIogHPbFnzyz77S66YNNuSg536V76/ezNdnhIkndHwIxTDs4SCguTM3xb3BzpJEhuWE/AwHvjzfkSn2yDexR/nxc/T528ltO4tcNKr8684dWVWGntW1HAuHMqhwVC0uke7/HpqXoHk2BiueHTbeHjnEdSpTjM024icXlwkwd7svrK0D7/9UJv2+bKPXfv7PncvljpKMFZy5I3wh9ITmjvBd0As2k6H6fml3nBdsRnzFJ+jAqIqE/MYHp/fpIAff/4mc07+jtCheJu1rr5VPFjaU/fbYusyPObxbPTn7nd9MYeJWrUsp29s2qiXH9WwrD42YIn/bvbPc+uFP8tY3swwAOWeJN0V8QQqST1KzpEga1iqRlWvWmcJaBc1P6NVanh47Xdb+0cOyW5dGcsvBXaWq8IvgjYH2CD5l39JudOwhvpNdjIsvlCRVe1yx8bJKbjPyBjjX7mscchKsOORJACc4TiSKALyi+F4/wAYV98yYzKWz3Z5Fa4s9ZzDKbi4FJUgmBgGTohaUjnaCehVW2PMnqLp2o0F0ztsLIntsnj/ztnjWFDPggAOaJ6WonJ2FHCSb+ck56J7TDpGoOwuT6mz3M1/Kq6LY7kbPVlGMToiC0qwg4TtEWLMUbVGAAgDk1S3gJSe/HQw0R24/YquN5umydry+P9eZhG7itBkkp+wOMZhYdM4s50eCS/UnoDm2AYox1ncawjkCzAIUAzTZnT1pnocbg8zEWUvk0AfDzS33mzzjPAAvOY8wIzuiEvs86Eiy17MWWOm6s5OpudqMpOYB6vmnRQuvNoMuH/wc5jrlKnfddZfpMieRje7k2h566CFDO+oldJrjX/Xu3bus24eZ6JdddplUJOH+ov/ppMOXcu6bXMZ+2LGBk6KV2YJOmSUNpe82W23kD+RSOOUVM9jFl+h5t2vX9+u5f3flrrL51R+V+/sONw7faFyE6gDiq7hm1XpRuhOvUNSIPVB75QSwohItOuBa59fp8AdoLjkDH85k5Gf/2Kmsm48CP2x1FN18QSTKgizOXwueuYf4zlwb9xJfA99Zr08Ty2oznvl0uvznoymun/vocVvL1n8ke/1ItmQVa55z4dBiDe1GJx7VjksFPJLqRg/aNVKIM3ITbEC2QlzWhTI2UVji9nyCFvS6CZ9B4pU1MPWn8uM+7HnnmSRoIZZzfAhNCfzbj2TKTWmRLsllbVyxYw/VB9glmwI834U83xZdOouM2jCHXkUZvSiyYl9ynRTlRGU78qFgyjleUXNxzEZnHWXLxQUFzTPRuWM7nXEGezDNnAv+iF1QTe5BKe+5z9wTbEqaM84LNiN6YZ/jb1N8QrNgVOK3IKtT09rSb9PG8p+3vpC9mi2RC3bfVC584xe5YOlqafzHGKLmdavJgV1ryw3v/SDPnLx92T45q29HQ/V+4NYtZJMmtUyByim7tJdHRrr7Yk6BBnu1IpMFKUjCAlC+bNVaaVGvunw2baHMXVoaYx2xfSt54pPpZa+7Yu9OcsjWpTlQ9dXUdoQFt/Ef1e7zudhD9D32ULEpzbvEDaDHaVOWVHI8I2+AcxLOOFTMEoyyvR9DQvLETZxz1KP43mzAxm+//Wa+k0rNXDvqnd9lByZRUbNrYQHBUZqghO20B+1stGkQlX5P6SgRrWjWDodsQudBPgjXQoCOQM+eVjU264w1wv5Vunpdh1phrq+Lip43X+l47YpixO5G14pit250NTQF8S9+9JvfQIIKOap/cVpgAAlagLLXnY6WAh/yzjk7uXao8P1eCf6ogfNsNkPpBjmwV0rDhx3D0ePvJFC0GzFpR4nzxiZosUNae4jzoDtGQTfbl5g6b7nsfXf4GW1PHNBY2rQoTS5lE9MROnGisW/YhLRGPzhHhzjPw4vBJAqbkdQ61Ll9SXecq8RhMwDOmSdI1zn+EnO9zz77bANK7r67exKervTrr7/ezJSCrYICuvPPP1+uvfZaueKKKySfxGtd2PqfDkE3/Z9rl6CuXx39Ysu/9u0q17zz/Yb/f/SbHNnPvSg013Nw2g9AQK6dz/Vje3R/QnnqnB+6111j5Ize7eX8XTcpoypGN0c1PigIpbsmJtCFSguOHtLERZSU7oAAk6fPkotGVgnVZe4l/f+7wa9486yeZd2Z9iw97LFdJKDAUtRFAsrGgx8bR0EWz0Jnw9rdeDrexAZhrhw8S4b9NM/1cx45ppts16ZuIL89aDwBMM4YBw7eS0zIeVJU4OxGj3N0QNDkVyHOyH3GuZf+ZX9QIITfo/PMvZ57FMxRfAb6DaYX5MtLe0v3G0YEAs+DnAf5BnIm7EsdH0JeyM/7veIMnQGvDC82GOsVe6DPlfJUdXmYBogkRFmnBnRZIB//sGFeqoLC2AabhWP/p8uDT3fusl6qlRQbO5oGg4otrG3ue9iCKZspxh6Fobk41oLddb/NjSMzfp6bXfUC2vW1zjgDfch5KWtCHKOj/Ird8IOw3rF/3CPOmXukTCzkl+IeP6lSsBnBxUvva4Mg/ij5dJ4n6z+q8Xt+9TnrvX/T5XL1iCVyRv9tpXOrxtLzqwVy//Bf5P/26Vq2Hg/qUlMu+nChvPftb4YdEalTo1iu2LerXPHmd3Lzod3k9Ke/MKD5GX06yAPDJ2f/7gJoXpCUhEKPmQtXSN9NG8ugb+eY39WtXixbtKwjL47fUAD4v9N3kM1b1C1nM/A98Lfw/bXgKhebYdtDxaaI54h1iCeGDx9erhs96qbIODvOl1RyPCNvgHOquKk2jdoZ8Ap0eLDQQuH85zpH3Q9Qb1MAM0MkCipZOwkWB2iuHTjcK8CAtDaC3c2x9dZb59S14qTf0w4Hng3Xalc0szac91HnF6YtCrQRPNLJk1YwpcAVleEkR5V6yznnVtemGz2v/fog35sWYBH1fKvBgweb12XaX5zDVVddZShxAaP4vBNPPFEuv/zyjHudmR933323+T706//93//JX//617K/Y6xvuOEGeeKJJ0wVLAmfm266Sfbee++y1xDksv+cMnDgwMRmioQVP2AH+589zT0NOnsVWb12nUyeuzEtnJ+qX4Q1gS3COSLRkmmtRQmch7EZmqxirZCsolJeWUAQ1Z1cS9yBPYAP38v5A5qnRQuEE00xHHYfOwlg8dOcpXLgfaUJzTBy21+6yV6bN92oA497bnfc2M+M+4ANw+nWAqY0hHWFbmNd+B0d4jYbPazNSMo22J0radghgrgoCyNI1NEl/uqrr8p+++1nfoe/RXHef/7zH0/gHHAcWvZTTz3V/B9/hHOjcx17k48J7TD6PwqqdsSpv9EfW1T7faPXz1iwQlo12JjiNxf977Qf6ApsD34Izy2TzlbQ3rYZNjWtygMjppQee9SS6kVVUtPNXpTuqk+jpHQ/9MWNu4aYRc7c97Ay/Ke5rv6C1yw97ebDPwRIxz7Y3Xy5xIR8Pp9JZ4SzMCzJbjySzAMe+NbzPc+d2F26NqsVymaE1VO8TwE+t9FNdjGH39FNccUmUduMP5t4dYrb88yJg93YhpyfkytYwjrj+8gl6cg6t3nn0xcsl9YNauYUT7BuNF9Gk4naCT/v94oztHudIlw/hTg2BTjPINcGiDiEa33tqNZy8POlnWvoqm//1VzuOWrrjN3Tbn/DtiqDiltxlF+q86iYtGAWi7JgypmLI4fEde7+MAWEG4oInfLO2b2kQ+NagUFzpy0gn4g9w+9BospNRSU8WwrksH8ff/yxKR7BX+NZ4KvzHNSuuOUqo5KCzYhG2LvEUuguLTyKgskqqF1R7KNjg9qy22ZN5dGxs+X6gxvLxXt0lsMeGCtH92gjmzSpbT6relWRi3bvLLe8/6P037SJ1KxWVMa6+uoXM+Tdb2bLX3dsK0+OmSYjfp4r9WsWy8LluTGpFKQgUUuzOiVSvaRYFq9YI12a1SkDzY/t2Vo+/O53+WTygrLXjv57b6lfc4P/gP7Hz8C/g2kF+xs1noEo0yd2kFgCv44YguJELfrWwrIoRkPF2XG+tJLHGXkDnLNo4jD8boZEu75xwKG4jPJ73QIJpeDF0Q9DAewlnLdzA0cFmgPMYuS5fyRKkqKec4odXBGQojDi6nCwK5pxTkn2aeKJQJjfA0xArfVFn5ayzfVDXSuI4xa6o3B8OG8UeVqOPWsOejXuG8/GLTmarbNQkxBBq7fSnHEe5XwrArcRI0bIqFGjzPecdNJJss8++8iee+5ZLvkCmH3fffcZgJskybhx48xr0SXnnXee6/fx+ksvvdRQ7bKH6Uw47bTTzOcyIxcBeAeM5zWsa2blHnLIIeZ8qIhFPv3003I6lD2wxx57yOGHHy75LpkoETPNsw0iW15TnrLWj7x+Vi/zE6cI28B6oEAhm+7Wzu5c1j/v12RWUJtB4E7BDs6j6h4Cey1CUt2JXmCdaUdI1Ake7RAFHEizcEi7NQl+1zftLNvdPDr0Z9WpXiRj/1meEtvZgafAD0kfbLICP3SrsC9Z62nba549jjM2IUzXY642I6kxHvb+SUKcIAl7IMqEGUVUbvNKs4G1nIfbe+yu/HwUu5gVXYYeyyS50uvaHedOX85tvw7474iNugWj6DjX9wdhv1IWB/Q/hz1yBp/36bG/yvXv/VjuPWd8sEyu2b+L9MyTOWdulO5OQCIqSvco4oAznv2q7N/vnlPqLwTp5tNubWWlcs4OD1oci30nfk2jIEu78Xrf7V20fOfeTaR1rdJZ5XZs7MdmRDnr1k+xbLbRTXHOOI8TZKns4gZyEP/qrFq3eeZx2BJATDq1eZY0YtjPc+JVu8lmVw0u+/+u/x3p2XXuB/hm7aJDsI8Ultnflen9meIMZXvEfw6jU3gO9jgpjT20AUJjD/Sdn8LNKMRuNPEr2cBeu+iGXCX7l+tUqvMoi6PchHsLgwZ2JE4GK2UX2OmOzzK+bsiZ3aRR/Wq+7uNWrerKC6fu4HpNxPwUf9tMOFHlpqIW3V+sARhOGM3EOtBRIRoL6jph7UcZDxdsRu5C0Z/mTdDX9vOJoojK72dpoZFiH007Lpf97xkjJ+/cTjZtVkcO27aV3DzoR7n/2G3KdPvB3VvK8+N+lXuH/iJ/26Oz+Rz2wr/220wOuHeMXHPAZjJ44hyZMGOxnLRTO3lsdHnGpYIUJE3ZpEFVmb1klbSssUa+nL++bPwVzGgPjZwi6/5IUXRpVlv+d3qPjYqdFbi2mzajxjPcfHqv0VD4TcrOkstoqFwaAv/sNiNvgPO4brBtSHTeHkdUXd9OcSa2nBS8UXZe2B0g9gzDXMUNHElDUEIKzCaRsLErmrmnmnhSQAKFRtcuyrNacTr3RDuEWLs40GkpJu4PwTQ/g9DEu81G18OteiuODpF8qcwiwULSGlpcAPEHHnjAVF//+9//lmOPPdYkRwiUEIDsgw46qKwTkOToc889V0bT5yZPPfWUnHHGGXLkkUea/zM7DhAcEF6Bc15DV+C+++5r/n/WWWfJhx9+KLfeeqsB1BEnw8ONN95oOmv69esnaYqftU+CxW2urD3PNpdipgXLVod6X9fmdUzig+QX88H9smjYDluYNamgu02F7VeHALRwz3DknCC/XYSkgT1BGgfUlZrg4ci1WpIgFN2DDoy68C2IcI0XPDNWRsxUcPCbUJ/zzRX9paqPa/Ci6SUZD/CDDubZREnlH0SUThAnH5sQFXgf1GYkZRvcZnXG/X1OqvagiUzeQ9JQhUQzewlfD98Gnf73v//d+ELYpqFDh8qTTz4pt912W9l7YCwhiQ5TCYIt4e8UWilVO13o/D6tghYvUV2hvqWCgX70f64JLr7b/gwFJLTTfWKPKuUAD+T3JSulSZ3qkXac8/08d56TnzhIbQbJefxPfAgtKuVA5x/Xs40ctUMr2doxX/Rfb/1gjg/O29Gz6zENcQIS2q3tpHR3q+5fuWatbHt9eYp6lagKZ2ctWlHu/+0bBQN/sAVKJe4GLCmzls4O97KhrBWbTSUtVheuodu1Qzz//vyxXaRk1SID8mB/7K5MzjmbzYjLx3crlrVHN+Gf6rmGod8NM+O8MneCJEHVbgPeOs8cADdIriSsLbFnjOODs6/dxis5xYuyPdt5wJjA93kVFnsB55niDPxm7hk+BjolV2YqZ+xBvsiOPXSOtlK6xxEvKPsV1801yeANNOOwkdEh7cbOEsSGcN46djBTcZQyqOTada8xMrYRHynq0R+2+Lkvrx7ZyowE5PmiK7nWolr1Zc/7SvOrfmIqZU4hlnWyaEaVm0qiQJc1zaGxoM5GZ72zFp3d6LlIwWYEF1vHkOPBp0Q3EVM59U+uRVR+9LldJEzjDTEH0q5RLTl8u1Zy2+Cf5d6ju8u5AzaRPe8cJSN+mivtqqlfVEWuPXALOeKhsbLfVs1lsz8orFvWryH/2q+rXPvO93LTId3ktKe/MKD5Rbt1Mp9XkIKkKU3qVDNzzH+es0z27tZCXv1ytvl9w+oirWqtN6xoKn/bvZOcsnM7z/Ek5GjdxhTHYTPcRrnZo6GUnQV9j25xFuP6HQ0VN1V7nUocZ+QNcB6XqCGxE2Uk96LsXHZ+nwYLQSh4g4oCQQQHJAaiqqrl87hPbuBIkkKiRjv5cHCTpt7iWREME4RwDlSnkmDEQWXuZ1zrJ5MAlBAg6bNJSwjYeDYYAai7wga+bvS8anSyVW9VxI7zbOsdMAJQm4MEroLmCJ0MDz74oAmMSPQSpNOpbgMabp/pDHZJVgC28wzZU16v4bPdhKAMQP2iiy6qENVk+txsZ8TPPFu/0uum8kCBX8EukJCA9jCIg2Gv/6Ci3R/aBep3/9ijMnRmXzbBHhEk6uwenDxsC9fN99qU7kH2Fp0W2qEP0Je0rFu/XrbMkMD3K+Mu6Su1/qA9CyNK00vih8QZ95FkCQkhkkusKQUO4koW2sIz1uQdoHlcNP3ZbAb6SYvcWOtxAttxUl157V0nVXvQ8TkwlQwYsCExix5HTjjhBHn88cfl+eefNywlFG4BCrB/KeQ688wzy96j9MMqOi6En/hJ7GtAc96Xj8J9Q/8TjKL//RZ4REGpqEky9Cm2PBvTyS63DC8HeETRcU4CjcDWT8GAbTPweSmO0KJSjRUUVGcN3LXLOjl35MZ7Yo87x5ifoy7uLQ1qpUOj67dbGx2i16drnTW9oqSuHPfchqITW6Jmmtr19vDMJX6AJWUuUWYttccAErq3bZ2+/fbbp0Z/vGL1WtnuBvdChfJrqrUnZb3aQk0q2TZDmTaSsBlu9POsNaXf1VEsful3w1C1V+bZg3GL6m/1ifG1YOqi2D7o5wT14RWcJWajCYPkKTbaTdwo293Acy97orN42UOZqOfdgPNMcYaOdYqz6JX4ldiAg2elutwJLkc1TkrjSeyHdpPaIPm+93ziyz4EtSF2cZQyW6hOV8YvuzgqiOg8ez43yiLYMKD57Yd3kz03b2b+TYEh95vr3PvxnwPdR+cIqUyNOLmbnng9AAEAAElEQVTkppIeCcV6U9BE7bsWZwH6YHP07/gAQXNZBZsR/rlRyIcOJU/K/fd6flF1nLvpcy2AYd27+fwD+20ie9w5Usb8Mk927NhIzunXUf797vdy70Fty9YejR4n7thOLn/jO3nh1A1duQds1UI+mvi7PPvpr/K33TvLrR/+JA+MmCyHbtNSXvli4/FFBSlIEgLbyMxFK6VaUanOVND8rD7t5dUvZ8mE+RvGKV/Sfa10qTpDfvppVbl8GXEyLFF+x5NEZTOyYRvKzsJBMxz+oHajA6Tzdz+joeKmaq9dieOMPwVwjhM4ZsyYwImyMKKBBMAXxsovBW8Q0cAEAJXKY5I72iGhtK1Bv4/PZNPhaFE5bYN2SQtJPQIRHP80O955jupo43CoIkBR4biL/JAY/YV2exI4ZKMUjVMI3gG/SLZBXRLVtbrR82aq3koStIiT0sSrQsvZBXbJJZeYRAlJGnW0tTPdS/baay95+OGH5eCDDzbGf/z48eb/6EPWL9/BawDf+/bta7rImbf+yiuveDryr732mkn2MV+9Iog+N5wWkiTa5ce1cy9zWUNhaYiv37maeS/Jr6DJ6LDAeZh55nYCjcQTyfMwnfnOBI/OKiXpSIJHO66wXV5dDZw/do6kEMkpipqSkp/nLJUDcphXrjLy4l2kYa1qkbOPUMigFJo40rq/OZRCNMpOlKRsQlCbwR4nUcH1oUvj7hJJungLybXjvH///hn1Fnv0sccey/gZQ4aULxxBr1555ZXmyHdB94wePdqA1STugzy/KBJc7EV8bGy5GyDhpNlFpsxdJu3/mOmZS8c5fisdr2p7snWQedkMLSpVmlzuKQClUtQ+tV89adS4iez35KSNPnPn/5QW5L13zo7SrlH+dKDbQnyIf8DB9W/1b0BbEi+lyZekhVnpcTJrkXTBVlCQhg7FRpAooggm7VEodGsCPHnJ55f1lerFRb4o67UjVOcEcqC7WLtcN75Nkp2FSj/P4QQ8/NLvBo2DKnsnSNzCekGH4rfynPzMM3eToF2G6uuR29EZ4zzLTLbAD3jO2mGPeAH0fFempgwdHeUnziBXhX+Grxp2LFZQ4T7pHG0Fl+1xUvZ4jjCMhnwePrbfQoBL9+osNwxyL76KitnC7rpH7xFncW0aA6DbM+kMnrv68xTKxaX7w3bfsx69QPO7e683a9dmG0F49kqjH3SEVNDcVNQ2Q3W8n5id12g3utp38pfoKuwce5s1onbFz5ov2Izggo2AmYn1AeaQ6T6jo5w6OKywRu1RfjpGhH97Md42rlNNzu2/iVzz9vfy2pm95LhebeW1L2fKC1/Ol35NNqzts/p1lPe+/U0eGTlFTu/ToWy9XbX/ZnLw/WOkZ/uG0m/TxjL0x7kya9FKKSmqIqvX5u+oroJUPunYuJY0rFUi381aIodv11Ke/OTXsr+d3ru9PDhiqqz9w1+pXa1Ihv9tF6m6fkMhuObL8L3Zw9g/P6B5lDYjaF6JPa3xapDRUIWO80oAnMfVEYXRx3hQfZorUOL3OvhOkhBBKHj9ih2YQLcCiGp3SCj9m4LoBAbZrtmeIx4WHIlKSOLoDBaAvLS6Wglq7RlctsPBv7nv3/6r9UbOP0m2Zw5oENmsRHvGRtKAkVMwJICvBO+cS5x7ya16S6vY+T9Vx9xbnckad8Vv3DODuZ5MFVovvviiPPPMM/Lss8+arl/A3wsuuMDoALoF3QS6XKpdSX5w30ge8Nqbb7657F7dcccdZu45upF7yJ5jdvqjjz7q+pmPPPKImcGuVE9pih/doGuD/YwjQRIhl3nmtlzy6reh3tetfbONZgX6FaU8DAKehAXN7TmEsLREocvsZDH3gMpE7JZ2h7kVgCm9Ht3mSdinbLSwQeTD83eSVvVrxDYzjY5gCujsZwpw7HSk7U4UpenlHuc6hyhJm5BJlFKYtUo3iSYQ1GbE0SWSREGV/V2Ic8Z5Za7qjUNYpxR3hPGjcgXOSUijU3luXrNw3fYi1IkKdoTtOAd4YZ/yfmx8WNDcKewpKvN5/S677GJ+pzS5d+68VmavqSn/Hls6U86Wve8u7UD/226byPE7ti3rDMgXufKtifLSZ+4dM6dtU0e6N14v5wxeWvY7dGyuI0hUfpqz4XMR58y9KIU1rfYWH5DYlXgDW6GJFfwmN8r6uOW/g3+Wh0ZOzWnEiZOynoIVbCFF4sTo/N3Y+27dygDlOG1GJiG5bo9i0W50fFbsrBvgEWbGecFmBBN7zXO/0W2sFT/FR1HYEvxefBsKQWjEsAuYsn2GF3j++lm9DOWu056w/wFNuT4F6DOJ3XHuZTN0pjSjx0hEu1GeJiE2uJxpXrjfcVLazOCH/arHjcNk6apoukrDdN2TV7MZYtAh2nVv5za4Jzx/YoQ4m1Zyoaz3eu+EK/qb9ct1UvRFkQbrmGsEPNaxgrnmcjLlpuKwGbkAHMpMxsG58Xw1V6wFFXY3utt5FmxGuGeGDiHHke3Z8XfsexRiA3Va1ONnjAhg+Sufz5Anx0yVU3t3MNTsxz76qXTquWGv1CgpkpsP7SZ/fXy89O7cSLZoWcq6CtvP7YdvLSc+MV5uO3wr+eLXhTJq0jw5fJtm8tIXv0VyXQUpSCbBUvdo30Cmzl8uDaVENmlSqww0P7Zna/nq10XyoEXNDoh+wa6b/PG/onKF0th0dCQ4DzEz+UbFczKNtYrKZijrVRyjoZSdBB+M743Lvi+r5HFG3gDnUYtNpcViwXDELSx+uuJI3pJEirKyWzeYVqzYgYndIcHfcBJxjHAcSdSpk8zGdzqNChCzwZKYI55J6NKnQoYETppd1UoTT1IlDO0sDqg9K1FBijCJJ5JWJCa9ZmwkJShCjAhrCeAxyQSaXb3FHuC+EiCRAEaSqviNU7JRmzB3lq7zo446yvyfLiD0G3NmvYBz9jIAOLPTSQ6gH6B7BzzQgh5+0kWuBhZAnO+hc9UpfB/zz+lIr0jCuiExQtIUUC1MBaGbUJUbRtBvuYjXXMEgNsMv/SDAahRzCL3EntnnVgCGvmGvY6fitE8vfTZDrnzr+0g+a8iFO0uzuvHNgtUEGMm/bAUgbp0oAAfadaOzinXGahA9h87SUTRJ2wSnfqaQiJ9OSmE7kWAXXkVhM5LsONdgyr7HlZ0OKw5Bp4QtPswFONexTXwG+zAT4OLWdf7mV7PkgK1bhDoHEvwUo1Jgg36NymZ4zarVhL12+27deo68/s3v8uyPG3/GrYMnmQO5Zv+ucuDWLaRacfIg+tp162Wr6zIXS93bt4rxw/Ef7h36CzvQ/L6oiuQ8gsSWAyNgNwkj+pwpYqNwmaIs7dZWynpNwkdFcxwWWAEkCWpvbIpD9gJxL/uS/wOi29dHrKV7LUqb4Vds+l1EAQ+ldcduh4kHCzYjvGgXD+seXzSXZ++n45x1x7Mm/ifec7IA+i2icgPPD7qvlMVh0Emdy2IJfELsBLobG+W3MNnZTWXbDM4PX1XnZOeTv+IcJ6UsTX50uc4+zdTMYNO1+wHNeW3UIz9sn0cZYrR4iBgLvafjIbDj5FbIAfh9/kkC5h9OnCPnvfhNxveQ2+Agf0E8ie/Dc9LRdIzHUfsVBfOWW2dhvsYZPE+Nt7WgQrvRyRXzf7s4S33Ugs0ILtxjv5hDlFTtug6VPZYcAc86214uKaoq/9pvMzn9mS9k/61ayFat68nBWzaRJ779XQ7bA4Ct9P3d29SX03p3kIv/N0FeOaOnAdORbdrWN1TtV7450cw7P/PZLw1ofsoOjeSRce7jRApSkChki5Z1ZO06kYmzl8hh27aUx0ZPK/vbP/boJHcNmSzLV2/YX/87fQfZvEVdT3ZNiswpisQeOsdagZ85Y4QobQbYE74+n4/9yjXO8BoNBaMVgv0PMhrKryyt5LmpSgmcswhZECwQHFsqSOIWrdRk4bHhogbNNShBMiWz+Js6PlS7ATrgPOLoA0pr9QwHryXxRRCexhxx+/oIDnHkSUx5zYJJcv4l94kuhDAKi6QMhw0EOYMxlG6mxJNWaVM5CxiQxkx1FdYQoDmBe1xzyfwI9wQHn3uqM6rs6i07eLf3SZoVv0HWXSZ2CvSL8xr80rayrxVgY4bt/vvvv9FnqYElwPzf//4nRxxxxEafA4Uvwfd+++0nFUVwfFgb/MylQySfxE/CLIjNcEoScwjdxFkAht3CkdVrpfhBQd5c5tIjP/62VA66PzqAwkkZG5co3SV+jZ9Z835oerFPStNr09hmusdKHcqziivJ5kc4Z6XXYhyFl031qvjNxWYkYRec3e1O4DxqRqOCeAv3n8A2zJ5lf1EBTgFbthEfbnvp4v99Y4BzN2rdbH41Ab8CLwTOXj5DEJvhx0bY3b7duq2TgQsWyHdTZslpb7pTnv/rre/NofL4X7eR7drVl+IYwEnmZve7bZQsXpkZvHrrrB6ydNYv5r6hXzQZcPfQyWWvef4UEjG1NxpBQhI6FxrgpIVnSjxIEZuOFwNE4dCki3OGrl5fJjrnILJ67Trp/u+hGV+TK7jEtXD++IR01WLn3K5PmVns5xdnnJFJ3Oh38Y8QxtD5pd8t2Izggl5Utir0Hb5Prs85my3Br2ENAnKyRgED3T7DL/OUG3iO7PXYT4YhT6+PnEcQNjFlv+J87Q5bhGJs9IkWGqSVX/IjTpYm1eUArTwnpXRnfwFKYdOzzT61k/V+JS7w3K14iMYDnhE6j+uhiIhnxfWTY/EaDxEXYB6myzzTveJauS5lGSKPxbXiE5ETjqKTMIk4I67GDZuZlPPENvDc8VFZ98SGH330kclBkpcNI8OGDZNbbrnF5A9pJnr11VfN6EAVRv498cQT5d7D+MD33nuv7P+cx7nnnitvvvmmuQ+HHXaYYUqsLCNHgo7tyCQaW+DDZJqr7iY9OjSUPTdvJle9PVHuO7q7nLFzazli4hx58pNpcuJOGxg1zuzTQYb/OFduHPSjoWm3u9a/mr5Ibhv0nRzfReSpH8SA5hcM6CC3f7zBXy5IQaIQRn21bVBDPv91keyxWVOZuXBFGWh+TI/WMmPBCrlt8CRZs650T2zeoo48d/L2roXZGhOgA+1RHs58GX43NoRcpPoFzhghrM0AL8IuYa80txdlnGGzfVJMM3LkSKP70a9+R0P5laWVPDeVN8B5VIlXHEESqQhAiSaD+BlXcpeFp3OOAJZIkkUlNqUDEmTDcL1agalOstIoAsrymToLLs7ugUyiVT4oIxSWW4CYlCi1TVQVt04gSBMz3HuAUHu2r610eS3gCOsKgDjNyh29JxgOqnjTBM113jz3RA2bV/WW7nk1OrnQZiXVcU6xhZcccMABZqY5Bo/kBs+E2eQnn3xy2WsuvfRSE+Q8+eST5v8EP2PHjjU029w3Xo9htgOVTz75pCww4udVV11l7tk//vGPct/P7wDO6W5PS1c4JdtaZP+QuPHT5RdU1lDimJJkS5jlYjPSmEPoJuhHEnnoR7qZdWafUvBRSKS6057bE/ec8qBUsVGKso9ERXdp0/SyVpw0h9hivcdKm2/TxNsASxoCgAh4T9Kze/fuvh39qGxGEnYh03dlsxkF2VhyWatBE1w6YgKKWh3bhP8Xtkuw101D5dm/lNI4BykeBrTQ8RZebCVBbIbaCABz/MIgQfsujRrJhG02L+1AvO3TjO858ckvNvrdQVu3kF27NjFJkGb1qmekeF+6co1M+n2ZvPH1LHlm7HTxK5/8o4/UrVE6d5LiAGU78Sok6tqitucIkrA0wElLNhYT+/qU5liZS/AziV8UhMg2Q9dLJs5aIoc+6L0mSIZdvk8XiWKkB0kvCpKVgc15fdk6TZRSMco4Iyj9LmsKdgDiZi2Ay0a/W7AZwYW1AlhK3IlOwP+J4hl66XFtwmDNkcPyopYO2qmITVmyYo1sf0N5Zo1j31wg9/dfHJiNi3XPORAPjhgxwqxJ8l/sD3xJYi8dAZHWCJ8w4qbr2Ftq99jb6Ehe55VX9AJ6G9cukeF/653xNUkKMTH+M8+LOIv/o/O4ThL5diFtmPh58txlsu89pewGmSQTAB4GNOfcdU47oDnr1I15K8pOwrjijCQKdPlu4mgOZWAA7CZvxN7mIPbcd999zag+v4yg2BtiM/JUhx56qOtr9t57b5NbUnH6Wccee6wB3T/44ANzXowSPP30083YwnyVIP4d+jOKjnPWPDoX4Z6HaUC7ZO9NZf97xsjrX82SAR1qyYmbVZHbB/8kO23SSLo2Ly1UKC6qKrf+ZUs59IFPZNu29eWg7i3L1unhHVbLVVNWy+yqjeWc/vXk7iG/GNB87zbr5L1fK44NKEj+Sq1qRbJd2/ry64LlMmvxSjlxx7Zy77ANhRmX7rWpWXd2UfSth20h+3RzbzRh7xHnsX8yjfJwjr1At2E/NMajsFX/HjQGwsdE36J/7ZGHceAZ+rm81y4K0G504jnuBdegcUTQwuillTw3lR8ISESCkSehi7Ou3cIsAISFEQfgQ0AF8EuyBFArU0dHUAk7m9ZLcHzZJCgG7hWALt9BIgGxqamSAMeUJh6lQWIqzW5QFCDnQoEBjqNfsem4wgRjmnhCMWknOuwAOPY2QJxmBwqAeZB7ErWw/kkCU+lvV4MFrfgNS5uVROCSbSbIXXfdZWaWDxw40HSaUNxxxhlnyL/+9a+y1xBcsHZUuN5bb73VGHWC4wEDBsioUaMM2KVCMc3ll19uKs4w2gRGTz311EYJFCja+WwbqM9X4Zlzruwr9DLARbYuv6Dyy9xlod/7+pczy4KNqKnaw9oMpYXEnqXN+kESWCkjtVhHg3pl8kBvorMBk1nbCkoo3fink+fLCS7ASy6y9xbN5La/dJOkhWdDQpzEXVzsI3aRndIcamLJpulF93LPg4BmcQjnR6ABSEBiLJfEbFibkTRVu9MGVfY5UvkmQYAKBV2V6USfU5DP+Nd+XeWatzd0YC9YtlpWrSvt8PMzaoh17GRZcbMdfm1GVDZC9bkmvjnf057+QsZNz25TSehxRC3OJLwWYHPvuNZM8ZBbR7w9giQTDXA25qkkJAyLCfFKthm6mkTyM1M2Wwz14DFbS+/OjWMb6eEUr04TYn1sj91pQqI/ijgjzPWgT9Q3ykS/y/dzTbnYjGzdg9yDK6+8Uh566CGTB2Fc3X333WeAqorcPch96927t9FbnH8UIIeXHeC5sUbJzWQDnFWXB2kKqVOj2LUo68wha0WGjDN/8yO63jmHPn36mAJ79j+xJrqTv6NL8CUrEmjuRW+NruD68I8BDdlj48aNM7rb1uVb/XtYxs9T0DzNrnNbiI2Jk2Gk0Q4xrscu/rLHDmpxlJ/ir1y7zP1Qs7sJ6w876wQhsjFveen3qNhiwsYZSRboqrDeYbrgYDwg64F7QdPFM888Ix9/7O/ZArJzZBLsp3MMhQo2jO7zTz/91OT+NBdGnuo///lPIHaMfJUoqNqVAY59ybPz43O5ScNa1eTqAzaTS1/9VrqftLV0qLNOTtipo2G8+t/pPcu6dds0rCm3HLalXPDi1wZQ79CgpGwU1SMn9ZJjH/9COjSpK3/ZrpW8/NkMeX96FTmnb3u5e9iGOdMFKUhQ2aljQ1m4YrVhNgAwv3PIL3LvnFLQ/G+7bSIjfp4nt374s6yyGptGXryLWddugn+Mv4UuzhYT2GLnJDXGCxsDYa90ljrjHWxdHwee4ZZPskdD4a/raCht9CQOtotxi7LgIZU9N5VXwDmLMSzAoQC2c6aHXe0XpfB5BAlK2aRJpKjmldgdIFGA5vqZ2rVGslkdZX5v09TRlao0fBxxgLeamEKhxDlDN0jiiGILLwcuiPgJfJzztVC6AKLKlsB9JzhD6aZBcaaFBDjMac6bVwoVFHGmarAwFb/aPZYPnYVUfGdKHhGw33777ebwkscff7zc/6kg1/XkJf369TOd/Nlkzz33jBx8jsNm8Ky4HmWwQI/RlRPVDCmVqfOWh37vP16ZEAtwHtZm8B50PsEXujjNJKbqYtauV1CMDtC5PZr0OOX57+Wn+eFmzmeSu/ZsIAN6dk8t+ZcW+wj32EnTC4DO82FdYatYZ1HS9OZanRuFBLEZ/DtN4DybzShItHGGX9+e50ISib0KcG37tkHodY/t2bYccI4c/PQkQ63rJVD78t3YPfaGc804bYdfmxGnjSBx+uQpvcq+h4D9geFT5LkJSyQO+fry/lL0x8xGN+Ea8ZvQbVF0S7rRAOOfUAxFHJQmpTvjsYj5cmEx8ZqhS0yOL5aJHYYE1zZZqNlHXdxbGtQqiWSkB5JppEe2ThMFlDJ1miBh4oyg4lbQ60a/y7m++OKLcv311xu7TryJb7zzzjsHii2zdQ/efPPNcueddxpwhQJHCn2h3WUNaA6hInYPItpdHBWtrtOW2MW++L5+2J5sHyVoYfe4i3vJDv/ZuBMYQD0beO5mM9Ad6DHWHzkm8ijE7HSqsv91TUZFiZ2kcB3oDvU3udcArtx3cjQky/vd528c5Dru2R/Xn6npIm7wnGdHsTxrzo1y3q1Y2a2Q1q34K1fAPNNnXLFPFzm6h3c+StkaWIuAEH7WmpN5y6nfWbOq3wE3otDd+RpnuAn3A7tHo8Zll10WeS5lyJAhxnfgme26665y3XXXleXTR48ebdamgubI7rvvbu4HbImHHHKIVPQ4I1fMgPwWOVL2KY1fFLjl8nm7b9ZM3u/6m1w3aJIc3nydnLPrJjLip3nynw9+lMv26Vr2un6bNpGTd24nZz/7hVy45Wpp33JDw+LDx28rxzwyzsxD32uLpjLo2zny1NhfZe+26+W9aRVL/xckfendqTQ2+XTKAjli+1ZSXHWRAc2RRrVK5JRd2sndjlnmdJ4f17O1pw1QxkJsF/FPLs1x+NEUCnJkioE4bPZGCuvJZfmxV1HhGfper79psSCHsxgXjHX16tXG5qOj+ekWs1b23FReAee5JJYxHm4zPXRx8PDDVmE5hYVDlQoJXBJjduI4UzegX7Hn4UQFmut90vnQNiU6n2/TGGmlKfcUx1ErTXFu/NDiZhNNTPGsCBLTcgrt2epR0d+GVbrce86FnzhAACUEoHRa66w9ngFrLe7Ak4CBJGlUhQRhhTVL15aTVjGsOKu37CNbZ2ESM87THFNQGcQ5pkOTdVEVM9nSsn5uM7bf/GqWmVkbRtxsTFibwd7ClvEeWD+ispG5JHKydTN+P3uJHPJAZprfXGTUedsavYPuS3LGuxetLOs6TfYR1gbngO9A4hyH2qbpzYWiKqhkqs6NQ7xsBs+GLit0C0nFODsLvYDzgs1IVvxQKlJQwp4l4HQb9xPUFn16ST/pcWN5YPGpbygidPfb+G66/LzG6rA+9fv92owkbQT3hzjjisOayeWHliYglJmJ9Y5+adS4iaytXk8Wrq4qX/66UEZOmi+bNa8j+3RrJh2b1JLa1YpC62x0HPeQglb8cLfPYQ53WHEyT7kl6ZMQZQ+g4xDfWqn8o56hy9pRwIV4xu7QHDtrrfz91e8yft6EK/rnbH+J1/ELWVv4Frn48l6dJlyfdprY3YrsFb9xRhQ2wetcGb0E4A0wgQ098sgjTdLuggsukKuvvjrn7kHWE0W9sFcddNBB5neMjCKR+Nprr5muxcrQPRgVra5tB1gXJFexHVrs6/cz/KwDLxv11nHtZeqyYhn4ys/l/q7d6G4AupfN0GsgwYqN0FiW/a/6G/+eIin0O/s/KhAyiVF1FD05YwHTbX9PKVujl3CP9396Q5flltcOKQcYpwGe6wgZ1oHfIji3QlodDYE+wS4f//YiX99/bv+OclbfDax3UVCz2wWL6JywcZubftfOO2JC7h2xqTJzRuULZYszlD017jjDTZxxRpS5MGjaKcLC18IfAZjHxgCY8z3koNEXTh2MjeVvlUHC5qdYi3SD4lfRCKdsQVHku/5vn66y/z2jZdg6kT2riNz2ly3lsAfHyrbtGpSjvD60a00Z9tUKefynmvLMgA3x+CZNastDx20rJz4xXi7evbNMnv6bfL9wrYz+raoc36OlPPXpjJzOryB/DoGSHWr2cVMWSJ/OjWVg3w7y348mlf39v3/pJg+OmFIONC+qUkWGXrSzNKrtrZvxS7AVUTAWBo2BtBAXMB3MR8fZBLVXYfGMoD6jWzHu3LlzTcyq+T/tRlefLqrc1A033CCvvPKKAex5VhT73nTTTaaQSwX/429/+5s8//zz5l5TrHvvvff6Zk/70wHnmtABFOeGulU+sBijBE7sbhJobJyV62Hos1R0hoGCIlGB5s5ZfdkS8DbNoFaa4iQDMCstrs4CCqpw/CSmkhDuNZtRg9U0QUsSGEqzoxV73NvOnTtvNIuJwFPvv1LwRSnMtyWoshkJ0hCdO8LaDUKh4lfcKFB07zmrtziXuNcpldJJd25W9jEdKnEA55s2y62aDuqrHu0bSIv6NXICznOxGRQwYT+12jHNrmpNujkTOdMXrJA97hwd6/e/f+6OhnoMUTrdoCM7ohYtzkOwT2mwjqhQNUuCzC5owD/g/qAnNbEUlqbXr2ALocfUgrukfQe1GZqwYP9QSKC/i6uzMBNVe8FmJCeZ7IgW/nDQlUaiPehnuEm9mhvv+/d+WSUrVq+VGiVFG323nUDz+n67Uj2bzdAiV/zRpG2EnYCwfWFikXnzfjJrv2+zpnJYtw7mNbnqAz9sJ8jxj2dm8QkiGmsp8xS6VKQ8mEyCIsrxWawXu4g6TrCeeEXZYbRDk5grW4fm9u3qy1Mnbpfz97vNuo1SnJ0m7BfWJ3EU95i4Um2h+jVecUZQmxEUMFV2mAsvvFAOPPBAs69JOkUhJAABMugGVGFP9urVy4AgAOcVuXvQqT9zHdOidkDHavB55LCCFEfa8WsQxkF8F7VRjefNkwd3LZHTP1q90esB0OnaOnHn9hnjDJ2ty2vIL9kzivk33fMcyibC/iC2T2M8YBBBT9FAgO2hEM4WP13VH57a1Vzr3b3XyzkjNtimIGsnavCc77aZY8IwnNjFXxOW15PLB0+E6ya2LvNs77OZdlhnxG5RxQbodwqoObSTUHOhNLV4dRJGFWfwPRRmJRVnuEmccQZ2QYVxAdhonh9d6Lvttpv8GQS9F5TFRMecso/BIZyFDbnmu+rXLJFbDtncjFA6avpC2bptQ7nxkC0MW2KXZnVkkya1jB1hfd56+FZywZtT5F9vTjSv0T2wZau6cufh3WTg81/Lge2rSJXiEpk4d7W8/Nl0ObhTNXnt541tTkEKguyySUPDCvbplIXSq0MD+b99usgVb06UDybOMX+/ZM/O8sNvS+Wfr35Xjpb9mv27mvEAQfGWOMUZA1F0BusSOAv6HP1KwxA2JGwsFgTP4HVhWUzswrL2f8Ss2o2OPXz77beNf0HOMIrYYujQoXL22WcbX4VzprAK9lvyxXqviGf43pdeesnEHOecc44pxho5cqTEJcUVlUJRK0E1EMsUQAahR8wk6vB7dZPod4XpUrXpr5CoNjOVHwQ1LLIwdBTOSlOd48DCZSFr9aWfJLnfxFTcorSTFEEQ6OVKj+hWNey3cEILMaiqpIrG+R63WUzcf5RU0PufTVDeOEMAJGl13yNcp87oBDSPO6D2okDh+9EzWukbV8WvVnEVOs7Dr1ucEPYP+8S5h8IEJtmkpCj359/vthHy3Ck7yHbtvKl33US7BnOxGTqLh+KoNAuY7KKuWm02l563xddJrnJE5yrSr+WGzoEmdUr1C8luiqnSZtqw5+vGkez3K5po5XCjc9S95UZRxZ5Uiiq1T7mw1aAf6TT3spNJF9xhh/E71XewbUYcc26dIEnBZuQPVTu6C3+SgBigiDXvJRq0BhG3mbTdr/vY/F59WYLXbN9tU3/aAEg24AD7gJ1Im2LX9oW1YAc7pgVGWhUfdG64ref8zG5nvp7KcT2zUyoHTdI7gXMKZrHV2snMNYaNWXT0Efo0aRYT1tqUpUVy3EuZO8X+e1An2XPrtjl/n3aVkPQnKR93goz9wf7jIPnvpDfm7wqysMZUn4S1GUFHSNk2g/cRW0Ul2v3nLNrh//q3itw9qDZD9Uqu47t49vi+o0aNMtfvNlbDzznZDCJ+AFN0JjkPZZjQIlxsycrVa2Xr68rnMW4Y9KM5RvxtZ2nwRxGXfd3kL/BV+Tz85mx5OHukg85Ft/VbnOMBw+RCeC66Zv0W8dogL3ku83xGbJh9/u/nh8iB3TbkbTJ1nUcJnmMzNdZC9+eSL/JLx67y0embZ7SrXp/30QU7SYt6mdcCfhdrUP2UpAr5lIXLyaaiTUW55K20OJecKXGGggRxxxlp56ZgSuL+ce0A5/hD+KG2sH6Jv9KM0eOgavebM9ZxBAByMCs697Ffm5BNenRoJHu0XicX/W+CvHbmjobC/dgei+Sc57+UK3rVkNXLF5uYg7Vx39EN5YiHxsqdH0+S83ftZK6F/VE87xc5r3uJ3PP1Wjmnf3tp+ONcGf3LfHl78ho5rltNeXpC+JGHBYlWGtYqkfnLki1m2LDa15tO8e4tqkudWjVk3LRFsm3b+nLTIZvLeS9+I0N+pKBYZECXxtK7U2O54+PSrnMFzVvVryEvn75DmY+Sae+QR0qz+YL9is0AeMY/sGeJs6c1xgvbGJkJz9B/ExvZY0DC2oySkpJyPp3aKYpkTzvttDJGqSOOOMIUfwUVGKqc42j5Lp5h3759jQ/5yCOPmFFPsGkhjz32mHm2Y8aMMUVFlR449ys4EwCHBKd+kv65zqWyK3UJDjKBvroAg1SD29UhUXWZIzgXVKVxvl5AfxDRuUY6+0+r6zVJjkNpz7Jyo+FNkxLd7uTjnHINHjJJNwclVyaHn0IML2rNTLOYuP9+Zwn6payPkrYxl1mEnDtrJY0qdDUkKGWtOOd+cp/iqvglOKnMM0HiEuwASTfWrZdeiaPjPCo5+pFx5me2uYJeXS9BbYbOUiRZhS2Lk87GS5atWiv73D1G5ixZ5fjL17F8X+emteX1M3uU3SO7c0DHYeCwkujG4UozIEcPEBSzltMeY0KXOZWxfhlZvCiquM/YF5uml+vz6x+RnMVRxo9BF6cJmuu8efSNDV65VfxqsBKFzfCiai/YjOTEzY5o9Tprm47BbP4kn8G+CCpvn72j7HfPmHK/2/W/w+XfOxabtUQCze70cxMFfigQQnQfOtehdjrhs6dlI7KJXbDDflMQRqljFYRB32QCYXgvhTDoqTDMU5fu1Vnilh132klWLF9uro8kMvR4OndVKY/96EQbOOFakxzLwmxfaIqzyVMHNpHF8yfJ0KGTylHiBmVc0ZEeSXWV+Ck6Z42yzrCFxBU8N2chRBCbEbTjHCnYjNzEpkfPhQUIHwJ/kyLAXIqS/MQ22tXOmrJHWDnZq6qXFLkWaSG9bx1lfm7Tpp48e3JpwYWyDPnNX9jCaynE5HAbD4ge1lxHFOMBg/q95Bi1WDTXmd3OPfrcT1Xk2B3rlsvbvH18B9nvqcmen63nEBZAV+YN1mzYZoS169bLVtdl1+HOsVe2znOOHSRP5iV+rpV9RD6PNURBXZLCPnKyqXCtrB/8QoAP9UGCdGwraK6xl51LjTvOSNtmMDoGIEkZm9BX5Emx5Vro9dFHH5lrB7StDBKk2Y57w3rHp8B2uD3bqPJdfPburdfL3Fk15LLXv5U7jthKztiltYz8bqrcPnalPHHqzlKzRmnM0bxedXnk+G3l2MfGS70axXLYlg2NzWHtHrdXL9l6qyVy5nNfmRENUG8P/v53A5qfP6CD3PGxt94rSLTCs1m0ojwW1qJedTN+irwcs8RH/Dwv1ttevbiq6SbHovOdjetUk+3a1pMFS1bI59OXyOYNV8rxndfL/d/OKzuXpnWqydX7d5XbP5pkjsUrN1zD43/dRnp2aOg7j4RuiQIPCyNgNpyDzYyis8SVkQcboo2R9tinsMWETpvBOWCPsZdR2owqf2A2FJ+/8MIL8vTTT5vreffdd2X48OGhgHOnEEMhmuvnXoLp2UxXYJPcT8D7AnBuzebBuPJw/FJJ52JIWGgsYhazXakbJX2W0iZGCZprdzfGlU0ad3U9iQqdZYXTh6OoSQ/OxY2GN2nhHO0OhLQ6+RDWE0UNYR1++/4TtLrNErQp9b2uNQxAEpfoLELOHSWb5vNBQbNWuLc2ZXNcFb9UwiU137IyCWub4qlMHVja3RG1vHBMJzny2fLzAcOKJqsmXrVbVhvA37ke7XrxazMUJEBHJ1EgM3vRStOhsWZd8O7OXKRLs9ry6hkbgPJMAC/7Wztx0H0kstCfNiiRVNJd6QZJxOQDQMw9cSZucqXpZe3hw2Gv7KDAa//qPcFGBk3OxgWac08yBTF+Kn6D2gwvqvaCzUhOnHEEawF/hUIbv0UuYdmvOruMBpm+YKXMWlVLDuydfW6zxhnEAug5/ERljVJdx08+J0kbEYVw30lSc+jccM4fn5ZrIebg+qhUt0EY7gc+OEluPyOskMlzl5X7fxL66NLXvpObDtnC+KE2pTvXqEWm2SiPAU7Ut06CxcmW58dNl2ve+SHja6D+fGtgaSJcu1GdILOuUXRepvvO8yShoiNo0mZKcK5RYj7OUZ8hBSqA7Ha3oo6IymQzgrLaxWkztNiQsQL2mAr+T65GX1NRuwdVbKrLMMLzpPBFGQiIXXKRbN2F6j+x7ty62t3er0W8bgD6F78uKgNxoSDH7nmNJQkiXuMB8cV1PGAuXVh+hPtAro97NnDYepFh/kdyZAN5nV3l+LKat+E6ud47d14n543KfG1hus9VH5IrYg0EvX9Bu8uRCVf0L9O7gOXOUSsUbp870vs8/FyjsqaRKE+TwRLhnuqcV3Ku+CB6rex34hvV75nWsObjtBkgk66OI86I2mYAVpEPVsGeA/wq1f/VV18thx12mNH/rIl//OMfZq0wpxZBvzAHne7F+++/3/g+UPFC8Z72M4+jGCtTnpZiVtYG9yRTTj8qhl32b3FRVbl2305ywjMT5PYPJso2JbPkn72byNUjl8htH082s9DtGOWhY7cxc82nTVonh2/fugyghFXxoWO7yxnPfiXH9mgttasXyRtfzTag+Tn9OsjdQwvgeRLStXkd+XTKAlcwfft2deWzaQvl4O4t5MOJc2TJymiajWoUV5Wqsk7Wrq8i1YpL85UA5t1a1pU2DWvI3KWrZeiP8+TArZvLObtuKn994nP5au4Gn/28bmvlo1lr5cKXvpGVazfkEk/Ysa38bfdNpNiHTlOG6jTzSOqLaaFhNkYedCc2xI5j1YaEHU2GXeI+6KjkOG1G69atjR4/5phjJArh/C644ALZZZddjB+DYCeJnZxsmDbTVaXvOM+0EHCmqZYH/KQKLYghD2tIMlXqeokCGX6+L2zXYCbhXHFAqGb1QzsYlXBvnDSKBM0oCgRlwGbidWl0ESslunbLRx18FVet4hsgQhGStIySEtgLpEDhsnfcOnCUdla7bdJMwsc9izAK0DxTxa+9l/V17Gc/1Vu8n71R6B4MLqz3bEVRrCWC9qhEAei5M2dK1LLZVYPNz4t26yRn9O3o+t0U/hCMsm8VEMhG3UrACUjAPotiPIXKvKWr5P/emChD/6BSSkMO366VXLVfl8D2k3VD4oW9p/bdpgBOcg4jyWO+L266waAzEKOizLQTS0r/x/rFRwBId+ugVD2c9j3hfLHX2NRsoLmbRGEznEmVgs0IL7l29/H88K91PIhz/qmfzwgjbt2Al3w0Xw7onfl67HVm04ly7soapcwbnB8HhYsVATQPAsKQeASE4doJtPk/9wM957d7dN97PpGk5c2vZxvg3G3uqt1tr5TH2ummncxaMMw9SYKyXGXBstWy839GZH3dy6ftIFu0rOvajaqUuAoucY1KZ6gghK0XlYpR47x8AM3dhOdiz37WbkUtKuO67E4TN5uhdIv8Pu04AxvNehw8eHAZUE6ikNnlZ511VoXvHrTXETojjA7XsUTEIlz/2LFjfdPzhslt4Vvh8ytI6zVaUH0S+++mYeSK/vLuhNly8SvlR0eomLndI5hvPTHSOdw2U4PuDR0bwnnZ4+ly6fq3BTuxzY3BZ2KGvW4FwJ0z4GXUMF/vRb6+vL/p3Msk2Hd0P4lkvyOOZi5cIbvdkZ2SPhtg7jVqZa/HAFKres6F57lmE5Li+Csk0POREUd9EPJHWhyEDWMN85xZw6rflSlIi2rYt8QZQeeK52Nuaty4cTJgwIY9ctFFF5mfJ5xwgtx3331GPz3xxBPGLrDfmV977bXXlmNPeuaZZwxYDnU75wvQfuedd0q+i1+9rs+DdeLGAmQ377Eu8A0ySZQMi3xWg5pFcvUereScV3+WS/q1lKO37SYPdFxhqNnbN6olx/VqW3ae9dbMl1O6rJGHvi+SzTarK12se9C9TX156sRtDXjeq0NDOW2XdvLQyKkGND9y+1YyatI8mTY/97nIBXGXtg1rGJzCKTMXrpS/7thGHh89Tfbbspl8N2uJ1KleLEft0FqmzV8ug74tnSvuV1o3qGFYBSgyrlVSVYrWrzF2eunq9VK/Zon06tjQdLiPnbxAZi9eKX/ZtqVctNsmcsTD4+WlzzbkVF84ZXt5YfwMeeCb2VJUZX0ZaN6gush/9mwqm7apL1V8jELAf6BYxy2fn5QEzWWhDyhw5+A9+Cfaja6jyWwb4scP0m53Bc3z1WZ4CbPOsZ8jRmSPKeOWvALOMz1wAGweBMFX0OR1GKr2bJW6uVQBK62OviYq0NyumE2zu5vnQ9KNSnruHxsVxzEojWJUooozDKWYX/nq8v6+KnPtOeJxFTV4Vb/alUv8jXVCEG/Pak1DMAoo9KRmEYYFzf1W/KoBUqOTjQKF54MUZpzHI1EGEqxVdAlJMGzRxF1rloHdUcptg382h8oO7RvIXUduJXWrVTUMHyRalOEDvUqQriA668jWcTgxnDN7HLvg137i3H7yy3wzY2jFmtwrmKMSv9RMfp4j98kGTpwzu7OBElEIiRIcQirJ06yi1w5MEvJxjjHhnmODOAgitIPSDgpYw9ht1no+gOYkdsKA5lHZDF5jP4+CzUhe9JmxV7UjO+jYoVxsEevjmUNbyLGvlK+k7nbNR66jPrLFGTZrEaAXfg/nhy4k4YlNwZ6g65w2paKIky6bOAQ/mDgJ4dp4lsQiQfXdfUdvLUnJlHnLTJIyW7c9tl79ApLw6CtsHX9PyrdmzWWi4LXFD/hjF2WzlnmG2AoYQLg2TSARP2Cj06RiDCPsOU2Ace94hpm6FRFiN5jclOIxiTgjU/cg50E3yHXXXWfuPYm5K664wuy7gw8+uFJ1D4bJJ2nhPjoV+kidfcuzy6UY082e6Gg8DorQMwGLuk4UOHfajH26NZd9t2yRNbdh/z1KEN25N5wjlnLxx/e+e4xMnReuoDrKa7SvNdu8c1ts2nQ3wFrzXpoo99KHfhhBorgfg779TS58udTuusmbx7bzNXaQUTMUGFHc5wdkT1vY33YnoY5Y5DqwYdpJiN7XOCMoaJ6vuan+/ftnnPM9aNCgrJ+BfWGGbWUV7r1XXEC+HOwD8du8F2W+i3OjwHTV7NlyxR4d5IaPf5XtN1tqOpfvPbq7nPzk52Y29l6bNzF7koKWI/pvK9tvV0UGPv+1ySEBwKps2qyOPH/K9jLw+a9k1qJiuWq/rnLV298bgHTr1vWk76aN5ZmxpaOkChKt7L9lc3nrm/KMP8i5AzrKIyOnyg0Hby7XvvODbN6ijgzo0kTGTp4v46culHaNahoWx6Z1qpvmQJ4pYzuYL7567XpTIPvL3GXmJ681XeUi0qZ+NZm+YIU0rl1Nem+Knq4iMxYsl9e/nCW7dGokV+xDs4uYdWIzDrxyeg958bPppvOcmeUrrdzjcydvK21qrs3aFKhCXoliRWKjOJiX/YiO5M0FuCc2Ja7hsBm51A/SsU8cbqNt3EDzfLUZbkKc8NZbb8mwYcPKPUfyFqwB7rHddU5ONU4WqyrrM1m1hIVgxKnwtWqW5GlY+lKtQPe7aFH+BOB+Z6g7hSpqL5pDeyYNolUcuQrJbu2QA5RNcn6dV6GDW3e30ihysPm9aBSjEtYPiiUJxekMeOxgQoNZZQJwUkskJSQrqN4GCGLNKA0azyrOjkov4RzYnzz7MDRicYDm7PsgXWRu4qzestWskwKFBBj7BCc525zSgmS3GU5htAfJcsDAXESr9wnqSULrXlm5eq1sfV1wOrs4pHrRemlVu4qZW9SyYR0hJ/3zjLny67IimbMsP+e8Z5I61Ytk9N/7ZE2uBxGdS6w6x29RnJ3QJimlxQq5UCdhDyh8YD35HT0T1z7SAB37FFUnT1BBT1Jcxj3Bh8EpDkLTG/W54DtgF/Dn4i7yy2QzCBK5D+rDFmxGvDbDS28MHTrU6A3njHu/QmwB4EQSLAw7Bnrnme9Wy/DZG/tJNngeJM4AiCTGskdE4CeqruNnUnS5cQsBts6IBFDSawTYUj3D4ca+5AQY4gBPkGE/zjXzIJ0S9Ps0acQ6xc9Ogj3lyIfHydczFmd93S2HbiH7bZlbp6BNZ0ich3+GzWAdc434aRUFPPcSu1uR62RPs06xSVwnIHVSccaQIUPKdQ+q0D34+OOPm+++8sor5cEHHzT7rHfv3nLvvfea2FuFayEJ9uabb5brHsx3ti3bZtDxwjWRs/AjxNvoV2JKLejgWb3//vvmfuYS8zHHUbv9Ec6Rwi7sBDO62QPZruvDDz80MyJtRhWnzdDi21M/LNUjfmXbNvXkmT9mokct2GPNJdn+uNfeD0M57pRcdX6mHJEte945Wn5dkP/dl37vR6Z77/wMe+wgNkxZYjjIH5JHI0YJWrSYj6KMOFwT69m+Vmx0HHFYITeVf3HGxx9/bOYD23lhzUeyDmAn9ZunIFZEh1Oolotw7jDIsAZ1jOc9QybJi+Ony/On9pCW9WvI0B/myHkvfi3nbltDutRdY/al+s6fT1soZz77lZzeu52cvHO7cvp46ao1cvH/vjWFS2f0aS83DvpJFixfbfJV/9ijs9z4/oYCvTikZklVWb46f5pBkpC3BvaU/e8du9Hvt2xVVzo1qS3fzlosNxy0ubz42Qx57YtZslXrurJd21IMC4AcoByK9XUU2UkV8wyrVqkiy1evlZWr15nf/zhnqaxas166NasuDWSptGjeTOasEBnyw1zp0Lim8fn32qKZPPXJr/L02F/LzoF85aPHb2N+97/PZ0qzutVNt7vKrYd1k723aFpuDSlzofrGNp6E/sTPxRdiXFMU42TCCH4JebWwI3n9CNdp20tiIGXlwUYqC1cm0Dxfbcb69evl3HPPlVdffdXEH9xHW3jmXOdzzz1nYgmEAh6+/08z49y5KahupqKCpHIu1QN+qdqV5pzEFtWMfgMjp+j8MbfPj5qaHSF5wObE6KIk8mF2t1JSOK8xG41ilMk57e5OG5RQSnSuEwckzSQBz4PkLSAA9Hjaje7sqNQOjjgFxYpCJxGEY5hmkitK0NxP9ZZ2LHDNmvBLC6yqyOJnzYTpEHFLfpGEdivgql5SJN9duZtsfnX0nedBZeXaKvLLIpFfFq0U+dVOclUM0PzD83eSVvXjAyjpWNG5xCQ/g+gc9CG6gcM5Z5b9boMSfmYO42dg90hwplVIZY/JQAfh96TtP2Cz8WMAt3Quoh+a3rhAc2x2EgVNXjYDG815cM08q4LNyE3C+Bk6Iw1hj4Rlm8jGRuUmSrXNewHsV64c5QqcH/PIOHn2lB0CxRl0PeGbEmgCxKngi2iFu3Zqo+vYE0o1GjVdbtyiRbR2EgPfE59P6cCVXQT/WGMRXsN9zLUrz6/06ewOCNz58SQ5b8DGs/EyFUNwbSRMWBOAmXH5+o+Nniq3fLCBISeTfHV5P19zCf3SGbI+saPEnMSWPEPdLzYIkcaIsKi7FfFDWcP8nqI7EnP23ENncivKOCNb9yDfcc0115ijsnUPhqFqVx+P/UaBpp28VVA6185Au7tQuxP5XAqz/Pgs6nOwThTQd9oM1hixD+c/4YpSn3nJyjXS86bhWT//c2smusqh27SU6w7cTHIVbLDtj2suaac7SscDRilxFUl5yfvn7RQZ2J+vgLnX53iNHQQEYZ0SKwEGYLOSYKyMU9DFxKToCma3atEAQDrXy7Wqfo+qaLiQm0pGgjwrZ5c44BN2nlyTWx4922dpoWRY0ZgDITbQ7tGB/Toaeu1Tnvpcnjlpe9muZQ35a9eqcuf4ZXLfUVuVKzjdtm19eeyv25gi0BkLV8qle3cu8/tqVyuWu4/cSu4e8ovxq88fsImMnjRPhvw414Dmh2/XUn78bal88esiiUNs0JwZ33RRV1YgvWX96rJp09qePvc3Mxab+fN3fDxJTnn6Czmv/ybyzjm9ZOgPc2XkpHny7czFMot8Ip3PRVVNt/laA56LNKpdzVDAd2leRzo0qikDujaRmb/NldG/LJDPF1eRzmuWy4AujWXgqR1l5Zq1ho79tsGTyr77pJ3aymHbtjQ08Yc88KkBzOkwV9D8vP4d5dTe7VzP3WYutOnMlZEG24G/qfnfpP1/LVyG9deOraMWbKDX2Cf2MUL8kwuGmpbNOPvss0288PrrrxsdpHPLiXXw//h5yimnmBEgPGsKJgHa8X/jAs3zruOcB8ED4CDo5wGQVM615Z8kAYvLWa1gC9/J63Bicv3O4cOHm2ovm0bIDmijBM3ZIJx3nDTkfoXOTjZrmAof3fCavOJ5KBARNDmnRRckBZPs7h758zw57ZnSrn+Vby7vVzYzlnWVJiU6wSWBtc6wdBoSZ0clgYk9dzbKLiMAEUBzlB17pTKB5tnEnh/CwYynv//97wYgKXSch7MZmYRkI5SXdMAEFZv20E8B1+7/GSzTFueNSc1rGXrRzob+KWlHVimTotI57GEFJdCdOo5EdaczucOawk6yLrEJaRZSpTX/NhNlvdfcQpuml8Om6Y1y7AvPR202QGWaOhk7CW02wAnrVkHRgs2I12bYAlsJ6wH/ABCEgCxsfIAOIiHWt2/fQL4J65viQu0CoUPQjQ77kr02leN7ts4aZ7COYHXAR8YX9Nu9ZdPlcuCzxDG+ImrRIlp0S7aCaLvLlwNZW7OhnDtoXtlr3jm7l3RoHF9hqRfgMPTCnaVp3eq+CgRIeHpRYLv5+hprES/5tY3PjP1V/v3ej75ee8+RW5nEWhI0iPbsd66T67XnhrsxCuS7sNewBTxTEur2iBN+IrY91IaBQpwRrc349NNPTRyQqYNIGUJYn3QSurEP0ulN8XouuSZiaI3PtTsxCHMb+hy6ZEA7/BynzQDAgU6a5K8XY1++gru5yrCLdpEmdaJnbvTbde71+rQkSPFAGMDcTz6PXJEyDWiHocZZFY1hRBtqdHa103eyi4bxRwAj1EbHVTRcyE2lE2eMHDnS2HR8U3ID5NLxy8M0fBGj4CswpiMXn4rvZo8R99h5L4DT81/4SmYuWCqndlom7Vq3lG+W1ZUb3//Z+HjMsLYFuu4zn/tS2jaoKf85rJuZf23L0B9+l3++9p3su2UzaV2/htz6B7AK4HvMDq3L/p+U1K1eLOtlvSxZWTGaTdykqIoII8HrFIusXi9yRZ+Gsqq4tlzz4YYub+SUndvJI6Ommn9/c0V/Gf7jXLnlw59l3tLVsvtmTcyIyE2a1DJ063SbA2pTZMC9gbYdgPuX35fJd7MWy4SZi6VWcRXpUGed7LNNe9lzq1YCuggt//ezS+m7VZ48YVvDLvDo6Gky4qd50rFJzXKvOatvB8NEAFAfVCgoJd/LutXmTPx/OycXd5yqDaSZYrC4hThdGxOxNTamo3FeFPm+dTHiGV72/LHHHpMTTzyxLIf5t7/9zXSdUzC01157GaarPw1VO4ZGE0UkQTEcUVCOMzOHBcIizkTdCpBIkJPrd2IEAek1QWMvqihBc1UQaVJR2J36SkOuc9hy+TyS1pq4oqOeTa7JuUzdEdxjnrdSlSWdIHEGDE/vX98ob84lTfp8nSPOvsKhyuZ04/BpUoZnwDNRhZtrl5FSh/AsCcj/TKC5W5ENFCMDBw6Um2++OfHv/zMEJ6xjgI9+/foF/mxNfvmhPUTGjBkjrdu0ld0f+i7Qd1VmaVuvSF4buLPUrJZex5cmAJOwlV7jSJQCGFAjHwqpVA8TUHBf0tTDgJPYbcB7P0w/Nk0v95kgIYokGv6DPp98Ac2ddrJgM5JJaLHG8K/xa/GZWJdQKubi42pSyo3y2Auwt7tObIrfouISM9/cKQ8cvaX07tzEc/1z7XwuesqmVgwjmsSmCIhrs3VdPsxF12fIvfQCsLK9Hx2+852lbAMqg07qbHRNXPr7i2kL5ZjH3DsnP72kj+nYcRMSrlxvEJYt9fUVZEay0cVe/L8J8s6EjecleiUix/yjd+RrATAB+mg/NIhaKKAghM4N5x5FlUCKUzh/bAHJILf57egFbKDaQ/Y2a10TiCSUDj/88EKcEYHNQH+j/9HJXjpRC9TRr14+hBs9b1DR76FYJkx3IuuGQizOgbXFfmC/K1ipAI6fwiqoWrd0KebKBzlk83ry6neL8qK73Jkj+vry/r5GUaUBoAe9F19PXyRHPjI+ss+zi4zxx21fRVkG9KhIDCMKmmN3/Yz9cSsazlScHYUU4ozkgPNPPvnE5CVY59iPXHLXdNuS/8a2BBWNOfAxKEQcO3as8a1s8A+bMWnyVDn/1R+lTu1a8siJPaRmSZG89uVMufadH+WuI7aUnTuVtxeLVqyW8174RpatXms6zekstmX6guVy4csTZNWadfLXHduaDuSf5pQCqXSf/75klXz8Q2lxYBpSVKWKFBdBUC6y/g9bB315Pgr+9uKVpetuh3b1pX71KnLOdrXkP8NmyrTF62TqkirSok6xzFqyRnq2byCtG9aQV7+YVRZb1Copkk+nLDD06p9NW2jA8fnLVm80QhEwvWPjWtKxSS3p3KSW1F05R0pWLZR67TaXc1/+XuY53nP0Dq3lgl03kUHf/mZm2k+eu0ya16suk35fVvaaU3dpJ+f062jmpIdd+7D8OP0q/GeNb5yFwlE3BfI9gOYUuscJ3mYSnWmuDbVOTIdDO/KVJTOKXNfwPwmekVfAOUaDal4qW6FRjWox43hhxEgOe80goMOJasYovhNufQIYNo12mkc5z9xOBhHU5ApU5yKaaNbK6ji652waRZxHVXpaaa33VJkKSBLgeKSR9HYGN0/tV8+1uztJUUp0wASUedA17tZlFHburHZN4CS6JYD+TKA5IOshhxwiN9xwg5x11lmpJ5kroqB/CKCzPWfW/6677hqKHhe95leXYL9Y29gw9s1mV6VP356kDD5/JzP7Cj1NdzdBF/srrbXNM8CZ5gjSWRmV2PRR6qxiCwBCAeLSokUHdGZPhKGsj1roJMFHA5y0WXrC3md+hkmi8WxIGnBv0gbN0T/YSc6dgk99PgWbkYzN4O/4kvgrNivEsGHDTBwRdp0S0JIko2PcSxS0gH5aAXtnhyBFYCRb5y9bJTveNGyjz3j5tB1ki5Z1XdcVYCP7AX0YJc26JrKJ43Q2aZpz0Ym7iE2URSwsHfn3s5cYGkGVdvVL5LpdapQrFGA9RN3xlgkocXae23Yul8IOLRRQX9/u1K5dv5H0vXNcoM8bdXFvaVCrJK86OpRRQEFm5+iBNAucMxW4oQf82mqde3jZZZeZeeLszZ133lkuvvhio3vyfaZ4PtsM1h0xL36tVzGHn3wStoR4nLUXdq/SpMH6YM8HGS3IezU3hY1DZ2uTArE918rfwgI4fLYbI0ocMuGK/mV7Iiy4POq80qKqpPzgoF3nmd4btYQpHKALsfu/h0b6uawhbYLJBi57MYwkNXYw6HVRxI2u8AOau71fRyxqcTZ71B7ZkauvVYgzkokz7PvNmuXZ4fPn4pdT6EshFSwGfsWOOexOd2c+i2sCeyBm77TZFvJ/g6abruB7jtpKapQUyZtfz5Kr3vpBbj50c9mta/nCTUDxq97+Xob/NE9uPWwL6dmh4UY65IHhU+TRUVMNhbdUqSL3DZtcNpP8xJ3alf2/IO7StXkdE68gx/ZsLW99PVveOKunNKpVTQbcPkp279JQnv9sthy7eTV55rtV5nW37Nlc3vxphQybtND8f4/Nmso1B3SV+jU3rEFo1ikUgG2gZrWisk5wnunX0xfKDW9/I9/+vnGRyG5dm8i/D9rMsA4wu/yNr2ZJi3qlRT5aGIH8Y49OckzPNqE6zO3mTQr9sjU5sSeVUUwLhdX/9yoUjoo1MS3QPFNzKveAf1PorjYkTCw75k+EZ+QVcM7D4yFGTW2AQcAoOalL2GQ4MASjLLKoHjRVWlyDAudRguZKKU9VGsFSmg4hCghwhAArU2V1lOLWHaGJOegYUXppAtUbVRP/X99UZ8Zq0gWDEBUluhYyaPeGzp3NliBVsIZ5H2mCafkAmgOKHHjggXL11VfLeeedV6mNTNrBCeuOYqY99tjD12dqMRWJKECSIEEo65u9YNOGIouWr5YeN2ZOLFQU2bdbM7n2wM1MlXGm7uFM9I5JVvUrJXquI1+imCOOEBxjwyjwshP2SQG1Oq8ZvcdsqDR1D0E+lNH4D1EVNdjU+X5pehU0JyFFMitN8IR1gX3gnG2bXbAZydgM1gB7lYSmE1xWSsWwQTGfPWLECEMn5ib40gAzmUZG0XEOCAb4hY4bN3meHPd4+Y5o5LUzepjZc/a+B9RB3wA4xglk61x0BWT4vz16KW7/nOfLtXJ/0C257GcvkMOeq4s+x8/Xa9TZernI8J/myhnPfuX590uh5e9VmtBEh2J3o7Zz6M4nR06SO0eXUtb7FbqKdo2Yll2FNUUMHEVHh1sCiaSR2oq0WRPsUR1hCtx47/777y/HHHOM6Up89913TXHFe++954v1oiAb2wx8W/Y2/q3Tl8Hf5Pd+YkonM2GYPBBrFmCDRK1fUcDcLTeF34T94e8cWhjEOfLvsHshX+jGVerXLJbhF+5ULpfEtan+xi+PM2/jdj/CANZR3Nfxf98xNHMKQMpW12UukAhzXXYRKzYtaEd1kmMHw4LmAJtRdIrbIzs4bHZI1nFQ36cQZyQLnOPPEI/jM7ImcvU3YNfDFjEGxI/YY2qJfe2iOs1nYc+IS22mKl63dNUaOeOZrwywfeeRW5mc0IcT58g/X/1O/rFnJzly+/KznVmbL38+U24c9KOc2aeDnLJLO6nquN4JMxbLJa9/az7ruJ5t5MXxM0znM7J167qydeOq8vRXpf8vyAZhlrh25Z83oKM8NGKq3HF4N+ndubEM+3GuXP7mREPNftP7P8mbZ/WUA+4ba17bvl6RnN9tjUxbViT//dJ9zju0+ctXrZMFy7Ov53/u2VmO7tFaflu0Ut76Zra8/c1smbFghWzdup58NX2xLF+9gQL/riO3lF27eLOjBWkkZf61c/36eS9xsc3URKe62grsht9z07wnOGOYEQtJgeZuopT2OvYpaOPJuD8ZnpFXwHmQCq0gAnWDdkTb9D86AztsxW+mRcSCAzyPkppdu0VI5OValZarKB0ZDrcf6u84RKtMcRRQWjxXniVBXpQzT4PIgkWLZefbxyVK/eUlClTH2d2tFFIafOKE2XP2FAzCKSMZHVShV0bQnD283377mW4QOkAqu5FJ22agq4YOHWrAimz3GpuA8xO2mIpnS2AOIJlJfp6zVPa9e7Tkq1zWp7F0qLZYVixfXkbnk40SDv2LraVqGarYsF2ZUYjS7JNAwe6nSYmuo2BIwuv8Se0a0M4+9CN/1/ucS5Iyk2hHFOBfGrrPFtbJpEmTcqYrzSZeNL06KxDRtZIPoLnNDqNroGAzkrEZ7EVlynADqugWd1IXBvXhhwwZInvuuedGyVtlOcGXzjQyCmrdHj16GH2BnuN67h02Re4bPmWj17506g7SrVXdsrnXOgs6SZ/DjbHIr03JJTYh6YEdyiU2Of2ZL2XEzxtmm5cUVZEv/6//Rq/jGZCg12skEaFFURxhdYofYOTW3RtJ3XWloz+iKKSGhhLqxivenBj4vWf1aS/nDojPvyc5xjr2O9IjjP61E0gkjOwEUpJxrteoDr/iZTNoJKDgoNB1Hs5mOBkM+RtgGGsTve23AJAOHXRx0NFBNhU8RYD8pMAuCGjuNjbQWVjF6zShzE9lEGHfRTHeIEkw/cFdS8r8b7c9rLkkLfRCD9g2Ko6i1lzBc2yMPRIgSDGaE1hmHdnUtdl0zdNjf5Xr3/sx42vC5r20eFCZI3P1x+McOxi2gz4q0DwTEMRBDlALwfzElYU4I7ncFM+K+JeDZ4R/QVyeq+Dr031LcW02yRZzsB44N3S+Yg/OYuKlK9fImc99ZeZZ33v0VlKvRomMn7pAzn7+azm2R2s5p//GxfmA4xe8/I10aVZbrjtwM2lYq/z30uH84PAp8tjoaXJg9xayWfM6cufHk2TB8tKu5l061pet2zRwjXn+jAIl+7ippcUE/9q3i9zx8SRTmHDCjqUjjM567itzDxeuWC3Pj5thGKtOefpL0/W9eYs60rRONbl811ayZMFcGTfpN7nryzWyeHV2f7N5rSpy+GY15KQ9tpca1Yrlu1lLZMgPv8uQH+fKxFlLpGeHBobefuSk+WXvad+optx++JamOz6qQiQdeZFr/INvZeeKsPtqFzM1BYJBUTSZC2tiWqC5n8aTTMUEX/wJ8Yw/BXBOJzIOExtLu6RznSPiJdxOFhKJIgKiXCt1Vfg8nGQWb1SU8rmeC103+TCjmnPhXtPJbNMXJQFEuJ3LwGHrUwfO0+gq1LmzmjzU7g3uPUkFziMboFjZQXMqNvfdd1+58MILjaH5MxiZfKDdBWyAotIruWBTUBEYhHV+AOAA5oIEQHYya9HKtWb+z50f/yJRS+PaJXLJXptKv00bS53qxaHmdatOxa7ZIxo0eYgDSwCWdnc3NphzI6GUZoEZ+hB9o8lIr/3OOWuCMi6aYz6f9RmG3jZqIVmAXxZm7nAu4kbTqzrBpuROQ1gDBD6cAwleXSsFmxG/zVCqa0AlCha89gdAFn5vtpnKQW2Rzj5nv2djOdE56+hYGwAhUfXxD6UsTLZcs1tzabRylllTcYCNQUXnzXHYdOdRxEpRxiZ00/S4cXhgX97LD1Z9HmS0EVSI21zvj6nmhF5t5ILdNpHqxUWBgfLPpi6Uvz6xMWuBX9mswXq5dKe65hlqciVq0eRUkPntuYgWQ6itAMix6X/jLMbzGtXhVwo2Iz6bYTMYKniJX4H/EGRN2DS4fgV9iT+pbFicC+eFzcoFNNfCKo2LneuN97EXbAYR1WdxzJMOA6rblO1u+SG/jA1uRa1h9XfQa6RbT8EOP8W46ivmUtCjHcsaf2i3mTKn2M/Wz3PJJd/FPrKZYqKO3ewiPgWWw44dDAOas3/JQyfV1KMjOxQIylQIVrAZyeWmtLBfG/rIO7mxmIQR1jbFXb179874Oj8xBwUsCOsnE1PVitVr5W//m2AouR86trsZIwQoe+azX8lWrevKvw/cXGpVK6+jFi5fbYozP5+2SK49oKv077Jxzm3KvGWmQOeb6Ytk7/ZVZdnqdfL6zxsowXffrIl0aFxLHh45Vf6MAq36BxNL2aCa1Kkm5/XvKLcO/llO3LGtnNGng/n959MWymnPfCnvnbOjDHz+K/lmxmL57NK+snjFGun331HSoXFNaVanusxctEIu2LWT7Na1saxcvixj/IJe+XTceFkotWRxjWbmGX46Zb4sXblWdtqkoaFcf2fCb+XO9dz+HeXEndp6MlWGZSXh/OLQqV5Ngc6RTjBXkzsmbxx1E27SoHmmYgItsqtevbppkMLX5fv+8pe//OnwjLwCzjkVApGoBaPE4sbBxNkkqI+jY5uNzOGct8n3aEIhTKUuwQoKIo1uEa/kez6ci86541yYKe9GPWE/gzjnLfIdFGQQeO7zxKRUgXOUG8GHPqO0hEQT4AidhQiGJkoqy4oGmgMs7rPPPnLmmWcaSpM/i5FJ22agk6G3hZrSrXMgymIqLxrHTOemRxB2El5PcIRtIMGQBPio4K7qVK3GZC+zx7mPBIFpMH3EkVDKVQhM0cOAbOhiv89Wk5R6r70c9iCiNFJpzl5yzqIi2EmzwIL7TOKAJClrmSSaFoYkTdPL3gEoQfcoKwFSsBnx2wzWAf41ey5bIQfrBf/R6W/6FTdbBCAIaAErkB+fGvYUimc1lrBfv989n8gvc5dt9J4L+rWR0/ttKvkmXn56mK5GOx6IIjZxggRX799VDt+uVSg/WHW53cXgNx50zlgPIsf0aG0SizWKq8qadetNYnPw93Nk8tzlEoXsv1VzuengzTca30RSRfVoFN2p+ZCcsufKYtvJI9hdmlHFlAqa41eFGa9VsBnx2gwKrLAVxJH4mqxvbHZQ8Jj3spb9xuhudgJfinXpHEPoN85QliiuyW9Bina1qk7D5467OzuMaN4sV3YlZaFwxj1h83m2uAHRFDbfd/TWORfj5tptxvWii/B3jnsrOzVyrnkufGC7gz6J2E2BZds2+xk7WBFA82yFYFw7cTuxIXb13HPPLeSmEshN2YwhOuLUyWKSi7COydH369fP8zV+Yg7WC3kxiqrw58hj4Jd7FYetWbdO/vXm9/LplAVGf3VuWlvmLV0lF748QRavXGPG97SqX2Oje/TGV7MNOL7H5k3lkr06b9TUgX17/IPP5NVJ66SopJqcuGM7mbVohTxkgeU7dmwoPds3kDuHRN9wko/Ss21tWV+1xNxr5OgdWku7RjVNVz4jnP7yR5zC3PhjHv1M+ndpLGf17SBbXjukXJHZ1W9/bxp1iGvoPGe+/KIVa2T7dg2kU9Na0rxudam6fp0sWbJYZs1fLL8tXCYLV1WVmUvXyW8rqkhxUVXZpk19MxJs7tJV8u43v8laC1LcZZOGctneXaRjk2gLaZWVBB2WBEugjnRS3anFBMSr7LcgTENRC/4A8UISbL5aTHDPPffIww8/bOwJOuSiiy4yXedhGwoqmvwpgHO6XQm6ccyo7g0zKyzbeWs1r3NmlC40rdRF7ErdTM4hn6l0pvnQLaLzSKluTjP5roafBAGORjaqMzcgwp63mGsBBY4FARpJDjqVvGYiJiGaPAS4owM/TVFaYBQr56LPgHNUKjR9DnEHE2mD5ugfQPMTTjhBrr/++lQZIyqT+LUZgwYNkj59+mzUCaVJCAArgsdcOyfoiCLgyBYAZbIZ2QQ7RmDEHiLwSoOGnPMmiYRtxbYh2AQdk5EGYI0zy7PMByYU1cPovlycSe1e5B7rDFaS9Ko3/XRIqN1OE3TIdRZV1MIe1cBL6SDToullP1MtzD4mea22oWAz4rcZmsTinhP8Zkv6s2bYc/gRYb8b4BxbxPNmX1JcyN7MBlqozSBIpmuKdYm+dXb8HfnwOPl6xuKN3r9Vq7rywqk7SL6KXeFvz0V3u0a34mhsbxRzr6OcQetlNzUBY89+5xq9YhHmRp734jeSL0L3yJl93BOuNjUuh15jWGpc9gcAIb6OjtZIW9DZdjdKVPS/2CNsAYAcPmRQH6ZgM+K3GfhT5GWwHSQqgxRF2gIoQXFetmSn+k18L3vAZsMC9Ca25fdB4wz2pVJHK4NJGNHubHxU7c7WRpGoGR2D6Axlj4kyV6X6W/d9FJ33Xl3cbvZGu0Q1SR5njNPjxmGydNWGebReEoVdVLYl9YHTiB/V/1Db7DV2MIiw9wAo2aPQs+dLUYnu29dee03uvPNOk78kH/fXv/5V9t9/f+OfpjmyqrLmpjQnqowhGuuhq7AnrP1chbXGXtp1111dz4nvwn55xRy8Br3G69Cj5FLYG9pxmokhCvaiu4f8Is+MnS7/OWwL6dO5sQFvAcYHfTtHbjx4c+m76cY5iJkLV8jlb0yUyfOWyWV7b1o295rvw06SV+/YqZO88dVvcs/QX6R+zRI5YrtWpkva7jZvUa+67L9lc1m4Yo289NkMqWyyTWOROvXqyYhfFpVd7//ts6m8/NlM+W7WYrn5kC2kZ4cNPvJ/B/8sw36aKy+csoNMnrtMDn7gU/Oejy7Yuex5Hf/YZ/L5r6WfR8FD3epF8sWvi2Ta/OXy2+KVsnptKURIQUPt4nWyauEcqVOjmixZuUa+/H29TF1S/hy3bVNP/rFnZzPTPA77hF5mTbAmidnTYJQkV6SNS1yjFnxjJ5JsCkwSNLflhx9+kL333ttgGuiHd955R0aNGmVsycCBA6WyS6UHzrXaj6ADoxQ1mKhGhiMbAKKVumw2DjafPZPbdlT4PBJBGKukOgq9RI2tzoSPcx6pn3OhOpqDKuugQIBWDmlyDsXD9WjwE5RiUDshnNXadjCUFHCuAH5UycMoOvDdAHylQrNp9XXGFgeBd5QGN23QnMIXjMzhhx8ut956awE0T8Fm6FxY1pbfebZhBCAEvU6hUxQ2wylQRBJ4UWiC/ouaIjHs+BCKl+xK9qQ7UNA3gFp0gnKkCZprd3ccetitQyJT94t2E8U9RzybsObxZzj3KGZR5SJaSc8+5VzcAi8vml4FuaIqVgGAwTbh+5HI0OdXsBnx2wyeL/rLmcTKJCRB0bm5UCp+8MEHxhaxN/FF/YwIsG2G04d1dvyxpi5/eby8P7XUvjgljdFBYSlVteAYu+c2F13nRGrxQRRV/9e+84M8N256ud99c0V/qRqxTXGb/a5U4G465otpC+WYxz6TNOWV03vIZi3qhJq5qteo8ZZS42YStV/skTRj4KBzZYMWtyHYGJJgYUHzgs2I32bwE5uBXmJN5tLMQKyO/0ZxZaYkMX4ta8rNTthjCIPEGTrOSCmxo/LRnewayjzBfYo6rncTrocYjMaKuHNVzs57LxuVTR4fPVVu/uDnrLZa2R5zLcbNJL/8vkz2u/cTX6+9r1/VsmvNBSzQYiHWBzFTPjQV2ONW0OnY6aBsVHyGTSWcT6C502YcdNBBBmh99913DQhy6KGHyt1335326VWq3BQYBDEwsYMzD4mfo7TtuQrrdvTo0bLHHntsZEvQH6xlr8J1zpn4gXXL65wFVfyN/YD9y8Sm++bXs+Sqt7431N/H9Wxt9sobX82Sa975QY7ZobWcO6CjlBSV3+eAuK98PlNuGzxJtm5dV07bvoEs+PUnk5uz9R3zz1/6bKY8Nnqq+Yyjtm8lgFhPj/1VZi5cWfa6vp0bSZdmdWTslAXy1fRSYLiiym4daxqWqJ//uIyqVUSu3K+rLFq+Wh4YMcWwlPzfPl2kQc0NuYxXv5gpNw76SZ4+aTvZtFltuXfoL3L30MnSq0MDeeyv25Z75k+PnS43DPqx3He2bVhTGtUqkaKqVWTOkpUybf4Kz/Pbu0Ox9Gq0UjZpXjr2Iq6iOZuVJIpGp7BixyXsD7sxkz2vfgC2Iq6mwLRA80keeAb3AF8zzeacPyVwro53VKIVtQCKKG63CqxcxJ4ZxecHcfgUPNTEEM6VJhRInuD8swHTpr7l+kgWYkQ5l7QqiPWeUeXD81SFlasoxaAGekq/x0HyI1MRhAL4bp0QSXedU9TAvUlq/l8m4V4S7PthA7CdMT2452p0cp2fljZoTmUnRoYq3rvuuisvgsLKJn5sxpAhQ4yjxT71O882rFOBLue7orYZSv0NGEswkeZayjSyw7Zr9nxAnYseF1CtjB9pCvud7rgkurvdOjSV0p2fnAsJxKhsZa7FizjWBOxpMCQ4QXN8K+6L32plLfTi4DqioOklkYFtwr7hQ+hnFGxG/ILu1yQWSRm/CX2/jCLZirhYd/j1PPdsnT3ZbIatb/F3EAL32cXN5eLXyydDVL64rJ9UK644vgighH2N6DP2HrYWG+On+MCPjJo0T059+styv/vXvl3kqB3iZ2+iAEJ1OTrGWUzKcx796Xg5f7h7QURcst+WzeT6gzbfKNGZ67y8TJTuWhBBsjntkR65FrfZI6rwP90AJnxYGzwKCjAWbEb8wv7Dd0Df8Az79u2b0+fBmMdzhm7bS+fhHwC44U+62QkK9/Hxevbs6dtmkHAl+YzfwlqLqztKmSdUp3EOGgdgn6KOX+xcFfYg6eJM5yiHTJ2ZTsk2O/zDU7ua9RJHMW7QefLkspTSXZ+tMggGLZZmjaP3iFfCjKVIa6SMslF5FQ1wf1iL+Qyae9kMzU2nyQhWWYR9oU1w5Cm8KJ0pgMK/hZUgCh+LcU577bVX2X7CJ8GWsE45BzdbwnPXxgzWQrbYJBub7tczlsj5L30jPdo3kKsP6Cq1qxXLpN+XykUvT5DqxVXl3wdtbujcnTJ/6Sq59o0vZfDPS+SY7ZrJObt1ldoO+naETvZ3J/wmj4yaajqjD+7e0szr/uSXBfLet+Xna++1RVNp36iW6bp+/7vSc8132bdbMxOjvfblrLLfNaxVIuf062j+/fiYaVKjpKpcsmdn2WmT8muKIgVo2KHH528UJex7zyfCauB5XHPAxj7HqjXr5OMffpfHRk/LWGiw5+ZNDfU7FO3tG9Ust8bs+IX4NspxTehg9YdoGkprDKMWarvFJW5NgehRtRVRFQ+mBZoX4oxKDpyzyQgOUO7MOKKCKkrg3A5Mgsym9RJVOhhXNhtKgYQeTnI2pzsu4R4SKGpVcprUPTqHUiuv40i+24Eeis+LVt+mnPUCJZIEzpWWjGeU1pwNFZwoALWws3TZT1rFzTPAkdMuHIxPkGA4bdCcYgac1913313uv//+Amieos0YPny4CcxZSwS07PM4upgA5Akm+OwobYaCw87q2zSEZDb6z08Sx9mBos40yaRMhUl+REeZUP0Zhn0kLlaWbHOS4/p+u3sRO8kaQ+9RTJBWwZudQGJPpF0ESEFXUNDcD02vXbDgx0/iXLBNmqBQ36JgM+IXnv+wYcMM+B1UZ1DQiq8ellKRhMInn3xi1gp6IlsyIYjNQC9TPIlO5hpZoyuq1pJ/jHC3jw8f21127pSuvxhGuDaKZ0lg8G90ilvXS1D58teFcvSjn+VFhz46xhmLsA7wqfFjhv28QM554evYvn+bNvXk/mO2lno14qNBJN6y9ahN6Y7vzjNOe6RHrmKPCeMa3bpR+B1JMOJI4qagPlHBZiSzHwEjeF74VAAhmWbI+hEdH4gf7RTWDP4BhecA6146jbgAH3jHHXf0ZTNYg8TnSVB926JAq4IsXHeU4/LyKVflBrQqlWum2dl+AOxP/tFH6tbIrcvukZFT5NbBkwK/z8sOKligOs4ubON6vbqzdUwaNi3q8ZlxihsblT12kLWnucp8Bc0LNiMZIe4Fh8DXwd/3yl9S/IT/3qtXr0h0z0cffSR77rmn0TM63oG16cWsxR5WWnTWsl8GLvv9Wkhjs+mW1GkkN4/4XeYuWy3//cuWpvOZjvG7h0yWZz/91czdPnGntlL8x3fZ40OqtdhU7hoxQ36Zu0zO6N3eFK+6Ffvy3cz6fn7cDBn8/RzZoV2D0rhm/XoZ8fM8+WRy6RxwlS1a1pGe7RtKcdUqMm7qAkNLng/SrWVdw+a0dt36cmA5snvXxrJXt+by6/zlhg0L2vTTdmkv+23VrOzeIQDkD46YIo+MnCp3HLGl7PwHoE6BwS0f/GRmzO+/VfNAhcDalBdkXLDt23PoKKNsI6m8RAs/iAU4jzSahrgGmmK4H37jEmdTIOdtj/8L0xSYFmhesBl5DJwrHVauxkrnhJHgogLLjbokX0BzZ0chjiTnro6oFx1KnAJgibFVRZVWdY8qH5tWLImgyAZwbfphFB4GQYEAL0coCeCc+wFoBHCeBljjFAoJAEnYc7lQ2DnXoQYo2umnhifTXkgbNOdeUM278847yyOPPJLq/qns4sdmMH8FwJkODSQuJg+CH549VLxR2Ax11nTUiD3fMGmxaRC1ez+OwqSg7CM8S5uCP2nhmdINogUTabKyKFCNL8GIDH4qk4oGLmE7pMOcC0ladDj3Jc0EEnuPpIAmMKKai2UXLDhpejncih45F3wrhHPRdV+wGflfoJttpmy2wJOkEM/bTxLCr83QQk5AFFsvs9ZZkzNmzZbj3pjn+T0VgbrdFnxx4gH2MPfRLhgKO3N2/NQFcvzjpXsy3+6NMjihV7h2u7vvtzU15bgnv4rke67Yp4v8ZbuWkXSW56JH8dGI+bDpxMJpzkqOUtwAJq6L54mdsG2BXynYjOSeHXE2OlvzS7k2YuDXsx4o+rSF9Y8/6Ubp6xRACnzyXXbZJaPN4PfEEBR3UnjjhwkuLrFHjXD+9ogK7m/QuCyfclXZimc4+L8WWjqLBgA+trx2SKDP97JR+94zxtD75iJh7J9b0YCTcQNdT36GmDzJAo6oRbt0VacTb3F9XA9rkeecb9dWsBnJCP43ADZ+DLmbTL4oeQzsAfnCKL73ww8/lN12282sS/IBjHdwMgPaa5jYgdd17Ngx51F3TjbdhYsWy0e/1ZRBU1bLOX3ayUm9O5qxRxSq/t8bE6V2tSLTfd6+QbVyMTr5Aj5r2I9z5faPJ8miFWvkzD4d5KCtW3iyZUEp/sZXs+Wdb2bLz3OWmc7oHTs2lOWr18qYX+bL8J82joPoeqdQlK52uq6/nDpXvv3Nm5Y8Cmldv7ps3aa+AcCXrVor7034TdY6cphbNKoqO7WuLpt0aCuDf5hn7gM060fu0Fp27dpko9FRvy9ZJZe9/p1MmbfMFCls0bK0oY/PP+SBT+WvvdoYGvznTt5OujSv47sRiJg3lzFY9kgTdKRt7/00wynzDu8JM8Ioytwn+wRWiDDxiBYPKoiuo100V+SnKTAt0LxgMyo5cI4BIsnAolKHzI26JIxwXvbcqChBc6+OQicdq1buEGAEBRv8CkqOQITgKu1KUBJFnIvO9E0rKELZs7ao7sawU0WrxQxejABxzjm3FXnaVLwIYBpV+DyjuMA9Bd7U8NgdKnYAmjZojsO47777muT6k08+meoc6j+D+LEZI0eONHaAPRsnPaGzcjgXm6HUg6xnAok0O6+iHtnhRvWnySSt2k+TfcSvcC42OJwPHdXYTBuotvWmUqrZ1b9x6Cc9F54r55I2W00coHkmml4O7rnS9HJo4Anox/rnvqgeKtiMihFnZJop6yUKbGMX8Anw20hQebF1BLEZOrcQ28ZnewXffM6W1w31PMfB5+8kLeunp7v8itIMs5cAgOwCIK+Zs+qnexXu0KFx+0eT8hI017hQ2V1s8FVHoejs1bXV68nbExfKgyOnZv3cgX07yEHdW0ibBjXyJrHPtWkBGqCDgmtK+6g2K6ni8biF5wgAy/1nH/PTpv/NZqcKNiMdm+E1QzaokJRmbetcWy0GpcAKXe6HDQU/A/3Qp08fT5vB//lc1gsJ8DjnfucyooLzU4rzbLmVfMxVBSkaUFDJBhE4NJYJSp8epUy4on9k91G7s9VeURCFvcJuAeTBBlpZhGsl5uHaKHLDjtk6Pa5YK4gUbEayQs7YD7Oe6vFcx3+ojhk0aJDZX9gSdL7b+E61FwCjHPiYYVhC/bLpDvtuhtz/+VJpWqtILu7bQrbapJUUV68p9wydLM98+qv0bVVFjuxWT3ptt3Gen4Kid775TR4YMVkWLl9jQOAjt2+dkX0DWvi3v/lN3p0wW6YvWGEoynfq2FDq1SyRGQtWmC71z6aVjrZyCjPEu7euZ2Ki+jVLpFpRFZEqVQw9/OIVawwQv3rtelm6co0sXrnWnF+dakVStWoVQ4deo6RIGteuJtVLqpr30BW+avVqGT9lgfy6aLXrd7ZtWEP26dZcOjUskYk/TZLvF5fI57NXS5M61c24pMO2bSmtG2yc6+K7Xxw/w8QwvTs1MrPP7fsCZfuPvy2VE3ZsKzd/8JMMOnfHjUD3TAyK5CmibExxjqTKNB43H1hJ1C9DdxL3R1XE69YUmGn8X1qgecFmVGLgXGeicVDdZSellLqEQCcsYGIHJQgbOIpNrOdNQi5bR6EmhljINh2KH7DBr/C5gBI4tGmAjn6TZGl1vSNUPWmCLhMNV1xd55pgUrrptLsxqJAnMZzEXN9snX4E2iQbAc1xHJMWnsl+++1njPxzzz0XK0hTEH82g/UAcEYyhiRVnM4XlXnocyqHc7EZ6HbOGUmbepD7q7ovjnNxViiTWGIvq0619Vsa7CNeYp9L3IBsNiHxroBspnNxA5fcEne5AtWcCz/Tvi82aI6tTDJxpZ1GGhyxj/A/dc6cFsIUbEbFiTNIJHA4Z8p6CeuOZKoW+fDMoWpv06aNYYRwShCbQQKCfQYgTOzgZ5/tc/cYmTLPuwvti0t2SZ3m1ktIRLOX/dIM2wCz0scqIINN4f1eAEWU4EFYodCCIotMxaisY71GLdTJRgmcj6IUnTwnklN2ARp61Gaq4bVeHZsVRfAdAM2xtzr2gWtXW4FdBuDUa3TGeAWbkZ7NAAgYMmRIzo0Y7G+AFTqYWA/oNnR6kJhe6XUBzt1sBp+r42nwl9MsMvUjnK/qM/YCtk31mbNgRnNVacX6cYAIPHd0GwUE+A6nfhjN6MpskkSRGHsH34kGC54rMS6AjOq4tEZSRs2uhf3CDitrpa3TsckKpAcZOxiFFGxG/sYZ7H18+QEDBkTWcY4PhW1xa7jgnHgdzRB8N7nbJBhLFyxZLv9+Z6J89NNCObTDOunTptjo9a+n/C5vTK8uM5aulwt36yQHd2/hCu4CEg/9Ya6Za/7Db0vMXPMjtm/lOivdFmab020+/Ke5MnbyAmlQq1i2a9tAurepZ0DmFavWyPgfp8vkeStk2rKqsmTl2hjvgki3FnWke4vq0qhopRSvXiKr1lWV6atryjdzVsukeaukXf1i2Xur1rLXFs2ka/PSWMXtXnw4cY4pPFi+aq1csW8X6dO5fP79yTHTTGHw86dsL9e9+4Ohgz93wCZ5gy84R1JxnWoP0KH4NsTK2Pi0QHO9F+yluPwnZ3OLNsjqga1MAzQv2IwKApyzkTQACNr1hbPpVh3D3z/44ANDrRUmKaT0V3qrokpG2LSqBDVBuobtzgMCCAUbNDEUxinTWdlBZlnEJepIJD2Ly01QWlQ9uXW9Z6Lh2u2hiZEHJ7pmAI2dCaY0k3sAAUGpm6MUkhmsXw7E7lBJKoHIOjjggAMMY8RLL72UtwnoyiZeNkNZGVgTmjSn0y9OQQdQnQh1YlibgS5H9xFQUKSTJvUgNobiJWxqnJ36bhXKOhddKzGxbzxPHHmSzWnel0w2IY31z7kACtvzssNUvXJv7arXoHaXAID1wvs4lzQ7LBTA12KCtM+FZ0SilDVDQHLllVcaf5XuNQoDX3755YLNyOM4Qwuj6M7Yaaedsr6WZw04RpKYxJT6AwTA2CJnYWqQOIOYQYvBoPQNYl9mLlwhu90x2vPvZ2xdXQ7appX57KSTu9nGADHv163gIJs4AeaSatXkzI/XuL7268v7SxEtJymJFlMrQ4HfDlGbnQydnokSOJ+Efeh3JqxXwayCa6zXfAdfFDRX38Ft76I7bLvMPeFa8Y1gMzr88MMLcUYKz421ys/BgwfL7rvvnpNPoexU5FvwDUjKYieC7FOAuU8//dTEG5yLvZbw7fB/tDgj7W7XoOLGtqj7nP0BtXFcXZJpCOuKQgpycPzbLoLqd983kX7Xy6ftUEblm5TwDMnTYsNbtWplYiib0r0iF30p608mdi0tkuCaWdfsS7XNcbOoFHJT+R1nkPOhoBabkouwxoi/+TyAPrdGJvQoryN+0AaEpMeoDf1xrlz55kRpWlPkgFbLpU3dUoaUX1bXk6e+WS6N61SX8wZsIn06N/L0576YtlCeHz9d3pswR7ZuXVcO376V7Na1qdSqljn/Qbf419MXmW7zz6YuNJTx0Jm3rF1FurdvLJu1rC9N61QzM9ChhOdvcxavlPnLVsvSVWtLj5Ucawx4vW59KYhN2Naodok0qVNN6lYvljo1iqV+jRJpVq+atKhbQ2pXLzLd6tPmLzfFyxNnLZFvZi6SmQtXSpv61aRTPZH2NZZLl/oinVqXji1x89tXrF5rOumfHjvNnNMZvTuYbnSbvp7n+uioqfLAiCny8HHbyJq16+T0Z78y3eZ0wmfTZeT9kmZQtMfjYgfxdfHniZPRk0ljHdxDinnRncQlSRUd2jEOB34/ewCbiO1MKsYp2IxKDJyzuQg6SBZ7GQClLoEGJWgiKK555iRyMFx8bhSGywk2aAIc5QtolOm87RmJQRI1cYlWEtO1S7VRmqLzNRTEyuTc2rO7OE5+f3mkwLkWiKiDnubMWATaehJ8gBJprxkSyTiMMCUQlLEHNCgDzMGB1OqtOO4bBv/AAw80e+7VV19N/dn8mcTNZvDM0a/qAAJ24Hgx6ylOYd2xR0lkhbEZrFnenw8FQ+wpEm/sJ+5bGudSNqd3xgyTXOF+QsuodKZpANZBbEJSAD5+DcnRXM7FWf3LZ9k0g9nutQL4BHokgNMsJsgn0NxOrBGAcX8Ihh555BG56aabzHoC/Nlnn30MW8nBBx9csB95CpxrYVTv3r2zBp34IzBfEeza+5LfEwQzSzBMnKH03ejkXFihstHBXrP9WmndyH8cEYdwX9TPjGoM0DOfTJN/D/rJ9W9fXto7VYDZpgVUhoJcki/qA6NvtIM5jW63bPS2Ol4kaLGpxr0KRmTqUM0HURvJeXqB5k7Rjvtnn31Wbr31VuOXcX3XXnutiTkqC3BYUWwGx/vvvy/9+/fPKZlLcpi9zudSDEQBVBD9yh7XTiTnWAriHuKfikJhnk1stkW6lokL2N/EJlGxLaYtmstEN1MQYCfPWSN2EdQ2N470/bn5MHJEC98oEnHTV1ok4czZ2N2H+Si2/VLf3o9wfXaRm82iws8or7eQm8r/OAP9PXz4cNlzzz1D62r8AvQHNoB1RS7f2cykepTYmJgzqWYIp3AeE374WR4YMVWGz6pq5nYfv00jWbZwrvw6c7Z8OGWVDJ5RJO0aVJcLdusku2zq3ci3YNlqee3LmfLy5zNNUfCuXZvK/ls2k506NZJqRZn9K/bt+M8+k0VrS6Rqo7by0+/LDa054Db07sxVr1ejWJrVrS71axZLg5ol0qBWiaFlLy6qKiVFVQzAzr8Bp1esWScr16yTFavXyaIVq2Xe0tUyd+kqM3+cz+Iz2jeqJe0b1TRzxrdsWdcUMC2e95vpbCafhM+v7Iu2375Qasv7PyyQ/30x05zPMT1am8786sXln9/SVWvkund+lBE/z5UHjukuHRrXkr889Knpzj+9tzczi+ZMdaRdWjoXX1eZxcjbKGMY90XtAY08cfo0mRiwkhSeP4WRiq/YMQ73Ia4Cs4LNqMTAuYJlLKJsCWw6zukSCZKIUDqTKKnZk+ji4x6qA8pPpRLHoDqTCfa8WJRl2gkV7WDOh653QHAcEZKfYYJPkyi/ZUzZ/x/efUNSJ2g3nxq1fKC/RQAiSWhGPf8kV9Ccbm9bdCad7gV7JiSGJ4pkMOvkkEMOMcUqb7zxRt7T4VU2cdoMBTZxMAge2Cs4Qeg9QIy41yKODno96EwzZfzAlnnNv0060YHec+6ptCh6oWNEb7olkziS0InoDwXE0k5IakdrHAC+zqBXP4IA06Z0dwYSFALqngM0TxOwwEbyjJRCP23QHP8Kn48OAF2jts145ZVXzPp+++23TSfbsGHDUmeSqewSFjhHF5EoBTTJNLqGJAhAiBuwzft57tDPBYkzgox18itfTV8kRz0yPuNrHtq3oaxcNC9jHBEniAzAxD7O1c+kU2O7G4Z5/v2h3aoZPQcApXouyQJIm00KvzpKP9LuYLZZXMLEIlGP0WAvcr252m8FmPU64wQjcgHNOY8wNhKbQVEV17n33nsb8BbQ9PzzzzeAekGSsxnce4pjc6ExxUYQQ5PrCNog4LQZxDyabCfpiaCn8VErSzzKukc/cn3EcRrX60xptU1p57DCCP4husFtLKGdw8g2yiofhUIH7LjfwjdnA4rNKqJjK/KhECQsaO6nyI3r1aLlXK63kJuqGHEGBVAff/yxAc7D+NU0FqAbKaYlTwIIT07A3m+sM/I6xKPEJWnRX3M/lP4av372iqry73d/kJ/mLJPzBnSUg7s3l5XLl8vk6bPk+fGz5N1fVkn7+sVy9LZNZd9t20ttD/1u4oXZzDWfbQ66u3fp1Ej6bdpY+m7aeKNOaz+jYAG/AdDnLF4lC5avloXLV8uC5Wtkyco1smbtelkDA435ud4A6NWLq0qN4qpSvaTIUMA3qV3NdKHz3a0a1DDAu1dhsNuo0x9mzpc3PpsmH/4wX2YuXSvbNC2Sg7dsLAO6tXH128f8Mt/MNG9et7rcdMgW0rhOiVz40gQD2j96/DaeTFrkb7gX5Eo4j7RyJk5WEvv8tKlDG2jU/kXdQBOEAStO0Znm5F81V+BkFYujwKxgMyogcM5CYHEENRTZDAAzztkEfuZ4cEvsWYNRdpqz6XG2CJQA+uI2XJw/G02DKv6vCodEFEqKc7CpJNMQ7jfUWyQd86HrXani6QriCPucnF09Lx7atGyWh99uPpwvjBqvSdOoOWkk2U9BxgskDZp7Oai2AeZe6nMIY4AJeA877DCjIwA+8j2IrYxi2wyeqXZJ2xS2MGqwjwC04xC1GZwLegx9y1rTtZUJ2EUnc34ABOzvNHUf1zB58mRTGAM4w3mnKdpdSWBjO9KaTHKrzCV5FkeyUAF86P79+BxxCter1eVBO5XCiHNesFb/arcP56IU+vkAmiNpU8WzRu0ATP2rgs2oOHGGU1j7BLO77babJ9BLopi150aTiLAmWAvELn7jDM4VPYi/Q7IpbCdy2O5z5KXju0qV5Qs2iiOwcVEX/yq7kjLG5KLPucfdrh3i+fetWtWVF07dwfzbHn9FMltnsOaawPYLIpMgCtN5HWaeniZfEDsJlYTO5Bzw0+IqbvICI9ICX7hee5xKUBvpZTNYp+gEANKCJGczKHDr0aNHqGIedCdznslh8TwZIehXMuWm+D2Ft8TmdLCz5nX8Dn4iR0WdI60MjUotbOtHt9FO2nkfd2daFIJPgc/KM/OTE+R67SIoiiz1etMqgspWDM4zw7aEEef15gOrCHvPttdRFm3r9XLYFPbaYejX1yrEGRUnztC55EHHydrjCMkdab5m5MiRJr5AL6i9AKAlN0UuBSaSNIQcnHY1oxO0QJxzfP+7OXL7R5PM/6Fp32uLpmbO+ZwFS+TxkT/LK9/MlxpV18k+HUvkgK1bSpuWzT3tmZlNPWuJDPnhd0ML/+3MJbJFyzqyfbsGsn37+rJJnfUy+YcJqTI7KtMvxQxaGAwgD338iJ/nybCf5poO+l4dGsr+WzWXvpvUlxVLFpZjBCwbXVK1ltw5ZLK51nP6d5TjeraR1WvXySWvfWfmuz9+wrYbgfZOppO08zfZWElUWMs6Hpf7QJ5VGWVzLXZWdkAKEe2cTT6A5k5xK6hjDel9COPrFWxGJQXOVdno/De/XRdDhw41G9IrmWV/vgYlUXeaAwqTWAs7py9XUZoWNhlKCoWJYsBwoKjSUhJagYZTHEdSMGzVUxRU8c6EJLRZ9iwPBdi8ulxwzO15eGnS32pgTsCPUUn7OQUFzb0MsAZl+hyU0j1bspYuHmYN8ozefffd1IsI/qyCzeAgeMA2EBg49y0BA04BeyhqcbMZCN/H/ubAwSHo1QSHBgwEEugadDG6L83uEE3osRei6PBLkqJX58c5Z3VHRTGs40MAqdOw3W6JNnReGkGfXf2rNIOsWwJ1P5TucYk9X531m7at1O5ROs3VtyrYjIoNnKPHR40aZTpDnJ9HQoiAm0RqpgI6fF0E/9JPnIFfwmcjTtAgSmH23/YZOrJVrtqvi+zZqXaZ/6pd2mrbcj0/9AugKvdDGWPCCN0gW183NONrRv29t2dCSWewco2asNdrJGEfld7VwlgSVkkX+9ixiDKLqA8c11xBuxCY601CT3uBL3HSHbqB5mFGmBRsRv7ZjCFDhhi/NCgYyNpHt6Fb0P/4/m5FWEFzU5ybMtuwp9T+KPsgOoyfcemwOAWbir4g30AOL9P+0dFO6pvyWo0D8nFuNudIIw05jDBjVzIVQaXpi7NWbVZCPw1LubKKuM0Drmigudv12iAR+1lzhZnGDhZsRsWKM3ScbL9+/XzngPhs7AeAmXOsz5gxY0xxP8x4vI6Yg/WTZmMGehzbx/UB0Lr5uYC9r305S+4dOtl0ap/Tr6P069LYAOir1qyT17+cIY+OnCLzlq2WHk3XSb82xbJ1h+ZZi2jmLFkpoyfNl/FTF8onk36XaQtWStsG1WWbdg1ls+Z1pGvzOrJ5i7qGhj0JQYd89uXX8v2sRVLSuJ18N2eFfPHrQvlh9lLTmd67UyPp07mx9OrYQGpXK/bMXX/9y0x55vPf5ZNZ62SnNtXlnD5tpWu7FjJ76Vq5+H8TpKSoqtxxxJaec82V6QQdSt40LX8AbIzcbdBxXOwbu6nDZpQNCh6zT7HF+Ga5MIgkAZpnile14Ir9pXbCT1NgwWZUUuDcObc2CHA3YsQIk/TO1EGncwb1lkTlZCvgiHLAcIWtvIx6dq3OukuT7kqVlQJHaVOUAgrjZGSrevIr+9/7iUz6fZnnvCnWBg6F3c2nip/nwbnoLJo0gz4tWKErFqOSdmd1rqC5U9yeg4JvGB5nJTfr9eijjzavw+GNKjAsSHAhgCWAIDmEDnHOdULooiZhit2IUvzaDJwSBdF1j3Oe/B9di8OYZncstlWdxrT1sFslbi6jStSBDJs8U6c+H8aHKBMKgDmBcZrCmmYsAX4Yazjq6t8woLmCT2mD5todDGiu96BgMyo+cM4zBDTZa6+9yvwBt9EgmQRdwj7RsSGZ9BFJMfa7jmNIYl3PWrRCdr19tK/XDrlgJ6lVdU0ZiK40sgrOBI0jgoAkXjJj4QrZ/Y7Rkc5+1YS9+odRARSsJ65Xk4lp6q1MzCJRdavaIz3SKgR20h3yf7VZUc/TzdUuFWxGftoMP/kkL5Yg9hFrHxtAZ6CzCCtonMEawUZoYYaX/XHqMPay7m1yUvkGKttFomFmtdudadgm3edcL/s8zXjLZtPCrkfRAepVBJX02BG7wYJ4O66GAmUVUT2urGM2xXlc+UpizKRHJmqHoca2ChLp9WqBeMFmVMw4I8g4WWJvbAnrz62Ylrgc0Jy1Ya/XtPI6ijn41eOMVXpu3HR5bPQ0U9h68s5tZd8tm5uZ5eyDsZMXyIvjp8vg73+XTg2LZYfGa6R74/XSrkWpPXPzyW02xXabbiFTlhXJdzOXyMTZS+T72UsMJTvf1bZhDWnTsKa0bVhT2jSoYUDnhrVKpGHtEvOzTvViA+RnEkD+hSugdl9j6N1nL1ppusdnLFwp0xcslx9mLpDZS9dJnepFsmmzOrJV63qybdt6sk2b+mZ+eSZZt369jPx5njw/boYM/2mu7NutmRy/fVOpuWaxzJw1W977eZm8PbWq7NG5nly6T1dpUM99PaE/WEN+mU7iEm2QYR275W6Dxhdq/5xsHZl8HGX80vnuFQ0099OVbxdcOfVAwWZUcOCcBayzm2wJmpxyyujRow3FqtfsWK3m5fujpGbXGeIklNiQaQOOAJ9KcW8Djk66q6g79jLN1VAK8rTndiuVTS60Utm6zrMl67gnKDqCKp4D9waKYp5FWhXT7A06UTkvQPO0Z4hFDZpnAt/00Op+nK599tlHzj33XPOMoFfK1dgXJDdBnylo7lWtC/jJ84JeMSoJazPY4+gaDj6D/USRTlrUgpq8x8kkoZemHtY5hmovc9U16kAqpbsmz/x0KGigxRGFUx8VE0o+dL0DsMCEYlPFR1n9W5FBc2wlQRuguQYo7PnjjjuuYDPyPM7w4xdA07v77rubxDs+GmvPORok0/pQZhSlz/UCXtlDxA4UyBC7JG0XJsxYLIc/PM736z84b0dpXKPKRnGEgujZ4ohcQJKlq9ZIjxuH+3rt55f1lerF4XUEzxAfNFeAgpgWHZppxmKaorGIJqGwlfZYo6Dnq+xZ2PS0R3pkm6cbxXxZHRuizAlB7VLBZuSvzSCfxAg3v4An+wjggHhVdZtbEVbQOAOdqU0QFGL53VN8HjpM/WLsGms+X0Blm+WJBHKuRaK6z/V68VNtnZ00oKQU5kE77MI0AiQ5dkTH1fC92Zh3ohbARJtVhFyAXi86PVd7ky/gitM+a4fhVVddZfQRuQ72NzOz045Z/+wSJM7wO04Wva1j2ii6cVvX+FnE2zQfaBFqWjqdc6BAKAyrxso1a+XNr2bLo6OnyorV6+TYHq3lkG1aSqM/OqjnL1slb3w1W978apb8+NtS2bZlddmq/mrpWne1tGm+oUiKvUpcrnlCt2YM5plPm7dCpi1YLr/OXy7T5vNzhcxbtkrmL1st85auNrPMEQB85plXK64qRVVF1q4rnXPO3HNmnq9aW8oKU7OkSOrXLDZgeKv6NaRZnWJZu2iOtKpXInv22lJaNajlSw+bvMLsJfLehN/k3Qm/yfLV6+Tw7VrKX7ZrZT6Xv3/8w1y5bfDPsnrNOjmnVyNpXbK0bHSJrQf5PnvsIH5Mmqwk2EKeSdTNZzZbB4fXPHD10+MaG5U0aO4UzcupbdSCaGwEgPqOO+4oJ5xwQiE3VdmAc6+5tUFk7NixJtnslnDWat6o55mzKDlvPjMfZoijoACGs82uJYjiniu9F4pEk19RgbfaWUIyDaOedjc1QQyzKeNQ4G507dkUKI4PRR4Ed87OiCRpqbR7DgOEU5cmlXRSoLlXJTeO7eWXX27GRBAQXnLJJXLkkUeacylIekICimeUKTEJaA5QjZMQheRiM7TTgOIlbJpNpcie1oKlJOa3kUxiPylVU5p6WGks3eYYRt2hoMkz7Jnebzt5Zne9x9k1EfX8pyRE7RNrN1Olshvw4qf6NwwNbpK0v36ShoDmaitZ1wQmBImArnEkSguSDHCOvn///fdlwIAB5jnDCARg4ccXUZvBoWCdjupxghb4GPikJMa8in2TkrlLV0mfW0cGes8mTWrJI8duJeuWbZjJl8m2KUjiN7nGvYTS8f/emOj7nD44bydp3SBagMStWEgBCq7TCzjgdVokgB+Q75TJrHu7Sxud5paE8hKdo4gdTZs9Kyilu4LoQWJfTcYhYcaGFGxGftsMOvrYu9lGudmFUuhyO//kLMIKGmdoEwRJVnRmWB1ig8oc5GZ0byfZqWwL9o/ZveiKOPxdG1RWBjDNccUFKieRa/LbiRfHnHDWqDItpZ0rYp+qvVKGGGUUYW0HzZ3ZoDnxYD4Uljjv/RtvvCGXXnqpiRVZv/io+++/v8lRFWKO/I8z/IyThcVBG98oJvKa742vxboHIOO1aTCK2B3e2TCHbEKX9Uff/y7PjP1VPp+2SHbfrIkcsX0r6dF+w7gRZnkDLL/37W/y8+/LZIum1WTz+utkk5orpE29IimqWtUUKoUtJjGMDyvXmiJdQHy6ylesWWdA8+KqVaS4qErpz6pVpW6NYqlXs9gA7M7mT78MshQNjJ+yUEZOmidDfpgrsxatlAFdGsve3ZpJ300bm8+G2h4gnc78OYtXysB+HeTw7VoZinbnKA8OvpM1gY6mgC+pHLrbvcS+kwtNIr/mVSCr+Ar+eWUEzTM1Bb7yyity9dVXG9+ANXHbbbfJYYcdlnqusyJI3gPnBB0kI93m1gYREr0obmdSRmdGRQ2aKyDBxvSqCks6oUugRXI5iLNuJ0wIMvi/Jvkw8GEUjSaNSAgG7SyJ496Q/MS4xFUhGwQ4164b1qndZeRFS6XBTxxd4BoIcU4EQmnT6KcBmtuCXjr11FON83PyyScbR5eOAeYSkUwvSP4GJ+guHLVddtkl5+8LazPYw1ASYdMIJJzBrOpa7Yrg9XHOq0OP0MGcVkejW2KdZEtSFK72aAZ0i9LS8lwoskDfYhPSZtgIO/8pDlF6r6Dz1f1W/4aZlRt2dmyUooUW7F0bNFebQbKDDpC0qf4Lkhtwjrz33nsGAOFZ409nSnRlsxlKv6mgBSAse4FzyzXZFLX4mRmeTU7Zpq50rrFE6pWU2jb2A51iFPS6gSQkpRh19ML46fLsp9NDfSed8K0bJJPEpwjC7rjHZ9br1G4PHbeRZrdHLmKvWTsJZXcz2sLzJf4mYUksnO9FAl6U7n5tFu/j+bLX8R+C2qW0bAbnTdfi008/bcAXCuNOPPFEUyxs66srr7xSHnroIeMz4U/fd999Jjn/Z7IZ+EDkdjLtX42f2SesA+dsWbsIyw2czmQzACMAJeKwEVoIpJ3KuYzeCJtQByDCtiYxj1cLPLleBZXjmAPPcyTXpCPD0mKftPWazgnX4qCwbAN8BrEka4dcURrFFpnWlFLY85ztgmmuN9uatvV5muBKEJuBbn777bflrbfekjvuuMMAsgXJ7ziD8R/kw93svepFckfEul46nzWqmAkxOv/XvL36oXHkktzOQ/Pq6PGg4/YyCQD5i+NnyKtfzpR6NUpkvy2byT7dmsumzTboU2jXoTH/+Ps58skv86WkqkiXRkXSruZq2aJZDdmhU3Np07J5bCx4Xnl9fCqvQlko3b+evki+nL5Ivpi2UMZNXWio4Xfp1MjMPAcsp4MdoSOewuFXvphput5P3LGtHNS9RdnfvZ4JcRZ+g8aY9uiSpBo7bQbbtOwg+UbwMPKx3AebnSSJhqW0QHNbuG5wDL6bAisaAynqO+200+See+5J7DwqouQdcM7mJiGqipfF7TW3Nojg+BAAkKxAuGyt5kWUijlKSlWCqrQBCa6PcwEkyERl7EcUvNWECQmRoBSFGFIqN3VGa9r3hi4XHGkUeFzAMMbwyEfGZwXOlT5FK8iD0FK50bHkIuw/7g1KPR8CobRBc9bKWWedZYwMgYlS9FEgg/HFmS1IujYjm95hPVPkEFZysRm8R6vx0cPZ5lhpsK+AirMrMVe2CToecF6jmq8XRZEZ1xWEbjKu5JnOf+S+cCTtSNuiFdv5QBXPeiRhrH5NrsCLJu50LnIQetx8A80JOKieBjTXRJyXzShIxbAZbsJ7CDDxFXnW2YL+IDZD1zS+HZ/PviDhpJTuaRfw2ELiZs+7xkg+yzdX9M86izBO0ZnCyiaDUM2fdrdH3F3aWizAQTIOm6G2vaKA5pk6VrhW3ZtO6mPtTORnGJAlTZtx/fXXm66TJ554whSxcA4nnXSS/Pvf/5bzzjvPvOamm26SG264wbwGH+CKK64w+QV827QLq5O0GcyN5Zl7JTp1DJ12qHrlXQYNGiR9+vQpp9sz2Qw7jsAnjLs7iLhDfWJ79AZH1KCDjmkix5TWWEPnHHjEngMf1s+083Bx5ppyzelxfkEp7FXnsea5tjSZNf0I/pU+X4rYMuXOKgJoXogzKkecMWbMGJMTd9p8bAi6A5+D/eWWO1J7QU4HzIQiex03aheO8Leoc0lO4Xp1rjo2Ki5dR0f2sB/nyTsTZpuO7PaNasqemzeV/l2ayOYt6pSx2taqU1eKGreXz35dJOOmzJfPpi6UxSvXSrOa66VtnarStUUd2aptE9msTWNp06hWRvA5jNiYR9t27eX3JavMvPNf5i4zRcGTfl9qOuSnzVtuZqt3b1NPureuJzt2bGiYu1QfzVmyUj7+fq68O2G2jJ+6UPp0biyHbttC+m/aRIqqVgk0ipZcklsOxqv4NSrJF1YS1ibFvOAa+Lo6egvfnnNMitk3LdDcy2awPvAFdtppp8TOpSJKXgLnAJk4KyzuTEFHEMHw8DkAb2pk9NKjTIrr7KJ8oFi0qeLDzIUPU5mcSfEqRXE+gDU4I5rgiIMWOOic81zm17rRsSgIEaa6kD2I40NCLB8CobRBc+4HM82HDx9ujExlSXj+mYITAgccpV133TXUd+RiM0gooIcRQL6gRShuXYk4vprACvJ5fBbOEVSInIsGV2mJFgvlQ9e7PifOgcIl1alRsKwEFX1OdJujg6Os2A4j2iXpp6grCnrcTNW/7HXAGOxSUuwEmUSpN20gtWAzKh9wrjOpSbySRM3W6RfEZvDZ7C9iFLoI0THavYzOjxu0yEVI6PS7bZTkg4z+e2+pXzPd2aOZuj1IXhGH2d3LCjBXBrEpclm3/B9gAruRL7OToxDdmzpflufH9eFnsi9JCga91rRtBl0nMD488sgjZb+DuhGdRBc6eoyOqb/97W9y8cUXm79zvbzn8ccfl6OOOkr+LDYDgJd9TAGMU0hC45/gs6ku95IPP/xQevXqVQaAZ7IZucYRUVF8amc2a94evZGLPeLaiAPiGtMURjgXew68Ak5BWZLsEVT5MBs7DAsXB2vU+YzR7/Z4rXy+tmy5My1u02fMmqbYPp9B87RtRkGiizPcxn8Qa2BL2FdeepG9h24if0wszeu8imx1tJDmksgrhc0luQnnS67WjmOSkKUr18hHP/wugyf+LiN/nic1S6pI17prZMdNGsl+PbpKi/rlx/DNXLRSvpuxSL6cMkcmzFgok+etlLkrRFatE2lYs9gA2I1rV5MGtUqkUa0S0/ldr2ZJ2Vzz6kWlP6GQ1/nm/GS++ZKVa2TRijWyeMUamTVvoUyfs0BWFdWSeSvWyZzFq2Tt+vXmszs2rimdmtaWTZrUlk5NaslmLeqUzW5H+LxvZy6WTybPl4+//12+mr5Ytm5dV/bYvKnsv1ULaVKnWuBcktd4EM3BaKwZdSOezUqixWNpNePhaxDHK7ul7WO5jXOMi9lXRx6y35MEzQs2oxIC5wRin3zyia+gI4gA2JJgJdBh4RCcREnNzmdC1UlFF0FNEhRTmYQNjwHzO08jV3Em+VAwSneFw01BgXbm+qG2jFtx2on3JIx7Jrp21gwOOs8p12IL1qFWT2mwF4QVQKuHtWgl7UAoH0BzEkVQ6hGYVERqzcoufoITnJTRo0fLHnvsEfjzMZFhbQbfa+vhKEA+53w+7UrMVinKNZDw4z1pdXTYAh0odjlMsVBcVPHcE2jt9DnZ1dphOzLCjlbh+ZKAT/s5acU0vlMu43LC0kja1b+I2m58ibRn5eLTUITCc9JOgILNqHzAOXuABDHAEeuS4s9MYxOC2AyKUthfJM28RhfZoAU/lU7WpgDPF/ny14Vy9KOfJfJd/9yzs/y1V5u8un43ATDX+IdEpXMuehLdHkkK4CFJIQWYWLO27eT3ac7AjaNLFZtNvMV+DzqGJB9sBh3nDz74oDkH9BA6ac899zRd6Mcee6xZvyT48GdJzqvA4sT/oQT+s9gMOvv4P3bAFvQzRecUghKzZtNLPGvtAMtkM+KII6Lw02yGJtVfQTuztTMQ/8n2vfNJbMBJO/Q0oY4N9tJl6AP8VeKEfCjyDCLqcyioTJ5Mr5f1yhrguXFNrOGKdG1uwt5zxnpcMwXdFAflm73KB5tRkOjiDOf4D3Kf/I61x6hat1hXmyqITdAxYCZBcrYA3Qqi27mkMAxXvJ/z4HzxH9KKzafPnCVvjP5Wpq9vKBPnrZGJs5ZI6wY1ZPt2DWT7dvVli5Z1DWBtzx/XIqkfp82SidPmyOwlq2V9tdqyrqSWrJQSWbRynQHCV65ZV3Yw45xLZK45Hd9FVaqY2eLMN+eosmq5rFq2UDq1bSUdWzSUFvWqm6Np3erlvlsFwB2g/JsZi2X81AUybspC8/sd2jeQ/l0am6NpneBNNzA3o7/95pKcxUTY9lwa8fIJV8AeE5eor5FtjSo7CffBLijgfuRSLJgmaF6wGZUQOMdZIckQdfcZQS0KgSR91PPM+Vzt0M2VDj3K7jClf0g6qcT9sB1upR7DmAKQpJns1go+wHw/ijNu4JxONdZmHLPKNNizE3Rctwa4zq4lpaVSmsECaL5OLr30Unn99ddNYJKkgStIsHVOMUy2fc9M+r322iuQPtQOkDA2Q2eI06EbZB502JmqOLtasMRhdwho1wPXQZIj7dELShuVD3O7cWKVTpYANdNzsvUpgaLqU+63H4rxikJl5WRCgWYX0DBJcav+ZQ9qEjLbuIO4BQp91jGd5jZoXrAZlcNmqFAYAVCCbiDQHTVqlPEFnPO4w9gMZrmS2CAu8VuU4qSTVdBC6WTTLiZxux9T5i2Xh0dONTP5wsrArapK3y7NzGzCNMdnhBnjgJ/vxRzinItuz9vLt6IIP4LOxp6q35OtmxG7y32paNepwj5XqmLiJvt52pTuXKcbU0S+2AzO47LLLpObb77ZJEfRM9C0c24Ieo+Z5ugsmzHuiCOOMNf0wgsvyJ/FZrCniSmI2/VvjNXh9+QV/DLqDRs2zADh6G0vm5FEHBFVsT4ADLGGTQWcqTFBZ79mKhrLRyHXp9dLvg3fX22wxl34q+hBQGYKLCqCvcr0jO2CVnJ8XCO2Cp2XdjwZpWhBAD95nvharG99xhxp26ukbAb66ZZbbjEgD4yhr776qhx88MFlf0fvXXnllfLQQw+Ze4R9uO+++8wcZxXWDV3xb775ptkDsJhQZJV2/JZvcQY+BPeEZ4mNpckBnYjed1trfDa2AeyBhqtcwepcGK5o/uJ8KRaLmpEuDOMvNlhnxQN4fz5toQGjP5u20ADpAN+b/NHl3blpbWnbsKY52jWqKbWrFZVj01Uac70X2XIyOo+eZ+jW4c35MKcdqvYp5udymTh7sUyeu9wA6wD727atLzt2aGjOzw8Ne6Zxq0rxHyaX5NaIF5QpS3OPSJrMHdhs9BjPI4w9zsROEoSJMk3QPK04Y/r06fLPf/5T3n33XRMHoicee+wxkzvza0fySfIOOA9iaIIIigwHl+QXCiQqp4fgCaWA4xi02iuuLj4MWJBEXFyi1BxsBAJD7j/OaNK0t06ABEWX9Lw9KF22vHZIOeAcIw94lBRlMvvKBtmUak1ZAXDcuCcAa2nTUuVDp/m//vUvef7552XIkCGulHwFqTg2g78zm3b33Xf3vbZZA3oEBc0BW2AgSXIshRYsaVcitgg9S5CPniH4wUalPQ86U1CRtGjiTp3YIM/YqU+zUYz7nYOIT5EmlZUK64jziYIJJVch+ILKjufDfdHqXw1cWEdJJiZJknNQ3KA0qwWbUblsBs8TwJyEIbpKfTQYsfBJ3ApJ/NoMe2QGRSBhWZg0saFdI7Z/zc986gIjgYOu1XnXQfark4mC+2fHEfl0nc5uD2wD+jyXbo9cZ+wm7bcD8NF166ebkevlulSXV4TrdBtrhS1wxv8kGu3r1JhLiyMoAsuXOINz+Pvf/26AEmw+eY0LLrjAdJyfcMIJBeDcshkUzeE7EisrkxPPmX0exKcdOXJk2RgDp83g+7AP+TL6z49wzuh57cwGgGA/KyOW7dPyGhL7XH8mXVHROrPRAawB/k2jSEUqCPAjxCfMRkVHs17Jq8VFZ5u0YH+xXzreUu2QPmM9ch2HmIskGWcAdKCjsG2HHnroRsD5TTfdJDfccIM88cQTptntiiuuMDEjxd/KxrbPPvsYH/qBBx4w9/Gkk06SHj16yLPPPiuVXYLgGdgQclPoCnLD5IW9mqlYA1BvE5/w/KPOkbqN5XBjuDJFsX+wKdlgddLCeZBv01gtkw0mFz99wQr5fvYSA6IzZ3za/OXmgGK9fs1iQ4PeuFY1Q51ev0ZVqbZulaxZuVTWrFwudWtWl6YN60ujBvWlOmu8Cp/JOYisXL1WfpoyTRYsWS4NmraQleuqyNwlq+X3JSvl96WrzHzzJSvXGvr3Do1rSfvGNaVDo1rSpXkd6dayrm/6db/NnKy9qMatujXiZWPKstl9Wc9p+fXYLMBqLWLL1R4rQ4HafWXTUpvgVaSQJmieVpwxf/58sycHDBhg5qpzf8gBc/16D/zYkXySSg+ca7czQQ6dvfwMUj2USZSahM8BqE6zolQrngno8qGLD8OrM8TZNChOu4MMg6zKxi2oilpQctqFn1bVtt11/uax7UxQnBZ45ExEsud4RgDVPI80C0DSBs1Zp9ddd508+uijpjLLScdXkIoJgkBphvHOpmfUZrBHEHSFX32hIzsoYCLwTmtkB+dBwENwpYE+HZIcaSWmtQIWG4Azn3aCRau1o6iSdnaBIvY8xGz3m0DHtpdpF+ARgOK0UmiRVjDsDL6005y1rACTBi5hq3/DiBa8kUzSDtKCzahcNkOr5AG+nLqKpDF7wtYZQWwGr9FOgChHZqh/rSA6YB57Qf3rNHUKe1UpjHNlE9N4Tq9TuyC0WCAf5uNq0TCJJtZPmODfq9sjn67TFuIJ9gxdAkH8dq6T5Iodi1SE+e/6jEnKuYHmbvter5PYggN/jPv21ltvSd++fSVN4ZldcsklcvbZZ5f9jjiI+eYk6P/sVO22zcAHQPfgH3E/dH51kH3OeyjCYq1jS/ARVS+ytnRcTz6M/gsr5HhUT9uJdvYCgAsFGl7MLRVReG7KpqVFEGk1isT1PEn8cy3KzoX+U5DN7r7Ph87sKEDzIOMQedZxJvrTjDN4jjZwzrlQPAr178UXX2x+h1/Gfn788cflqKOOMoWDnCNFz9pd+N5778m+++5rchNJs5jlM55BvK0MUviMbh35Os6DHBNdnLkU3foVL4YrDm3SwPa5sSklIZwfRQdR5JUWLl9tQPW5S1fJvKWrDdg9b+kqmb9stSxfvVaWrVwji5etlCUrVsmKVatNNzh+X7WSEikuKpJVK5ZJtarrpWXTRmYmeu1qxdK4TjVpWqeaNKldTZrWrSbN6laX+jXji8WIXW09FpfNcTJlofeUdQU7r7PEsQf4SWnhY1roZdusqMXJpuVmA9MCzdPOTV1yySWm+Gr48OGe55fNjuSbVGrgXBNZeoksXu0SUzoSjJOC6EGoVpWahA3gRaWSlNhBVpoGTIWEHYo721wnJ+2t31m9aQIkUdK1f3LhDmXdamkJRhZljlGjGot7xXPh3xoIJAlw5QNoDlXhPffcYzqUWb8FyW/xazMGDRokffr0ybie3WyGX92ebyM7bBuFbtUEFnveTsAnAai4FVLlAzAcByOADexg21gP9lx0Z+GGBjrYSZKkaSfXdHxIPhTgafDFnvUKvtzm0Kv9ylT9G0a0A8zuLCvYjMplM5RilTXnth/ZqwAZAMBBbQa6AD3IOuaz49SDBOqq8/m37gn0fpJV3EpHT9Ii6kRp2NmzcYpdBEXiKspuD/s682kuOolVrpkCcrosw4rO7HSjOtfrzAcgRosAeSaA5kGfMWvj/PPPNx0gxDr4IgALJ598spx++umShuATkmCjK0SFLhAoFUnUa4KL5BZJLoRkNfssXxNccdkMdBpNCvhu6JugTE5qMwCPKEjg/6qzWO+sLb4L/ZF2HBFloh39RYMHdpDrwvdWxrt82NdRxFw8O2wd15ZWo0gcool/pYV2e17sB5sxBT9HdXc+M4lgs/H5gs5rZ9/aoAlxiI4giXpdpx1nOIFzP4VUgDXYCgoq7HuN//nSSy/JIYccIpVZ/OamAPdGjx5t7jE0xW7+BJ+FDlW/g3ucNN29Fo3QGIINVLuFrkuD4UoLnDmPqHztMM1n6HfWNbk0dCM6Pg1dh13V2DVJdkmunXuhhRS6VvBliHPTKtpmn2CztLk1CR/DyaaFDcRH5P4AmidJP562zUDIsTIiFV+XcanEhwMHDpTTTjvN/L0iFuTmXfljlE6G28wonFUWL4dNR0IQhDFXEN2rUtLu7I5jLnUYhaVV7z179kw9yMK5ZgPgJBM8ZKoyIgnC0aFDh3LVS1TrKpVdpmcRhLo+Scpkv5I2aK6gBPdaO/lQ6qwlfRYkTJKqIM4H0Bwlfdddd8kHH3xQAM0riPhdjzq3MY555vbIDmjI0uzu4zq0K9amzwI4walXQAU7hm6MO5ljF1IBmqedPNE5WDj0cQDDrBscZQ7utwIeBJp0bikQwD0HlCPQQQenTaOvwDA0SjisSYwPyRU0d95v7BeJLA1cbPvFs85lZjCOP/fGCZoXbEbFE681QKCLHie48wq0bTsSxGaQROeztfI97gp8kmocMCypT4ceYk/ge9oFw3EI94Y4iQ489EkcnTHcb/s67dmz7FVNYvuZ0xiVzsLWodfRE1EVQXldJwe2DB2Z1lx0zoEYVMGiXITzZm1ycJ12XEiCJddxKPkAmrMviDFee+0104XBZwC4vfPOO6mChwcccICZaU5xOZ3ArGNo2gHzEc4N6nbAdeysUioCptv0vZVV7GdDQQcH9yEog51tMzQXpeM2KDBizbOm+Oy0mYeiFHQhABr3ilyVAo7YBx0rxcG+rogguvrO5FI0L4gu5iCnoY0iFO0644C0C5+yCb4LcUo2xkaeI8A6h92ZzfXmK5OIguasz6B0wtwHO4/JNSqdO+uaz4xiBEk+xhnkVhEnYwT/17/x08lYxj3hXuhrKrP40WPoRGwtOQByJF6gOfqD+IE91qtXr1RsA/4W58m+Jp+ED0DMhA+KT5QkwxUxDftWO5qTzp3wfVrMyT3AN0en46dSCJm0rtOCbz/YS9TCnlb7rQVWrBPilGHDhpXlGNGFSRWMcT/oNCcmwZdKyqdg3fOdHNhAtfc8D3KP3J+k2EnywWZMmjTJzCu/6KKL5LLLLjPsI+edd57ZE4yA8mNH8k3yruMcwfnI5bTCACC83p4PiyJQpxYDwWfweTqzjkRQ2p3dBFgYXDYqmyLtIEvp0MPMi7VFaVj1WaiBUufTr0GwA5m0O+d0DtqRr5ZWY+mc8zTXDsYNYw+45nVPvSqIuZ9RznbKB9D83nvvleuvv950JhPYF6TiiB+bAU0Neht9HiVoztql2ypfRnbQLUwilmvNNgZCqRSdrB8cUTBNBCmkilt0rjAAaFojMmwgAL2KcJ+Z+at+Rlqis8q4N2lTg9o0X5nsUzZxs19hZhNq0QP3RvVHwWZULptBUIvuRE/hw3oJSRHWDUUxfm2GznMl0USCNc19brNusTfQP6rzo+qQ0vnwSuOYRpGoc06jgjNxga6ayONac9FZQcWei86RZJefdlhyvXFTLjvHS7HGbF2eRPyLvtAxC3SIhwHN8zXO4JoAwukqZM8AiB999NFmNqJeJ+d/5ZVXyoMPPmj83t69e5vrSXM2e9L+Gz4kBzmiXXfdNdD7M8UZrG3iCE2ossbRKfkybiNXm8O1uXUG6r7WOATR3Fs+dymrcE34zfgPfn1n1pHaJqW51WecdOGT39yM+i6ViTFF2b7CgOa5jCAJAiDli81wdpyPGjXKdEcTG9kFc0cccYR57QsvvGDOmbm1+NW2sNavvvrqcuwmf8bcFPeOvLDaT3QChXS28F61DawdcgVp5VG8xtPa+9tmuFKdFjVAqOeBz5lUJ7FXQRH6w2bhsGeBcy9U1+m9iIPBle8g9kgaJPY6D3xHcvmIcy56EgxSCt5TAJ8LFhXVeZBPoOBM7wX7PG52knywGQi+HrES9kIF4BwAHZYNP3Yk36TSAec4K3oEBUDsz1BHngPB0UEpIEFnWcUhCkhgnOimThOQsBODQefbBXE++Q6CLJtm2K2jI0wgE6dwzkrhfMoHK8p+/8X/9ZNqRck/N84DZY4xD7J2Ms12yqVblc/E2Ea9dvwK6+Xhhx82CSK6PlDiBalY4sdm0N0DKOIsosnFZlARB5CS9hgIW8+QbAtDFa+griZzcGoVUAnTrYfeJrjhvgTtyolaWBta9Ma9SZrizKsaFmcZx1LprVSXRlmU5EewlwDndjd1RQfNveyXdqNjB21Kdy+fjoph1o7dhV+wGZXHZijIiy63CyO8hCQgYCUJm2w2g8/XgpR8nOfKddgFwza4HLaQx2bBCjvfO25axah1LfEYPqwmNtOydbaPbo9l0WR9lJ0vqhfTYF5jXykNMoc9Xirq8Rz2d+osTZLbQeOdgs2o2MLewi9BjxCrwtwxYID/4vdMcQbjcbBB2BS7aEvHFlCgYoMRHBWF6pviXHJVWqSfSdeyR7T7XvWXFsckNVYqiHC+PDeekddcYr8zhNUG2zOE0y4c0BEcUedmvObjalFbUpS62GzWVNSguVNsME0BJGI/vWav+DqfbEaBqj263BT/p6mLHDVxJboNG8Bhg1zYCh11lPZYWM3x+zkPZbjCbkU9hlUZjsgptW/fPrX7gW4k30ZBUabzsNmh7LxaVGCp5tkoakqzKJvnjD7lHHSMWRp6H5wOP03zjmlJtpnmyk6iTTTarKuxdy7sJPliMxD2xh577GHOSYUOdJir0HcVkaq90gDnvF6reYPOps32uSQISJZhxNSpVeA2DadWq8/yAZBA6OAjiLRpgeMQngVKUatWcUSdNMPacclrwgYycc07JCnb/YYR5f6edNc5Dg3KXAsuwq4dt0AgTCWZguZU62Xq8opLuI4nn3xS/vnPf8qbb75plHVBKp74sRlUtmGgFbzIxWbYxTnovbRHdij7iFbO55pgsuf02ICKXypFna+e1r62heer1Kr5AOQo7aHNzOJWlGQXiMVF9WV34QMGpD0+xC8TShRi2y+7+pf7rSNJtDCGPaVU0wWbUXlsBgdJB9YduiFbNwDPHlpC1gy6jSITrzWabwxV2YTz1c5lG1wO0vkXtR2KQxSc0evMVdeiO7jmXJm2ohZ7Xrh2AUXV+aIxn60X0xR7vBSJxKjHS3EvsQOsG7onwoDmhTijYosWTpB3wW6MGTPGJAT9vM8rzlB7wn5iL2Uaj8MaV0DZBiOIZ9Ie0ZetMzDTXOxs+kuv2S3fk7a9BMDhHPEdongGXoVPapuStKcKlEUxgsNP4YDqb4RrVb8jqnEnbqA5tp59l3TjkRM04blq7KGsmvlmM5zAOedHZ+nFF19s5phrbMtze/zxx+Woo44y/i95RorEtZP6/fffl7333tvoPN7/Z8tNkRMGcFW9oTlqYk1GG+20005lBb3YBnJMaY6FtYt/w+T4o2S4Ys2Q36cIGZuSlugIWHRjkDXsllfTGCsMC5YWEaSdZwOTws4HaSDKpPfDFjP7Ae/zATT3atbVtaF2X4sG/cak+WYzkGOOOcawP9O4pnLhhRfKJ598YnLyfuxIvkleAucsGhaSX1Ejw0bUoCSq5AVBOMCnUk8ocMtBJVHSNFqA+ATwdDVAQ5Gm2OCRFwVynOKkGcYIsw5wTEhupB1MKg0UBgDnnABgi2s+Tg04536hzFHGUXfFqHOkgYCfWYT5AJo/++yzZvYG8wZ32223xM+hIMnZDAw16wy9mYvN4D2aREXvpQ02xs0+EpRKUWeIpxnsqWALcOh51k6KyDREq4Mz0R5mojWMikLfrnrHpyCpkXaRmYLm7CcC4ySTWdgvDeL4yZoGfOF5MepFkwVJ2wzWCEkLpwwcOFDuueeejX7/yiuvGHou9h86kU4hgpHjjz8+1vOsiMKzJaHHuucZZ0vQqs1gb+L36hghTQLZHdrce+IG9A96J+1inaDi1fmXiemJ+4IdQlclvX/DihvFJP6qxnTZYgjtyMsHxpls4ux80QRmUHAZ+06xVRoxX5LjOdxAc+xk0L1ciDMqX5wBiD106FDZa6+9Mu6bTHEGtkELOtlLQTrxnOxQ2DC1Q3HRn+bSoUjXUa4S91ipMHGFNkTEEVfYhQNcszIOxMmq4QSGiOHibIbJVNSmrFDKahjVTNi0QXOnsIaUVRN79dJLLxn/HWDwrbfektdffz213BRrjnNBWOe33XabYdngmeDv3HTTTXLjjTcaOnZiWkZ9AApjL/VZ7bPPPqaQ/v777zf3/qSTTjL5WeKoP1tuSsf5gBU48xE8f9grGH/Ce9CdAEhp5pg4b21E8zP6LyzDVbaGDC3wB4BL2+8kHudcch0BazMb8+y5xiDAsWJBSYxJyiQ8R/Y8bDlhMSmuHZuu98LW+36L5HSkiDIRVBTQPFPBs+b//DQl5muc8emnn8rOO+9sRnNAvz527Fg57bTTzLinY4891rzGjx3JJ6nwwLk9M4rFFKUTpBQpTvosFbsaln/HWQ3LdVKNhtJGYadd5a/0lvlCfYtDgtJE4XJuBBVpzoxSulnOg+DDNoI2eJ4UcE5wzvlgYINWfscxizAfQPOXX35Zzj77bPOTCtiCVFzxYzNY/6xBKOfC2gztUEQIutPuekiafcStI8J29rFR2M20Zoi7dT9qgiTtWYkaYATVeW6Ah4LoYbvplGJSZ6olnXj0As25HkC3NBO/rHHWMeAoa4dg/+OPPzb+HU78VVddlZjN4JlrpxpCMoUuN86nf//+G71+yJAhJglHYRznTuIN4Pztt982Sf6CbFj/3Ct0lh9/yC3OcBvppHty8uTJxid2+n4VUWymJw4ADKX/5npZZ9gE7CKJE0DkfABuouhcVhYKt3ElOt+bYrU4O/LiEE1g2uCyXmcmmkDWNboxH0Z6JDFeSke8sM9J9ocBzdOMM6BCpPvk3XffNfuWvfnYY4+Za7Fnlj/00EPmPkHrCI0iBVcF8Y4ziAM++ugj2X333T0LrjLlpvDp0JdRMHNoF5uCETovOxf/MFcB4KAoM67xJG5jpVR/RTkrNFtc4afgLg3blIsom0iuwFAcrFB+6M2z7RXiDPYI15c2aO6mM8iLQWP7wQcfmOvbcccd5YADDpBDDz20bBZ2UoKP7DaO4oQTTjDdgGo/AEGwH4C+zNa1z5P9ec4555gOSO73YYcdJnfeeWfqOeOkbQZ7Fr2BPqRT2bn2tEmvR48exjbw9zSL/bUzHn3HeURdqONsyLDZfJV1AeHeAaBxf9LEGpQdBp8q6vyWAsdq07QpU3Wdcw1oc0rajE8aA0XNAGDPiPfDZqt7K61xr1GB5n7o7YlZFE8hVlN2knzGM9566y259NJLjU8IMA64D3iu4seO5JNUaODcDkzCzjPPVt3kF6R20mgpJR5HrgbHpnxEYafd4WjP7M6Hee/a2a2OBmJTgNhJIdsgxz1DXEEA5/fZwPmH5+8krerXSESZK2tCkoG02yxCHB/OCaAvrRkkVGSdfvrp8txzz5mgpCAVW/zYDIIR9iQgcxibwZrVz2Bfpw2IaGFXULqouAAV9jb3FMcIACXNogKSxCQg8qX7MaoAwwvwCDIPUTvoCDYAzdNmZiEwoPNXn1XaoBv3Fv9GGRNY13fddZephsUnJDijg/vAAw80/mGS53vBBReYIIQAxO/3AnLtt99+cu2118Z+fhVJ0BF+90u2OIPXsJ9YH+hCXqc0ulHM0M4ncSY1KLrhXqbpz8UhTkBKWZR4rvgC7MF8YFXJVTSpqz66PRddmdSUXYz1jT7J97EDUcyZ1eIyYskwoHnacYYmmgE+zjrrLHONrFkSeprUo9PjhhtuKNfpAfVnvnZ65EucwQHlMPfWzc/NZDOUvpznQYFblL4p32nrLEDdICOWomIxIjYhF8N3xi1eXYyZ2O4qelxh2yal+o7impWSOe2uzmz05rY99nvN+Q6au9kM7A5Fr4DOPBO69gpSsYR1RzGKjq7zmg+OXYAVkVgB/ytN/QKegY1ijyVRHKQFjgqio9N1bAGd1fwfXyatnJIN3uP/5jqn3a+fyv1QxkFl+4INBD887eYUbDz+cdwxUDY2Wy04SZuuPg7QPFtTIrkgitz4zhdffFGef/75Ap6RgFRY4Dwu0JzPxMApRUqY6qZMNFpBP8+u+soHkFo7Lrnf3J+0ZxgCUhPIYMigLHEmKJ0GWTsklfop6vPH4HE+OD4AWm7rMkm6dowuypwqrCQ6UrMJRh8ASZOtUc8i9CMYG+iinnrqKVPFW5CKL35sBglBbAXFI+iJIGsNhw09zD5Ke46pPSIjH9hHsFE4rtgobBw2D/sZ1TzVMDoPHRxmrmIcQoUydGdRBxh+AA+396h/E4Z2Nq4is3wBzZV62dkppTYDAB0d8sYbb5jE+e233y6nnnpqYr4XBTJU61522WW+9ARdcQD8JOP8zGP9M0nUcYbO34OhCkAOn5OCGfQivibryYvmvKIKBcZ0IOPHaVFkvlEGR90dwzPl/+haEhaVqTDCjR5YwS/+TSK/snSKORNydPXYCTkAQP4WduxX2nHGJZdcIiNHjiw3W9AWnS0IIwnzBTV5j57K19mC+WQzBg0aJH369NnIt81kM9Ad+F/EEF4ASlTixYgSVwOBnTsjVxUnuJDpmrVpQq8501ipihxXeCXTlfJXc1x+iwOx48SUaQMyUbEaOnU9z04ZIPMVNE/bZhQkekEnwtRDvtyLwYH9R56A16JXbApzewRUEoL+phEtjsKuIM1WAObEVPyfPY1fEmTec1RiYzCA5kmD98o4qHgSa4HGFI642VWyMcqwprGrSYk9F53iKfWziMPI66YVW9ugeVI4C/uChhMozvFF+U78UQp0Dz744NjA+4LkKXCOorLpKW3hdDUwQaKcZ45iJGmKREWRQqClSo8NH4RGC4WJAUuq6iub6HwWEiduIHXSoiA1ituN+sarQ1KfB++3aftyBRE0sIK2ka40r2ebFHBOEoTzYU4q3QRpi9KpaGWY2yzCoN2TQQUDQ7fgww8/XEgMVSLxYzO0QlLn0uKI++nCwEmkqi8fKFnzhbYqm43ClmryXakU7eKxuBxLnSGOzuNIO7mlHRxQasUZYHgBHpo0JGHE2qF4hIKlNAJAL9Cc82Rvpf2sWKesHXwJe5972QzOH52TVIKYiuJjjjnGJDczMUxg9wmq2YPoOiivTj755ETOsSJJVHGG3WWHDrT3ub0vlebcHumUFg1jrsJ1YRNJbmmiPZdYp6JdM/69zqHTwohMBUsVVYj5SOZSfIykUeiaNBBDLALQwrWRjEPXBn2m+RBnYFMZz0HymXnc2ISBAweWUSTil5Bcw39TpjakX79+5v933HFHKuddUWzG4MGDDa2usi9kshkKTAKgpMFSYTcQcHCOOmLJL7iaSdD9+E5cZ5r0wm7zstUnZk8DwOg1B9nTOhIrX+KKIJS/2UZTKAUx/gtxQdqMllGwGtqz4FnbxBkUuOQzaJ4PNqMg0QvxGn6TW66GtYtuxhZjGyjYZs0mWfBkC99HY5POiU5Lz5FLxy9BT9Osouwa/J58gd6PuAv/sRmcBzok15EquYg2PKDbKbjDrim7iuZ4omZX8RL1Y4j7kmCU8RLWAwUN2HTiFA70vtr3pJpC0gDN3WwGY5YovKKpgxzWbbfdlth5/NmkQgHnamS04jdK0JzFj4LUzqc4QLsgNFpqOLRzOW1nT0FhwCY6atIOHHCUOZ9cZiqSxNQAQ+cnaUIzaLeMgtQ4G4DU2d4b95xzDCvrRx2gfAPN/cwi1O5JjGAUIA9zYY888kgDJGBs0l7DBUneZiilrgYlOlcJvabzYtwS5TjNaVPXkZwieZM2bZXTZmYrXMpEeRslfaQGfWlTNiE2tW0aHRzOeYjYM/YH95oOurTXDgk9qmXZU/kAmqt9osLeBqXzyWYAgpCQhrYxk2gihv1Jch+KdjrO3Wai/5klijiDz0DnkKwFMMhWRMHr1PbgU2ugz5H2ngzTWUii3Y1NRGMd1UHEU/YM7bTjmbAFa/io9jVrYYTGEVqwpHFE2mMwchGd700RBOwkJOn4txZG6DPVQteK9ky9rhnWCDqD8Ql53nYRmh/2nHyxGZo4hKHk8MMPl08//VTOP/98uf/++82M2lGjRplkG4CZXSh2xBFHmHN+4YUXUjnvimIzmP+rcUEmm8HrVXdgI9IGJhVoVDuEL2aD6EHBAfIo+E750lDhJs4CNrtpIpvt5fUUnJL3SjuuCCrqb+hoCuIQe1asjqPAVsdNQZyUsB413mTPsQ+xw8QZXH/asUY+24yCJBtn8Dd8aeJPbIkzT+BW8KQ6K0qmI84FgB8GKXQ4n5+WKLujWy4dW6X3gvuiOXtluIqjUZDv4J6k5d/yzMn7AeLbeT+bUUZZN1S3R1EMl2nGO/FAmn6M2mSeizID2mOYFM/RvRIX+1maoHnBZqQnFQY410pePd0olRhOFpuQSp6kFn8mGi2ukWScXxA2KUOWL9W2Wv3LveF84qDt024ZFG82Z1s71QDwWUN+JE7gXEEAumKo1st30NzPLEKq+u2AL+gahK7wL3/5i6HWpfsu7TVckPRthldQgiPGeiPZhfNMsitJqnE34TzYQ0o1lzb7iBbmBKWutylv2dtauJBrNbXSoacd9NkFF4ylIMDIB1YAAkBsHGuetZMmiMVaJtjQgou0dTFrmftDYpRCvHy0GTAX4Ju+8sorctBBBwV6L1TyFHBQnVyQ6OIMZdugmIFO86CAgxa3ANIR6OtoC2WIyEcJ01moIyXUzmqCJ+rkX1zCeiD+4XlnY+pwFiwpdb3bDO18Fp6vdri4jfRwGxMS5wisJESZI7DbFJepz8cz1SIQfBd+r7GIMzbMJ5vB3uQ6AMhVzjvvPAOgjx49ugCc52gzeNYU2rHevWyGjrZDAEbyrThKY23VzSSClRGFI5t+13nt+dJQEbZpgnjPbppQga0BXz4f4opcRUdIqh5Dp/O8WNO2vqsswt6jOBf/gmslr6exTz4Ve6VlM8idElc4BVaSe+65xxTawlRiyxlnnGEKrwqSe5yBX0EeW33pbLZB2SRUV7O+7YKnsDkhfDl0HHEI55H23GyKNckLZGJVs3P2SmFOzKR2K1cK83xpFMSvJsbMNhrXi2kkKmYzLSjls4kH0iywwj8nNiEP6mWTWRtaPOU2Fz0KvZ8maJ5PccafUfISOMfIYGzinmeeLzS8dhckSgFlifECOI+jciiI0G0JgOTHkCUh2lXo7AyLY46GdkgquONGIY6h0mpkO+meTeKia9cZrfnQdRkGNPcK+DRxFcYIkiQ65JBDzCyQs846K1L9wWdeeumlppMDI+Ym7OcbbrhBnnjiCQPwsVZuuukm2Xvvvcu9jmDllltuMTqAJAvzdHv27Fn2d5wh5hE+//zz5p7QgUiFsj2L988qudoMOyjh/nN/cTYphmGmXZo6ON+SU1F1dtuFC3byPUggyHMj+Ic+Km46dL/XROCH3vPqxkxS2BPoX4RqZfaCPRtQZ/UmBXjkG2iuTDHsc7vILE6bEUauuuoqeeCBB4y/GjRBQmBFBzodcgWJxmaoTo5qDqAmtTUJBMiKvo+jkyLX4i2lPA1jE53JP6U5D9vtmFShAJIpceX1XtWzcTKtRC2sf+w7iSGSZH4SujoCS8eE2FS5+VoE4tZNQ7ybCURCX9jjpRCKKrhe/ES6BfPFZpA/2GOPPQyNo8p9990n1113nYlDClTtudkMfATAJ9a4m81IgsUwDkBZdbN2KOtsWec+1jiAwtl8YLULKyTZNQZhb2thDM9ZR5GkzTYWFwUxRROsWR2TlwQddJKgubIgcD1uxV4a+6Q1YiXNOEPjPxX2MvaCTkZAcw5i/GuuuabsNewNHU1RkPBxhsYPYW2D+lyqq/HNdQxFkLWs87vJLaLn0vLVdJQJuRyKkLmWIKJ+GeC/k8I86Iz4fBnLQWxEboKiH+5JkDXixjSiayNoTopno+MhiQfS9Od13Cb3g3gx6BgmZ2c+6yxMwUmaoHm+5KZudME+/iwYRd4D53GB5v/f3nmAS1ke7f+1966JDY0txm7yiaIgCjbsXZCqIqggxQYoYpdiwaCIXbChCIpUQSyIoqCJmti7scSS2Hvd//Wb7z/7Pedl+77l2d25r2s5bDl73jrzzNwz92Q8k+FVaVccB53CKklSrYxWNWCOBdtUjpGKE2lU/7oS4pwPt7OC9zDirlxIqThvxqvB3X//d6TEOQsGFkFxFhUkTZqX4gT1fOAEw/cHwdNBBx0UnH/++dJtEaWToXMDWUMCiTZt2uQlzgcOHBjcfvvtwQ033CDnhs4/5BPpBGGxCpBF7Nq1q1Tz7rTTTvJdEydOlCo/vdZxkjNmzAjGjRsnC6GTTz5ZbOL8+fODRkdUPoOAhmsWf8ACM20b7CanULNIOxkLcUdXVtQ2OFcg6Eop5qqY1Q4xTW6lHdDrDHGCFkjzpGYsFatWJuCC9AkHXoVmA8YxP4xzij3mHsIOpn0ts+8EP3pvJeEzKr2uUNc5+uijJVhxgc+gYI/CLMBPiB/2icBl5syZwaBBg4QwofPcUL3PIDlDxXtcNjk8K1w7KVhjptW1zL2CLYmyeKsa+VzfE1fFlFaAS1T4Qqpx/RNDYKtJklXSqZJrTIjua7WdQHGA6xCJUshkbGephSocK9aLrNUpimV/KcDv06dPcOCBB5ZVSB0HOnbsKOs1ulMUp5xySrBw4UKJPdhv4sTTTz9dkl16n3OeiDFszm5hn/HUU0+JPaThIuwz0lAxjBrEPeqHuI9dWVxsGWtvSJ96Sopybjl32AOKCLB/WsCW1AzZpKR/WWcQN0Ec1JN6CH6bdT3XK9dnrnOWq9irnHEcUcC3OKN///4yI5f7mm2BOCduzJfXMlQWZxA/qG8oR62vENx1dKmqIdUqZkUFzaNjd7FH1UqA51LzLXWtzbkh35Z2oyC+h9gDm8Sashq/o35clUbKWY+7RbRp57RUVRK+rtzCilyd+Tw4zhpz8ihl/5Q0Z30f1f1baz7j6TzcR6NwFN4S5yze3LlRUZLmODEcFzcNhjrtrjCdn8file1RaddCMlrc5HElllyp2bSlW3R7IPF5sD1pFTm4iT6MOAt0HA8GtFSjG5dcu878IFCg86EeSfMw8hE/WuxBAm///fcPzjrrLEkORelkdCFBNRUdHIUCDBZggwcPDnr37p197fDDD5eEOIQ6gCxv3rx5MHr06KxNoAOSJBzEB86ea2z8+PEi0QJYbLLAowKtRYsWQSMjCp+BvcMOa/cpv+vaYBbVmtzXLoxqJZAKgZlTdEH5kJxy5xtxrbOgjxP5KmZVxjjfzFlfklFxXheldlwQeLFGKJX0UflKHhxX1iEaYFVL2Clpzvf5oJpA0oztIantdkvRBRCXz6gUDzzwgFTuEjTiT12Q3KIqnkAFnH322VKERZEh9wkFClQEMz/RUJ3P0HUonRF0XHMtJ5XIV/Uj7IrawaTmdWpBpt4rcf3NfPK5PJK271EmrnJdR67Sinbdp9n5FvZh+NQotoPvUrUofqY9JiQXIMmwl+WQ5i7UZ1CYxL5BPkBMjxw5UpJbaYHk1i677CJJNpJcEL09evQIrr/++qBTp07yGZSvKMaC+Kc4a8iQIXKvs7ZKu/DPd59BjoRGB65jJVe5ZyhWYK2M3fAhFo8CKn2qHX2AggHIHx+LYSqFEgXEHKzjWbeqneacu51qvhQ7lbue0FErSprnI5S1mI3rW3OOvtsEJc1ZOxA3l3pdhsmlQuM4ooBvcQb3N3kqGjrYJo0tKBDlmsCOUQyGf0g71q5Vn4Ft0WY08nZxKdyGVUNYw+o6Wu9fXuca1CL2tNZhysVox3vU9sVda7uNb7lUDTXfllRsV0wmnnuOeD9K28D+u2q6bmd+uDBMR1RhU4kH0sxpacMOuccoVSXDMafORc83WitN0twXn/FNHu6jkTgKb4lzblYcDeACieoiwUBzAWIwqVxJu5oSQ4Zx0oR7sfl56gDimonIMdfZdj4QEm5XIdtTbTVaFCBYZvHDgkPnrOCc1eiqvGaxazYq4lyr5ArN/Kg30rxQpwtEwYMPPiiv7brrrpIcgpSOcnHYrVs3ceBXXHFF0cpcguxLLrkk6N69e/a1zp07B48//rgspLmGuM8mTZoUHHLIIU3+BtfVlClTgocffjjYY4895Ni6pCWJbCqF6SRpZFTjM1QminNRbNGsQQn3HAtcTSpE2SHnqqEkQVKXU9iFDU5aOjjc+cLfZ5s4TiS7fensxr5wvtKeP6/JI44T13Mldk8TpSpfWSjAqkXSnOOD7YQsUOBD991332zyKO3tNPjjM1wbyD2exjpUu5bxPdyXJO7V98TVDUehFMFv0gWZYel6bJnua9xd93EmrgoV44ZlzuNQ/aiUUIkC7qz7NMaEFCLN6a7XgvVykM9n4DvZv7QLHiHxkVMkhsbXsZ2Q5wrO97nnnitkOrFGq1atJCEWLtAy5PYZujbFJkNGkFzmXqqHmdi59l1zQxDm/NTkuyqiJFXMFQc4b27hkEsU1NqIkVxgv/BrbCu5z1KIf7dwQItplURPS/0matK80DgOHipjn2tUYyXwMc64++67RaEE8lA7bfEJxEg8J0eNciKjA++99960N7fm7Ca+ATVJYgfuvaRyOqpcy4P7l3uDtTRNIjpiI00pcvImSXExYVVDcnm6/qRAyId8G+eIY6K5iTjPjduZH5Yw5xhQ0MAxK3dEVdTAJrFOJy6J89wUy3lxvaRFmvvkM7rl4T4aiaPwkjjnwoBIOvjggyOVudIqK4wlVRBpV7urVArJERLc5SQrcDrqALhQdUGriaVqAgd++tA151tXocrpU/3E8XE78dXoqrwmJFqxzqAo5pzj7Jmpm3aVXNqkuQuOBx16kOYUlCBXy8+bbrop2G+//ar+fuZ3XHzxxdLRwb1bjDgnIOG+uu+++8ThPvTQQ2LbNAnD3BacMV0qO++8c/b3BgwYEDz66KMirUgV17HHHiufd0Egg1QKxQGNjEp9RjWEiAYlJM2iKmTimlBpJB/UUNxkUrHCriQ7AdkujlUpdta3zu44wTXJ4p5jEVWnZL7xGBzzYjOiNNjgs3GTUKWA+woSXyVUXZ9BYILUFPPE095Ogz8+g3scG8h1j49I2waGSUge2g2n92S1972udUlakNSKssq/0q5lXVsTl7CvcRA1mrhKa76hFn9qotON60opxq1mjrsWfiXhw9wkZnhMSFJz0fX6pviukpjZfEbjIZ/P4FqmwIj1DjEhzyEptBM9zbmgUdoITaRrbig8goLjofbKF0WJcmZ+K4lTaE2br9jJ565sHTvCtRtFMS0/WQe5xEKaa2Y37qmGNC80qlHVYdy56OXmSH31GeTL2Jdp06bl/YwSI3TlkscylAYII8YuYlPmzZuX2thT7l98FPkqrrsoOINKwXpPFZ3yjVNIYhs4FqwB8W/4a1QAklp/5lP2YlQvipdJwpUw55gQh0Acc5+zhkmLC1KFN/ifJJWPwzkvnnOMsP1cr0kWEvjkMwpxH+MbiKNItzUqD+jkRcL4ggsukOQvQQqdmNUkXnVWbNxyg+XODMRIVyKVwqIV48rDnYmIkdGZiOXMlNOFNd9L9X3aXXMqE8KCmG7htJOVbud7rkQLjoXKTB5su1asEmxy/HNVrD566i7BbiOfSHXmR72R5nTqHnDAASKbyLxXjj33B3P+WJBUC4om6GifM2dOyQHyqFGjpMtD5/qyGMHB3HzzzVVvj6Fyn+ESIjj3cm0M5x8CjodbyISdwD5o0qzUDm1N3uAL2J60uxi0Ihjbhs1L2yeoWgzHluQPUNkp187qLKu4gzFN1miHQ9pJQoIdtod9pzAwqjUO/kr9lxtgUQVMVXK+GVEkkSGpuQ98IM0JlDk+rJlc0lx9xnHHHZd6YGLwy2ewxmJNrfd42oUxCmwNaz4e7IfKEZIYo6jI7YYrd5vxhwTrJA5YeyedVAsDP0hCi4dL1ERt87Fp2LM016/EbrqmcIkKrkEtEtOOkCjsVCVdiFGAbeee4sFoHHcuOvZYx4TwiEMKmuNJwrTSTnPzGY2JXD6D7nI6gYgLe/bsKetkVcwgCU084M4HT1qxqVqwjiMOUAUj10a4a0MlGTXXph1sWszli+8MA9uDDeQccS6L+RBsEZ/lQSyvXdl0cZKPwaa5yoNpI6o4JZzjUj9MDA3SkrHX/dOxKlH6Co4V6woerAuIIbivWReyRtJzzaNYYZuvPgMFTRQai3WSM04QGHFeOrAHd955p9wv+ALmE0fBZ1RaCEuOltwSBTTVcgaVgm1g7U4cnnTnrgtyFeQyWFfTFAInw/HQ9WeSRQXwCjTwpDVqlXOA/eQ6IOagEIwH28U1rE1B2Lmkmnm0sJU1OnY2SbjrGh3rx3XAWohmtnLnolcKn3xGJdxHvcLLjnPAZrEwQ6b4nnvukS5NAmwcz6GHHlpyxzjfo9LaPsyKdSuLkOKIuqtBZYa0GlZltApVhWr1F4Yy6nl+1VQ3g7RlQvQaYpHMccWIl+M43IpVnbFCYKFJze2GPV5Rx3lcMz9qmTTnHm/Xrl1w5JFHBpdffnks1zFd49gfNzBkUcx9xd8jYZIvaCTA4xoi8GRuOTKKSN+ZVHvyPgN5TqoZ4yBE3HmAnO9SZGaxwdw/WjGftg32zSfo9igpHN4eN2nHg3uy1K7oarZHZ4T5Qgqzv0nKoWsiiYc7I4qfBIJJyB2XAiXxId+wCbo9SfgMQ236DK7hoUOHBnfccYd02qR9DZe6P5oA4sGaoxxJWVUYwYfFMXMwSkRp8zVxBXHiQ4wYhluMywO4BQOVrF84x/gMkmWopfhi+8Jz0VUykUcUXays+3gQy1UycsF8RmPD9RnIGaMIRm7lhBNOCA4//PBF1qc6zk0VMzQewM6kXZRUDKzpyMWwreWsK8PS5hyDfLNl0wRJcbeBpVof755rrhElpPh+Ys2k1xCq+KQqm3H8/Vwy9tV0ZZcD1jes6zVOTfL4anGMzkVnreTORXdtgM8+A0Lmuuuuk5xiofty/vz5MsqD9SHrBUNhLFiwQDpFTzzxRJkFrGMXq+EzqpkjToEPa/pwNzXvq6ITP7lf41Lx07Gi+JK08sRqp7XwNswxhNVjua/1eMRhwzWXzz2VlhpBoQIrHUejdo71i8YecRRZ4E/cEUppjuclv4V/ceXZdS66O75Ej0eU40t88xnFuI/Zs2cHe+65p0m1+wJdmCEjQ1UcJwijS+UWJzJf0E9ihQ4MLnCMY5JSD/mAMaCCJ4nKIvbfJdFzdWdw4+NAMAxuQjktaOc7zsoH6VuOIY6eAAsjXk0iMZfEV98nliibOE9q5kctkeYUx+BkqM666qqrYnMyXAf8LRd0jxN0MwOKxGspiUEWykcddZQk5rWal0pQtl2vO7qOTj75ZCHZsX/cu1SvkpwB2BH+7pNPPhm0aNEilv2tVRTyGQTZqBGMGzdOrpk4bR5BiSZSWIznWoT7UoGrUJ/A8fJheziP2JdSfZRLHnHsCRjxd5rAqjaRozNwKYDxwWfiRwh4IIVR1UhrezRpSOcNARZJGI6RdkimtfDXGeskf93jk5TPMNSez7jsssukuJVrl5leheIMn/dH5QixhfwfO8h9kMsO6ugoXi8mV1sLBQNugWohm896mi4qX5Sbqi3GLaXQWOfBkugppcsyLegcRlcykX3UzsZyi6q1iL7SLhZffMbw4cNldjkdIDoiimv+tNNOEzlFzi/yu8wr97EQpB4wduxYic+I4bCrpeSm3LET/FRiVUn0tNeSLrRzXGfhRpH3UD+k9ipuYrUQNO7SsT1RH3u3iYVzTS7LbWKJ23akERfomkN9E7FSXN2KSppHrbAVVWEb6wr8FzLD7du3T91n5ALbRwPX0UcfLT5FQX4R6V1GG3KvshZGchzbRseloTi4DpC359xHwWdUo9LHOonvLbZe0utYcydR2Sz2WfPWaY8VVYURXfsW4hg4Hq6/jtKGu+Ow0s7ll1pgxfrF9WnhOeBRjAgjFmN8aaVqUHGS5rlyXno83Lno1Rb5+hJnlMN9NGvWrGE4Cm87zoudwBkzZojTuf/++yWQVqfDzcZFhtFnngiJW0jztGdMaRUN1UVsDzdV2t0ZVPLgwDEKdL6nDZ1fq5JLaRsLVy6e6yrqAA8H/j+XLmjy2vTOGxacZ5jWzA+fSXNks0gSUe107bXXJn7dhGecd+3aVZwt5CygI4Ft5DP8pMKXc6jXOpgwYYIk6Kn8hUDnu+6++24p/NHEFzNOmNcO4UvSr0+fPvI6s9ENpfmMSy+9NNu53KVLlyY+I26EF+EQE9znJIapwE16rlGhZFkac5ZygcUoFe7VJO9YAKvf4zrgntNETrnrAncGLgmHtMH+uPLjaSdeNdigKJA1jptIUsKjEvnoaklz/q7bMZW2zzD4CZLdyO5CPtFpjv0pFGfUElhfqx2EZFY7yIP9xq7lU/SoNUAauMl7d1+1+NXtbCBx5cN6ulzkm7eryaxchb460iONLr0oiiPUp+hc9FJnC2vitlLS3BefwXxBim7ZB2YHatxBfMAal/iAaxlSl22kU9AQLbj2dt11Vymwatu2bVm5qTCxSmGTdvrpeKc0upNzdcHFodKYbz2ez17FAR3LkVScowVAaqexZa46StTrYewkcW7acUG+bsVqO/DjGksVBZQYpbCGwiVIIM4DDRDYAnJDvuCBBx4QnwbBQQ7Pvf87d+4suQDuV7YfG3b22WcnLptc7yjHZ5T7vazplQwt93uwWeR3tfAWqJ0uZywS9wPXF9+TdgOjNj2wD+UqjOSy4ZWqPrnHhFx+ml3VlRZYuUWtHBMdzaJFreUWXnNMkCbnmHDdpznmpBTSvJQiXy0QLKfI15c4oxLu46QG4ShqkjgPJ4NmzZol8ic4H04WAQ1SKMxlpWou7c4JbigkmUm6YyTTnnukVT1Uj3Azh2cipiGNrg7NF2lXlazE+JFUi/OYbHnBI9n/33nw6hJEh+cZAqrTWNCmLV8SJs0hJNIKBuhuxMm0bNkyuOmmm1JRKAg7D55DrOE8ABW6OBTOHxV0VPFS3UtRj4vRo0cLscs+8X1XXnlldq6U21FCRZfbUZLGTJxaA/fx6aefHtx2221y/LA3rs9AMou5UxzvJK4htgdpWBaJLIzcStYo5EgrAQQCC1eqcNmOtMF9gN8kuc+iPspEDgt97Jc7y6rYjDol8X0pKiA5g8/0hcTXYCPcie9KOXLsOQfujCh8XRzQjhSdA63b44PPMPgJTRjiu917KleckbTPiPreUPICOwi4J7lP0o5PoobOz2ZficF03jBrAI3JfJdMrmZf3Xm7Sjj4MmKkGpQjmaikeaUFx774DJKc7APrfuRfNe5QRSryHUcccYR8lqJbEub11u3hC8jrFFqnl+Mzwp1+5KyKjdiLA6zVIMwh+7i24u6Cc/0Q9zDHSPc7rlmqJKa5N9Iay5FL2lyLSnlUm2vSTnodBekLVBJaR3DoHNlyY171YeF1vW9Qn0HxyS677CKj+SAQ+vbtG4wcOTLtzTN4iKjiDC0MimocLDYLu+I23um9W6jwh89RfMG6hTx6UvOxcwFSk/wNDRgcl2qOSa5RJKWqPrFuIPensUeaxySqAqtqVR75fXwyfqHccbg+kOalFvmqj8/XsONLnFEp9/FDg3AUNU+cu+CkQTade+65Ypy4cdXpcCGmQaAjbaEELBdYXEniSuRBNDByK4BxcGrweCQho6UL/SgcWlTnDEIYo5WEZKVLnCPXzrXiVrYBrhuub986zdMkzTk+zBDimNxyyy2pF8gY/AUzTDt27BjceOONshhScE/NmTNHApWpU6dKx8OBBx4Yq8/AN7388suSKCOYIKHtBiVuJSuL8bhJdLfzLolkWTkdL3HKemHn3dmTKqOvM+pcP8RnCESjJPGj8Jlcy0hNpg2tWi4l2ND1Bsee4ILkgEvuRDmvi2DF7Ugxn2GI4tpK2mfEBQJ1ElsEtiR/WHeWU0xUa2AfsQH4O/5PAoN9j2teX5oIz2oklsPnkdjzWZ69Gl/OIyyZiL+phjT3yWegSkV8fsUVVzRJWiEJu8ceezTEfMF69xnauURRrY7YUzn3OCW+yTtQqMqaTOOSJJFvFnxUs0OJc2gWQe2NvA73UdpQaXM3/1aOika+4t40FQDL6WbVOMAdwcHPfDZWFaR8L/zK5zO0yIvia4MhjjhDRw+Rq4iDsFJSUDvRsdtu451ulztHHHub1kgOwLbi2+LIV+caReKSxi7n46rYYhvS5IM0hwRhXs0ollJyPKy7NccTJsU5fhQSsD2Q5mmqQ0dBmhcqaOahDTsan2jc6VOcYWgg4hx5xe7duwcjRowIevbsGTzyyCPBpEmTgilTpsj7+++/v8iftG7dOhEjzs0CuYgh8GVet1b15OuyCMs56nwiHnEYNK2M82WhrzPW2VdImyTOWZg4zzVjXaWdNfEVVXVyrZLmHA/uZ4InuizSOA6G+gIL/bh9BvcvC2f+FsmpcGIEd+yO1AirgURtj5TEJ1HH9qTdeZfW3Kdwxw/JSfV7+HGfOvE5VwQ8vvjMckjzXP7WlXLkftAAK1y8UM53sj38vitFbD7DUIs+Iw4oiYCtJTbBt+Sawcv9qPLB9UAsY+chFjhv7Ddd5yqV7M7rg7yo9X3NpU7C+cQ+sm8aQ5QrM+k7tPAYn8K5ZQ3FPuKfCpEyueCTzyC/cfHFF4tUO+fRJc7ZNuYNcm5dMPYJOXdyIoba8xkuwahFtZXI5RYDdp81Jd/PNZW23wr7IQiGamTsVQaWQjHiCl/lpvOpo5RSVOpbcW813XmuIpXGyPnGLvkGn3yGoXF8Busc5qazdk2qAUJJYyXRtdOYbaARA/tVbI54PTRhlMKhcEyQZwecnzTtQpIFVhQJqC93x3WoTyP/SHwCaZ7UqJYkSfN8axt8Hdcmha2oY7P+4ifrfPMZfqOuiHPkAXAWVG24wKEw73zixInidLiRcTpUbhFUxnGzYgi4EVjs+7DII5nAohqjDmleyj7nkrXV4CWKamTkwDCaaUlmhYHTJ7lEUIW8UlIdGS5x7pLnOgeFc6CVWO7sRneeYSXzemuVNGcbDjjgAOm05J5OO8g31B/i8Bl8B/cOSSCS9sUSuK78EQ9+X0l07vdqKxLZR0h8kq25SPykoXJN2Lc05XM1Wcl2oFSgiXcCjCTnc+cCC27OGUmZ8KiHNElzjk21sxR15qdKOfJdWiRW6hxIEgwEPxqw6/aYzzDEjTTijErgztcrRCIQM2jCg3uSYF47HystakkT2gGTS0nKnV+o8xwrnV/oG1SOkfUyNpp9hZTROIJETqkyk7UElWQmOcgah30l/s1FyuSCTz6DBBtJNTrQWDsCI84by2doUa2SFKXK5Zaa9yCnk1SzQDVFre5Yq1I68H2Sxq20Ax/fRH5Hz3e4eIA4hX3k/PlQ3BvFCA72mzwqa3nOM0UPlcwmThI++QxD4/gMJJHJC2DLGQeQVmEQ5CNND5DmgLUW8UKcI9mKKSmydkqyCSMXh4Ltwv/gu7ANKAGkpeaVZoGVjuvQgjjOEf4bVUBse1oqWEmR5mEQl0yYMCE488wz5Voh9oK/PPjgg2UNWCtrlUZDXRHnpS7C58+fL/InkydPloUZFyoX6Z577hnJhapd1CqjmvYiz5VMqbTSKSxryyJeg5dKOlHodsGpkcAi6EsbGE6CR7bFlXZNCuGuc25L7QTNJ1+ST/4jKmkzH0lz7lfkithH7t+0Rx8Y6h9R+AyS19w73J8E/uUuEHPJQWGrNCgp16azYGN7+L0kxlEUgypr0AFIcitNuSY93kg64qdIvGsVMYtbl2RIMjGiAQ9FXT7MDOJ6JNhgPpY7/iAKuOQOD67XYseddQ4kPgGpK0VsPsNQj3FGtQW0JJNKtbPcjy55ofLB5c4nTQvYbSWHinXAhFVfVOUpLEVZC2A/8PP55t3mWldUIxXsCyjKhjTnGmd/CpEySqK7MZNvPuO+++6T7rLwXGy2l3tv9uzZYldMqr0xfEauGavYJuKBcoo7fWvwKLWoVWXsi421UoUR1o9pS+NWAy0qVcJBiwfYd2waHZW+5NKiBNc1BVAo43CudZxWNYpUccE3n2Gof2DfIM9PPPFEuf6Ii7XwKo04A/tEHod8APeBFnlp57U23sW9rlR1XR2HmKaSInl68hKsNfHN2G9V88o3GjAu+FJgxfmh0IN8H+tzzhOv6VocP5ZUnJUWaR72Gffee6+ME+B+Rjli1qxZXjSUGhZFwxHnLrhRFy5cmA1UMPJUbuF0+FmJsVVZEJLbPlz0KhdfSsKo3EW8K3HoVgAXMjzuPF0cmg/zujHeJNWovmL2UBqLcZc4f3HI7mJAy5EvcaXNdJ6hBpTFzkmtkOacJ+5N7kscS60m9QyN5TO0kEpnCUVhX9y5eLr4VBtcLGDnd7mXsb1JKmsU8ickt/iJT0i7Sh8fhQ8nyMD+uufUVfzguGNb9bjHaY+oWMYnpB3wKNh3gkHtYkxqDiTHnr8dnpmF/2N7dMSKXtPmMwz1GGekVUDrFrVwP7IvLnnhY3d2NUWx7Bs2RG2PFqzp/qbtq0qZYbjppptKcVOp8aLuqysVzP7Wyrx7Jc25xgvNMdYZ8DoXnf2dOXNmsPfeewdjxowRH+NLnME1SBGfC6TZKcIcOHCgnF/OEap7hx9+uLyPqgTvP/nkk0GLFi1S2nJD3D7DtVF8rlRlKt8aPMpFvgIn8m7YaI4h9o+1IKRyvShpuPL9xCiQZ+wvqk/VKA/4CIoCIDU4p1ynOoKDB/Bl3ZFmnHHeeecF559/fpPXyNPhAwH24LTTThMJYApIsB/4Nx/y04bqAPkIUQ5Jfs0110heJ604oxD3oZ3XbJOuK5VEj5rcr0RdNy6QLyL2YD/dwrRcKirumKg4cnJwLowrSbvACv/lFrMRQ7nqmhwPlfzXNUxccVaapLnlpmoXDU2ch29mnA4zRKj8wAngjJBM2G+//YrOVdJkO0F7UvNFSiWE45Q3ytWJgqHDKYYdgHZR83kMZhRy71HN/oPQoisjreDRJc7vOmQNcbiQNpVUreqMPz0nwK3kKjfA0Jm6aZLmODgSQlxPM2bM8OLaMTQ2SvEZzJ/E/u6xxx6xdQlrslu7qApV9vI+28x9TEI97WQZyWvsry+d766Pwv4WCuoIBvW4EwwSmLrzCKM6tkoEuLOIG4U0zwUNwnUuOmQ5RRecK9YV6t/S8Bl0dYYJDtCrV6/g6quvXuT1G264Ibj11lulSh9wzQ0dOlRm0xrqD9XGGZWCJJI7hiiqJLPb+UhSLExepG3PVaY8Kn+HTdHCKXd+IY+0VVJyzTCsZs2uxLIW47KW0OSeb91+Cogk/He5yUHtTL3kkkuC+++/X17Dd/Bo166dJHp9gyvVDk466SQh/seNGyf3eZ8+feR1pFsNjeEztMhQO/3yKVP51uBRLdziAR3JwLqPNSH3iA/FL0krYlWiROYTuHaJM4ibww0t3BO67lBFKh3rlLQSWNq5KYhzbMODDz6YfY11l8aK+AW2C7+A3z755JNlW1G3MNQ28AuozVA8F74/koozsEVvvPGGKEOUwn2wrlQ7rTOvdQRUtXkT4g/2u9ri4CjVnjRPkm+/3EIoHtp5Xe0IFhfvvPOO+AuOiavAlDR0nc15IleT7/y4jRIaZ7mNErVOmqftMwzVwYjzPI6ARCYzRHA6OIW2bdsGBx10kMyvwfC4NxnGgG4wbnA65ny4CXBIGCgSuTySMApuJ0p4BhfHDIkQDEbaVWBhQpiEGs4tTYTnnD83qGUki/+wpFspkre+keYQg0ceeaQsuEhq+ZjEMjQ2wj6DpBQBP/fczTffLL4jCRusszx5sBh3K3uxvVTi+mDv3NmKOo867c53lYunaKlcH5WLZFBCpZogVROcxbrnkibNtdAsbZAoJPjh3LHeYPu4ByE7br/9dnktSZ9BoMffVHA97bXXXsEjjzwiREcYnTp1Clq2bBnssssucs2MGDFCugVYT6blbw1+xhmVQoulUFQiyR6XHwqTF9j3NJP4GgPlkymPqoBHfW1chVPlQjtJ6a6Paoah2yGDn9MCaR5pd/tVS5qH4wzO64UXXihEBLKJkJA80i4CKUaca2chXeduZ6EPY10M6fgMTUBz/bKu1ffxCWnNfU1qhBCFTDqKohxFLt+RTxHLVWbiofutOTgfcm5RkOZh6DlWX8z/VQmMfY+zoM2H3BTEOaM8yNOFwX3OMRg/fnxwxBFHyGsUYbM2MCWSxkCccQZxt6qjVsJ9qFIq/knzJpqvKncErI5jglhFdS7NNakWrpaba8uVr3fHRJUbQ/F9jLkgj0ROi1xUWiCGwEZxzXCtlLqe5hiobddCC/VplYwJTps0T9NnDBs2TGwAPgC/SN6JnBP8jsIUSorDiPMSDA8XGZVbJDRxQK1btxb5E2YT0OnUr18/mTHSqlUrL6T7VNaVxdG6666byja40hs4RYwFhhJHwmI47UpYTS6lSQiHnco2F89rMuc8CcnbQgGGD6Q5Rvzoo4+WxQSVlT5I+xsMhUD1/2GHHRY8/fTTcm8xmsL1GSyAk1iosTDTBScLee5/ghKqX9OWXcX2QOaEJazSroTlmKl8VDXfpRKw1chw0U1C0ONLglO7N30hzTnObA/HF7KEawji5NJLLxXCg7UZiQESRsjZpVF40L9//2D69OmS6CzlGmefuEZGjx4ddO3aNZFtNPgfZ1TqM3TmYBrFUu7sbP7vSu/FTV7ofqO0lUQMRALQ9bVRFU6VC2It9ptCtLg6Sd0CafZZVQa02y+N2I6Yl8LsSlVZCsUZHNN66Mo1NLbPwAaT8yAHAFhTaid6LZGqhYBdImeBbLkmxHMpcvmoElLOOSe+KKbayH6rTwqP3Uhz5m+ppAZ+uxKVmHBBm3a0st+VEi0+56Ygzol5+PvcxzvvvLMQJKz3Hn74YVG74zi4MSQxHLHJKaeckso2G2o/zmDdR86EmJUCvmrX9PlGwOKjiikcqSQ621/uOKa4+Jctt9yyqsJVLQhS34VdLCeG4veRZmd7wiMHkwbn1lUCqLQIle/R3Bo/yf3o8Sg1t5YmaZ62z6ChpEOHDkHz5s3lWJ511lliA4iddC1hCiXFYcR5GdD53Op0qIjEALBA4bWkb8J8yXa20RdZV5Xi5bhg9DF2rgNIY06gOrY4k0uVkDadp38ZK3FeSseMEjyct2qlHqsF29C5c2eprKb7I02JGYOhFLAYadOmjdzTkHfYYNdnYAup8iNQoeKXIqI4fYZWnOIX8FPYXmxwNZW9UUlYpT0eww0AtVo/anmvSmW4kNVCXovkmA/FQpDmrHfi6t4sF9xfbiCmx1F9BvL2dOLR6c19SLIAX5ekGhDbQvLv1FNPlQCl1IISrg26AyD9DY2HcJxRqc/wSY6XJL7KB6v0Xr5xItUCyUjmO7O+5/uTRhrzC92Oa7pt+HtJQFUGNI5gfaHdnUkRclxXxHOVxrwWZxjq3Wdgc3r37i0NHhAlrEO1qaHWyWQFcQ0zfwsViYW713xRCSkFnDMS3Jwv4oJyzlNcilhRI2pSQztalWghtlOllGp8sU8+g65FCDZydWwP885ZA0GIMG/92GOPleveBaOgyFPQbWhoTFQTZ7CeJ/7GBrHuirq7W8eN4p+4d7lPlUSnAMS9b8mvkL8pJomeBHSOeBxrcBpy1HfhA7DbasPD8uXljByMGyqfzzXi5mriyK1pd36+MWFpkuY++QwF1xPH69FHH5V1oSmUlAYjzivEggULJLFJVRFkyVNPPRXstNNOMkOEBxWvSd6U7ox1OtR8SLbnk+LVeUzhJFrcskpuUs2XwgKuHZw+56/b/d8kSpznCzB44IQoboAoCS9Uktqebt26CYFE1Wwl0osGQxqgw5Qq77At4x6HwEYqhwc+JE6fwT3M4pkABJ+gFafaEe1W9iqJEffsUlX6QH6vWbNmgS+FXRRv0bUcp7yXynBp8JNrHqEGswRgBDw+jKVgmzlGPpHmKvnlzjQv5DM45kmRSYq777476NixY/Duu++W3PXKLHQqkSGC6qULzFA5KvEZ5c4cTBrhgk3thFPyIopZfthyH0ZbJDG/0I1rKpUpjyu553Y5xkFM8XdYTxDPVWLfLc4w1LvPQJKZtSW+YsKECaLC4d6HucY7KUmRZsK9HJCMhlSmSKzU0QS+qISUAvwGdg77ypq3mu7OqBSxogbkL8W5cZEaHENiYS1oK4VoqUWfQWE6RekjR46UHIQR54Yo4ww4BrgGVQuM217oGlpJdLZV7RW2DLvPCCq2MS2wTcQePJKYI55Lvtwl0TkmcCvkkNLMI2AryR2x/ogzv+YqHHNc4J6I/7RICn+ZJmnuq88gT0AulrUFHJ0plJQGI84rAN1LO+ywQzB06NCgb9++ctPiTHA499xzTzB//nwhKqjcwunEPWPcnTPCotqHYEelUzBa4UAtqSRaPulbX5JqKl/CwgNn60q1p0GeA5ww24Rz4brShYobYMQ9O4bj0r17d3H+dAym0TVkMMSJuH0GAQXdF9hXvjff4jlc2avSRzyiLphhfyHyfVH60JlYFBQkPWM91zxCJbj4P+sLH+QUlTSnkptkTNrAJ0Ga4yNY62iyy0efwYxZCjLo+igFw4cPDy655JJg7ty5QgQZDOX6DBIqV155pch1FpNy9QHhcSJuAgj7V6oP1GIBLRxOc5ZfUvMLw8oCxBA+xDXhc8vDJaaICaMo0FPSnO6eSuy9jz7DYIgSjIvab7/9svK1TzzxRME4I5c91qJaH9ajhVQWqykaUjKZ/eYn60o3DkqTRFdFQpLvnLsoFRrzFXbp2I2k5gQraQ75lUTXaClESy37DKR499xzz2CvvfYyqXZDZHEG9wWKBrxOd3rSdpFt0zFBbCP3I/aZ3EQSuelikujEXEk3O2jTm/ouwHGgiCypsZCFmlJY95PPSDK/Rm5N1zHYedYuFJ0hnV+Ij4oDvvoMfD3KEtxPjz/+uLw2fvx4K7QqAUacV2goIRcxkrneg4S47777xLkggYABI0jB8VDdEeVNy03pLqrjnh1YCkgOcXzcOVOVyElRLanBSzVywipXTILJl278fJVYW17wSGrEea6Z5m6yD0fkdknilKOW2SdIRE6OIAoCodTqcYOhVhG1z8COqjQStqXUhHyuyl61vyQVqln4+tYJyCIaG4MtS3smlm4PxW8s8jkPrgxXWuSXkub48KTnI+cCx0XXOi5p7qPPIJlLApDkA/dxMVx22WXBRRddJBJeFE0YDOX6DNZtrOGIAXjuS1V7ObGMJjuIA9gPJW0KdQC6yiq1UCzgFk6pr4U4UIlzHqXGcepXiWt8UxYo1OXIWkK7hipZW/AdFAZWSpqn6TOYP4tfoACfGJcENJK53L8K4qzTTjstuOuuu6TAgiKsMWPGeFFwaKgNaJPABRdcIPOMQTlxhibk+R03H8M1WE5RU1xwlVWizOu4nck8QFRxUKXNFYB9rHQ2bLlkclgRK45cTy7SnFgjDSjRwkNlkNU/6XrCxzgj3/EkXmP2OV2O7Medd94ZHH744fI+yjSQRyhRtGjRIu3NNdRInHHVVVcJ+Udu+Pjjj4+Fzyh3/CB/HzvFNrqFqFzzcdrK8PgM8mZpS6Lr+DqOA3wJPoxzo74rSTURtoHcEceDNXpaKiaAc8NxwX9xrbBNeo3ErSzjs89gljljPiDNVa3BiPPSYMR5zAYe44XTIVAmKYqkCFUehx56aNUJe4yTGgQqepJwFMVAgEVyu9CcqVIDBr7LlRPWoK2cbgWVsEfKC8fmQ9W0VmKRHCOwdZ1KWsR5LtI8X7JPk5vMNoxyNhpOBgUHDDlOJq3Z6gZDrfoMCFhsCwvCarqotbJX59Jyb1YiMeuOEIHU8KETELvFMaL6NI3AL9cxcoMvjq0rw4Vd1WOflISkzqH3iTSnu5DOEI6RFoP46jNIWl133XVSrFdsXUaX+cUXXywS7ZbIMlRiP7g36CwkJiDxyzouqjgjDYTnhHMPYQN1xqHuD59jlifrUvxLrY43wK4pYVFsfqGC5CFjIHzxq+XYcu0a4txC0JHw1C7HYoV+SppXqlyTts9o165d0KFDB+kKJM4966yz5BpmDaAkDUmtGTNmBOPGjZMY6+STT5a1HN1fBkOpfoGYHsK12jiD69TtaiPnVEpRU1xIqljKtVUaB2Gj2Pe4OxyTkrktNdeD31XCIaqRinwvpAJju9IizcNgDaXXOtcX63O2jRwiygYUnPgSZ4DTTz89OPDAA6Xrljj73HPPlfsef8K5wpfMnDlTfAn3ap8+feT3UJ8wGEqxBXSZ//Wvf5VriHV5HHxGKdDZ3dyf2H3N5/M6BSPcs+SsyIO5Y/DiKPrBF2hOopCqY5JzxFW9lnhJG2HUhmsOL241EVVyhLynMC9N0lzl2RmVByflFvDyUxU2OSZRFxakHWcUAvHElClTgnnz5skIRoVJtZcGI84TgnbuTp06VZwOSVIS0lT74nTKrcrBIGAoWcwyZz1N46RAqoSuObYHUiIqqJywJlpKraJSJ4ujT7sarNRKrDSI81JI80Iy+zzcOSs4oXIVAnDyp556ajBnzhxxMlHKAiOBe+aZZwb9+vWTxV8+8N4111wjyUgWFkcccYR0h+iCiCBvyJAhweTJk+VaZLE0atQoSYApWLQNHDgweOCBByTgbt26tVRqQtAZDHH6DK437mMWiVESwtqJoCQ6hT+uxGw+YtDHTkDtosa+sGBMm1DSMSv55lFpAZkmLOOU0g+T5gQaPsyh5xhBLBAMu6R5nD6jGrBdXFtHH320+B4XXbt2FR+LXwF0Gp5zzjlS6duyZcvs50gI+FDkZ/AfdK4iy7n//vsHo0ePltggqjjDB4Q7ALHZrDFJjLFWwz+xFqtU6tw3FJpfqDaBBD6dlr4UA1cKzh3rao3tuHZdydywP8QHQpoTY1bSveGjz2C/ObcQMsQLrFHYd3wCMYje4ySmrUvQkHacoUVN2tSgsublNjXUGmGRqyM7ilEbvnfsAfZVbTRkDD7HVcSq5Jwrac61hjqTj4CQwg6zjn///fdlzaFjDvbYYw8vCvUowoIA4Z7Eb7Rq1UoKcbUQQdVL6Dp31Ut86n40+AuKvynK5fqhWDEOPqMcu08eoFiRrI7Bw0dVquZUCORlyLWxnkw79nAb8WigzEWIF1ITwWZEtf18L0Q1x5s1epr5tTBpHt4Wd0wJfk2L4rQ5qJpGVB/jDL0OKJyCw2C7wryExh6mUFIYRpynBIwYFeU4HeQSuFlVMotkSCGno1LoJGBzGYQ0oHP2cJjceHEhVwVwrk5ITbazOM9FSKSBUiqxJj/3YTB46iuJkedKmiPdhIOpFCrrppVcOGI9L8UIHs7VoEGDZBHGDJAoK4+Z8XbUUUdJpW2bNm3yEucER8cdd1xw8803i3QiM2uOOeYYCUpGjhwpn2nfvr1cU5DrHKvbb789uOKKK7LyRTglfpd9v/zyy+Vv8ruzZs1q0k1iMETtM0ikI/c8YcKEWCv3tbJXSXSSV7kW4KXOWE8SauuqVUOJuotaA8FiAZ1LIKmUvrvQj6KC2DfSnH3E5nLN4ce1cjxOn1EtKJoiOYUkIhX5LnbffXeZK0rlPuD/SM6FQdcIXesGQzFgE7D7SMKFY4Fq4gwfoet/inTprgIQNkl0AKaB8Loa+0dCB7/KSIdaJs1zAV+oRQNhyVz2GTUzCORKCrN99RnITZPAYi1AYtq6PgxpohyfwT3lKoPgf7QTPY7CTuwha3hAZ11ahIV2ZGseivUpBT9KzlTT4UhMRZ6IIgRfmmIKjVQkttP4r9TCCSXNtYDZV7g+g3U9XeeoNNCtR+4HktBgqHdwHxSyQ3HHGWr3KymSDas5VauSqkQ1Nj5pJZB8nAJxQKkKk7l8lxYW5CpWLec4Y9Pxg2mrnBUjzQsVFrCOYV/cAt5yii18jTNAr169hOvAf7mjobgn9F4whZLiMOLcA3CTQ64xdwrnQ8CB/AmOZ6eddmpimFm40cXnS/Ifg8OMPZK/Sc/Zc42dO+OEB4k1nYUa12ymuCqxkuo6j4o0r4bg4bN03DHLjwqoMNFQDVgQcP6prmV+LIF2PuIc6RLuq4ceeij7GlW6CxcuFKkVHCkFDzgcOrsULAr33Xdf+X7IdpwRRA+FEbp/VPYOHTpU5gIZDFH7DKoHsX277bZbMHjw4EV8RpzQOa1u8oh7HPurslE+dAKyfdyXUdu6SqGFBZy3SnyUVnxr8KO+Txf6lRxznQVFEt8X0ly78SGJXNI8Lp9hMNQryokzfIYSCySLiIF0Dm+pSii1Crpc8BkUDhA/VDsn3HdwPpVEh6DROAKipdzOVl99BtvFPcg5Jc4ANmfQUIs+Qzu4sMUa90c5G5wcCutTEvv5OuvSLPjRtTjrVewTBQTlyprzPZAP2DliFR+aYsoZqcI5LqYGWUukeT6fwbXN+z5dgwZDPcYZSg6r+kY19xx5ErXT+Cpyuq5yRqmxB79XzSjEKKBEdbXd3ZWMicrnt/B35MBriTTP9x0ae6g/11ir0DHxNc5Q5DsWY8eOlUZBYAolxWHEuWfAiCHvgNOZNm2aBAk4HSq3MNi33nqrOKMopdArBYtHuqoIlEj+40zS3BaIGwgbut9Z0BOsafVzmuQ55xRDDqFUSiVWEsR5XKR5PoJHnRBGmYQnhPThhx8uHd48qMzC+UeJbt26yTVAZTCdfoWIc5JVVGNRVbzjjjvK/EgI8i5dusgMQoI9FhTM9UGiS4EsFglanCQdIwT0dJC4VWaQUPyOdhkaDFHdWxdeeKFc3xR5oPgR9hkoICRFILB4pguQIioWkARMan/T7DjXYjMCHbYlbeCbsL38jELmS32f2thKKoiVNGehv/766wdpQ+e+QyhAmmvFL69TpBSXzzAYGj3OSNJnlAtsG3EQts1N0LgzDnngi3T9DwnhQ/FsFPYQO02xJvYw1+zdKGQGfQOxiiqsUTygBE2pRQM++wy6O+jQgjRXv2vEuaHWfQb3nMqgusqA2GPu13LJDxLZ2H3tZvO5SEhH2JVLzuC/IB/I7UU5aisp5JqpG/ZJkBCcR5SWePgKn32GwdAocQY2kbUf9oNcdZR2P1yYqSOR8FG5xk9o7IEfS7uoCX+IrwjHQVEcE/XZucZE5fo7ui0cN/JHtU6aFxudBXGuuTU4ATcGNZ/RGDDi3GNgxJBtmzhxolSw4ITatm0rs5qZhZZmJ5/OZoUUJZFTieRJ1KDDHCdLUEbgoV3PLNYhcdQBJEniVOLg4ibOkyLNCwXAp5xyiszt41z1799fEkhRzrnifmHOE1LtnO9ixDm48sorg9NPP10cIAk6pE+RZVew0CMBS2KLRQJzQCDncdAUkHD98X+qKq+77jpZdEBqItuy9957yxwggyEqUEB1wgknSHWvzp5SnzFp0iRRR8DeHHDAASIpF7fPcJNbdBKonB8Jfq1i5b5J0lfoCBEktQi+0gZ2BR8FIM3jIDhyVRAryZArcaf+wCfSnEIHtgvSXP01r19yySWiIMI1TvW5wWCoDmn6jHKgI6ooRGStWGgt7UoRUvQY9YzDJKFjp1RBKRy/5JMZrIeiAS3oInaCOM9F0OBT8ykN+OwzULnifmM+rdt5aVLthnryGa46Ek0WxMm6HuV+LUai+ziasFxZc/ab9Syxj/ohCHXdl3J8Wy0g10xd4hBegzD3Sb42DJ99hsHQKHGGjo3DJmIv4rSJOhIJW8VPHT/BQ+0W20J+JO5tKQZV7Ih7W1hXu8eE86PHBD6Fv6vFXlES1T6R5rmOiSqscEwo5KAohDGwFDZff/315jMaAEacew6qNvv06SOOhpmXGCn+jxOiI5bKLW7aJJNBbBOz5tgGkv8+JKKoCoK0ITAJy7lUWgFcLSqtIP7p19+C7S9+NBbyPE3S3A1MILAvvfRSIcxZkLCgYpv4STBdLVkG4UKlIx3goBhxTsc488ypGIP4pmucApUePXoEQ4YMkc8wR5o56CS6uL5IYkI2cY4hegD/7969u9wffGbPPfcU58o+01liMEQF7eogSZ5vkffoo49K4VXcPkM7CbApYVsXrmKlctWtYo0LjBB55513Eh8hUkphF7YoCZm/cFV1uFqW6wd/4BITPqjYsM3YcC2yUJ9x+eWXi+oHttdgMESLJH1GOcB2saaqZERV1DMOkwQkMUpGdNBToFwKCR4uGkiraDgO0jwM/AL7qEUD7Dvnlw5uErKMsfHNZ7DNxPRsG3EH6yUXXKP4ZwpzUeUC+ETioyeffDJo0aJFSltuMFTnM/R+1fFO5GaI97XIJ1xIqnYfggBp71pGPiICH6QqdbW+j/mAEiSNNuwz14f6pHKl7ONGmnHGsGHDZEY0DSUcExo1RowY0WQWLXks7jUXFM9fe+21iW2nwRC3z4CMZG1E7jXpsXHwG2qnWVOSpyF3A1Gdtgy5FhNQfJTkmAuOiTt+lWOADcc/E4+lXUyQBGmeKzZDzRJF2pkzZ0qM1q5dO+EI+JmmArMhXhhx7jnuvvtuIczpKtSEEUaMxIDOtyUQYc4yTgeiLs6FqCb/IQPp4vOhG0XnjkAEMFu6kJyLSyS4FcAEbvmkSNKoCouj69wX0vzqq6+WIIEObGTRNVkEac41XO05uO+++yRp5hJT3DM6F5IiizBpteuuu0pCCjJfcfvttwc9e/aUAgj3msJJQxRSENG+fXt5n+5fF+wP1xqBIUQ8JBD7bTCkgTh9BnaF5BYL+WLye/gPl8iNw/5iY0hEIRuf9ggRBbYAH0USMa35jOHEHTaN10jW4aPSlr/kvL322muyfWHSPJfPMBgM8SHNOCNX0h251GpHVKnsHsQNxCw+R8eJxFlEW+nxZ6Y5vgM/VkmsBTGlJDpJt6SKhqsF24q/LFcFheQV1wrENF36+DSUo3juEhBpgpFQqFaRMHa3CcJf7ykKiknGMd6JuJbtB0888URq220wROkz3PEa2GNXKYO4mfiAexlp9rTyFXETERT5s5/EA/i2QrPBaxXkQrDldNITa4QbWdxC6lwSyUkh7TgDsoXmjebNm0tcBiGDD6OTUX01xDk+8YILLsj+HsXQ+AhD8mA9SX6P/Ad5cQriFazdevfuLaqX2DN8+IABA+w0FfEZ5CbIE9GANHTo0FQLayBG8UGszcj7YpvUViVtpzV/T6Fl0sUEYcKY3JoqxoI0x0SlQZqHfQbXKeqy5B3hH/hJYYgVudYnjDj3HNyYGIZ8nXkYsQULFmSdDgvSffbZJzj44IPlZ5QdfSx4WRzk6upOCyoPXOr88EJEAt0c6hRxlJUaYO2+pNChUvnxqIlzX0jzG264ITj33HOl+5qK2jhAsM6cZRfHHnus7PvAgQOzstYu6OYhsKfCV0HHB4s3vi/XtU7QB1mIrBcEey4gE83fZX+RazcY0kaUPoOEF8F9JcmtfPaXxJk7O6gSmW+SUZANPpADqoZCggO/6UNSjHNOYK8BIceN4J4HvjRp367FDgSqkOYcqyR9hsFgyI8k44xcozYoNqpWiSiNIq5qkoms1/mJYkoUBcr5iobDs/p8IVpIglWSIFSfcfbZZ2cJdNSnWKtDiJSrWBA18h3nsWPHBsccc0w21j7ttNMkBmH9wD2GdPDaa6+d8NY2LowUSdZnqFIGMQUxN1Dp8loeN5EP7CtqIsROKIHovnPcVMo+jbV4HLacwtxcdld9MA9iQAqLo8jBlQsf4wyOCccBAgYpa1DKyEFDckCVkvUp14xLnJMDpsCBnOKZZ54p9zmdqJy3fLnCRofOiCafShEJjWdJxRm58P7770shP/li7kMdEaSFqJozUTsdZ16H48A1lGb+Ptz1jl/GpofHRHEsdAxL3H47bdI8n8/guuHY1JLCl6F0GHFeR8Cws0hlhgiSPxj+vfbaS5zOfvvt12SmUjXza1no+5D8J7him8qVQi9ViqSSyjINFErpvkyKOPeFNL/llltk3ve0adOC3XbbLdG/Hw44unbtKvKPVBcDVB1GjhwpM0pUqp2uDwj1CRMmyGdIurEfdInw/hlnnCGO8bHHHssmNpEeYjGF02Shw8Ka7yB5YDDUk8/QwAIymGu+GmB/dXaQymO59rcU286+UB3MQp57zodFKwlwAsBS1FCSgspf4sfxne4MSh4QLG7wk4SqDPb0gw8+ENJcix3S9hmG+oQRIv7GGQrufUZtUACZxKiNuIpoK90WElP8TdascXRwhGf18Tc0CcixTstPFSNaiiGfz6Cz9YEHHpBrtJaJKENyMFIkeZ+hnyO3Q5EIP1nPEwOoPfZhNGC1oECUTmJiJ/ZJkWstrt18uaTsfYYSLKXa8nAMiA9Sn0TeMS6f5GucQUxEXpM8kjZ7kMcixmWbuT8OPPBAkbPWQmNDcoAsO/XUUyW3R2zvEufXXHNNMHjwYFFLUvKQ64tuVDp1DYvisssuk65djiuFsknEGfnAiD/iD1R1c41C5P7DvqmdZj3t2uko15iquIUNoKg3Tehov3w2nXW2Fufiu/HbasOjzselTZr76DMMycCI8zqFzsbD6VDtyyJsjz32CA466KDggAMOkORIqYaGwIVFQRQEddQJFqSfIKmj3CaOnesUWdCXUgFczKmkQZ77QpojTcgiE3nCtm3bJr4NYeKc5xQ2IIUIWPhcfPHFwW233SYEDueboITXNGnL2ASqR1nAsZhi/iDvk1hVXHnllSL3TuU49wsEPYFNPVbMxwnOAeoALKKR32RhREcOxFo+IJkzevRoWfRy/xG4cPwVnGuUB1yQhIHcNJTuM/gc/gC/wD3F4jhK8P1axMSDv8n9SNCQr4hJZW0hxeg09+F+o/oW0pxtRmbYB78ZJs3DcOUzeRCcYOvU/8WRtHzzzTfFpoZJ87R9hqE+YYSIn3FGeGQDCaM0Rm0UKuKKm1SmA4+4hmIlknZJkLyuv2V/3U4abH9SRDPrCfxlNaS5+QxDFDBSJHmfgb9gPAEqIxS5aHehjpsgpibvQ7yt9tin+dilQguOse/kk/Ih11pcC1qxzz7EOMVI80pVQ3Ll4OKQA/bVZ7D/rKE4BshYK2jsIOdJLo94lxwJkvIQi4bkgC2iOB8inOuSHLRLnJN3Yj3D+4pHHnlEri/WWlHnTOrlmGLrub6TiDPy2QMUBHTMXykjEPgd7brmwT6orcJOV2OryIO++uqrsShuVcollDo+ifyXkuhRj4lKmzT30WeQ/4Z7IG5mbXHVVVfZWMOYYMR5A0Dla9XpUL1EhQxzp3A6GOR8hqec+bVJG3AMZtyye4W68VynWK5TSYI494U0pwv75JNPlusPCR6DoRAoQKHLrE2bNtL1z33GYpaEKo9coMKXIBLpHGaEPfXUU0GPHj1kgUMBhBLnkCYsRBXYvbSrOGvJZ3AsH374YTmGBIJxz1bLV8TEOdOkPkUv2Dm2mcA1iQ7pUhVa2FYUKnwgzeksJNmSjzTPBYpWNPjBD3K+1fdFIYOvXaWQ5pooNZ9hiAtGiPgZZ7j2nk48bD6JybSJEZVnJKnnksrqf6Ik0Ykt8Bl0ZpAoS6PrO9xJA5HPedMxHnF1PCpprnNwK9luizMMUcBIkeR9BiMJSPSyxkTytGPHjjl9BoWxapuwyyTjscWsSWuh65a17ltvvVVRwbFK2Ws3H2SREhE+qGsp8B/4sahm8SoxpXEIhAy+t9oCAp99BnkP1qqQ5oXyicTiEIgQiflyI4ZowXVDx3PLli1lHAyNGmHinLGMvHbddddlf491LZ3p/CQGN6QXZ+Rb6/O95M0rHfMXZbHTu+++K/c111Survc0Gi4q5RLyjYniUa5yQNqkuY8+A1VcinWuvfZaUcylQZDtJE/rKtoYaoQ4Hz58uHRpQlgUmsvCe5AfGAsM3xFHHCEyyrogZKFI5yaGkpsPYmXUqFFCkgACfJwYFassTKlKZb4If9+90SF/w/OP+TtILjQCdJaoOh2cPQsAnA7VWwQhaoioiqU6lsQ/stY+IM1ZH/mcIgEbx6mSOb9xEec+kOaAiksIzLvu1qXOywAAa+JJREFUuitLYBoMhYAtnj9/vkjglwqSLdgxKu4UzIhcuHBhtmIb4rx///4S2BvK9xncw/hpbAt+l+RW2GckVcREchOfT0CBTWYhToDhgwwr2wMJ4JNCi/pNOt8rnZNK0tINfvB7lQY/gIQDDwgyt6vUfIYhDhgh4mecEVYNoWODxJVvkrxxyjNiW/EZFA8hyejDSI986iNq86PqeCS2Z9+JzSstzjafYYgCRookD9b0+AXsPjm9hx56qCSfocl4/DrrUWwndonPRVHUGfV1RV6SbvpSOxkLQbvwtZtPC1rTLiCgmIHzFmUDSb4CAs49hHqlCgS++gxIGToZ582bJ+RrsWPBdT9r1iyZAW2oLu80YsSIgp+BWEUNA/VJZs+z5jPivLbijFwg9njhhRfkfsI+R1WIFC52KmXkiDumim1xFU3TAHaWuIzcUakNF+WMxaLRxVX0KnS+0iTNffYZkOXkZFFc1SIQitb69OnTMNxm3RDnTz/9dHDUUUfJoo7uwXzEOV2Bxx13XHDzzTcLAQJhe8wxxwQdOnSQucOgffv2Ytgg17lpbr/9dpmHQfUWpC6Lb8h2LmpkCljAQdZjELnRFATm3bt3l88pSNr6ttBOApx6jDMzWpD6gWRq0aKFzBChwohqOcgrugB8gE+zPtSI4+CYVwVcpxiF462UOK+2OiwqTJ8+XaSxkT8/7LDDUtsOQ22BBRpBIMUoBCfY9169ejWx2WFAvlEFfOGFF2Zfo5DqkksukfuUxRnE+fHHHy/fx8KCRenQoUOlCthQGCTQGU3AQhe/wHkJ+wweHNukSHTsHGsCziXPKWLCLyQ1l7sQCUDSiA4AX0hzAh+u80pJ81KDH6qqS5lJT4EkEu3ct24S0XyGIQ4YIeJnnKE+AxuCDCmdOr6ohlQqz1iu/+F38RkkyLDRPviMfOojur/VEBa5/KWO3KoEPvoMk030C0aK+Is77rhDHnRIuaN6ivkM105SRKtFncQF2CPtRIdYTNOmqvwveSLWu6qsFBXcbj72nWOodjnJfU+CNM/lO3Xf+fvsr44ZKbTvPvoMrhOIDgjAuXPnStF1MdBg0KpVK8n3oVJjqBxcR9w/hUAuHE6DucbutQXPAIneqVMnmX1sUu3Jo1yf4eYyuH/4SUNmXCMwUMrQ9XO+kSNaCKBS8UmPqQqDbaXhIi7Ohdwd95zacOCOxXULiMnjakNKGqS5jz5D/T/FchSPUDCi6NatmxTVUYRlqBHinEQ7N/6YMWOCiy66qMl84VwVdlRyUWmaq1sQg4MB4QLYf//9s59hEbrvvvvK9+cj7pn/gjFVSW+Ic7oOeRj+D1wGzNPA4XCeIIRZuFHAgNPhuKUZfOhcKB9mfSiodIa4wangBN0FfFTzPMolz30hzWfPnh107txZimEoejEYSoUWnTBD5sgjjxQ7ThEUMjQsBnLhrLPOkhnoLG7wOyywkG3iHmURymLrySeflAQGNoSF62WXXSZV3RTjJBXo1yoI5kkG4x+U6HR9BsHKE088IcdeA5U4fQZJfOQAIWlR+tCkPudbO+NY6Cc5C5Brim1ivyslAeIizeMsNisU/OSakUvXDcFhuJrafIahXBghUlvI5TOwTRTSYDPnzJnjXad5KfuEz8H3lCvPSGxLYTefx4/5SpqXQli48U4p+0GOgH0nNq+0ONtHn2Gyif7BSBG/wRoyn8pGuXGGW9TJecefKIlO7JK0tCu5TdbH5Cvj7gangMAtaE1q31XhME11ylz7rj6JOEP33UefAWgOoImMPDfHUcG2Q6xRaMz7NAiwXiCuO+WUUyR3QSG7IRmwVqVwUEF+iUYPiCs6PzkfNPgNHjxY1oRaREmOChv2yiuv2KmKGaX6DIqZtIOZhsu4RhGFER45outn1sTkkSqVio+jUXGbbbZJRO4735goVVHBv6RFmvvqM9T+4HO5xnfeeefs6wMGDBC/AI9qqBHiHIKDpCld4bvvvntB4pzFAIsGJFAgupE0giDv0qWLOBuq0ln0PfjggzLPRUGlHYaO6rxc4PN0MKiUEcBgEvRzUxKwIzfL4iMpg+kzuBS42aiYo6OfhRpOB3KJ5BYOh4qWpA1XNXOh4gIOF7UDSDiSY3FVAJdDnPtCmjP7GOfC4hFnUyvJQIMfINHMzGMWAoq+ffsKgQ75nS8B3bt3b6kGxI6RLODao+OcBWAu0hAfQLL66KOPbtKpbqgsuUWQCMEet89QKXS6p+luCH+vS6K78ljY6bhmAbLGoNui0hmttVgtXO6MXH5yTiiAIzBElistn5FrZA9gHUqBSBgEkOecc45cd/we61orvkwfRojULrAVBPVI3lFcw/qVJE1acUZcndnYOS3icv2PdlDgm0iU1+K+ut2ePFyyhv11CYtcPlyVWeopzjDZxNqFkSJ+o9w4g05Q/Aq/g31SZSTsUz7bFGW8RI4IIgTSPOk55LrvWkCAj3UlcaMaB+IDaZ5v39UvUVBPHoB48aqrrpIifJ98Bsi3LTQE0MBEwTHbrJLSSPEeeuihoqxXrfS/oXLkkmrnnud+gH8YOHCgnDNUdYkbe/bsWdL3IjXOfcX9Sw6D0bNIybu5XYonyHuRG2O9hWIBOXxDcZ+x6667SrED89FRu0prPBJ8AecYjgNCHZKY3FaaaimF+I2kzhm5O44Ldpv8LsVD5G2iHBNVy3GGwojzOiHO0f+/+OKLxZizWCxGnIMrr7wyOP300+WGoWL0xBNPlAtVgYQ7NwskO4veO++8U8h5FsqvvvrqIt8HOc6sC0hEZKAUSL+TtIXUh5hh/jryCyoJ38igMhYJiqlTp2ZlglQSlypInA6qACwIcOoEKnF2SbhzoZBQSXvWh2uoqBospfs9LGnLNZyrCrZa4twX0hxpf0YmcK+zUPTNyRj8B8TjXnvtFdx4443Z1/AFKItQRVosicsimcpEFsMELRB5+RbFdLRTNIU/MUSDOH0GASkBKkkDSOpi36OzALkm+F0SDNqBUam8bL7EET6T7fKJNE+qWrjUGbm8xv3NQztL0/AZJNNIrilIbGBzCJJYr4bBWpa5diRAKbTErhhxXjswQsQ/cM+RDKR4+dJLL5XOizTijDiRbxYtCTGKcdKa1ZckWaPqIyR/WYfpnEJIFva9nuIMk02sL8RFihiSjzNUGUntsUsklzJeqBzwt1h/U0RFvjFtFRW2B/+qBQQcu3ySuJXEPmnnnYrtO81V3J+s78lJU2gB6YxiadpyyIb68xFhUps8MaQ2/qJUcL3SQUoui7wX/AjQhhKKMikEYQ0Nj4G9wQ+xJjI/VNhnMG6QfCJENaMh8RdpxRmur4BT0BFQSSqGuOBag1OjAx/fkCa0uJj7h3ydzoqn8EubYaLK49VSnOHCYo46IM4hOekWRHJPZ64UI85Z1DDPHENGtTYynkjzMtN2yJAh8hm6n7lwqRZiwctiFKfBTQXhGyZPmMeKvDffXagaD+mFE044QRK8aS9ufQBEb77ue+0mg1hHAgWFABLgugiliiuqqi3+Fp1pVBvFMReqWsl4rmeKL8pNKhFoaFIJI+wGbrmOXSnEuS+kOd3AXAdURVL44qOTMfgPEun4ERYtCsgqutPcLvRioJKU5CzFVvnuR2aKIn1mhVPxIEqfge3EztGhpqNXygFBEnaX5JHKY2lQUqksFsENAXLattc30jxfBTNJANZadIDMmjVL1ohcGxBnafoMSHC2iVEOxbbBxv3UPowQSR8qpcioLveeSzLOSKOzhMJbyDeKaOm4xgf5Et/EQdYoUcVz4hxeY11GoVkl9t7nOMO6P+oLcZEihmhRrs9wiWQdL6Sd6PlyMaWCuJI4hTwkeUqVavYFuVShXBK9VPVNX/JO5fiM4cOHB82bN5diCzpQiSW5ZgwG38F1CrlLHgObonLw5Mi1A5fRVffdd5/JwRcA4/TatWsnfBLd+cyrTyvOcH1FeL66q5ZCngm77CqGxLHurYbfiBr5ZpprMTK5PHcsLj4syjjK5zgjDHhT1LpRU9H1DTlSYmtsgsFz4hyjzcXmzrXEAHDRYYQw+uGZl0hmtGjRQpKnCqTCqZoiyeoaL24mKnK4mZBP4P0ZM2Zk38cAHXXUUdKp/PDDDxetmKHqHwNJB7E7V8ZQHJwHks04HZLgBB0qmUXAUKnTSXouVDldSxRwRCEZnyup5AYv7j1SiDz3JXghgcC5v+CCCySJ4LOTMfgNriUURs4//3yx5U899ZQUUdFB3qlTJ/kMFbYk3m+99VZ5zmKPz7GA4L6CCKd4i4UXRBfg2sTPsAgjcYC/wV/xGapODf76DBbJkMFRyQGqvCxBSaXjNJSgpvgCaS0fwP7QAeUTaU5gD2nuVjAToF1++eXBTTfdJM+5/1g38uBzSfoPCC1856mnniqjgYrBiPPahxEitYO44ow0AGFO4o6kBnGN+h+6JtT/kAiqt/UzMR3+knibfSPe0REePEoll3yPM4w4Nxhqy2dgm9xcDPlKtcXldmPTeEKRBYAI8X0EpCuJywNJXPZZiYh8dlnzTnRokov1GYV8Bl2evuQXDYZCTQMnnXSS5Lwef/xxea1r165i58hhKVBUaNu2rXzel7GmvmHUqFGS/9EO/rTijHJ8hauWUmrTXaX8BtvijtHziTTPlbtRRV+No5RHqaZD3/c4I4wJEyaIAjdKChDoNCmjkAivmdSYxkZC5MQ5i7Dw7Eik0CH2qMiFpA4DclTndyiQzu3evbt8X5hoByx0qQRmhq3KkihpTtcQDqSU2QzIuOOAuPnM0VRn6O6//36RzKKQgWOpklncyLnOYT4HQeKf857GXKhCida3335bHGjUkvHcgiTUNHjBGZBUwvjzc9uhj+Ukzn0JXnD+BxxwgFQ/nnbaad47GYP/YAELOY4tx85DakGeK5j5xT2Jogig0IZOdSSGCPbbtGkj/sQthqJrnUUxRB72iYUyiYJS5xyDiRMnigoKf5uOKf4GHevuvXzuuecGN9xwg5DzjAuhMlhHXxjK9xlUfpLgiGtWNwEMwUg58lhcQ5AAPhHUSpqnNZcq3zZxnMJjTVyfcfzxxwczZ86UDhDWjhTAJAkCDGwHgWMpxWdGnBsMtR1npAFiVmRtw4opEDWa/El6Dm9SwH8jz06BGYkwdw48xe+cR00E5lN+q4U4w2QTDYba9Rmai9FOdGIDNxdTyL9w72OjsN8Uf/rsi/IBW6wFxfnssqpspZ13KgW14DMMhnyAMxk9erSsl2j6IC+mxeeMCiE3BlmmoECdQn5+cn8a/IwzqvEVcCTkFtVHRTF2I05+Iy7SPAx8tRYXaIe+HhcKAUo9LrXqM7ATNIORm6S5k/HXNJIZamTGeRhhqXaIarrGhg0bJs/PO+886RCko1Cl2qmugjilkgLMnj1bDARECO+fccYZQqoi54vxgTRnFgHV/DgXN8GO5AQSGCTgkfuFVKGqn+eQKcy5ueWWW+I+DA0DyChkT3A6nAuqgA488EBxOnSS5qusIoHEghxVAgy4K1uSJlAvIKnONhWS/Y9rLmzfJ5ZYhDj3hTSn4xLiULv1asXJGAzlzjlGJr5169bit1hYIQEPcY7P0YIwnvM+/oSgBpKde4RAxpcioFryGQQYd911V/Doo49KQBg3SpHHoquMSs4wGZwmlMj3iTTXjvzwNhXyGfi/pH3IPvvsI2sNJNtKgRHnBkPtxhlpQNfrjBdDnj3KcU61cJ4gzdkH9j9s33lf4x1IK50Dj8/QESq1FGeYbKLBUPs+g7WozpslHiAvxXqf3CI/3c/yHnEg3csU09ainQ4jbJchVLDHjF3ySWUrH2rJZxgaA8gmuw2CuUATCI2GgBwE60EKylFg5B7EbnEtG3Fem3FGlL4iXOgFD+b6qFII+ST5jbhI81zFBW4c5RYXwAfmOy7mMwzeEuc8J/k4bty4bKXIxRdfHNx2220iRcIFjmHiNZWMoCuIDkQkPrnwmWHO+1odo9KLuaBECMaKbkISGBgvgKGAyKdzXYkNup0hPOiA4sZDugJ5D2bjuB2PYbKdBCwSHwpuXGQeSMhiHNlmvqce59nlA8THgw8+KE6HGS0cB0gnJFmR6FcpKCqoSPzznOPtw1wobg2kS7jmKOKg2CINR9L88v/rwBu374rBSiuuKOQN8rZpkuaQgQQmFLlQ/GKBiaGWUWzOMaNBuB/5jIIqYHzbtddeK/aCjlWqFFUGikUti1h8XYcOHRLdn1r3GXTus4jGxx922GGL+Iy4kUsei2CHZBrnvNgYmKSl0H0i8jleFMGFO/J98xkkJDbeeGNRokCaqxQYcW4w1GackQZ0zEi5Ra7hcU6lJn98JM3Zborei9l74nJVf6FYjlEexN2M3WFeH8njtH1GMZhsosFQXz7DbWiApHAlzckLkVMkV0lOph5I81x2GYKFXBjQubI8INN9s8m+xRkAFTvtCKTLlHm0dK8aGgesbcgpFALxaK6mMe69Zs2aSQPHzjvvbFLtNRhn4DfIacXhK3TshpLozAJ31VLC28bnsenvvfdeavxGLtKcgiwUOqOy2ewn/JLm8cKKvlr44KPPMDQwcZ4EmEmATDtEOB3lStKHQZfgcccdF9x8881SLcRsXEhwSA263pUgofsQiV2IEOatX3HFFXJj6XxVfgcDNXbs2Ox3I2Xkyr3TyU51JlIqVAIhWU8SgG1oRHAMSIZMmjRJ5rLwHKdDUQOFC5wPjrMPnSLcFigbQFDjVNIudnDnnI/a+Rf5qZ0ZGrwkCe4brm/matBha07GUMsoZc4x8qq8D8GugNzFlpE4YRGKDCtSPxCrit12202eUzRlKM32IpN04403SpECRHXYZ1Dti9/IJ+saNSAxGANAYZ/6p2rlsaIA6wsq1H0izbW7kq4UV/nHR59BgMT6jOCx1HWHEecGQ+3FGUn7DFd1o9oxI4U6S/A/PsRM1ZLmYVA0ANlw+eWXy/7TqU+Ckgexos8ElckmGuICTSIXXnhh8PDDDwsJR9zSuXNnWTO7hAuFi71795bcGPcgTRwDBgywExOBz1ASneNPwp/3IbyIB3xRSoyj+Is1PUVbWtzEWp+GI81DVTNXNir4GGdQTEWDFgX2KJKQn2bsGzGlL6O+DH6DruANN9ww2wgIP4HNZ02opCi5K4rAUcQz+OUz8BM0b7JuR1EgTrvEepm/p/EC/8duEy+wFuB68YnfiIs0L6boO3/+fJHkxyYrN+iLzzD4i7ogzrkRkJkYM2ZMcNFFFzXpbg+DqnUSzQ899FD2NToEkXB//PHHJdin8mbKlCnB/vvvn/0MxoXFGN+vxDlVLBjMXOBvUFFE0LLDDjvIa3SjU9FC5VgpszTrGUgSIrOPysCtt94qr5EQQW5/jz32EDmUtMAtwYIWw8p5T5qULkacP9TjT5Isc4MXtlGDF5xgnIafLnzuBQpVLrvsMq8TWAZDVHOOSYigMnL00UdnX8Pn0AXFApVKYGaasxh1O8u4T7gfdeyIoTCQJ2OeFEVp7ox69RlU+6IGg9/HnxKoxO0zmP9EwlLlrCqdgxgHaU73gi/d7/lGiPjoMyiGQKWI+3n48OFN3guPE6KwhsJJwDXXqVMneeBrkRQzGAz+IU2foUogqG5EOT5DO0s0+eN2P2pSLG3Q7QJpznZVmiR0fYYShZzDefPmyXGtR4LKYCgG8kjEEqxbWHvQ5NGjR4+gS5cusrYCFJsyFmHPPfcUpUZIT5LC5MV69uxpBzkCn8Fxx/5CRqBExf+xy7nmgtcyVD0qV/EXx4p4zZ0rGx5tlSR8jDMAxAxNUxRUaexB9zDFLMh3Gwwu4CPgDlq1aiX2hOsaFVxyDiizYlfIQZAfQbKdWejYI2w8zWel2HgrwErOZ+B/acwkV5hrXFHc+O6777JqKfgo1s5sM1yZ2+xZz6R5LnBf0dBEXpfjwf2m6pYUqRgMueDHqqJKUFULyU2QUAxUqnOTPvXU/8pf0yU4c+ZMMXKAJDg3UHgeLYtliHUXc+fOlQUizgt5B1eChfnpLByVNAdsHws5nGKjA3KBCl2cDYtc5E/oKGABQEcX1aJUzmFUkwRJKcgIggUWuj6Q5mFASOD4SOwja091GwQAx4rFFlVUVN1S2BF1XQyLLa2q8ykwMRiqAZKgBNyNXtDkAyCfsWEuaa4+A1uHxB0S2zNmzJDFdpw+Q8d18Pfw5cjGs7DHt7N9LLQh01kvUMHLmgDiGFKbtURcoDjDN9Kc0TTsO0SJS5r76jNYc1AoQ7IhDF7nHLrHG1/Lg9fZD/5//PHHJ7zVhkYB90337t1lbUf8gZoJCicUcbggqY1MIDaIZCzqTYb0fIbaC8hd7HOUpDnA/1C8BWlGPEtSnufYLDpg6GqhODt8nSRNmtPhUilpHvYZxGGMb0MpjlE6RpobGhXt2rWTolIIE3IoFJkyGgo7prjjjjvk/ud+oUsYRcW+fftmVRUN1fkMGmggRMgf0iCDj8YOUzhN/ELRFLkt8jHYZWxiLQKyJR9prseK1ykOQ1mNglnyp8QBWuAEoQ5RHDd8jTO4D8k5u/lpto3n5IkNhjAoxMGeY2PIMxAHoCrH+k6LcchFMHubon4avGgAPOecc0oujKIrnfsSxTXIeAh3FBFcxUUKsPAzkIhcw4waQKXt+uuvt5NWos8gJttrr72kI538YhrdzFxP+C5GQ7Bd2GheUy4M20kBbiOR5nreGAN1wgkniJ+mGJFzR1yVhM8y1CZqvuP8rrvuklnnLFBJHIXnqefClVdeKYEGu05y+8QTTxTZEwU3DYE50g0sCu+8805ZLJOooBNZ/y6GhwUziXWcDd1HLIS4GYcOHSpVLPp5BUQ7VUcQ7Y2Ofv36yaISOT5d5GKsMKTIn1C5hTQuTof5oxBbJIjiAtcDC30kAlmIpNn17oKCjEnz/hGMev5/ncrjp7UMVl8hd7cFDtGdy8tx1QpgKsuqCSY4FyyieHC/+BKYpAWuF65N7vfZs2c3eY9OZGwCVaAUhBj8Ralzjk2q3U/E5TO4v0nSQ5SWImcVloEiKHA7AaNK9kPKEPT6RJpTpAVhQ5Cv42yA+YymMJ9hKBXWWRgf4owzGPuA3yAOhTxOo7OEB0lPkqvEsPigcDF4XLNwIc11hmMliTDzGU1hPsNQDGeffbb4C+49Vczh/ncVEZH4bdu2rRQ4pt1lVss+A4KJjn/ifhpu8vkMbKHaYnJK7mg9coe+Q8eMQIqXKyfOsdK5sjzIS7mjraJW5fLZZxCvERPpbGoFYxMgQuNopDKfYagEEOPcPxQEAZWDpxBI8xcoJOBXTA6+OGikoJgHwppi1iT5jHxNgfh/5TfwUfAEdKLjo8hxabwQd9Ng2qR5IZ/BcakHtZhyYD6jdPizuqgwQQH5SnVtqUkBDBmkNsQWiV7IEipMkIJTIB/ORcRih5sHop1KFPfGooKXSl8WlVQ4MosV8p7vN5QGZtdxHtzjyv/p9B4xYoQ4ZjoPqXalgpSKqSOPPFJmzmPko6z5YKEPyYn8DZ2FPpHmVO8e1GKL7GutLp+f9/MEJDg9jhkVwPwE7BsVwFQW4igJZMoBCyeCRApTwucsCiCVi+N050fnAgUxkDOcHyr5TjnllCbV3MjQ8B1USPIZimC4L11AbjGyAUKbz5Dgo9KyXLC9VP4T+FC1qaAClKCI6kMjzf0H55B7xh3NkQsEve6ID0C1ogbDFFGxCHQ/Q/KK68MNmA3RIg6foeM6CCjwB6XMgMIeMOaFzlDONw8IBAImbC9BAmsWFuXVkuaQMj6R5s8++6xIkLmkedw+oxZhPsNQKqyzMD7EFWdQhIfyCCokSZPm4c4S1FBYj7DeRy2NdQhrU8h1X0lz8xmLwnyGoRCwN8SadE2591G4Q1if856hMp8B6TBt2jRJtNOpV8hnkDskRwFJ0bp1a+k25PchUBcsWCDkVNKKiqWCuKdS0lyPlSqOoIaDP+R4UFDmqnLRhVktzGcsCvMZhkpA/ttdt9IIiO1yi/732WcfyY1g5wz5wXoblST4I8YMJclnhMF3k/vn77j8BjaZHDU+Cr6A5iDyOfgn/BRrC3LqUW9b2qR5MZ+RNGnug7qc+YwG6Tin6olZBG71IoQgFwA3AoF8uLKRi65FixZSWaXAcCFvAqHm3kDc3BAfyI62b99e3odkzwcqKpFwIoBBIgvpFNe50N3OBT9x4kTZbkP51VJ0iFDsQGc4Ro+iBSq6IBEqNb6Q5gQJJJR0ge/jvFh3zvlL57Qp+/ixKNIKYAyyO5eX2VT5wOepjuPYoKJQ6LOVAGIbuX6q79q0aZNXLQIFCGR1ubcgxJGjP+aYY6SIRSXouE8pEiCwJVDl3qZCnOtFSR3udRYyN954oyxekDvq1auXXFcUw5QLjglEPE6N70NeieShK51n8BPlzDlmIcniks9BsqM6QhEWBVhaoEIinve5Jvhe5lJxXXD9JdHxZajeZ+SqzK0WyGCp7cUO0wmo3Selfj8VsgSsaXQy5gP7wvXPQp+gKymfUeswn2GoBNZZ6G+cASkNcY7NS7KTpBSw3odAxy4TV9BNov6HorBqE1fE2iTC2G+koSv5PvMZhWE+o75BJx/xQyFgmyAj3TUhMQk2inhWQRcV8Ydb0I0t497kJzkFQ/m+4fDDDxeyg3ixUp8BWezaYtb/2uUXhS2OgjQnh4I0dNRjRjhW5FX5G6rKRSyjvqhcVa5a8Bn4XgrauD64JhSomEJSTZkyJba/bT7DUCogScl3QOr26NFDXjM/Ul3Oh4JVOsyT5DNy5TghzSHAOb+l8BtwVYzYwE7zk9/BPuOnWONXs21pk+Y++gyf1OXMZ9Q5cY4hIFHh4thjj5XAgtkSSma4wHBw4bkBClLsVHvwfbkkhCC/CUKo7sh3gdJVRuIYMh/yDaNI1T0V+PxNAEFHFwmftVm6lYNLFievTue5556T7gqcDhVeGPdSjTFOBWKLrmUMqS+z88KkOaiGOC8kKUzBgAYvYUlhnCYkIfcUxPVSSy0VRAm2g+NO1RdFJ4XGLEBOc1+5Hb0Up1DZxwKFhQodnwQibvcw9x+Oku8H2AUIdkjNfJ8pF1x7kEiHHXaYqFewUIk66DRED2yyVtCyKHHBQpZCiHHjxmVfo+gJ8oIKQRZ9+AQqF917i0pBZkARFGOXuLYJQMK+ClCwwaiKXOBvcY3q38JnuX+LohEWOS7YFxZhhsp8BkkOusNJZmET4ih2CEs4YrM0KMkn4ciagUIh5mr7IrPJQp4AiDEHKHwk5TPqBeYzDOXAElt++gxiCDpzSDaxlsWe+wyIG2w0/oef+DglLipJiuEziXPZb9bWlSTCfPMZrLlYx1NgS3cK8Xrnzp1FttSNj4gde/fuLcW/rPf79OkjalNxwXxG/QIylbi/EFhr6fWH+hAxCo0gxChu04dJtcfnEwrZt3JzU2GCQm0xn8OeJk0qxEmaRz1axDefUQg77bSTqMCgDAFYM5AvJqdFwUycMJ/RWLACrMblMwo1BZLPqoTfCI9/VVVbtosGsXK2LW3SvJZ8RppjE8xn1DFxngvhGefhrsHzzjtPulMhNljMYLCYN45RoeIDMK+Yw4IkNO+fccYZsoh77LHH5EaD7GNOOdWnGABmnBMsQ7xjpLSiByKOhSgy0CQrIPWRyeCGNUQDzhNJjnvuuUecDvJZSOQyQ4QCBs59PuOMQ4Cc5tyQ8PLFiOYizXVft7rwf0cBzOi1U7DRmtHMycKZafDCNUxATiU71y9JIUiRu+++O5aiAqpuIe3pCg/fu2Fw30A0QnYShOBQcIJUZTFPnG0n8ffggw9K17eCRQhVZTpGgeIXpIVxOCTEeJ1rBTUJZIkqAceOan66VLkW3cpigyE8HoHkBJWozB3kug+D7nauRfwWFahc+xDnbnc7xDn+Bal5Bb7HF2K11nwGRQmMXIEIwMYkoTySrxOQoIT/47t8JM2xtQRAFJbwUFAIwPUap8+oF5jPaExYYqt+fAbrRgo3sYXIG/pOmudLiilxwzpZSfRSkmL4L/YdX8W6pJJxHD76DJ86QFyYzzAA4nPU2chboaoWbvjQJCv3teY1iJGxXTab1s/cFLZYC5qICThvGgtAKMdNMpCQp+A/KdI8DJpXNBZyC4pzzdv10WcUAr6EXBcKEOSu8BFsN/dieKRC1DCf0ViwAqzG5DNykebwCDRqRNUUyHeS41a+gG3BV2DDyE0VWv+nTZrXms9IU13OfEaDE+fhrkEqPC+++GKZY07wwU1PVQ+vkSgA3FQEwiSsIfUgyHmfxSugEv2cc86RrjS+D/KNjkJedxdByPgi20uSGSMBEfroo4+KNDbgdToKJ0+eLBcqifFRo0bJ7D1FPuNCpyOEPmD/wt2MEC5xVzL6Bi5lzhkOhwfkE4ElTocHBlOPJ0ac7mV+h+Pug1xHIdJcEVXXeaHghY5tiGwSQdwTFIUgT0YCKUogdc19RbcGhSnFiHPAvJjTTz9dzhv33oknnihJAgUS7jhEiEbuRdQkCFjYdrqKAQsJElu33nqrnHec/Q033CCOqVpHh1MjyWYwFEL//v2FpGXmWy4bjyICNorPKOgs4f6gEEuJc7ra3YWUoTKfQWIDn8kClGPM6Iiwz0ijE5A1Bgt+fJQv8uwUDrKYp2OCDigFihtaIY3/9WXkic8wn9F4sMRWffgMOkToCmBWK7NgIVmT9hlRotykWBSkeS35jDQ7QFyYz2hskLciVsbOoDjlkuYkpfW+ovGDvBTqi8SkFHUQ18dV1GGIJjelJDq2mMIHt8uPB7Y4av+CDyMfBmmu+ck0gW/RTnyOA3EQz/FHdAtyzGrBZ7gYPXq0+BD8BTEmuSyat5KA+QxDLlgBVv34jKSbAokXyD9qvMDfxD7jo5Cad9cldLyTM0qLNK+lOMMXdTnzGflRfqTrOegedYk3nrtSuxBlSOlyYSLt/O6774pUrpLmgKQ5XeQQbCwoWfAoaQ7Jx4xlFpgEICzwqBCig90lzSHuLrjgAiE5mH1H5QgJcMh0xfHHHx/MmTNHSHxISm4MqtdxZgr+vvvgb2N0IPNd8LfczyEZ12jguDRr1izo16+fnHfOLWQoHcjbbbeddHBiiEj2cJynTp1aU6R5EoCsofMSyWCOF9crSguMHcjVGVsp3nvvPTlPd9xxR8lyyJxTtgfpazpvcYB0iVOwouBeYsFBZR7OkeCEhKab1EMui+4gzj/XwuWXXy6d9Vwn1YDryJdryeAv8Bl0iZDIyreARPoVGxWWYef18D3BQpUkGcopxaQeDU3B8WeRjx9mQU/yiIVq2GdQ4BB3jSHBDXafv4utZU1C0gjQCULhD4FKmrWOWjWMn3VJc4oADz30UEnqUS3te2DiC8xnNB40+VvooUSckiQE0SiLhMlJuhEYLUGCRIEtwx/4ok5Rjz6DYmnIKNbJdIVQwJmGz4gSXFuQJqz12QeKAXgN30PBN/urCTKuN9bg7H+lpHmt+QySb27xGmsxjpPbuaJjf4j144L5jMYG9p38FSPL1l9/fVkz6kNBvgrVJHJP+A5GmtHsYaS537kp9RmQDqwTsK3MsCc5rmMF8fckyon1eK3eSHOATcXHkp9j/4k1GMeHwiDkAcUENFD4ohJZCpBlp8GJvDIqNUmR5sB8hiEMjS0ogMf2cE9R1MFD0bFjR7kXGWXLOpAGA5r7Tj31VDugnvkMN0eDoqqOjorLRrLmZz1MvLrrrruKreZaYf1LvICvovCJdX6apHmacQaFtOxvoUe4yJb7kpHONCsqaZ4GzGc0UMd5nEhjHnMYSEBjCNzvpeOcDkYehkXBJU61KseaLmfm1kHWUlxAkQSGP+0OkVJJ87g7znG6zOkmcIOUVokskkYEayRqowBdGTgztyqNhBznAYdMcBGWn8M503VL1a4CApJkAPemm7xjP5A14VjSvcv77A/3HUkFVB7c+44iFqr7qpkPzRgI9osZNQZDPqBoQkDCQpjkQC6wAKWbhKIPBX6HESEsRgG2jMQ1iQQKvZBiXHHFFSWhG753DPlBVz8ByLRp07JSu67PYLGNz4CMotIXHxy3z+Da4JwSjLBNbieg230CuV4JaVEJtGoYm4qCh6vekstnGIrDfIYhH6yz0F8Qx7FmZKyX+vC0fUZcYL9Y/6v/YW2Oz6ELsFIJyFrzGT50gCjMZxgM9YFyfYbb5UccyO+7XX7lxgJKmkPE8Ps+A5/BccEX4XdmzpwpvoemB7rjDPlhPsMQBg2FjI/NBZcWggDlHqNpkMIa8uaomJQDlEVZ55Eb5Z7FhuXKedD8gfw0eSyUQlEBtGak0n0GI0rhgSg2oqEsjWPH9sFR4aMowiDnTqxA8RO+Kslip7TjjFpWlzOf0UAd53EC5wHZFu4EzAUko+nMohsBIO/GQo9uXkA1EERhuNsWAwOxngsslLn5qf4KA0l4Fr4k2iEW+X7D/0IlByFq6QQg4UHVHAED86+ZO0/HPl3/UVTwxtlp7pLlb/7n20i3AwdHIQGODxLJdTKQzVGR5gAHz/FmIaUPzkOnTp3k/7mIP4ibcGConwvX/7DtHEvON8lNFhWAThkeub4njXNvaDzcdNNNUhyVjzQvFR06dJC5R3SGkWSBACa4oTrVUDqYe0QhmjufVn0G5Ah+mwCAwjfsdNw+wyXNIca1+4SEvNt9wt+m+4RKcAKpOO0XvkGrhl3SvJDPMBgMlcM6C/0F3WJ0dbg+PE2fESfYL/wQ87yZz0qMSvKLfUCNiuNAwsdVPSiENH1GLXeAGAyG+kK5PsPt8qPjkOYdyBFsFl1+fE5VQYoBm10rpLn6DPYftUCUBTlWNE4QDxkMhvLAqD/WYLkeLlCiYJ3HGE+ai8olzVVlkfUTxHguYK/gVvgckuQ0jUAcopJiKM1nkJ+BRKXjGzuJbU8jzmD7Vl55ZYmN+PuqhkNeCx+FUhXXEec6TviQmzJ1ufqE6QqXCLr7uOEhJkoBHYUks1n8uvOY6QoEJOkhIqkKgjDVecx0C+abJY0z4feooHHRt29fqcBkQY3TYT47laQjR44sdfcaAqeccop053OcqfAhCUIFD4QTlVs4HQy8VvtCXMTdzVeNPPuB1zwVWdc5iyK6W3E2EM0uiRQH+H5kyFzg2Ajg9HUqrJBcp+oQMKOEa5rzQuKSLpAhQ4bI60qgs+3cb1Tg8f4ZZ5whQaZWVuLQIZ94nQQgc2Jw5sw7t/vFEDeQakNqiTEDhQBBqZ3lCp7rDMN8lYtUBHPdU5hiKB2FOvQJBKjmpAKaR5w+g+uDIjv8uY6HccF3YyN5YOeo3Oa6oMOt0IypKEhz1iiu1FbSPsNgaLTEFo9i0MSWIVkU6uZI0mckBWJYilpZN0O2sM10dEDUkBTDB7HPqoaSSxIxbZ9BgrHYPeWOIIFcatOmjRTCM46tlDWavmcwGAylohKfQUGTFjXxeWzxa6+9JqQEsSB2mJ9hX4Vdg2yvBdI8n8+geMviXIPBf6CUCNyxuS4YK8L6kdwYeQYKguBGIOnpfK1E1aiRfAYNNIwcxh7SfAZRnGackWum+SabbCKv46PU/+C7NF4odWRrKUg7zqhGXU7HJig0loBT5D6icZb7gtFZNIBeccUVKW55Y8Kk2kucx0zlJx0gJKkAF3khqXa6/ugIRHJdST5mVUDWQvYBusqYc0vXGElukuUsgOlUp1ooDAjAvfbaS2Y0FwJz0E844QSRp/Z9blySoPsYCZh8UiEcr/vvv18CFSq5KETAIeF0mjdvHrn8caWkucq1z+y9U/CHNZavejuQXuzcubMkfbjG05qNGb6neE6hgy62SNwh+UO1MY4GkgjSnNdwwCqDTeEIFW2cv8MPP1zed0koKvT4DIs1JE5wVsi9U1hRi1KahtoBQQDSnviUQol3xguwyGQBrCB5i/+59tprc/4O1zzzqpDywW4Z4keUPqMYaV4IkOiaOMOOF0uclROAEACRXHNlI33xGQaDwVBLSDrOiAKsvSkcx49AtuTaRpJUKueOnC4+DP9DzIX/qDWfQYwBaY5EO52N4X2+5pprgsGDB8v+aExJYTxFkeGudYPBYEjCZxAL8HnsErYYu4z9hZAiFuA1uhLJtfA9PqPWfIbBYMgPcrlIiYel2uksnzp1apMxl2+//bYUMbLuhPQ15Ae8Enad/LdyPmnFGblI83y5JY0XuB5oaiNewE9RnNtIPiPJsQmG6mHEucfzmF3QUYI0E46FxEUhIN1K1y7BO523hsqMP8QqToeqX7qhIWlxOigFVDs7pJpO8yiBvCKd3e+8847MSvG9+thgqFUgW8RMTCohGa3hIqyugHIIygh8DgkrFE+GDh0qQQS2HR9B9SGFISxQKcIaMGCAzBZCrs8KpmrLZ2B/CRQrIc3DyJU4I2giIClnxhSBDUV8BB74KQ2AzGcYDAaD/3FGVKQ5cuzEuPlI8zCIiTUp5o4Ww4ewtvE9znA7QFB6c/dZO0AoDiC+ZvSXdoBQCE8HCHG+wdDooAuOHBjF6tgOmj4Y92BIzmcQC2hBLf8H2DWaEnzu5PQtzmA76IJlW7iekSKGoKF4So8jnyHGDwMlUfLBBkMjIx9xznqJxgG6g107h22D9GW0oSE/4I/o2M5nz5OKM0olzcOg0UPjBZrZKLbVTnT+X6s+w1Cf8F8fzgOkNY85PBeXyvdipDlgm/jbGB1DZVh++eXFqdDdjOw9XaIYd845DgF5/EceeaTkuX4ukPD3gTQnIcacFEg3KrPMyRgM8QEZKiRNSa6GwevYGbe7fPz48SIPis2fNGmSFHDpGAN8CdWHVJCiUkJyGv9AgRXJ3FyzO6lUzFdoBQFPIoXP5VNRIQnGZ1igo6Ly1FNPRXZsGtlnIFEGac75q5Y0B5xDpKkY+cJ1RMKG7y1nxhTEB59DycMlzc1nGAwGg/9xRhSgQBzSnHiyVNIcULjXrFkz8WkUgbOfyDOS0KIgkA4jn7uyiYdQiXvooYeC9ddfPzun0Y3X8KkkI9V3IwPPfhlpbjAEwYQJE4JTTz01OPfcc2Utif3YZ599JDluSM5nQDzQuUnRLHacAm1yjShdUhiL+hnrfZ/gY5yBv6L4neNNzEyBFOpvOn4zHOtzbvSBfzAY6gmDBg3KmWdyHz6v8eoJdGsXKoJKIs5Q0jw80q8UsO2ss2kcIT5AOZNigIULF0qhLWtxmoLC3JnvPsNQn7CO84hkpcMdg0jyMjMZ4kOl2k866SRZQBFQ5JvHDCkB+eF2hWk3+uWXXy5z0sOVjBgXJOVIlvMcyWkqtKiUN0QLHAsy/FRuQWRhrA844ABxSlwTxSp4Ic0hvNImzUmIcS0R0OIwbSafwVAfYD4O97eCTihGfHCfY6PCQPYHiSd8E76D7imqgl3gs/BxJArwZ/i9iRMniuSfFWhV7jM4JyzySdBHQZoXg86Y4sG6IteMKQIqAiCCsa222iobAKXlMyjWoBo9jF69ekkxRy5wbTISB6KGIG7EiBHBfvvtl8DWGgwGQ7pxRpSkOUAqsxJpx7DPIIFHBxFy5iionXzyyTFsucFgSBvECUjCjh49Wp5DOlJMg7wopIshOZ+B/b3jjjvkfSUUco3WgPSIet5sPeemUFNgZAcjttyOc/wm+WGDoV5Bngnl1EKgYMddq5pUe33GGS5pTiNPVCNP2R44E3wUP9kezVfhr9LOTRkaE0acez6PGRx22GHB5MmTxTCwSHOBoSCBzEx0jBeGBDIeYvaSSy4J2rVrV5Z0FvKsVM4jDUwVKhXCY8aMEYOooHONIgAMFNWs3bp1k4IBH2QFkwTn+PHHH892gyKDhawyigF77rnnIsGHkuZbbrllqoYdJ0PwOn/+fHGaFHwYDIb6BCQ48kyvv/560QUtPozPh4lzS4JF7zNYG1BFi6+gUjaXz4gTuWZMkVRjbUARHuoGqpqTps8otxCECmVIGdYkBIEoN0Cc65gDg8EQL0yiN704Iwpgb1EuI5ashjS3OMNgaDxQfEmRDDaLJLyCXBFrzSlTpqS6fY3kMxgRCTHOWpm8XS6fQSzAOhs59yjnzda7zzj77LODWbNmCWnkEucUiHBMIZEYoYYynMHQ6MhHnDOLm1idbmhtxKDpkGZC8hM2etDfOCMu0jyXb6BQg+sBXwU/xbayfeQ3FyxYUBM+w1D7MOLcc9ANeNRRR8lClq7yfDK6dAmyQL7hhhuCP/3pT9LNjkwWSWQSH6V2DbKwRloPBweBT0cAyXMWsmq8KBiA+IWAx9HxnT169JAZvI0KjguGG0NOkQNzOihawKgzA4+FAYUSV155ZaqkOVXfdJUiJYWTYdaVwWCo3wQWs9jwBbkk5Uohzi0JFj0okEPq77LLLpOxHbl8BiNckgLnGF+OzBW+jII4SBOSZhTY+eQzihWCtG/fPvj222/lMwrk6lm3sPYxGAzxwdRJ0oszovAZSpoTKxA7VlIQbXGGwdC4YCwDCWzyT8xQVUAiMi4IlURDMgVsxH0UjpLnK8Vn5Jo3q53occYkteYzUAlFpY0YjvynNsfceuutQcuWLSVvSicnDUwQUUaeGxoVNNthS6ZOnSq8Aaq6gHFy2BflFchVcb9QvN+lSxdpKCiHV7CC3WTjDHwK5xZp9ThJ81y+gjEA5NFQsIL0J+9DYV7btm2bKDYbDFHDiHOPQcUPMx/o+L7ooouadLiHgcMZPHhwkzm2dLCT+IZQL6VrkKpUOuPp0DriiCPkMxgnuteRgCf5rJVhBEbahU4yGuKeKqAkJAR9B8eVCix1OsyQQhKlc+fOsiigmy+t7eI8TZs2Tbr1Ntlkk1S2w2AwJAOKdTp27CiLW3xEJcS5JcGiBVW9hx56qMizb7vttjl9BsecAIVAhbErcfsM/BMd2VR24++p7CUBRMKN1wiIWEfg+5MKjiotBCGI4333GmbOJskrihQMBkN8MHWSZBCHzyBhho3kZzWkucUZBkPjwmKG9IEdZ14sHdHk7irxGcQF2olOTABhop3o/D+qWCBNn0HukzinEFD0pCFJgYoox5Yu/htvvLHg79JY9Pbbb2fJQoOh0XDMMcfkHB3rqsYxjo3GPYpmsC2QoMOHDy95DWoFu/Egn8+gaAg+inOm8+6ThPoMijGw3xD9jICiaYKCPfJYBkMc+F8dToOXgARHKgOZjGJAtiIspQFpTpJeE85///vfm3wXFZE8hxQHvM9C2f0Mi0US0foZfm6zzTZNpNuRc2de6osvvhjBXtc+OK7I30OSjxo1Sp5DOKAeADGFggDzppCroasvKSfDzFfIAyp6jTQ3GOofN910kyRESiHNDcmgVatWwUsvvZQlzcM+gype/DYjPXget8+gWpeZfBS9sU0Q5VwvdAcdd9xxsm10UBx99NFSIc54maT8Vhj4L44BgXg+UK3urk8Az3ndYDDEh1LiDEM0iNpnECMwSgp/UA1p7nOcQZxMATpJPrrqXbDvu+66q8TRFJRzHA0GQ/lYc801ZbwDhKsLntv80WSAUhSNL0qaV+Iz6NwjFsAf6DhKGnpQDICcQPWJ3F818UDaPoPRlBDjhR7MalZAHKH+ucsuu4icdCmFhHSnGwyNChRssRHhhztqDYUJuoeR/qZYByWHctagI0eOFOWHY489VmwaDX2MC7n55ptj2qvGQC6fsc466wTnn3+++AniPZot0+IzaEChOQg1XxqEaO7cbLPNEtkOQ2PCiHNPwYxxOsCY01kKIK9xHCxkMSpz5syR6hvkV1VCiC6CQgllfpI81xns+T6T6zv0PcP/AXl7AhEcNzO9KCygcku7/pmFxPx6KvGo5o3L6fC9KBbceeedcl0gqWIwGOobVPCSiEDuqhpYEix6oOxSKFAhUYUMVdw+Q0lzAlRIc51prj6DCmMSZAS0BLOsMaLsNCkXVghiMPiLUuIMQ/So1mcQM9KhSOFDpaR5LcQZFIPlKiKE/KGLhuQtiUDkRM8777ySiBGDwdAU5JHoSCOp7doYnrvS7YZ4UahIoVyfgU+AMIGQh/CiiPb777+X34NMee2118omT3zwGcRiNAgVeqiSJp3m7DvX9tixY7PxUiFQoMVxMxgM8cAKdpMB9o6xwSiDoFSMbaMwyBc+g+2jUKyS+CUKWGFuY8CIcw+BtHe/fv2k8jPcRZ4PdDZTZaOLPGaTU3lVysLOEA8IMChe6NChgzyHbNhqq61ENhaH8/zzz4vcE2QAFa0HHnigyD5RlR2V0+F7kDHhb+BkqMQzGAz1DwJ7ZPVQLakGlgRLD3H6DJ1lyxoBX0WHUCGfgYINko5nn3124HMhCMlC63QyGAyNiHJ9xg8//CDdJCR9GA1WyXzAWogz6ER54IEHpJMpDGJtkq8UOXPsiNn69u0rhWIGg6F8MC7nhhtukEQ6XbtIuiKjSl7KUNs+g1iBYjiKbfkceUfsJ0W4SJLT6f75558XjElqwWe4UNIcBU58CIXEFAO6BYFc6xA67D8P5jPjUyCZDAZDPLCC3eRw1VVXSUPg5ZdfHmy99dbGZziwwtzGgLGqHoKK908++USSGFTO8Hj00UdFioL/k/DOVTWJbAWBCQlmFm0rrrhiVmKolK5BfrL4pWq00GdyfYe+Z/g/cPzpYsgXqFApxZxWJNyRQEFSmUU3r/P/a665RhbrlZLo/B4zSKgGI2GExL7BYKh/0N0Bcc6cqHD1JTPXkNtWYPNJlvDg/9gc/u/Ky1kSLH1E6TOUNOdzSNe6pLmvPqPUQhA6mtxOJ0BizjqdDIZ4YeokteUzUCqjY+T2228X8qNS0txXn+HGqMh43nbbbSLfGQZjBFq3bp3tLAQcG44XBJDBYCgP7du3F4LxnHPOkTUm603mbYfVSAy1HWcQO5B/hESBRIcAVwWTefPmSdEEHYi8Vks+IwxiCGJiYov1119fusj14eLCCy+UjnT8KkqTzF62YhGDwVAPgDDHr7uqg8ZnWGFuQyFj8A5fffVV5vnnn2/y2GGHHTKdO3eW/5eCn376KbPJJptkzjzzzOxrO+64Y+bkk0/OPv/1118z6623XmbYsGHy/IsvvsgstdRSmUmTJmU/88orr5CBzzz55JPyfObMmZnFF1888/HHH2c/c91112VWXnnlzA8//BDJ/jcyfvvtt8y//vWvzBVXXJHZddddM0suuWSmRYsWmaFDh2ZeeumlzDfffJP59ttviz743IgRIzKrrrpqZuHChWnvlsFgSBCzZ88Wu/3qq68u8t5uu+2W6datW/b522+/LZ8NP/ici6uuuiqzwQYbZJZeemnxJQsWLMhsuOGGOX+3V69eObfrhRdeyBx22GHZ38POhXHuuecu8n2bb755JMelHlGuz2B98dhjj2Xmzp2b+fLLL2vCZ7BW4dobOHDgIu916dIlM2jQoOzz+fPnyzG47LLLMi+//LJcT6xrSl07GQyGylEszjD44TPeeOONzLbbbptZfvnlM0sssUTdxhnsa7t27TIXXnhhk/XOs88+m/3MXnvtlenZs2eT33vxxRflcxwPg8FgaGSUG2d8/fXXmffeey/zt7/9TfKG06dPl7X62LFjMxdddJHXPsNgMNQOfvzxR1nDTp48ucnrXbt2zRx00EGpbVejo1H4jI8++khi3KeffjpnfIHfO/jgg5v8zsMPPyyf++yzz1LYYkM1sI5zD7HSSitJ9ab7YK7oGmusIf/P1TW4cOFCkQV/6623RCqpXbt2UuGJdESpXYOrrLJK0L17d/ncI488Ip3vvEenFnMjAB3UVJR26dJFKkpnz54t0q29e/cOlllmmcSPVb2Byi2koPr37y8qA6gHdO7cWSRqkcWiK4KKLypf83UV8jrnmdlVM2bMCHbcccfE98NgMKQH7DR2INfMuLlz5wbjxo3LPv/DH/4gnw0/+JwLxn9gj5B0xd9QUU9Hwocffph9UJUPjjzyyJzb9d1334kKyvDhwwsqlCAb6H4vM/QM1fsMZhIis/X66683mWXru89gX959993guOOOW+Q9XucaUeyyyy7B+PHjZT4tEvSTJk0SNR5dOxkMhvhg6iT+A8URjR/xF9jQWoszBg0aJL6v0APlNaQlv/766ybxssFgMBjiy00xAmr11VcPtthiC3mPn+QkGYFBzpD4kXU7MYnBYDBUChsn6Ccagc9g+4455pjgxBNPDHbYYYecn2GcR1hpR5+7oz4MNYKqaHdDYqD7r1+/fnm7Buke22KLLTLLLLNMZo011pAKlw8++GCR78nVNejiggsukCoYvodOhEMPPTTz4YcfNvnM66+/ntl0000ziy22mHx2rbXWkmrSMEaPHi2dhXwXf8utFPr000+lK+WPf/xjZtlll800a9Ys06dPH+l6d5Grm/HOO+/MNGLl1ieffCLd/fvss4900G2zzTaZIUOGSEWvVm7x8+qrr86stNJKmUcffTTtzTYYDA0EfBRKJ9irYsA35Os432677WLawsb1GVT7rrjiirI+mDNnjvkMg8EQC4rFGYZ0QZdDx44dxT/UapzBdqIoUuhBJxKdHqik0ZGkD+JIftKRBKwjxGAwGMpHuT6DGOTaa68V9ShixRVWWCEzdepUO/QGg6Fi3HXXXcI1jBs3TrqZURCiQ5luYINfqIU4A/+Ui39yH8QYo0aNyrRs2TLzyy+/yO+ZolX9YzH+SZu8N/gBugfpRlt55ZWDNm3ayAyiXBg4cKDMxKMKiLl4dJ3TZfLEE09IFxtgrg9d8ddee61UlvJdEydOlHlJzCl94YUXgnPPPVcqdehgpxKJih2qkOgQcyuWmG1KB71i1VVXDZZddtmgUcEty9y9qVOnBvfcc490edLFefDBB0vXP/NHeK9t27Zpb6rBYGgQMB993XXXFV/AfLxioNOdSlQeLs4777zg0ksvFQUU7DyKJ8OGDZPKVUNl+Pnnn0UF4Nlnnw0233xzmT1oPsNgMBgM9Rxn0E3/1VdfZZ//+9//lvnlxJnEpsyrZWbv4MGDZRa6znlnDYOKG13rBoPBYIjWZ/D5f/7znzInnLygwWAwVIrRo0dL7ogu3u233z648sorZY1XDciV8J0o8KKQMXny5OCQQw5pYvPgMuBDvvjii6Bly5ayntxss83sRNZwnPGf//wn+PTTTwt+hu2EM5s2bVqTme8oei2xxBJBp06dROEZLowYBOVDBarO7NNnn30WrLbaarHuiyFipM3cG/wA84g222wz6UQLd7eHsc4660g3uQvm1nbq1Cn7nC6T3r17N5lzuO666xacc3j33XdLh8rPP/+cfY1LNDy3xNAUdOnffvvtmf33319UAMaPH2+HyGAwJIoJEyZIF1cupZNyOs6Zh4cv+Mc//pGZNWtWZuedd5buRWZzGyoDnXVU9P7nP/+R5+YzDAaDwVAq6sVn5OoIYd9+//vfS+f5Cy+8IN1LKK7REWMwGOoHzFfdYYcdpPMZtUQUKV555ZUmn/n+++8zvXr1yqy++urSEU1+yzoXG9dnGAyGxgT5qMGDB2fuvffenHzE8OHDM6usskrmvvvuk5wVM9U32mgj8SGG+vcZzHB//vnns4/Zs2fLdTJp0qTMe++9J58ZM2ZMZrXVVsv89NNP2d8788wzM5tvvnmKW26oFDbj3CBgRvn+++8f7LnnnkWPCDNuwx3fyy23XHYOLZ2HVGe538W8I54/+eSTeb/3yy+/lG53nbvqbtuaa64psy1uvvnmvLMwGhV0ZlLZNH36dKmSOvrooyP/G8wkpqIq3B0aBsoCdDRyPTRr1iw45ZRTgh9++CH7PrMG+Y4NN9xQPsM8WpQOXOSbV0jVn8Fg8BM33XRTsO+++0rXeTXgO+iORn2EzrCZM2dKJe/dd98d2bY2Gtq3by9zpfCjSfkMg8FgMNQH6tlnsG8PPPBA8Pbbbwf/8z//E5x22mnBOeecE/Ts2TPtTTMYDBGCWavklBYsWCDdbagx7b333sG3336b/Qx5C7rIUEnk86hUHHbYYXYeykQ9+wyDwVD/IB910UUXBYceeugi78FFkPM+++yzpUOanNWtt94q/sLtLjbUr89ACXPrrbfOPv74xz/K65tssomoWYGOHTsGSy+9dNC9e/fgxRdfFEXmUaNGiTqnofbQlKE0NCTuuuuu4JlnnlmEwMwHyIyRI0cGrVu3FuPw0EMPiaQd8hTgv//9r/z/97//fZPf43k+2Tt+58ILL1wkUXHBBReInMXyyy8viY1evXoF33zzTdC3b9+K97eescYaa0T+nVwX1113nSwKCmH8+PHBoEGDpLgBQvy1114TKX5Ib64XcPzxx4tM/2233SYEG5L/FFS89NJLwXrrrSefQQ7Hxf333y8O5/DDD4983wwGQ/Vg1AbELH4gajCag8XoG2+8Efl3Nwr222+/RH2GwWAwGOoTtewzGBGTq/ia+Oaxxx5LZZsMBkMymDVrVpPn48aNE5lwmj3IadHAQREw+QyVh2Vc4BZbbCFke4sWLexU1bDPwP4Tr7pgFBi5KwXy8RRXkPtaa621gj59+gQDBgxIYWsNBoOvoNASWXi3SRDiF3l4mgQ7dOiQ6vbVOnzxGVEV5uJTKMylgcUKc2sXRpw3ON57772gX79+Unlb6txwKmV69Ogh880hRSHPjz32WCFMKwGzH+h2Z9Y5821dDBkyJPt/5qdTFUznsRHnyYAiBaq/mN9C1V0hMOOe+S5UV2mAQrXYwoUL5fn3338vM0ymTJkiASrgfFPZzUwY/f611167yffy+TZt2sg8EYPB4B9ILJF8wo7HYYPefPPNoEuXLpF/t8FgMBgMBoPBYGgsQJSD1VdfXX5CoNOF7pIh5LroLIMMMeK89kFDDjlMxUorrdQkH4kCAef/2muvDZ5//vnguOOOkwJuUyAxGAwKSHOQq0lQ3zM0Fqwwt/5hUu0NDoKETz75JPjLX/4iEuk8kKa68sor5f/aRe6CCkxkSCCxqdyki3zFFVfMEptU0yyxxBLBxx9/3OT3eB4mRZHubteunSxcJ0+eHCy11FIFt5dKrvfff1/k4g1+SfjTZc719NRTT8nzt956S2SWtdvxl19+keupkMx/GFwzM2bMkI5zg8HgH3777Tchzrt167bImI2uXbsGZ555ZvY5Yzyee+45efD/Dz74QP7vdpOffvrp4oPeeecdKcZBIgt/4rtkk8FgMBgMBoPBYPA/dmF0HAX/yKwCCA9kVSFKXRgZUj8g30guUh8rrLBC9r077rhDYlMagbbaaivpGqVRR1UTDQaDwWAwNCaMOG9w7LHHHlJRqWQGjx122EG6jPk/hEU+QIAirw0hSicxMz4AQQdyFEi4uwEKz3feeedFKjv5/NSpU0vqeGebVltttWCZZZapet8NpUn4I2NVCug0p5K3VatWUgCBEsHuu+8enHXWWdlghfOPJD8zYCDRkWqnijssz6645ZZb5PdsvpjB4CeQaH/33XelKj8MXnfvbe57lEN48Ppll10m/2eEg4LCKEjyzTffPDjqqKNErgmJRAq2qOZE5ST8oMAnF1DK2HXXXcVn8KAASAt7FMi2Ipu0zjrrSBEPn3n99dcjPUYGg8Fg8Aesa5s3by7rS9RSDjnkkODVV19t8pkffvhBfAs+iOJgxgWFC4INBoPBUHvAtjM6jlyHoXEwfPhw8enEnihYksNUkI9CEZG8pDuekrXB559/ntIWGwwG36CNgKU0CRoMhvqASbU3OEgaaaWtgupLFpX6Ol2DEORKoCK9Tafg9ttvLz+R24YYd2cAnXrqqdKBCAm/4447Bn/961+lQx1Jd5c0/+6774Q85TkPAEECYY+ENw4IaSxIdeTkhw4dKh2JBv8k/OfOnSvnZ8yYMaIMQBcp3wFRrpL7zDaHYON64hyjdABJRqd6LlD1SxFHqdtgMBiSBXY818xQtQmlyBi5KJTEYuacq4JC0muvvfYKjjzyyLx/H/uCGgY2ZMSIEbK9L774otggcMkll4jCCkU6G220kdgqEiUvvfSS2R2DwWCoQ6BqAnECeU7inAJPfAN2XzvQTjnlFFE8mjhxosypO/nkk6WIc/78+WlvvsFgMBgqBLZ8+vTpwbx584L1118/+zqEBx3HX3zxRZOucyND6gN0j5N3QpofRTMU0Sji1o5yFAeIA12oFDPvUYBtMBgM2An8BU2B8CEAHgOO5KSTTrIDZDDUIzIGQwi77bZbpl+/fk2ed+vWLft87ty5mS222CKzzDLLZNZYY41Mly5dMh988MEix/Gqq67KbLDBBpmll146s+OOO2YWLFiQfe+RRx6BPcn5ePvtt+Uz999/f2b77bfPrLDCCpmlllpKvmfJJZfMbLvttvJeGKNHj85suOGGsl38vYULFy6yX+G/dcIJJzT5zL/+9a/Mfvvtl1luueUya621Vub000/P/Pzzzw13jUyePFmOzxJLLJF98HyxxRaT///yyy+L/E6rVq3keLm47bbb5Fj++uuvTV7/5ptvMv/+97/l/0cddZQc8zDmzZsnf/O5556LfP8MBkPtAz+1ySabZH777beSPo/dWmmllTK33HKLPOf31l577cyll16a/cwXX3whPuTOO++MbbsNBoPB4A8++eQTWW8++uijWT9A3DFx4sTsZ15++WX5zJNPPpniljYupk+fLrHdsssum1l11VUzBx98cJP3LX4zGAyFwJq/d+/emXXXXTfz2muvLfK+2v1JkyZlX3vllVfM7nuMgQMH5s0n6gPfnQs33XST5BV/+OEHeb7XXntlevbs2eQzL774onzHSy+9lMj+GAwGP/D1119nnn32WXlgA0aOHCn/Z60Jhg8fLmvRKVOmZP75z3/KmnSjjTbKfP/992lvusFgiAHWcW4o2iUYfr7bbrtJV0YpFb08cgEJbyRzkeJdeeWVgzZt2khXugtmn/MYOHCgdKUju/unP/0pmD17tsy9pVoUqSUwYcIE6XK/9tprpduZ71J5JWQYFT169BA5ccXyyy+f/T+djMzzpoKM76YKlW57ZMfppG5ECX8XqAVw/DkfuST8UQ9YfPGm0x/0c+EuUzp6eCB9xfmk6zOMm266SST/t9tuu4j2ymAw1AvoCsEvYPeRay8F2Kiff/5Zug3A22+/LV0EyLMr6CzEhyDZx3w7g8FgMNQ3vvzyS/mpvgEVJHyF6xtY/26wwQbiG1DCMiQHxoERvxGLtW3bVlQCUJxRWPxmMBiKAZWR8ePHB1OmTBHFRdb/uu5nVBM/u3fvLnEFvoD8VJ8+fWTMnNl8P3HaaacFxxxzTMHPbLzxxjlfJ9bDl7zzzjsyHoz8Xy7pZWDyywZDY+Fvf/ub8BMK/AJAUXfcuHGitIuabs+ePUWlhFGls2bNKlutEEXfe++9N3jllVfED6GSiEIiNskdHYWtQ5Xxxx9/FI4DhVdVxDAYDAkgDjbekAzontt5550zhx566CIVs+uvv37mrLPO8rqKa7PNNsvMmTNnkQ73MNZZZx3pJndx2GGHZTp16pR9ThcCVcQKOpypKB42bFj2tWJ/Z+bMmZnFF18889FHH2Vfu+aaazIrr7xy5scff8w0OsLHD6WBQYMGZZ+fe+650s1Jp+Zbb72VeeCBB6QblI5yxaxZs0QtQN/fbrvtMjvttFPmp59+avK3vvzyy8zyyy8vx99gMESDWvYZYUyYMEHUL3KpneTDSSedlNl4442z1cDz58+XKmJVv1AceeSRTeyWwWAwNCLqyWfkA/HC/vvvn2nZsmX2tTvuuENUrsJo3rx5ZsCAAQlvYWMD1a/11lsvc+ONN+b9jMVvBoMf8Nln5OtIHjt2bPYzxAe9evXKrLbaapKHYD8+/PDD1LbZEB9uv/12yft99tln8nzMmDFy3t2c1JlnnpnZfPPN7TQYDA3oM5LAPvvsIz7ohRdeEJVVVFhR7EWdVXHiiSdmmjVrlnnooYcyf/vb3zItWrTI7LLLLqlut8HQaGjaHmqoKdDNS8UT1U133HFH9nWqY6mUPffccwOfq37p7na7OfKByqpw9RYVWY8//ni285DuEPe76HzmOZ0hLjhOa665psxvZ7YRHYgKPrvNNts0qd6ioouZJczENTTFu+++K135irPPPluq4fi55ZZbStU2x++6665r0tXDuadzh25+qvPoOKer3wUVdcS4zCc2GAzRoJZ9Ri5Fin333TdYd911S/r88OHDxa5MnjzZZpcbDAZDg/mMfGBNSvcy/sHgH5555pnggw8+kLgOlbF11llHfL/bcW7xm8HgB3z2GeQVcj3cjmXyTVdffXXw2WefSTchnYDWbVz7wEegRvmPf/wjeOutt+TaPOWUU4LOnTtnZ5d37NgxWHrppSV/Rd4PNctRo0ZlO00NBkNj+YwkwH7jg7baaitRWeVYkGOH29DcOTmvkSNHiuISaqxjx44VddwFCxakvfkGQ+MgbebeUD1GjRolFZJ0zd13330yn8nnudB0JG+99dbZrr9ineBHH310Zsstt5R5VHSG0KnM3GztBqHjkEv5iSeeaPJ7Z5xxhnSiK6677jrpeGYOCVWmdDC41W09evTI7L333k2+49tvv5XvppvBYDAY6gG15jPCeOedd6RLgG0vBcwwX2WVVTJPP/10k9fffPNNse/MrHLRunXrTN++fSPdZoPBYKhV1LrPyAeUquhoQQXJBV0d+IbPP/+8yet0gTDn0JBszMi54Ngze5huG+LCNdZYI/Ppp5/KZyx+Mxj8Qr36DENt4u9//7soHBILLrvsspktttgiM3To0Ox8c8U//vGPTKtWrTLLLLOM5AmZY2wwGOKH+Yz/xeuvvy5r3ueff16eWzwSL6ZPny58EX6BmfXMqnfBTHtUAOCe1lprrczpp58uSliGxoN1nNcBqMiiQqlLly4yZ+Occ87xdi70e++9F/Tr108qykqdAUK152abbSZdylSCMjededvhedrFwLGhA5qu8k6dOgW33nqrdB+++eabFe6NwWAw1B5qyWfkApW2v/vd70S1pBguueSS4MILL5SK3h122KHJextttJF0kjz00EPZ11AYWbhwocw0NJQOOgLp3FhjjTVEEQY/y3ywQqCrZ4sttpDPM8sLn2wwGPxDrfuMMOgyJJYgBnj44YfFF7igowMlJNc3vPrqq9IFYr4hGgwaNChYbLHFCj6Y+fjbb7/J5wcPHhwcfvjh2W4b3p84cWJEW2MwGKJEvfkMQ23jL3/5i3RnMov4+++/D1566SVRnlxmmWWafG7bbbcNHnvsMZkp/P777wcDBw5MbZsNhkaC+YxA1rv9+/cPWrZsKeq44KOPPhL+Y9VVV21yvFDI5T1D5bjnnntkjQKvhBrJ/PnzRXlE8euvv0quEXVjOvxvueUWUQRgPWNoPCyZ9gYYqgfJg2uuuUYS0CSrSUb4CmRHPvnkE1nAukZp3rx5wejRo0WWHckWF2uttVZw3333ySL2008/FWle9nHjjTeW95Fe53c+/vjjJr/H80LyWjvttJP8fOONN4JNNtlEPvvUU08t8h3AZLoMBkO9oJZ8Rq6ggqR5t27dgiWXbLqEYfzDeuutFwwbNkyejxgxQha348ePD/7whz9kA4wVV1xRHhwHApSLLrpIirMgT4YMGSI+5pBDDkll/2oRn3/+uQR5bdq0Ce6//37x2a+//npW/jAXuP5IWt1www1B8+bNxff26NFDfufAAw9MdPsNBkP9+ox88uz4hSlTpgQrrbRS1jesssoqUsjDT+RakWhFKnLllVeWpB6keYsWLdLe/LoAo51cieRcIM7TkVCMgFJAdvAehQzA4jeDwS/Um88wGAwGQ3wwn/F/o6N0HK0hPvzyyy/SzHnppZdKvKdwY40HHnhAiqwefPBBKVTYfvvtpRmHgqrzzjtPChoMjQPrOK8T3HzzzcHyyy8fvP3221Ih6Sv22GOP4Pnnnw+ee+657IMuQDrA+X+YNHdBhzqkCIaOCqGDDz5YXsdo0YHgdoZArvC8UGcIfw8wLw/wWbYNYl8xZ84cSZi5RtRgMBhqHbXiM8Jg8Uqy/LjjjlvkPV7XJDsgaUeV6BFHHCF2Xh+XXXZZ9jMDBgwQQoSOGAjcb775RrrT8TeQ7bm64AhscgESeNdddxXyl8eee+65SDEWREH4+9q1axfUMihQaNasmRQ07LjjjlKAsPfee0tBWj7cdtttwQknnBC0b99eCJAOHTrIOeC7DAaDf6hVn5EL+AbmBu6+++5NfAMzTRVXXHFFcMABB0iXc+vWrYWcZd6tIRpQYIWSWKGHxncQ5XT8K37++efgnXfeCTbccEN5bvGbweAf6slnpI3hw4dni30VNJQQj6D0RDEwvircRGIwGAy1gkb2GahgTZ8+PXjkkUeC9ddfP/s6sQe5LNQyymkQNBTGM888I2qJKBj/+c9/lhhw3333lcIFxZNPPimFf5DmCtSLUad88cUX7RA3GtLWijdUj/nz52eWXHLJzMMPP5xp27atPH777beaObThGeddunTJDBo0KPt8wYIFmXvuuUfm0c6bN0/2b6ONNmoye/Cuu+6SeUTjxo3LvPTSS5mePXvKnIqPPvpI3n/jjTcyF1xwgczGe/vttzNTpkzJbLzxxjLLVvHLL7/I7HXmnDOHi3nozLI488wzEzsWBoPBEDdq3WckhU8++STz4YcfZh9z5syRuVOPPPJIzs937Ngxc/XVV8vM9JdffjlzzDHHyDy9999/P/uZbt26Zdq1a9fkez/77LNMLYNZgf37988cccQR4jO33377zPXXX1/wd/7yl79kzj777CavDR48WOZg/vTTTzFvscFgKAfmMwxpghiRebOzZ8/OvPLKK5nu3btnfve732V9p8VvBoNfMJ8RHZ566qnMH/7wh8y2227bJF924oknZpo1ayYzcMlvtWjRIrPLLrtE+JcNBoMhGTSqz2Afe/funVl33XUzr7322iLvf/HFF5IbmTRpUvY11sHko5588smEt7Z+cOedd8ox3GCDDeTY4kOPPvrozBprrJH59NNP5TM9evQQXsjFt99+K783c+bMlLbckBaMOK9xcPNuttlmmT59+shzSOEVV1wxM2bMmEytEuc8h1xQzJ07VxLzEOMYM4j1Dz74YJHvueqqq8T4Lb300pkdd9xRCHfFu+++KyT56quvLt+z6aabZs4444zMl19+2eQ73nnnncy+++6bWW655TJrrrlm5rTTTsv8/PPPse27wWAwJIl68BlpAT+1ySablBzIkcxfaaWVMrfcckv2NXzbwQcfnKkn4FN5UGT2zDPPZK677rrMsssuK4Vs+cBn1157bQlUOJ5PP/105ve//70EI//+978T3X6DwZAf5jMMaYNiKuIxyHJ86p577pl54YUXmnzG4jeDwQ+Yz4gOX3/9tcRsFO66+TIlUyZOnJj9LAW7RqYYDIZaQyP7jJNOOkmaLOA73KaK7777rkmRFBwHRQXkTXbeeWd5GBbFwIEDxQ8WeuAr77jjDvk/OSvFDz/8IPzPtddeK8+NODe4MOK8xtG3b18hgXE4Cm52nA1Ox7Aohg0bJobSJetzJWnOP/986UqHEKDK9/7771/kc6NHj85suOGG8hnI+oULF2bf4/jnM9h333139nO53qcKymAwGKKG+YzK8OOPP0rh1sUXX1zy73z11VdCIE+bNq0JcU6ARGf2H//4RwmG/vvf/2ZqGSTvwgEcwS/dL/lAQHjsscdKdfkSSywhldYDBgwQ/6dKMQaDIX2YzzAYDAaD+Yzk0bVrV1F0Ai5xTpc562VXfRFArowcOTKFLTUYDIbK0MhxRj6uYOzYsdnPfP/995levXplVltttczyyy+fOfTQQ4VcLxcUImyzzTZSgMqDPI3bOa1/h0bDFVZYIXPYYYfVXE4GtUiI8UIPcnoUIXCcH3vssSa/D59z1llnyf+HDBmS2W677Zq8/9Zbb8nv0ShiaCwYcV7DoDKJhHP4hgfISjSKxEkUcldhkMAnkT9jxgyRiMfRQIC4RhJ5eLrbb7755syLL74oVUnIw3/88cfZbkO3cowHZDyLACqIFeoc3c/huAwGgyFKmM+oHBMmTBB/m0vtpFAVMcVXrj2nKIpRIf/85z8zkydPFjWV5s2bi7+oVZCoQzrXBT4TH1oMFKm99957sv/8DoHcr7/+GuPWGgyGUmE+w2AwGAzmM5IH8QIjBDWGcIlzuuXIQYVBPEEOqx7BmKx8JBP5vUJNKyZpbDD4CYszksPUqVOF20AS/tVXXxWCmOYHVXBqpPEfqA7T+HjjjTc2yUmhbKVd6BQVLL744lluB/DeyiuvLN3phsbCYvyT9px1gyEJfPPNN8Ff/vKXYMyYMcFFF10UbL/99sFf//rXnJ9dd911g8GDBwe9e/fOvnb44YcHyy23XHD77bfL85122ilo3rx5MHr0aHn+22+/Bc2aNQv69OkTDBo0KOf3/vnPf5ZtuOmmm7KvLbbYYsHkyZODQw45JOI9NhgMBkMU2GeffYKll146mDZtWkmfHz58eHDJJZcEc+fODbbddtu8n3vrrbeCTTbZJHjwwQeDPfbYoyZPVseOHYP33nsveOyxx7KvnXLKKcHChQuDJ554ouTv2W233YL11lsvGD9+fExbajAYDAaDwWAw+AvW1DvssEMwZ86cbAyx++67Z3NXrJOPPfbY4Mcff2zyezvuuGPQpk2bYMSIEUG94aeffgo+++yzJq8NGTIkeOihh4I333xT8mnvvPNOsNFGG0lMtdVWW2U/t8YaawRLLbVUClttMBgM/mL11VcPLr300uCII44I1lprLfEt/B+88sorwRZbbBE8+eSTQYsWLYJ6Q//+/YNJkyYFN998c7DhhhvKcSDPx36vttpqwa+//io+F16InN5HH30UdOnSJTj++OODoUOHpr35hoSxeNJ/0GBIC5Dg+++/f7DnnnsW/SyByLLLLtvkNUjzxx9/PLt4//vf/97kuxZffHF5jnPJBT7/3HPPBd27d8+5bWuuuaYEPBhvq2cxGAwGP/Cvf/1LkjAslEvBZZddJsT5Aw88UJA0BxtvvLHY/jfeeCOoVUCSL1iwQIII9oOg6/rrr29SeHbmmWcGXbt2zT5/7bXXpAjt9ddfD5566qmgQ4cOwQsvvGCBiMFgMBgMBoOhYUHO6JNPPpFmiyWXXFIejz76aHDllVfK/3//+99LLuqLL75o8nsff/xxsPbaawf1CIqX2Td9QIZPmTJFCgggzV3wnvtZI80NBoPh/wApfNdddwXffvttsPPOO4vP+fnnn5twG3/605+CDTbYIC+3UeuAKCf/BBlOMyT5vocfflhIc7DEEksE06dPl58co86dO0su64ILLkh70w0pwIhzQ0MAx/DMM88Ew4YNK7m7cOTIkZLUp5Ocit977703+PDDD+X9//73v+JwCFxc8JxqpFygy5yqrV122aXJ6xjfu+++W/4GXe29evUKrrrqqor31WAwGAzRYezYscHvfvc7KbwqBipSL7zwwmDWrFnSLVIM77//fvDpp58G66yzTlCrINhANeXOO+8Mtt56a9l/OmI6deqU/Qy+8913380+x39efvnlwXbbbRfstddewQ8//CDd6X/4wx9S2guDwWCoTVCoBXFA94QCm0rxEgTCiiuuKPEFpIrBYDAY/AYKVM8//7w0XOiDmIJ1tf4fMphua8Wrr74q62wS/I2AqVOnSvwEcR7GQQcdJHFbq1at5HMGg8FgCMSvEBMss8wywYknnij5my233FL4C4qTVl111ZK5jVoHPpRmF2Kjr776SrgYV6kE0Ik+c+bM4Lvvvgv+85//yOcpXjM0HuysGxpC7qpfv35iDMNd5PkwatSooEePHlJpRTIKKV0W5nSDV4Lvv/9euvCQlArDfQ0pdyq/qIDq27dvRX/LYDAYDNGAwimI827dui2yUKbqFGlxLchCGvGcc84RWw8BrIEGAQoPxoWcf/75QmDQAYG04IABA4JNN91UirVqGQcccIA88mHcuHFNnlNE9uyzzyawZQaDwVC/ePrpp4PrrrtuEXUTlEBmzJgRTJw4MVhllVWCk08+OTjssMOC+fPnp7atBoPBYCiOlVZaSQpRXaywwgpSCKWvo2B46qmnitTuyiuvLKMCIc3rUVI3X0MKsdP666+ffY1Yi6Lcli1bihLkPffcI6MQ77vvPiHTDQaDoZGx+eabS/HVl19+KTLl5LdQMzEYDIVhHeeGoNHlruh8C4MZHyyyIbGR7WDWBYtxZHUB0rrIdoS7N/JJZOGYqFRypWrzgdnpdCGG51YZDAaDIVkg0U4Hx3HHHbfIe7yuKiTgmmuuEelEZkPRQa4PqlMBPuOf//ynJG/++Mc/StLrf/7nf2Q2OJW/BoPBYDCUCoqx6EC84YYbstKCgIQYpALKWW3bthU/QwEYqh6M1TAYDAZDbeOKK66QglWKcVu3bi35J9QRaw2DBg2SJpVCD/JwLsiTzZ49e5Hxh+TnKCYgl4YaFmosyOvSkGIwGAyNDrrKadggLqDxA+U/GgbxH402/sNgKAdGnBuCRpe7gszIBzrU6Sj85ZdfpGr14IMPzjodHI4rkUVnIs9zSWSRwIIsgZAvBraJBJgRKQaDwZAu9t577yCTyQjRHcbcuXObdFK/88478tnw47zzzpP3l1tuOUn0UMhFcMLnmQWuIz/oUs+VMHJnhbsgQYYvQ1aLTpTtt98+uO2225p8hr9PFzwEPn+f2VWMIDEYDAZDbQPfwAgRdyYhaMRZhQaDwVDPIOZgDJKbo7r66quDzz77TBo9iAlqkeA47bTTgpdffrngQxtXFBSC0X1fShc5JPobb7wR4x4YDAZDbQL+gmY9eI1GH/9hMBSCSbUb6h6lyF2FJXcXLlwYfPDBB0JE8BPiA8eCrK6CilbkTSAudtxxRwlmCFzCs5ZYrM+bN0/mY4Qxbdo0qeRCVosACDn5oUOHBqeffnpMR8NgMBgMvkruugooL7zwgsz/PvLII3N+HnnGwYMHCyFCMdf06dPF/zDXT6XfmbmOusott9wSbLTRRjIahPdeeumlkkeXGAwGg8Ev3HXXXcEzzzwjfiOMRpxVaDAYDIbaA00lpTSWuAXBEOfk7iB6SmlIoXjYYDAYGhlnnnlmsO+++0oR7ddffy2jBSnIoqmDkU6NPv7DYCgEI84Nhv8vucssJMUPP/wQnH322cFbb70lEu377befdPK5Saj27dsH//nPf6Sbj0QUJPusWbOy3YMK5qIzf4nOxTBY8FMtzCxCAgGkU5BWZL66wWAwGBoH4cQREoObbLJJsNtuu+X8/O67797keb9+/YQgf/zxx4Ucx6dQ0IUvU7WUW2+9VXwUo0g6dOgQ494YDAaDIQ689957Yu8ptrUCKIPBYDA0Ch5++OHg7bffDo4//vhF3iMGomjsz3/+szynC5883I033pjClhoMBoM/QPGQgiPGDEKUb7vttkKa06Sh4z/gQxj/QRc6uaQxY8akvdkGgxdYLENm1WAwGAwGg8HgBZByX3fddaXy96yzzir6eZZyJJOQLYQUJwii8Avi/dlnn5XCLgVEPM+ZaWUwGAyG2gI2/tBDD20yagq1EkZ7kPQiEYZM++eff96k4HfDDTcM+vfvL8W6BoPBYDDUGjp27Bj861//CubPn5+TOB8xYoS8v+SSS4oi1xlnnBEcccQRqWyrwWAwGAyG2od1nBsMBoPBYDB4Rox88cUXwTHHHFPwc19++aWMGaEyGBKFymCtHFZJ3rAKisn1GgwGQ+1ijz32CJ5//vkmrzGmA5Jg4MCBQbNmzbKzCukcATar0GAwGAy1DuSF84ERijwMBoPBYDAYooIR5waDwWAwGAwe4aabbpI5VHSdF8JKK60k8/u++eYbIUnoUN94440XkXE3GAwGQ30Au7/11ls3eW2FFVYI1lhjjezrNqvQYDAYDAaDwWAwGAyGymHEucFgMBgMBoMnQGLwwQcflNl8xYAs76abbir/R3795ZdfDoYNGybE+dprry2vf/zxx8E666yT/R2eu9LtBoPBYKgv2KxCg8FgMBgMBoPBYDAYKocR5waDwWAwGAyeYOzYscHvfve7YP/99y/7d3/77TeRbQcbbbSRkOd0oitR/tVXXwULFy4MTjrppMi322AwGAzpYO7cuU2eL7vsssHVV18tD4PBYDAYDAaDwWAwGAzlwYhzg8FgMBgMBg8A8Q1xzoy+JZdsukTr2rWrzDOnoxzwc4cddgg22WQTIctnzpwZ3HbbbcE111wj7y+22GJB//79g4suuijYbLPNhEgfMmSIyL8fcsghqeyfwWAwGAwGg8FgMBgMBoPBYDD4DCPODQaDwWAwGDwAEu3vvvtucNxxxy3yHq8jza749ttvg169egXvv/9+sNxyywV/+tOfgttvvz1o37599jMDBgyQz/Xs2TP44osvglatWgWzZs2SbkSDwWAwGAwGg8FgMBgMBoPBYDA0xWKZTCYTes1gMBgMBoPBYDAYDAaDwWAwGAwGg8FgMBgMhobB/7UuGQwGg8FgMBgMBoPBYDAYDAaDwWAwGAwGg8HQgDDi3GAwGAwGg8FgMBgMBoPBYDAYDAaDwWAwGAwNDSPODQaDwWAwGAwGg8FgMBgMBoPBYDAYDAaDwdDQMOLcYDAYDAaDwWAwGAwGg8FgMBgMBoPBYDAYDA0NI84NBoPBYDAYDAaDwWAwGAwGg8FgMBgMBoPB0NAw4txgMBgMBoPBYDAYDAaDwWAwGAwGg8FgMBgMDQ0jzg0Gg8FgMBgMBoPBYDAYDAaDwWAwGAwGg8HQ0DDi3GAwGAwGg8FgMBgMBoPBYDAYDAaDwWAwGAwNDSPODQaDwWAwGAwGg8FgMBgMBoPBYDAYDAaDwdDQMOLcYDAYDAaDwWAwGAwGg8FgMBgMBoPBYDAYDA0NI84NBoPBYDAYDAaDwWAwGAwGg8FgMBgMBoPBEDQy/h9XbKr47TQO7AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_clips = 20\n", + "rho_values = [10, 20, 152, 220, 75]# Add labels for different rho values (5 rho values, 40 clips each)\n", + "rho_labels = []\n", + "for rho in rho_values:\n", + " rho_labels.extend([f\"ρ={rho}\"] * num_clips) # 40 clips per rho value\n", + "\n", + "lorenz = Lorenz63(rho_values=rho_values, num_clips=num_clips,period_length=20,random_seed=2023)\n", + "# fig, ax = plt.subplots()\n", + "lorenz.visualize_data(time_range=None)" + ] + }, + { + "cell_type": "markdown", + "id": "7d6521ce", + "metadata": {}, + "source": [ + "A key step in this dataset is to preprocess by whitening the data and subsampling it to take larger timesteps. This ensures that the dynamics can be aptly captured by the DMD. Here we'll subsample by a factor of 10 (i.e. only skipping 10 steps to fit our models to). This allows the system to capture longer timescales (more relevant to comparison) with greater computational efficiency. We could similarly take 10 times as many delays, but that would make fitting slower. " + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "90e66ece", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((2000, 3), 100)" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "subsample = 10\n", + "\n", + "data = lorenz.data \n", + "ss = StandardScaler()\n", + "data = [ss.fit_transform(i) for i in data]\n", + "data = [i[::subsample] for i in data]\n", + "data[0].shape, len(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "0eb18f19", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 100/100 [00:03<00:00, 30.85it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 4950/4950 [00:03<00:00, 1617.36it/s]\n" + ] + } + ], + "source": [ + "from DSA import DSA\n", + "# #compute silhouette score\n", + "from sklearn.metrics import silhouette_score\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "dsa = DSA(data,verbose=True, n_delays=70,rank=6,score_method='wasserstein')\n", + "sims = dsa.fit_score()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "e7a0aecd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/sklearn/manifold/_mds.py:677: FutureWarning: The default value of `n_init` will change from 4 to 1 in 1.9.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 [1. 1. 1. 1. 1.]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "from sklearn.manifold import MDS\n", + "from sklearn.metrics import silhouette_score, accuracy_score\n", + "from sklearn.svm import LinearSVC\n", + "from sklearn.model_selection import StratifiedKFold\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(6,3)) # Add a third axis for decoding accuracy\n", + "\n", + "# Plot heatmap\n", + "sns.heatmap(sims, cmap='gist_gray', ax=axes[0], cbar_kws={'label': 'DSA Wasserstein'})\n", + "rho_values = [10, 20, 152, 220, 75]\n", + "\n", + "lorenz_names = [rf\"$\\rho=$ {rho_values[i]}\" for i in range(len(rho_values))]\n", + "tick_positions = [num_clips/2 + i*num_clips for i in range(5)]\n", + "axes[0].set_xticks(tick_positions)\n", + "axes[0].set_yticks(tick_positions)\n", + "axes[0].set_xticklabels(lorenz_names, rotation=45, ha='right')\n", + "axes[0].set_yticklabels(lorenz_names, rotation=0)\n", + "\n", + "# Perform MDS for visualization\n", + "vis = MDS(n_components=2, dissimilarity='precomputed', random_state=42)\n", + "embedding = vis.fit_transform(sims)\n", + "\n", + "# Create DataFrame for scatter plot\n", + "df = pd.DataFrame()\n", + "df[\"x\"] = embedding[:, 0]\n", + "df[\"y\"] = embedding[:, 1]\n", + "df[\"System\"] = rho_labels\n", + "silhouette_score_ = round(silhouette_score(sims, rho_labels),3)\n", + "\n", + "# Plot scatter with improved styling\n", + "sns.scatterplot(data=df, x=\"x\", y=\"y\", hue=\"System\", ax=axes[1], s=60, alpha=0.8)\n", + "axes[1].set_xlabel('MDS Component 1')\n", + "axes[1].set_ylabel('MDS Component 2')\n", + "axes[1].set_xticks([round(min(df['x']),2), round(max(df['x']),2)])\n", + "axes[1].set_yticks([round(min(df['y']),2), round(max(df['y']),2)])\n", + "handles, labels = axes[1].get_legend_handles_labels()\n", + "# axes[1].legend(handles, labels, bbox_to_anchor=(1.05, 1), loc='upper left', frameon=True, fontsize=8, markerscale=0.7)\n", + "axes[1].legend(handles, labels, frameon=True, fontsize=8, markerscale=0.7)\n", + "\n", + "def compute_decoding_accuracy(sims, rho_labels, n_splits=5, random_state=42):\n", + " \"\"\"\n", + " Computes the decoding accuracy using a linear classifier with stratified k-fold cross-validation.\n", + "\n", + " Parameters:\n", + " - sims: The similarity matrix used as features for classification.\n", + " - rho_labels: The labels corresponding to each sample in the similarity matrix.\n", + " - n_splits: Number of splits for stratified k-fold cross-validation.\n", + " - random_state: Random state for reproducibility.\n", + "\n", + " Returns:\n", + " - avg_test_acc: Average test accuracy over all folds.\n", + " - avg_per_class_acc: Average per-class accuracy over all folds.\n", + " \"\"\"\n", + " # Encode string labels to integers for classification\n", + " from sklearn.preprocessing import LabelEncoder\n", + " le = LabelEncoder()\n", + " y_encoded = le.fit_transform(rho_labels)\n", + "\n", + " # Initialize stratified k-fold cross-validation\n", + " skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_state)\n", + "\n", + " # Initialize variables to store results\n", + " test_accs = []\n", + " per_class_accs = []\n", + "\n", + " # Perform stratified k-fold cross-validation\n", + " for train_index, test_index in skf.split(sims, y_encoded):\n", + " X_train, X_test = sims[train_index], sims[test_index]\n", + " y_train, y_test = y_encoded[train_index], y_encoded[test_index]\n", + "\n", + " # Train the classifier\n", + " clf = LinearSVC(max_iter=10000,C=10)\n", + " clf.fit(X_train, y_train)\n", + "\n", + " # Predict on the test set\n", + " y_pred = clf.predict(X_test)\n", + "\n", + " # Compute test accuracy\n", + " test_acc = accuracy_score(y_test, y_pred)\n", + " test_accs.append(test_acc)\n", + "\n", + " # Compute per-class accuracy\n", + " per_class_acc = []\n", + " class_names = np.unique(y_encoded)\n", + " for i, class_label in enumerate(class_names):\n", + " idx = (y_test == i)\n", + " acc = accuracy_score(y_test[idx], y_pred[idx])\n", + " per_class_acc.append(acc)\n", + " per_class_accs.append(per_class_acc)\n", + "\n", + " # Average test accuracy and per-class accuracy over all folds\n", + " avg_test_acc = np.mean(test_accs)\n", + " avg_per_class_acc = np.mean(per_class_accs, axis=0)\n", + "\n", + " return avg_test_acc, avg_per_class_acc\n", + "\n", + "# Example usage:\n", + "avg_test_acc, avg_per_class_acc = compute_decoding_accuracy(sims, rho_labels)\n", + "\n", + "# Plot per-class decoding accuracy\n", + "print(len(avg_per_class_acc),avg_per_class_acc)\n", + "# axes[2].bar(range(len(rho_values)), avg_per_class_acc, color='gray') # Ensure 5 bars are plotted\n", + "# axes[2].set_xticks(range(len(rho_values)))\n", + "# axes[2].set_xticklabels(rho_values, rotation=45, ha='right')\n", + "# axes[2].set_ylim(0, 1.05)\n", + "# axes[2].set_xlim(-1, len(rho_values))\n", + "# axes[2].set_ylabel('Test Accuracy')\n", + "# for i, acc in enumerate(avg_per_class_acc):\n", + " # axes[2].text(i, acc+0.02, f\"{acc:.2f}\", ha='center', va='bottom', fontsize=8)\n", + "# axes[2].text(0.5, 0.95, f\"Avg Test Acc: {avg_test_acc:.2f}\", ha='center', va='top', fontsize=10, transform=axes[2].transAxes)\n", + "\n", + "plt.suptitle(f\"{dsa.n_delays[0][0]} delays, rank {dsa.rank[0][0]}, Silhouette: {silhouette_score_}, Test Acc: {avg_test_acc:.2f}\")\n", + "\n", + "plt.tight_layout()\n", + "# plt.savefig(f\"{save_path}/dsa_silhouette_clustering_{dsa.n_delays[0][0]}nd_r{dsa.rank[0][0]}.pdf\", dpi=300)\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a5ff5a5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dsa_test_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a6640d0576f9906cc4f56be283f1e30e51ef855b Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 5 Nov 2025 14:36:00 -0500 Subject: [PATCH 37/51] replicate dsa paper fig 3 --- examples/dsa_fig3_tutorial.ipynb | 431 ++++++++----------------------- 1 file changed, 109 insertions(+), 322 deletions(-) diff --git a/examples/dsa_fig3_tutorial.ipynb b/examples/dsa_fig3_tutorial.ipynb index dab6216..3489faa 100644 --- a/examples/dsa_fig3_tutorial.ipynb +++ b/examples/dsa_fig3_tutorial.ipynb @@ -9,20 +9,20 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# #install the packages that we haven't added in setup.py\n", - "# ! pip install matplotlib\n", - "# ! pip install scikit-learn\n", - "# ! pip install seaborn\n", - "# ! pip install pandas" + "#install the packages that we haven't added in setup.py\n", + "! pip install matplotlib\n", + "! pip install scikit-learn\n", + "! pip install seaborn\n", + "! pip install pandas" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -33,7 +33,8 @@ "import seaborn as sns\n", "import pandas as pd\n", "\n", - "rng = np.random.default_rng(2023)\n" + "rng = np.random.default_rng(2023)\n", + "np.random.seed(2023)" ] }, { @@ -52,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -185,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -199,7 +200,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -245,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -279,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -305,6 +306,38 @@ "models = [x for mtype in models for x in mtype] #list the models by type (bistable,...,line,...,point,...)" ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2),\n", + " (200, 1000, 2)]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "models = [i[:,::10] for i in models]\n", + "[i.shape for i in models]" + ] + }, { "cell_type": "code", "execution_count": 7, @@ -312,173 +345,39 @@ "scrolled": true }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 12/12 [00:02<00:00, 4.23it/s]\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n" + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 66/66 [00:00<00:00, 646.60it/s]\n" ] } ], "source": [ "#dmd parameters, all others are default for now.\n", - "n_delays = 50\n", - "delay_interval = 20\n", - "rank = 30\n", + "n_delays = 20\n", + "delay_interval = 1\n", + "rank = 15\n", "device = 'cuda' #change this if you have a GPU! Otherwise it will be slow\n", "\n", "#playing around with optimization here, we don't necessarily need the metric to converge to \n", "#get good clustering!\n", - "dsa = DSA(models,n_delays=n_delays,rank=rank,delay_interval=delay_interval,verbose=True,device=device,iters=1000,lr=1e-2)\n", + "# dsa = DSA(models,n_delays=n_delays,rank=rank,delay_interval=delay_interval,verbose=True,device=device,iters=1000,lr=1e-2)\n", + "dsa = DSA(models,n_delays=n_delays,rank=rank,delay_interval=delay_interval,verbose=True,device=device,score_method='wasserstein')\n", "similarities = dsa.fit_score()" ] }, @@ -497,7 +396,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -506,7 +405,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -535,13 +434,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/om2/user/ostrow/anaconda/envs/dmrsa/lib/python3.9/site-packages/sklearn/manifold/_mds.py:299: FutureWarning: The default value of `normalized_stress` will change to `'auto'` in version 1.4. To suppress this warning, manually set the value of `normalized_stress`.\n", + "/Users/mitchellostrow/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/sklearn/manifold/_mds.py:677: FutureWarning: The default value of `n_init` will change from 4 to 1 in 1.9.\n", " warnings.warn(\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -581,7 +480,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -591,11 +490,11 @@ "nmodels = 5 #3*nmodels total, turn this up as high as you want\n", "sigma = 0.05\n", "\n", - "ntrials = 300\n", + "ntrials = 100\n", "dt = 0.01\n", - "downsample = 20\n", - "n_delays = 50\n", - "rank = 30\n", + "downsample = 10\n", + "n_delays = 20\n", + "rank = 15\n", "\n", "#vary params for model 1\n", "a = np.random.uniform(-5,-3,size=nmodels) \n", @@ -609,17 +508,17 @@ "a1 = np.random.uniform(-2,-5,size=nmodels)\n", "a2 = np.random.uniform(-8,-10,size=nmodels)\n", "\n", - "def fit_dmd(x,n_delays,rank,delay_interval):\n", + "def fit_dmd(x,n_delays,rank,delay_interval=1):\n", " x = flatten_x(x)\n", " #notice how we initialize the dmd separately here, rather than the DSA object itself\n", " dmd = DMD(x,n_delays=n_delays,rank=rank,delay_interval=delay_interval,device='cuda')\n", - " dmd.fit(send_to_cpu=True)\n", + " dmd.fit()\n", " return dmd.A_v.numpy()\n" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": { "scrolled": true }, @@ -628,7 +527,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "0\n", + "0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_15994/1281545838.py:28: RuntimeWarning: CUDA device 'cuda' requested but CUDA is not available. Falling back to CPU with NumPy. To use GPU acceleration, ensure PyTorch with CUDA support is installed.\n", + " dmd = DMD(x,n_delays=n_delays,rank=rank,delay_interval=delay_interval,device='cuda')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "1\n", "2\n", "3\n", @@ -644,165 +557,39 @@ " x1,cond_avg = run_model1([-.1,.1],dict(dt=dt,sigma=sigma,ntrials=ntrials,a=a[i],b=b[i],c=c[i]))\n", "\n", " #x has shape conditions x trials x time x dimension\n", - "# x1 = x1[:,:,::downsample] #here we're downsampling instead of using delay_interval in the dmd class\n", - " dmd1 = fit_dmd(x1,n_delays,rank,downsample)\n", + " x1 = x1[:,:,::downsample] #here we're downsampling instead of using delay_interval in the dmd class\n", + " dmd1 = fit_dmd(x1,n_delays,rank)\n", " models.append(dmd1)\n", " model_types.append('bistable')\n", "\n", " x2,input_optimized = run_model2(cond_avg,dict(dt=dt,sigma=sigma,ntrials=ntrials,eval1=eval1[i]))\n", - "# x2 = x2[:,:,::downsample]\n", - " dmd2 = fit_dmd(x2,n_delays,rank,downsample)\n", + " x2 = x2[:,:,::downsample]\n", + " dmd2 = fit_dmd(x2,n_delays,rank)\n", " models.append(dmd2)\n", " model_types.append('line attractor')\n", "\n", " x3,input_optimized = run_model3(cond_avg,dict(dt=dt,sigma=sigma,ntrials=ntrials,a1=a1[i],a2=a2[i]))\n", - "# x3 = x3[:,:,::downsample]\n", - " dmd3 = fit_dmd(x3,n_delays,rank,downsample)\n", + " x3 = x3[:,:,::downsample]\n", + " dmd3 = fit_dmd(x3,n_delays,rank)\n", " models.append(dmd3)\n", " model_types.append('point attractor')\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 0 0.0\n", - "0 1 0.019186703\n", - "0 2 0.009880952\n", - "0 3 0.013784869\n", - "0 4 0.018270064\n", - "0 5 0.015367441\n", - "0 6 0.010148779\n", - "0 7 0.016282732\n", - "0 8 0.01389684\n", - "0 9 0.010658683\n", - "0 10 0.016471991\n", - "0 11 0.015901202\n", - "0 12 0.011905524\n", - "0 13 0.016815798\n", - "0 14 0.014998405\n", - "1 1 0\n", - "1 2 0.021556804\n", - "1 3 0.016072713\n", - "1 4 0.0036702405\n", - "1 5 0.018898722\n", - "1 6 0.018109493\n", - "1 7 0.008407826\n", - "1 8 0.021166135\n", - "1 9 0.017249746\n", - "1 10 0.0080381455\n", - "1 11 0.019543765\n", - "1 12 0.016486458\n", - "1 13 0.0062052174\n", - "1 14 0.020368177\n", - "2 2 0\n", - "2 3 0.0107088955\n", - "2 4 0.02125326\n", - "2 5 0.015990915\n", - "2 6 0.01086911\n", - "2 7 0.021016344\n", - "2 8 0.011367685\n", - "2 9 0.009826509\n", - "2 10 0.02084833\n", - "2 11 0.014214892\n", - "2 12 0.0102015\n", - "2 13 0.020632776\n", - "2 14 0.011294038\n", - "3 3 0.0\n", - "3 4 0.016205672\n", - "3 5 0.017034156\n", - "3 6 0.008126642\n", - "3 7 0.017564781\n", - "3 8 0.010036567\n", - "3 9 0.005970233\n", - "3 10 0.016932372\n", - "3 11 0.013024486\n", - "3 12 0.004991472\n", - "3 13 0.016377633\n", - "3 14 0.0110647725\n", - "4 4 0\n", - "4 5 0.018426005\n", - "4 6 0.017557994\n", - "4 7 0.0063851164\n", - "4 8 0.020856904\n", - "4 9 0.016737634\n", - "4 10 0.005545816\n", - "4 11 0.01925493\n", - "4 12 0.01626808\n", - "4 13 0.005015298\n", - "4 14 0.020049619\n", - "5 5 0\n", - "5 6 0.0163266\n", - "5 7 0.018175203\n", - "5 8 0.016562212\n", - "5 9 0.016271744\n", - "5 10 0.017757162\n", - "5 11 0.011503207\n", - "5 12 0.016194634\n", - "5 13 0.017730288\n", - "5 14 0.013685055\n", - "6 6 0\n", - "6 7 0.016080128\n", - "6 8 0.0069996584\n", - "6 9 0.0036702405\n", - "6 10 0.015919933\n", - "6 11 0.012714164\n", - "6 12 0.00534886\n", - "6 13 0.016106054\n", - "6 14 0.011915534\n", - "7 7 0\n", - "7 8 0.020391578\n", - "7 9 0.016231399\n", - "7 10 0.0036539645\n", - "7 11 0.019402957\n", - "7 12 0.01626808\n", - "7 13 0.0045149554\n", - "7 14 0.020455785\n", - "8 8 0.0\n", - "8 9 0.0070758825\n", - "8 10 0.01992735\n", - "8 11 0.010426882\n", - "8 12 0.007453307\n", - "8 13 0.01998112\n", - "8 14 0.008400734\n", - "9 9 0.0\n", - "9 10 0.01592742\n", - "9 11 0.012410495\n", - "9 12 0.004931404\n", - "9 13 0.015799666\n", - "9 14 0.011166656\n", - "10 10 0\n", - "10 11 0.019130701\n", - "10 12 0.015856154\n", - "10 13 0.0041287956\n", - "10 14 0.020103062\n", - "11 11 0\n", - "11 12 0.011820107\n", - "11 13 0.018692581\n", - "11 14 0.0074372957\n", - "12 12 0.0\n", - "12 13 0.015724031\n", - "12 14 0.010517948\n", - "13 13 0\n", - "13 14 0.019738\n", - "14 14 0.0\n" - ] - } - ], + "outputs": [], "source": [ "nmodels_tot = len(models) #should be 3*nmodels\n", "\n", "sims_dmd = np.zeros((nmodels_tot,nmodels_tot))\n", "sims_mtype = np.zeros((nmodels_tot,nmodels_tot))\n", "#notice how we are initializing the similarity transform separately here\n", - "comparison_dmd = SimilarityTransformDist(device='cuda',iters=2000,lr=1e-3)\n", + "# comparison_dmd = SimilarityTransformDist(device='cuda',iters=2000,lr=1e-3)\n", + "comparison_dmd = SimilarityTransformDist(device='cpu',iters=2000,lr=1e-3,score_method='wasserstein')\n", "\n", "for i,mi in enumerate(models):\n", " for j,mj in enumerate(models):\n", @@ -813,27 +600,27 @@ " if j < i:\n", " continue\n", " sdmd = comparison_dmd.fit_score(mi,mj)\n", - " print(i,j,sdmd)\n", + " # print(i,j,sdmd)\n", "\n", " sims_dmd[i,j] = sims_dmd[j,i] = sdmd\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/om2/user/ostrow/anaconda/envs/dmrsa/lib/python3.9/site-packages/sklearn/manifold/_mds.py:299: FutureWarning: The default value of `normalized_stress` will change to `'auto'` in version 1.4. To suppress this warning, manually set the value of `normalized_stress`.\n", + "/Users/mitchellostrow/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/sklearn/manifold/_mds.py:677: FutureWarning: The default value of `n_init` will change from 4 to 1 in 1.9.\n", " warnings.warn(\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -867,7 +654,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "dsa_test_env", "language": "python", "name": "python3" }, @@ -881,7 +668,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.18" } }, "nbformat": 4, From ab51bb2fe2579d70bd70869649c0952c0f1d886b Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 5 Nov 2025 15:37:42 -0500 Subject: [PATCH 38/51] bug fixes, add tests, add docstrings to DSA and inputDSA --- DSA/dsa.py | 56 +++++- DSA/simdist.py | 6 + tests/dmd_test.py | 4 +- tests/simdist_test.py | 46 +---- tests/test_wasserstein_optimization.py | 257 +++++++++++++++++++++++++ 5 files changed, 328 insertions(+), 41 deletions(-) create mode 100644 tests/test_wasserstein_optimization.py diff --git a/DSA/dsa.py b/DSA/dsa.py index 3604559..df6ba76 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -860,6 +860,34 @@ def compute_similarity(i, j): class DSA(GeneralizedDSA): + """ + Dynamical Similarity Analysis (DSA) for Data-driven dynamics comparison + + Attributes: + X : np.array or torch.tensor or list of np.arrays or torch.tensors + First data matrix/matrices. + Y : None or np.array or torch.tensor or list of np.arrays or torch.tensors + Second data matrix/matrices. If None, X is compared to itself pairwise. + dmd_class : class + DMD class to use model fitting. Default is the local Havok, + but pykoopman objects can be passed in, for example + device : str + Device to use for computation ('cpu' or 'cuda'). Default is 'cpu'. + verbose : bool + Whether to print verbose output during computation. Default is False. + n_jobs : int + Number of parallel jobs to use. Default is 1 (sequential). + **dmd_kwargs (dictionary of dmd arguments--for HAVOK, see DMDConfig, repeated here: + DMD Attributes: + n_delays (int): Number of time delays to use in the Hankel matrix construction. + Default is 1 (no delays). + delay_interval (int): Interval between delays in the Hankel matrix. + Default is 1 (consecutive time steps). + rank (int): Rank for SVD truncation. If None, no truncation is performed. + Default is None. + lamb (float): Regularization parameter for ridge regression. + Default is 0 (no regularization). + """ def __init__( self, X, @@ -874,7 +902,6 @@ def __init__( lr: float = 5e-3, **dmd_kwargs, ): - # TODO: add readme simdist_config = { "score_method": score_method, "iters": iters, @@ -899,6 +926,33 @@ def __init__( class InputDSA(GeneralizedDSA): + """ + Dynamical Similarity Analysis (DSA) for controlled systems + + Attributes: + X (required) : np.array or torch.tensor or list of np.arrays or torch.tensors + First data matrix/matrices. + X_control (required) : np.array or torch.tensor or list of np.arrays or torch.tensors + Control data matrix/matrices for X. + Y : None or np.array or torch.tensor or list of np.arrays or torch.tensors + Second data matrix/matrices. If None, X is compared to itself pairwise. + Y_control : None or np.array or torch.tensor or list of np.arrays or torch.tensors + Control data matrix/matrices for Y. Must be the same shape as Y. + dmd_class : class + DMD class to use for decomposition. Default is SubspaceDMDc. + dmd_config: class or dictionary containing parameters of the dmd model + simdist_config: class or dictionary containing parameters used for comparison. + Depending on what is in here (e.g. compare = "state" versus "joint" or "input"), + the type of comparison will be direclty inferred -- "state" yields standard DSA metric, + "input" or "joint" yields the controlalbility metric. + device : str + Device to use for computation ('cpu' or 'cuda'). Default is 'cpu'. + verbose : bool + Whether to print verbose output during computation. Default is False. + n_jobs : int + Number of parallel jobs to use. Default is 1 (sequential). + + """ def __init__( self, X, diff --git a/DSA/simdist.py b/DSA/simdist.py index d027d0b..699160b 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -481,8 +481,14 @@ def fit_score( if isinstance(A, np.ndarray): A = torch.from_numpy(A) + # Only convert to float if not complex (preserve complex dtypes for eigenvalues) + if not torch.is_complex(A): + A = A.float() if isinstance(B, np.ndarray): B = torch.from_numpy(B) + # Only convert to float if not complex (preserve complex dtypes for eigenvalues) + if not torch.is_complex(B): + B = B.float() # Check if we have 2D matrices or 1D eigenvalues is_matrix = A.ndim == 2 and B.ndim == 2 diff --git a/tests/dmd_test.py b/tests/dmd_test.py index d1c28b5..a08240a 100644 --- a/tests/dmd_test.py +++ b/tests/dmd_test.py @@ -70,7 +70,7 @@ def test_dmd_2d(seed, c, t, tau): data[i] = A @ data[i - 1] dmd = DMD(data, 1) dmd.fit() - assert np.linalg.norm(dmd.A_v.flatten() - A.flatten()) < 1e-1 + assert np.linalg.norm(dmd.A_havok_dmd.flatten() - A.flatten()) < 1e-1 @pytest.mark.parametrize("n", [500]) @@ -102,6 +102,6 @@ def test_to_cpu(seed, n, t, c): X = rng.random((n, t, c)) device = "cuda" if torch.cuda.is_available() else "cpu" dmd = DMD(X, 1, device=device) - dmd.fit(send_to_cpu=True) + dmd.fit() assert dmd.A_v.device.type == "cpu" assert dmd.H.device.type == "cpu" diff --git a/tests/simdist_test.py b/tests/simdist_test.py index 84d4234..5375a64 100644 --- a/tests/simdist_test.py +++ b/tests/simdist_test.py @@ -3,44 +3,29 @@ from DSA.simdist import SimilarityTransformDist, pad_zeros from scipy.stats import special_ortho_group, ortho_group import torch -from netrep.utils import whiten TOL = 1e-3 SIMTOL = 2e-2 @pytest.mark.parametrize("device", ["cpu"]) -@pytest.mark.parametrize("preserve_var", [True, False]) @pytest.mark.parametrize("dtype", ["numpy"]) @pytest.mark.parametrize("score_method", ["angular", "euclidean"]) @pytest.mark.parametrize("n", [10, 50, 100]) -@pytest.mark.parametrize("group", ["GL(n)", "O(n)", "SO(n)"]) @pytest.mark.parametrize("seed", [5]) -def test_simdist_convergent(seed, n, score_method, dtype, preserve_var, group, device): +def test_simdist_convergent(seed, n, score_method, dtype, device): rng = np.random.default_rng(seed) X = rng.random(size=(n, n)) - if group == "SO(n)": - Q = special_ortho_group(seed=rng, dim=n).rvs() - Y = Q @ X @ Q.T - iters = 5000 - elif group == "O(n)": + + Q = ortho_group(seed=rng, dim=n).rvs() + while np.linalg.det(Q) > 0: Q = ortho_group(seed=rng, dim=n).rvs() - while np.linalg.det(Q) > 0: - Q = ortho_group(seed=rng, dim=n).rvs() - Y = Q @ X @ Q.T - iters = 5000 - elif group == "GL(n)": - # draw random invertible matrix - Q = rng.random(size=(n, n)) - Q /= np.linalg.norm(Q, axis=0) - Y = Q @ X @ np.linalg.inv(Q) - iters = 80_000 - - X, _ = whiten(X, 0, preserve_variance=preserve_var) - Y, _ = whiten(Y, 0, preserve_variance=preserve_var) + Y = Q @ X @ Q.T + iters = 10000 + # excessive but we just want to see that it converges sim = SimilarityTransformDist( - lr=1e-2, iters=iters, score_method=score_method, device=device, group=group + lr=5e-3, iters=iters, score_method=score_method, device=device ) if dtype == "torch": X = torch.tensor(X).float() @@ -77,21 +62,6 @@ def test_transposed_q_same(seed, n, score_method, dtype, device): assert np.abs(score1 - score2) < SIMTOL -@pytest.mark.parametrize("n2", [10]) -@pytest.mark.parametrize("n1", [50]) -@pytest.mark.parametrize("seed", [5]) -def test_zero_pad(seed, n1, n2): - rng = np.random.default_rng(seed) - X = rng.random(size=(n1, n1)) - Y = rng.random(size=(n2, n2)) - m = max(n1, n2) - sim = SimilarityTransformDist(iters=10) # don't care about fitting - sim.fit_score(X, Y, zero_pad=True) - assert sim.C_star.shape == (m, m) - assert pad_zeros(X, Y, "cpu")[0].shape == (m, m) - assert pad_zeros(X, Y, "cpu")[1].shape == (m, m) - - @pytest.mark.parametrize("n", [10]) @pytest.mark.parametrize("seed", [5]) def test_ortho_c(seed, n): diff --git a/tests/test_wasserstein_optimization.py b/tests/test_wasserstein_optimization.py new file mode 100644 index 0000000..2e35ae6 --- /dev/null +++ b/tests/test_wasserstein_optimization.py @@ -0,0 +1,257 @@ +""" +Test to verify Wasserstein distance optimization works correctly. +Tests both SimilarityTransformDist and DSA classes to ensure: +1. Pre-computed eigenvalues produce identical results to matrices +2. Identical systems produce near-zero scores +3. Both torch and numpy complex arrays work correctly +4. DSA correctly caches eigenvalues for efficiency +""" +import pytest +import numpy as np +import torch +from DSA.simdist import SimilarityTransformDist +from DSA import DSA +from DSA.dmd import DMD + + +@pytest.fixture +def random_matrices(): + """Generate random test matrices.""" + np.random.seed(42) + torch.manual_seed(42) + A = torch.randn(5, 5) + B = torch.randn(5, 5) + return A, B + + +@pytest.fixture +def random_data(): + """Generate random time series data for DSA tests.""" + np.random.seed(42) + n_samples = 100 + n_features = 10 + X1 = np.random.randn(n_features, n_samples) + X2 = np.random.randn(n_features, n_samples) + return X1, X2 + + +def test_simdist_wasserstein_with_matrices(random_matrices): + """Test SimilarityTransformDist with full matrices.""" + A, B = random_matrices + + simdist = SimilarityTransformDist( + iters=100, + score_method="wasserstein", + lr=0.01, + device="cpu", + verbose=False + ) + + # Test with matrices + score_from_matrices = simdist.fit_score(A, B) + assert score_from_matrices > 0, "Score should be positive for different matrices" + + # Test with identical matrices (should be close to 0) + score_identical = simdist.fit_score(A, A) + assert score_identical < 1e-3, f"Identical matrices should have near-zero score, got {score_identical}" + + +def test_simdist_wasserstein_with_precomputed_eigenvalues(random_matrices): + """Test SimilarityTransformDist with pre-computed eigenvalues produces same results as matrices.""" + A, B = random_matrices + + # Get score from matrices + simdist1 = SimilarityTransformDist( + iters=100, + score_method="wasserstein", + lr=0.01, + device="cpu", + verbose=False + ) + score_from_matrices = simdist1.fit_score(A, B) + + # Get eigenvalues + eigenvalues_A = torch.linalg.eig(A).eigenvalues + eigenvalues_B = torch.linalg.eig(B).eigenvalues + + assert eigenvalues_A.ndim == 1, "Eigenvalues should be 1D" + assert torch.is_complex(eigenvalues_A), "Eigenvalues should be complex" + + # Get score from pre-computed eigenvalues + simdist2 = SimilarityTransformDist( + iters=100, + score_method="wasserstein", + lr=0.01, + device="cpu", + verbose=False + ) + score_from_eigenvalues = simdist2.fit_score(eigenvalues_A, eigenvalues_B) + + # Scores should be identical (or very close) + diff = abs(score_from_matrices - score_from_eigenvalues) + assert diff < 1e-3, f"Scores should match, got difference of {diff}" + + # Test with identical eigenvalues + score_identical_eig = simdist2.fit_score(eigenvalues_A, eigenvalues_A) + assert score_identical_eig < 1e-3, f"Identical eigenvalues should have near-zero score, got {score_identical_eig}" + + +def test_simdist_wasserstein_with_numpy_arrays(random_matrices): + """Test that numpy complex arrays are handled correctly.""" + A, B = random_matrices + + # Convert to numpy + A_np = A.numpy() + B_np = B.numpy() + eigenvalues_A_np = np.linalg.eig(A_np)[0] # numpy returns (eigenvalues, eigenvectors) + eigenvalues_B_np = np.linalg.eig(B_np)[0] + + assert eigenvalues_A_np.ndim == 1, "Numpy eigenvalues should be 1D" + assert np.iscomplexobj(eigenvalues_A_np), "Numpy eigenvalues should be complex" + + simdist = SimilarityTransformDist( + iters=100, + score_method="wasserstein", + lr=0.01, + device="cpu", + verbose=False + ) + + # Should work without errors + score_from_numpy_eig = simdist.fit_score(eigenvalues_A_np, eigenvalues_B_np) + assert score_from_numpy_eig > 0, "Score should be positive" + + +def test_dsa_wasserstein_caching(random_data): + """Test that DSA correctly caches eigenvalues for efficiency.""" + X1, X2 = random_data + + dsa = DSA( + X=[X1, X2], + Y=None, + dmd_class=DMD, + device="cpu", + verbose=False, + n_jobs=1, + score_method="wasserstein", + iters=100, + lr=0.01, + n_delays=1, + rank=5, + ) + + scores = dsa.fit_score() + + # Check scores shape and properties + assert scores.shape == (2, 2), f"Expected shape (2, 2), got {scores.shape}" + + # Check that diagonal is near-zero (comparing same systems) + diagonal_scores = np.array([scores[i, i] for i in range(len(scores))]) + assert np.all(diagonal_scores < 1e-3), f"Diagonal should be near-zero, got {diagonal_scores}" + + # Check that matrix is symmetric + symmetry_diff = np.abs(scores - scores.T).max() + assert symmetry_diff < 1e-6, f"Score matrix should be symmetric, got max diff {symmetry_diff}" + + # Verify the optimization actually cached the eigenvalues + assert hasattr(dsa, 'cached_compare_objects'), "DSA should have cached_compare_objects" + assert len(dsa.cached_compare_objects) == 2, "Should have 2 groups of cached objects" + assert len(dsa.cached_compare_objects[0]) == 2, "First group should have 2 objects" + assert len(dsa.cached_compare_objects[1]) == 2, "Second group should have 2 objects" + + # Check that cached objects are complex eigenvalues + first_obj = dsa.cached_compare_objects[0][0] + assert first_obj.ndim == 1, "Cached objects should be 1D" + assert torch.is_complex(first_obj), "Cached objects should be complex" + + +def test_dsa_wasserstein_vs_angular_difference(random_data): + """Test that Wasserstein and angular methods produce different results (as expected).""" + X1, X2 = random_data + + # DSA with Wasserstein + dsa_wass = DSA( + X=[X1, X2], + Y=None, + dmd_class=DMD, + device="cpu", + verbose=False, + n_jobs=1, + score_method="wasserstein", + iters=100, + lr=0.01, + n_delays=1, + rank=5, + ) + scores_wass = dsa_wass.fit_score() + + # DSA with angular + dsa_ang = DSA( + X=[X1, X2], + Y=None, + dmd_class=DMD, + device="cpu", + verbose=False, + n_jobs=1, + score_method="angular", + iters=100, + lr=0.01, + n_delays=1, + rank=5, + ) + scores_ang = dsa_ang.fit_score() + + # Both should have same shape + assert scores_wass.shape == scores_ang.shape + + # Both should have near-zero diagonals + assert np.all(np.abs(np.diag(scores_wass)) < 1e-3) + assert np.all(np.abs(np.diag(scores_ang)) < 1e-3) + + # Off-diagonal elements should be different (different metrics) + # But both should be positive and non-zero + assert scores_wass[0, 1] > 0 + assert scores_ang[0, 1] > 0 + + +if __name__ == "__main__": + # Allow running as a script for quick testing + print("=" * 60) + print("Testing Wasserstein Distance Optimization") + print("=" * 60) + + # Create fixtures manually + np.random.seed(42) + torch.manual_seed(42) + A = torch.randn(5, 5) + B = torch.randn(5, 5) + random_matrices = (A, B) + + np.random.seed(42) + X1 = np.random.randn(10, 100) + X2 = np.random.randn(10, 100) + random_data = (X1, X2) + + print("\n1. Testing SimilarityTransformDist with matrices...") + test_simdist_wasserstein_with_matrices(random_matrices) + print("✓ Passed") + + print("\n2. Testing SimilarityTransformDist with pre-computed eigenvalues...") + test_simdist_wasserstein_with_precomputed_eigenvalues(random_matrices) + print("✓ Passed") + + print("\n3. Testing with numpy arrays...") + test_simdist_wasserstein_with_numpy_arrays(random_matrices) + print("✓ Passed") + + print("\n4. Testing DSA with Wasserstein distance caching...") + test_dsa_wasserstein_caching(random_data) + print("✓ Passed") + + print("\n5. Testing DSA Wasserstein vs Angular...") + test_dsa_wasserstein_vs_angular_difference(random_data) + print("✓ Passed") + + print("\n" + "=" * 60) + print("All tests passed! ✓") + print("=" * 60) From a13180ff01c47d93f8bb549b5d79c43da280f9da Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 5 Nov 2025 17:01:03 -0500 Subject: [PATCH 39/51] bug fixes and addition of a new tutorial demonstrating all the different ways to use dsa --- DSA/simdist.py | 5 + DSA/simdist_controllability.py | 2 +- DSA/sweeps.py | 11 +- examples/fig2_real.ipynb | 5211 ------------------------ examples/how_to_use_dsa_tutorial.ipynb | 1144 ++++++ 5 files changed, 1158 insertions(+), 5215 deletions(-) delete mode 100644 examples/fig2_real.ipynb create mode 100644 examples/how_to_use_dsa_tutorial.ipynb diff --git a/DSA/simdist.py b/DSA/simdist.py index 699160b..36044a4 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -7,6 +7,7 @@ from scipy.stats import wasserstein_distance import ot # optimal transport for multidimensional l2 wasserstein import warnings +from typing import Final try: from .dmd import DMD @@ -142,6 +143,7 @@ def __init__( verbose=False, eps=1e-5, rescale_wasserstein=False, + compare: Final = 'state' ): """ Parameters @@ -164,6 +166,8 @@ def __init__( eps : float early stopping threshold + + compare : str (final). dummy variable for inference of types / config """ self.iters = iters @@ -177,6 +181,7 @@ def __init__( self.eps = eps self.rescale_wasserstein = rescale_wasserstein self.wasserstein_compare = 'eig' # for backwards compatibility + self.compare = compare def fit( self, diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py index cf1f1da..e700882 100644 --- a/DSA/simdist_controllability.py +++ b/DSA/simdist_controllability.py @@ -21,7 +21,7 @@ def __init__( score_method: Literal["euclidean", "angular"] = "euclidean", compare: Literal["joint", "control", "state"] = "joint", align_inputs: bool = False, - return_distance_components: bool = True, + return_distance_components: bool = False, ): f""" Parameters diff --git a/DSA/sweeps.py b/DSA/sweeps.py index e23c7ea..510d88d 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -85,15 +85,20 @@ def sweep_ranks_delays( continue dmd = DMD(train_data, n_delays=nd, rank=r, **dmd_kwargs) dmd.fit() - pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict( + + # pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict( + # test_data, reseed=reseed, full_return=True + # ) + pred, H_test_pred, H_test_true= dmd.predict( test_data, reseed=reseed, full_return=True ) if error_space == "H": pred = H_test_pred test_data_err = H_test_true elif error_space == "V": - pred = V_test_pred - test_data_err = V_test_true + raise ValueError("V space not implemented ") + # pred = V_test_pred + # test_data_err = V_test_true elif error_space == "X": pred = pred test_data_err = test_data diff --git a/examples/fig2_real.ipynb b/examples/fig2_real.ipynb deleted file mode 100644 index ca13ae3..0000000 --- a/examples/fig2_real.ipynb +++ /dev/null @@ -1,5211 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "52fcf42e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Shared parameters:\n", - " System: n=10, m=1, p_out=10, N=10000\n", - " Dynamics: rho1=0.92, rho2=0.82, g1=1, g2=1.5\n", - " Noise: obs_noise=0.0001, process_noise=0.0\n", - " Nonlinearity: nonlinear_eps=0.01\n", - " Model: n_delays=150, rank=10, pf=150\n", - " Evaluation: n_iters=10\n" - ] - } - ], - "source": [ - "\"\"\"\n", - "Figure 2 InputDSA Data Analysis \n", - "\"\"\"\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "# SHARED PARAMETERS - used consistently across all analyses below\n", - "# Only change these values to modify the entire notebook behavior\n", - "n = 10 # latent state dim\n", - "n_large = 50\n", - "m = 1 # input dim \n", - "p_out = 10 # observed dim (partial observation) - gets overridden in some cells\n", - "p_out_small = 2\n", - "N = 10000 # sequence length\n", - "N_small = 1000\n", - "n_Us = 4\n", - "obs_noise = 0.0001\n", - "process_noise = 0.0#1\n", - "nonlinear_eps = 0.01\n", - "input_alpha = 0.001\n", - "g1 = 1\n", - "g2 = 1.5\n", - "rho1 = 0.92\n", - "rho2 = 0.82\n", - "seed1 = 11\n", - "seed2 = 12\n", - "n_delays = 150\n", - "rank = 10\n", - "pf = 150\n", - "n_iters = 10\n", - "backend = 'n4sid'\n", - "\n", - "print(f\"Shared parameters:\")\n", - "print(f\" System: n={n}, m={m}, p_out={p_out}, N={N}\")\n", - "print(f\" Dynamics: rho1={rho1}, rho2={rho2}, g1={g1}, g2={g2}\")\n", - "print(f\" Noise: obs_noise={obs_noise}, process_noise={process_noise}\")\n", - "print(f\" Nonlinearity: nonlinear_eps={nonlinear_eps}\")\n", - "print(f\" Model: n_delays={n_delays}, rank={rank}, pf={pf}\")\n", - "print(f\" Evaluation: n_iters={n_iters}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a08ecb20", - "metadata": {}, - "outputs": [], - "source": [ - "# in this analysis, we are goign to look at how to appropriately compare partially observed systems\n", - "# we will look at the following systems\n", - "\n", - "# 4 systems, made up fo 2 pairings (1,2) (3,4) same intrinsic dynamics, (1,3) (2,4) same read in dynamics\n", - "# we will look at the behavior in the fully observed setting of DSA and AgentDSA, and then in the\n", - "#partially observed setting of DMDc versus subspace DMDc\n", - "#we'll looking at clustering capability across many instantiatons of the data, \n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4b891d5e", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "# Updated to use DSA package imports\n", - "import sys\n", - "sys.path.insert(0, '..') # Add parent directory to path to import DSA\n", - "\n", - "plt.rcParams['pdf.fonttype'] = 42\n", - "plt.rcParams['ps.fonttype'] = 42\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f3cdd518", - "metadata": {}, - "outputs": [], - "source": [ - "from DSA import InputDSA\n", - "from DSA import SimilarityTransformDist as SimDist\n", - "from DSA import ControllabilitySimilarityTransformDist as ControlSimDist\n", - "from tqdm import tqdm\n", - "\n", - "def compare_systems_with_InputDSA(Ys, Us, n_delays=150, rank=10, backend='n4sid'):\n", - " \"\"\"\n", - " Compare controlled systems using InputDSA from DSA package.\n", - " Uses the new update_compare_method() to avoid refitting DMDs multiple times.\n", - " \n", - " Parameters:\n", - " - Ys: list of output data arrays (p_out, N)\n", - " - Us: list of control input arrays (m, N)\n", - " - n_delays: number of delays for DMD\n", - " - rank: rank for DMD\n", - " - backend: 'n4sid' or 'custom' for SubspaceDMDc\n", - " \n", - " Returns:\n", - " - sims_full: joint similarity scores\n", - " - sims_control_joint: control scores from joint optimization\n", - " - sims_state_joint: state scores from joint optimization\n", - " - sims_control_separate: control scores from separate optimization\n", - " - sims_state_separate: state scores from separate optimization\n", - " \"\"\"\n", - " # Transpose data for InputDSA (expects time_first=True by default)\n", - " Ys_T = [Y.T for Y in Ys]\n", - " Us_T = [U.T for U in Us]\n", - " \n", - " # Configure DMD\n", - " # dmd_config = SubspaceDMDcConfig(\n", - " # n_delays=n_delays,\n", - " # rank=rank,\n", - " # backend=backend\n", - " # )\n", - " dmd_config = dict(\n", - " n_delays=n_delays,\n", - " rank=rank,\n", - " backend=backend\n", - " )\n", - " \n", - " # Create InputDSA with joint comparison\n", - " # This will fit the DMDs once and return joint comparison results\n", - " inputDSA = InputDSA(\n", - " X=Ys_T,\n", - " X_control=Us_T,\n", - " dmd_config=dmd_config,\n", - " compare='joint',\n", - " return_distance_components=True\n", - " )\n", - " \n", - " # Fit DMDs and get joint comparison results\n", - " sims_full, sims_state_joint, sims_control_joint = inputDSA.fit_score()\n", - " \n", - " # Update comparison method to 'state' without refitting DMDs\n", - " inputDSA.update_compare_method(compare='state')\n", - " sims_state_separate = inputDSA.score()\n", - " \n", - " # Update comparison method to 'control' without refitting DMDs\n", - " inputDSA.update_compare_method(compare='control')\n", - " sims_control_separate = inputDSA.score()\n", - " \n", - " return sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate\n", - "\n", - "\n", - "#strict comparison metrics, for when we fit and compare separately\n", - "def compare_A(A1,A2):\n", - " simdist = SimDist(iters=1000,score_method='wasserstein',lr=1e-3,verbose=True)\n", - " return simdist.fit_score(A1,A2)\n", - "\n", - "def compare_A_full(As):\n", - " sims = np.zeros((len(As),len(As)))\n", - " for i in range(len(As)):\n", - " for j in range(i+1,len(As)):\n", - " sims[i,j] = compare_A(As[i],As[j])\n", - " sims[j,i] = sims[i,j]\n", - " return sims\n", - "\n", - "def compare_B(B1,B2):\n", - " csimdist = ControlSimDist(score_method='euclidean',compare='control')\n", - " sim = csimdist.fit_score(None, None, B1, B2)\n", - " return sim\n", - "\n", - "def compare_systems_full(As,Bs):\n", - " csimdist = ControlSimDist(score_method='euclidean',compare='joint',return_distance_components=True)\n", - " sims_full = np.zeros((len(As),len(As)))\n", - " sims_control_joint = np.zeros((len(As),len(As)))\n", - " sims_state_joint = np.zeros((len(As),len(As)))\n", - " sims_control_separate = np.zeros((len(As),len(As)))\n", - " sims_state_separate = np.zeros((len(As),len(As)))\n", - " for i in tqdm(range(len(As))):\n", - " for j in range(i+1,len(As)):\n", - " all_sims = csimdist.fit_score(As[i],As[j],Bs[i],Bs[j])\n", - " sims_full[i,j] = sims_full[j,i] = all_sims[0]\n", - " sims_state_joint[i,j] = sims_state_joint[j,i] = all_sims[1]\n", - " sims_control_joint[i,j] = sims_control_joint[j,i] = all_sims[2]\n", - " \n", - " for i in tqdm(range(len(As))):\n", - " for j in range(i+1,len(As)):\n", - " sims_state_separate[i,j] = compare_A(As[i],As[j])\n", - " sims_control_separate[i,j] = compare_B(Bs[i],Bs[j])\n", - " sims_state_separate[j,i] = sims_state_separate[i,j]\n", - " sims_control_separate[j,i] = sims_control_separate[i,j]\n", - "\n", - " return sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7ba785c8", - "metadata": {}, - "outputs": [], - "source": [ - "def make_stable_A(n, rho=0.9, rng=None):\n", - " rng = np.random.default_rng(rng)\n", - " M = rng.standard_normal((n, n))\n", - " # Make it diagonally dominant-ish and scale spectral radius\n", - " A = M / np.max(np.abs(np.linalg.eigvals(M))) * rho\n", - " return A\n", - "\n", - "def simulate_system(A, B, C, U, x0=None,rng=None,obs_noise=0.0,process_noise=0.0,\n", - " nonlinear_eps=0.0,nonlinear_func= lambda x: np.tanh(x),nonlinear_eps_input=0.0):\n", - " n, m = B.shape\n", - " p_out = C.shape[0]\n", - " N = U.shape[1]\n", - " X = np.zeros((n, N+1))\n", - " C_full = np.eye(A.shape[0])\n", - " C_full[np.where(C == 1)[1],np.where(C == 1)[1]] = 0.0\n", - "\n", - " if x0 is not None:\n", - " X[:, 0] = x0\n", - " else:\n", - " X[:, 0] = np.random.default_rng(rng).standard_normal((n,))\n", - " Y = np.zeros((p_out, N))\n", - " for t in range(N):\n", - " X[:, t+1] = A @ (X[:, t]) + nonlinear_eps * C_full @ nonlinear_func(A @ X[:, t]) + \\\n", - " B @ ((1-nonlinear_eps_input) * U[:, t] + nonlinear_eps_input * nonlinear_func(U[:, t])) + \\\n", - " np.random.normal(0, process_noise, (n,))\n", - " Y[:, t] = C @ X[:, t] + np.random.normal(0, obs_noise, (p_out,))\n", - " return X[:, 1:], Y # states aligned with Y\n", - "\n", - "def smooth_input(m, N, alpha=0.9, rng=None):\n", - " rng = np.random.default_rng(rng)\n", - " w = rng.standard_normal((m, N))\n", - " U = np.zeros_like(w)\n", - " for t in range(N):\n", - " U[:, t] = alpha*(U[:, t-1] if t>0 else 0) + (1-alpha)*w[:, t]\n", - " return U" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "87d14512", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def simulate_As_Bs(latent_dim, input_dim, observed_dim, seq_length,rho1=rho1,\n", - " rho2=rho2, g1=g1,g2=g2, seed1=seed1, seed2=seed2, input_alpha=input_alpha,same_inp=False,n_Us=n_Us,\n", - " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x)):\n", - "\n", - " A1_true = make_stable_A(latent_dim, rho=rho1, rng=seed1)\n", - " cov_matrix_B1 = np.random.default_rng(seed1).standard_normal((latent_dim, latent_dim))\n", - " cov_matrix_B1 = cov_matrix_B1 @ cov_matrix_B1.T # Make it symmetric positive definite\n", - " B1_true = np.random.default_rng(seed1).multivariate_normal(np.zeros(latent_dim), cov_matrix_B1, input_dim).T * g1\n", - "\n", - " A2_true = make_stable_A(latent_dim, rho=rho2, rng=seed2)\n", - " C = np.linalg.qr(np.random.default_rng(seed2).standard_normal((latent_dim, latent_dim)))[0]\n", - " cov_matrix_B2_rotated = C @ cov_matrix_B1 @ C.T \n", - " B2_true = np.random.default_rng(seed2).multivariate_normal(np.zeros(latent_dim), cov_matrix_B2_rotated, input_dim).T * g2\n", - "\n", - " # Random partial observation: select p_out of n states\n", - " idx_obs = np.sort(np.random.default_rng(seed1).choice(latent_dim, size=observed_dim, replace=False))\n", - " C_true = np.zeros((observed_dim, latent_dim))\n", - " C_true[np.arange(observed_dim), idx_obs] = 1.0\n", - " \n", - " X_trues, Ys,Us = [], [], []\n", - " i = 0\n", - " if same_inp:\n", - " U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1+i) \n", - " control_labels = []\n", - " state_labels = []\n", - " for a1, As in enumerate([A1_true, A2_true]):\n", - " for b1, Bs in enumerate([B1_true, B2_true]):\n", - " i += 1\n", - " if not same_inp:\n", - " for j in range(n_Us):\n", - " U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1+ i + j) \n", - " X_true, Y = simulate_system(As, Bs, C_true, U, x0=np.zeros(latent_dim),rng=seed1+i,\n", - " obs_noise=obs_noise,process_noise=process_noise,\n", - " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", - " X_trues.append(X_true)\n", - " Ys.append(Y)\n", - " Us.append(U)\n", - " control_labels.append(b1)\n", - " state_labels.append(a1)\n", - " else:\n", - " X_true, Y = simulate_system(As, Bs, C_true, U, x0=np.zeros(latent_dim),rng=seed1+i,\n", - " obs_noise=obs_noise,process_noise=process_noise,\n", - " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", - " X_trues.append(X_true)\n", - " Ys.append(Y)\n", - " Us.append(U)\n", - " control_labels.append(b1)\n", - " state_labels.append(a1)\n", - "\n", - " return X_trues, Ys, Us, control_labels, state_labels, (A1_true, A2_true), (B1_true, B2_true)\n", - "\n", - "\n", - "X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out,N,\n", - " input_alpha=input_alpha,g1=g1,g2=g2,n_Us=1,obs_noise=obs_noise,process_noise=process_noise,\n", - " nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x))\n", - "fig, ax = plt.subplots(1, 4, figsize=(8, 2),sharey='row')\n", - "#plot Us and Ys against time\n", - "for i in range(4):\n", - " # ax[0, i].plot(Us[i].T[:100])\n", - " ax[i].plot(Ys[i].T[:100,:],alpha=0.5)\n", - " \n", - " # Remove spines and ticks\n", - " for spine in ax[i].spines.values():\n", - " spine.set_visible(False)\n", - " ax[i].set_xticks([])\n", - " ax[i].set_yticks([])\n", - "# plt.savefig(f'{folder_path}/data_examples.pdf', format='pdf', dpi=300, bbox_inches='tight')\n", - "plt.show()\n", - "\n", - "# X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out,N_small,\n", - "# input_alpha=input_alpha,g1=g1,g2=g2, same_inp=False,n_Us=4,\n", - "# obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "728cf5a2", - "metadata": {}, - "outputs": [], - "source": [ - "from DSA import DMD,DMDc, SubspaceDMDc\n", - "from tqdm import tqdm\n", - "\n", - "def get_dmds(Ys,n_delays=1,rank=None):\n", - " As = []\n", - " for Y in Ys:\n", - " dmd = DMD(Y.T,n_delays=n_delays,rank=rank)\n", - " dmd.fit()\n", - " As.append(dmd.A_v.numpy())\n", - " return As\n", - "\n", - "def get_dmdcs(Ys,Us,n_delays=1,rank=None):\n", - " As = []\n", - " Bs = []\n", - " for Y, U in zip(Ys, Us):\n", - " dmdc = DMDc(Y.T, U.T,n_delays=n_delays,n_control_delays=n_delays,rank_input=rank,rank_output=rank)\n", - " dmdc.fit()\n", - " As.append(dmdc.A_v.numpy())\n", - " Bs.append(dmdc.B_v.numpy())\n", - " return As, Bs\n", - "\n", - "\n", - "def get_subspace_dmdcs(Ys, Us, p=20, rank=None, backend='n4sid'):\n", - " \"\"\"Fit SubspaceDMDc models using DSA package.\"\"\"\n", - " As, Bs, Cs, infos = [], [], [], []\n", - " for Y, U in zip(Ys, Us):\n", - " model = SubspaceDMDc(Y.T, U.T, n_delays=p, rank=rank, backend=backend)\n", - " model.fit()\n", - " As.append(model.A_v)#.numpy())\n", - " Bs.append(model.B_v)#.numpy())\n", - " Cs.append(model.C_v)#.numpy())\n", - " infos.append(model.info)\n", - " return As, Bs, Cs, infos\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "db4d50cb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000)]\n" - ] - } - ], - "source": [ - "X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out_small,\n", - " N_small,input_alpha=input_alpha,g1=g1,g2=g2,same_inp=False,n_Us=n_Us,\n", - " obs_noise=obs_noise,process_noise=process_noise,\n", - " nonlinear_eps=nonlinear_eps)\n", - "print([i.shape for i in Ys])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3ef1f7f5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#plot examples of the inputs and the outputs\n", - "fig, ax = plt.subplots(2,2,figsize=(4,2),sharex=True,sharey=True)\n", - "ax = ax.flatten()\n", - "for i in range(4):\n", - " ind = 4*i\n", - " ax[i].plot(Us[ind].T[:100] + 10*np.mean(np.abs(Us[ind])), color=plt.cm.Set2(1), label='Input (u)')\n", - " ax[i].plot(Ys[ind].T[:100, 0], color=plt.cm.Set2(2), label='Output (y)')\n", - " #remove all ticks and lines\n", - " ax[i].set_xticks([])\n", - " ax[i].set_yticks([])\n", - " ax[i].spines['top'].set_visible(False)\n", - " ax[i].spines['right'].set_visible(False)\n", - " ax[i].spines['bottom'].set_visible(False)\n", - " ax[i].spines['left'].set_visible(False)\n", - " \n", - "ax[0].text(1, 0.4, 'Input', transform=ax[0].transAxes, color=plt.cm.Set2(1), va='top')\n", - "ax[0].text(1, 0.2, 'Output', transform=ax[0].transAxes, color=plt.cm.Set2(2), va='top')\n", - "plt.tight_layout()\n", - "# plt.savefig(f'{folder_path}/input_output_examples.pdf', format='pdf', dpi=300, bbox_inches='tight')\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "eef05f5d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[legend.py:1217 - _parse_legend_args() ] No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Use SubspaceDMDc from DSA package to analyze singular values\n", - "\n", - "\n", - "fig, ax = plt.subplots(2,2,figsize=(9,6),sharey=True,sharex=True)\n", - "ax = ax.flatten()\n", - " \n", - "for j, (Y, U) in enumerate(zip(Ys[::n_Us], Us[::n_Us])):\n", - " # Test different numbers of delays for subspace identification\n", - " nds_all = [10, 25, 50, 75, 100, 125, 150, 175, 200]\n", - " \n", - " for k, nds in enumerate(nds_all):\n", - " # Fit SubspaceDMDc with varying number of delays\n", - " model = SubspaceDMDc(\n", - " Y.T, # SubspaceDMDc expects (T, p_out)\n", - " U.T, # SubspaceDMDc expects (T, m)\n", - " n_delays=nds,\n", - " rank=20, # Use fixed rank for comparison\n", - " backend='n4sid'\n", - " )\n", - " model.fit()\n", - " \n", - " # Extract singular values from model info\n", - " singular_vals = model.info['singular_values_O']\n", - " \n", - " # Convert to numpy if needed\n", - " if hasattr(singular_vals, 'numpy'):\n", - " singular_vals = singular_vals.numpy()\n", - " \n", - " # Plot singular values\n", - " ax[j].plot(singular_vals, '-', label=f'{nds}', \n", - " color=plt.cm.Blues_r(k / (len(nds_all) + 4)))\n", - " ax[j].set_yscale('log')\n", - " ax[j].axvline(x=20, color='k', linestyle=':', alpha=0.5)\n", - " \n", - " ax[j].set_xlabel('Mode Number')\n", - " ax[j].set_title(f'System {j+1}')\n", - " ax[1].legend(title=\"Delays\", loc='upper right', bbox_to_anchor=(1.5, 1), \n", - " fontsize=12, title_fontsize=15)\n", - "\n", - "ax[0].set_ylabel('Singular Value')\n", - "ax[2].set_ylabel('Singular Value')\n", - "plt.tight_layout()\n", - "# plt.savefig(f'{folder_path}/singular_values_subspace_dmdc.pdf', format='pdf', dpi=300, bbox_inches='tight')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "3636fc5c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n", - "========================================\n", - "Number of valid trials: 150\n" - ] - } - ], - "source": [ - "dec = 0 #can change this to look at the efect of using the incorrect ranks\n", - "A_dmd = get_dmds(Ys,n_delays=n_delays,rank=rank- dec)\n", - "A_cs, B_cs = get_dmdcs(Ys,Us,n_delays=n_delays,rank=rank - dec)\n", - "As, Bs, Cs, infos = get_subspace_dmdcs(Ys,Us,p=pf,rank=rank-dec,backend='custom')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "5ae5efa9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "N4SID - A matrix shapes: [(10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10), (10, 10)]\n", - "N4SID - Ranks used: [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]\n", - "N4SID - Backend info: ['unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown']\n", - "\\nEigenvalue comparison (first system):\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\\nComputing similarity matrices...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:00<00:00, 548.06it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 123.68it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 608.27it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 135.77it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Custom backend silhouette score: 0.685\n", - "N4SID backend silhouette score: 0.669\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "As_n4sid, Bs_n4sid, Cs_n4sid, infos_n4sid = get_subspace_dmdcs(Ys, Us, p=pf, rank=rank-dec, backend='n4sid')\n", - "print(f\"N4SID - A matrix shapes: {[A.shape for A in As_n4sid]}\")\n", - "print(f\"N4SID - Ranks used: {[info['rank_used'] for info in infos_n4sid]}\")\n", - "print(f\"N4SID - Backend info: {[info.get('backend', 'unknown') for info in infos_n4sid]}\")\n", - "\n", - "# Quick comparison of eigenvalues (first system)\n", - "print(\"\\\\nEigenvalue comparison (first system):\")\n", - "eigs_custom = np.linalg.eigvals(As[0])\n", - "eigs_n4sid = np.linalg.eigvals(As_n4sid[0])\n", - "eigs_real = np.linalg.eigvals(A_trues[0])\n", - "\n", - "plt.figure(figsize=(8, 6))\n", - "plt.scatter(eigs_real.real, eigs_real.imag, alpha=0.7, label='True', s=100)\n", - "plt.scatter(eigs_custom.real, eigs_custom.imag, alpha=0.7, label='Custom backend', s=50)\n", - "plt.scatter(eigs_n4sid.real, eigs_n4sid.imag, alpha=0.7, label='N4SID backend', s=50, marker='x',c='k')\n", - "plt.xlabel('Real part')\n", - "plt.ylabel('Imaginary part')\n", - "plt.title('Eigenvalue comparison (first system)')\n", - "plt.legend()\n", - "plt.grid(True, alpha=0.3)\n", - "plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)\n", - "plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)\n", - "plt.show()\n", - "\n", - "# Compute distances using both backends for comparison\n", - "print(\"\\\\nComputing similarity matrices...\")\n", - "_, _, _, _, sims_state_custom = compare_systems_full(As, Bs)\n", - "_, _, _, _, sims_state_n4sid = compare_systems_full(As_n4sid, Bs_n4sid)\n", - "\n", - "from sklearn.metrics import silhouette_score\n", - "silh_custom = silhouette_score(sims_state_custom, state_labels, metric='precomputed')\n", - "silh_n4sid = silhouette_score(sims_state_n4sid, state_labels, metric='precomputed')\n", - "\n", - "\n", - "print(f\"Custom backend silhouette score: {silh_custom:.3f}\")\n", - "print(f\"N4SID backend silhouette score: {silh_n4sid:.3f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "79bb2540", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:00<00:00, 490.65it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 138.91it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 525.72it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 134.68it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 604.50it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 126.83it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 620.90it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 135.16it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABTEAAAFPCAYAAACVlIpbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAABw8ElEQVR4nO3dd3xUVfrH8e9kUkmlBEJNKIqCooiINEGpioJIEXEVENBVBOtaf4plEayA6OriKk1kNWJHaSuIC4gNQUSlGEBa6BAIaTPn9webSc6kEJKQ3ITP+/XixT333Ln33Enm4c7DPc91GWOMAAAAAAAAAMChAsp7AAAAAAAAAABQGJKYAAAAAAAAAByNJCYAAAAAAAAARyOJCQAAAAAAAMDRSGICAAAAAAAAcDSSmAAAAAAAAAAcjSQmAAAAAAAAAEcjiQkAAAAAAADA0UhiAgAAAAAAAHA0kpgAAECS9MQTT8jlcmnfvn3lPRScIbZs2SKXy6Xp06ef8munT58ul8ulLVu2+NZ17txZnTt3LrXxnars83nhhRfKbQzlZejQoUpISCjvYQAAgEqMJCYAABXUzz//rP79+ys+Pl6hoaGqW7euunXrpilTppT30CqshIQEuVwuuVwuBQQEKCYmRueff75uvfVWrVq1Kt/XZG8/YsSIfPsfffRR3za5E8RDhw71rXe5XIqIiFCjRo3Uv39/zZ07V16v97ScY35jzz7fOnXqqHv37lq6dGmpHuedd97RpEmTSnWfZeXYsWN6+umn1aJFC1WpUkXR0dHq2LGjZs6cKWNMeQ8PAADgjBFY3gMAAACnbsWKFbr88svVoEEDjRw5UnFxcfrzzz/1zTffaPLkyRo9enR5D7HCuvDCC3XfffdJklJSUvTrr78qMTFRb7zxhu655x699NJLeV4TGhqquXPn6h//+IeCg4Otvjlz5ig0NFRpaWl5XhcSEqJ//etfkqTjx49r69at+vTTT9W/f3917txZH3/8saKiok7DWebo1q2bbr75ZhljlJSUpH/84x+64oorNG/ePF155ZWlcox33nlH69at0913322tj4+P1/HjxxUUFFQqxyltycnJ6tKli3799VcNGjRId955p9LS0jR37lwNGTJEn3/+uWbPni23213eQwUAAKj0SGICAFABjRs3TtHR0fruu+8UExNj9e3Zs6d8BlVJ1K1bV3/5y1+sdc8++6wGDx6siRMn6qyzztLtt99u9ffs2VOffPKJvvjiC/Xp08e3fsWKFUpKSlK/fv00d+7cPMcKDAzMc6y///3vmjBhgh5++GGNHDlS7777bimeXV5nn322NYa+ffuqRYsWmjRpUomTmMeOHVN4eHiB/S6XS6GhoSU6xuk0ZMgQ/frrr/rwww/Vu3dv3/oxY8bob3/7m1544QW1bNlSDz74YDmOMn8ne+8BAAAqGqaTAwBQAW3evFnNmzfPk8CUpJo1a/qWC6s56HK59MQTT+RZv2/fPg0cOFBRUVGqXr267rrrrjx3ES5atEgdOnRQTEyMIiIi1LRpUz3yyCO+/qVLl8rlcundd9/VI488ori4OIWHh6t37976888/rX19/fXXGjBggBo0aKCQkBDVr19f99xzj44fP55nbL/99psGDhyo2NhYhYWFqWnTpnr00UetbXbs2KFbbrlFtWrVUkhIiJo3b6633norv7exyMLCwjRr1ixVq1ZN48aNyzONuG7durrsssv0zjvvWOtnz56t888/X+edd94pHe+hhx5S9+7dlZiYqA0bNlh9X3zxhTp16qTIyEhFRUWpdevWeY5bEueff75q1KihpKQkSUX/+QwdOlQRERHavHmzrrrqKkVGRurGG29U586dNW/ePG3dutU3dT27dmJ+v59r167V0KFD1ahRI4WGhiouLk633HKL9u/ff0rncfToUYWHh+uuu+7K07d9+3a53W6NHz++wNd/8803WrBggYYOHWolMLONHz9eZ511lp599tl8f1cnTpyo+Ph4hYWFqVOnTlq3bp3Vv3v3bg0bNkz16tVTSEiIateurT59+lg1PqUTP++OHTsqPDxckZGR6tWrl3755Rdrm4Le+zvvvFMRERFKTU3NM74bbrhBcXFx8ng8p3QsSfroo4903nnnKTQ0VOedd54+/PDDAt9HAACA0sKdmAAAVEDx8fFauXKl1q1bd8oJspMZOHCgEhISNH78eH3zzTd6+eWXdfDgQc2cOVOS9Msvv+jqq69WixYt9NRTTykkJESbNm3S8uXL8+xr3LhxcrlcevDBB7Vnzx5NmjRJXbt21U8//aSwsDBJUmJiolJTU3X77berevXq+vbbbzVlyhRt375diYmJvn2tXbtWHTt2VFBQkG699VYlJCRo8+bN+vTTTzVu3DhJJ6b/XnrppXK5XLrzzjsVGxurL774QsOHD9eRI0fyTGc+FREREerbt6/efPNNrV+/Xs2bN7f6Bw8erLvuuktHjx5VRESEsrKylJiYqHvvvTffqeQnc9NNN2nhwoVatGiRzj77bEknHmZzyy23qHnz5nr44YcVExOj1atXa/78+Ro8eHCxzy23gwcP6uDBg2rSpImkov98JCkrK0s9evRQhw4d9MILL6hKlSqKi4vT4cOHtX37dk2cOFHSifeyIIsWLdIff/yhYcOGKS4uTr/88oumTp2qX375Rd98841cLleRziP75/Xuu+/qpZdesqZ8z5kzR8YY3XjjjQW+/tNPP5Uk3Xzzzfn2BwYGavDgwXryySe1fPlyde3a1dc3c+ZMpaSkaNSoUUpLS9PkyZN1xRVX6Oeff1atWrUkSf369dMvv/yi0aNHKyEhQXv27NGiRYu0bds2X5J31qxZGjJkiHr06KFnn31Wqampeu2119ShQwetXr3aepBOfu99QkKCXn31Vc2bN08DBgzwbZuamqpPP/1UQ4cO9b0vRT3WwoUL1a9fPzVr1kzjx4/X/v37fclYAACA08oAAIAKZ+HChcbtdhu3223atm1rHnjgAbNgwQKTkZFhbZeUlGQkmWnTpuXZhyQzduxYX3vs2LFGkundu7e13R133GEkmTVr1hhjjJk4caKRZPbu3Vvg+JYsWWIkmbp165ojR4741r/33ntGkpk8ebJvXWpqap7Xjx8/3rhcLrN161bfussuu8xERkZa64wxxuv1+paHDx9uateubfbt22dtM2jQIBMdHZ3vsXKLj483vXr1KrA/+9w//vhj3zpJZtSoUebAgQMmODjYzJo1yxhjzLx584zL5TJbtmzxvbe537MhQ4aY8PDwAo+1evVqI8ncc889xhhjDh06ZCIjI02bNm3M8ePHC3wPToUkM3z4cLN3716zZ88es2rVKtOlSxcjybz44ovGmKL/fIYMGWIkmYceeijP9r169TLx8fF51uf3+5nf8ebMmWMkmWXLlvnWTZs2zUgySUlJvnWdOnUynTp18rUXLFhgJJkvvvjC2l+LFi2s7fJz7bXXGknm4MGDBW7zwQcfGEnm5Zdfts4nLCzMbN++3bfdqlWrrJ/lwYMHjSTz/PPPF7jvlJQUExMTY0aOHGmt3717t4mOjrbWF/Tee71eU7duXdOvXz9rffbnMPv9PJVjXXjhhaZ27drm0KFDvnULFy40kvL9GQMAAJQWppMDAFABdevWTStXrlTv3r21Zs0aPffcc+rRo4fq1q2rTz75pET7HjVqlNXOfkjQ559/Lkm+Kewff/zxSZ+gffPNNysyMtLX7t+/v2rXru3blyTfHZnSiTp++/btU7t27WSM0erVqyVJe/fu1bJly3TLLbeoQYMG1jGy78wzxmju3Lm65pprZIzRvn37fH969Oihw4cP68cffzyVtyKP7DsIU1JS8vRVrVpVPXv21Jw5cySdeJhNu3btFB8fXyrHWrRokVJSUvTQQw/lqSNZ1LsT8/Pmm28qNjZWNWvWVJs2bbR8+XLde++9vrtWi/Lzyc2/Xuipyn28tLQ07du3T5deeqkknfLPr2vXrqpTp45mz57tW7du3TqtXbs2Ty1Sf9nve+7fX3/ZfUeOHLHWX3vttapbt66vfckll6hNmza+3/uwsDAFBwdr6dKlOnjwYL77XrRokQ4dOqQbbrjB+l12u91q06aNlixZkuc1/u+9y+XSgAED9Pnnn+vo0aO+9e+++67q1q2rDh06nNKxdu3apZ9++klDhgxRdHS0b3/dunVTs2bNCnyfAAAASgNJTAAAKqjWrVvrgw8+0MGDB/Xtt9/q4YcfVkpKivr376/169cXe79nnXWW1W7cuLECAgJ8tfquv/56tW/fXiNGjFCtWrU0aNAgvffee/kmNP335XK51KRJE6vu37Zt2zR06FBVq1ZNERERio2NVadOnSRJhw8fliT98ccfklTo1Pm9e/fq0KFDmjp1qmJjY60/w4YNk1Tyhx5lJ4IKSmwNHjzYNyX4o48+KtEUb/9jbd68WVLh70Fx9OnTR4sWLdLixYu1atUq7du3Ty+++KICAk5cJhbl55MtMDCwxNOKDxw4oLvuuku1atVSWFiYYmNj1bBhw3yPdzIBAQG68cYb9dFHH/nqQs6ePVuhoaHW9Or8ZL/v+SWssxWU6PT/vZdOPEAp+/c+JCREzz77rL744gvVqlVLl112mZ577jnt3r3bt/3GjRslSVdccUWe3+eFCxfm+V0u6L2//vrrdfz4cd9/bhw9elSff/65BgwY4Et+F/VYW7duLfD8mjZtWuD7BAAAUBqoiQkAQAUXHBys1q1bq3Xr1jr77LM1bNgwJSYmauzYsQXeoZf7YR4n47+PsLAwLVu2TEuWLNG8efM0f/58vfvuu7riiiu0cOFCq/bgyXg8HnXr1k0HDhzQgw8+qHPOOUfh4eHasWOHhg4detI7PXPL3vYvf/mLhgwZku82LVq0KPL+8pP9cJbsepH+evfurZCQEA0ZMkTp6ekaOHDgaTtWaalXr55VzzG3U/35hISE+JKfxTVw4ECtWLFCf/vb33ThhRcqIiJCXq9XPXv2PKXfh2w333yznn/+eX300Ue64YYb9M477+jqq6+27iTMz7nnnquPPvpIa9eu1WWXXZbvNmvXrpWkYt2FePfdd+uaa67RRx99pAULFuixxx7T+PHj9eWXX6ply5a+c501a5bi4uLyvD4w0L6ML+i9v/TSS5WQkKD33ntPgwcP1qeffqrjx4/r+uuv921zqscCAAAoD1yRAABQiVx88cWSTkz7lE5McZakQ4cOWdtl31GVn40bN/rufJOkTZs2yev1Wg8RCQgIUJcuXdSlSxe99NJLeuaZZ/Too49qyZIlVkIs+w6vbMYYbdq0yZdM/Pnnn7VhwwbNmDHDeoDKokWLrNc1atRIkvI84Tm32NhYRUZGyuPxFJiUK4mjR4/qww8/VP369XXuuefmu01YWJiuvfZavf3227ryyitVo0aNYh9v1qxZcrlc6tatm6QTd8RKJ96D053YzFbUn8/JFHW6+8GDB/Wf//xHTz75pB5//HHfev/fo1Nx3nnnqWXLlpo9e7bq1aunbdu2acqUKSd93dVXX63x48dr5syZ+SYxPR6P3nnnHVWtWlXt27e3+vIb74YNG6zPkHTiZ3rffffpvvvu08aNG3XhhRfqxRdf1Ntvv+37edesWbPEv88DBw7U5MmTdeTIEb377rtKSEjwTdHPHkdRjpVdGiG/8/v9999LNEYAAICTYTo5AAAV0JIlS2SMybM+u+Ze9tTOqKgo1ahRQ8uWLbO2+8c//lHgvl999VWrnZ3wufLKKyWdmO7r78ILL5QkpaenW+uzn9Kc7f3339euXbt8+8q+azP3uRhjNHnyZGs/sbGxuuyyy/TWW29p27ZtVl/2a91ut/r166e5c+fmm+zcu3dvAWd8csePH9dNN92kAwcO6NFHHy00KXf//fdr7Nixeuyxx4p9vAkTJmjhwoW6/vrrfVN3u3fvrsjISI0fPz7P087z+10oDUX9+ZxMeHh4kaaC53c8SZo0adIpHc9f9pPeJ02apOrVq/t+/wrTrl07de3aVdOmTdNnn32Wp//RRx/Vhg0b9MADD1h1PCXpo48+0o4dO3ztb7/9VqtWrfIdNzU1Nc/PsHHjxoqMjPR9hnr06KGoqCg988wzyszMzHP8U/l9vv7665Wenq4ZM2Zo/vz5ee4QLuqxateurQsvvFAzZsywfp6LFi0qUQkLAACAouBOTAAAKqDRo0crNTVVffv21TnnnKOMjAytWLHCd5dVdg1ISRoxYoQmTJigESNG6OKLL9ayZcu0YcOGAvedlJSk3r17q2fPnlq5cqXefvttDR48WBdccIEk6amnntKyZcvUq1cvxcfHa8+ePfrHP/6hevXq+R4Ukq1atWrq0KGDhg0bpuTkZE2aNElNmjTRyJEjJUnnnHOOGjdurPvvv187duxQVFSU5s6dm+/DTl5++WV16NBBF110kW699VY1bNhQW7Zs0bx58/TTTz9JOpH8W7Jkidq0aaORI0eqWbNmOnDggH788UctXrw43wSsvx07dujtt9+WdOLuy/Xr1ysxMVG7d+/Wfffdp9tuu63Q119wwQW+9+pksrKyfMdKS0vT1q1b9cknn2jt2rW6/PLLNXXqVN+2UVFRmjhxokaMGKHWrVtr8ODBqlq1qtasWaPU1FTNmDFDkrR06VJdfvnlGjt2rJ544okijaMgp/LzKUyrVq307rvv6t5771Xr1q0VERGha665Js92UVFRvvqQmZmZqlu3rhYuXKikpKQSncfgwYP1wAMP6MMPP9Ttt9+uoKCgIr1u5syZ6tKli/r06aPBgwerY8eOSk9P1wcffKClS5fq+uuv19/+9rc8r2vSpIk6dOig22+/Xenp6b7k6QMPPCDpxF2ZXbp00cCBA9WsWTMFBgbqww8/VHJysgYNGuR7L1577TXddNNNuuiiizRo0CDFxsZq27Ztmjdvntq3b69XXnmlSOdx0UUXqUmTJnr00UeVnp5uTSU/1WONHz9evXr1UocOHXTLLbfowIEDmjJlipo3b249PAgAAKDUlcsz0QEAQIl88cUX5pZbbjHnnHOOiYiIMMHBwaZJkyZm9OjRJjk52do2NTXVDB8+3ERHR5vIyEgzcOBAs2fPHiPJjB071rfd2LFjjSSzfv16079/fxMZGWmqVq1q7rzzTnP8+HHfdv/5z39Mnz59TJ06dUxwcLCpU6eOueGGG8yGDRt82yxZssRIMnPmzDEPP/ywqVmzpgkLCzO9evUyW7dutca3fv1607VrVxMREWFq1KhhRo4cadasWWMkmWnTplnbrlu3zvTt29fExMSY0NBQ07RpU/PYY49Z2yQnJ5tRo0aZ+vXrm6CgIBMXF2e6dOlipk6detL3NT4+3kgykozL5TJRUVGmefPmZuTIkWbVqlX5vkaSGTVqVKH7zX5v9+7d61s3ZMgQ37EkmSpVqpiEhATTr18/8/777xuPx5Pvvj755BPTrl07ExYWZqKioswll1xi5syZ4+v/9NNPjSTz+uuvn/R8izL2ov58hgwZYsLDw/Pdx9GjR83gwYNNTEyMkWTi4+ONMcYkJSXl2c/27dt9P+Po6GgzYMAAs3Pnzjy/r9OmTTOSTFJSkm9dp06dTKdOnfIdw1VXXWUkmRUrVhR6vv5SUlLME088YZo3b27CwsJMZGSkad++vZk+fbrxer3Wttnn8/zzz5sXX3zR1K9f34SEhJiOHTuaNWvW+Lbbt2+fGTVqlDnnnHNMeHi4iY6ONm3atDHvvfdenuMvWbLE9OjRw0RHR5vQ0FDTuHFjM3ToUPP999/7tinsvc/26KOPGkmmSZMmBW5TlGMZY8zcuXPNueeea0JCQkyzZs3MBx98YIYMGeL7uQIAAJwOLmNO0/wjAABwxsq+GzAxMVH9+/cv7+GcUR544AHNmTNHmzZtUkhISHkPxzH69u2rn3/+WZs2bSrvoQAAAKAYqIkJAABQiSxZskSPPfYYCcxcdu3apXnz5ummm24q76EAAACgmKiJCQAAUIl899135T0Ex0hKStLy5cv1r3/9S0FBQSetZwoAAADn4k5MAAAAVEpfffWVbrrpJiUlJWnGjBmKi4sr7yEBAACgmKiJCQAAAAAAAMDRuBMTAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBAAAAAAAAOBoJDEBAAAAAAAAOBpJTAAAAAAAAACORhITAAAAAAAAgKORxAQAAAAAAADgaCQxAQAAAAAAADgaSUwAAAAAAAAAjkYSEwAAAAAAAICjkcQEAAAAAAAA4GgkMQEAAAAAAAA4GklMAAAAAAAAAI5GEhMAAAAAAACAo5HEBIBy9t5776latWo6evRoqewvISFBQ4cOLZV9ZZs/f74iIiK0d+/eUt0vAGfZsmWLXC6Xpk+fXqTtiV8Aiqq048WZ5tJLL9UDDzxQ3sMAKrzyvtY505R27CKJCaDC+vnnn9W/f3/Fx8crNDRUdevWVbdu3TRlyhRru2eeeUYfffRRsY+zfv16PfHEE9qyZUvJBpwPj8ejsWPHavTo0YqIiPCtT0hI0NVXX13qxzuZf/zjH/n+g96zZ081adJE48ePL/MxAU61efNm3XbbbWrUqJFCQ0MVFRWl9u3ba/LkyTp+/PhpO+7pjEmngvgFlI3KfL2TkZGhyZMnq2XLloqKilJMTIyaN2+uW2+9Vb/99lupj6O8fP7553riiSdKtI8HH3xQr776qnbv3l06gwKKgGsdYpfjYpcBgApo+fLlJjg42DRp0sQ8/fTT5o033jCPP/646d69u2ncuLG1bXh4uBkyZEixj5WYmGgkmSVLlpRs0Pn48MMPjcvlMtu3b7fWx8fHm169ehVrn2lpaSYjI6NYr23evLnp1KlTvn3/+Mc/TJUqVcyRI0eKtW+gMvnss89MWFiYiYmJMWPGjDFTp041r7zyihk0aJAJCgoyI0eOPG3HPp0xKSkpyUgy06ZNO+m2xC/g9Kvs1ztXX321cbvd5i9/+Yt59dVXzaRJk8xf//pXU69evSLFoYpi1KhRpqRfvT0ej4mLizOPPfZYKY0KKBzXOsQuJ8auwNJJhQJA2Ro3bpyio6P13XffKSYmxurbs2dP+QyqGKZNm6b27durbt26pbbPkJCQUttXbv369dPo0aOVmJioW2655bQcA6gIkpKSNGjQIMXHx+vLL79U7dq1fX2jRo3Spk2bNG/evHIcYQ5jjNLS0hQWFlbq+yZ+AadfZb7e+e677/TZZ59p3LhxeuSRR6ztX3nlFR06dKiMR1l0x44dU3h4eJkeMyAgQP3799fMmTP15JNPyuVylenxcWbhWucEYlfJlXbsYjo5gApp8+bNat68eZ4LekmqWbOmb9nlcunYsWOaMWOGXC6XXC6Xr97a1q1bdccdd6hp06YKCwtT9erVNWDAAGvawvTp0zVgwABJ0uWXX+7bx9KlS33bfPHFF+rYsaPCw8MVGRmpXr166ZdffjnpOaSlpWn+/Pnq2rVrkc752LFjuu+++1S/fn2FhISoadOmeuGFF2SMsbbzryk3ffp0uVwuLV++XPfee69iY2MVHh6uvn37WjXiEhIS9Msvv+irr77ynWfnzp19/TVr1lSLFi308ccfF2m8QGX13HPP6ejRo3rzzTeti/psTZo00V133eVrZ2Vl6emnn1bjxo0VEhKihIQEPfLII0pPT7delz0N+7///a8uueQShYaGqlGjRpo5c6Zvm5PFpOx9LFiwQBdffLHCwsL0z3/+U5L0xx9/aMCAAapWrZqqVKmiSy+9tNhfQIhfQNmozNc7mzdvliS1b98+z2vcbreqV69urduxY4duueUW1apVSyEhIWrevLneeusta5ulS5fK5XLp3Xff1SOPPKK4uDiFh4erd+/e+vPPP61tv/76aw0YMEANGjRQSEiI6tevr3vuuSfPFNmhQ4cqIiJCmzdv1lVXXaXIyEjdeOONRd7H0KFD9eqrr0qS733N/SXe6/Vq0qRJat68uUJDQ1WrVi3ddtttOnjwYJ73pVu3btq6dat++umnfN9roLRwrUPscmrs4k5MABVSfHy8Vq5cqXXr1um8884rcLtZs2ZpxIgRuuSSS3TrrbdKkho3bizpxP+irVixQoMGDVK9evW0ZcsWvfbaa+rcubPWr1+vKlWq6LLLLtOYMWP08ssv65FHHtG5554rSb6/Z82apSFDhqhHjx569tlnlZqaqtdee00dOnTQ6tWrlZCQUODYfvjhB2VkZOiiiy466fkaY9S7d28tWbJEw4cP14UXXqgFCxbob3/7m3bs2KGJEyeedB+jR49W1apVNXbsWG3ZskWTJk3SnXfeqXfffVeSNGnSJF+9l0cffVSSVKtWLWsfrVq1KlG9LaAy+PTTT9WoUSO1a9euSNuPGDFCM2bMUP/+/XXfffdp1apVGj9+vH799Vd9+OGH1rabNm1S//79NXz4cA0ZMkRvvfWWhg4dqlatWql58+YnjUmS9Pvvv+uGG27QbbfdppEjR6pp06ZKTk5Wu3btlJqaqjFjxqh69eqaMWOGevfurffff199+/Y9pfeA+AWUjcp8vRMfHy9Jmj17ttq3b6/AwIK/miYnJ+vSSy+Vy+XSnXfeqdjYWH3xxRcaPny4jhw5orvvvtvafty4cXK5XHrwwQe1Z88eTZo0SV27dtVPP/3ku1srMTFRqampuv3221W9enV9++23mjJlirZv367ExERrf1lZWerRo4c6dOigF154QVWqVCnyPm677Tbt3LlTixYt0qxZs/Kc22233abp06dr2LBhGjNmjJKSkvTKK69o9erVWr58uYKCgnzbtmrVSpK0fPlytWzZssD3CygprnWIXY6NXaUyKR0AytjChQuN2+02brfbtG3b1jzwwANmwYIF+dZSK6hGVGpqap51K1euNJLMzJkzfesKqsmSkpJiYmJi8tSD2b17t4mOjj5pnZh//etfRpL5+eef8/T515T76KOPjCTz97//3dquf//+xuVymU2bNlmvzX2+06ZNM5JM165djdfr9a2/5557jNvtNocOHfKtK6ymnDHGPPPMM0aSSU5OLvTcgMrq8OHDRpLp06dPkbb/6aefjCQzYsQIa/39999vJJkvv/zSty4+Pt5IMsuWLfOt27NnjwkJCTH33Xefb11hdaKy9zF//nxr/d13320kma+//tq3LiUlxTRs2NAkJCQYj8djjCl6nSjiF1A2KvP1jtfrNZ06dTKSTK1atcwNN9xgXn31VbN169Y8+xg+fLipXbu22bdvn7V+0KBBJjo62neOS5YsMZJM3bp1rRq47733npFkJk+eXOj7Mn78eONyuawxDBkyxEgyDz30UJ7ti7qPgurKff3110aSmT17trV+/vz5+a43xpjg4GBz++2351kPlBaudU4gdjkzdjGdHECF1K1bN61cuVK9e/fWmjVr9Nxzz6lHjx6qW7euPvnkkyLtI3fdlMzMTO3fv19NmjRRTEyMfvzxx5O+ftGiRTp06JBuuOEG7du3z/fH7XarTZs2WrJkSaGv379/vySpatWqJz3W559/LrfbrTFjxljr77vvPhlj9MUXX5x0H7feeqs1BaBjx47yeDzaunXrSV+bLXus+/btK/JrgMrkyJEjkqTIyMgibf/5559Lku69915r/X333SdJeaY4NWvWTB07dvS1Y2Nj1bRpU/3xxx9FHmPDhg3Vo0ePPOO45JJL1KFDB9+6iIgI3XrrrdqyZYvWr19f5P1LxC+grFTm6x2Xy6UFCxbo73//u6pWrao5c+Zo1KhRio+P1/XXX++rK2eM0dy5c3XNNdfIGGONoUePHjp8+HCe87j55putON2/f3/Vrl3bF5P935djx45p3759ateunYwxWr16dZ7zuP322/OsO9V9+EtMTFR0dLS6detmnVerVq0UERGR73tbtWpV4hhOK651TiB2Faw8YxfTyQFUWK1bt9YHH3ygjIwMrVmzRh9++KEmTpyo/v3766efflKzZs0Kff3x48c1fvx4TZs2TTt27LBqsx0+fPikx9+4caMk6Yorrsi3PyoqqkjnYfxqwuVn69atqlOnTp6LiexpFUX5It+gQQOrnf0Pcn51SwqSPVaKyeNMlf25TklJKdL2W7duVUBAgJo0aWKtj4uLU0xMTJ7Prv/nVDrxWT2Vz2nDhg3zHUebNm3yrM8dQwqbqloQ4hdw+lXm652QkBA9+uijevTRR7Vr1y599dVXmjx5st577z0FBQXp7bff1t69e3Xo0CFNnTpVU6dOzXff/g85Ouuss6y2y+VSkyZNrDqg27Zt0+OPP65PPvkkTyzxf18CAwNVr169PMc9lX3kZ+PGjTp8+LBV37Sw85JOvI/EMZxOXOvYiF15lWfsIokJoMILDg5W69at1bp1a5199tkaNmyYEhMTNXbs2EJfN3r0aE2bNk1333232rZtq+joaLlcLg0aNEher/ekx83eZtasWYqLi8vTX1h9FEm+os8HDx7M9x+X0uZ2u/NdX5QkRLbsf+Rq1KhRKmMCKpqoqCjVqVNH69atO6XXFfWirTQ+p6fj6Zz+iF9A2avs1zu1a9fWoEGD1K9fPzVv3lzvvfeepk+f7jv+X/7yFw0ZMiTf17Zo0eKk55Gbx+NRt27ddODAAT344IM655xzFB4erh07dmjo0KF53peQkBAFBASUaB/58Xq9qlmzpmbPnp1vf2xsbJ51hw4dIo7htOJa5wRiV8HKM3aRxARQqVx88cWSpF27dvnWFfQP6vvvv68hQ4boxRdf9K1LS0vzTQE42euzC+bXrFmzyE/oze2cc86RJCUlJen8888vdNv4+HgtXrxYKSkp1t1Mv/32m6+/NJzs4iMpKUk1atTI9x8m4Exx9dVXa+rUqVq5cqXatm1b6Lbx8fHyer3auHGjVZA+OTlZhw4dKtZntzj/ix0fH6/ff/89z/rixhDiF1C+Kuv1jiQFBQWpRYsW2rhxo/bt26fY2FhFRkbK4/EU+fjZd49mM8Zo06ZNvoTBzz//rA0bNmjGjBm6+eabfdstWrSoqKd1Svso7L1dvHix2rdvX6SkzI4dO5SRkWH9ewKcDlzrELskZ8YuamICqJCWLFmS7//WZdcLadq0qW9deHh4ngt16cT/AvrvY8qUKfJ4PNa68PBwScqzjx49eigqKkrPPPOMMjMz8+x/7969hZ5Dq1atFBwcrO+//77Q7STpqquuksfj0SuvvGKtnzhxolwul6688sqT7qMoCnqvsv3www8nvZABKrsHHnhA4eHhGjFihJKTk/P0b968WZMnT5Z04rMrnXh6dm4vvfSSJKlXr16nfPyCYlJhrrrqKn377bdauXKlb92xY8c0depUJSQknHQ6qj/iF1A2KvP1zsaNG7Vt27Y82x86dEgrV65U1apVFRsbK7fbrX79+mnu3Ln53hmW3/FnzpxpTYV9//33tWvXLl+8yb4TLPf7Yozxxe6iOJV9FPTeDhw4UB6PR08//XSe12RlZeXZ/ocffpCkIj8xGigurnWIXZIzYxd3YgKokEaPHq3U1FT17dtX55xzjjIyMrRixQq9++67SkhI0LBhw3zbtmrVSosXL9ZLL72kOnXqqGHDhmrTpo2uvvpqzZo1S9HR0WrWrJlWrlypxYsX+6YOZLvwwgvldrv17LPP6vDhwwoJCdEVV1yhmjVr6rXXXtNNN92kiy66SIMGDVJsbKy2bdumefPmqX379nm+tOcWGhqq7t27a/HixXrqqacKPd9rrrlGl19+uR599FFt2bJFF1xwgRYuXKiPP/5Yd999t+8uiZJq1aqVXnvtNf39739XkyZNVLNmTV8NrD179mjt2rUaNWpUqRwLqKgaN26sd955R9dff73OPfdc3XzzzTrvvPN8cSgxMVFDhw6VJF1wwQUaMmSIpk6dqkOHDqlTp0769ttvNWPGDF177bW6/PLLT/n4hcWkgjz00EOaM2eOrrzySo0ZM0bVqlXTjBkzlJSUpLlz5+aZanQyxC+gbFTm6501a9Zo8ODBuvLKK9WxY0dVq1ZNO3bs0IwZM7Rz505NmjTJ92V7woQJWrJkidq0aaORI0eqWbNmOnDggH788UctXrxYBw4csI5ZrVo1dejQQcOGDVNycrImTZqkJk2aaOTIkZJO3GHVuHFj3X///dqxY4eioqI0d+7cU6rJdyr7aNWqlSRpzJgx6tGjh9xutwYNGqROnTrptttu0/jx4/XTTz+pe/fuCgoK0saNG5WYmKjJkyerf//+vv0sWrRIDRo0UMuWLYs8TqA4uNYhdkkOjV0lfr45AJSDL774wtxyyy3mnHPOMRERESY4ONg0adLEjB492iQnJ1vb/vbbb+ayyy4zYWFhRpIZMmSIMcaYgwcPmmHDhpkaNWqYiIgI06NHD/Pbb7+Z+Ph43zbZ3njjDdOoUSPjdruNJLNkyRJf35IlS0yPHj1MdHS0CQ0NNY0bNzZDhw4133///UnP44MPPjAul8ts27bNWt+gQQPTu3dva11KSoq55557TJ06dUxQUJA566yzzPPPP2+8Xq+1nf/4p02bZiSZ7777ztpuyZIlec5l9+7dplevXiYyMtJIMp06dfL1vfbaa6ZKlSrmyJEjJz0v4EywYcMGM3LkSJOQkGCCg4NNZGSkad++vZkyZYpJS0vzbZeZmWmefPJJ07BhQxMUFGTq169vHn74YWsbY058dnv16pXnOJ06dbI+i8YUHJMK2ocxxmzevNn079/fxMTEmNDQUHPJJZeYzz77zNomKSnJSDLTpk076fkTv4DTrzJf7yQnJ5sJEyaYTp06mdq1a5vAwEBTtWpVc8UVV5j3338/zz6Sk5PNqFGjTP369U1QUJCJi4szXbp0MVOnTrXGKMnMmTPHPPzww6ZmzZomLCzM9OrVy2zdutXa3/r1603Xrl1NRESEqVGjhhk5cqRZs2ZNnhg4ZMgQEx4enu95FXUfWVlZZvTo0SY2Nta4XC7j/zV86tSpplWrViYsLMxERkaa888/3zzwwANm586dvm08Ho+pXbu2+b//+7+Tvt9AaeFah9jltNjlMuYUqqcCAEqVx+NRs2bNNHDgQOt2/GrVqqlXr16aNWtWOY7O1rJlS3Xu3FkTJ04s76EAcADiF4CiKihelLalS5fq8ssvV2JionUXUGXw0UcfafDgwdq8ebNq165d3sMBzgjErpIr7dhFTUwAKEdut1tPPfWUXn31VR09elTSiRozBw8ePOW6LafT/PnztXHjRj388MPlPRQADkH8AlBU+cULnJpnn31Wd955JwlMoAwRu0qutGMXd2ICgEP88ccf+vzzz/Xaa69p06ZN+u2339SwYcPyHhYAnBTxC4ATVOa7mQBUXsSuouNOTABwiGXLlunee+9VcHCwPv74YxIAACoM4hcAAABON+7EBAAAAAAAAOBo3IkJAAAAAAAAwNEqdRJz+vTpcrlc2rJlS3kPBQAAAAAAAEAxVYgkZnYy8vvvvy+zY65fv15PPPEECVAAp+TNN9/Uueeeq9DQUJ111lmaMmVKsfYzbtw4uVwunXfeeXn6vF6vXn/9dV144YWKiIhQrVq1dOWVV2rFihUlHT6ASqq4sWnp0qVyuVz5/vnmm29826WmpurVV19V9+7dVbt2bUVGRqply5Z67bXX5PF4TtdpAagESnrt9OOPP6p3796qVq2aqlSpovPOO08vv/yyr3/Lli0FxjGXy6WRI0eW9ikBqATK4ntdbocOHVLNmjXlcrn0/vvvF+tYZ4LA8h7A6XTTTTdp0KBBCgkJOeXXrl+/Xk8++aQ6d+6shISE0h8cgErnn//8p/7617+qX79+uvfee/X1119rzJgxSk1N1YMPPljk/Wzfvl3PPPOMwsPD8+3/29/+ppdeekl/+ctfdMcdd+jQoUP65z//qU6dOmn58uW65JJLSuuUAFQCpRGbxowZo9atW1vrmjRp4lv+448/NHr0aHXp0kX33nuvoqKitGDBAt1xxx365ptvNGPGjFI9JwCVQ0nj08KFC3XNNdeoZcuWeuyxxxQREaHNmzdr+/btvm1iY2M1a9asPK+dP3++Zs+ere7du5fqOQGo+Mrqe11ujz/+uFJTU0sy7DNChXiwz/Tp0zVs2DB99913uvjii8vkmO+//74GDBigJUuWqHPnzmVyTAAV1/Hjx1W/fn1deuml+uyzz3zr//KXv+ijjz7Sn3/+qapVqxZpX4MGDdLevXvl8Xi0b98+rVu3zteXlZWlqKgo9erVS4mJib71SUlJatSokcaMGaPJkyeX3okBqNBKGpuWLl2qyy+/XImJierfv3+B2+3bt0/Jyclq3ry5tf6WW27RtGnTtHHjRivpCQAljU9HjhzR2WefrXbt2un9999XQMCpTTLs2rWrvvvuOyUnJys0NLTY5wGgcimr73W5rVu3Ti1bttTjjz+uxx9//KTXXWeyCjGdPD9ffvmlOnbsqPDwcMXExKhPnz769ddfrW3yq4mZkJCgq6++Wv/97391ySWXKDQ0VI0aNdLMmTOt1w0YMECSdPnll/umGixdurQsTg1ABbRkyRLt379fd9xxh7V+1KhROnbsmObNm1ek/Sxbtkzvv/++Jk2alG9/Zmamjh8/rlq1alnra9asqYCAAIWFhRVr/AAqp9KKTZKUkpKirKysfPtq1KiRJ4EpSX379pWkPNdoAFDS+PTOO+8oOTlZ48aNU0BAgI4dOyav11ukY+/atUtLlizRddddRwITgKWsvtfldtddd6lv377q2LFjcYZ8RqmQSczFixerR48e2rNnj5544gnde++9WrFihdq3b1+kGpabNm1S//791a1bN7344ouqWrWqhg4dql9++UWSdNlll2nMmDGSpEceeUSzZs3SrFmzdO65557O0wJQga1evVqS8twt3qpVKwUEBPj6C+PxeDR69GiNGDFC559/fr7bhIWFqU2bNpo+fbpmz56tbdu2ae3atRo6dKiqVq2qW2+9teQnA6DSKI3YJEnDhg1TVFSUQkNDdfnllxe5Tvnu3bslnUhyAkBuJY1PixcvVlRUlHbs2KGmTZsqIiJCUVFRuv3225WWllboa//973/L6/XqxhtvLNlJAKh0yup7XbbExEStWLFCzz33XPEHfQapkDUx//a3v6latWpauXKlqlWrJkm69tpr1bJlS40dO/akdZd+//13LVu2zJflHjhwoOrXr69p06bphRdeUKNGjdSxY0e9/PLL6tatG9PJAZzUrl275Ha7VbNmTWt9cHCwqlevrp07d550H6+//rq2bt2qxYsXF7rd22+/reuvv15/+ctffOsaNWqk5cuXq1GjRsU7AQCVUkljU3BwsPr166errrpKNWrU0Pr16/XCCy+oY8eOWrFihVq2bFngazMyMjRp0iQ1bNgwTz1NAChpfNq4caOysrLUp08fDR8+XOPHj9fSpUs1ZcoUHTp0SHPmzCnwtbNnz1bt2rV1xRVXlMq5AKg8yvJ73fHjx3X//ffrnnvuUUJCAg+WLoIKl8TctWuXfvrpJz3wwAO+BKYktWjRQt26ddPnn39+0n00a9bMuk03NjZWTZs21R9//HFaxgyg8jt+/LiCg4Pz7QsNDdXx48cLff3+/fv1+OOP67HHHlNsbGyh20ZGRqp58+Zq27atunTpot27d2vChAm69tpr9fXXX3PHEwCfksamdu3aqV27dr5279691b9/f7Vo0UIPP/yw5s+fX+Br77zzTq1fv17z5s1TYGCFu+QEcJqVND4dPXpUqamp+utf/+p7Gvl1112njIwM/fOf/9RTTz2ls846K8/rNmzYoB9++EH33HPPKdfRBFD5leX3ugkTJigzM1OPPPJIscd7pqlwUXvr1q2SpKZNm+bpO/fcc7Vv3z4dO3as0H00aNAgz7qqVavq4MGDpTNIAGecsLAwZWRk5NuXlpZ20lqV//d//6dq1app9OjRhW6XlZWlrl27Kjo6Wq+88or69u2r22+/XYsXL9bmzZv1/PPPF/scAFQ+JY1N+WnSpIn69OmjJUuWyOPx5LvN888/rzfeeENPP/20rrrqqlM+BoDKr6TxKbv/hhtusNYPHjxYkrRy5cp8Xzd79mxJYio5gHyV1fe6LVu26Pnnn9e4ceMUERFR7PGeaSpcErM0uN3ufNdXgAe1A3Co2rVry+PxaM+ePdb6jIwM7d+/X3Xq1CnwtRs3btTUqVM1ZswY7dy5U1u2bNGWLVuUlpamzMxMbdmyRQcOHJB0okD0unXr1Lt3b2sfZ511ls4991wtX7689E8OQIVVkthUmPr16ysjIyPf/ziePn26HnzwQf31r3/V//3f/xVr/wAqv5LGp+z+/B52KKnAG1TeeecdNW3aVK1atSru0AFUYmX1ve7xxx9X3bp11blzZ9922bXE9+7dqy1bthT5YWVnkgqXxIyPj5d0oq6lv99++001atRQeHh4iY/jcrlKvA8AZ44LL7xQkvI87OL777+X1+v19ednx44d8nq9GjNmjBo2bOj7s2rVKm3YsEENGzbUU089JUlKTk6WpHzvfsrMzCzwycEAzkwliU2F+eOPPxQaGprnzoGPP/5YI0aM0HXXXadXX321WPsGcGYoaXzKTkLu2LHDWp9dry6/aZyrVq3Spk2buAsTQIHK6nvdtm3btGnTJjVq1Mi3Xfad5XfccYcaNmyoI0eOnJZzrMgqXIGi2rVr68ILL9SMGTP08MMPKyYmRpK0bt06LVy40HrQRUlkJ0IPHTpUKvsDULldccUVqlatml577TVr6uRrr72mKlWqqFevXr51+/bt0759+9SgQQNVqVJF5513nj788MM8+/y///s/paSkaPLkyWrcuLEk6eyzz5Z04qmaPXv29G37448/6vfff+fp5AAsJYlN0ok7AfwTAWvWrNEnn3yiK6+80qont2zZMg0aNEiXXXaZZs+eTa05AIUqaXwaOHCgJkyYoDfffNN6QM+//vUvBQYG5vtw1nfeeUdSzpRzAPBXVt/r/v73v2vfvn3WduvWrdNjjz2mBx54QG3bti2VG/QqmwqXxJRO1Fm68sor1bZtWw0fPlzHjx/XlClTFB0drSeeeKJUjnHhhRfK7Xbr2Wef1eHDhxUSEqIrrrgizxOqAEA6UTvl6aef1qhRozRgwAD16NFDX3/9td5++22NGzfOehDZK6+8oieffFJLlixR586dVaNGDV177bV59jlp0iRJsvpatWqlbt26acaMGTpy5Ii6d++uXbt2acqUKQoLC9Pdd999ek8UQIVSktgkSddff73CwsLUrl071axZU+vXr9fUqVNVpUoVTZgwwffarVu3qnfv3nK5XOrfv78SExOtcbRo0UItWrQok3MGUDGUND61bNlSt9xyi9566y1lZWWpU6dOWrp0qRITE/Xwww/nmfLp8Xj07rvv6tJLL/UlEQDAX1l9r+vQoUOe7bJv0mvdunW++0EFSWJm16rMrmXZtWtXzZ8/X2PHjtXjjz+uoKAgderUSc8++6waNmxYKseMi4vT66+/rvHjx2v48OHyeDxasmQJSUwABbrjjjsUFBSkF198UZ988onq16+viRMn6q677irV43z88cd64YUX9O9//1vz589XcHCwOnbsqKeffjrfh54BOLOVJDZde+21mj17tl566SUdOXJEsbGxuu666zR27Fg1adLEt11SUpIOHz4sSRo1alSe/YwdO5YkJoA8Snrt9Prrr6tBgwaaNm2aPvzwQ8XHx2vixIn5/qfu4sWLlZycrEcffbSUzwJAZVNW3+tw6lymAjzN5uWXX9Zdd92lTZs28b9mAAAAAAAAwBmmQhQr+u677xQeHu57qA8AAAAAAACAM4ejp5PPnTtXS5cu1ezZszVixAgFBjp6uAAAAAAAAABOA0dPJ2/YsKFSUlLUt29fTZo0iSczAQAAAAAAAGcgRycxAQAAAAAAAKBC1MQEAAAAAAAAcOYiiQkAAAAAAADA0UhiAgAAAAAAAHA0kpgAAAAAAAAAHI0kJgAAAAAAAABHI4kJAAAAAAAAwNFIYgIAAAAAAABwNJKYAAAAAAAAAByNJCYAAAAAAAAARyOJCQAAAAAAAMDRSGICAAAAAAAAcDSSmAAAAAAAAAAcjSQmAAAAAAAAAEcjiQkAAAAAAADA0UhiAgAAAAAAAHA0kpgAAAAAAAAAHI0kJgAAAAAAAABHI4kJAAAAAAAAwNFIYgIAAAAAAABwNJKYAAAAAAAAAByNJCYAAAAAAAAARyuXJOarr76qhIQEhYaGqk2bNvr222/LYxglMn78eLVu3VqRkZGqWbOmrr32Wv3+++/lPSwARXCqMSgxMVHnnHOOQkNDdf755+vzzz8vo5HmVZzYM336dLlcLutPaGhoGY0YQEFKOxYZY/T444+rdu3aCgsLU9euXbVx48bTeQqWUzmfN954Qx07dlTVqlVVtWpVde3aNc/2Q4cOzRO7evbsebpPA0A+Ksq1E9dJwJmnPOPTqRz7l19+Ub9+/ZSQkCCXy6VJkyYV+7hnsjJPYr777ru69957NXbsWP3444+64IIL1KNHD+3Zs6esh1IiX331lUaNGqVvvvlGixYtUmZmprp3765jx46V99AAFOJUY9CKFSt0ww03aPjw4Vq9erWuvfZaXXvttVq3bl0Zj/yE4saeqKgo7dq1y/dn69atZTRiAPk5HbHoueee08svv6zXX39dq1atUnh4uHr06KG0tDTHnc/SpUt1ww03aMmSJVq5cqXq16+v7t27a8eOHdZ2PXv2tGLXnDlzTvu5ALBVpGsnrpOAM0t5xqdTPXZqaqoaNWqkCRMmKC4u7pSPh/8xZeySSy4xo0aN8rU9Ho+pU6eOGT9+fFkPpVTt2bPHSDJfffVVeQ8FQCFONQYNHDjQ9OrVy1rXpk0bc9ttt53WcRZVUWLPtGnTTHR0dNkNCsBJlXYs8nq9Ji4uzjz//PO+/kOHDpmQkBAzZ86c03AGtpJe32VlZZnIyEgzY8YM37ohQ4aYPn36lPZQAZyiinztxHUSULmVZ3wqybVPfHy8mThx4ikfE8aU6Z2YGRkZ+uGHH9S1a1ffuoCAAHXt2lUrV64sy6GUusOHD0uSqlWrVs4jAVCQ4sSglStXWttLUo8ePRwTs4oae44ePar4+HjVr19fffr00S+//FIWwwOQj9MRi5KSkrR7925rm+joaLVp0+a0x6vSuL5LTU1VZmZmnli2dOlS1axZU02bNtXtt9+u/fv3l+rYARSuol87cZ0EVF7lGZ8qc27L6co0iblv3z55PB7VqlXLWl+rVi3t3r27LIdSqrxer+6++261b99e5513XnkPB0ABihODdu/e7diYVdTY07RpU7311lv6+OOP9fbbb8vr9apdu3bavn17GY4WQLbTEYuy/y6PeFUa13cPPvig6tSpY30Z6Nmzp2bOnKn//Oc/evbZZ/XVV1/pyiuvlMfjKdXxAyhYRb524joJqNzKMz5V1txWRRBY3gOoDEaNGqV169bpv//9b3kPBcAZpKixp23btmrbtq2v3a5dO5177rn65z//qaeffvp0DxMACjVhwgT9+9//1tKlS62HaQwaNMi3fP7556tFixZq3Lixli5dqi5dupTHUAFUIFwnAUDlU6Z3YtaoUUNut1vJycnW+uTk5Apb2PTOO+/UZ599piVLlqhevXrlPRwAhShODIqLi3NkzCpJ7AkKClLLli21adOm0zQ6AIU5HbEo++/yiFclub574YUXNGHCBC1cuFAtWrQodNtGjRqpRo0axC6gDFXUayeuk4DKrzzjU2XMbVUUZZrEDA4OVqtWrfSf//zHt87r9eo///mP9b9fFYExRnfeeac+/PBDffnll2rYsGF5DwnASRQnBrVt29baXpIWLVpUbjGrNGKPx+PRzz//rNq1a5+GEQI4mdMRixo2bKi4uDhrmyNHjmjVqlWnPV4V9/ruueee09NPP6358+fr4osvPulxtm/frv379xO7gDJU0a6duE4CzhzlGZ8qU26rwinrJwn9+9//NiEhIWb69Olm/fr15tZbbzUxMTFm9+7dZT2UErn99ttNdHS0Wbp0qdm1a5fvT2pqankPDUAhThaDbrrpJvPQQw/5tl++fLkJDAw0L7zwgvn111/N2LFjTVBQkPn555/LZfxFiT3+5/Dkk0+aBQsWmM2bN5sffvjBDBo0yISGhppffvmlPE4BgDk9sWjChAkmJibGfPzxx2bt2rWmT58+pmHDhub48eOOO58JEyaY4OBg8/7771uxLCUlxRhjTEpKirn//vvNypUrTVJSklm8eLG56KKLzFlnnWXS0tJO+/kAyFGRrp24TgLOLOUZn0712Onp6Wb16tVm9erVpnbt2ub+++83q1evNhs3bizhu3BmKfMkpjHGTJkyxTRo0MAEBwebSy65xHzzzTflMYwSkZTvn2nTppX30ACcRGExqFOnTmbIkCHW9u+99545++yzTXBwsGnevLmZN29eGY84R1Fij/853H333b7zrVWrlrnqqqvMjz/+WPaDB2Ap7Vjk9XrNY489ZmrVqmVCQkJMly5dzO+//14Wp2KMObXziY+PzzeWjR071hhjTGpqqunevbuJjY01QUFBJj4+3owcObLC/ac3UFlUlGsnrpOAM095xqdTOXZSUlK+8alTp07FPv6ZyGWMMWVzzycAAAAAAAAAnLoyrYkJAAAAAAAAAKeKJCYAAAAAAAAARyOJCQAAAAAAAMDRSGICAAAAAAAAcDSSmAAAAAAAAAAcjSQmAAAAAAAAAEcjiQkAAAAAAADA0cotiZmenq4nnnhC6enp5TWEUlFZzgPACRX9M13Rxw+gYJXp812ZzgU401W0z3NFGy+A4ivPzzux5vRwGWNMeRz4yJEjio6O1uHDhxUVFVUeQygVleU8AJxQ0T/TFX38AApWmT7flelcgDNdRfs8V7TxAii+8vy8E2tOD6aTAwAAAAAAAHA0kpgAAAAAAAAAHC2wvAdw5MiR8h5CiWSP3/88goODFRoaWh5DAlAKKmpsKigm5UZ8Aiq2ihqfcssvVhGbgIqtosSmolwr+SM+ARVbecSn4sSaU3UmxqZyq4l5+PBhVY+pIY+yyuPwp11cXJySkpLOuF8ooKI7EZuqyyNPeQ/ltCE+ARUT104AnKiyxyaJ+ARUVJU9Pp2Jsanc7sR0uVzyKEuXhfVTUEi4XMHBUlCgFBIsExQkBbnlDXbLBLnlDQqQNzhAXrdL3uAAeYJc8gZJJtAlT5BLJlDyBElet2QCJW+Q5A2UjFsyQZI30Jz4222kQCMT5JUr0CjA7ZE7yKsAt1fBQR6FBGYpyO1RaGCmQtweVQnMVJg7Q2HuDIUHZirCnaawgEyFu9MUGXBcVVwZighIU3hAhiICMhTh8ig8IECeo4E6++LtysjIOKN+mYDK4ERs8uiykL4KCq4iV0iIFBQkBZ/4Y4LcMsGB8ga5ZbJjU2CAvEGu/8Um1/9ik+QN/F+scp+ISdmxyRt4IladiFdGxm1kAo1MkJEr0CtXoFcB//sTFOhVSFCWggL+F5sCsxQWmKUqgRkKDchUFXeGItzpCvvf31UC0hXhSlekOztGpSsyIEtVXFK4K1DeY0GKb7WF+ARUQNa1U2iEXEFBUkiQFBQsExQoExwoExwgE+g+EZuCTvzxBLlOxKNg1/9ikCsnHrn1v2uq/8Uot6Ts2BRk5A2QFOSVCTS+2OQO9Mod6FFwkEfBbo+CA7MU4s6OTZkKCchUeGCGwt3pquI+8XdYQIYiA44rMiBdYa50RQWkKyIgQ2EuryID3Mo86ubaCaigfLEppG9ObAoOkkKCpcDs2OSW93+xyQQFyBMY8L+Y5Mr5O1DyBrl810rewPy+25n/LZ+IUSbQyBXklcv9v/gU5FFwoFdBgR4Fu/8Xm4IyFRaYpVB3pqoEZKhKYIaqBGQoPDBNVQIyFRGQ9r/vdP+7hgpIV5UAjyJcUhjXTkCFlh2fOoUPUGD2d7vgQCkwSCbkf/EpMOBE7ikwQJ7s66fAE9/rfDHJLzZ5A7NzTf/LQwXJ930uO++kICMFnsg3uYM8cmfnndweBQVmKSwwOzZlKcydrgh3pkLdOddPJ2JT+onYFHBcEQEZCndlKiLAqyoutzxHA9Xk4j/PuNhETUwAAAAAAAAAjlZud2IGBwcrLi5Oy3bPlY6X1yhOn7i4OAUHB5f3MACcopzY9KGULimlvEdU+ohPQMXEtRMAJ8pz7VQJEZ+Aiik7Pn21O1E6Vt6jKX1nYmwqt5qYkpSWlqaMjIzyOvxpdSYWWAUqi8ocmyTiE1CRVeb4RGwCKq7KHJsk4hNQkVXm+HQmxqZyTWICAAAAAAAAwMmU23TybgEDrHZAZGTOcrUYq88cth9Jf+XyLb7liT90sfq6NP3dar9Qd7Fvue03I62+zAz79GtXP2y19x+t4lte0eZf9muN12qn5soF/5xRw+q7ptHPAlAx5IlN4eG5GoWXEe62codv+eOHulp9yZe47f1muHzLd9/4kdX32Z4WVjs4wH6a3g/rG/qWr7zIji8e47La54Xv9C2vPVrP6nuz9XQBqBj8Y5M7KiqnERxkb5yRaTV3v13btxwdlmb1BQbY1zNuV0573+wGVp/Xb7aSCbDjjTst51po2ZOTrb5UY49ppycnJv6RaV83Xdd4tQBUHP7x6VRk9GztWw5e8L3Vt/2htlY7+o+c+LRi4utW3zP7mlrtaoFHrfbzP3b3LdeuYX/nq1nFrh0U6s657tp4MNbq++GqcQJQMeS5dqpVM6eRZX+/8uw/YLUD4+v7lr0xEVZfVox956Nx5VwPBX1n56NMul1jw3jtewhdua6lJm5aZvUd8NrHyTQ5+auFR86z+iZcMFdnCh7sAwAAAAAAAMDRSGICAAAAAAAAcLRym06ee/q4JHlTcm7jD4itbvW5ck/nlDT5pyt8yw+1nm/1XR+52Wo/uquzb7lqRKrVFxls39r7+9Y4q121es40hA+Pxlt9Gabgt65j2KYC+wA4W4BfvPEey3mMnTV9Mx/Tp/X0LVdVViFbSnIV3BUge5pBgMv4b1AsAS7vyTcC4Ej+8cdz5EiBfQqyr1E83oB8l6W88SUgV3DyDz15FNJfJcCee+72K3UR6c25BosMqISPWgdQYoXFoEzj8Wu7/doFf1fzL73jNXZczMrV9vL0CKDCsqaPS/Ik78lpBLgL37ZGzrVVZrQ9rTsj2i++5AopQX6PnPHfr0mzy/q4cj2U59zgKlbfQY+dv8rMdeG1LWynzlTciQkAAAAAAADA0UhiAgAAAAAAAHC0Yk8n37lzp/773/9qz5498nrtKYpjxow56ev9n0Ceewp51h9brD7/aVJ3XPCbb3n8yqusvpXN7KdBTaq30Lfcdqv9dPI9GfZ+4+IOWe1DuZ5O3jdiq9V32GtPYcj9XNDv0u1bhpsLQFkpaWzyfwJ57viTe/qmlLcsRu7ZSC6/+UfBLQ5Z7czVVXP6XPbU88417Dh2Tsguq/3d7w1VkBC/J5kH5dp3ENPJgXJVovjk9wTyU4lNx9NyXus/fTzQ7fd08oBC4oTftEpXIfPJU70ZVvuo39PJU3JN9UzxhhV8TACnXYmvnU4T4196p5BSPF6/To9f2xWQE6+M/3Ry+U8vdxW4LYCyVaL45PcEcmsKuV8+Rx677fLkxAz/73X+7dwhxGT6HdNvv/LvD8rp9y+TkWbs883dW1jJjMquWGc+ffp03XbbbQoODlb16tXlyvVIeZfLVa7/2AE4cxGbADgV8QmAExGbADgV8Qn5KVYS87HHHtPjjz+uhx9+WAEBzEgH4AzEJgBORXwC4ETEJgBORXxCfor1m5CamqpBgwbxiwTAUYhNAJyK+ATAiYhNAJyK+IT8FOtOzOHDhysxMVEPPfRQsQ9sDtv1m1zh4b5l/xqY/rWefj1W27ec1PNfVt/duy622h0n3udbPn62XY/JlW5/GEJjD1rtjB05Y1qQGmf1VXcftdq7s2J8yxvS7G2vFYCyUBqxqTD+dea8KSl2f+4ScH4llLK+r2pvm6vEySFPFatvfrJdSfdL9zn2zjJzYteRzFCrKyjArqWSlB7rWz7mCRaA8lHi+JRhX8MoKOcS7qSxKVctuIDCal5KcuWumelf8snvpSag4H7/GpjH/OpHpXiDc/WFFDomAKfP6b52KgmXf9ndXG2v/GrF+QUkr387w52rr+AamP5tamIC5aek8cmz/4DVdtfK9ewSv1qVnn37rXZgeM73syC/WpwuY9fyNrmnuYfa1zT++80jNdW3uCkz3era642w2rnj2uY0+zksZ5JiJTHHjx+vq6++WvPnz9f555+voCC72PxLL71UKoMDgFNBbALgVMQnAE5EbALgVMQn5KfYScwFCxaoadOmkpSnwCoAlAdiEwCnIj4BcCJiEwCnIj4hP8VKYr744ot66623NHTo0FIeDgAUH7EJgFMRnwA4EbEJgFMRn5CfYiUxQ0JC1L59+xId+MrlW6z25J+u8C3fccFvVl/uGpiStK3NMd9yr3q9rD6Taddgql9lh2+52dxtVl+Qy66DkPjrRfYgc5U++GBvK6vrplorrPbHey/0LV8akyQAZa80YlO3lTus9vRpPX3L/vXfrBqYkuIm58SFA7e0tfqitti1VKL+OO5b/mfLjoWOKX23XTMz8FjOQL7ZkmBv7Fe7yZORs21AoF9Bu0sKPSyAUlTS+LT7bftayOPN+WwfT7OnV+WugSlJ8QN/9i27q1ez+lzBfrVy3Tl14zaM9huEX326gCy7nVUlZ4Ondl9h9R3JKrju5Z9H7ZrBN51V4KYASllpXDtl9Gxd7NcGz/8uZz897Gcb1PrOrg8X/O0G33K3WwZafdt/q2W1TbB9zRPzc87X3syAWKtvaxW7nVY9J5ZFbvEb8DUCUEZKGp8C4+tbbU+NnGevuDz2RU3uGpiSlLX1T9+yu6p9nRKUGlPwQevb12sBh+1nqSjE77rreJpvccXxRlbXviy75nnu2r8/HapX8BgquWI95umuu+7SlClTSnssAFAixCYATkV8AuBExCYATkV8Qn6KdSfmt99+qy+//FKfffaZmjdvnqfA6gcffFAqgwOAU0FsAuBUxCcATkRsAuBUxCfkp1hJzJiYGF133XUlOvDEH7pY7Ydaz/ctj195ldWX1PNfVjv3FPKs7fbUT3esPR3AHDpS4BhSvfatvJ59flOdauTMFU3Lsj8wOzLt6VgZnpy3sl7w/gKPCeD0KY3Y9PFDXa12VeXMl3R5/eZS+tWTzj2FvNpbK62+3fe0s9rHq4f7lse2mGP17c2KstrNLtputbuE5ZTCuG+XXQYj07itdt2QQ77lHekxAlA+ShqfosPSrHbu6eQBLjs2BQTY0yhzTyH37D9g90XZ8cY6RhW/EhReO+gZv+nk3rCc7b1+ATLLa8cm/zEDKB+lce0UvOD7Yr829xRy//1sf9i+doqp3ty3/P65L1h946rZ3y2rB9tTOGdH5dTQiYw4bvXVDE+12iHunOC2tYk9jRRA2SlpfPLGRFjtzOhQ37L/97ogr9+1U64p5J6DB+2+AL8vgbkeMpR1tj3N2z/h5g3zKwEUmpOTSkq3c1kHMsOttidX2bC9x+xzO5MUK4k5bdq00h4HAJQYsQmAUxGfADgRsQmAUxGfkJ9i1cSUpKysLC1evFj//Oc/lZKSIknauXOnjh49epJXAsDpQ2wC4FTEJwBORGwC4FTEJ/gr1p2YW7duVc+ePbVt2zalp6erW7duioyM1LPPPqv09HS9/vrrpT1OADgpYhMApyI+AXAiYhMApyI+IT/FSmLedddduvjii7VmzRpVr17dt75v374aOXJkkfbRpenvVvv6yM2+5ZXN7L67d11stU1mpm/ZvwamZ+9eq5271tPcFZdYfa4su5ZBt3ZrrHZMUE69lBZV/rT6Xvzdrpv3QNOFvuWZO+36LYOaCEAZKI3YlHyJu8C+4BaHrHbW93adpKgtObVU/Gtgxk1cYbW3PZ7T/+b2DlbfvqN2/ZNMjz2mrKycm+jT94cVOF5JqlLzmG85Ndne7ysX+W8N4HQpaXwK9KtzmbumZKDb67+5xRWcU2/Jvwam54hdO9wVklMf3LjtelEuvxJQxvitCMjZ/rjHrvmUmmXXIQ9w5Yw5LatYl6MASkFpXDttf6it1c5d8tY/TPiXw631XXrOfvxqYNYbb1877fxbTv+A9TfbfRvs74T+dcsD0nNWBK4PtfoOu+zruf3tc75r1vjajmXqKwBlpKTxKSvG/qxnROdcb/jXxHQZ+ztVUGqMb9m/BqZ/fXHrGK0b2Sv8Lp48Ifb3OndoTozZdtyORYcyqljtrFz10A+nFP4dsDIr1lXj119/rRUrVig42L4gTUhI0I4dOwp4FQCcXsQmAE5FfALgRMQmAE5FfEJ+ilUT0+v1yuPx5Fm/fft2RUZGlnhQAFAcxCYATkV8AuBExCYATkV8Qn6KlcTs3r27Jk2a5Gu7XC4dPXpUY8eO1VVXXVVaYwOAU0JsAuBUxCcATkRsAuBUxCfkp1jTyV988UX16NFDzZo1U1pamgYPHqyNGzeqRo0amjNnTpH28ULdxVb70V2dfcuT6i20+jpOvM9q16+Sc+uwOWTXciq01lNkpuyN7ToIEe50q+3NVcTl/BD7duXWcdus9vkhO33L+4/btQsAlI3SiE0BGf7Fm3IWM1fbdUr8StQp6o+cOrrHq9v1J3PXwJSkBk/l1Hk68NnZVt+RI3aNk+YNdlntX1c19C1XPceuyeJfoy53Pc3IOikCUD5KGp/cLr+amLmCk9svGLn8i865C671m7sGpiSZ9FzXQi7/je2mf607K1567WN687w45//R89TWBFBmSuPaKfqPQury+n+8/cJT8LcbfMsx1ZtbfblrYEpSnedzrp063pRm9c1OaW21w0IyrHbm1zn19A42s8frifAbf67moaYCUE5KGp+MfzFvVwHL+W1rve4UrlNOtmkh/V4T4Nfm+ig/xUpi1qtXT2vWrNG7776rNWvW6OjRoxo+fLhuvPFGhYWduQVGAZQvYhMApyI+AXAiYhMApyI+IT/FSmIuW7ZM7dq104033qgbb7zRtz4rK0vLli3TZZddVmoDBICiIjYBcCriEwAnIjYBcCriE/LjMsaYk29mc7vd2rVrl2rWrGmt379/v2rWrJlv8VV/53zwpNWuGpHqWz541J6OfXy/nWXv3/r7Avc7d8Ul9opcU8jPGvKj1eWOjbW3zcqy27nOo9+qDVZXaIA9NT3FE+pbfuGnblbfH4MeLXC8AEpPacSm13/vVGBfsMuOEYc8dqz65/qOvuWxLT6z+t7c3sF+7fGcuFbtaju+HOvfxmqHb0u12knXRfiWM2P8zinInhIVlpTzNL/jDey4tXXEAwJQNkoany4a+ZLV9p8xbvHrO3ROzrKnih0jjF9pndzTnM6+/Vury79kjwIKnuYU8Zn9/+QZHrudkpkzjX3vUbv8xrreTxW4XwClqzSunby7z7Lamabg13hlx6Bu6wb6lt89d5bVN2D9zVa7Z531vuWvW4RafYF161htc+yY1d4xLGeqetXf/UqM+YWyoKM513uZEXbsWvYp105AWSlpfOoROdRekSv1ZTLt73WuULu8jqt+bd9yVoydj8qItp+WnjuGhHz+ndXlrmqXIzPHj1ttV647SmevnWf1HfDa8TIj13TzBceaWX33nrtIZ4piPdjHGCNXPnUB9u/fr/Dw8HxeAQCnH7EJgFMRnwA4EbEJgFMRn5CfU5pOft1110k68VSooUOHKiRXMXiPx6O1a9eqXbt2Bb0cAE4LYhMApyI+AXAiYhMApyI+oTCnlMSMjo6WdCIjHhkZaRVTDQ4O1qWXXqqRI0eW7ggB4CSITQCcivgEwImITQCciviEwpxSEnPatGmSpISEBN1///0luoU3M8M+dGRwum95T4Zdc8mVbs96D3Ll1D5I9dr1CFxZfrcb56r15F8D07N3r9UOiIy09xUclDNe47b6Ylx2jboDJqdGnSe1WM9LAlBMpRmbPtvTwmoH5Cou17nG71bf/OTmKsjeLDuO7fOr+XbkSM4/xiH+NTDfX2W1s65oZbWr7MiJc8dkxyYF2O2siFwxMMVvWwCnXWnFJ7/LHZt/WUtvIf1e+zopzyytXG3/GpieI0esdkAVuy6w3Dkx5nC6X/0orx1/jmXknFBaWpAAlK3SvHZ6Zl9Tq537e5PXr+Ckx9jf67b/Vsu3PK5aF6tv5wb7u9vslNa+5UZ191t9WTt2Wu3A2nFWO2xPTmAM23HU6jMB9pi8VYJybWvX1gRw+pVWfDLp6VbbXStXbU2/epqefXZMCTicEyfyZHfymeLuO4ZfDUzPwYP2fkNDC+zfmmVfK+3xRFttb65qkH+mVStwDJVdsWpiPvDAA1Ztgq1bt2rSpElauHBhqQ0MAE4VsQmAUxGfADgRsQmAUxGfkJ9iJTH79OmjmTNnSpIOHTqkSy65RC+++KL69Omj1157rVQHCABFRWwC4FTEJwBORGwC4FTEJ+SnWEnMH3/8UR07dpQkvf/++4qLi9PWrVs1c+ZMvfzyy6U6QAAoKmITAKciPgFwImITAKciPiE/xSremJqaqsj/1Y9cuHChrrvuOgUEBOjSSy/V1q1bi7SP2tUPW+3ft+bULYmLO2T1hcbadQQSf73It+zZF2L1dWu3xmpHuHPqIPyaZdcU8K+B6U1JsdqB9er6lmPcdg3M/Z4Iqx3tzqmXEriP2k5AeSiN2BQckGW1A1w5xeTOCdll9X3pPsdqp+/OqQ/X7KLtVl+mx65x0rxBzr7St9k1n/xrYAZ++YPVdjdpm7NtrQyrz79ES+DOnLpznmqZAlA+ShqfTIDfhztXnUuXX1FMv5Jzyh3WjB3iZIy9X6vpd0z/GpjeVPvayKo1dRK5YyuA8lMa107VAu0ak5km5yumx68mptcvQJngnFqV1YPt/fi9VGEhOdc85phdq9K/BmbWrt32cdwNfcupDfy+AwbZBwo6mlMrL61GYQWJAZxOJb528vpdH6Wl5TQy/S6I/IXkfPa9YXZ+xxPi95yB3PXEjx+3uvxrYHpzj8GvPzrA/q7mkR3nctcbjgq093MmKdadmE2aNNFHH32kP//8UwsWLFD37t0lSXv27FGUXxF4ACgrxCYATkV8AuBExCYATkV8Qn6KlcR8/PHHdf/99yshIUFt2rRR27Yn7gpauHChWrZsWaoDBICiIjYBcCriEwAnIjYBcCriE/JTrOnk/fv3V4cOHbRr1y5dcMEFvvVdunRR3759S21wAHAqiE0AnIr4BMCJiE0AnIr4hPwUK4k5bdo0DRo0SHFxdu2RSy65pMj72H/UrqtUtXpODZRDfn0ZO8LtF3tzLdew68HFBNk1CLy5izt5PFafK9iubZC7BqYkZW3f4Vt+et1VVl/mBvv2ZW+DnJoE9/T+zB6v7hWA0680YtMP6xvaK3Ldr/7d7359mfbN7IHHctpdwux4k5Vlb/vrqpx9ua6zd1tlh12bKXcNTEmqMXWlb/lolxb2GALt43qa5MTIYL/adwDKTknjkzut6DUkXV67nVUl57XeML/OAL/9FhYm3HYNKP8amJ7kPb7lIHftQseY5sq5BHW7qY8JlJfSuHZ6/sfuBfa5/GKMN8OOIzE/58SC2VH2MQPS7YCU+XV13/KOYdWtvrA9dmzLXQNTkmJm5lw7bZp4qT2mEL+4mOuRCwGHizVxEUApKGl8cvnV9nblrk8ZZH9nkl+dbx3Pye8EhNq1cd2hBT8DxRUWZrU9B+3nuxRWI/Ow197vfo+dB8tUTvw8mGXnzM4kxYrKDz30kGrVqqXhw4drxYoVpT0mACgWYhMApyI+AXAiYhMApyI+IT/FSmLu2LFDM2bM0L59+9S5c2edc845evbZZ7V79+6TvxgAThNiEwCnIj4BcCJiEwCnIj4hPy5jTInm8CQnJ+vtt9/WjBkz9Ntvv6lnz54aPny4rrnmGgUEFJwjPbizntX+8Gi8b7lvxFarb0GqffvwB3tb+ZbTsuxbbgfEfW+1zw/JmRL+3fEEqy/3I+olKcZt30Kcewp5vX6/WH1uv6dhmQZ1chp+p73gp6cFoGwVNzb99YebinyMI5n2dIBvtiT4lvs0XWv1ffDtxVa7at3DvuWDO6OtvsBDdmzKqmWXzQiukulbTrjePo7/FIWUXjn1YyLnrbH6FqTOEoCyV5z4dHRnvNWuEpAztSnVa8eIoybTaj+1+wrfstdvvvhxj30dlenNiT8ZXjsWHU63p0j5C3LnTM3K7LzL6nPH2HHOFZ4zRcpUsePW/N+fLfQ4AE6P4l47tVv4oNX25CpfY/xK2Xj92plfxOY0uh2w+gI/rmq1DzbL+dpa70t7KmjYjqNWO7VBpNXefkXO+Jvc840K447NGZNn716rb5E3sdDXAjg9ihOfftlmlws8NzhnCnamsWPIpsx0q73ieCPfclJ6rNW37bgdm7wm5/hT6n9u9W3Nsq+logPsa7TcU8gfbNjG6guo4jdlPHdZn8b1ra4FPz6pM0WJi3zUqlVLHTp0UNu2bRUQEKCff/5ZQ4YMUePGjbV06dJSGCIAnDpiEwCnIj4BcCJiEwCnIj4hW7GTmMnJyXrhhRfUvHlzde7cWUeOHNFnn32mpKQk7dixQwMHDtSQIUNKc6wAcFLEJgBORXwC4ETEJgBORXyCv2IlMa+55hrVr19f06dP18iRI7Vjxw7NmTNHXbt2lSSFh4frvvvu059//lmqgwWAwhCbADgV8QmAExGbADgV8Qn5CSzOi2rWrKmvvvpKbdu2LXCb2NhYJSUlFdifabxWO8PkDOWw165PUN1t1zi5qVbOk6l2ZFaz+l78vavVbh23zbd8WfQGqy/GZdfA3O+JsMe4IafupX8NTM+RI1Y7cF9OnSjjsc8NQNkojdjk8avVlFtIQJbVDgqwY5Vyvda/5q4/q0ZUkF/MCLBf6/IbUmBgznH9a2B609IKPS6A8lHS+JTqV+fSnSuG+NfAPOa1y50fyQrxLWf51blMzQq22rlrZgbI3o9/jczC+NfA9Bw6bLUDo3Ouq1xZfrEUQJkpjWunmlVSrHbu+nD+dXj9a2JurZJTa65muP3d7LDLrjvnich1veR3bWT8auJ5g/yOG3IK388CCr4WBFB2ShqfDnjt70kHPTkxJs0vH7XXa+eC9mXl1NU9kBlu9R3KsGtV5o5rB7z2fvd4/K6HdMxq7/fk7Nu/BqY31Y6Jub8UulPtGp5nklO6E3PlypX67LPP9Oabb/p+kWbOnKmGDRuqZs2auvXWW5WefuLNdLlcio+PL2x3AFAqiE0AnIr4BMCJiE0AnIr4hMKcUhLzqaee0i+/5Dyl++eff9bw4cPVtWtXPfTQQ/r00081fvz4Uh8kABSG2ATAqYhPAJyI2ATAqYhPKMwpJTF/+ukndenSxdf+97//rTZt2uiNN97Qvffeq5dfflnvvfdeqQ8SAApDbALgVMQnAE5EbALgVMQnFOaUamIePHhQtWrV8rW/+uorXXnllb5269ati1xUNdWYAvuC/Nq7s2Ks9sd7L/QtZ3jsU3ig6UKrfX7ITt/y16lNrL4Dxq57EO226xN4G+TUljMN6lh9uWtgSlLW7mTfsruqXb8FwOlVmrHpvPCdBfYFueyamEnpsVbbk5Hz/0J1Qw5ZfVVq2vEl05NTWy4sya5JlxVhx8fAnXa/p0mGbzml1wUFjleSwueu8i0f7dum0G0BlL7Sik87PXY9ykhvTi2kFGNfC6V47ZiRW4DL+LX96sTlqmWXkhlidR3LsPfrv680V844qoXb+81dA1OSsrbmnHNgvboFjhfA6VGa106hbvv6KCt3TUxTeE3MtOo5cSTEbz/729v1fpUrrAQdtWvpeqvY3yD9+5UrnLlj7es3/xqYnuQ9OdvWqC4AZau04lOm3/VRZq5a3/7VuHPX8pUkT662/zMTsrwF3wuY4bcfr999g/7PTchUrrbbr/a4/4MRcufQvGfuc1hO6U7MWrVq+YqmZmRk6Mcff9Sll17q609JSVFQkH8KEgBOL2ITAKciPgFwImITAKciPqEwp5TEvOqqq/TQQw/p66+/1sMPP6wqVaqoY8eOvv61a9eqcePGpT5IACgMsQmAUxGfADgRsQmAUxGfUJhTmk7+9NNP67rrrlOnTp0UERGhGTNmKDg4Z2rRW2+9pe7duxdpXz9n1LDaHcM2+Za/S69p9W1Ii7Pal8Yk+ZbrBe+3+mbubGe19x/PeUz93oORVp8n1T79wH12Nv+e3p/5lj8LaG/1GY99+27uKeSegwcFoOyUZmxae7Se1c491TLIb9rlMY/f1MrAnP4d6TFWX2pyuNWOrJOSs58G9nQpd4o9lcBTze4PzjWlIXLeGhUm9xTyKh+uKmRLAKdDacWnPzLt66bIgOO+5RSvXeLmmNeeBv7n0YLL3KRl2ddCJld8Sc2wr4vS0gq/68HtzpnmVLWKPdXclWVP3Mo9hTxr+45C9wug9JXmtdPGg/b0bG+uj7/xm4bp347ckrO8tYkdq2p8bcecQ01zljMj7P2E7bDL9qTV8LtGO5xraujevSpM7inknn37C9kSwOlQWvFp4ZHzrPa2sJyyYf5TzTen2Tmonw7lfCfce8wuQ3g4xb7uym1BzWZW+8+0alY7KjDNah/MyslXqXF9q8+dmm61c08h92xK0pnqlJKYNWrU0LJly3T48GFFRETI7TdnPzExUREREQW8GgBOD2ITAKciPgFwImITAKciPqEwp5TEzBYdHZ3v+mrVquW7HgDKArEJgFMRnwA4EbEJgFMRn5CfU6qJCQAAAAAAAABlzWWMMSffDAAAAAAAAADKB3diAgAAAAAAAHA0kpgAAAAAAAAAHI0kJgAAAAAAAABHI4kJAAAAAAAAwNFIYgIAAAAAAABwNJKYAAAAAAAAABzNUUnMvXv36vbbb1eDBg0UEhKiuLg49ejRQ8uXLy/xvocOHaprr7225IMEcMYhNgFwKuITACciNgFwImJTxRdY3gPIrV+/fsrIyNCMGTPUqFEjJScn6z//+Y/2799f3kMDcAYjNgFwKuITACciNgFwImJTJWAc4uDBg0aSWbp0ab79w4YNM7169bLWZWRkmNjYWPOvf/3LGGNMYmKiOe+880xoaKipVq2a6dKlizl69KgZO3askWT9WbJkiTHGmG3btpkBAwaY6OhoU7VqVdO7d2+TlJTkO8aQIUNMnz59zLhx40zNmjVNdHS0efLJJ01mZqa5//77TdWqVU3dunXNW2+9dVreFwDli9gEwKmITwCciNgEwImITZWDY5KYmZmZJiIiwtx9990mLS0tT//y5cuN2+02O3fu9K374IMPTHh4uElJSTE7d+40gYGB5qWXXjJJSUlm7dq15tVXXzUpKSkmJSXFDBw40PTs2dPs2rXL7Nq1y6Snp5uMjAxz7rnnmltuucWsXbvWrF+/3gwePNg0bdrUpKenG2NO/EJFRkaaUaNGmd9++828+eabRpLp0aOHGTdunNmwYYN5+umnTVBQkPnzzz/L7P0CUDaITQCcivgEwImITQCciNhUOTgmiWmMMe+//76pWrWqCQ0NNe3atTMPP/ywWbNmja+/WbNm5tlnn/W1r7nmGjN06FBjjDE//PCDkWS2bNmS776zs9u5zZo1yzRt2tR4vV7fuvT0dBMWFmYWLFjge118fLzxeDy+bZo2bWo6duzoa2dlZZnw8HAzZ86c4p88AMciNgFwKuITACciNgFwImJTxeeoB/v069dPO3fu1CeffKKePXtq6dKluuiiizR9+nRJ0ogRIzRt2jRJUnJysr744gvdcsstkqQLLrhAXbp00fnnn68BAwbojTfe0MGDBws93po1a7Rp0yZFRkYqIiJCERERqlatmtLS0rR582bfds2bN1dAQM5bVatWLZ1//vm+ttvtVvXq1bVnz57SeisAOAixCYBTEZ8AOBGxCYATEZsqPkclMSUpNDRU3bp102OPPaYVK1Zo6NChGjt2rCTp5ptv1h9//KGVK1fq7bffVsOGDdWxY0dJJ36oixYt0hdffKFmzZppypQpatq0qZKSkgo81tGjR9WqVSv99NNP1p8NGzZo8ODBvu2CgoKs17lcrnzXeb3e0nobADgMsQmAUxGfADgRsQmAExGbKjbHJTH9NWvWTMeOHZMkVa9eXddee62mTZum6dOna9iwYda2LpdL7du315NPPqnVq1crODhYH374oSQpODhYHo/H2v6iiy7Sxo0bVbNmTTVp0sT6Ex0dXTYnCKBCIjYBcCriEwAnIjYBcCJiU8XimCTm/v37dcUVV+jtt9/W2rVrlZSUpMTERD333HPq06ePb7sRI0ZoxowZ+vXXXzVkyBDf+lWrVumZZ57R999/r23btumDDz7Q3r17de6550qSEhIStHbtWv3+++/at2+fMjMzdeONN6pGjRrq06ePvv76ayUlJWnp0qUaM2aMtm/fXubvAQDnITYBcCriEwAnIjYBcCJiU+UQWN4DyBYREaE2bdpo4sSJ2rx5szIzM1W/fn2NHDlSjzzyiG+7rl27qnbt2mrevLnq1KnjWx8VFaVly5Zp0qRJOnLkiOLj4/Xiiy/qyiuvlCSNHDlSS5cu1cUXX6yjR49qyZIl6ty5s5YtW6YHH3xQ1113nVJSUlS3bl116dJFUVFRZf4eAHAeYhMApyI+AXAiYhMAJyI2VQ4uY4wp70GciqNHj6pu3bqaNm2arrvuuvIeDgBIIjYBcC7iEwAnIjYBcCJik7M55k7Mk/F6vdq3b59efPFFxcTEqHfv3uU9JAAgNgFwLOITACciNgFwImJTxVBhkpjbtm1Tw4YNVa9ePU2fPl2BgRVm6AAqMWITAKciPgFwImITACciNlUMFW46OQAAAAAAAIAzi2OeTg4AAAAAAAAA+SGJCQAAAAAAAMDRSGICAAAAAAAAcDSSmAAAAAAAAAAcjSQmAAAAAAAAAEcjiQkAAAAAAADA0UhiAgAAAAAAAHA0kpgAAAAAAAAAHI0kJgAAAAAAAABH+39GM1i60uAozwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from sklearn.metrics import silhouette_score\n", - "A_type = [A_dmd, A_cs, As, As_n4sid]\n", - "B_type = [A_dmd, B_cs, Bs, Bs_n4sid]\n", - "names = ['DMD, Partially Observed', 'DMDc, Partially Observed', 'Old Subspace DMDc, Partially Observed', 'Subspace DMDc, Partially Observed']\n", - "for Ai, Bi, name in zip(A_type, B_type, names):\n", - "\n", - " sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate = compare_systems_full(Ai,Bi)\n", - "\n", - " fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", - " \n", - " # Define data and titles for each subplot\n", - " sims_data = [sims_full, sims_state_joint, sims_control_joint, sims_state_separate, sims_control_separate]\n", - " titles = ['Joint', \n", - " f'State (Joint) \\n {np.round(silhouette_score(sims_state_joint,state_labels,metric=\"precomputed\"),2)}',\n", - " f'Control (Joint) \\n {np.round(silhouette_score(sims_control_joint,control_labels,metric=\"precomputed\"),2)}',\n", - " f'State (Separate) \\n {np.round(silhouette_score(sims_state_separate,state_labels,metric=\"precomputed\"),2)}',\n", - " f'Control (Separate) \\n {np.round(silhouette_score(sims_control_separate,control_labels,metric=\"precomputed\"),2)}']\n", - " \n", - " # Loop through all subplots\n", - " for i, (data, title) in enumerate(zip(sims_data, titles)):\n", - " im = ax[i].imshow(data)\n", - " cbar = plt.colorbar(im, ax=ax[i], shrink=0.2, location='top')#, label='Distance')\n", - " cbar.ax.tick_params(labelsize=10)\n", - " cbar.ax.spines['top'].set_visible(False)\n", - " cbar.ax.spines['right'].set_visible(False)\n", - " cbar.ax.spines['bottom'].set_visible(False)\n", - " cbar.ax.spines['left'].set_visible(False)\n", - " ax[i].set_title(title,y=1.8)\n", - " #loop through all of them and remove x and yticks, then add System as text label for each\n", - " for i in range(5):\n", - " ax[i].set_xticks([])\n", - " ax[i].set_yticks([])\n", - " # ax[i].text(0.5, -0.1, 'System', transform=ax[i].transAxes, ha='center', va='top')\n", - " ax[i].set_ylabel('System')\n", - " ax[i].set_xlabel('System')\n", - " ax[i].spines['top'].set_visible(False)\n", - " ax[i].spines['right'].set_visible(False)\n", - " ax[i].spines['bottom'].set_visible(False)\n", - " ax[i].spines['left'].set_visible(False)\n", - " plt.suptitle(name,y=1.1)\n", - " plt.tight_layout()\n", - " # plt.savefig(f'{folder_path}/{name}.eps', format='eps', dpi=300, bbox_inches='tight')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "2b529073", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:00<00:00, 523.63it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 110.19it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 474.72it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 133.29it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 594.62it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 95.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Silhouette Scores:\n", - "DMD State: 0.132\n", - "DMDc State: 0.143\n", - "DMDc Control: 0.002\n", - "SubspaceDMDc State: 0.669\n", - "SubspaceDMDc Control: 0.521\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Get the similarity matrices for each method\n", - "sims_full_dmd, sims_control_joint_dmd, sims_state_joint_dmd, sims_control_separate_dmd, sims_state_separate_dmd = compare_systems_full(A_dmd, A_dmd)\n", - "sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc = compare_systems_full(A_cs, B_cs)\n", - "sims_full_subdmdc, sims_control_joint_subdmdc, sims_state_joint_subdmdc, sims_control_separate_subdmdc, sims_state_separate_subdmdc = compare_systems_full(As_n4sid, Bs_n4sid)\n", - "\n", - "# Print silhouette scores\n", - "print(\"Silhouette Scores:\")\n", - "print(f\"DMD State: {np.round(silhouette_score(sims_state_separate_dmd, state_labels, metric='precomputed'), 3)}\")\n", - "print(f\"DMDc State: {np.round(silhouette_score(sims_state_separate_dmdc, state_labels, metric='precomputed'), 3)}\")\n", - "print(f\"DMDc Control: {np.round(silhouette_score(sims_control_joint_dmdc, control_labels, metric='precomputed'), 3)}\")\n", - "print(f\"SubspaceDMDc State: {np.round(silhouette_score(sims_state_separate_subdmdc, state_labels, metric='precomputed'), 3)}\")\n", - "print(f\"SubspaceDMDc Control: {np.round(silhouette_score(sims_control_joint_subdmdc, control_labels, metric='precomputed'), 3)}\")\n", - "\n", - "# Create 2x3 subplot\n", - "fig, axes = plt.subplots(2, 3, figsize=(6, 5))\n", - "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", - "\n", - "# Column headers (bold)\n", - "column_headers = ['DMD', 'DMDc', 'SubspaceDMDc']\n", - "for i, header in enumerate(column_headers):\n", - " axes[0, i].text(0.5, 1.75, header, transform=axes[0, i].transAxes, ha='center', va='bottom', fontweight='bold', fontsize=16)\n", - "\n", - "# Row headers\n", - "row_headers = ['State DSA', ['Not Available', 'Input DSA', 'Input DSA']]\n", - "for i in range(3):\n", - " axes[0, i].text(0.5, 1.55, 'State DSA', transform=axes[0, i].transAxes, ha='center', va='bottom', fontsize=12)\n", - "\n", - "axes[1, 0].text(0.5, 1.55, 'Not Available', transform=axes[1, 0].transAxes, ha='center', va='bottom', fontsize=12)\n", - "axes[1, 1].text(0.5, 1.55, 'Input DSA', transform=axes[1, 1].transAxes, ha='center', va='bottom', fontsize=12)\n", - "axes[1, 2].text(0.5, 1.55, 'Input DSA', transform=axes[1, 2].transAxes, ha='center', va='bottom', fontsize=12)\n", - "\n", - "# Data for each subplot\n", - "data_matrices = [\n", - " sims_state_separate_dmd, # top left\n", - " sims_state_separate_dmdc, # top middle \n", - " sims_state_separate_subdmdc, # top right\n", - " None, # bottom left (gray matrix)\n", - " sims_control_joint_dmdc, # bottom middle\n", - " sims_control_joint_subdmdc # bottom right\n", - "]\n", - "\n", - "# Create gray matrix for bottom left - use same size as other matrices\n", - "matrix_size = sims_state_separate_dmd.shape[0]\n", - "gray_matrix = np.ones((matrix_size, matrix_size)) * 0.5\n", - "\n", - "# Plot each subplot\n", - "for idx, (ax, data) in enumerate(zip(axes.flat, data_matrices)):\n", - " row = idx // 3\n", - " col = idx % 3\n", - " \n", - " if idx == 3: # Bottom left - gray matrix with diagonal lines\n", - " im = ax.imshow(gray_matrix, cmap='gray', vmin=0, vmax=1, extent=[-0.5, matrix_size-0.5, matrix_size-0.5, -0.5])\n", - " \n", - " # Add diagonal lines from bottom-left to top-right\n", - " for i in range(matrix_size):\n", - " for j in range(matrix_size):\n", - " ax.plot([j-0.5, j+0.5], [i-0.5, i+0.5], 'k--', linewidth=1)\n", - " \n", - " # Set axis limits to match other plots\n", - " ax.set_xlim(-0.5, matrix_size-0.5)\n", - " ax.set_ylim(matrix_size-0.5, -0.5)\n", - " \n", - " # Remove ticks and labels\n", - " ax.set_xticks([])\n", - " ax.set_yticks([])\n", - " ax.set_xlabel('')\n", - " ax.set_ylabel('')\n", - " \n", - " # Remove spines\n", - " for spine in ax.spines.values():\n", - " spine.set_visible(False)\n", - " \n", - " else:\n", - " im = ax.imshow(data, cmap='viridis')\n", - " \n", - " # Add colorbar on top with only 2 ticks\n", - " cbar = plt.colorbar(im, ax=ax, shrink=0.4, location='top', pad=0.02)\n", - " vmin, vmax = data.min(), data.max()\n", - " cbar.set_ticks([vmin, vmax])\n", - " cbar.set_ticklabels([f'{vmin:.2g}', f'{vmax:.2g}'])\n", - " cbar.ax.tick_params(labelsize=10)\n", - " \n", - " # Remove colorbar spines\n", - " for spine in cbar.ax.spines.values():\n", - " spine.set_visible(False)\n", - " \n", - " # Set custom tick positions and labels (every 4 positions)\n", - " tick_positions = [1.5, 5.5, 9.5, 13.5] # Middle of each group of 4\n", - " tick_labels = ['1', '2', '3', '4']\n", - " \n", - " ax.set_xticks(tick_positions)\n", - " ax.set_xticklabels(tick_labels,fontsize=10)\n", - " ax.set_yticks(tick_positions)\n", - " ax.set_yticklabels(tick_labels,fontsize=10)\n", - " \n", - " # Set axis labels\n", - " ax.set_xlabel('System',fontsize=10)\n", - " ax.set_ylabel('System',fontsize=10)\n", - " \n", - " # Remove spines\n", - " for spine in ax.spines.values():\n", - " spine.set_visible(False)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "2edb4f13", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 16/16 [00:00<00:00, 287.19it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 39.64it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 380.73it/s]\n", - "100%|██████████| 16/16 [00:00<00:00, 41.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Silhouette Scores:\n", - "DMDc Full (state): 0.028\n", - "SubspaceDMDc Full (state): 0.377\n", - "DMDc Full (control): -0.001\n", - "SubspaceDMDc Full (control): 0.435\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Get the similarity matrices for each method\n", - "sims_full_dmdc, _, _, _, _ = compare_systems_full(A_cs, B_cs)\n", - "sims_full_subdmdc, _, _, _, _ = compare_systems_full(As_n4sid, Bs_n4sid)\n", - "\n", - "# Print silhouette scores\n", - "print(\"Silhouette Scores:\")\n", - "print(f\"DMDc Full (state): {np.round(silhouette_score(sims_full_dmdc, state_labels, metric='precomputed'), 3)}\")\n", - "print(f\"SubspaceDMDc Full (state): {np.round(silhouette_score(sims_full_subdmdc, state_labels, metric='precomputed'), 3)}\")\n", - "print(f\"DMDc Full (control): {np.round(silhouette_score(sims_full_dmdc, control_labels, metric='precomputed'), 3)}\")\n", - "print(f\"SubspaceDMDc Full (control): {np.round(silhouette_score(sims_full_subdmdc, control_labels, metric='precomputed'), 3)}\")\n", - "\n", - "# Create 1x2 subplot\n", - "fig, axes = plt.subplots(1, 2, figsize=(6, 3))\n", - "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", - "\n", - "# Column headers (bold)\n", - "column_headers = ['DMDc', 'SubspaceDMDc']\n", - "for i, header in enumerate(column_headers):\n", - " axes[i].text(0.5, 1.55, header, transform=axes[i].transAxes, ha='center', va='bottom', fontweight='bold', fontsize=16)\n", - "\n", - "# Data for each subplot\n", - "data_matrices = [\n", - " sims_full_dmdc, # left\n", - " sims_full_subdmdc # right\n", - "]\n", - "\n", - "# Plot each subplot\n", - "for idx, (ax, data) in enumerate(zip(axes.flat, data_matrices)):\n", - " im = ax.imshow(data, cmap='viridis')\n", - " \n", - " # Add colorbar on top with only 2 ticks\n", - " cbar = plt.colorbar(im, ax=ax, shrink=0.4, location='top', pad=0.02,label='Joint DSA')\n", - " vmin, vmax = data.min(), data.max()\n", - " cbar.set_ticks([vmin, vmax])\n", - " cbar.set_ticklabels([f'{vmin:.2g}', f'{vmax:.2g}'])\n", - " cbar.ax.tick_params(labelsize=10)\n", - " \n", - " # Remove colorbar spines\n", - " for spine in cbar.ax.spines.values():\n", - " spine.set_visible(False)\n", - " \n", - " # Set custom tick positions and labels (every 4 positions)\n", - " tick_positions = [1.5, 5.5, 9.5, 13.5] # Middle of each group of 4\n", - " tick_labels = ['1', '2', '3', '4']\n", - " \n", - " ax.set_xticks(tick_positions)\n", - " ax.set_xticklabels(tick_labels, fontsize=10)\n", - " ax.set_yticks(tick_positions)\n", - " ax.set_yticklabels(tick_labels, fontsize=10)\n", - " \n", - " # Set axis labels\n", - " ax.set_xlabel('System', fontsize=10)\n", - " ax.set_ylabel('System', fontsize=10)\n", - " \n", - " # Remove spines\n", - " for spine in ax.spines.values():\n", - " spine.set_visible(False)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "d85b184f", - "metadata": {}, - "outputs": [], - "source": [ - "#collect statistics now: \n", - "#sample random systems from the set of 4 pairings\n", - "#sample 4 input drives for each system, making 16 diferent systems in total \n", - "#compute silhouette score based on A labels and B labels\n", - "\n", - "def get_silhouette_scores(n,m,p_out,N,n_iters,\n", - " input_alpha=input_alpha,g1=g1,g2=g2,same_inp=False,n_Us=n_Us,\n", - " n_delays=n_delays,pf=pf,rank=rank,process_noise=process_noise,obs_noise=obs_noise,\n", - " nonlinear_eps=nonlinear_eps,nonlinear_func=lambda x: np.tanh(x),\n", - " y_feature_map = lambda x: x, u_feature_map = lambda x: x,backend=backend,\n", - " use_joint_control=True):\n", - "\n", - " silhouette_state_dmdc = []\n", - " silhouette_control_dmdc = []\n", - "\n", - " silhouette_state_subspace_dmdc = []\n", - " silhouette_control_subspace_dmdc = []\n", - "\n", - " silhouette_state_dsa = []\n", - " silhouette_control_dsa = []\n", - "\n", - "\n", - " for i in tqdm(range(n_iters)):\n", - " X_trues, Ys, Us, control_labels, state_labels, *_ = simulate_As_Bs(n,m,p_out,\n", - " N,input_alpha=input_alpha,g1=g1,g2=g2,same_inp=same_inp,n_Us=n_Us, seed1=seed1+i,seed2=seed2+110*i,\n", - " obs_noise=obs_noise,process_noise=process_noise,\n", - " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", - " Ys = list(map(y_feature_map, Ys))\n", - " Us = list(map(u_feature_map, Us))\n", - "\n", - " A_cs, B_cs = get_dmdcs(Ys,Us,n_delays=n_delays,rank=rank)\n", - " print('dmdc:', [i.shape for i in A_cs])\n", - " As, Bs, Cs, infos = get_subspace_dmdcs(Ys,Us,p=pf,rank=rank,backend=backend)\n", - " print('subspacedmdc:', [i.shape for i in As])\n", - " A_dmds = get_dmds(Ys,n_delays=n_delays,rank=rank)\n", - " print('dmd:', [i.shape for i in A_dmds])\n", - " sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc = compare_systems_full(A_cs,B_cs)\n", - " sims_full_subspace_dmdc, sims_control_joint_subspace_dmdc, sims_state_joint_subspace_dmdc, sims_control_separate_subspace_dmdc, sims_state_separate_subspace_dmdc = compare_systems_full(As,Bs)\n", - "\n", - " sims_state_dmd = compare_A_full(A_dmds)\n", - "\n", - " #compute silhouette scores\n", - " silhouette_state_dmdc.append(silhouette_score(sims_state_separate_dmdc,state_labels,metric='precomputed'))\n", - " if use_joint_control:\n", - " silhouette_control_dmdc.append(silhouette_score(sims_control_joint_dmdc,control_labels,metric='precomputed'))\n", - " silhouette_control_subspace_dmdc.append(silhouette_score(sims_control_joint_subspace_dmdc,control_labels,metric='precomputed'))\n", - " else:\n", - " silhouette_control_dmdc.append(silhouette_score(sims_control_separate_dmdc,control_labels,metric='precomputed'))\n", - " silhouette_control_subspace_dmdc.append(silhouette_score(sims_control_separate_subspace_dmdc,control_labels,metric='precomputed'))\n", - " \n", - " silhouette_state_subspace_dmdc.append(silhouette_score(sims_state_separate_subspace_dmdc,state_labels,metric='precomputed'))\n", - "\n", - " silhouette_state_dsa.append(silhouette_score(sims_state_dmd,state_labels,metric='precomputed'))\n", - " silhouette_control_dsa.append(silhouette_score(sims_state_dmd,control_labels,metric='precomputed'))\n", - "\n", - " print(silhouette_state_subspace_dmdc[-1],silhouette_state_dmdc[-1])\n", - " print(silhouette_control_subspace_dmdc[-1],silhouette_control_dmdc[-1])\n", - "\n", - " # print(silhouette_state_subspace_dmdc,silhouette_control_subspace_dmdc)\n", - " return silhouette_state_dmdc, silhouette_control_dmdc, silhouette_state_subspace_dmdc, silhouette_control_subspace_dmdc, silhouette_state_dsa, silhouette_control_dsa\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e32ce5f0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/10 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "methods = [ 'DMD','DMDC', 'Subspace DMDC']\n", - "state_means = [np.mean(silh_state_dsa),np.mean(silh_state_dmdc), np.mean(silh_state_subdmdc)]\n", - "state_stds = [np.std(silh_state_dsa) / np.sqrt(n_iters), np.std(silh_state_dmdc) / np.sqrt(n_iters), np.std(silh_state_subdmdc) / np.sqrt(n_iters)]\n", - "control_means = [np.mean(silh_ctrl_dsa),np.mean(silh_ctrl_dmdc), np.mean(silh_ctrl_subsdmdc)]\n", - "control_stds = [np.std(silh_ctrl_dsa) / np.sqrt(n_iters), np.std(silh_ctrl_dmdc) / np.sqrt(n_iters), np.std(silh_ctrl_subsdmdc) / np.sqrt(n_iters)]\n", - "\n", - "# Create bar plot\n", - "x = np.arange(len(methods))\n", - "width = 0.35\n", - "\n", - "fig, ax = plt.subplots(figsize=(6,4))\n", - "# Prepare data for violin plots\n", - "state_data = [silh_state_dsa, silh_state_dmdc, silh_state_subdmdc]\n", - "control_data = [silh_ctrl_dsa, silh_ctrl_dmdc, silh_ctrl_subsdmdc]\n", - "\n", - "# Option to create either violin plots or bar plots\n", - "plot_type = 'bar' # Change to 'bar' for bar plots\n", - "\n", - "if plot_type == 'violin':\n", - " # Create violin plots\n", - " violin_parts1 = ax.violinplot(state_data, positions=x - width/2, widths=width, showmeans=True, showmedians=False)\n", - " violin_parts2 = ax.violinplot(control_data, positions=x + width/2, widths=width, showmeans=True, showmedians=False)\n", - "\n", - " # Color the violin plots\n", - " for pc in violin_parts1['bodies']:\n", - " pc.set_facecolor(plt.cm.Paired(0))\n", - " pc.set_alpha(0.8)\n", - " \n", - " for pc in violin_parts2['bodies']:\n", - " pc.set_facecolor(plt.cm.Paired(1))\n", - " pc.set_alpha(0.8)\n", - "\n", - " # Set the color for violin lines (edges) as well\n", - " for key in ['cbars', 'cmins', 'cmaxes', 'cmedians', 'cmeans']:\n", - " if key in violin_parts2:\n", - " violin_parts2[key].set_color(plt.cm.Paired(1))\n", - " # Create legend manually\n", - " # ax.plot([], [], color=plt.cm.Paired(0), alpha=0.8, label='State')\n", - " # ax.plot([], [], color=plt.cm.Paired(1), alpha=0.8, label='Control')\n", - "\n", - "elif plot_type == 'bar':\n", - " # Create bar plots\n", - " ax.bar(x - width/2, state_means, width, yerr=state_stds, alpha=0.8,color=plt.cm.Paired(0))\n", - " ax.bar(x + width/2, control_means, width, yerr=control_stds, alpha=0.8,color=plt.cm.Paired(1))\n", - "\n", - "\n", - "ax.text(0.1, 0.8, 'State', color=plt.cm.Paired(0), fontsize=18, ha='center', va='center', transform=ax.transAxes)\n", - "ax.text(0.1, 0.7, 'Input', color=plt.cm.Paired(1), fontsize=18, ha='center', va='center', transform=ax.transAxes)\n", - "\n", - "\n", - "# Add labels and formatting\n", - "ax.set_xlabel('Method')\n", - "ax.set_ylabel('Silhouette Score')\n", - "ax.set_xticks(x)\n", - "ax.set_xticklabels(methods)\n", - "# ax.legend(loc='upper left')\n", - "\n", - "plt.tight_layout()\n", - "# plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c085ce64", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [00:50<15:50, 50.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999995829788267 0.9994804238352938\n", - "0.863046118997211 0.23133393565678578\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [01:38<14:41, 48.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999996460530998 0.5761319024802469\n", - "0.8701154730521196 0.24099690133052715\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [02:26<13:48, 48.71s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999912817283558 0.9521479914270492\n", - "0.16003234487022538 0.16403266188793597\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [03:14<12:56, 48.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.999997826126348 0.9976338825933455\n", - "0.3814445884235741 0.2529392671562286\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [04:03<12:06, 48.46s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999679564451 0.9920394705518483\n", - "0.010578386107770881 0.04765377864976594\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [04:52<11:21, 48.69s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999889902481 0.9689650322969088\n", - "0.5630268469649073 0.3016799456824357\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [05:40<10:29, 48.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999998497630886 0.3183726653904416\n", - "0.9534753079734178 0.2617349582738815\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [06:28<09:39, 48.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999993846554156 0.8273921704738043\n", - "0.9949309508072234 0.21925306644298592\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [07:16<08:52, 48.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999392047036 0.9954893728664165\n", - "0.8926091704516487 0.1903970895833016\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [08:04<08:02, 48.27s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999896719519 0.995444964889423\n", - "0.9961439015917473 0.2041291174096036\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [08:52<07:14, 48.22s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999238686303 0.9972320906387236\n", - "0.9583486457958001 0.2825033975417309\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [09:41<06:25, 48.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999384251308399 0.3684689139358635\n", - "0.47414138222768587 0.0851508391625842\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [10:29<05:36, 48.12s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999348885965 0.7527879372104045\n", - "0.6306063443490444 0.2672479104166636\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [11:16<04:48, 48.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999951190598705 0.3610613497907184\n", - "0.8961250841720869 0.2641135351952263\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [12:05<04:00, 48.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.999998341385793 0.6230706090075946\n", - "0.9248202840122726 0.17706479248767715\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [12:53<03:12, 48.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999674326947 0.9994709308073931\n", - "-0.1067841427238009 -0.09112366530336576\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [13:41<02:24, 48.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.999999868783956 0.20194098857734308\n", - "0.7239155278059701 -0.0724678271629539\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [14:29<01:36, 48.14s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999997066328019 0.819120040107554\n", - "0.8702333799674973 0.05895311655939994\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [15:17<00:48, 48.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999998800189802 0.9349864382675056\n", - "0.5766529970474021 0.14812653792397995\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [16:06<00:00, 48.32s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999876386543 0.9989465989638291\n", - "-0.10880975421142923 -0.041194873224640466\n", - "0.7840091887055854 0.9999959305984649 0.8177832037795628\n", - "\n", - "4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [00:49<15:31, 49.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7148854335890451 0.3570867373101759\n", - "0.254784330813526 0.2564970447924318\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [01:37<14:32, 48.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9991213701183851 0.9338003716720993\n", - "0.373621258031336 0.192136675493342\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [02:25<13:41, 48.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6355829754026776 0.9872634331292893\n", - "0.1854906962368728 -0.03767345531702448\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [03:13<12:51, 48.24s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9995839406566759 0.9953287380325818\n", - "0.6123764433477282 0.08684510901067677\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [04:03<12:12, 48.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6963230455649736 0.845687225356722\n", - "0.4016672245447243 0.058871525818189774\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [05:09<12:48, 54.92s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9992640993428434 0.998645561471499\n", - "0.8038460988934154 0.2454871038684441\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [06:15<12:40, 58.47s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9987683545735093 0.0736808970230497\n", - "0.8285925196418789 0.2732293212884245\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [07:22<12:14, 61.24s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9915730805336032 0.994797192140245\n", - "0.5981192746869755 0.1964379017215781\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [08:27<11:25, 62.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.16730169440098075 -0.050823293824917536\n", - "0.856633281362433 0.7165541780129958\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [09:33<10:33, 63.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9955512573222484 0.4421153238515224\n", - "0.7824419645630796 0.27359514600465207\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [10:36<09:30, 63.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999171575551626 0.3104755396741338\n", - "0.4001872470668205 0.16345363658381468\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [11:40<08:27, 63.42s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9483586189931417 0.966822117653678\n", - "0.7168567181733992 0.12511920485220757\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [12:44<07:26, 63.78s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9561742831184827 0.9966754990231261\n", - "0.9029807911758108 0.2610828125429131\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [13:49<06:24, 64.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9990568101519974 0.7746559801011399\n", - "0.9337617390487356 0.3075022066959726\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [14:53<05:20, 64.16s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9998411060381232 0.2569602675253595\n", - "0.8390945275201664 0.22370357604102423\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [15:57<04:16, 64.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9997865367342857 0.241318053358768\n", - "0.6837142493572079 0.07254009908039336\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [16:59<03:10, 63.47s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8785750042711452 0.810468321924495\n", - "0.570785198489913 0.27891043801749216\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [18:04<02:07, 63.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9995900377560776 0.9195043770087221\n", - "0.9833055223571778 0.3036383897052762\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [19:01<01:01, 61.76s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.2812199039990566 0.3239224658462285\n", - "0.6939734888761797 0.2935816367842393\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [20:04<00:00, 60.20s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9660441509081211 0.42782272440222124\n", - "0.8648016287642502 0.4537986269330362\n", - "0.630310376634007 0.8613259430515268 0.6772214951028864\n", - "\n", - "6\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [00:57<18:09, 57.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6829675131066244 0.4223460413096838\n", - "0.8854467748170356 0.2616686133906402\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [01:55<17:18, 57.68s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4778190008236387 0.17609356285751082\n", - "0.6598414498361063 0.22278253995276884\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [02:53<16:23, 57.88s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5471160613933711 0.08871996231037635\n", - "0.4259459201932812 0.1866660821930045\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [03:50<15:19, 57.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8016038453841238 0.9988028414222979\n", - "0.8509811383108216 0.2604414799956156\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [04:48<14:27, 57.83s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7321304877045927 0.9301852495572647\n", - "0.8173496247672856 0.12185147255399653\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [05:48<13:37, 58.39s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6365979901030729 0.4041255920722771\n", - "0.7579932786817185 0.18545833884321933\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [06:45<12:36, 58.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9195536285180825 0.9806066331854593\n", - "0.7777951467327848 0.28973384255619494\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [07:41<11:28, 57.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.984003610143904 0.9995813967756805\n", - "0.8788713016811251 0.2749585482464467\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [08:39<10:33, 57.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5158567945640098 -0.07237010093454069\n", - "0.9126702269824578 0.49939973342165545\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [09:35<09:30, 57.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7923416282245809 0.2817045952973056\n", - "0.7779161159103634 0.24577059528112646\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [10:30<08:28, 56.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7312936187732099 0.9473852533471532\n", - "0.7597158791730374 0.18176727052706398\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [11:24<07:25, 55.64s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6469929404560593 0.3729713725848219\n", - "0.40568443893046857 0.2157982900886147\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [12:17<06:24, 54.87s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7282137874227994 0.381613387917653\n", - "0.7096534869397652 0.32360433315080395\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [13:09<05:23, 53.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8932251993393823 0.9698401650825509\n", - "0.7012288905220221 0.240646029051426\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [14:02<04:29, 53.85s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8119149687546602 0.2780525694562858\n", - "0.7676685570825138 0.24978632748796964\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [14:56<03:34, 53.63s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4208085507139975 0.19105960199501956\n", - "0.4335780142580806 0.16747429030574595\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [15:49<02:40, 53.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7648091158857311 0.8826299558795999\n", - "0.5728535489842801 0.15178372322416311\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [16:52<01:52, 56.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7153545536283132 0.8906240461622843\n", - "0.9652633954881787 0.2609344859351437\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [17:54<00:58, 58.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5778547187917267 0.44230974875355167\n", - "0.8466528891503173 0.07585444605775558\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [18:50<00:00, 56.52s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8191002897878881 0.368712975313898\n", - "0.8319921385680488 0.28762059488907493\n", - "0.5467497425173066 0.7099779151759884 0.5484566045827914\n", - "\n", - "8\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [00:53<17:02, 53.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9248303386842245 0.7146369776756394\n", - "0.7451216619675085 0.23952590552851677\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [01:48<16:13, 54.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7832002042045016 0.3089931254863645\n", - "0.6649420392703927 0.11572462988981133\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [02:41<15:13, 53.73s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6435735655396131 0.20445585902685298\n", - "0.872934293916127 0.2747311850562459\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [03:35<14:18, 53.68s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.706631097080003 0.9684960879289083\n", - "0.48356213906831524 0.20405758550928416\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [04:30<13:33, 54.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9661794181953494 0.32230796996366945\n", - "0.8934327360343968 0.35701384353475246\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [05:23<12:34, 53.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9553748648518876 0.39828794838648274\n", - "0.7830886629530971 0.22893819637325005\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [06:18<11:44, 54.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8147103362485131 0.0988428621121708\n", - "0.9470716284359546 0.3104522087632273\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [07:11<10:47, 53.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9767647013433851 0.7556305630672474\n", - "0.943084645089665 0.10792093436819339\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [08:05<09:54, 54.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8085664544760404 0.34372255960639364\n", - "0.9022105132439618 0.21804741703514957\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [08:58<08:56, 53.63s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7606182512852901 0.4256418262830215\n", - "0.8894219397963725 0.2948401293001088\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [09:52<08:03, 53.72s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6282569085372263 0.3089051839947159\n", - "0.8012605799820862 0.24923431995121953\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [10:46<07:09, 53.75s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9255080438194763 0.8188655274348823\n", - "0.7987398983988274 0.14982915606986894\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [11:39<06:15, 53.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.917964256305034 0.935502457207692\n", - "0.6930882697627829 0.22298600961410608\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [12:32<05:20, 53.42s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6367458407978331 0.35127711063627737\n", - "0.5818592184667145 0.27120945643360456\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [13:26<04:28, 53.63s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8304468291687427 0.18779258604062105\n", - "0.6704730508807738 0.24147650357533848\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [14:18<03:32, 53.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9894151988315718 0.9953587181268179\n", - "0.24522148086447199 0.2299362315813862\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [15:10<02:38, 52.78s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6041337842499772 0.33126028917602063\n", - "0.9598960458391113 0.3595816525605222\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [16:02<01:45, 52.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9685427305295512 0.9324988048230214\n", - "0.4098858470516994 0.3098063660817312\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [16:57<00:53, 53.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8142915376417594 0.34116724781207\n", - "0.9629912195463708 0.16932229722168923\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [17:49<00:00, 53.50s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8214845853326898 0.23004491704025687\n", - "0.7719468109436691 0.25361105460709327\n", - "0.4986844310914563 0.8238619473561336 0.5526251265224809\n", - "\n", - "10\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [00:53<16:48, 53.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7991433678090709 0.565793146732338\n", - "0.6580735402758165 0.2469688530509827\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [01:47<16:06, 53.71s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6407325038895381 0.40472342435440967\n", - "0.42905662200774763 0.06822521009658045\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [02:40<15:09, 53.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8461176454032904 0.3138150886305985\n", - "0.6417382914134774 0.3695419197033751\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [03:34<14:19, 53.71s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5371381446176151 0.3640210948047854\n", - "0.47543343188655235 0.3412147377093789\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [04:29<13:30, 54.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4817741069115222 0.3312604718736136\n", - "0.921089351917504 0.28936051553243025\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [05:23<12:37, 54.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9687073854918788 0.9991191759574398\n", - "0.9241084179945119 0.12928319716867753\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [06:23<12:07, 55.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4295218657374844 0.11410334626856197\n", - "0.894517240546653 0.2000469265578521\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [07:21<11:22, 56.88s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.33677496103480126 -0.08890655024206669\n", - "0.8852859753982001 0.32121996122835905\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [08:18<10:25, 56.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8001191065128971 0.8390420933339114\n", - "0.8682404172168996 0.31176429277749024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [09:13<09:23, 56.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6306414649718846 0.760817453744526\n", - "0.7830045461575633 0.25697639413796286\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [10:09<08:26, 56.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9700886369661625 0.3402876141906415\n", - "0.479714946691821 0.21419923744792801\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [11:07<07:32, 56.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7112346911590584 0.8115064155105561\n", - "0.892931950721412 0.15764011379775023\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [12:03<06:36, 56.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7012834016157923 0.14910716991895367\n", - "0.8036564778741786 0.2426703326352978\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [13:02<05:43, 57.26s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7875423195769864 0.7459283517299533\n", - "0.6840405260414184 0.12612654890845015\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [14:02<04:49, 57.87s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5680739236743386 0.6798750591982248\n", - "0.7685265107130248 0.21111568535663267\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [14:56<03:47, 56.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8969783486575266 0.8201654338199273\n", - "0.6419161613136062 0.3102890006181207\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [15:50<02:48, 56.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.2102115990246819 0.681500023791654\n", - "0.9457387099496892 0.27367950454988077\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [16:48<01:53, 56.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7230200609338846 0.4987655547588908\n", - "0.8993263982985391 0.32930054005012344\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [17:43<00:56, 56.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4811909979021496 0.34295258004093626\n", - "0.984001565270018 0.17301095039273662\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [18:41<00:00, 56.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9145787220471548 0.47275372687986705\n", - "0.9310953047402001 0.22434178009172623\n", - "0.5073315337648862 0.6717436626968859 0.5167306060806733\n", - "\n", - "20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [00:57<18:21, 57.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9892640331231699 0.8594591384334251\n", - "0.8254778135215022 0.214267756737885\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [01:56<17:26, 58.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9512447101134738 0.4068049229052108\n", - "0.736197252981335 0.1987269496108924\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [02:53<16:23, 57.88s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8785697149599488 0.6235207265603029\n", - "0.6158978028372307 0.24119758793689644\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [03:50<15:18, 57.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7442104757416566 0.2526657447637686\n", - "0.7914724527675518 0.3287430462844653\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [04:49<14:28, 57.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8749731165405094 0.38901877685785274\n", - "0.9143839901122117 0.3008742080828827\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [05:46<13:29, 57.80s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7524401849433755 0.5273911397333929\n", - "0.8560878537175243 0.27101413652478457\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [06:49<12:52, 59.46s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.18044896982307718 0.14029720452084493\n", - "0.8081506503339186 0.19824224783168232\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [07:50<11:56, 59.74s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9770507781642589 0.7183770834927682\n", - "0.26385329595023455 0.115051332187116\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [08:49<10:54, 59.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5358649236504333 0.6741896151072617\n", - "0.8652764268463012 0.2600824214341021\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [09:50<09:59, 59.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7370445733058059 0.21205111557687406\n", - "0.9575139770925202 0.5804208804017441\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [10:49<08:58, 59.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7010619836064139 0.8787181635255477\n", - "0.39316111137823206 0.22912150415632226\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [11:46<07:50, 58.80s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.511356583372921 0.9090642506020197\n", - "0.8585437451244906 0.3032818384153309\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [12:41<06:44, 57.78s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8422170048715416 0.4655938834297251\n", - "0.9246601826856204 0.25795015987507086\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [13:37<05:42, 57.14s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5393678866134317 0.16183292650561076\n", - "0.6668216456383955 0.19683088749074412\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [14:36<04:48, 57.69s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9385038404707957 0.7075567029351021\n", - "0.7926214453281066 0.2651271505385519\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [15:33<03:50, 57.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9396540889153789 0.71283293556484\n", - "0.955523845385363 0.28787200438430793\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [16:29<02:51, 57.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7483994134243397 0.9725720264591999\n", - "0.7723355923572701 0.23929991033336254\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [17:25<01:53, 56.71s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.963901587135688 0.725603976138003\n", - "0.874380533643646 0.39667421074578557\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [18:20<00:56, 56.16s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8335779478889345 0.429612405947956\n", - "0.6335114677482351 0.32923557189268776\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [19:16<00:00, 57.80s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7048793856690092 0.5371596636189394\n", - "0.9764039741453683 0.2923650669525318\n", - "0.5652161201339324 0.7672015601167083 0.5580053587875079\n", - "\n", - "50\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [01:12<22:54, 72.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.2860380003458474 0.3105522329810055\n", - "0.8752166267181785 0.5155899527565754\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [02:26<22:03, 73.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5898848214821798 0.45556156918402146\n", - "0.6069604392366142 0.2936238949125084\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [03:37<20:29, 72.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7320529918600682 0.8521377298136814\n", - "0.9029918902655901 0.2876787842363736\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [04:47<19:04, 71.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.539977020978684 0.4945501601133633\n", - "0.6153494078059176 0.24901310001351387\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [06:00<17:56, 71.78s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.21960990625785626 0.18522784750233728\n", - "0.5309055215391791 0.4288068204167372\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [07:11<16:42, 71.62s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6459410466940635 0.011299983501322868\n", - "0.9483473503631741 0.4318358565300766\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [08:22<15:28, 71.45s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.42576715973064605 0.31801706152072473\n", - "0.7561012171300019 0.34173896506185514\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [09:34<14:18, 71.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8848059959184817 0.688873283915466\n", - "0.8467319580550701 0.2723758348586194\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [10:47<13:12, 72.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6394936234771974 0.27199690137762766\n", - "0.9632065247896976 0.3683824099393246\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [11:58<11:57, 71.75s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8243466273351014 0.39518703428173496\n", - "0.9016127395936266 0.5168346307232419\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [13:10<10:45, 71.73s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.666926006575496 0.6990843787631436\n", - "0.6746058253840981 0.4336576557230802\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [14:22<09:35, 71.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8956944324512491 0.23953877668101403\n", - "0.8504315319655691 0.4273766175223321\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [15:33<08:20, 71.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6499095153580638 0.2245850900849572\n", - "0.8056497448834813 0.24283914573402143\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [16:45<07:10, 71.80s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.887792229639151 0.6347844805856808\n", - "0.8796551535411032 0.36216678946757896\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [17:59<06:01, 72.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5086444268624157 0.0936516339750865\n", - "0.7878271994226096 0.42504508357141196\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [19:14<04:52, 73.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.11948895738930862 0.31070889043209277\n", - "0.5937901505822004 0.382057515121027\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [20:27<03:39, 73.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.49807007753376553 0.5953937744140247\n", - "0.5051521673419727 0.3233819925076515\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [21:41<02:26, 73.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.3383236736143306 0.6032253506345908\n", - "0.7233016813318316 0.37123212471933364\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [22:51<01:12, 72.35s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7190588170171746 0.7969780119901608\n", - "0.8585962210786311 0.2878671355020555\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [24:00<00:00, 72.01s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.34565097190956035 0.10234097838994428\n", - "0.8181598910705421 0.4034857434846065\n", - "0.4141847585070991 0.5708738151215321 0.41546844901558033\n", - "\n", - "100\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [02:29<47:28, 149.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8446268725815469 0.7256464342912119\n", - "0.8273507722373987 0.5603376456698084\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [05:01<45:16, 150.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5457822603798255 0.21750971297207908\n", - "0.8546880341433041 0.35635946004801594\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [07:33<42:57, 151.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6715401504742341 0.33921036794768644\n", - "0.7607462917806747 0.40100202095421456\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [10:08<40:44, 152.77s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5267314701678696 0.6466412902454441\n", - "0.9278811439470444 0.425815857095872\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [12:46<38:40, 154.72s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4643429036975759 0.190965385996421\n", - "0.9294583058441246 0.6218037387658151\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [15:20<36:01, 154.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.709206644599262 0.33229187867188287\n", - "0.6681369604804535 0.5088500240453075\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [17:55<33:29, 154.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.2314738406844464 0.06774352764780177\n", - "0.916137156986661 0.4823204525486465\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [20:27<30:46, 153.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4078497168933002 0.5483546343845598\n", - "0.9390646310432331 0.5249700522658651\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [23:10<28:43, 156.65s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8576657585702796 0.27128668076026385\n", - "0.8870119230779476 0.5507856621345018\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [25:41<25:48, 154.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7253773211988085 0.2804275006355139\n", - "0.9014721499938876 0.5419448466702601\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [28:00<22:29, 149.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.33641812436974 0.35422686708680384\n", - "0.877598941516769 0.49945679860528824\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [30:34<20:10, 151.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8753192957665168 0.280436722323244\n", - "0.87155131343598 0.4605904753540729\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [33:14<17:58, 154.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0788372675369562 0.356938915948146\n", - "0.9434898139880066 0.5660042178199005\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [35:51<15:28, 154.83s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.13548756460266684 0.3020333447007765\n", - "0.8355524739767075 0.4803127179691466\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [38:28<12:56, 155.30s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.15113425915118855 -0.012416282573434669\n", - "0.9499796252950421 0.4505210752534833\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [41:04<10:22, 155.73s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7603783923118979 0.3960604328259445\n", - "0.5260696835489838 0.2634785255655468\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [43:23<07:31, 150.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6931923903264781 0.5476441672681036\n", - "0.5774190372196778 0.37382427961108844\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [45:51<04:59, 149.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8499123123044735 0.5544635520573259\n", - "0.869813808721149 0.4762205555314316\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [48:09<02:26, 146.25s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5867010922012843 0.10158268344160948\n", - "0.9031706778944122 0.6281068800498706\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [50:38<00:00, 151.92s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4224749726743423 0.24078994145418864\n", - "0.9225045347541461 0.49925414194469775\n", - "0.3370918879042787 0.5437226305246348 0.38753305360921275\n", - "\n", - "200\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [02:38<50:05, 158.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5909926793101823 0.5267353297787027\n", - "0.793287839335513 0.42577658486413167\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [05:17<47:44, 159.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6247010938533479 0.2711818540152699\n", - "0.944896066035209 0.5541491013249726\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [07:53<44:35, 157.38s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.40754480344278765 0.12368201193512694\n", - "0.7442620102045194 0.48312609484057234\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [10:36<42:35, 159.71s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5789496801447473 0.26461895585748385\n", - "0.7904986694139292 0.5211463345792007\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [13:21<40:23, 161.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.658181489951501 0.4111157930411643\n", - "0.8767443415128332 0.41738304427727346\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [15:46<36:24, 156.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5890209837764785 0.31261881183448553\n", - "0.7431785673340168 0.43313114828135746\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [18:22<33:48, 156.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.25878407195050107 0.248673711901176\n", - "0.960555865133256 0.602995612582953\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [20:56<31:03, 155.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1831344683291642 0.7502605606731848\n", - "0.7419020251917682 0.44774711485528707\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [23:39<28:55, 157.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6156212189531662 0.30370286626147514\n", - "0.8113055539834164 0.5869938172389021\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [26:22<26:32, 159.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.25602000113544043 0.20566905280002584\n", - "0.8723014637982822 0.40689361063820395\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [29:03<23:58, 159.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.08782627932844758 0.21599346406778525\n", - "0.9338566334595068 0.7108388099126532\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [31:25<20:35, 154.38s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7509720423118675 0.31559635433883176\n", - "0.8671199750284003 0.5852102479633505\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [33:59<18:00, 154.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.23497824333432582 0.20581158461935417\n", - "0.8292549170886632 0.4671277111079004\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [36:30<15:19, 153.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.21076681207816744 0.05435857097436688\n", - "0.8983166829817066 0.6088961437819176\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [38:59<12:39, 151.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.43216414491713195 0.2700225343287927\n", - "0.9219818012435689 0.5448139659231047\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [41:39<10:17, 154.43s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.35107496005046335 0.17495664975537167\n", - "0.8019340960503707 0.4185433604322402\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [43:57<07:28, 149.65s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7667975097980471 0.41876674952603615\n", - "0.4005731630535587 0.3527487793499603\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [46:30<05:01, 150.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.48806800421228 0.7464100466923176\n", - "0.9245962301647113 0.5186315236551856\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [48:51<02:27, 147.77s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.23529197058614706 0.2865792918700654\n", - "0.8240179717146053 0.47096734519534117\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [51:25<00:00, 154.26s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5023233858774772 0.3795988310852768\n", - "0.9255917812733652 0.6415014495916215\n", - "0.3243176512678147 0.4411606921670835 0.32947940422530647\n", - "\n", - "500\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [02:52<54:44, 172.86s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.22043632221253617 0.1553981097516287\n", - "0.9015436071811085 0.5472704301810019\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [05:46<51:59, 173.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6025273736285195 0.19152691356660215\n", - "0.8385417110841888 0.4769818571042821\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [08:31<48:00, 169.45s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5742814715509301 0.34682026258812115\n", - "0.9061019555563466 0.5823313202283038\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [11:23<45:28, 170.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.26261340789480214 0.2719860300390877\n", - "0.9001388681520854 0.5518161850508868\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [14:10<42:21, 169.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.21261855977293215 0.6854052550690519\n", - "0.7678151017058328 0.28790413421616146\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [17:01<39:35, 169.69s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1527939370789289 0.25347613159299026\n", - "0.7390842568896852 0.42379904680922015\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [19:44<36:17, 167.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.2861601938983629 0.3523174081703131\n", - "0.8983865080718274 0.4778147328195415\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [22:25<33:07, 165.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1473331275960964 0.2616190097172466\n", - "0.8477978341974416 0.3867557529999165\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [25:15<30:35, 166.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8111390724509978 0.37228173553201405\n", - "0.8776929228510219 0.4795653764782277\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [28:05<27:59, 167.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4085765746438009 0.34948545998649555\n", - "0.8007255529314821 0.3891526031748061\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [30:40<24:34, 163.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.13740835750248043 0.20976463111068544\n", - "0.9424595808849461 0.6339189675854268\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [33:37<22:22, 167.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5112216206695892 0.23838856619317703\n", - "0.7904138275111404 0.4297397739791532\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [36:22<19:28, 166.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0990374510279309 0.19216912255339327\n", - "0.9358155844669447 0.5563190397561102\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [39:10<16:45, 167.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6601977913749432 0.27982790995797213\n", - "0.8684212521301466 0.5335795085482751\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [41:40<13:30, 162.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5956458226808542 0.24524113278914392\n", - "0.7972147740858228 0.4332194784851243\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [44:25<10:52, 163.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5122700595630902 0.488491597606007\n", - "0.8265298610883107 0.5350677727259068\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [47:18<08:17, 165.89s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7476222074587422 0.6771672929832568\n", - "0.8479695857330589 0.4960150918510703\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [50:06<05:33, 166.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5302998066361749 0.2871918771799252\n", - "0.8765691515631118 0.47461433287297644\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [52:54<02:47, 167.18s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.15639471147498035 0.44150693921106593\n", - "0.8473852661332886 0.6010330942129157\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [55:32<00:00, 166.64s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8169119290035589 0.3552092297921594\n", - "0.8893471350212314 0.44209055341031084\n", - "0.33276373076951693 0.4222744899060126 0.33110059858440477\n", - "\n", - "1000\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▌ | 1/20 [03:20<1:03:20, 200.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.21599824061235723 0.2122759472603924\n", - "0.7939899099574769 0.47536600422017516\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 10%|█ | 2/20 [06:50<1:01:46, 205.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1772414590625133 0.1638066071548832\n", - "0.7768398756044337 0.5351219512328911\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 15%|█▌ | 3/20 [10:20<58:53, 207.86s/it] " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.20305987719615948 0.31641285252240126\n", - "0.8275996865695451 0.4554359223321068\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 4/20 [13:51<55:47, 209.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4365103362894593 0.21617428873080619\n", - "0.9339548743077184 0.5467185377035322\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 25%|██▌ | 5/20 [17:14<51:43, 206.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5446757682556929 0.37759894045670706\n", - "0.9053551309392543 0.5450234643659914\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 30%|███ | 6/20 [20:44<48:33, 208.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.3956405273624292 0.7379086544620574\n", - "0.9555669816927188 0.5676020992068349\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 35%|███▌ | 7/20 [24:13<45:08, 208.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6897428707916682 0.5966675741110706\n", - "0.893383950275017 0.6036722976049932\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 8/20 [27:53<42:24, 212.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.402043882408865 0.2152717511761012\n", - "0.8068825670591858 0.5761876966524075\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 45%|████▌ | 9/20 [31:27<38:58, 212.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1932406826463367 0.691683731087698\n", - "0.840336073582292 0.4572776129603895\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 50%|█████ | 10/20 [34:48<34:50, 209.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6452371929978948 0.6364881125494939\n", - "0.8706150369494879 0.49482891283103936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 55%|█████▌ | 11/20 [38:15<31:15, 208.38s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6798123405096732 0.29606565488857894\n", - "0.33811609109222995 0.22316664135652803\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 12/20 [41:53<28:11, 211.43s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6521372440734303 0.500413621081764\n", - "0.783705095460566 0.39231804266732906\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 65%|██████▌ | 13/20 [45:22<24:33, 210.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.6152243737606016 0.18487729125383087\n", - "0.9151161076602892 0.5136816998547024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 70%|███████ | 14/20 [48:48<20:54, 209.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5863428471516422 0.26471775040865647\n", - "0.9251590994184722 0.5257523396494801\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 75%|███████▌ | 15/20 [52:19<17:29, 209.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.25925966794872307 0.42358410823229564\n", - "0.90824545757701 0.5961194479231974\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 16/20 [55:54<14:05, 211.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.18580617952186845 0.44905640372446726\n", - "0.7375453310329729 0.41519043266013644\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 85%|████████▌ | 17/20 [59:32<10:39, 213.24s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.35446445789725217 0.33174072035690144\n", - "0.7717447035468411 0.39792695627207353\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 90%|█████████ | 18/20 [1:03:00<07:03, 211.74s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4703759666641165 0.738175762691752\n", - "0.9178287956011302 0.5468846777749655\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 95%|█████████▌| 19/20 [1:06:36<03:33, 213.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.2850865276468535 0.29375256722749515\n", - "0.8114035929558596 0.5211518240095194\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20/20 [1:10:08<00:00, 210.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1226260966699091 0.4394821713598579\n", - "0.748719768120352 0.34339422686100335\n", - "0.40430772553686045 0.4057263269733723 0.4372786707655439\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "#sweep partial observation fraction and compute silhouette scores\n", - "\n", - "n_iters = 20\n", - "\n", - "\n", - "silh_state_dmdcs = []\n", - "silh_ctrl_dmdcs = []\n", - "silh_state_subdmdcs = []\n", - "silh_ctrl_subsdmdcs = []\n", - "silh_state_dsas = []\n", - "silh_ctrl_dsas = []\n", - "\n", - "# p_outs = [1] #+ np.arange(2,22,2).tolist()\n", - "p_out = 2\n", - "n_uses = [2, 4, 6, 8, 10, 20, 50, 100, 200, 500,1000] #[::-1]\n", - "for n_use in n_uses:\n", - " print(n_use)\n", - " ss_dmdc, sc_dmdc, ss_subdmdc, sc_subdmdc, ss_dsa, sc_dsa = get_silhouette_scores(n_use,m,p_out,\n", - " 5*N_small,n_iters,input_alpha=input_alpha,g1=g1,\n", - " g2=g2,same_inp=False,n_Us=n_Us,n_delays=n_delays,rank=min(n_use,100),pf=pf,\n", - " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps)\n", - " silh_state_dmdcs.append(ss_dmdc)\n", - " silh_ctrl_dmdcs.append(sc_dmdc)\n", - " silh_state_subdmdcs.append(ss_subdmdc)\n", - " silh_ctrl_subsdmdcs.append(sc_subdmdc)\n", - " silh_state_dsas.append(ss_dsa)\n", - " silh_ctrl_dsas.append(sc_dsa)\n", - "\n", - " print(np.mean(ss_dmdc),np.mean(ss_subdmdc),np.mean(ss_dsa))\n", - " print()\n", - "\n", - "\n", - "silh_state_dmdcs = np.array(silh_state_dmdcs)\n", - "silh_state_subdmdcs = np.array(silh_state_subdmdcs)\n", - "silh_state_dsas = np.array(silh_state_dsas)\n", - "silh_ctrl_dmdcs = np.array(silh_ctrl_dmdcs)\n", - "silh_ctrl_subdmdcs = np.array(silh_ctrl_subsdmdcs)\n", - "silh_ctrl_dsas = np.array(silh_ctrl_dsas)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2662682c", - "metadata": {}, - "outputs": [], - "source": [ - "#for efficiency (if you desire)\n", - "# silh_state_dmdcs = np.array(silh_state_dmdcs)\n", - "# silh_state_subdmdcs = np.array(silh_state_subdmdcs)\n", - "# silh_state_dsas = np.array(silh_state_dsas)\n", - "# silh_ctrl_dmdcs = np.array(silh_ctrl_dmdcs)\n", - "# silh_ctrl_subdmdcs = np.array(silh_ctrl_subsdmdcs)\n", - "# silh_ctrl_dsas = np.array(silh_ctrl_dsas)\n", - "\n", - "# # Save data\n", - "# np.savez(f'silhouette_data_n_use.npz',\n", - "# silh_state_dmdcs=silh_state_dmdcs,\n", - "# silh_state_subdmdcs=silh_state_subdmdcs,\n", - "# silh_state_dsas=silh_state_dsas,\n", - "# silh_ctrl_dmdcs=silh_ctrl_dmdcs,\n", - "# silh_ctrl_subdmdcs=silh_ctrl_subdmdcs,\n", - "# silh_ctrl_dsas=silh_ctrl_dsas,\n", - "# n_uses=n_uses)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d6a705b2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "methods = ['DMD','DMDc','Subspace DMDc']\n", - "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", - "p_frac = np.array(n_uses[:len(silh_state_dmdcs)])\n", - "\n", - "fig, ax = plt.subplots(2, 1, figsize=(5,4),sharex=True)\n", - "\n", - "# Plot state silhouette scores\n", - "\n", - "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", - " ax[0].plot(p_frac, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", - " ax[0].fill_between(p_frac, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", - " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", - " color=plt.cm.Set2(i))\n", - "\n", - "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", - " ax[1].plot(p_frac, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", - " ax[1].fill_between(p_frac, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", - " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", - " color=plt.cm.Set2(i))\n", - "\n", - "ax[0].set_xscale('log')\n", - "ax[1].set_xscale('log')\n", - "ax[0].set_ylim(-0.05,1.05)\n", - "ax[1].set_ylim(-0.05,1.05)\n", - "# Create custom legend with colored text\n", - "from matplotlib.lines import Line2D\n", - "ax[0].text(0.5, 0.5, 'DMD', color=plt.cm.Set2(0), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", - "ax[0].text(0.5, 0.4, 'DMDc', color=plt.cm.Set2(1), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", - "ax[0].text(0.5, 0.3, 'SubspaceDMDc', color=plt.cm.Set2(2), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", - "\n", - "# Add subplot titles\n", - "ax[0].set_title('State', fontsize=16, pad=10)\n", - "ax[1].set_title('Input', fontsize=16, pad=3)\n", - "ax[1].set_xlabel('Number of States')\n", - "fig.text(-0.05, 0.5, 'Silhouette Score', va='center', rotation='vertical',fontsize=16)\n", - "plt.tight_layout()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "5f1c041a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/2 [00:02 11\u001b[0m silh_state_dmdc, silh_ctrl_dmdc, silh_state_subdmdc, silh_ctrl_subsdmdc, silh_state_dsa, silh_ctrl_dsa \u001b[38;5;241m=\u001b[39m \u001b[43mget_silhouette_scores\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp_out_small\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mN_small\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_iters\u001b[49m\u001b[43m,\u001b[49m\u001b[43minput_alpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_alpha\u001b[49m\u001b[43m,\u001b[49m\u001b[43mg1\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mg1\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mg2\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mg2\u001b[49m\u001b[43m,\u001b[49m\u001b[43msame_inp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43mn_Us\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_Us\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_delays\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\u001b[43mrank\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mr\u001b[49m\u001b[43m,\u001b[49m\u001b[43mpf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[43m \u001b[49m\u001b[43mobs_noise\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mobs_noise\u001b[49m\u001b[43m,\u001b[49m\u001b[43mprocess_noise\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprocess_noise\u001b[49m\u001b[43m,\u001b[49m\u001b[43mnonlinear_eps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnonlinear_eps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 15\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 16\u001b[0m silh_state_dmdcs\u001b[38;5;241m.\u001b[39mappend(silh_state_dmdc)\n\u001b[1;32m 17\u001b[0m silh_ctrl_dmdcs\u001b[38;5;241m.\u001b[39mappend(silh_ctrl_dmdc)\n", - "Cell \u001b[0;32mIn[32], line 32\u001b[0m, in \u001b[0;36mget_silhouette_scores\u001b[0;34m(n, m, p_out, N, n_iters, input_alpha, g1, g2, same_inp, n_Us, n_delays, pf, rank, process_noise, obs_noise, nonlinear_eps, nonlinear_func, y_feature_map, u_feature_map, backend, use_joint_control)\u001b[0m\n\u001b[1;32m 29\u001b[0m Us \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mmap\u001b[39m(u_feature_map, Us))\n\u001b[1;32m 31\u001b[0m A_cs, B_cs \u001b[38;5;241m=\u001b[39m get_dmdcs(Ys,Us,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[0;32m---> 32\u001b[0m As, Bs, Cs, infos \u001b[38;5;241m=\u001b[39m \u001b[43mget_subspace_dmdcs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mYs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mUs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrank\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m A_dmds \u001b[38;5;241m=\u001b[39m get_dmds(Ys,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[1;32m 35\u001b[0m sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc \u001b[38;5;241m=\u001b[39m compare_systems_full(A_cs,B_cs)\n", - "\u001b[0;31mTypeError\u001b[0m: get_subspace_dmdcs() got an unexpected keyword argument 'f'" - ] - } - ], - "source": [ - "rs = np.arange(2,25,1)\n", - "n_iters = 2\n", - "silh_state_dmdcs = []\n", - "silh_ctrl_dmdcs = []\n", - "silh_state_subdmdcs = []\n", - "silh_ctrl_subsdmdcs = []\n", - "silh_state_dsas = []\n", - "silh_ctrl_dsas = []\n", - "\n", - "for r in rs:\n", - " silh_state_dmdc, silh_ctrl_dmdc, silh_state_subdmdc, silh_ctrl_subsdmdc, silh_state_dsa, silh_ctrl_dsa = get_silhouette_scores(n,m,p_out_small,\n", - " N_small,n_iters,input_alpha=input_alpha,g1=g1,\n", - " g2=g2,same_inp=False,n_Us=n_Us,n_delays=n_delays,rank=r,pf=pf,\n", - " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps,\n", - " backend=backend)\n", - " silh_state_dmdcs.append(silh_state_dmdc)\n", - " silh_ctrl_dmdcs.append(silh_ctrl_dmdc)\n", - " silh_state_subdmdcs.append(silh_state_subdmdc)\n", - " silh_ctrl_subsdmdcs.append(silh_ctrl_subsdmdc)\n", - " silh_state_dsas.append(silh_state_dsa)\n", - " silh_ctrl_dsas.append(silh_ctrl_dsa)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0a65665b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "methods = ['DMD','DMDc','Subspace DMDc']\n", - "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", - "\n", - "fig, ax = plt.subplots(1,2, figsize=(8,3),sharex=True)\n", - "\n", - "# Plot state silhouette scores\n", - "\n", - "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", - " ax[0].plot(rs, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", - " ax[0].fill_between(rs, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", - " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", - " color=plt.cm.Set2(i))\n", - "\n", - "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", - " ax[1].plot(rs, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", - " ax[1].fill_between(rs, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", - " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", - " color=plt.cm.Set2(i))\n", - "\n", - "# ax[0].set_xscale('log')\n", - "# ax[1].set_xscale('log')\n", - "ax[0].set_ylim(-0.05,1.05)\n", - "ax[1].set_ylim(-0.05,1.05)\n", - "# Create custom legend with colored text\n", - "from matplotlib.lines import Line2D\n", - "ax[0].text(1.4, 0.8, 'SubspaceDMDc', color=plt.cm.Set2(2), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", - "ax[0].text(1.4, 0.65, 'DMDc', color=plt.cm.Set2(1), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", - "ax[0].text(1.4, 0.5, 'DMD', color=plt.cm.Set2(0), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", - "\n", - "# Add subplot titles\n", - "ax[0].set_title('State', fontsize=16, pad=10)\n", - "ax[1].set_title('Input', fontsize=16, pad=3)\n", - "ax[1].set_xlabel('Rank of DMD')\n", - "fig.text(-0.05, 0.5, 'Silhouette Score', va='center', rotation='vertical',fontsize=16)\n", - "plt.tight_layout()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b1ac349b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/2 [00:15 27\u001b[0m ss_dmdc, sc_dmdc, ss_subdmdc, sc_subdmdc, ss_dsa, sc_dsa \u001b[38;5;241m=\u001b[39m \u001b[43mget_silhouette_scores\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp_out\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[43m \u001b[49m\u001b[43mN\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_iters\u001b[49m\u001b[43m,\u001b[49m\u001b[43mrng\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43minput_alpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.001\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mg1\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[43m \u001b[49m\u001b[43mg2\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43msame_inp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43mn_Us\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_Us\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_delays\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_delays\u001b[49m\u001b[43m,\u001b[49m\u001b[43mrank\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mpf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[43m \u001b[49m\u001b[43mnonlinear_eps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnonlinear_eps\u001b[49m\u001b[43m,\u001b[49m\u001b[43mnonlinear_func\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtanh\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 31\u001b[0m \u001b[43m \u001b[49m\u001b[43my_feature_map\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mY_feature_map\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu_feature_map\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mU_feature_map\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 32\u001b[0m silh_state_dmdcs\u001b[38;5;241m.\u001b[39mappend(ss_dmdc)\n\u001b[1;32m 33\u001b[0m silh_ctrl_dmdcs\u001b[38;5;241m.\u001b[39mappend(sc_dmdc)\n", - "Cell \u001b[0;32mIn[198], line 40\u001b[0m, in \u001b[0;36mget_silhouette_scores\u001b[0;34m(n, m, p_out, N, n_iters, rng, input_alpha, g1, g2, same_inp, n_Us, n_delays, pf, rank, process_noise, obs_noise, nonlinear_eps, nonlinear_func, y_feature_map, u_feature_map)\u001b[0m\n\u001b[1;32m 37\u001b[0m Us \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mmap\u001b[39m(u_feature_map, Us))\n\u001b[1;32m 39\u001b[0m A_cs, B_cs \u001b[38;5;241m=\u001b[39m get_dmdcs(Ys,Us,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[0;32m---> 40\u001b[0m As, Bs, Cs, infos \u001b[38;5;241m=\u001b[39m \u001b[43mget_subspace_dmdcs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mYs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mUs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpf\u001b[49m\u001b[43m,\u001b[49m\u001b[43mn_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrank\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mn4sid\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 41\u001b[0m A_dmds \u001b[38;5;241m=\u001b[39m get_dmds(Ys,n_delays\u001b[38;5;241m=\u001b[39mn_delays,rank\u001b[38;5;241m=\u001b[39mrank)\n\u001b[1;32m 43\u001b[0m _, _, _, sims_control_separate_dmdc, sims_state_separate_dmdc \u001b[38;5;241m=\u001b[39m compare_systems_full(A_cs,B_cs)\n", - "Cell \u001b[0;32mIn[186], line 36\u001b[0m, in \u001b[0;36mget_subspace_dmdcs\u001b[0;34m(Ys, Us, p, f, n_id, backend)\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;66;03m# N4SID identification\u001b[39;00m\n\u001b[1;32m 29\u001b[0m nfoursid \u001b[38;5;241m=\u001b[39m NFourSID(\n\u001b[1;32m 30\u001b[0m df,\n\u001b[1;32m 31\u001b[0m output_columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(Y\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m])],\n\u001b[1;32m 32\u001b[0m input_columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mu\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(U\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m])],\n\u001b[1;32m 33\u001b[0m num_block_rows\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mmin\u001b[39m(p, f)\n\u001b[1;32m 34\u001b[0m )\n\u001b[0;32m---> 36\u001b[0m \u001b[43mnfoursid\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubspace_identification\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;66;03m# Determine rank - use n_id if provided, otherwise auto-determine\u001b[39;00m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_id \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/Desktop/Projects/AgentDSA/AgentDSA/n4sid/nfoursid/src/nfoursid/nfoursid.py:90\u001b[0m, in \u001b[0;36mNFourSID.subspace_identification\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 87\u001b[0m y_past, y_future \u001b[38;5;241m=\u001b[39m y_hankel[:, :\u001b[38;5;241m-\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows], y_hankel[:, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows:]\n\u001b[1;32m 88\u001b[0m u_instrumental_y \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mconcatenate([u_future, u_past, y_past, y_future])\n\u001b[0;32m---> 90\u001b[0m q, r \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m matrix: matrix\u001b[38;5;241m.\u001b[39mT, \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinalg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqr\u001b[49m\u001b[43m(\u001b[49m\u001b[43mu_instrumental_y\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mreduced\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 92\u001b[0m y_rows, u_rows \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39my_dim \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mu_dim \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_block_rows\n\u001b[1;32m 93\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mR32 \u001b[38;5;241m=\u001b[39m r[\u001b[38;5;241m-\u001b[39my_rows:, u_rows:\u001b[38;5;241m-\u001b[39my_rows]\n", - "File \u001b[0;32m~/opt/anaconda3/envs/iblenv/lib/python3.10/site-packages/numpy/linalg/linalg.py:952\u001b[0m, in \u001b[0;36mqr\u001b[0;34m(a, mode)\u001b[0m\n\u001b[1;32m 950\u001b[0m signature \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mD->D\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m isComplexType(t) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124md->d\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 951\u001b[0m extobj \u001b[38;5;241m=\u001b[39m get_linalg_error_extobj(_raise_linalgerror_qr)\n\u001b[0;32m--> 952\u001b[0m tau \u001b[38;5;241m=\u001b[39m \u001b[43mgufunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msignature\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msignature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextobj\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 954\u001b[0m \u001b[38;5;66;03m# handle modes that don't return q\u001b[39;00m\n\u001b[1;32m 955\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m:\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[0;32m/Users/mitchellostrow/opt/anaconda3/envs/iblenv/lib/python3.10/site-packages/numpy/linalg/linalg.py\u001b[0m(952)\u001b[0;36mqr\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m 950 \u001b[0;31m \u001b[0msignature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'D->D'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misComplexType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'd->d'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 951 \u001b[0;31m \u001b[0mextobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_linalg_error_extobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_raise_linalgerror_qr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m--> 952 \u001b[0;31m \u001b[0mtau\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgufunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mextobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 953 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 954 \u001b[0;31m \u001b[0;31m# handle modes that don't return q\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\n" - ] - } - ], - "source": [ - "#varying eps and observing changes\n", - "\n", - "nonlinear_eps_range = np.arange(0.1,1.1,0.1)\n", - "n_iters_local = 2 # override for this analysis\n", - "\n", - "Y_feature_map = lambda x: x #np.concatenate([x,x**3,x**5],axis=0)\n", - "U_feature_map = lambda x: x\n", - "\n", - "silh_state_dmdcs = []\n", - "silh_ctrl_dmdcs = []\n", - "silh_state_subdmdcs = []\n", - "silh_ctrl_subsdmdcs = []\n", - "silh_state_dsas = []\n", - "silh_ctrl_dsas = []\n", - "\n", - "for i, nonlinear_eps in enumerate(nonlinear_eps_range):\n", - " print(nonlinear_eps)\n", - " ss_dmdc, sc_dmdc, ss_subdmdc, sc_subdmdc, ss_dsa, sc_dsa = get_silhouette_scores(n,m,p_out,\n", - " N,n_iters_local,input_alpha=input_alpha,g1=g1,\n", - " g2=g2,same_inp=False,n_Us=n_Us,n_delays=n_delays,rank=20,pf=200,\n", - " nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x),\n", - " y_feature_map = Y_feature_map, u_feature_map = U_feature_map)\n", - " silh_state_dmdcs.append(ss_dmdc)\n", - " silh_ctrl_dmdcs.append(sc_dmdc)\n", - " silh_state_subdmdcs.append(ss_subdmdc)\n", - " silh_ctrl_subsdmdcs.append(sc_subdmdc)\n", - " silh_state_dsas.append(ss_dsa)\n", - " silh_ctrl_dsas.append(sc_dsa)\n", - "\n", - " print(np.mean(silh_state_dmdcs),np.mean(silh_state_subdmdcs),np.mean(silh_state_dsas))\n", - " print()\n", - "\n", - "\n", - "silh_state_dmdcs = np.array(silh_state_dmdcs)\n", - "silh_state_subdmdcs = np.array(silh_state_subdmdcs)\n", - "silh_state_dsas = np.array(silh_state_dsas)\n", - "silh_ctrl_dmdcs = np.array(silh_ctrl_dmdcs)\n", - "silh_ctrl_subdmdcs = np.array(silh_ctrl_subsdmdcs)\n", - "silh_ctrl_dsas = np.array(silh_ctrl_dsas)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a7b0352b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/mitchellostrow/opt/anaconda3/envs/iblenv/lib/python3.10/site-packages/IPython/core/pylabtools.py:170: UserWarning: Tight layout not applied. The bottom and top margins cannot be made large enough to accommodate all axes decorations.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", - "methods = [ 'DMD','DMDC', 'Subspace DMDC']\n", - "\n", - "non_eps = nonlinear_eps_range[:len(silh_state_dmdcs)]\n", - "\n", - "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n", - "\n", - "# Plot state silhouette scores\n", - "\n", - "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", - " ax.plot(non_eps, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", - " ax.fill_between(non_eps, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", - " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", - " color=plt.cm.Set2(i))\n", - "\n", - "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", - " ax.plot(non_eps, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", - " ax.fill_between(non_eps, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", - " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", - " color=plt.cm.Set2(i))\n", - "\n", - "\n", - "ax.legend(loc='lower right',bbox_to_anchor=(1.5, 1))\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "jaxenv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb new file mode 100644 index 0000000..10733a8 --- /dev/null +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -0,0 +1,1144 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comprehensive Tutorial: How to Use DSA Classes\n", + "\n", + "This notebook provides a comprehensive guide to using the different DSA classes:\n", + "1. **GeneralizedDSA**: The most flexible class supporting different DMD types and similarity metrics\n", + "2. **InputDSA**: Specialized for systems with control inputs (subclass of GeneralizedDSA)\n", + "3. **DSA**: The standard DSA algorithm from Ostrow et al. (2023)\n", + "\n", + "We'll cover:\n", + "- How to pass in different data structures\n", + "- How to configure DMD and similarity metrics (using dataclasses or dictionaries)\n", + "- How to use prediction and stats error to run hyperparameter sweeps\n", + "\n", + "## Table of Contents\n", + "1. [Setup and Data Generation](#setup)\n", + "2. [Data Structure Options](#data-structures)\n", + "3. [GeneralizedDSA Class](#generalized-dsa)\n", + "4. [InputDSA Class](#input-dsa)\n", + "5. [DSA Class (Standard)](#standard-dsa)\n", + "6. [Hyperparameter Sweeps](#hyperparameter-sweeps)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup and Data Generation \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "from DSA import DSA, GeneralizedDSA, InputDSA\n", + "\n", + "from DSA import DMD, DMDc, SubspaceDMDc\n", + "\n", + "from DSA import SimilarityTransformDist, ControllabilitySimilarityTransformDist\n", + "\n", + "from DSA import (\n", + " DMDConfig, \n", + " DMDcConfig, \n", + " SubspaceDMDcConfig,\n", + " SimilarityTransformDistConfig,\n", + " ControllabilitySimilarityTransformDistConfig\n", + ")\n", + "\n", + "import DSA.pykoopman as pk\n", + "from pydmd import DMD as pDMD, SubspaceDMD\n", + "\n", + "from DSA.sweeps import sweep_ranks_delays\n", + "from DSA.stats import compute_all_stats\n", + "\n", + "np.random.seed(22)\n", + "torch.manual_seed(22)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate synthetic data for demonstrations\n", + "\n", + "We'll create simple dynamical systems for testing\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_linear_system(n_time=100, n_features=5, n_trials=10, eigenvalue_range=(0.8, 0.95)):\n", + " \"\"\"\n", + " Generate data from a stable linear dynamical system.\n", + " \"\"\"\n", + " # Create a random stable system matrix\n", + " A_true = np.random.randn(n_features, n_features)\n", + " # Make it stable by scaling eigenvalues\n", + " eigvals, eigvecs = np.linalg.eig(A_true)\n", + " eigvals = eigvals / np.abs(eigvals) * np.random.uniform(*eigenvalue_range, size=n_features)\n", + " A_true = eigvecs @ np.diag(eigvals) @ np.linalg.inv(eigvecs)\n", + " A_true = np.real(A_true)\n", + " \n", + " # Generate trajectories\n", + " data = np.zeros((n_trials, n_time, n_features))\n", + " for trial in range(n_trials):\n", + " x = np.random.randn(n_features) * 0.1\n", + " for t in range(n_time):\n", + " data[trial, t] = x\n", + " x = A_true @ x + np.random.randn(n_features) * 0.01 # Add small noise\n", + " \n", + " return data, A_true\n", + "\n", + "def generate_controlled_system(n_time=100, n_features=5, n_control=2, n_trials=10):\n", + " \"\"\"\n", + " Generate data from a controlled linear dynamical system.\n", + " \"\"\"\n", + " # Create system matrices\n", + " A_true = np.random.randn(n_features, n_features) * 0.5\n", + " A_true = A_true / np.max(np.abs(np.linalg.eigvals(A_true))) * 0.9 # Make stable\n", + " B_true = np.random.randn(n_features, n_control) * 0.3\n", + " \n", + " # Generate trajectories with control\n", + " data = np.zeros((n_trials, n_time, n_features))\n", + " control = np.zeros((n_trials, n_time, n_control))\n", + " \n", + " for trial in range(n_trials):\n", + " x = np.random.randn(n_features) * 0.1\n", + " for t in range(n_time):\n", + " u = np.random.randn(n_control) * 0.5 # Random control input\n", + " control[trial, t] = u\n", + " data[trial, t] = x\n", + " x = A_true @ x + B_true @ u + np.random.randn(n_features) * 0.01\n", + " \n", + " return data, control, A_true, B_true" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Data Structure Options \n", + "\n", + "DSA classes accept multiple data structure formats:\n", + "\n", + "### Single System Comparison\n", + "- **2D array**: `(time, features)` - Single trajectory\n", + "- **3D array**: `(trials, time, features)` - Multiple trials from same system\n", + "\n", + "### Multiple System Comparisons\n", + "- **Pairwise**: Pass a list of data matrices `[X1, X2, X3, ...]` for all-to-all comparison\n", + "- **Disjoint Pairwise**: Pass two lists `X=[X1,X2,...]` and `Y=[Y1,Y2,...]` for bipartite comparison\n", + "- **One-to-All**: Pass a list `X=[X1,X2,...]` and single matrix `Y` to compare all X to Y\n", + "\n", + "### Lists of Variable-Length Trajectories\n", + "- **List of 2D arrays**: `[array(t1,f), array(t2,f), ...]` - Different length trajectories\n", + "- **List of 3D arrays**: `[array(n1,t,f), array(n2,t,f), ...]` - Different numbers of trials\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2D data shape: (100, 5)\n", + "3D data shape: (10, 100, 5)\n", + "List of 2D arrays: 5 arrays with shapes [(50, 5), (60, 5), (70, 5), (80, 5), (90, 5)]\n", + "List of 3D arrays: 3 arrays with shapes [(5, 100, 5), (6, 100, 5), (7, 100, 5)]\n", + "Mixed list: 8 arrays\n" + ] + } + ], + "source": [ + "# Example 1: Single 2D trajectory\n", + "data_2d = np.random.randn(100, 5) # (time, features)\n", + "print(f\"2D data shape: {data_2d.shape}\")\n", + "\n", + "# Example 2: Multiple trials (3D array)\n", + "data_3d = np.random.randn(10, 100, 5) # (trials, time, features)\n", + "print(f\"3D data shape: {data_3d.shape}\")\n", + "\n", + "# Example 3: List of 2D arrays with variable lengths\n", + "data_list_2d = [np.random.randn(50 + i*10, 5) for i in range(5)] # Variable time lengths\n", + "print(f\"List of 2D arrays: {len(data_list_2d)} arrays with shapes {[d.shape for d in data_list_2d]}\")\n", + "\n", + "# Example 4: List of 3D arrays with variable trial counts\n", + "data_list_3d = [np.random.randn(i+5, 100, 5) for i in range(3)] # Variable trial counts\n", + "print(f\"List of 3D arrays: {len(data_list_3d)} arrays with shapes {[d.shape for d in data_list_3d]}\")\n", + "\n", + "# Example 5: Mixed list (2D and 3D arrays)\n", + "data_mixed = data_list_2d + data_list_3d\n", + "print(f\"Mixed list: {len(data_mixed)} arrays\")\n", + "\n", + "#All data structures are valid inputs for DSA classes!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. GeneralizedDSA Class \n", + "\n", + "The `GeneralizedDSA` class is the most flexible, allowing you to:\n", + "- Use different DMD algorithms (standard DMD, Kernel DMD, Neural DMD, etc.)\n", + "- Use different similarity metrics (angular, euclidean, Wasserstein)\n", + "- Configure via dataclasses or dictionaries\n", + "\n", + "### 3.1 Basic Usage with Default DMD\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 218.44it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.96s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Similarity matrix shape: (2, 2)\n", + "Similarity between systems: 0.1501\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate two similar systems\n", + "data1, A1 = generate_linear_system(n_time=100, n_features=5, n_trials=8)\n", + "data2, A2 = generate_linear_system(n_time=100, n_features=5, n_trials=8)\n", + "\n", + "A1eigs = np.linalg.eigvals(A1)\n", + "A2eigs = np.linalg.eigvals(A2)\n", + "\n", + "plt.scatter(A1eigs.real,A1eigs.imag)\n", + "plt.scatter(A2eigs.real,A2eigs.imag)\n", + "plt.xlabel(\"Real\")\n", + "plt.ylabel(\"Imag\")\n", + "\n", + "# Compare using GeneralizedDSA with default settings\n", + "gdsa = GeneralizedDSA(\n", + " [data1, data2],\n", + " dmd_class=DMD,\n", + " similarity_class=SimilarityTransformDist,\n", + " verbose=True\n", + ")\n", + "\n", + "# Fit and score\n", + "similarity_matrix = gdsa.fit_score()\n", + "print(f\"\\nSimilarity matrix shape: {similarity_matrix.shape}\")\n", + "print(f\"Similarity between systems: {similarity_matrix[0, 1]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 Using Configuration Dataclasses\n", + "\n", + "Dataclasses provide type safety and clear documentation of parameters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 239.52it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity with custom config: 0.3253\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Define configurations using dataclasses\n", + "dmd_config = DMDConfig(\n", + " n_delays=3, # Use 3 time delays\n", + " delay_interval=1, # Consecutive time steps\n", + " rank=10, # Truncate to rank 10\n", + " lamb=0.01, # Small regularization\n", + " send_to_cpu=False # Use GPU if available\n", + ")\n", + "\n", + "simdist_config = SimilarityTransformDistConfig(\n", + " iters=1000, # Optimization iterations\n", + " score_method='angular', # Use angular distance\n", + " lr=5e-3, # Learning rate\n", + ")\n", + "\n", + "# Use configurations in GeneralizedDSA\n", + "gdsa = GeneralizedDSA(\n", + " [data1, data2],\n", + " dmd_class=DMD,\n", + " similarity_class=SimilarityTransformDist,\n", + " dmd_config=dmd_config,\n", + " simdist_config=simdist_config,\n", + " verbose=True,\n", + " device='cpu' # or 'cuda' for GPU\n", + ")\n", + "\n", + "similarity_matrix = gdsa.fit_score()\n", + "print(f\"Similarity with custom config: {similarity_matrix[0, 1]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3 Using Dictionary Configurations\n", + "\n", + "Dictionaries offer more flexibility and are easier for parameter sweeps.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity with dict config: 0.3126\n" + ] + }, + { + "data": { + "text/plain": [ + "((8, 100, 5), torch.Size([15, 15]))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define configurations using dictionaries\n", + "dmd_config_dict = {\n", + " 'n_delays': 5,\n", + " 'delay_interval': 1,\n", + " 'rank': 15,\n", + " 'lamb': 0.001\n", + "}\n", + "\n", + "simdist_config_dict = {\n", + " 'iters': 1500,\n", + " 'score_method': 'euclidean',\n", + " 'lr': 1e-3\n", + "}\n", + "\n", + "gdsa = GeneralizedDSA(\n", + " [data1, data2],\n", + " dmd_class=DMD,\n", + " similarity_class=SimilarityTransformDist,\n", + " dmd_config=dmd_config_dict,\n", + " simdist_config=simdist_config_dict,\n", + " verbose=False\n", + ")\n", + "\n", + "similarity_matrix = gdsa.fit_score()\n", + "print(f\"Similarity with dict config: {similarity_matrix[0, 1]:.4f}\")\n", + "\n", + "data1.shape, gdsa.dmds[0][0].A_v.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.4 Using PyKoopman DMD Models\n", + "\n", + "GeneralizedDSA integrates with PyKoopman for advanced observables and regressors.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 1it [00:00, 321.13it/s]\n", + "Fitting DMDs: 1it [00:00, 418.93it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 29.62it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity with PyKoopman: 0.9291\n", + "(8, 100, 5)\n", + "(2, 2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Use TimeDelay observables with SubspaceDMD regressor from pydmd\n", + "observables = pk.observables.TimeDelay(n_delays=10)\n", + "regressor = SubspaceDMD(svd_rank=-1)\n", + "\n", + "# Create configuration\n", + "from dataclasses import dataclass\n", + "\n", + "@dataclass\n", + "class CustomPyKoopmanConfig:\n", + " observables = observables\n", + " regressor = regressor\n", + "\n", + "gdsa = GeneralizedDSA(\n", + " data1, data2,\n", + " dmd_class=pk.Koopman,\n", + " similarity_class=SimilarityTransformDist,\n", + " dmd_config=CustomPyKoopmanConfig(),\n", + " simdist_config={'score_method': 'wasserstein'},\n", + " verbose=True\n", + ")\n", + "\n", + "similarity_matrix = gdsa.fit_score()\n", + "print(f\"Similarity with PyKoopman: {similarity_matrix:.4f}\")\n", + "print(data1.shape)\n", + "print(gdsa.dmds[0][0].A.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. InputDSA Class \n", + "\n", + "The `InputDSA` class extends GeneralizedDSA for controlled systems, comparing both:\n", + "- **Intrinsic (recurrent) dynamics** (A matrix)\n", + "- **Input-driven dynamics** (B matrix)\n", + "\n", + "Two DMD variants are available:\n", + "- **DMDc**: Standard DMD with control (Proctor et al., 2016)\n", + "- **SubspaceDMDc**: Subspace identification approach (Huang & Ostrow et al., 2025) - recommended for partially observed systems\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1 Basic InputDSA with DMDc\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data shape: (8, 100, 5)\n", + "Control shape: (8, 100, 2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 411.19it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 326.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "InputDSA similarity: 3.3637\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Generate two controlled systems\n", + "data1, control1, A1, B1 = generate_controlled_system(n_time=100, n_features=5, n_control=2, n_trials=8)\n", + "data2, control2, A2, B2 = generate_controlled_system(n_time=100, n_features=5, n_control=2, n_trials=8)\n", + "\n", + "print(f\"Data shape: {data1.shape}\")\n", + "print(f\"Control shape: {control1.shape}\")\n", + "\n", + "idsa = InputDSA(\n", + " [data1, data2],\n", + " [control1, control2],\n", + " dmd_class=DMDc,\n", + " dmd_config=DMDcConfig(\n", + " n_delays=2,\n", + " rank_input=None,\n", + " rank_output=10,\n", + " lamb=0.01\n", + " ),\n", + " simdist_config=ControllabilitySimilarityTransformDistConfig(\n", + " score_method='euclidean',\n", + " compare='joint' # Compare both A and B via controllability\n", + " ),\n", + " verbose=True\n", + ")\n", + "\n", + "similarity = idsa.fit_score()\n", + "print(f\"\\nInputDSA similarity: {similarity[0, 1]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.2 InputDSA with SubspaceDMDc\n", + "\n", + "SubspaceDMDc is better for partially observed systems and handles rank selection more robustly.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 52.81it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 2021.35it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SubspaceDMDc similarity: 0.9359\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Use SubspaceDMDc backend\n", + "idsa = InputDSA(\n", + " [data1, data2],\n", + " [control1, control2],\n", + " dmd_class=SubspaceDMDc,\n", + " dmd_config=SubspaceDMDcConfig(\n", + " n_delays=3,\n", + " rank=8,\n", + " backend='n4sid' # or 'custom'\n", + " ),\n", + " simdist_config=ControllabilitySimilarityTransformDistConfig(\n", + " score_method='euclidean',\n", + " compare='joint'\n", + " ),\n", + " verbose=True\n", + ")\n", + "\n", + "similarity = idsa.fit_score()\n", + "print(f\"\\nSubspaceDMDc similarity: {similarity[0, 1]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.3 InputDSA Comparison Modes\n", + "\n", + "InputDSA offers three comparison modes:\n", + "1. **'state'**: Compare only A matrices (intrinsic dynamics)\n", + "2. **'control'**: Compare only B matrices (input effects)\n", + "3. **'joint'**: Compare both A and B via controllability Gramian\n", + "\n", + "\n", + "For computational efficiency, you don't have to recompute the dmds each time. Simply run the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:408: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "control similarity: 0.0043\n", + "state similarity: 0.5079\n", + "joint similarity: 2.2604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "comparison_modes = ['state', 'control', 'joint']\n", + "results = {}\n", + "\n", + "idsa = InputDSA(\n", + " [data1, data2],\n", + " [control1, control2],\n", + " dmd_class=DMDc,\n", + " dmd_config={'n_delays': 2, 'rank_output': 10},\n", + " simdist_config={\n", + " 'score_method': 'euclidean',\n", + " 'compare': 'control'\n", + " },\n", + " verbose=False\n", + ")\n", + "similarity = idsa.fit_score()\n", + "results['control'] = similarity[0, 1]\n", + "print(f\"{'control':10s} similarity: {similarity[0, 1]:.4f}\")\n", + "\n", + "state_config = SimilarityTransformDistConfig\n", + "joint_config = ControllabilitySimilarityTransformDistConfig\n", + "\n", + "for mode,cfg in zip(['state','joint'],[state_config,joint_config]):\n", + " idsa.update_compare_method(compare=mode,simdist_config=cfg)\n", + " similarity = idsa.score()\n", + " results[mode] = similarity[0, 1]\n", + " print(f\"{mode:10s} similarity: {similarity[0, 1]:.4f}\")\n", + "\n", + "\n", + "# Visualize\n", + "plt.figure(figsize=(8, 4))\n", + "plt.bar(results.keys(), results.values())\n", + "plt.ylabel('Similarity Score')\n", + "plt.title('InputDSA: Comparison of Different Modes')\n", + "plt.ylim([0, 1])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.4 InputDSA with Distance Components\n", + "\n", + "Set `return_distance_components=True` to get three metrics:\n", + "1. Full controllability distance\n", + "2. Jointly optimized state similarity\n", + "3. Jointly optimized control similarity\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Components shape: (2, 2, 3)\n", + "\n", + "Distance components between systems 0 and 1:\n", + " Controllability distance: 3.4692\n", + " State similarity: 1.5174\n", + " Control similarity: 0.0637\n" + ] + } + ], + "source": [ + "idsa = InputDSA(\n", + " [data1, data2],\n", + " [control1, control2],\n", + " dmd_class=DMDc,\n", + " dmd_config={'n_delays': 2, 'rank_output': 10},\n", + " simdist_config={\n", + " 'score_method': 'euclidean',\n", + " 'compare': 'joint',\n", + " 'return_distance_components': True\n", + " },\n", + " verbose=False\n", + ")\n", + "\n", + "components = idsa.fit_score()\n", + "print(f\"Components shape: {components.shape}\") # (n_systems, n_systems, 3)\n", + "print(f\"\\nDistance components between systems 0 and 1:\")\n", + "print(f\" Controllability distance: {components[0, 1, 0]:.4f}\")\n", + "print(f\" State similarity: {components[0, 1, 1]:.4f}\")\n", + "print(f\" Control similarity: {components[0, 1, 2]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. DSA Class (Standard) \n", + "\n", + "The `DSA` class implements the original algorithm from Ostrow et al. (2023). This was written so that if you have been using DSA, you don't ahve to change your code (backwards compatibility)!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.1 Basic DSA Usage\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 342.95it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 3.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "DSA similarity: 0.3565\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Generate data\n", + "data1, _ = generate_linear_system(n_time=100, n_features=5, n_trials=10)\n", + "data2, _ = generate_linear_system(n_time=100, n_features=5, n_trials=10)\n", + "\n", + "# Standard DSA with simple interface\n", + "dsa = DSA(\n", + " [data1, data2],\n", + " n_delays=3,\n", + " rank=10,\n", + " delay_interval=1,\n", + " score_method='angular',\n", + " verbose=True,\n", + " device='cpu'\n", + ")\n", + "\n", + "similarity = dsa.fit_score()\n", + "print(f\"\\nDSA similarity: {similarity[0, 1]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Hyperparameter Sweeps \n", + "\n", + "Finding optimal hyperparameters (n_delays, rank) is crucial for DMD performance.\n", + "We can use prediction error and statistical measures to guide selection.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.1 Basic Hyperparameter Sweep\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test data shape: (12, 150, 5)\n", + "\n", + "Running hyperparameter sweep...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:00<00:00, 18.58it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Sweep completed!\n", + "AIC shape: (5, 6)\n", + "MASE shape: (5, 6)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Generate a test system\n", + "test_data, _ = generate_linear_system(n_time=150, n_features=5, n_trials=12)\n", + "print(f\"Test data shape: {test_data.shape}\")\n", + "\n", + "# Define parameter ranges\n", + "n_delays_range = [1, 2, 3, 5, 7]\n", + "ranks_range = [3, 5, 8, 10, 12, 15]\n", + "\n", + "# Run sweep\n", + "print(\"\\nRunning hyperparameter sweep...\")\n", + "all_aics, all_mases, all_nnormals, all_residuals, all_l2norms = sweep_ranks_delays(\n", + " test_data,\n", + " n_delays=n_delays_range,\n", + " ranks=ranks_range,\n", + " train_frac=0.7, # Use 70% for training, 30% for testing\n", + " reseed=5,\n", + " return_residuals=True,\n", + " return_transient_growth=True,\n", + " device='cpu'\n", + ")\n", + "\n", + "print(f\"\\nSweep completed!\")\n", + "print(f\"AIC shape: {all_aics.shape}\")\n", + "print(f\"MASE shape: {all_mases.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.2 Visualizing Sweep Results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Optimal parameters based on MASE:\n", + " n_delays: 5\n", + " rank: 15\n", + " MASE: 0.4495\n" + ] + } + ], + "source": [ + "# Create heatmaps for different metrics\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 12))\n", + "\n", + "# AIC (Akaike Information Criterion - lower is better)\n", + "im1 = axes[0, 0].imshow(all_aics, cmap='viridis', aspect='auto')\n", + "axes[0, 0].set_title('AIC (lower = better)')\n", + "axes[0, 0].set_xlabel('Rank')\n", + "axes[0, 0].set_ylabel('n_delays')\n", + "axes[0, 0].set_xticks(range(len(ranks_range)))\n", + "axes[0, 0].set_xticklabels(ranks_range)\n", + "axes[0, 0].set_yticks(range(len(n_delays_range)))\n", + "axes[0, 0].set_yticklabels(n_delays_range)\n", + "plt.colorbar(im1, ax=axes[0, 0])\n", + "\n", + "# MASE (Mean Absolute Scaled Error - lower is better)\n", + "im2 = axes[0, 1].imshow(all_mases, cmap='viridis', aspect='auto')\n", + "axes[0, 1].set_title('MASE (lower = better)')\n", + "axes[0, 1].set_xlabel('Rank')\n", + "axes[0, 1].set_ylabel('n_delays')\n", + "axes[0, 1].set_xticks(range(len(ranks_range)))\n", + "axes[0, 1].set_xticklabels(ranks_range)\n", + "axes[0, 1].set_yticks(range(len(n_delays_range)))\n", + "axes[0, 1].set_yticklabels(n_delays_range)\n", + "plt.colorbar(im2, ax=axes[0, 1])\n", + "\n", + "# Non-normality (lower = more normal, better behaved)\n", + "im3 = axes[1, 0].imshow(all_nnormals, cmap='viridis', aspect='auto')\n", + "axes[1, 0].set_title('Non-normality')\n", + "axes[1, 0].set_xlabel('Rank')\n", + "axes[1, 0].set_ylabel('n_delays')\n", + "axes[1, 0].set_xticks(range(len(ranks_range)))\n", + "axes[1, 0].set_xticklabels(ranks_range)\n", + "axes[1, 0].set_yticks(range(len(n_delays_range)))\n", + "axes[1, 0].set_yticklabels(n_delays_range)\n", + "plt.colorbar(im3, ax=axes[1, 0])\n", + "\n", + "# L2 Norm (transient growth measure)\n", + "im4 = axes[1, 1].imshow(all_l2norms, cmap='viridis', aspect='auto')\n", + "axes[1, 1].set_title('L2 Norm of DMD matrix')\n", + "axes[1, 1].set_xlabel('Rank')\n", + "axes[1, 1].set_ylabel('n_delays')\n", + "axes[1, 1].set_xticks(range(len(ranks_range)))\n", + "axes[1, 1].set_xticklabels(ranks_range)\n", + "axes[1, 1].set_yticks(range(len(n_delays_range)))\n", + "axes[1, 1].set_yticklabels(n_delays_range)\n", + "plt.colorbar(im4, ax=axes[1, 1])\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Find optimal parameters\n", + "best_idx = np.unravel_index(np.argmin(all_mases), all_mases.shape)\n", + "best_n_delays = n_delays_range[best_idx[0]]\n", + "best_rank = ranks_range[best_idx[1]]\n", + "print(f\"\\nOptimal parameters based on MASE:\")\n", + "print(f\" n_delays: {best_n_delays}\")\n", + "print(f\" rank: {best_rank}\")\n", + "print(f\" MASE: {all_mases[best_idx]:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.4 Using Statistics for DMD Quality Assessment\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DMD Matrix Statistics:\n", + "==================================================\n", + "MAE : 0.0077\n", + "MASE : 0.2627\n", + "NMSE : 0.1039\n", + "MSE : 0.0001\n", + "R2 : 0.8832\n", + "Correl : 0.9397\n", + "AIC : -9.2117\n", + "logMSE : -9.2521\n" + ] + } + ], + "source": [ + "data, _ = generate_linear_system(n_time=100, n_features=5, n_trials=10)\n", + "dmd = DMD(data, n_delays=3, rank=10, device='cpu')\n", + "dmd.fit()\n", + "\n", + "\n", + "pred = dmd.predict()\n", + "\n", + "stats = compute_all_stats(data,pred,dmd.rank)\n", + "\n", + "print(\"DMD Matrix Statistics:\")\n", + "print(\"=\" * 50)\n", + "for key, value in stats.items():\n", + " if isinstance(value, (int, float, np.integer, np.floating)):\n", + " print(f\"{key:25s}: {value:10.4f}\")\n", + " else:\n", + " print(f\"{key:25s}: {value}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "This notebook covered:\n", + "\n", + "### 1. **GeneralizedDSA**\n", + "- Most flexible class for custom DMD models and similarity metrics\n", + "- Supports configuration via dataclasses or dictionaries\n", + "- Integrates with PyKoopman and PyDMD\n", + "- Offers Wasserstein distance for eigenvalue comparison\n", + "\n", + "### 2. **InputDSA**\n", + "- Specialized for controlled systems\n", + "- Uses DMDc or SubspaceDMDc\n", + "- Compares state, control, or joint dynamics\n", + "- Handles surrogate inputs when true inputs are unknown\n", + "\n", + "### 3. **DSA (Standard)**\n", + "- Simplified interface for the original DSA algorithm\n", + "- Supports all data structure formats\n", + "- Multiple comparison modes (pairwise, one-to-all, disjoint)\n", + "\n", + "### 4. **Data Structures**\n", + "- Single trajectories: 2D arrays\n", + "- Multiple trials: 3D arrays\n", + "- Variable lengths: Lists of arrays\n", + "- All classes handle these formats automatically\n", + "\n", + "### 5. **Hyperparameter Sweeps**\n", + "- Use `sweep_ranks_delays()` for comprehensive parameter search\n", + "- Metrics: AIC, MASE, non-normality, transient growth\n", + "- Combine metrics for robust model selection\n", + "- Workflow: Sweep → Select → Compare\n", + "\n", + "### Best Practices:\n", + "1. Start with hyperparameter sweeps on representative data\n", + "2. Use MASE or combined metrics for model selection\n", + "3. For controlled systems, use SubspaceDMDc for partial observations\n", + "4. Use Wasserstein distance for fast, optimization-free comparisons, especially if dmd models are close to normal\n", + "5. Leverage GPU (`device='cuda'`) for large datasets\n", + "\n", + "For more details, see:\n", + "- Ostrow et al. (2023): https://arxiv.org/abs/2306.10168\n", + "- Huang & Ostrow et al. (2025): https://www.arxiv.org/abs/2510.25943\n", + "\n", + "Feel free to reach out to ostrow@mit.edu with questions or further interest!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dsa_test_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5eff5b8b83b15525dc0ab2eaa472c9aa9fe7e4e8 Mon Sep 17 00:00:00 2001 From: Mitchell Ostrow <35669245+mitchellostrow@users.noreply.github.com> Date: Wed, 5 Nov 2025 17:02:28 -0500 Subject: [PATCH 40/51] add unmentioned detail to tutorial --- examples/how_to_use_dsa_tutorial.ipynb | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb index 10733a8..f9809d7 100644 --- a/examples/how_to_use_dsa_tutorial.ipynb +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -1107,6 +1107,11 @@ "4. Use Wasserstein distance for fast, optimization-free comparisons, especially if dmd models are close to normal\n", "5. Leverage GPU (`device='cuda'`) for large datasets\n", "\n", + + "## Unmentioned topics\n", + "1. Unmentioned is parallelization of comparison (change the n_jobs parameter in the DSA class)\n", + "2. Unmentioned is gpu support (device='cuda') in all classes\n", + "For more details, see:\n", "- Ostrow et al. (2023): https://arxiv.org/abs/2306.10168\n", "- Huang & Ostrow et al. (2025): https://www.arxiv.org/abs/2510.25943\n", From 51602144400e5ba043bfee3bd48c70b81198d04c Mon Sep 17 00:00:00 2001 From: Ann Huang Date: Thu, 6 Nov 2025 16:11:13 -0500 Subject: [PATCH 41/51] updated sweep_ranks_delays to work with DMDc and SubspaceDMDc --- DSA/sweeps.py | 60 ++++++++++---- examples/how_to_use_dsa_tutorial.ipynb | 104 ++++++++++++++++++++++--- 2 files changed, 139 insertions(+), 25 deletions(-) diff --git a/DSA/sweeps.py b/DSA/sweeps.py index 510d88d..e435bbc 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -1,6 +1,8 @@ import numpy as np from tqdm import tqdm from .dmd import DMD +from .dmdc import DMDc +from .subspace_dmdc import SubspaceDMDc from .stats import ( measure_nonnormality_transpose, compute_all_stats, @@ -9,7 +11,7 @@ from .resdmd import compute_residuals import matplotlib.pyplot as plt from typing import Literal - +import warnings def split_train_test(data, train_frac=0.8): if isinstance(data, list): @@ -33,13 +35,15 @@ def sweep_ranks_delays( data, n_delays, ranks, + control_data=None, train_frac=0.8, reseed=5, return_residuals=True, return_transient_growth=False, return_mse=False, error_space="X", - **dmd_kwargs, + model_class=['DMD', 'DMDc', 'SubspaceDMDc'][0], + **model_kwargs, ): """ Sweep over combinations of DMD ranks and delays, returning AIC, MASE, non-normality, and residuals. @@ -70,7 +74,12 @@ def sweep_ranks_delays( all_aics, all_mases, all_nnormals, all_residuals, all_num_abscissa, all_l2norm : np.ndarray Arrays of results for each (delay, rank) pair. """ + if model_class in ['DMDc', 'SubspaceDMDc']: + assert control_data is not None, "Control data is required for DMDc and SubspaceDMDc" + train_data, test_data, dim = split_train_test(data, train_frac) + train_control_data, test_control_data, dim_control = split_train_test(control_data, train_frac) + all_aics, all_mases, all_nnormals, all_residuals, all_l2norm = [], [], [], [], [] for nd in tqdm(n_delays): rresiduals = [] @@ -83,16 +92,34 @@ def sweep_ranks_delays( rresiduals.append(np.inf) l2norms.append(np.inf) continue - dmd = DMD(train_data, n_delays=nd, rank=r, **dmd_kwargs) - dmd.fit() + + if model_class == 'DMD': + model = DMD(train_data, n_delays=nd, rank=r, **model_kwargs) + elif model_class == 'DMDc': + model = DMDc(train_data, train_control_data, n_delays=nd, rank_output=r, **model_kwargs) + elif model_class == 'SubspaceDMDc': + model = SubspaceDMDc(train_data, train_control_data, n_delays=nd, rank=r, **model_kwargs) + else: + raise ValueError(f"Invalid model class: {model_class}. Valid options are 'DMD', 'DMDc', and 'SubspaceDMDc'.") + model.fit() # pred, H_test_pred, H_test_true, V_test_pred, V_test_true = dmd.predict( # test_data, reseed=reseed, full_return=True # ) - pred, H_test_pred, H_test_true= dmd.predict( - test_data, reseed=reseed, full_return=True - ) + if model_class == "DMD": + pred, H_test_pred, H_test_true= model.predict( + test_data, reseed=reseed, full_return=True + ) + elif model_class == "DMDc": + pred, H_test_pred, H_test_true= model.predict( + test_data, test_control_data, reseed=reseed, full_return=True + ) + else: + pred = model.predict(test_data, test_control_data, reseed=reseed) + if error_space == "H": + if model_class == 'SubspaceDMDc': + raise ValueError("H space not implemented for SubspaceDMDc. Use X space instead.") pred = H_test_pred test_data_err = H_test_true elif error_space == "V": @@ -117,27 +144,32 @@ def sweep_ranks_delays( # pred = pred[:, :, -ndim:] # stats = compute_all_stats(pred, test_data_err[:, :, -ndim:], dmd.rank) # else: - stats = compute_all_stats(test_data_err, pred, dmd.rank) + stats = compute_all_stats(test_data_err, pred, model.rank if model_class in ['DMD', 'SubspaceDMDc'] else model.rank_output) aic = stats["AIC"] mase = stats["MASE"] if return_mse: mase = stats["MSE"] nnormal = measure_nonnormality_transpose( - dmd.A_v.cpu().detach().numpy() if hasattr(dmd.A_v, "cpu") else dmd.A_v + model.A_v.cpu().detach().numpy() if hasattr(model.A_v, "cpu") else model.A_v ) if return_transient_growth: l2norm = measure_transient_growth( - dmd.A_v.cpu().detach().numpy() - if hasattr(dmd.A_v, "cpu") - else dmd.A_v + model.A_v.cpu().detach().numpy() + if hasattr(model.A_v, "cpu") + else model.A_v ) else: l2norm = None - L, G, residuals, _ = compute_residuals(dmd) + if return_residuals and model_class == 'DMD': + L, G, residuals, _ = compute_residuals(model) + residuals = np.mean(residuals) + else: + warnings.warn(f"Residuals not implemented for {model_class}") + residuals = None aics.append(aic) mases.append(mase) nnormals.append(nnormal) - rresiduals.append(np.mean(residuals)) + rresiduals.append(residuals) l2norms.append(l2norm) all_aics.append(aics) all_mases.append(mases) diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb index f9809d7..ac7660f 100644 --- a/examples/how_to_use_dsa_tutorial.ipynb +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -34,16 +34,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -70,7 +70,7 @@ "import DSA.pykoopman as pk\n", "from pydmd import DMD as pDMD, SubspaceDMD\n", "\n", - "from DSA.sweeps import sweep_ranks_delays\n", + "from DSA.sweeps import sweep_ranks_delays, plot_sweep_results\n", "from DSA.stats import compute_all_stats\n", "\n", "np.random.seed(22)\n", @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -114,7 +114,7 @@ " \n", " return data, A_true\n", "\n", - "def generate_controlled_system(n_time=100, n_features=5, n_control=2, n_trials=10):\n", + "def generate_controlled_system(n_time=100, n_features=5, n_control=2, n_trials=10, nonlinearity=False):\n", " \"\"\"\n", " Generate data from a controlled linear dynamical system.\n", " \"\"\"\n", @@ -134,7 +134,8 @@ " control[trial, t] = u\n", " data[trial, t] = x\n", " x = A_true @ x + B_true @ u + np.random.randn(n_features) * 0.01\n", - " \n", + " if nonlinearity:\n", + " x = np.tanh(x) \n", " return data, control, A_true, B_true" ] }, @@ -1015,6 +1016,89 @@ "print(f\" MASE: {all_mases[best_idx]:.4f}\")\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.3 Basic Hyperparameter Sweep and Visualization for DMDc / Subspace DMDc" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Running hyperparameter sweep...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/5 [00:00,\n", + " array([,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Nonlinear control system with 15 features and 2 control inputs\n", + "data1, control1, A1, B1 = generate_controlled_system(n_time=100, n_features=15, n_control=2, n_trials=20, nonlinearity=True)\n", + "\n", + "# Define parameter ranges\n", + "n_delays_range = [1, 2, 3, 5, 7]\n", + "ranks_range = [3, 5, 8, 10, 12, 15, 20, 30, 40, 50]\n", + "\n", + "# Run sweep\n", + "print(\"\\nRunning hyperparameter sweep...\")\n", + "all_aics, all_mases, all_nnormals = sweep_ranks_delays(\n", + " data1,\n", + " control_data=control1,\n", + " n_delays=n_delays_range,\n", + " ranks=ranks_range,\n", + " model_class='SubspaceDMDc', # can be 'DMDc' or 'SubspaceDMDc' for control systems\n", + " train_frac=0.7, # Use 70% for training, 30% for testing\n", + " reseed=5,\n", + " return_residuals=False,\n", + " device='cpu'\n", + ")\n", + "\n", + "plot_sweep_results(all_aics, all_mases, all_nnormals, n_delays=n_delays_range, ranks=ranks_range, cmap='viridis', name='SubspaceDMDc')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1107,11 +1191,9 @@ "4. Use Wasserstein distance for fast, optimization-free comparisons, especially if dmd models are close to normal\n", "5. Leverage GPU (`device='cuda'`) for large datasets\n", "\n", - "## Unmentioned topics\n", "1. Unmentioned is parallelization of comparison (change the n_jobs parameter in the DSA class)\n", "2. Unmentioned is gpu support (device='cuda') in all classes\n", - "For more details, see:\n", "- Ostrow et al. (2023): https://arxiv.org/abs/2306.10168\n", "- Huang & Ostrow et al. (2025): https://www.arxiv.org/abs/2510.25943\n", @@ -1127,7 +1209,7 @@ ], "metadata": { "kernelspec": { - "display_name": "dsa_test_env", + "display_name": "py39", "language": "python", "name": "python3" }, @@ -1141,7 +1223,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.9.18" } }, "nbformat": 4, From 9fd4514d11b78193be69d668e85bfd83db91bdf3 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 6 Nov 2025 21:40:09 -0500 Subject: [PATCH 42/51] bug fix --- DSA/sweeps.py | 3 +- examples/how_to_use_dsa_tutorial.ipynb | 220 ++++++++----------------- 2 files changed, 74 insertions(+), 149 deletions(-) diff --git a/DSA/sweeps.py b/DSA/sweeps.py index e435bbc..60ceeed 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -78,7 +78,8 @@ def sweep_ranks_delays( assert control_data is not None, "Control data is required for DMDc and SubspaceDMDc" train_data, test_data, dim = split_train_test(data, train_frac) - train_control_data, test_control_data, dim_control = split_train_test(control_data, train_frac) + if control_data is not None: + train_control_data, test_control_data, dim_control = split_train_test(control_data, train_frac) all_aics, all_mases, all_nnormals, all_residuals, all_l2norm = [], [], [], [], [] for nd in tqdm(n_delays): diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb index ac7660f..6a30413 100644 --- a/examples/how_to_use_dsa_tutorial.ipynb +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -34,16 +34,16 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 2, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -225,8 +225,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 218.44it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.96s/it]\n" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 187.58it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:03<00:00, 3.10s/it]\n" ] }, { @@ -235,12 +235,12 @@ "text": [ "\n", "Similarity matrix shape: (2, 2)\n", - "Similarity between systems: 0.1501\n" + "Similarity between systems: 0.8746\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -294,15 +294,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 239.52it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.07s/it]" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 225.10it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.16s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Similarity with custom config: 0.3253\n" + "Similarity with custom config: 0.6212\n" ] }, { @@ -362,7 +362,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Similarity with dict config: 0.3126\n" + "Similarity with dict config: 0.4891\n" ] }, { @@ -424,8 +424,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 1it [00:00, 321.13it/s]\n", - "Fitting DMDs: 1it [00:00, 418.93it/s]\n" + "Fitting DMDs: 1it [00:00, 273.82it/s]\n", + "Fitting DMDs: 1it [00:00, 440.95it/s]\n" ] }, { @@ -439,14 +439,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 29.62it/s]" + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 26.33it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Similarity with PyKoopman: 0.9291\n", + "Similarity with PyKoopman: 0.2337\n", "(8, 100, 5)\n", "(2, 2)\n" ] @@ -526,8 +526,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 411.19it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 326.15it/s]" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 328.84it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 451.49it/s]" ] }, { @@ -535,7 +535,7 @@ "output_type": "stream", "text": [ "\n", - "InputDSA similarity: 3.3637\n" + "InputDSA similarity: 2.9736\n" ] }, { @@ -593,8 +593,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 52.81it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 2021.35it/s]" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 40.68it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 817.76it/s]" ] }, { @@ -602,7 +602,7 @@ "output_type": "stream", "text": [ "\n", - "SubspaceDMDc similarity: 0.9359\n" + "SubspaceDMDc similarity: 0.5177\n" ] }, { @@ -652,9 +652,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "control similarity: 0.0131\n" + ] + }, { "name": "stderr", "output_type": "stream", @@ -667,14 +674,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "control similarity: 0.0043\n", - "state similarity: 0.5079\n", - "joint similarity: 2.2604\n" + "state similarity: 0.3775\n", + "joint similarity: 1.8671\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -735,7 +741,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -745,9 +751,9 @@ "Components shape: (2, 2, 3)\n", "\n", "Distance components between systems 0 and 1:\n", - " Controllability distance: 3.4692\n", - " State similarity: 1.5174\n", - " Control similarity: 0.0637\n" + " Controllability distance: 3.0558\n", + " State similarity: 0.9661\n", + " Control similarity: 0.0629\n" ] } ], @@ -791,14 +797,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 342.95it/s]\n", + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 367.31it/s]\n", "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 3.00s/it]" ] }, @@ -807,7 +813,7 @@ "output_type": "stream", "text": [ "\n", - "DSA similarity: 0.3565\n" + "DSA similarity: 0.5150\n" ] }, { @@ -857,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -873,7 +879,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:00<00:00, 18.58it/s]" + "100%|██████████| 5/5 [00:00<00:00, 15.20it/s]" ] }, { @@ -930,90 +936,36 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABU8AAASlCAYAAACY8ygzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA1GNJREFUeJzs3QmcXePdOPBnstsSS2STSOzEEpqg1F7EUrG0qqoSsXWxB620iKVtlJYoKvhbX1Vba+kWS4jltYQoRQkiJJYkKEI0i5n7/zyP3nlnkjtxZ3LPzNw73+/7Oe/MPffcc597Zhq/+Z3f83uqcrlcLgAAAAAAUE+7+g8BAAAAAJA8BQAAAABogMpTAAAAAIACJE8BAAAAAAqQPAUAAAAAKEDyFAAAAACgAMlTAAAAAIACJE8BAAAAAAqQPAUAAAAAKEDyFEjOP//8sOGGG4aampraK1JVVRXOOussV6iOSZMmpety++23l/11mTBhQlhxxRXDe++919JDAQDIxI9+9KOw22671T5+4403Uix33XXXueJ1xOsRr8vTTz9d9tdl/PjxYc011wwLFixo6aEAFULyFFqJ3/3udylg2XrrrRs8Jj5/7LHHLrF/7ty54eyzzw6DBg1KybDlllsubLLJJuEnP/lJeOedd770vePrf/WrX6Xj27Xzz0Jze+yxx1KS+qOPPlriuV/+8pfhzjvvzOR999hjj7DuuuuGsWPHZnJ+AKD8kmdxe/TRR5d4PpfLhX79+qXnv/GNbxQ8R4xlunTpko556aWXGnyvP//5z2HHHXcMPXr0CMsvv3xYe+21w7e//e10Y3fxJGdD23nnnfeln2n69Onh//2//xd++tOfFn0dKJ2//e1vBQsxPvvss7Q/FiVk4bDDDgsLFy4MV1xxRSbnB9oeWRJoJX7/+9+HAQMGhMmTJ4fXXnut6Ne9/vrrYfPNNw/nnntuGDhwYEqC/va3vw0777xzuPrqq8NOO+30pee45pprwueffx4OPvjgZfwUNDV5GpPfzZ08jb7//e+nwPKTTz7J7D0AgPIRk5833XTTEvsfeuih8NZbb4XOnTs3+NrbbrstJTZ79eqVYttCfv3rX4dhw4al40aPHh0uuuii8M1vfjO8+uqr4eabb17i+Bif/s///M8S2z777POln+Xiiy8Oa621VoqLaZnkaYxxCyVP4/6skqfxd3jEiBHhwgsvTEl/gGXVYZnPACyzeFc8JtD+9Kc/pWRWDDbHjBnzpa+LCc8DDjggzJ49OwUf2223Xb3nf/GLX6Rk6pe59tprUxAbA41yNW/evLDCCiu09DDKwvz580OnTp1SlXH8Y+W4445Lf+wcfvjhLT00AKCF7bXXXikuiDfjO3T4vz8XY0J18ODB4f3332/wtTfeeGN6ff/+/dPxP//5z5eIXeMN/ziN/t57713i9XPmzFli31e+8pXwve99r9GfY9GiRSmm/sEPfhDKmRi3adcqVjLHtmQPPvhg2GWXXTL7+QBtg8pTaAViYLfKKquEvffeO3zrW99q8E794v74xz+G5557LvzsZz9bInEade3aNSVQvyxx+89//jPsuuuuRb3nP/7xj7Dnnnumc8cWAV//+tfDE088Uft8rJ5s3759CrjzYpAdE3WrrbZavbu/P/zhD1NlQl1PPvlkmk7erVu3NI0rTun63//933rHxGk+sVrhX//6V/jud7+brl2hz5+l6urqNAUsjj8GaTH5PHPmzCWO+7LPEz/Lqaeemr6PlRH5qWj5qWoxCLz++utr98dpSHlvv/12Snj27NkzVYFsvPHGqYq4UI/WWMlx+umnhzXWWCONI7ZqiOJ0uc022yzcddddGV4tAKBcxErPDz74INx33321++IU6NjvPcZdDZkxY0Z45JFHwne+85205YsD6ooxYYxBvva1rxU8R4xLSiW2HojvV2yM+8ADD4Ttt98+xXUrr7xy2Hfffeu1Hojxcoyp7r777tp9U6ZMSftigreuGCsv3orr73//e+35V1pppRT3v/jii/WOiXFejK+nTZuWktDxuEMOOSQ0p1gVGos5Ytwe4/3hw4eHDz/8cInjvuzzxM9y2WWXpe/rtluIMe7qq6+e9sfq0/z+utP7X3755fQ30aqrrpqKO4YMGVLvutdtMxEromNf2/i707dv39rnY6I/vl6MC5SCylNoBWKyNFaQxmrAGLBefvnl4amnngpbbrnlUl+XDyIOPfTQJr93PqhdPOgrJAZEMUiKgdSPf/zj0LFjxzTlO7YGiIFLDBJjsBn7rT788MPh+OOPrw1eY3Dz73//OyU8Y5IvigF2PF/doDUGmzHYiZW3MeEaq2Lj3eJ47FZbbVVvPAceeGBYb7310tT2pU3JiYtgxfcuRkxyxs/1ZWJSOn6m2Cc2VkmMGzcuBefPPvts6jlb7OeJP/dXXnkl/OEPf0jT1rp3755eG4PKOCXtyCOPTMcdffTRaf8666yTvsZq469+9au1fXDj8TGIPeKII9IfJSeeeGK98cYqj/j7dcopp6Tm+fH7vDi+LFsDAADlI7aR2mabbVJsEuOYKMYYH3/8cUqK1r1BXlc8PibSYj/UGAvFmCXGuNtuu23tMTHBFZ+LPU/jzJeY3CommVeo2jXGnHUrYwvFuDFO2mKLLb70Pe6///70WWPv1ZjE+89//hMuueSSlOR95pln0jWJ8W18zxjjxpvmUYznYnwXixli/BVj5Bh3xvfOx25RjOniNPKhQ4emWWHxM8V4P978j4UJ8fx1q3PjcfG52OIg3vReWnVt/LkUI17rYtY2iHFl/JzxOkydOjWN880336y9IV/s54kJ2Lj2QkzCx+PzYswaj41FFPvvv3+KhaN4Mz//90a87vGG/2mnnZZ+p2699daw3377pcKR+Jq6YuI0nvPMM89MRQd1xb9vFi/CAGiSHNCinn766Zj1y913333pcU1NTa5v3765E044YYlj43HHHHNM7eMtttgi161bt2V6/9NPPz2d95NPPin4fmPGjKl9vN9+++U6deqUmzZtWu2+d955J7fSSivldthhh9p9cYw9e/asfTxq1Kj0fI8ePXKXX3552vfBBx/kqqqqchdffHHt515vvfVyQ4cOTd/nffbZZ7m11lort9tuu9Xui2OKYzv44IOL+ozTp09PxxezPfjgg0s9V3w+HrfGGmvk5s6dW7v/1ltvTfub8nkuuOCC9No4zsWtsMIKuREjRiyx/4gjjsj17t079/7779fb/53vfCf9TsT3qTvetddeu3bf4n75y1+mY2bPnr3Uzw4AVK5rr702xQNPPfVU7tJLL03xXT52OPDAA3M777xz+r5///65vffee4nXb7rpprlDDjmk9vFPf/rTXPfu3XOLFi2qd9yZZ56Z3ifGOHvuuWfuF7/4RW7KlCmNjt8ef/zxpX6e733ve7nVVlutwfPGz5u3+eabpzg1xqd5zz33XK5du3a54cOH1+6Ln3urrbaqfXzAAQekrX379rm///3vad8zzzyTzn/XXXelxzHGXnnllXNHHXVUvXHMmjUrxWx198eYL772tNNOyxUjH+cVsxWKMwv9/AcPHpxbuHBh7f7zzz+/yZ8n/k1QKOXw3nvvLfF3Rt7Xv/719Ls0f/782n0xlt52221TbL34eLfbbrvc559/XvAzHX300bnllltuqZ8boBim7UMLi3fk47TrfCP7eEf3oIMOStOs49TwpYl3uOM0mWURp2XFu/ZxitDSxLHE3lTxrm+8K5/Xu3fvNIUrVpfmp4LHatJYGRnvVufvyu+www5pf/w+isfH/Gy+8jRWbMaFAuK54phihUHc4h3k2Bog3uWPd/LrKraHVZxaH+96F7MNGjSoqHPGKUx1r32cWhSvRWyM39TPU6x43eKd97hQQvw+f+64xQqAWIEQqyTqitUB+YrYxcW2B9HSepgBAG1H7BcZqy//8pe/pEUl49elTdmPU9qff/75eouPxu9jbHHPPffUOzZO1Y79UGNFaHwutp+Ks2BilWDdafJ5sYKzUMwWF0pdmhh/5WOcpXn33XdT3BanmdethI2VkLE3az62i2LcGmOsfIVjjGfj9Pq4eGs+xo1fYzyfbykVxxrbWuWvR36Lba7irK3Yk3NxsSqzGDFuLTbGXbxVVkPi9a47CyuOJf6tkL8OTfk8xYozxeLMrfj7F3/v8ueOP8sY48bYOratquuoo45K711I/PnH3+NYGQuwLEzbhxYUE5IxSRoTp7EvVF4MPH7zm9+EiRMnht13373B18epQa+//nqzjPW9995LgccGG2ywxHMbbbRRSgTGnp9xSn4+IRqDx9h7KE7fiQsGxCk1cfpR/rk4/nyyMgZD+SRfQ2JSsG4QHHuEFiP2Siq231WxYruAumKQvO6666Y+Tk39PI35WcSg9corr0xbIYsvuLC0a5VveZCfigUAtG0xZouxU0xyxvgvxqzxRvHSFoqK06vjDfbXXnutNv6K07djoUDsh1lXTLzFLd54j/3hY//K+F7xxvALL7xQbxHTGHM1NY4rZqX1OCU9aijGjQne/EJEMcaN0+off/zx0K9fvxRvxX1xqnnd5GlM7OYTsfmYsKFFi2I8XFdMVNbt3bk0MY7MOsaNBRaxQGDxGLfYz9MY8Xcn/szOOOOMtBUSr3mc0p8nxgWag+QptKB4ZzXe7Y4J1LgtLgabS0uebrjhhikxGZOWMYBritgMPgaB8e7uslax5vXp0ycFMrG6MgbNMQiKvbNiIH7CCSekIDUGlrEHVr73Ur4K84ILLkh37wtZvDq2oUrKxcWAPyYcixED3br9QJuqKZ+nseeOK882lJzN940q5lrlFwHI91sFAIiVprGqb9asWakfaOyDWUiM82K/05hgLFQNGpNdn376acG4JybaYnVn3GK1Y1wkMyZT4wKbyyrGuIUWOloWceGimNiNMe6aa66Zeriuv/76KYH6u9/9LvWVjzFu3b6c+bgt9v0sVP25eN/WuAhoMb1J8wt5FdvXP8bhDVVoNkZjP09Tzh179MdK00JisUJjYtzYM7bYvxkAGiJ5Ci0oJkdj0JVfibKuP/3pT+GOO+4I48ePb/A/+PHufAxW493+0aNHN2kMMQEbxcrXxRNuiwdcMfjIT8WvK66IGYO8ugncGETGwDImUWPyMCZmY5VpXJBpwoQJacpTnLaVl18IKQbRpb6DHpPLxVapxqlGcQGsL5O/6173D4d4tzx/DRvzeZZW8VnoufiziNczJoVLca3izz4mTvMrnwIAxARgXPTniSeeCLfcckuDFyQuGvrWW2+Fc845J1VqLp68itPA48KU8abvlyUmY/I0FhaUQoxxY6wdZ/rE+LMh/fv3T18binFjjBSrTqN4gz0u5BkTpDF5mp9tFb/GxGl8v9i6KrarysvHhDHmL3WMGxemyrf+Kibeq7sw1dJi3LrnjInv+DOJ7Qka+3kainEb2p9vDRYT6aWKcRf/nQRoCslTaCGx/05MkMYV4wtNg4rVmzExevfdd6ceqIXE140dOzat/B4TfrG6s65YTXreeeel5xuSf83TTz+91ORpvFMdq2DvuuuuNG0nH3zFADFOs4p9nepO04lB5A033JCC7fxKrTHBGqtNL7zwwrQ6aD7gjGKvqxiMxWn9sdJh8eqEWDna1ORevudpMYrteRo/W0xY56t1b7/99hRY/uQnP2n058kH5HEq/uLic4vvjz+Lb37zm+m6x6ltcfXXhs5djClTpizxuwMAtG0xdomrose4L96w/7Ip+6eeemq96fZ5cRZOTCrG5GlsARBXpi8Ud/z9739vcPp8U8T3iDe3Y5zT0BTzKE5Jjzf6Y+I2xnb5CtsYY8V+/4snfWP8GmPZadOmhZNPPjntiwnWmKSLK8/nj8mLFZQxRv7lL3+ZkpJ1+4kua4yb73lajGJ7nsaWUCNHjqwdZ/wdiLPU8vF8Yz5P3Ri3buVyLMjI768rJmTj3zRXXHFFOO6449LPpqFzFyMWaxxyyCFFHw/QEMlTaCExKRqTm8OGDSv4/Fe/+tUUHMRgs6HkaQxWYgI23pmNd7hjc/Wvfe1raX/svRSTa7EX0tKSp/EOb0y+3X///eHwww9f6phj39IYoMVE6Y9+9KM0LScGN/FO+/nnn1/v2HzQGO/ix+AqL44zBsdxStKWW25Zuz8mVv/f//t/KTCLfVNj0Bb7GcWm8LEaNAZpf/7zn0NTZNHzNE7vj9chjjMmkMeNG5emEcXpbY39PDHRGsUFE77zne+kn1/8IyUGnPG5+LOJQXq+HULsiRuT4vE88fv4nnGaXJy2FYPEeHyxU7jiVLq4yMMxxxxT0usDAJS/pfVuj2IMGBexjNPuCyVOoxjrXnzxxSnmyN9Ij3HuHnvskWYtxQRarEyN1ZxxYdK4kFRdMbaJCdrFxZvUS7v5G+O0OHU/xkVLS57mE7wxZovnO+KII1KRwyWXXJIqVs8666wlYtwYW8eZTXWTpDHGjXFxLDCo27M0xnwxAXnooYemRbFirBdj/BkzZoS//vWvKXa/9NJLQ1Nk0fM0tgKIi5vGvytiHB/bEcRrmf+bpTGfJx/jHn/88SnpGgsA4vFxVl2MXWORRWx7EOPq+PdI3OKMvPh+m266aYpx498qMdaOfWZjhXNMvhcjJs1jPLzvvvuW9PoAbVQOaBH77LNPrkuXLrl58+Y1eMxhhx2W69ixY+79999Pj+P/ZI855pgljvvwww9zZ555Zm7TTTfNLb/88um8m2yySW706NG5d99990vHcuGFF+ZWXHHF3GeffVZvf3y/MWPG1Nv3zDPP5IYOHZqOj++188475x577LGC5+3Ro0c6x+zZs2v3Pfroo2nf9ttvX/A1//jHP3IHHHBAbrXVVst17tw5179//9y3v/3t3MSJE2uPiWOK53jvvfdyze3BBx9M7/2HP/whXd/4GZdbbrnc3nvvnXvzzTeb9Hmic889N7fGGmvk2rVrl84/ffr0tP/ll1/O7bDDDuk94v4RI0bUviZe1/j70K9fv/R70qtXr9zXv/713JVXXrnEeG+77baCn+fyyy9PP8e5c+eW8CoBAOXm2muvTTHDU089tdTjYiwT457oj3/8Y3rN1Vdf3eDxkyZNSsdcfPHFuUWLFuWuuuqq3H777ZfOE2OjGIdsscUWuQsuuCC3YMGC2tfFWCi+rqGtbkzUkOOPPz637rrr1tuXP2/8vHXdf//9ua997Wsp5uratWuK1f/1r38tcc4YM7Vv3z630kor5T7//PPa/TfeeGM676GHHlpwLDEmizF0t27dUqy+zjrrpFj/6aefrj0mfqYVVlgh15I//4ceeih39NFH51ZZZZUU7x9yyCG5Dz74oEmfJ16f4447Lrf66qvnqqqq0vnz4t8PgwcPznXq1GmJvzmmTZuWGz58eIptY4wbY+RvfOMbudtvv73o39ef/OQnuTXXXDNXU1NTwqsEtFVV8f+1dAIXaFmxF1S8qxurR+PddtqOWN0Rp0dddNFFLT0UAICSev3111Pv0zjrKVZT0jbEiuhYAXzaaaelxWoBllVxy/gBFS1OSfrxj3+cpizlV7mk8sWFu+KiAE1dbAwAoDWLxQGxMCC2O6LtuPbaa1MbrB/84ActPRSgQqg8BQAAAAAoQOUpAAAAAEABkqcAAAAAAAVIngIAAAAAFNAhlLG4sM0777wTVlpppVBVVdXSwwEAmlkulwuffPJJ6NOnT2jXruXuCc+fPz8sXLgw0/fo1KlT6NKlS6bvQfbErwDQtrWG+LU5YtdKil/LOnkaE6f9+vVr6WEAAC1s5syZoW/fvi0WfK7Vf8Uwa051pu/Tq1evMH369IoIQNsy8SsA0JLxa3PFrpUUv5Z18jRWnEZvPjMgdF1RB4JS2n/9TUt6Pr5w18c3uBQAJTR37tx0IzUfE7SEeNc+Bp9vThkQuq6UTTwy95Oa0H/wG+m9yj34bOvEr9k5YNMhGZ697bpzzlUtPQSAitLS8WtzxK6VFr+WdfI0P1U/Jk6z/IG3RR2qOrb0ECpS165dW3oIABWpNbTvWXGlqrRloSa0/OejNMSv2RG/ZkP8ClCZ8WuWsWulxa8yjgAAAAAAlVZ5CgDQWlTnakJ1LrtzAwBAOcSulRa/qjwFAAAAAChA5SkAQAnUhFzaspDVeQEAaJuyjF0rLX5VeQoAAAAAUIDKUwCAEqhJ/5eN7M4MAEBblGXsWmnxq8pTAAAAAIACVJ4CAJRAdS6XtixkdV4AANqmLGPXSotfVZ4CAAAAABSg8hQAoJWvWFpJq5UCAFDZsWulxa8qTwEAAAAAClB5CgBQorvr1SpPAQBo47FrpPIUAAAAAKDCqTwFACgBPU8BACgXep4WT89TAAAAAIACVJ4CAJRAdS6XtixkdV4AANqmLGPXSotfVZ4CAAAAABSg8hQAoARq/rtlIavzAgDQNmUZu1Za/KryFAAAAACgAJWnAAAlUB1yactCVucFAKBtyjJ2rbT4VeUpAAAAAEABKk8BAEqgOvfFloWszgsAQNuUZexaafGrylMAAAAAgAJUngIAtPIVSytptVIAACo7dq20+FXlKQAAAABAASpPAQBKoCZUhepQldm5AQCgHGLXSotfVZ4CAAAAABQgeQoAUAI1uWy3LEyaNClUVVUV3J566qmlvvbxxx8Pu+yyS1hhhRVC165dww477BD+85//ZDNQAADKKnatySh+bQmm7QMAtFHbbrttePfdd+vtO+OMM8LEiRPDkCFDlpo43WOPPcLo0aPDJZdcEjp06BCee+650K6d+/IAAFQWyVMAgBKozrBvVP68c+fOrbe/c+fOaWuqTp06hV69etU+XrRoUbjrrrvCcccdl6pPG3LSSSeF448/Ppx22mm1+zbYYIMmjwMAgMqJXaMsz93clAcAAJSJfv36hW7dutVuY8eOLen577777vDBBx+EkSNHNnjMnDlzwpNPPhl69OiRKld79uwZdtxxx/Doo4+WdCwAANAaqDwFACiTytOZM2em/qJ5y1J1WsjVV18dhg4dGvr27dvgMa+//nr6etZZZ4Vf//rXYfPNNw833HBD+PrXvx5eeOGFsN5665V0TAAAlJ7K0+KpPAUAKBMxcVp3ayh5GqfTN7QQVH57+eWX673mrbfeCvfcc0844ogjljqGmpqa9PX73/9+qlDdYostwkUXXZSm7V9zzTUl/LQAANDyVJ4CAJRATa4qbVlo7HlPPvnkcNhhhy31mLXXXrve42uvvTasttpqYdiwYUt9Xe/evdPXgQMH1tu/0UYbhRkzZjRqnAAAVF7sGmV57uYmeQoAUGFWX331tBUrl8ul5Onw4cNDx44dl3rsgAEDQp8+fcLUqVPr7X/llVfCnnvu2eQxAwBAa2TaPgBACftGZbVl6YEHHgjTp08PRx555BLPvf3222HDDTcMkydPTo/jlP9TTz01/Pa3vw233357eO2118IZZ5yR2gB82ZR/AADaRuxanXH82pxUngIAtHFxoahtt902JUkXt2jRolRl+tlnn9XuO/HEE8P8+fPDSSedFP7973+HQYMGhfvuuy+ss846zTxyAADIluQpAEAJVId2actCdcjWTTfdtNRp+nFaf6FFqeIGAED5yTJ2bY74tTmZtg8AAAAAUIDKUwCAEshluGJpPDcAAJRD7Fpp8avKUwAAAACAAlSeAgCUQJarilbSaqUAAFR27Fpp8avKUwAAAACAAiRPAQBKoDrXLtMNAADKJXatbmL8etlll4UBAwaELl26hK233jpMnjx5qcd/9NFH4Zhjjgm9e/cOnTt3Duuvv37429/+tkznXJxIHAAAAABoUbfccksYNWpUGDNmTHjmmWfCoEGDwtChQ8OcOXMKHr9w4cKw2267hTfeeCPcfvvtYerUqeGqq64Ka6yxRpPP2eqSpw8//HDYZ599Qp8+fUJVVVW48847W3I4AABNVhOqQk1ol9FWOT2jyp34FQCoBNnGru2aFL9eeOGF4aijjgojR44MAwcODOPHjw/LL798uOaaawoeH/f/+9//TvnEr33ta6m6dMcdd0wJ0qaes9UlT+fNm5c+UCyfBQCA1k78CgBQvLlz59bbFixY0GAV6ZQpU8Kuu+5au69du3bp8eOPP17wNXfffXfYZptt0rT9nj17hk022ST88pe/DNXV1U0+ZyEdQgvac8890wYAUO6yXLG0klYrLXfiVwCgEmQZu0b5c/fr1y/UFafPn3XWWWFx77//fkp6xiRoXfHxyy+/HAp5/fXXwwMPPBAOOeSQ1Of0tddeCz/60Y/CokWL0vs05ZytLnnaWDE7XTdDHTPWAADQWolfAYC2bObMmaFr1661j+OiTqVSU1MTevToEa688srQvn37MHjw4PD222+HCy64ICVPS6Wskqdjx44NZ599dksPAwBgCcuyquiXqc7lXPEyJX4FANpa7Fo3fo2J07rJ04Z07949JUBnz55db3983KtXr4Kv6d27d+jYsWN6Xd5GG20UZs2alabsN+Wcra7naWONHj06fPzxx7VbzF4DAEBrJX4FAPhynTp1SpWjEydOrFdZGh/HvqaFxEWi4lT9eFzeK6+8kpKq8XxNOWfZV57G0t5SlvcCAJR2xdJs+kZldV6yJ34FANpa7Bo15dyjRo0KI0aMCEOGDAlbbbVVGDduXFqsc+TIken54cOHhzXWWCPN7Il++MMfhksvvTSccMIJ4bjjjguvvvpqWjDq+OOPL/qcFZc8BQAAAAAqz0EHHRTee++9cOaZZ6ap95tvvnmYMGFC7YJPM2bMCO3a/d8k+rgY1T333BNOOumksNlmm6XEakyk/uQnPyn6nK0+efrpp5+m8tq86dOnh2effTasuuqqYc0112zJoQEANEpNaBeqM+qIVBP0PG0txK8AQCXIMnZdlvj12GOPTVshkyZNWmJfnH7/xBNPNPmcrT55+vTTT4edd965XiltFMtpr7vuuhYcGQAALEn8CgDQtrRo8nSnnXYKOavHAgAVIMsVS/OrldLyxK8AQCXIMnattPg1u6sEAAAAAFDGLBgFAFCivlFxy4KepwAAlEvsWmnxq8pTAAAAAIACVJ4CAJRAda4qbVnI6rwAALRNWcaulRa/qjwFAAAAAChA5SkAQAlUh3Zpy0J1BfWMAgCgsmPXSotfVZ4CAAAAABSg8hQAoARqcu3SloWaXOXcuQcAoLJj10qLX1WeAgAAAAAUoPIUAKAE9DwFAKBc6HlaPJWnAAAAAAAFqDwFACiBmngHP1eV2bkBAKAcYtdKi19VngIAAAAAFKDyFACgBGpCu7RlIavzAgDQNmUZu1Za/Fo5nwQAAAAAoIRUngIAlEB1rl3aspDVeQEAaJuyjF0rLX6tnE8CAAAAAFBCKk8BAEqgJlSlLQtZnRcAgLYpy9i10uJXlacAAAAAAAWoPAUAKAE9TwEAKBd6nhZP5SkAAAAAQAEqTwEASqA6tEtbFrI6LwAAbVOWsWulxa+V80kAAAAAAEpI5SkAQAnU5KrSloWszgsAQNuUZexaafGrylMAAAAAgAJUngIAlEBNhn2j4rkBAKCU8WWWfUlrKih+rZxPAgAAAABQQipPAQBKoCbXLm1ZyOq8AAC0TVnGrpUWv1bOJwEAAAAAKCGVpwAAJVAdqtKWhazOCwBA25Rl7Fpp8avKUwAAAACAAlSeAgCUgJ6nAACUCz1Pi6fyFAAAAACgAJWnAAAlUJ1hb6d4bgAAKGV8mW3P08qh8hQAAAAAoACVpwAAJaDnKQAA5ULP0+KpPAUAAAAAKEDlKQBACVTn2qUtC1mdFwCAtinL2LXS4tfK+SQAAAAAACWk8hQAoARyoSrUZLRiaTw3AACUQ+xaafGrylMAAAAAgAJUngIAlICepwAAlAs9T4un8hQAAAAAoFIrT6+d2yssV1MRH6XVWLjHli09hIq0x+rfb+khVKSq5ZZr6SFUpL/PGNfSQ4CyUpOrSltW56ay/O6jNUOXz8WvpfSf3QaV9Hx8YY8eP3ApsvD5565rBib8+/+5rtAKYtdKi19VngIAAAAAFOB2NwBACVSHdmnLQlbnBQCgbcoydq20+LVyPgkAAAAAQAmpPAUAKAE9TwEAKBd6nhZP5SkAAAAAQAGSpwAAJVAT2mW6AQBAucSuNU2MXy+77LIwYMCA0KVLl7D11luHyZMnN3jsddddF6qqqupt8XV1ffrpp+HYY48Nffv2Dcstt1wYOHBgGD9+fKPGZNo+AAAAANCibrnlljBq1KiU3IyJ03HjxoWhQ4eGqVOnhh49ehR8TdeuXdPzeTGBWlc83wMPPBBuvPHGlJS99957w49+9KPQp0+fMGzYsKLGpYwBAKAEqnNVmW4AAFAusWv1f+PXuXPn1tsWLFjQ4JguvPDCcNRRR4WRI0fWVoguv/zy4ZprrmnwNTFZ2qtXr9qtZ8+e9Z5/7LHHwogRI8JOO+2UkqdHH310GDRo0FIrWhcneQoAAAAAlFy/fv1Ct27darexY8cWPG7hwoVhypQpYdddd63d165du/T48ccfb/D8cVp+//790/vsu+++4cUXX6z3/Lbbbhvuvvvu8Pbbb4dcLhcefPDB8Morr4Tdd9+96M9g2j4AQCtfsTSr8wIA0DZlGbtG+XPPnDkzTa3P69y5cyjk/fffD9XV1UtUjsbHL7/8csHXbLDBBqkqdbPNNgsff/xx+PWvf52SpTGBGnucRpdcckmqNo2PO3TokBKyV111Vdhhhx1CsSRPAQAAAICS69q1a73kaSlts802acuLidONNtooXHHFFeHcc8+tTZ4+8cQTqfo0Vqg+/PDD4Zhjjkk9T+tWuS6N5CkAQAnkcu1CTa5dZucGAIByiF2bEr927949tG/fPsyePbve/vg49jItRseOHcMWW2wRXnvttfT4P//5T/jpT38a7rjjjrD33nunfbFK9dlnn01VqsUmT0XiAAAAAECL6dSpUxg8eHCYOHFi7b6ampr0uG516dLEaf/PP/986N27d3q8aNGitMWp+nXFJG08d7FUngIAlEB1qEpbFrI6LwAAbVOWsWvUlHOPGjUqjBgxIgwZMiRstdVWYdy4cWHevHlh5MiR6fnhw4eHNdZYo3bRqXPOOSd89atfDeuuu2746KOPwgUXXBDefPPNcOSRR6bnY7uAHXfcMZx66qlhueWWS9P2H3rooXDDDTeECy+8sOhxqTwFAGijJk2aFKqqqgpuTz31VMHXvPHGGw2+5rbbbmv2zwAAQGU46KCD0nT6M888M2y++eZpev2ECRNqF5GaMWNGePfdd2uP//DDD8NRRx2V+pzutddeYe7cueGxxx4LAwcOrD3m5ptvDltuuWU45JBD0v7zzjsv/OIXvwg/+MEPih6XylMAgBKoyf3fqqJZnDsLsal+3QA0OuOMM9L0qHjHv5B+/fot8Zorr7wy3enfc889sxkoAABlE7suS/x67LHHpq2hG/91XXTRRWlbmtgv9dprrw3LQvIUAKAN95aq24A/9oS66667wnHHHZcqSQuJPaIWb9ofm/B/+9vfDiuuuGLmYwYAgOYkeQoAUAI1Ga5Ymj9vnIpUV+fOndNWKnfffXf44IMPavtKFWPKlClpStVll11WsnEAAFC+sWuU5bmbW+V8EgCAChenzHfr1q12yzfLL5Wrr746DB06NPTt27dRr4l9pmILAAAAqDQqTwEASqAmVKUtC/nzzpw5M60amtdQ1elpp50WfvWrXy31nC+99FLYcMMNax+/9dZb4Z577gm33npr0eP6z3/+E2666abUJxUAgPKRZewaZXnu5iZ5CgBQJmLitG7ytCEnn3xyOOyww5Z6zNprr13vcWykv9pqq4Vhw4YVPZ7bb789fPbZZ2H48OFFvwYAAMqJ5CkAQAlU56rSloXGnnf11VdPW7FyuVxKnsYkaMeOHRs1ZT8mWxvzXgAAVHbsGmV57uam5ykAQBv3wAMPhOnTp4cjjzxyiefefvvtNL1/8uTJ9fa/9tpr4eGHHy74GgAAqBQqTwEAWvmKpVmvVhorSOOCT3V7oOYtWrQoTJ06NU3Pr+uaa65JC0vtvvvumY4NAIDyil2bI35tTpKnAABtXFz0qSEDBgxI0/oX98tf/jJtAABQySRPAQBKtWJpRr2dKmm1UgAAKjt2rbT4tXJqaAEAAAAASkjlKQBACeTi3fuM7rDHcwMAQCnjyyyrQ3MVFL+qPAUAAAAAKEDlKQBACcSeUZn1PM2wHxUAAG1PlrFrpcWvKk8BAAAAAApQeQoAUAI1uXZpy0JW5wUAoG3KMnattPi1cj4JAAAAAEAJqTwFACgBPU8BACgXep4WT+UpAAAAAEABKk8BAEqgJlSlLQtZnRcAgLYpy9i10uJXlacAAAAAAAWoPAUAKAE9TwEAKBd6nhZP5SkAAAAAQAEqTwEASkDlKQAA5ULlafFUngIAAAAAFKDyFACgBFSeAgBQLlSeFk/lKQAAAABAASpPAQBKQOUpAADlQuVp8VSeAgAAAAAUoPIUAKAEcvEOfqjK7NwAAFAOsWulxa8qTwEAAAAAWlvydOzYsWHLLbcMK620UujRo0fYb7/9wtSpU1tySAAAy9Q3KquN1kH8CgBUgqxj15oKil9bNHn60EMPhWOOOSY88cQT4b777guLFi0Ku+++e5g3b15LDgsAAAoSvwIAtC0t2vN0woQJ9R5fd911qQJ1ypQpYYcddmixcQEANFaWd9gr6c59uRO/AgCVIOvq0JoKil9b1YJRH3/8cfq66qqrFnx+wYIFacubO3dus40NAAAWJ34FAKhsrWbBqJqamnDiiSeGr33ta2GTTTZpsMdUt27dard+/fo1+zgBAArRM6rtEb8CAOVKz9MyTJ7G3qcvvPBCuPnmmxs8ZvTo0enufn6bOXNms44RAADyxK8AAJWvVUzbP/bYY8Nf/vKX8PDDD4e+ffs2eFznzp3TBgDQ2uh52raIXwGAcqbnaZkkT3O5XDjuuOPCHXfcESZNmhTWWmutlhwOAAAslfgVAKBt6dDSU51uuummcNddd4WVVlopzJo1K+2P/UyXW265lhwaAECj5HJVactCVuel8cSvAEAlyDJ2rbT4tUV7nl5++eWpd+lOO+0UevfuXbvdcsstLTksAAAoSPwKANC2tPi0fQCASlATqtKW1blpHcSvAEAlyDJ2rbT4tUUrTwEAAAAAWqsWrTwFAKgUWa5YmtV5AQBom7KMXSstflV5CgAAAABQgMpTAIBWvmJpJa1WCgBAZceulRa/qjwFAAAAAChA5SkAQAnoeQoAQLnQ87R4Kk8BAAAAAApQeQoAUAJ6ngIAUC70PC2eylMAAAAAoMVddtllYcCAAaFLly5h6623DpMnT27w2Ouuuy5UVVXV2+LrFvfSSy+FYcOGhW7duoUVVlghbLnllmHGjBlFj0nlKQBAie7ex95RWaik1UoBAKjs2LWp8estt9wSRo0aFcaPH58Sp+PGjQtDhw4NU6dODT169Cj4mq5du6bn82ICta5p06aF7bbbLhxxxBHh7LPPTse/+OKLBZOsDZE8BQAAAABa1IUXXhiOOuqoMHLkyPQ4JlH/+te/hmuuuSacdtppBV8Tk6W9evVq8Jw/+9nPwl577RXOP//82n3rrLNOo8Zl2j4AQAnk0h32jDY/IQAAyiV2zf1f/Dp37tx624IFCwqOZ+HChWHKlClh1113rd3Xrl279Pjxxx9v8HN8+umnoX///qFfv35h3333TVWleTU1NSn5uv7666cK1li9Gita77zzzkZdK8lTAAAAAKDk+vXrl3qN5rexY8cWPO79998P1dXVoWfPnvX2x8ezZs0q+JoNNtggVaXedddd4cYbb0zJ0m233Ta89dZb6fk5c+ak5Op5550X9thjj3DvvfeG/fffPxxwwAHhoYceKvozmLYPAFACNaEq/V9W5wYAgHKIXevGrzNnzkx9RvM6d+4cSmWbbbZJW15MnG600UbhiiuuCOeee25KpkaxIvWkk05K32+++ebhscceSy0Bdtxxx6LeR/IUAAAAACi5rl271kueNqR79+6hffv2Yfbs2fX2x8dL62laV8eOHcMWW2wRXnvttdpzdujQIQwcOLDecTHB+uijjxb9GUzbBwAo0YqiWW4AAFAusWuukfFrp06dwuDBg8PEiRNr98XK0fi4bnXp0sRp/88//3zo3bt37Tm33HLLMHXq1HrHvfLKK6lParFUngIAAAAALWrUqFFhxIgRYciQIWGrrbYK48aNC/PmzQsjR45Mzw8fPjysscYatX1TzznnnPDVr341rLvuuuGjjz4KF1xwQXjzzTfDkUceWXvOU089NRx00EFhhx12CDvvvHOYMGFC+POf/xwmTZpU9LgkTwEASqAmVxWqMqoQjecGAIByiF2bGr/GJOd7770XzjzzzLRIVOxPGpOd+UWkZsyYEdq1+79J9B9++GE46qij0rGrrLJKqlyN/UzrTtOPC0TF/qYx4Xr88cenRab++Mc/hu22267ocUmeAgAAAAAt7thjj01bIYtXi1500UVp+zKHH3542ppK8hQAoARyuS+2LGR1XgAA2qYsY9dKi18tGAUAAAAAUIDKUwCAEmjKqqKNOTcAAJQyvswyxsxVUPyq8hQAAAAAoACVpwAAJaDyFACAcqHytHgqTwEAAAAAClB5CgBQAjW5qlCVUW+neG4AACiH2LXS4leVpwAAAAAABag8BQAogVzuiy0LWZ0XAIC2KcvYtdLiV5WnAAAAAAAFqDwFACjZ3ftsejtV0p17AAAqO3attPhV5SkAAAAAQAEqTwEASiDeuc+u8rRyVisFAKCyY9dKi19VngIAAAAAFKDyFACgBGJbp6xaO1VQyygAACo8dq20+FXlKQAAAABAASpPAQBKQM9TAADKhZ6nxVN5CgAAAABQgMpTAIBS0PQUAIByoelp0VSeAgAAAAAUoPIUAKAUclWpd1QmsjovAABtU5axa4XFrypPAQAAAAAKUHkKAFACudwXWxayOi8AAG1TlrFrpcWvKk8BAAAAAApQeQoAUAK5DPtGZdqPCgCANifL2LXS4teKSJ6u1XFOWKFT+5YeRkX5pF9F/Gq0OtWd123pIVSkFabPbekhVKTdtj23pYdQkeatsVxLD6GifL5ofksPoaxNmjQp7LzzzgWfmzx5cthyyy0LPjdr1qxw6qmnhvvuuy988sknYYMNNgg/+9nPwje/+c2MR1w5vtLljbDCciaBldKNPf09kIWOm/TP5LxtXacXZ7b0ECrSHqt/v6WHAF/q85qFrlKZkSEDACiFeHc9qzvsGZ132223De+++269fWeccUaYOHFiGDJkSIOvGz58ePjoo4/C3XffHbp37x5uuumm8O1vfzs8/fTTYYsttshkrAAAlEnsGlVQ5anb3QAAZWLu3Ln1tgULFizT+Tp16hR69epVu6222mrhrrvuCiNHjgxVVQ0HvI899lg47rjjwlZbbRXWXnvtcPrpp4eVV145TJkyZZnGAwAArY3kKQBACVcszWqL+vXrF7p161a7jR07tqQ/u1hJ+sEHH6Tk6ZdVrN5yyy3h3//+d6ipqQk333xzmD9/fthpp51KOh4AAMozds39N36tBKbtAwCUiZkzZ4auXbvWPu7cuXNJz3/11VeHoUOHhr59+y71uFtvvTUcdNBBqVK1Q4cOYfnllw933HFHWHddvb0BAKgsKk8BAEohl/EWQkqc1t0aSp6edtppadr90raXX3653mveeuutcM8994QjjjjiSz9q7Isae57ef//9qc/pqFGjUs/T559/3u8SAEA5yDp2zYWKofIUAKDCnHzyyeGwww5b6jGxV2ld1157baokHTZs2FJfN23atHDppZeGF154IWy88cZp36BBg8IjjzwSLrvssjB+/PgSfAIAAGgdJE8BAEogl6tKWxYae97VV189bcWfP5eSp8OHDw8dO3Zc6rGfffZZ+tquXf0JTO3bt0/9TwEAaNuxa5TluZubafsAAG3cAw88EKZPnx6OPPLIJZ57++23w4YbbhgmT56cHsfvY2/T73//+2lfrET9zW9+E+67776w3377tcDoAQAgOypPAQBKpUx7O8WForbddtuUGF3cokWLwtSpU2srTmNl6t/+9rfUV3WfffYJn376aUqmXn/99WGvvfZqgdEDANCWYtfmJnkKANDG3XTTTQ0+N2DAgDStv6711lsv/PGPf2yGkQEAQMuSPAUAqLCepwAA8GXxpZ6nxdHzFAAAAACgAJWnAAClkMuwb5R+VAAAlDq+zDLGzIWKofIUAAAAAKAAlacAACUR+5Jm1ZtUz1MAAEodX2YZY1aFSqHyFAAAAACgAJWnAACloOcpAADlQs/Toqk8BQAAAAAoQOUpAEApqDwFAKBcqDwtmspTAAAAAIACVJ4CAJRCruqLLQtZnRcAgLYpy9i1wuJXlacAAAAAAAWoPAUAKIFc7ostC1mdFwCAtinL2LXS4leVpwAAAAAAWSVP586dG+68887w0ksvleJ0AADlu2JpVhslJX4FANq0rGPXXGjbydNvf/vb4dJLL03f/+c//wlDhgxJ+zbbbLPwxz/+sdRjBACAZSJ+BQBo/S677LIwYMCA0KVLl7D11luHyZMnN3jsddddF6qqqupt8XUN+cEPfpCOGTduXPbJ04cffjhsv/326fs77rgj5HK58NFHH4Xf/va34ec//3lTTgkAUBkrlma1sUzErwAAzRi75hofv95yyy1h1KhRYcyYMeGZZ54JgwYNCkOHDg1z5sxp8DVdu3YN7777bu325ptvFjwu5i+feOKJ0KdPn0aPq0nJ048//jisuuqq6fsJEyaEb37zm2H55ZcPe++9d3j11VebckoAAMiM+BUAoGVaJc2tsy1YsKDBYy+88MJw1FFHhZEjR4aBAweG8ePHp3zjNddc0+BrYiVpr169areePXsucczbb78djjvuuPD73/8+dOzYsXmSp/369QuPP/54mDdvXkqe7r777mn/hx9+uNTyWACASlWVy3Zj2YhfAQCaL3atyv1fDNatW7fabezYsQV/DAsXLgxTpkwJu+66a+2+du3apccxB9mQTz/9NPTv3z+9z7777htefPHFes/X1NSEQw89NJx66qlh4403btKvQIemvOjEE08MhxxySFhxxRXTAHfaaafa6VCbbrppkwYCAABZEb8CADS/mTNnpqn1eZ07dy543Pvvvx+qq6uXqByNj19++eWCr9lggw1SVWpcgynOMvr1r38dtt1225RA7du3bzrmV7/6VejQoUM4/vjjm/wZmpQ8/dGPfhS22mqrdAF22223lAmO1l57bT1PAYC2KctVRVWeLjPxKwDAYvFlljFm7osvMXFaN3laSttss03a8mLidKONNgpXXHFFOPfcc1Ml68UXX5z6p8bp/c2aPH3wwQfDzjvvHIYMGVJvf+x5CgAArY34FQCg9erevXto3759mD17dr398XHsZVqM2M90iy22CK+99lp6/Mgjj6TFptZcc83aY2J168knnxzGjRsX3njjjex6nu6xxx5hnXXWSVWmsfoUAKDNa2WrlSJ+BQBosdg117j4tVOnTmHw4MFh4sSJ9fqVxsd1q0uXJiZGn3/++dC7d+/0OPY6/ec//xmeffbZ2q1Pnz6p/+k999xT9NialDyNq1Qde+yx4fbbb09T9YcOHRpuvfXW1NwVAABaG/ErAEDrNmrUqHDVVVeF66+/Prz00kvhhz/8YVqsfuTIken54cOHh9GjR9cef84554R77703vP7662lq/ve+973w5ptvhiOPPDI9v9pqq4VNNtmk3harU2Mla+yXmmnyNJbSnnTSSSlj++STT4b1118/9ZGK2dvYgPW5555rymkBAMq/b1RWG8tE/AoA0Iyxa67xV/uggw5Kiz6deeaZYfPNN095xwkTJtQuIjVjxozw7rvv1h7/4YcfhqOOOir1Od1rr73C3Llzw2OPPRYGDhxY0h91k3qe1vWVr3wlZWxjNve8885Lq1z97ne/SyW148ePDxtvvHFpRgoAACUgfgUAaJ2OPfbYtBUyadKkeo8vuuiitDVGsX1Ol7nyNFq0aFGath8zu/3790+9Ai699NLUyDU2Zo37DjzwwKaeHgCgvLSyO/csSfwKANBMsWuucq50kypPjzvuuPCHP/wh5HK51Hz1/PPPT30D8lZYYYVUZhun8QMAQEsTvwIA0GzJ03/961/hkksuCQcccEDo3Llzg32lHnzwwSYNCgCg7GR5h72C7ty3FPErAEAdWVeH5tp48nTixIlffuIOHcKOO+7YlNMDAEBJiV8BAGj2BaPiHfy40tXChQvr7R82bNiynBYAoPzkqr7Ysjo3JSF+BQDIOHatsPi1ScnT119/Pey///7h+eefD1VVVan3aRS/j6qrq0s7SgAAWAbiVwAAmqJdU150wgknhLXWWivMmTMnLL/88uHFF18MDz/8cBgyZEiYNGlSkwYCAFDOqnLZbiwb8SsAQPPFrlUVFL82qfL08ccfDw888EBaFKpdu3Zp22677cLYsWPD8ccfH/7xj3+UfqQAANBE4lcAAJqt8jROy19ppZXS9zGB+s4776Tv+/fvH6ZOndqkgQAAVMSKpVltLBPxKwBAM8auuTZeebrJJpuE5557Lk3d33rrrcP5558fOnXqFK688sqw9tprl36UAACwDMSvAAA0W/L09NNPD/PmzUvfn3POOeEb3/hG2H777cNqq60WbrnlliYNBAAAsiJ+BQCg2abtDx06NBxwwAHp+3XXXTe8/PLL4f33308LSO2yyy5Fn+fyyy8Pm222WejatWvattlmm/D3v/+9KUMCAIAGiV8BAGi2ytNCVl111Ua/pm/fvuG8884L6623XsjlcuH6668P++67b1pwauONNy7V0AAAMlf131VLszo3pSd+BQDaqixj10qLX4tOnuYrTYvxpz/9qajj9tlnn3qPf/GLX6Rq1CeeeKJg8nTBggVpy5s7d27RYwIAoG0RvwIA0GzJ027duoWsV0C97bbbUi/VOH2/kLFjx4azzz4703EAADRJruqLLQtZnbfCiV8BAFogdq2w+LXo5Om1116byQCef/75lCydP39+WHHFFcMdd9wRBg4cWPDY0aNHh1GjRtWrPO3Xr18m4wIAoLyJXwEAaLGep59//nmYNGlSmDZtWvjud78bVlpppfDOO++khZ9iErRYG2ywQXj22WfDxx9/HG6//fYwYsSI8NBDDxVMoHbu3DltAACtTuwZlVXfqAz7UbUl4lcAgGaIXSssfm1S8vTNN98Me+yxR5gxY0bqQbrbbrul5OmvfvWr9Hj8+PFFn6tTp05h3XXXTd8PHjw4PPXUU+Hiiy8OV1xxRVOGBgAA4lcAAEqiXVNedMIJJ4QhQ4aEDz/8MCy33HK1+/fff/8wceLEZRpQTU1NvUWhAADK6u59VhvLRPwKANCMsWuujVeePvLII+Gxxx5LVaN1DRgwILz99ttFnyf2MN1zzz3DmmuuGT755JNw0003pVYA99xzT1OGBQAABYlfAQBotuRprA6trq5eYv9bb72Vpu8Xa86cOWH48OHh3XffTauhbrbZZilxGtsAAACUk6rcF1tW52bZiF8BAOrHl1nGmFW5Np483X333cO4cePClVdemR5XVVWFTz/9NIwZMybstddeRZ/n6quvbsrbAwBAo4hfAQBotuTpb37zmzB06NAwcODAMH/+/PDd7343vPrqq6F79+7hD3/4Q5MGAgBQ1rLs7VRBd+5bivgVAKCOrPuS5tp48rRv377hueeeCzfffHP45z//mapOjzjiiHDIIYfUW0AKAABaA/ErAADNljxNL+zQIXzve99r6ssBACqLytNWT/wKAPBfKk9Lnzy9++67iz7psGHDih8BAABkQPwKAECzJU/322+/eo/jIlG5XG6JfVF1dfUyDwwAoJxkuWJpJa1W2pzErwAAzR+7Vlr82q7YA2tqamq3e++9N2y++ebh73//e/joo4/SFr//yle+EiZMmJDtiAEAoAjiVwAAWqTn6YknnhjGjx8ftttuu9p9Q4cODcsvv3w4+uijw0svvbTMAwMAKCu5qi+2rM7NMhG/AgAsFl9mGWPmqtpe5Wld06ZNCyuvvPIS+7t16xbeeOONUowLAABKRvwKAECzJU+33HLLMGrUqDB79uzaffH7U089NWy11VZNGggAQEWsWJrVxjIRvwIANGPsmmvjydNrrrkmvPvuu2HNNdcM6667btri92+//Xa4+uqrSz9KAABYBuJXAACaredpTJb+85//DPfdd194+eWX076NNtoo7LrrrqGqqnJ6GgAAtIYVSytptdKWIn4FAGie2LXS4tcmJU+jmCTdfffd09aQTTfdNPztb38L/fr1a+rbAABASYhfAQBotuRpMeLiUYsWLcryLQAAWocseztV0J371k78CgC0CVn3Jc2Ftt3zFAAAAACg0mVaeQoA0GZk2Teqgu7cAwDQCmTc8zRUUPyq8hQAAAAAoACVpwAApaDnKQAA5ULP06KpPAUAAAAAKGXl6cSJE9M2Z86cUFNTU++5a665Jn294oorQs+ePZv6FgAA5UPlaasnfgUA+C+Vp9kmT88+++xwzjnnhCFDhoTevXuHqqqqgsd997vfbcrpAQCgpMSvAAA0W/J0/Pjx4brrrguHHnpok94UAKDSVGW4YmmmK6G2EeJXAIDmiV0rLX5tUs/ThQsXhm233bb0owEAgAyIXwEAaLbk6ZFHHhluuummJr0hAAA0N/ErAADNNm1//vz54corrwz3339/2GyzzULHjh3rPX/hhRc2aTAAAJAF8SsAAM2WPP3nP/8ZNt988/T9Cy+8UO+5hhaPAgCoaFmuWFpBPaNaivgVAKCZYtcKi1+blDx98MEHSz8SAADIiPgVAIBmS54CANB8K5ZW0mqlAABUduxaafFrkxaMAgAAAACodJKnAACl7h1V6i0jkyZNSv3qC21PPfVUg6+bNm1a2H///cPqq68eunbtGr797W+H2bNnZzdQAADKJ3bNNX1Il112WRgwYEDo0qVL2HrrrcPkyZMbPPa6665bIoaNr8tbtGhR+MlPfhI23XTTsMIKK4Q+ffqE4cOHh3feeadRY5I8BQBoo7bddtvw7rvv1tuOPPLIsNZaa4UhQ4YUfM28efPC7rvvnoLTBx54IPzv//5vWLhwYdhnn31CTU1Ns38GAAAqwy233BJGjRoVxowZE5555pkwaNCgMHTo0DBnzpwGXxNv5NeNZd98883a5z777LN0njPOOCN9/dOf/hSmTp0ahg0b1qhx6XkKAFAKWVaJZnTeTp06hV69etW7O3/XXXeF4447LiVHC4nJ0jfeeCP84x//SMFqdP3114dVVlklJVN33XXXbAYLAEDpZDzDKTTh3BdeeGE46qijwsiRI9Pj8ePHh7/+9a/hmmuuCaeddlrB18SYtW48W1e3bt3CfffdV2/fpZdeGrbaaqswY8aMsOaaaxY1LpWnAABlYu7cufW2BQsWlPT8d999d/jggw9qA9ZC4nvGILVz5861++L0qHbt2oVHH320pOMBAKBtxK8LFy4MU6ZMqXcjPsaX8fHjjz/e4Pk//fTT0L9//9CvX7+w7777hhdffHGp4/n4449TLLvyyisX/RkkTwEASrhiaVZbFIPCeAc9v40dO7akP7urr746TY3q27dvg8d89atfTT2jYv+oOBUqTuM/5ZRTQnV1dZoqBQBA65d17FrVyPj1/fffT/Fkz5496+2Pj2fNmlXwNRtssEGqSo0zp2688cbUQiq2pXrrrbcKHj9//vwUwx588MG1M6iKIXkKAFAmZs6cme6W57fRo0cXPC5Oa2poIaj89vLLL9d7TQwy77nnnnDEEUcsdQxxkajbbrst/PnPfw4rrrhiCoI/+uij8JWvfCVVBwAAQGPj16bYZptt0gJQm2++edhxxx1TT9MYq15xxRVLHBvbU8VFTnO5XLj88ssb9T56ngIAlEnP03iHvJi75CeffHI47LDDlnrM2muvXe/xtddeG1ZbbbWiGujHBaOmTZuWKgQ6dOiQpj3FXlOLnxMAgLbd87RrkfFr9+7dQ/v27cPs2bPr7Y+PG+ppuriOHTuGLbbYIrz22msFE6dxManYo78xVaeR5CkAQIWJd9zjVqx4Bz4mT+Od+xh0FisGuVEMQuMqqI1duRQAAPILmQ4ePDhMnDgx7LfffmlfnIYfHx977LGhGHHa//PPPx/22muvJRKnr776anjwwQdTsUBjmVsFAFACzdEzKisx+Tl9+vRw5JFHLvHc22+/HTbccMMwefLk2n0x0frEE0+k6tPYX+rAAw8MJ510Uuo7BQBA69dcPU8bY9SoUeGqq64K119/fXjppZfCD3/4w9RfP7+YabzRX3fa/znnnBPuvffe8Prrr4dnnnkmfO9730vVpfmYNiZOv/Wtb4Wnn346/P73v0/J1dg/NW5xgapiqTwFAGjj4kJRsbl+TJIuLgadU6dOTYtD5cXHMXD997//HQYMGBB+9rOfpeQpAAA01UEHHRTee++9cOaZZ6YEZ+xlOmHChNpFpGbMmFGvx/6HH34YjjrqqHTsKquskipXH3vssTBw4MDaIoC77747fR/PVVesQt1pp52KGpfkKQBAmfQ8zcpNN93U4HMxORqn9dd13nnnpQ0AgDLVTD1PGytO0W9omv6kSZPqPb7ooovS1pg4tilM2wcAAAAAKEDlKQBAG688BQCgjWmllaetkcpTAAAAAIACVJ4CAJRAU1cVLfbcAABQyvgyyxizqoLi14pInn5as1yoqWnf0sOoKB8OrKDf8lZk/moV8T+5VufT3qu09BAqUqdP/TuQhc4f1WRy3rYqt8jvKeVp2qIeYbmF4oJSmrteSU9HXlVn1yIDK64wwHXNwHIzP3FdM1Dzz5dd1xKqzi1yPcuMiA0AoBT0PAUAoFzoeVo0PU8BAAAAAApQeQoAUAoqTwEAKBcqT4um8hQAAAAAoACVpwAArXzF0kparRQAgMqOXSstflV5CgAAAABQgMpTAIBS0PMUAIByoedp0VSeAgAAAAAUoPIUAKAE9DwFAKBc6HlaPJWnAAAAAAAFqDwFACgFPU8BACgXep4WTeUpAAAAAEABKk8BAEpB5SkAAOVC5WnRVJ4CAAAAABSg8hQAoASq/rtlIavzAgDQNmUZu1Za/KryFAAAAACgAJWnAACloOcpAADlQs/Toqk8BQAAAAAoQOUpAEAJVOW+2LKQ1XkBAGibsoxdKy1+VXkKAAAAAFCAylMAgFLQ8xQAgHKh52nRVJ4CAAAAABSg8hQAoFQqqLcTAAAVTuxaFJWnAAAAAAAFqDwFAGjlK5ZW0mqlAABUduxaafGrylMAAAAAgAJUngIAtPYVSyvozj0AABUeu1ZY/KryFAAAAACgAJWnAAAloOcpAADlQs/T4qk8BQAAAAAoQOUpAEAp6HkKAEC50PO0aCpPAQAAAAAKUHkKAFACep4CAFAu9DwtnspTAAAAAIACVJ4CAJSCnqcAAJQLPU+LpvIUAAAAAKAAlacAAKWg8hQAgHKh8rRoKk8BAAAAAApQeQoA0MpXLM3qvAAAtE1Zxq6VFr+qPAUAAAAAKEDlKQBAKeh5CgBAudDztGgqTwEAAAAAClB5CgBQAlW5XNqykNV5AQBom7KMXSstflV5CgAAAABQgMpTAIBS0PMUAIByoedp0VSeAgAAAAAt7rLLLgsDBgwIXbp0CVtvvXWYPHlyg8ded911oaqqqt4WX1dXLpcLZ555Zujdu3dYbrnlwq677hpeffXVRo1J8hQAoASqctluAABQLrFrVRPi11tuuSWMGjUqjBkzJjzzzDNh0KBBYejQoWHOnDkNvqZr167h3Xffrd3efPPNes+ff/754be//W0YP358ePLJJ8MKK6yQzjl//vzySJ6eddZZS2SIN9xww5YcEgAANEj8CgCQjQsvvDAcddRRYeTIkWHgwIEp4bn88suHa665psHXxFxir169areePXvWqzodN25cOP3008O+++4bNttss3DDDTeEd955J9x5553lU3m68cYb18sQP/rooy09JACApveNymqj1RC/AgBlL9c88evcuXPrbQsWLCg4nIULF4YpU6akafV57dq1S48ff/zxBj/Gp59+Gvr37x/69euXEqQvvvhi7XPTp08Ps2bNqnfObt26pXYASztnq0uedujQoV6GuHv37i09JAAAaJD4FQCgODGpGROW+W3s2LEFj3v//fdDdXV1vcrRKD6OCdBCNthgg1SVetddd4Ubb7wx1NTUhG233Ta89dZb6fn86xpzzkI6hBYWm7T26dMnNXTdZptt0kVcc801Cx4bs9N1M9QxYw0A0Bpk2ZtUz9PWRfwKAJS7rPvqV/333DNnzkx9SfM6d+5csveIecS45cXE6UYbbRSuuOKKcO6555bsfVq08jSWycaVsSZMmBAuv/zyVE67/fbbh08++aTg8TGxWjdbHbPXAADQXMSvAADFi4nTultDydM4E719+/Zh9uzZ9fbHx3GmejE6duwYtthii/Daa6+lx/nXLcs5Wzx5uueee4YDDzwwNWyNK1397W9/Cx999FG49dZbCx4/evTo8PHHH9duMXsNANAq6HnaJohfAYCK0Ew9T4vVqVOnMHjw4DBx4sTafXEafnxct7p0aeK0/+effz707t07PV5rrbVSkrTuOeMs9ieffLLoc7aKaft1rbzyymH99devzRAvLmanS1neCwAAy0L8CgBQGqNGjQojRowIQ4YMCVtttVUYN25cmDdvXhg5cmR6fvjw4WGNNdao7Zt6zjnnhK9+9ath3XXXTcWYF1xwQXjzzTfDkUcemZ6vqqoKJ554Yvj5z38e1ltvvZRMPeOMM1L70P322688k6dxhaxp06aFQw89tKWHAgDQKHqetk3iVwCgHDVXz9PGOOigg8J7770XzjzzzLSg0+abb55afeYXfJoxY0Zo1+7/JtF/+OGH4aijjkrHrrLKKqly9bHHHgsDBw6sPebHP/5xSsAeffTRKcG63XbbpXPGtZfKInl6yimnhH322Sf0798/vPPOO2HMmDGpv8HBBx/cksMCAICCxK8AANk59thj01bIpEmT6j2+6KKL0rY0sfo0VqjGralaNHn61ltvpUTpBx98EFZfffWU/X3iiSfS9wAAZaUJvZ0adW5aBfErAFARsoxdKyx+bdHk6c0339ySbw8AAI0ifgUAaFtaVc9TAIBylmXfKAAAKCWxa3H+r8sqAAAAAAC1VJ4CAJRCLvfFloWszgsAQNuUZexaYfGrylMAAAAAgAJUngIAlKhnVFZ9o/SjAgCg1PFlljFmVeUUnqo8BQAAAAAoROUpAEApxLvrWd1hr6A79wAAVHjsWmHxq56nAAAAAAAFqDwFACiBqpovtixkdV4AANqmLGPXSotfVZ4CAAAAABSg8hQAoBT0PAUAoFzoeVo0lacAAAAAAAWoPAUAKIGq3BdbFrI6LwAAbVOWsWulxa8qTwEAAAAACpA8BQAohVwu2y0jr7zySth3331D9+7dQ9euXcN2220XHnzwwS/5qLlw5plnht69e4flllsu7LrrruHVV1/NbIwAAJRZ7JqrnNJTyVMAgDbsG9/4Rvj888/DAw88EKZMmRIGDRqU9s2aNavB15x//vnht7/9bRg/fnx48sknwworrBCGDh0a5s+f36xjBwCArEmeAgCUsG9UVls0d+7cetuCBQuWaczvv/9+qhg97bTTwmabbRbWW2+9cN5554XPPvssvPDCCw1WnY4bNy6cfvrpqWI1vu6GG24I77zzTrjzzjuXaTwAAFRG7FpVOYWnkqcAAOWiX79+oVu3brXb2LFjl+l8q622Wthggw1S8nPevHmpAvWKK64IPXr0CIMHDy74munTp6eq1DhVPy+OZeuttw6PP/74Mo0HAABamw4tPQAAgIoQ765ndYf9v+edOXNm6kua17lz52U6bVVVVbj//vvDfvvtF1ZaaaXQrl27lDidMGFCWGWVVQq+Jj+dv2fPnvX2x8dLm+oPAEAbiV0jlacAADS3mDituzWUPI3T8GNidGnbyy+/nKbgH3PMMSlh+sgjj4TJkyenROo+++wT3n333Wb/fAAA0NqoPAUAKIEsezs19rwnn3xyOOyww5Z6zNprr50WifrLX/4SPvzww9qK1t/97nfhvvvuC9dff31Kwi6uV69e6evs2bND7969a/fHx5tvvnnjBgoAQIvIui9pVQVVnkqeAgBUmNVXXz1tXyYuDBXF6fp1xcc1NTUFX7PWWmulBOrEiRNrk6Vx8aonn3wy/PCHPyzJ+AEAoLWoHykDANA0uVy2Wwa22Wab1Nt0xIgR4bnnnguvvPJKOPXUU9OiUHvvvXftcRtuuGG444470vdxyv+JJ54Yfv7zn4e77747PP/882H48OGhT58+aco/AABlIOvYNVc5pacqTwEA2qju3bunxaF+9rOfhV122SUsWrQobLzxxuGuu+4KgwYNqj1u6tSp4eOPP659/OMf/zjMmzcvHH300eGjjz4K2223XTpPly5dWuiTAABANiRPAQAqrOdpYwwZMiTcc889Sz0mLixVbzxVVeGcc85JGwAA5UfP0+KZtg8AAAAAUIDKUwCAUojFmVlViFZOyygAACo9dq2w+FXlKQAAAABAASpPAQDacM9TAADaHj1Pi6fyFAAAAACgAJWnAAClUJP7YstCVucFAKBtyjJ2rbD4VeUpAAAAAEABKk8BAFr7iqWVc+MeAIBKj10rLH5VeQoAAAAAUIDKUwCAEqj676qlWZ0bAADKIXattPhV5SkAAAAAQAEqTwEASiGX+2LLQlbnBQCgbcoydq2w+FXlKQAAAABAASpPAQBKIPaMyqznaeXcuAcAoMJj10qLX1WeAgAAAAAUoPIUAKAU4t31rO6wV9CdewAAKjx2rbD4VeUpAAAAAEABKk8BAEqgKpdLWxayOi8AAG1TlrFrpcWvFZE8XaX9vLBCe0W0pdR17Y9Kej6+8FHnri5FBhas3N51zUCHz/y7moWqate1lKoXdAhhQklPCc2ie/tPwvId/PerlKrXmF/S8/GFTxZ1cSmyUFURf4q3OtWdurX0ECrS8stv1tJDqCyfzw/hqbtaehQ0gn+xAQBKoea/WxayOi8AAG1TlrFrhcWvyl8AAAAAAApQeQoAUAJ6ngIAUC70PC2eylMAAAAAgAJUngIAlEJcUDSrRUUrZ7FSAABagyxj1wqLX1WeAgAAAAAt7rLLLgsDBgwIXbp0CVtvvXWYPHlyUa+7+eabQ1VVVdhvv/3q7f/000/DscceG/r27RuWW265MHDgwDB+/PhGjUnyFACgFHK5bDcAACiX2DXX+Pj1lltuCaNGjQpjxowJzzzzTBg0aFAYOnRomDNnzlJf98Ybb4RTTjklbL/99ks8F883YcKEcOONN4aXXnopnHjiiSmZevfddxc9LslTAAAAAKDk5s6dW29bsGBBg8deeOGF4aijjgojR46srRBdfvnlwzXXXNPga6qrq8MhhxwSzj777LD22msv8fxjjz0WRowYEXbaaadU0Xr00UenpGyxFa2R5CkAQAlU5bLdAACgXGLXqv/Gr/369QvdunWr3caOHVtwPAsXLgxTpkwJu+66a+2+du3apcePP/54g5/jnHPOCT169AhHHHFEwee33XbbVGX69ttvh1wuFx588MHwyiuvhN13373oa2XBKAAAAACg5GbOnBm6du1a+7hz584Fj3v//fdTFWnPnj3r7Y+PX3755YKvefTRR8PVV18dnn322Qbf/5JLLknVprHnaYcOHVJC9qqrrgo77LBD0Z9B8hQAoBSy7E2q5ykAAKWOL7OMMXNfnDsmTusmT0vlk08+CYceemhKhHbv3n2pydMnnngiVZ/2798/PPzww+GYY44Jffr0qVflujSSpwAAAABAi+nevXto3759mD17dr398XGvXr2WOH7atGlpoah99tmndl9NTU36GitMp06dmhKkP/3pT8Mdd9wR9t577/TcZpttlipVf/3rXxedPNXzFACgBKpqst0AAKBcYteqRsavnTp1CoMHDw4TJ06slwyNj7fZZpsljt9www3D888/nxKh+W3YsGFh5513Tt/HXquLFi1KW5yqX1dM0uYTrcVQeQoAAAAAtKhRo0aFESNGhCFDhoStttoqjBs3LsybNy+MHDkyPT98+PCwxhprpEWnunTpEjbZZJN6r1955ZXT1/z+mJDdcccdw6mnnhqWW265NG3/oYceCjfccEO48MILix6X5CkAQCnoeQoAQLlopp6njXHQQQeF9957L5x55plh1qxZYfPNNw8TJkyoXURqxowZS1SRfpmbb745jB49OhxyyCHh3//+d0qg/uIXvwg/+MEPij6H5CkAAAAA0OKOPfbYtBUyadKkpb72uuuuW2Jf7Jd67bXXLtOYJE8BAEoh3lzP6uZ9hkUBAAC0QVnGrhUWv1owCgAAAACgAJWnAAAlUJXLpS0LWZ0XAIC2KcvYtdLiV5WnAAAAAAAFqDwFAGjtK5ZW0J17AAAqPHatsPhV5SkAAAAAQAEqTwEASiHeXK/J6FJWzo17AAAqPXatsPhV5SkAAAAAQAEqTwEAWvmKpZW0WikAAJUdu1Za/KryFAAAAACgAJWnAAClEG+uZ3WHvXJu3AMAUOmxa4XFrypPAQAAAAAKUHkKAFAK8c59ZpWnFXTrHgCAyo5dKyx+VXkKAAAAAFCAylMAgFKoicuKZnhuAAAoh9i1wuJXlacAAAAAAAWoPAUAKIGqXC5tWcjqvAAAtE1Zxq6VFr+qPAUAAAAAKEDlKQBAa1+xtILu3AMAUOGxa4XFrypPAQAAAAAKUHkKAFAKKk8BACgXKk+LpvIUAAAAAKAAlacAAKWg8hQAgHKh8rRoKk8BAAAAAApQeQoAUAo1IYSqDM8NAADlELtWWPyq8hQAAAAAoACVpwAAJVCVy6UtC1mdFwCAtinL2LXS4leVpwAAAAAABag8BQBo7SuWVtCdewAAKjx2rbD4VeUpAAAAAEABKk8BAEqhJhebO2V3bgAAKIfYtcLiV5WnAAAAAACtLXk6YMCAUFVVtcR2zDHHtOSwAACa3jcqq41WQfwKAFSErGPXXOXEry06bf+pp54K1dXVtY9feOGFsNtuu4UDDzywJYcFAAAFiV8BANqWFk2err766vUen3feeWGdddYJO+64Y8HjFyxYkLa8uXPnZj5GAIDiZHmHvXLu3Jc78SsAUBmyrg7NhUrRanqeLly4MNx4443h8MMPT1P3Cxk7dmzo1q1b7davX79mHycAAETiVwCAytdqkqd33nln+Oijj8Jhhx3W4DGjR48OH3/8ce02c+bMZh0jAECD9Ixqc8SvAEDZ0vO0PKbt13X11VeHPffcM/Tp06fBYzp37pw2AABoaeJXAIDK1yqSp2+++Wa4//77w5/+9KeWHgoAQNPU5LLr7ZTOTWsifgUAylqWsWuFxa+tYtr+tddeG3r06BH23nvvlh4KAAB8KfErAEDb0OKVpzU1NSn4HDFiROjQocWHAwDQNLmaL7YsZHVemkT8CgCUvSxj1wqLX1u88jRO158xY0Y4/PDDW3ooAADwpcSvAABtR4snT3ffffeQy+XC+uuv39JDAQBovSuWZuSVV14J++67b+jevXvo2rVr2G677cKDDz641NfEPvUxhltttdVCVVVVePbZZ0NbIn4FAMpe1rFrTs9TAAAqwDe+8Y3w+eefhwceeCBMmTIlDBo0KO2bNWtWg6+ZN29eSrL+6le/ataxAgBAc9NkFACgta9Y+t/VSufOnVtvd+fOndPWVO+//3549dVXw9VXXx0222yztO+8884Lv/vd78ILL7wQevXqVfB1hx56aPr6xhtvNPm9AQCo0Ni1TvxaCVp82j4AAMXp169f6NatW+02duzYZbp0cdr9BhtsEG644YZUTRorUK+44orQo0ePMHjwYD8WAADaPJWnAAClkGVvp/+ed+bMmakvad6yVJ1GsV9pXPxov/32CyuttFJo165dSpxOmDAhrLLKKss8bAAAWqms+5LmVJ4CANDMYuK07tZQ8vS0005LidGlbS+//HJatPOYY45JCdNHHnkkTJ48OSVS99lnn/Duu+/6+QIA0OapPAUAKIXUNiqrytPGHX7yySeHww47bKnHrL322mmRqL/85S/hww8/rK1ojf1O77vvvnD99denJCwAABUoy9g1qpzCU8lTAIBKs/rqq6fty3z22Wfpa5yuX1d8XFNTk9n4AACgXFgwCgCglH2jstoysM0226TepiNGjAjPPfdceOWVV8Kpp54apk+fHvbee+/a4zbccMNwxx131D7+97//HZ599tnwr3/9Kz2eOnVqejxr1qxMxgkAQJnFrrmmxa+XXXZZGDBgQOjSpUvYeuutU1upYtx8882pNVVsQbW4l156KQwbNiwtuLrCCiuELbfcMsyYMaPoMUmeAgC0Ud27d0+LQ3366adhl112CUOGDAmPPvpouOuuu8KgQYNqj4vJ0Y8//rj28d133x222GKL2gTrd77znfR4/PjxLfI5AAAof7fccksYNWpUGDNmTHjmmWdSPDp06NAwZ86cpb7ujTfeCKecckrYfvvtl3hu2rRpYbvttkvFAJMmTQr//Oc/wxlnnJGSs8XS8xQAoBTSNPeMprpnOIU+JkzvueeepR4TF5aqK/ZT/bKeqgAAtNHYtYnx64UXXhiOOuqoMHLkyPQ43pj/61//Gq655poGe/FXV1eHQw45JJx99tlpAdSPPvqo3vM/+9nPwl577RXOP//82n3rrLNOo8al8hQAAAAAKLm5c+fW2xYsWFDwuIULF4YpU6aEXXfdtV4f/vj48ccfb/D855xzTujRo0c44ogjlngu9vCPydf1118/VbDG42IrgDvvvLNRn0HyFACgFFphzygAAGiR2DX3Rfzar1+/1Gs0v40dO7bgcN5///1URdqzZ896++Pjhvrqx3ZTV199dbjqqqsKPh+n+8f2VOedd17YY489wr333hv233//cMABB4SHHnqo6F8M0/YBAAAAgJKbOXNm6Nq1a+3jzp07l+S8n3zySTj00ENT4jT28S8kVp5G++67bzjppJPS95tvvnl47LHHUkuAHXfcsaj3kjwFACiFLCtEVZ4CAFDq+DLLGDP3xblj4rRu8rQhMQHavn37MHv27Hr74+NevXoVXAgqLhS1zz77LJEs7dChQ1rwNFa9xu8HDhxY77UbbbRRqlotlmn7AAAAAECL6dSpUxg8eHCYOHFivWRofLzNNtsscfyGG24Ynn/++fDss8/WbsOGDQs777xz+j4mTuM5t9xyy5RIreuVV14J/fv3L3psKk8BAEqhJt5dz2V4bgAAKGV8mWGMWdP4c48aNSqMGDEiDBkyJGy11VZh3LhxYd68eWHkyJHp+eHDh4c11lgj9U3t0qVL2GSTTeq9fuWVV05f6+4/9dRTw0EHHRR22GGHlFidMGFC+POf/xwmTZpU9LgkTwEAAACAFnXQQQeF9957L5x55plpkajYnzQmO/OLSM2YMSO0a9e4SfRxgajY3zQmXI8//viwwQYbhD/+8Y9hu+22K/ockqcAACWQy9WkLQtZnRcAgLYpy9g1auq5jz322LQV8mXVotddd13B/YcffnjamkrPUwAAAACAAlSeAgCUakXRrHqTZrkSKgAAbU+WsWuFxa8qTwEAAAAAClB5CgBQsrvrKk8BAGjjsWuk8hQAAAAAoLKpPAUAKIWamhCqMlqxNMOVUAEAaIOyjF0rLH7V8xQAAAAAoACVpwAApaDnKQAA5ULP06KpPAUAAAAAKEDlKQBACeRqakIuo75RuQrqGQUAQGXHrpUWv6o8BQAAAAAoQOUpAEAp6HkKAEC50PO0aCpPAQAAAAAKUHkKAFAKNbkQqnIZVgYAAEAZxK4VFr+qPAUAAAAAKEDlKQBAye6uZ7SqaAXduQcAoMJj1wqLX1WeAgAAAAAUoPIUAKAEcjW5kMuob1Sugu7cAwBQ2bFrpcWvKk8BAAAAAApQeQoAUAq5mgx7nmbYjwoAgLYny9i1wuJXlacAAAAAAAWoPAUAKAE9TwEAKBd6nhZP5SkAAAAAQAEqTwEASkHPUwAAyoWep20jeZrL5dLXzz6tnCa0rUX1ZwtaeggVqeY/81t6CBWpZn77lh5CRapeUNXSQ6hIVdUtPYLKUrNgfr2YoCV9HhaFkMvw3FSE/4tf/WNQajWfibOyUOOyZqJ6YTbnbes+XyQ3kMl1/dw/BCW9ntULWkX8mmXsWmnxa1WupX9ay+Ctt94K/fr1a+lhAAAtbObMmaFv374t8t7z588Pa621Vpg1a1am79OrV68wffr00KVLl0zfh2yJXwGAloxfmyt2raT4tayTpzU1NeGdd94JK620Uqiqat0VUnPnzk2J3vg/jq5du7b0cCqG6+q6lhO/r65rOSmX39cYxnzyySehT58+oV27lmvlHoPQhQuzLSPq1KlT2QeeiF8pn39fy43r6rqWC7+rrmtriF+bI3atpPi1rKftx1+ylqoyaaoYIAmSXNdy4ffVdS0nfl/b7nXt1q1bSw8hBYWVEBiSPfEr5fTvazlyXV3XcuF3tW1f15aOX8WujdNyJRoAAAAAAK2Y5CkAAAAAQAGSp82kc+fOYcyYMekrrmtr5/fVdS0nfl9dV8C/A+XEf7dc13Li99U1LRd+V8lSWS8YBQAAAACQFZWnAAAAAAAFSJ4CAAAAABQgeQoAAAAAUIDkKQAAAABAAZKnAAAAAAAFSJ5m7PLLLw+bbbZZ6Nq1a9q22Wab8Pe//z3rt614Z511Vqiqqqq3bbjhhi09rLJXXV0dzjjjjLDWWmuF5ZZbLqyzzjrh3HPPDblcrqWHVlYefvjhsM8++4Q+ffqk380777yz3vPxep555pmhd+/e6Trvuuuu4dVXX22x8Zb7NV20aFH4yU9+EjbddNOwwgorpGOGDx8e3nnnnRYdcyX8rh522GFL/Fu7xx57tNh4geYhfs2G+LX0xK6lIXbNhvi1+a9rJH4lC5KnGevbt28477zzwpQpU8LTTz8ddtlll7DvvvuGF198Meu3rngbb7xxePfdd2u3Rx99tKWHVPZ+9atfpT+YLr300vDSSy+lx+eff3645JJLWnpoZWXevHlh0KBB4bLLLiv4fLymv/3tb8P48ePDk08+mRJ+Q4cODfPnz2/2sVbCNf3ss8/CM888kxL/8euf/vSnMHXq1DBs2LAWGWsl/a5GMVla99/aP/zhD806RqD5iV+zI34tLbFraYhdsyF+bf7rmid+pdQ6lPyM1BPviNT1i1/8IiWnnnjiiRQ80XQdOnQIvXr1cglL6LHHHkvJ/b333js9HjBgQEqUTJ482XVuhD333DNthcSq03HjxoXTTz89XevohhtuCD179kx3Tb/zne+41o28pt26dQv33XdfvX3xBsBWW20VZsyYEdZcc03XtAm/q3mdO3f2by20MeLX7IhfS0vsWhpi12yIX5v/uuaJXyk1lafNPK3k5ptvTndK4vR9lk2c5hxL9ddee+1wyCGHpCQJy2bbbbcNEydODK+88kp6/Nxzz6WK3i/7jxPFmz59epg1a1aaql83+bf11luHxx9/3KUskY8//jhN41l55ZVd02U0adKk0KNHj7DBBhuEH/7wh+GDDz5wTaENEb+Wlvi1tMSu2RO7Nh/xa+mIXyk1lafN4Pnnn0/J0jgld8UVVwx33HFHGDhwYHO8dcWKiabrrrsu/TEfp5GeffbZYfvttw8vvPBCWGmllVp6eGXrtNNOC3Pnzk39Y9u3b5/+YIrV0jE5TWnExGkUK03rio/zz7Fs4r+1sQfqwQcfnHpN03RxytMBBxyQ+iBPmzYt/PSnP003U2KiP/4bAVQu8WvpiV9LT+yaPbFr8xC/lo74lSxInjaDmOB79tln052k22+/PYwYMSI89NBDEqjLoG4lZFyQKwaj/fv3D7feems44ogjSvFja5Pi9fv9738fbrrpptRWIv7ennjiianCN/7eQmsXF4/69re/ndojxBYpLJu6bSTiglzx39u4kFy8m//1r3/d5YUKJn4tPfFr6YldqQTi19ISv5IF0/abQadOncK6664bBg8eHMaOHZuaG1988cXN8dZtRpyau/7664fXXnutpYdS1k499dR0Bz/+BycmSg499NBw0kknpd9bSiPfp3f27Nn19sfHeviWJvB88803Uw9UVaelF9ukdO/e3b+10AaIX7Mnfl12YtfsiV2zJX7NnviVUpA8bQE1NTVhwYIFLfHWFevTTz9NU0p79+7d0kMpa3HV8nbt6v+zEKfmxt9ZSiNOf45BaOwtmxdbJTz55JN6IZcg8Iy95O6///6w2mqrleLHxWLeeuut1PPUv7XQ9ohfS0/8uuzErtkTu2ZH/No8xK+Ugmn7GRs9enSaohNXe/7kk0/SdOg43fGee+7J+q0r2imnnJJWgo1T9d95550wZsyYlOSLPQ5punhNY4/T+Psap+3/4x//CBdeeGE4/PDDXdZG/jFUtwo6NtqPLRBWXXXVdG1jK4Sf//znYb311ksB6RlnnJFaI+y3336ucxOuaUzkfetb3wrPPPNM+Mtf/pJ69eb7c8XnY/UUjb+ucYv9pL/5zW+mhH+8QfXjH/84zaQYOnSoSwoVTPyaDfFr6YldS0Psmg3xa/NfV/ErmcmRqcMPPzzXv3//XKdOnXKrr7567utf/3ru3nvvddWX0UEHHZTr3bt3uq5rrLFGevzaa6+5rsto7ty5uRNOOCG35ppr5rp06ZJbe+21cz/72c9yCxYscG0b4cEHH8zFf14X30aMGJGer6mpyZ1xxhm5nj175jp37pz+XZg6dapr3MRrOn369ILPxS2+jqZd188++yy3++67p/92dezYMf237KijjsrNmjXLJYUKJ37Nhvi19MSupSF2zYb4tfmvq/iVrFTF/5ddahYAAAAAoDzpeQoAAAAAUIDkKQAAAABAAZKnAAAAAAAFSJ4CAAAAABQgeQoAAAAAUIDkKQAAAABAAZKnAAAAAAAFSJ4CbUZVVVW48847W3oYAABQFPErQMuTPAVa3GGHHZYCw7h17NgxrLXWWuHHP/5xmD9/fksPDQAAliB+BWg7OrT0AACiPfbYI1x77bVh0aJFYcqUKWHEiBEpmfqrX/3KBQIAoNURvwK0DSpPgVahc+fOoVevXqFfv35hv/32C7vuumu477770nMffPBBOPjgg8Maa6wRll9++bDpppuGP/zhD/Vev9NOO4Xjjz8+Vayuuuqq6VxnnXXWUt9zzJgxoXfv3uGf//xnpp8NAIDKI34FaBskT4FW54UXXgiPPfZY6NSpU3ocp+8PHjw4/PWvf03PHX300eHQQw8NkydPrve666+/PqywwgrhySefDOeff34455xzahOwdeVyuXDccceFG264ITzyyCNhs802a7bPBgBA5RG/AlSuqlzMIgC0cM+oG2+8MXTp0iV8/vnnYcGCBaFdu3bh1ltvDd/85jcLvuYb3/hG2HDDDcOvf/3r2srT6urqlAzN22qrrcIuu+wSzjvvvPQ4tgG47bbbwh133BH+8Y9/pMRqrGYFAADxKwCF6HkKtAo777xzuPzyy8O8efPCRRddFDp06FCbOI1J0V/+8pcpmfr222+HhQsXpgRrnMJf1+IVpHFK/pw5c+rtO+mkk9IUqyeeeCJ07969GT4ZAACVSPwK0DaYtg+0CnG6/brrrhsGDRoUrrnmmjT1/uqrr07PXXDBBeHiiy8OP/nJT8KDDz4Ynn322TB06NCURK2rY8eO9R7HStOampp6+3bbbbeUgL3nnnua4VMBAFCpxK8AbYPkKdDqxCn7P/3pT8Ppp58e/vOf/4T//d//Dfvuu2/43ve+l5Kra6+9dnjllVeadO5hw4aFm266KRx55JHh5ptvLvnYAQBoe8SvAJVL8hRolQ488MDQvn37cNlll4X11lsv9SeNi0i99NJL4fvf/36YPXt2k8+9//77h//5n/8JI0eODLfffntJxw0AQNskfgWoTHqeAq1S7Hl67LHHhvPPPz8t7vT666+nqfqxz+nRRx8d9ttvv/Dxxx83+fzf+ta30pT+Qw89NFUKHHDAASUdPwAAbYv4FaAyVeVyuVxLDwIAAAAAoLUxbR8AAAAAoADJUwAAAACAAiRPAQAAAAAKkDwFAAAAAChA8hQAAAAAoADJUwAAAACAAiRPAQAAAAAKkDwFAAAAAChA8hQAAAAAoADJUwAAAACAAiRPAQAAAAAKkDwFAAAAAChA8hQAAAAAoADJUwAAAACAAiRPAQAAAAAKkDwFAAAAAChA8hQAAAAAoADJU4AS2WmnndKW98Ybb4Sqqqpw3XXXucYAABXuqaeeCttuu21YYYUVUgz47LPPtvSQ2gxxN5AlyVOoYDFpFwO3Ll26hLfffnuJ52Oib5NNNmmRsbVVf/vb38JZZ53V0sMAANp4fPj00083eMzMmTPD2WefHbbaaquwyiqrhO7du6e48f777y/qPSZNmpTeI25TpkxZ4vnDDjssrLjiiqGSLFq0KBx44IHh3//+d7jooovC//zP/4T+/ft/6fWJW+fOnUPPnj3TNf7lL38Z3nvvvQZ/bnF79NFHl3g+l8uFfv36pee/8Y1v1Huu7nt16NAhrLrqqmHw4MHhhBNOCP/6179CayNeBlobyVNoAxYsWBDOO++8lh5GmxMD5v/85z/h0EMPrRcMxj9GAABaq7vuuiv86le/Cuuuu274+c9/Hs4444zwySefhN122y1ce+21jTpXW7lpPG3atPDmm2+GU045JRx99NHhe9/7Xko8L83xxx+fkqxXXnllOPXUU1NSc8yYMWGjjTYKDzzwQMHXxKKIm266aYn9Dz30UHjrrbdSIraQ+LOL7xV/fuecc074yle+Eq6//vowaNCgcOGFF4bWpCnxcqG4G6BUOpTsTECrtfnmm4errroqjB49OvTp0ye0BfHu+/z588Nyyy3XYmPIV/0CAJSTnXfeOcyYMSNVnOb94Ac/SDHlmWeeGUaOHFnUeeLxf/nLX8IzzzyTknVZ+eyzz8Lyyy8fWtKcOXPS15VXXrno12y//fbhW9/6Vr19zz33XNh9993DN7/5zVQV2rt373rP77XXXuG2224Lv/3tb1MVaV5MqMZq0vfff7/ge62//vopoVtXLK7YZ599wsknnxw23HDDdO5y8/nnn4eamprQqVMncTeQGZWn0Ab89Kc/DdXV1V9afRqDj3PPPTess8466a71gAED0mtj5WpdcX+cDhSnDMXpXDFBuPbaa4cbbrih6AqEmFh87bXX0rStGGR269YtBeIx+F2WMd1zzz1hyJAhKWl6xRVX1E6LuvXWW9Md7DXWWCOstNJKKVD9+OOP03lOPPHE0KNHjzR9LI5h8XPHO/S77LJLOiaOYeDAgeHyyy9vdO+l+Fkvu+yyJaZPxURvHP++++67xDliAjhem+9///tFXVsAgGW18cYb10ucRjEGism1WN0Yq1CLcdxxx6Xqy2KrT3/3u9+l947vFW/4H3PMMeGjjz4q2HYqtgPYYYcdUtI0xob5uOvXv/51irdibBqfi4nI2IYgxlsxpuzbt2+KE2PcFafYFyNWgcZEZ+xlGuPW+NqXXnqp9vkY4+24447p+zh1P46jbh/8xoiVoOPGjUuf+9JLL13i+YMPPjh88MEH4b777qvdt3DhwnD77beH7373u416r9VWWy3cfPPNKQn7i1/84kuPj5/r2GOPTcnbGA/H67jNNtuE559/Pj0fY+9YrRz/NoifP/5M6nrkkUfS9VlzzTXTzzi2GTjppJNSxWheQ/FyVPdnHK9R/u+DmGRePO6OyezVV189jSP+7PPi3x/x53jQQQc16loBbZvKU2gD1lprrTB8+PBUfXraaac1WH165JFHpuk7MbEY70A/+eSTYezYsSk4vOOOO+odGwOPeNwRRxwRRowYEa655poU7MQ73jHoLca3v/3tNLb4HrEi4f/9v/+XEpRxmlhTxjR16tQUUMZE41FHHRU22GCD2ufia2KAFz9/HPsll1wSOnbsGNq1axc+/PDDFNQ/8cQTKeCKY4pVFXkxURo/07Bhw1Jw+ec//zn86Ec/Sne5Y1BfrDiud955JwW7cdpUXgz0YiXA+eefn4L4OGUrL77X3Llzl6gUAABobrNmzUoJyWKrPLt27ZqSYzGu+rLq0xiLxRvdu+66a/jhD3+Y4roYg8VFmP73f/83xW15MXm45557hu985zspRor9QvN+//vfp2RiTNzGuCrGVzHmjDfC4031n/zkJ7WxYJxiH2PYpYl9XuN7xWRsHGNM9MXXfu1rX0ufKd4AjzFevEEf+5XGqfhbbrllvTE1Vj7Gvvfee5dIasb3iwnLP/zhD2lc0d///vdUFBCvR6xIbYyYyIyJ3wcffDDFnPFntjQxAXr33XfXxsAxxo4FDD/+8Y9T8jvGyDG2jtf98MMPr9d+ICZdY6FE/PnGxO3kyZPTtYwJ+fjc0uLlxQsbYoFBbI8Qk6cxdo5xeV3xb4r4+xOTtfE94s8lHhP/XomFFHGsAEXLARXr2muvjbdZc0899VRu2rRpuQ4dOuSOP/742ud33HHH3MYbb5y+f/bZZ9OxRx55ZL1znHLKKWn/Aw88ULuvf//+ad/DDz9cu2/OnDm5zp07504++eQvHdeYMWPS6w8//PB6+/fff//caqutVvu4KWOaMGFCvWMffPDBtH+TTTbJLVy4sHb/wQcfnKuqqsrtueee9Y7fZptt0rnq+uyzz5b4DEOHDs2tvfba9fbF6xm3vOnTp6f3jj+HvGOOOSbtW9zUqVPT/ssvv7ze/mHDhuUGDBiQq6mpWeI1AADLEh82xquvvprr0qVL7tBDD/3SY/Px12233Zb76KOPcqusskqKafJGjBiRW2GFFerFkZ06dcrtvvvuuerq6tr9l156aTrPNddcU7svxlpx3/jx4+u9Zz7uWn311dN75o0ePTrtHzRoUG7RokX1YsH4nvPnz1/qZ9l8881zPXr0yH3wwQe1+5577rlcu3btcsOHDy/4mRtzfRoSxxuvW6GfW7wuK620Um2MeuCBB+Z23nnn9H2MY/fee+9654qvizFoQ0444YR0TPxcSxOPifF+vNZ5V1xxRdrfq1ev3Ny5c5e47nWPLRRTjx07NsXkb7755pfGy/mfcdeuXdPvTKHn6sbd+Z/z8ssvn3vllVdyF1xwQTrmzjvvXOrnBFicafvQRsS75bGBemxI/+677xZszB6NGjWq3v5Y7Rn99a9/rbc/TtWJ05fy4rSYWOn5+uuvFz2m2Durrni+WEkQ73o3ZUyxYnTo0KEF3ytW3tatWNh6663TFJ54R7yuuD9O7YrtAvLq9k2Nd/VjL6l4hz5+1vi4FGIfqvjesVoiL1ZLxEqCQw45pHa6EgBAc4vVgrGCL8ZEjV2ENLYfii2SYrXiP/7xjwarO2O1aDwuzgrKizOJYiXk4jFfrDZsqO9qHGd8z7wYX0WxQrVuj9C4P77n22+/3eDYY8z87LPPpmrFujODNttss7QAUz5WzUJsJ9VQe4RYSRsrYGM/2XhM/NrYKfuLv1dUTDuGr3/966n6dfHrG3u0xorOxffX/dugbkw9b968FFNvu+22KSZv6HejkPhe8W+PYsTWB/H3IVbzxoXP4t9DhVplASyN5Cm0IaeffnpKChYKeuPqoDFYjX2K6urVq1fq7RSfX3yKz+JiT6s4TSeKPVbj1K66WwxQl3aO/Iqk+XM0dkwxedqQxd8rH1THXkuL749TeuomReNUsTiFLN/nKgZrsbdWVKrkaT7BG98r/7ni9KVFixZZNRQAaDExpovTwWNfydhXsymLj55wwgkphmqo92k+9qnbcimKiwDFAoDFY744RT4+t6wxX924szHjijbaaKOU/ItJwCx8+umn9ZKRdcVYNMamcZGoP/3pT+lntPjCU419r6ih9yvV9Y2LkOUT0TFhGz9HvldsY2LqpcX8i4vvFVsZ/POf/0xjamxbA4BI8hTakBh8xrvuDVWfRsVWOLZv377g/nxD9li9GVcHrbs99thjjTpHY8dU9252seP9sjFMmzYt3WGPwfGFF16YKh9iD6bYvytavL/Ssoh/mMTq2Hz16Y033pgWvyoUsAMANIdY/RkrG2Nf+Ng3tCmKqT5tjCxivtYk3jx/5ZVXliggqCtWmsYZSuPHj0+9T2NyuqleeOGFdH2KSUo29frGBG+s1o2xdOw7e+edd6aYOr/AU2Ni6qX9/AuJC8rmE7mxvypAY0meQhutPq27KFPUv3//FLS8+uqr9fbPnj07rfYZn2+MWB0aA6K6W1w9tDFKPaamiAs2LViwIAX7sYF9XGU23ulvbNBWTCI43hnfe++9U/I0VjrEKtQ4tQgAoCWceuqpaXGeiy66KC3KuSxi8jQm+OKiUIvLx3Rxkai64qyl6dOnN0vMV0hD44pefvnl0L179zQzqdRihW+clt9QO6po//33TzO04oKnyzJlP1aDPvTQQ2kRqmIqT5vq+eefTwnh3/zmNyl5GqfOx5i6UCVzKdtVTZgwIS1KGxe0ipWucaHbuu25AIoheQptzDrrrJOqT6+44oo0lT4vJgWjcePG1Ts+VltGManXGF26dEkBUd0tPy2/WKUeU1Pk76LXrUqI04riHxJNkQ+wY/K3kJgsjdPi4h8r8b1jNSoAQHO74IILwq9//evUqihOu19W+erTu+66K/URrSvGiXEafpxSXTfmuvrqq1Pc1RwxXyFx5tTmm28err/++nqxW6zUvPfee2tj1VJ67rnn0nWKcXN+RftC4rT3uJp8bIWwzz77NOm9Yn/9mBSPVaE/+9nPQnPH1PH7iy++uNHxcrHi64888siw1VZbhV/+8pcpifrMM8+k7wEa4/86ZgNtRgyO/ud//ifdRd94443TvlgVGu/Exin9MdCI/YcmT56cgsX99tsv7Lzzzs0+ztYwpt133z0F8zEojZWnsSfUVVddFXr06NFg64OlGTx4cPp6/PHHp2qCxROk8Y+D1VZbLfU7jVOw4vsAAJTaNddck6ryFhcTpXEBp1ipt95666XenrGVUF1x+nXPnj0b/Z7x3LGKNSYI61ZsxorA0aNHp6rUPfbYIwwbNizFqb/73e/ClltumW78t2QSOcZksTLziCOOSBWhl1xySUoGN9TDtViPPPJImD9/fkpexkVT46yjONspnvuOO+5IM7mWJsbJxYpVn/HnGBOWcXHW+DOI8WaMbWNhQrzuWdpwww1TEccpp5ySFumKC4H98Y9/LNhz9svi5cb8vsXrGn+f4zniZ4zJ1J///Oep8rWxs+KAtkvyFNqg2D8pBqExCVlXvBsb+6LG3kP5gC0GsmPGjGmxsbb0mGK/0Th1KrY7iMFefP8f/vCHKcg//PDDG32+Aw44IBx33HHh5ptvrg1g6waDMVF70EEHpT8WTNkHALISqxYLiQv6xMRaFFsnFYpHHnzwwSYlT+O0/VhVWWjqfkxExvgqro4ee8vHdkZHH310qhKMPeFbSqyKjUnmGHueeeaZaSzxhn5sgdWYhYsKyS9eFM8Zr01MVMdrE/vMFruafLHybbTiVP+YuIxjj8nXeI0HDhwYshY/Y2yHFROiY8eOTbPUYuuBY489dokk5pfFy8WISegbbrghtQmIidu8mCiO1yF+9qeeeqpFf7eA8lGVa40dsgHasPgHQ5ymFtsqLL/88i09HAAAAGiz9DwFaEXi1K14h/2b3/ymxCkAAAC0MNP2AVqBOXPmpH5MsUVA7M1UioUZAAAAgGUjeQrQCvzrX/8KhxxySFogKva/iiu7AgAAAC1Lz1MAAAAAgAL0PAUAAAAAKEDyFAAAAACg0nqe1tTUhHfeeSestNJKoaqqqqWHAwA0s1wuFz755JPQp0+f0K5dy90Tnj9/fli4cGGm79GpU6fQpUuXTN+D7IlfAaBtaw3xa3PErpUUv5Z18jQmTvv169fSwwAAWtjMmTND3759Wyz4XKv/imHWnOpM36dXr15h+vTpFRGAtmXiVwCgJePX5opdKyl+Levkaaw4jbYfdFLo0L5zSw+norT7+D8tPYSK9KdnzmnpIQBUlLlz56YbqfmYoCXEu/Yx+HxzyoDQdaVsqgfmflIT+g9+I71XuQefbV3+d3W7sFfoEDq29HAqyicHbtnSQ6hID/y/41p6CAAVpaXj1+aIXSstfi3r5Gl+qn5MnHZoX94/iNamXfualh5CReratWtLDwGgIrWG9j0rrlSVtizUhJb/fJQ4fg0dQ4cqydNSat/R3wNZEL8CVGb8mmXsWmnxqwWjAAAAAAAqrfIUAKC1qM7VhOpcducGAIByiF0rLX5VeQoAAAAAUIDKUwCAEqgJubRlIavzAgDQNmUZu1Za/KryFAAAAACgAJWnAAAlUJP+LxvZnRkAgLYoy9i10uJXlacAAAAAAAWoPAUAKIHqXC5tWcjqvAAAtE1Zxq6VFr+qPAUAAAAAKEDlKQBAK1+xtJJWKwUAoLJj10qLX1WeAgAAAAAUoPIUAKBEd9erVZ4CANDGY9dI5SkAAAAAQIVTeQoAUAJ6ngIAUC70PC2enqcAAAAAAAWoPAUAKIHqXC5tWcjqvAAAtE1Zxq6VFr+qPAUAAAAAKEDyFACgBGoy3hrj8ssvD5tttlno2rVr2rbZZpvw97//famvue2228KGG24YunTpEjbddNPwt7/9bZmuBwAAbTd2rQmVQ/IUAKDC9O3bN5x33nlhypQp4emnnw677LJL2HfffcOLL75Y8PjHHnssHHzwweGII44I//jHP8J+++2XthdeeKHZxw4AAK2J5CkAQAlUh1ymW2Pss88+Ya+99grrrbdeWH/99cMvfvGLsOKKK4Ynnnii4PEXX3xx2GOPPcKpp54aNtpoo3DuueeGr3zlK+HSSy/1uwEAUIGyjl2rGxm/tmaSpwAAZWLu3Ln1tgULFnzpa6qrq8PNN98c5s2bl6bvF/L444+HXXfdtd6+oUOHpv0AANCWdWjpAQAAVILq3BdbVueO+vXrV2//mDFjwllnnVXwNc8//3xKls6fPz9Vnd5xxx1h4MCBBY+dNWtW6NmzZ7198XHcDwBA5ckydo2yPHdzkzwFACgTM2fOTAtA5XXu3LnBYzfYYIPw7LPPho8//jjcfvvtYcSIEeGhhx5qMIEKAAAsSfIUAKAEslxVNH/emDitmzxdmk6dOoV11103fT948ODw1FNPpd6mV1xxxRLH9urVK8yePbvevvg47gcAoPJkGbuGjM/d3PQ8BQBoA2pqahrskRqn90+cOLHevvvuu6/BHqkAANBWqDwFACiBmlAVqkNVZudujNGjR4c999wzrLnmmuGTTz4JN910U5g0aVK455570vPDhw8Pa6yxRhg7dmx6fMIJJ4Qdd9wx/OY3vwl77713WmDq6aefDldeeWUmnwcAgMqNXZsSv7ZmkqcAABVmzpw5KUH67rvvhm7duoXNNtssJU5322239PyMGTNCu3b/NwFp2223TQnW008/Pfz0pz8N6623XrjzzjvDJpts0oKfAgAAWp7kKQBACdTkvtiy0NjzXn311Ut9PlahLu7AAw9MGwAAlS/L2DXK8tzNTc9TAAAAAIACVJ4CAJRAdYZ9o7LsRwUAQNuTZexaafGrylMAAAAAgAJUngIAlIDKUwAAyoXK0+KpPAUAAAAAKEDlKQBACdTkqtKWhazOCwBA25Rl7Fpp8avKUwAAAACAAlSeAgCUgJ6nAACUCz1Pi6fyFAAAAACgAJWnAAAlUB3apS0L1ZmcFQCAtirL2LXS4leVpwAAAAAABag8BQAogVyGK5bGcwMAQDnErpUWv6o8BQAAAAAoQOUpAEArX7E0q/MCANA2ZRm7Vlr8qvIUAAAAAKAAlacAACVQnWuXtixU5zI5LQAAbVSWsWulxa8qTwEAAAAAWlvy9OGHHw777LNP6NOnT6iqqgp33nlnSw4HAKDJakJVqAntMtoqp2dUuRO/AgCVINvYtV1Fxa8tmjydN29eGDRoULjssstachgAAFAU8SsAQNvSoj1P99xzz7QVa8GCBWnLmzt3bkYjAwBoPSuWVtJqpeVO/AoAVIIsY9f8+StFWfU8HTt2bOjWrVvt1q9fv5YeEgAANEj8CgBQ3soqeTp69Ojw8ccf124zZ85s6SEBANRbsTSrjfIkfgUA2mLsWl1B8WuLTttvrM6dO6cNAADKgfgVAKC8lVXyFACgda9Ymk1vp0parRQAgMqOXSstfq2cGloAAAAAgEqpPP3000/Da6+9Vvt4+vTp4dlnnw2rrrpqWHPNNVtyaAAAjVIT2oXqjO5L14Scn0YrIX4FACpBlrFrpcWvLZo8ffrpp8POO+9c+3jUqFHp64gRI8J1113XgiMDAIAliV8BANqWFk2e7rTTTiGXq5xMNADQdmW5qmi1eKnVEL8CAJUgy9i10uJXPU8BAAAAAFpb5SkAQCX1jYpbNueunDv3AABUduxaafGrylMAAAAAgAJUngIAlEB1riptWcjqvAAAtE1Zxq6VFr+qPAUAAAAAKEDlKQBACVSHdmnLQnUF9YwCAKCyY9dKi19VngIAAAAAFKDyFACgBGpy7dKWhZpc5dy5BwCgsmPXSotfVZ4CAAAAABSg8hQAoAT0PAUAoFzoeVo8lacAAAAAAAWoPAUAKIGaeAc/V5XZuQEAoBxi10qLX1WeAgAAAAAUoPIUAKAEakK7tGUhq/MCANA2ZRm7Vlr8WjmfBAAAAACghFSeAgCUQHWuXdqykNV5AQBom7KMXSstfq2cTwIAAAAAUEIqTwEASqAmVKUtC1mdFwCAtinL2LXS4leVpwAAAAAABag8BQAoAT1PAQAoF3qeFk/lKQAAAADQYh5++OGwzz77hD59+oSqqqpw5513fulrJk2aFL7yla+Ezp07h3XXXTdcd911Sxxz2WWXhQEDBoQuXbqErbfeOkyePLnRY5M8BQAogerQLtMNAADKJXatbmT8Om/evDBo0KCU7CzG9OnTw957///27gXOqrJcHP8zgFxMwAy5qIh4ScULGqgHzVuHQDFTK/N4TPBGR49Uyi854UEhrENaeMk8ohZqeEwtlfprYUii+RNvKOU9TQ+gAl7+CkJykdm/z1rGxOhGZ4a1Zs9e8/2ez3uYtWbtNe8spvHh2c/7vEfEoYceGvPmzYuzzjorTjvttLjrrrvqrrn55ptj9OjRMX78+HjsscfS+w8dOjRee+21Rs3Nsn0AAAAAIHPLli2rd5xUiSbjgw4//PB0NNSUKVOib9++MXny5PR41113jfvvvz8uueSSNEGauPjii2PkyJFx8skn173mzjvvjKlTp8Z3vvOdBn8tZQwAABmoLdXkOgAAoFpi19q/x6+9e/eOrl271o1JkyZlMv85c+bE4MGD651LkqbJ+cTq1atj7ty59a5p06ZNerzumoZSeQoAAAAAZG7hwoXRpUuXuuNyVadNsXjx4ujRo0e9c8lxUun67rvvxltvvRVr164te82zzz7bqK8leQoAkIHaHHuTJvcGAIAs48s8++rX/v3eSeJ0/eRpNZI8BQAAAACqRs+ePWPJkiX1ziXHSaK2U6dO0bZt23SUuyZ5bWMoYwAAyEBtqU2uAwAAqiV2rc05fh00aFDMmjWr3rmZM2em5xPt27ePAQMG1LumtrY2PV53TUOJxAEAAACAilm+fHnMmzcvHYmXXnop/XjBggXp8dixY2P48OF1159++unx4osvxpgxY9Iepv/93/8dt9xyS5x99tl114wePTquueaauP766+OZZ56JM844I1asWBEnn3xyo+Zm2T4AQAbWRk068pDXfQEAaJ3yjF0Tjb33o48+Goceemi9xGdixIgRcd1118WiRYvqEqmJvn37xp133pkmSy+77LLYZptt4qc//WkMHTq07prjjjsuXn/99Tj//PPTDab22muvmDFjxoc2kfo4kqcAAAAAQMUccsghUSqVNvj5JIFa7jWPP/74R9531KhR6dgYkqcAABnIs7eTnqcAAGQdX+YZY9YWqGd/cb4TAAAAAIAMqTwFAMjA2hx7kyb3BgCALOPLfHueFofKUwAAAACAMlSeAgBkQM9TAACqhZ6nDafyFAAAAACgDJWnAAAZWFtqk4485HVfAABapzxj16LFr8X5TgAAAAAAMqTyFAAgA6WoidqcdixN7g0AANUQuxYtflV5CgAAAABQhspTAIAM6HkKAEC10PO04VSeAgAAAAAUtfK07ZvvRNs2qys9jUIpdWhf6SkU0r7DJ1d6CoW0erPi9FJpSeb99+hKTwGqSm2pJh153ZtiWfTN/aJth46VnkahrOi7ttJTKKTPzhxT6SkU0q6fXFzpKRTSNQN/XukpQNXIM3YtWvyq8hQAAAAAoAzJUwCADKyNNrmOxpg0aVLss88+0blz5+jevXscffTR8dxzz33ka6677rqoqampNzp2VBkJAFBEeceuawuUcizOdwIAQOree++NM888Mx588MGYOXNmrFmzJoYMGRIrVqz4yCfUpUuXWLRoUd2YP3++JwoAQKtWiJ6nAACtoefpsmXL6p3v0KFDOj5oxowZH6oqTSpQ586dGwcddNAGv05SbdqzZ8/M5g0AQMuk52nDqTwFAKgSvXv3jq5du9aNZHl+QyxdujT9c4sttvjI65YvXx59+vRJv85RRx0VTz31VCbzBgCAaqXyFAAgA7XRJh15WHffhQsXpkvr1ylXdfqh19bWxllnnRUHHHBA7L777hu8buedd46pU6fGnnvumSZbf/SjH8X++++fJlC32WabjL4TAACKHrsm8rx3c5M8BQCoEknidP3kaUMkvU+ffPLJuP/++z/yukGDBqVjnSRxuuuuu8ZVV10VF1xwQZPnDAAA1UzyFAAgA2tLNenIQ1PvO2rUqLjjjjvivvvua3T16CabbBJ77713vPDCC0362gAAtM7YNZHnvZtbcWpoAQBIlUqlNHF6++23xx/+8Ifo27dvo5/M2rVr44knnohevXp5qgAAtFoqTwEAWviOpY29b7JU/8Ybb4xf//rX0blz51i8eHF6PtlkqlOnTunHw4cPj6233rpu06mJEyfGP/3TP8WOO+4Yb7/9dvzwhz+M+fPnx2mnnZbDdwQAQFFj10Se925ukqcAAAVz5ZVXpn8ecsgh9c5fe+21cdJJJ6UfL1iwINq0+ccipLfeeitGjhyZJlo/+clPxoABA+KBBx6Ifv36NfPsAQCg5ZA8BQDIQKnUJmpLbXK7d+OuL33sNbNnz653fMkll6QDAIDiyzN2bUr82pIV5zsBAAAAAMiQylMAgAysjZp05CGv+wIA0DrlGbsWLX5VeQoAAAAAUIbKUwCADNSW8ttVNLk3AABUQ+xatPhV5SkAAAAAQBkqTwEAMlCb446lee6ECgBA65Nn7Fq0+LU43wkAAAAAQIZUngIAZKA2atKRh7zuCwBA65Rn7Fq0+FXlKQAAAABAGSpPAQAysLZUk4485HVfAABapzxj16LFrypPAQAAAADKUHkKANDCdywt0m6lAAAUO3YtWvxanO8EAAAAACBDKk8BALLasTSn3k5F2q0UAIBix65Fi19VngIAAAAAlKHyFAAgA6Xk3fuc3mFP7g0AAFnGl3lWh5YKFL+qPAUAAAAAKEPlKQBABpKeUbn1PM2xHxUAAK1PnrFr0eJXlacAAAAAAGWoPAUAyEBtqU068pDXfQEAaJ3yjF2LFr8W5zsBAAAAAMiQylMAgAzoeQoAQLXQ87ThVJ4CAAAAAJSh8hQAIAO1UZOOPOR1XwAAWqc8Y9eixa8qTwEAAAAAylB5CgCQAT1PAQCoFnqeNpzKUwAAAACAMlSeAgBkQOUpAADVQuVpw6k8BQAAAAAoQ+UpAEAGVJ4CAFAtVJ42nMpTAAAAAIAyVJ4CAGRA5SkAANVC5WnDqTwFAAAAAChD5SkAQAZKyTv4UZPbvQEAoBpi16LFrypPAQAAAABaWvJ00qRJsc8++0Tnzp2je/fucfTRR8dzzz1XySkBAGxU36i8Bi2D+BUAKIK8Y9faAsWvFU2e3nvvvXHmmWfGgw8+GDNnzow1a9bEkCFDYsWKFZWcFgAAlCV+BQBoXSra83TGjBn1jq+77rq0AnXu3Llx0EEHfej6VatWpWOdZcuWNcs8AQA+Tp7vsBfpnftqJ34FAIog7+rQ2gLFry2q5+nSpUvTP7fYYosNLpPq2rVr3ejdu3czzxAAAP5B/AoAUGwtJnlaW1sbZ511VhxwwAGx++67l71m7NixaYC6bixcuLDZ5wkAUI6eUa2P+BUAqFZ6nlbJsv31Jb1Pn3zyybj//vs3eE2HDh3SAQAAlSZ+BQAovhaRPB01alTccccdcd9998U222xT6ekAADSanqeti/gVAKhmep5WSfK0VCrFN77xjbj99ttj9uzZ0bdv30pOBwAAPpL4FQCgdWlX6aVON954Y/z617+Ozp07x+LFi9PzyWZQnTp1quTUAAAapVSqSUce8rovjSd+BQCKIM/YtWjxa0U3jLryyivTjZ8OOeSQ6NWrV924+eabKzktAAAoS/wKANC6VHzZPgBAEdRGTTryujctg/gVACiCPGPXosWvFa08BQAAAABoqSRPAQAy3LE0rwEAANUSu9Y2MX694oorYrvttouOHTvGfvvtFw8//PAGr12zZk1MnDgxdthhh/T6/v37x4wZM+pd884778RZZ50Vffr0SfdX2n///eORRx5p1JwkTwEAAACAirr55ptj9OjRMX78+HjsscfSZOjQoUPjtddeK3v9uHHj4qqrrorLL788nn766Tj99NPjmGOOiccff7zumtNOOy1mzpwZ06ZNiyeeeCKGDBkSgwcPjldeeaXB85I8BQDIcMfSvAYAAFRL7FpqQvx68cUXx8iRI+Pkk0+Ofv36xZQpU2LTTTeNqVOnlr0+SYiee+65MWzYsNh+++3jjDPOSD+ePHly+vl33303br311rjooovioIMOih133DEmTJiQ/plsAtpQkqcAAAAAQOaWLVtWb6xatarsdatXr465c+emVaHrtGnTJj2eM2dO2dck90qW668vWZp///33px+/9957sXbt2o+8piEkTwEAMtASe0YBAEAlYtfav8evvXv3jq5du9aNSZMmlZ3PG2+8kSY6e/ToUe98crx48eKyr0mW9CfVqs8//3zU1tamy/Nvu+22WLRoUfr5zp07x6BBg+KCCy6IV199Nb3/DTfckCZj113TEJKnAAAAAEDmFi5cGEuXLq0bY8eOzezel112Wey0006xyy67RPv27WPUqFHpkv+kYnX9pf2lUim23nrr6NChQ/z4xz+O448/vt41H0fyFAAgAy2tZxQAAFQqdi39PX7t0qVLvZEkMMvp1q1btG3bNpYsWVLvfHLcs2fPsq/ZcsstY/r06bFixYqYP39+PPvss7HZZpul/U/X2WGHHeLee++N5cuXp4nchx9+ONasWVPvmo8jeQoAAAAAVEz79u1jwIABMWvWrLpzyVL85DhZev9Rkp6mSWVp0uM02SDqqKOO+tA1n/jEJ6JXr17x1ltvxV133VX2mg1p18jvBQCAMko59iZVeQoAQNbxZZ599UtNuPfo0aNjxIgRMXDgwNh3333j0ksvTatKk6X4ieHDh6dJ0nV9Ux966KF45ZVXYq+99kr/nDBhQppwHTNmTN09k0Rpsmx/5513jhdeeCHOOeecdJn/uns2hOQpAAAAAFBRxx13XLz++utx/vnnp5tEJUnRGTNm1G0itWDBgnq9SleuXBnjxo2LF198MV2uP2zYsLTH6eabb153zbo+qy+//HJsscUW8eUvfzm+//3vxyabbNLgeUmeAgBkoJS+w57Po8zptgAAtFJ5xq6Jpt462fQpGeXMnj273vHBBx8cTz/99Efe76tf/Wo6NoaepwAAAAAAZag8BQDIQG3UpP+X170BAKAaYteixa8qTwEAAAAAylB5CgCQ0Y6iTdlVtKH3BgCALOPLPGPMUoHiV5WnAAAAAABlqDwFAMhAbakmanJ6hz25NwAAVEPsWrT4VeUpAAAAAEAZKk8BADJQKr0/8pDXfQEAaJ3yjF2LFr+qPAUAAAAAKEPlKQBAC9+xtEi7lQIAUOzYtWjxq8pTAAAAAIAyVJ4CAGRA5SkAANVC5WnDqTwFAAAAAChD5SkAQAZqSzVRk1Nvp+TeAABQDbFr0eJXlacAAAUzadKk2GeffaJz587RvXv3OProo+O555772Nf98pe/jF122SU6duwYe+yxR/z2t79tlvkCAEBLJXkKAJCBUinf0Rj33ntvnHnmmfHggw/GzJkzY82aNTFkyJBYsWLFBl/zwAMPxPHHHx+nnnpqPP7442nCNRlPPvnkxj8cAABaVexaamT82pJZtg8AUCWWLVtW77hDhw7p+KAZM2bUO77uuuvSCtS5c+fGQQcdVPbel112WRx22GFxzjnnpMcXXHBBmnj9yU9+ElOmTMn0+wAAgGqh8hQAIAPvv8Nek9N4/2v07t07unbtWjeS5fkNsXTp0vTPLbbYYoPXzJkzJwYPHlzv3NChQ9PzAAAUS76xa43KUwAAmt/ChQujS5cudcflqk4/qLa2Ns4666w44IADYvfdd9/gdYsXL44ePXrUO5ccJ+cBAKC1smwfACAD695lz8O6+yaJ0/WTpw2R9D5N+pbef//9ucwNAIDqk2fsmsjz3s1N8hQAoKBGjRoVd9xxR9x3332xzTbbfOS1PXv2jCVLltQ7lxwn5wEAoLXS8xQAIAOlnEej5lIqpYnT22+/Pf7whz9E3759P/Y1gwYNilmzZtU7l2wYlZwHAKBYSi0sfm3JVJ4CABRMslT/xhtvjF//+tfRuXPnur6lySZTnTp1Sj8ePnx4bL311nWbTn3rW9+Kgw8+OCZPnhxHHHFE3HTTTfHoo4/G1VdfXdHvBQAAKknlKQBABvLdrbRxPaOuvPLKWLp0aRxyyCHRq1evunHzzTfXXbNgwYJYtGhR3fH++++fJlyTZGn//v3jV7/6VUyfPv0jN5kCAKA65R27lvQ8BQCgpUqW7X+c2bNnf+jcsccemw4AAOB9lu0DAGQhz+ZORWoaBQBA5eXdmLQUhWHZPgAAAABAGSpPAQCykGdvpwL1jAIAoAXIuy9pqTjxq8pTAAAAAIAyVJ4CAGQg2aOpAfs0NfneAACQZXyZZ4xZKlD8qvIUAAAAAKAMlacAABko5dg3Ktd+VAAAtDp5xq5Fi18LkTyt/f/fjtqa9pWeRqHUtCvEj0aL0+7dT1V6CoW0opci+jzsevuEXO7b2j016H8qPYVCqX2nttJTgCbp+FYp2rYv0Hq2FmBVN/FAHjbv+G4u923tlq7pVOkpFNK5f/5SpadQSN/r/kSlp1Ao4tfqI0MGAJCF5N31vN5hL9A79wAAFDx2LVj86u1ZAAAAAIAyVJ4CALTwHUuLtFspAADFjl2LFr+qPAUAAAAAKEPlKQBAFpJ31/N6h71A79wDAFDw2LVg8avKUwAAAACAMlSeAgBkoFSqSUce8rovAACtU56xa9HiV5WnAAAAAABlqDwFAMhKgXo7AQBQcGLXBlF5CgAAAABQhspTAIAM6HkKAEC10PO04VSeAgAAAACUofIUACCrnlF59Y3SjwoAgKzjyzxjzFIUhspTAAAAAIAyVJ4CAGSi5u8jD3ndFwCA1inP2LVY8avKUwAAAACAMlSeAgBkQc9TAACqhZ6nDabyFAAAAACgDJWnAABZUHkKAEC1UHnaYCpPAQAAAADKUHkKAJCFUs37Iw953RcAgNYpz9i1YPGrylMAAAAAgDJUngIAZKBUen/kIa/7AgDQOuUZuxYtfs2k8nTZsmUxffr0eOaZZ7K4HQAA5Er8CgBAbsnTr371q/GTn/wk/fjdd9+NgQMHpuf23HPPuPXWW5tySwCAYuxYmtdgo4hfAQCaMXYttfLk6X333RcHHnhg+vHtt98epVIp3n777fjxj38c3/ve97KeIwAAbBTxKwAAzZY8Xbp0aWyxxRbpxzNmzIgvf/nLsemmm8YRRxwRzz//fJMmAgBQiB1L8xpsFPErAEAzxq6lmtadPO3du3fMmTMnVqxYkSZPhwwZkp5/6623omPHjlnPEQAANor4FQCApmjXlBedddZZccIJJ8Rmm20Wffr0iUMOOaRuOdQee+zRpIkAAFSzmtL7I697s3HErwAA9ePLPGPMmlIrT57++7//e+y7776xcOHC+PznPx9t2rxfwLr99tvreQoAQIsjfgUAoNmSp/fcc08ceuihMXDgwHrnk56nAACtUp67ihbonftKEb8CADRT7Fqw+LVJPU8PO+yw2GGHHdIq06T6FAAAWjLxKwAAzZY8feWVV2LUqFHxq1/9Kl2qP3To0Ljlllti9erVTZoEAEDVs1tpiyZ+BQBoxti1VNO6k6fdunWLs88+O+bNmxcPPfRQfPrTn077SG211VbxzW9+M/70pz9lP1MAAGgi8SsAAM2WPF3fZz7zmRg7dmxaibp8+fKYOnVqDBgwIA488MB46qmnNvb2AADV1Tcqr0FmxK8AQKuXd+xaKs4TbnLydM2aNemy/WHDhkWfPn3irrvuip/85CexZMmSeOGFF9Jzxx57bLazBQCAJhK/AgDQWO0a/YqI+MY3vhG/+MUvolQqxYknnhgXXXRR7L777nWf/8QnPhE/+tGP0mX8AACtQp7vsBfonftKEb8CAKwn7+rQUitPnj799NNx+eWXx5e+9KXo0KHDBvtK3XPPPRs7PwAA2GjiVwAAmi15OmvWrI+/cbt2cfDBBzfl9gAA1UflaYsmfgUAWI/K0+bZMCp5B3/GjBnxm9/8pt4AAICWSPwKANByXXHFFbHddttFx44dY7/99ouHH374I/vZT5w4MXbYYYf0+v79+6d5yvWtXbs2zjvvvOjbt2906tQpvfaCCy5IW5HmWnn64osvxjHHHBNPPPFE1NTU1H3B5ON1EwMAaFVKNe+PvO7NRhG/AgB8IL7MM8YsNf7eN998c4wePTqmTJmSJk4vvfTSGDp0aDz33HPRvXv3D10/bty4uOGGG+Kaa66JXXbZJd3MPslXPvDAA7H33nun11x44YVx5ZVXxvXXXx+77bZbPProo3HyySdH165d45vf/GZ+laff+ta30ozta6+9Fptuumk89dRTcd9998XAgQNj9uzZTbklAADkRvwKANCyXXzxxTFy5Mg0udmvX780iZrkHadOnVr2+mnTpsW5554bw4YNi+233z7OOOOM9OPJkyfXXZMkUo866qg44ogj0orWr3zlKzFkyJCPrGjNJHk6Z86ctCw22RSqTZs26fjsZz8bkyZNanDWFgCgSGpK+Q42jvgVAKD5Yteav8evy5YtqzdWrVpV9q9h9erVMXfu3Bg8eHDduSTfmBwncVw5yb2S5frrS5bm33///XXH+++/f9r7/i9/+Ut6/Kc//Sn9/OGHH55v8jRZlt+5c+f04ySB+uqrr6Yf9+nTJy2lBQCAlkT8CgDQ/Hr37p0ukV83ksLLct544400XuvRo0e988nx4sWLy74mWdKfVKs+//zzUVtbGzNnzozbbrstFi1aVHfNd77znfiXf/mXdFn/Jptski7nP+uss+KEE07It+fp7rvvnmZqk6X7SQ+Ciy66KNq3bx9XX311WiYLANDq5LljqcrTjSZ+BQD4QHyZZ4xZev+PhQsXRpcuXepOd+jQIbMvcdlll6XL/JPEaLIPU7IZVLLkf/1l/rfcckv8z//8T9x4441pz9N58+alydOtttoqRowYkV/yNGnIumLFivTjZPn+F77whTjwwAPjU5/6VNrcFQAAWhLxKwBA8+vSpUu95OmGJCvb27ZtG0uWLKl3Pjnu2bNn2ddsueWWMX369Fi5cmW8+eabaUI0qTRdv7DznHPOqas+Teyxxx4xf/78tAK2ocnTJi3bT8piv/SlL6Uf77jjjvHss8+m5bXJBlKf+9znGnyfZLerPffcs+5BDho0KH73u981ZUoAALBB4lcAgJarffv2MWDAgLQ/6TrJUvzkOMkXfpSk7+nWW28d7733Xtx6663pBlHr/O1vf0t7p64vSdIm926oJlWelrPFFls0+jXbbLNN/OAHP4iddtopSqVSXH/99ek3+Pjjj6eltAAAkBfxKwBAyzF69Oi0GnTgwIGx7777xqWXXpqufE+W4ieGDx+eJknX9U196KGH4pVXXom99tor/XPChAlpUnTMmDF19zzyyCPj+9//fmy77bZprjHJOSZ9Uk855ZTsk6frKk0bImnO2hDJN7C+5JtJqlEffPBByVMAoKrU/H3X0rzuTeOJXwEAmj92bWr8etxxx8Xrr78e559/frpJVJIUnTFjRt0mUgsWLKhXRZos109aM7344oux2WabxbBhw2LatGmx+eab111z+eWXx3nnnRf//u//nq6YT5b2/9u//Vv6NTJPniY7YuUp2VHrl7/8ZZpR3lA57qpVq9KxzrJly3KdEwAA1Uv8CgBQXUaNGpWOcmbPnl3v+OCDD46nn376I+/XuXPntII1GU3V4OTptddeG3l44okn0mRpki1OssS333579OvXr+y1SVnud7/73VzmAQCwUUo174885HXfghO/AgBUIHYtWPzapA2jEkkT1rvvvjuuuuqqeOedd9Jzr776aixfvrxR99l5551j3rx5aZ+CM844I+1tsKGs8dixY2Pp0qV1Y+HChU2dPgAArYz4FQCAxmrShlHz58+Pww47LO01kCyj//znP5+WwV544YXp8ZQpUxq1m9aOO+6YfpzsqvXII4/EZZddliZlP6hDhw7pAABocZKeUXn1jcqxH1VrIX4FAGim2LVg8WuTKk+/9a1vpTtfvfXWW9GpU6e688ccc0zMmjVroyaU7Iq1fl9TAADYWOJXAACarfL0j3/8YzzwwANp1ej6tttuu3jllVcafJ9kGf7hhx8e2267bbr0/8Ybb0ybv951111NmRYAQOWoPG3RxK8AAOtReZpv8jSpDl27du2Hzr/88svp8v2Geu2112L48OGxaNGidDfUPffcM02cJm0AAAAgK+JXAACaLXk6ZMiQuPTSS+Pqq69Oj2tqatKNosaPHx/Dhg1r8H1+9rOfNeXLAwC0ODWl90de92bjiF8BAOrHl3nGmDWlVp48nTx5cgwdOjT69esXK1eujH/913+N559/Prp16xa/+MUvsp8lAABsBPErAADNljzdZptt4k9/+lPcdNNN8ec//zmtOj311FPjhBNOqLeBFABAq6HnaYsmfgUAWI+ep/kmT9MXtmsXX/va15r6cgAAaFbiVwAAckue/uY3v2nwTb/4xS82eiIAAFVN5WmLI34FANgAlafZJ0+PPvroesfJJlGlUulD5xJr165t+AwAACAH4lcAADZWm4ZeWFtbWzd+//vfx1577RW/+93v4u23305H8vFnPvOZmDFjxkZPCgCgWncszWvQeOJXAIDKxK41rb3n6VlnnRVTpkyJz372s3Xnhg4dGptuuml8/etfj2eeeSbLOQIAwEYRvwIAkGvl6fr++te/xuabb/6h8127do3//d//bdJEAACqWqkm39FI9913Xxx55JGx1VZbpa2Vpk+f/pHXz549O73ug2Px4sVRBOJXAIBmjF1LjY9fC5U83WeffWL06NGxZMmSunPJx+ecc07su+++Wc4PAIAmWLFiRfTv3z+uuOKKRr3uueeei0WLFtWN7t27F+L5i18BAGi2ZftTp06NY445Jrbddtvo3bt3em7hwoWx0047fWxVAwBAIeW5Y+nf77ts2bJ6pzt06JCOcg4//PB0NFaSLC23wqjaiV8BAJopdk209p6nO+64Y/z5z3+OmTNnxrPPPpue23XXXWPw4MHp8i4AALK37k3rdcaPHx8TJkzI9Gskm4KuWrUqdt999/TeBxxwQBSB+BUAgGZLniaSJOmQIUPSsSF77LFH/Pa3v/1QoA8AUDR57iq67r7JSp8uXbrUnd9Q1WlT9OrVK90QdODAgWny9Kc//Wkccsgh8dBDD8VnPvOZKALxKwBA/rFrIs97V03ytCGSzaPWrFmT55cAAGg1ksTp+snTLO28887pWGf//fdPN1m65JJLYtq0adFaiF8BANjoDaMAANhA36i8RgUkG4G+8MILlfniAABUb+xaKs5fnuQpAABlzZs3L13ODwAArVWuy/YBAFqNPPtGNeG+y5cvr1c1+tJLL6XJ0C222CK23XbbGDt2bLzyyivx85//PP38pZdeGn379o3ddtstVq5cmfY8/cMf/hC///3vs/xOAABoCXLueRoFqjyVPAUAKKBHH300Dj300Lrj0aNHp3+OGDEirrvuuli0aFEsWLCg7vOrV6+O//N//k+aUN10001jzz33jLvvvrvePQAAoLWRPAUAyEKevZ2acN9DDjkkSqUNvzBJoK5vzJgx6QAAoBXIuy9pKQqjycnTWbNmpeO1116L2traep+bOnVq+udVV10VPXr02PhZAgDARhK/AgDQLMnT7373uzFx4sQYOHBguolATU1N2ev+9V//tSm3BwCoPi2s8pT6xK8AAB+IL1We5pc8nTJlSrrU68QTT2zKywEAoFmJXwEAaLbkabKhwP7779+kLwgAUEQ1Oe5YmutOqK2E+BUAoHli16LFr22a8qLTTjstbrzxxuxnAwAAORC/AgDQbJWnK1eujKuvvjruvvvu2HPPPWOTTTap9/mLL764SZMBAIA8iF8BAGi25Omf//zn2GuvvdKPn3zyyXqf29DmUQAAUCniVwAAmi15es899zTpiwEAFFaeO5YWqGdUpYhfAQCaKXYtWPzapJ6nAAAAAABF16TKUwAAmm/H0iLtVgoAQLFj16LFrypPAQAAAADKUHkKAJCVAr3DDgBAwYldG0TlKQAAAABAGSpPAQBa+o6lqgIAAMg6vswzxixFYag8BQAAAAAoQ+UpAEAL37G0SLuVAgBQ7Ni1aPGrylMAAAAAgDJUngIAZEHPUwAAqoWepw2m8hQAAAAAoAyVpwAAGdDzFACAaqHnacOpPAUAAAAAKEPlKQBAFvQ8BQCgWuh52mAqTwEAAAAAylB5CgCQBZWnAABUC5WnDabyFAAAAACgDJWnAAAtfMfSvO4LAEDrlGfsWrT4VfKU8tau9WRysHJzxd55aLsyl9u2esuXfKLVP4M89P3/RnquGap9N/kFMN4zpeos3TGiTcdKz6JYStu+W+kpFNJm7VZVegqF1K6Nf2/lYcmqLrnct7X7+bJulZ5Coby7/L2IeLHS06ARJE8BALKg5ykAANVCz9MGUwYHAAAAAFCGylMAgCyoPAUAoFqoPG0wlacAAAAAAGWoPAUAaOE7lhZpt1IAAIoduxYtflV5CgAAAABQhspTAIAs6HkKAEC10PO0wVSeAgAAAACUofIUACADep4CAFAt9DxtOJWnAAAAAABlqDwFAMiCnqcAAFQLPU8bTOUpAAAAAEAZKk8BALKg8hQAgGqh8rTBVJ4CAAAAAJSh8hQAIAM1fx95yOu+AAC0TnnGrkWLX1WeAgAAAACUofIUACALep4CAFAt9DxtMJWnAAAAAABlqDwFAMhATen9kYe87gsAQOuUZ+xatPhV5SkAAAAAQBmSpwAAWfaNymsAAEC1xK6lpk3riiuuiO222y46duwY++23Xzz88MMbvHbNmjUxceLE2GGHHdLr+/fvHzNmzKh3TXKvmpqaD40zzzyzwXOSPAUAAAAAKurmm2+O0aNHx/jx4+Oxxx5Lk6FDhw6N1157rez148aNi6uuuiouv/zyePrpp+P000+PY445Jh5//PG6ax555JFYtGhR3Zg5c2Z6/thjj23wvCRPAQCy0oLetQcAgIrErqWmPfeLL744Ro4cGSeffHL069cvpkyZEptuumlMnTq17PXTpk2Lc889N4YNGxbbb799nHHGGenHkydPrrtmyy23jJ49e9aNO+64I61UPfjggxs8L8lTAAAAACBzy5YtqzdWrVpV9rrVq1fH3LlzY/DgwXXn2rRpkx7PmTOn7GuSeyXL9dfXqVOnuP/++zf4NW644YY45ZRT0qX7DSV5CgCQ4Y6leQ0AAKiW2LXm7/Fr7969o2vXrnVj0qRJZefzxhtvxNq1a6NHjx71zifHixcvLvuaZEl/Uq36/PPPR21tbbok/7bbbkuX55czffr0ePvtt+Okk05q1LNq16irAQAAAAAaYOHChdGlS5e64w4dOkRWLrvssnSZ/y677JJWkibL8ZMl/xta5v+zn/0sDj/88Nhqq60a9XVUngIAZKEF7lYKAAAViV1L73+ZJHG6/thQ8rRbt27Rtm3bWLJkSb3zyXHSq7ScpJ9pUk26YsWKmD9/fjz77LOx2Wabpf1PPyj5/N133x2nnXZao38gJE8BAAAAgIpp3759DBgwIGbNmlV3LlmKnxwPGjToI1+b9D3deuut47333otbb701jjrqqA9dc+2110b37t3jiCOOaPTcLNsHAMhAnr1J9TwFACDr+DLPGLOmCfcePXp0jBgxIgYOHBj77rtvXHrppWlVabIUPzF8+PA0Sbqub+pDDz0Ur7zySuy1117pnxMmTEgTrmPGjKl33+RckjxN7t2uXeNToZKnAAAAAEBFHXfccfH666/H+eefn24SlSRFZ8yYUbeJ1IIFC6JNm38sol+5cmWMGzcuXnzxxXS5/rBhw2LatGmx+eab17tvslw/ee0pp5zSpHlJngIAZCHP3qR6ngIAkHV8mWeMWWray0aNGpWOcmbPnl3v+OCDD46nn376Y+85ZMiQKJWa/s3qeQoAAAAAUIbKUwCADOh5CgBAtWiJPU9bKpWnAAAAAABlqDwFAMiCnqcAAFSLFtrztCVSeQoAAAAAUIbKUwCALKg8BQCgWqg8bTCVpwAAAAAAZag8BQBo4TuWFmm3UgAAih27Fi1+VXkKAAAAAFCGylMAgCzoeQoAQLXQ87TBVJ4CAAAAAJSh8hQAIAM1pVI68pDXfQEAaJ3yjF2LFr+qPAUAAAAAKEPlKQBAFvQ8BQCgWuh52mAqTwEACui+++6LI488MrbaaquoqamJ6dOnf+xrZs+eHZ/5zGeiQ4cOseOOO8Z1113XLHMFAICWSvIUACADNaV8R2OtWLEi+vfvH1dccUWDrn/ppZfiiCOOiEMPPTTmzZsXZ511Vpx22mlx1113Nf6LAwDQqmPXmuK0PK1s8nTChAlpJcT6Y5dddqnklAAACuHwww+P733ve3HMMcc06PopU6ZE3759Y/LkybHrrrvGqFGj4itf+Upccskluc+1mohfAQBal4r3PN1tt93i7rvvrjtu167iUwIAaJE9T5ctW1bvdLK8PhlZmDNnTgwePLjeuaFDh6YVqNQnfgUAqp6epw1W8Uxlkizt2bNng65dtWpVOtb54D8gAACKrHfv3vWOx48fn1ZCZmHx4sXRo0ePeueS4yTeevfdd6NTp06ZfJ0iEL8CALQeFe95+vzzz6cbGWy//fZxwgknxIIFCzZ47aRJk6Jr165144P/gAAAqJTm6Bm1cOHCWLp0ad0YO3asv/AKEL8CANVOz9MqSZ7ut99+6S6uM2bMiCuvvDLdqODAAw+Md955p+z1yT8Q1v8HQ/IPCACA1qJLly71RlZL9hPJSqAlS5bUO5ccJ19H1ek/iF8BAFqXdpXeyGCdPffcMw1G+/TpE7fcckuceuqpH7o+y75eAADV1vM0T4MGDYrf/va39c7NnDkzPc8/iF8BgELQ87R6lu2vb/PNN49Pf/rT8cILL1R6KgAAVW358uUxb968dCSSFT7Jx+taJCUreoYPH153/emnnx4vvvhijBkzJp599tn47//+7/QN7bPPPrti30M1EL8CABRbm5YW5P/1r3+NXr16VXoqAAAtrudpYzz66KOx9957pyMxevTo9OPzzz8/PV60aFG9XvN9+/aNO++8M6027d+/f0yePDl++tOfxtChQ/0kfATxKwBQjfQ8rZJl+9/+9rfjyCOPTJfqv/rqq+mOsW3bto3jjz++ktMCAKh6hxxySJRKG866Jn3ny73m8ccfz3lm1U38CgDQulQ0efryyy+nidI333wzttxyy/jsZz8bDz74YPoxAEBVqfKepzSM+BUAKAQ9T6sjeXrTTTdV8ssDAECjiF8BAFqXiiZPAQCKpCm9SQEAoBLErlW4YRQAAAAAQEuh8hQAIAvJ5kwfsUHTRt8bAACyjC/zjDFLxYlfVZ4CAAAAAJSh8hQAIKOeUXn1jdKPCgCArOPLPGPMmuIUnqo8BQAAAAAoR+UpAEAWknfX83qHvUDv3AMAUPDYtWDxq56nAAAAAABlqDwFAMhATe37Iw953RcAgNYpz9i1aPGrylMAAAAAgDJUngIAZEHPUwAAqoWepw2m8hQAAAAAoAyVpwAAGagpvT/ykNd9AQBonfKMXYsWv6o8BQAAAAAoQ+UpAEAWSqX3Rx7yui8AAK1TnrFrweJXlacAAAAAAGWoPAUAyICepwAAVAs9TxtO5SkAAAAAQBkqTwEAspC0dcqrtVNxWkYBAFD02LVg8avKUwAAAACAMlSeAgBkQM9TAACqhZ6nDafyFAAAAACgDJWnAABZKJXeH3nI674AALROecauBYtfVZ4CAAAAAJSh8hQAIAN6ngIAUC30PG04lacAAAAAAGWoPAUAyELS1imv1k7FaRkFAEDRY9eCxa8qTwEAAAAAylB5CgCQAT1PAQCoFnqeNpzKUwAAAACAMlSeAgBkobb0/shDXvcFAKB1yjN2LVj8qvIUAAAAAKAMlacAAC19x9LivHEPAEDRY9eCxa8qTwEAAAAAylB5CgCQgZq/71qa170BAKAaYteixa8qTwEAAAAAylB5CgCQhVLp/ZGHvO4LAEDrlGfsWrD4VeUpAAAAAEAZKk8BADKQ9IzKredpcd64BwCg4LFr0eJXlacAAAAAAGWoPAUAyELy7npe77AX6J17AAAKHrsWLH5VeQoAAAAAUIbKUwCADNSUSunIQ173BQCgdcozdi1a/FqI5GntO8ujtmaTSk+jUGo2aV/pKRRS15dWV3oKhdT+zb9VegqF9N6mn6z0FAppRZ/3Kj2FYllbU+kZQJO8121NtOnU1tPL0BadxQN5qA2/Z3N5riWLQPPQt9OSXO7b2nVv906lp1Aof2u7ttJToDUmTwEAKq727yOvewMAQJbxZZ4xZm0Uhre7AAAAAADKkDwFAMiwb1ReAwAAqiV2rWli/HrFFVfEdtttFx07doz99tsvHn744Q1eu2bNmpg4cWLssMMO6fX9+/ePGTNmfOi6V155Jb72ta/Fpz71qejUqVPsscce8eijjzZ4TpKnAAAAAEBF3XzzzTF69OgYP358PPbYY2kydOjQofHaa6+VvX7cuHFx1VVXxeWXXx5PP/10nH766XHMMcfE448/XnfNW2+9FQcccEBssskm8bvf/S69bvLkyfHJTzZ8jw89TwEAspC8uZ5XgajCUwAAso4v84wxS+//sWzZsnqnO3TokI5yLr744hg5cmScfPLJ6fGUKVPizjvvjKlTp8Z3vvOdD10/bdq0+M///M8YNmxYenzGGWfE3XffnSZHb7jhhvTchRdeGL17945rr7227nV9+/Zt1Lei8hQAAAAAyFzv3r2ja9eudWPSpEllr1u9enXMnTs3Bg8eXHeuTZs26fGcOXPKvmbVqlXpcv31Jcvy77///rrj3/zmNzFw4MA49thjo3v37rH33nvHNddc06jvQeUpAEAWkr5OefUm1fMUAICs48s8Y8zS+/deuHBhdOnSpe70hqpO33jjjVi7dm306NGj3vnk+Nlnny37mmRJf1KtetBBB6V9T2fNmhW33XZbep91XnzxxbjyyivTdgDnnntuPPLII/HNb34z2rdvHyNGjGjQtyJ5CgAAAABkrkuXLvWSp1m67LLL0mX+u+yyS9TU1KQJ1GTJf7LMf53a2tq08vS//uu/0uOk8vTJJ59MWwI0NHlq2T4AQAZqSvkOAAColti1ppHxa7du3aJt27axZMmSeueT4549e5Z9zZZbbhnTp0+PFStWxPz589MK1c022yy23377umt69eoV/fr1q/e6XXfdNRYsWNDguUmeAgAAAAAV0759+xgwYEC69H79qtHkeNCgQR/52qTv6dZbbx3vvfde3HrrrXHUUUfVfe6AAw6I5557rt71f/nLX6JPnz4Nnptl+wAAWdDzFACAatFMPU8bI+lLmiylT5bZ77vvvnHppZemVaXJUvzE8OHD0yTpuk2nHnrooXjllVdir732Sv+cMGFCmnAdM2ZM3T3PPvvs2H///dNl+1/96lfj4YcfjquvvjodDSV5CgAAAABU1HHHHRevv/56nH/++bF48eI0KTpjxoy6TaSSpfZt2vxjEf3KlStj3Lhx6aZQyXL9YcOGxbRp02LzzTevu2afffaJ22+/PcaOHRsTJ06Mvn37pknZE044ocHzkjwFAMhATe37Iw953RcAgNYpz9g10dR7jxo1Kh3lzJ49u97xwQcfHE8//fTH3vMLX/hCOppKz1MAAAAAgDJUngIAZEHPUwAAqkUL7HnaUqk8BQAAAAAoQ+UpAEAWkjfX83qDvThv3AMAUPTYtWDxq8pTAAAAAIAyVJ4CAGSgplRKRx7yui8AAK1TnrFr0eJXlacAAAAAAGWoPAUAaOk7lhbonXsAAAoeuxYsflV5CgAAAABQhspTAIAsJG+u1+b0KIvzxj0AAEWPXQsWv6o8BQAAAAAoQ+UpAEAL37G0SLuVAgBQ7Ni1aPGrylMAAAAAgDIkTwEAslBab9fSzEfTpnTFFVfEdtttFx07doz99tsvHn744Q1ee91110VNTU29kbwOAIACyjV2Lel5CgBAy3bzzTfH6NGjY/z48fHYY49F//79Y+jQofHaa69t8DVdunSJRYsW1Y358+c365wBAKClUXkKAJCFXN+5b3zp6cUXXxwjR46Mk08+Ofr16xdTpkyJTTfdNKZOnbrB1yTVpj179qwbPXr02MiHAgBAq4xdS3qeAgDQzJYtW1ZvrFq1qux1q1evjrlz58bgwYPrzrVp0yY9njNnzgbvv3z58ujTp0/07t07jjrqqHjqqady+T4AAKBaqDwFAMhCbc4jIk1qdu3atW5MmjSp7FTeeOONWLt27YcqR5PjxYsXl33NzjvvnFal/vrXv44bbrghamtrY//994+XX37ZzwcAQNHUNk/8WgTtKj0BAAAaZuHChWlf0nU6dOiQ2aMbNGhQOtZJEqe77rprXHXVVXHBBRf4KwIAoFWSPAUAyEBNqZSOPKy7b5I4XT95uiHdunWLtm3bxpIlS+qdT46TXqYNsckmm8Tee+8dL7zwQhNnDQBAa4xdE3neu7lZtg8AUDDt27ePAQMGxKxZs+rOJcvwk+P1q0s/SrLs/4knnohevXrlOFMAAGjZVJ4CAGQhz11Fm3Df0aNHx4gRI2LgwIGx7777xqWXXhorVqyIk08+Of388OHDY+utt67rmzpx4sT4p3/6p9hxxx3j7bffjh/+8Icxf/78OO200zL/dgAAKHDsmihQ5ankKQBAAR133HHx+uuvx/nnn59uErXXXnvFjBkz6jaRWrBgQbRp849FSG+99VaMHDkyvfaTn/xkWrn6wAMPRL9+/Sr4XQAAQGVJngIAFLDyNDFq1Kh0lDN79ux6x5dcckk6AABoBVSeNpiepwAAAAAAZag8BQAoaOUpAABsML7U87RBVJ4CAAAAAJSh8hQAIAu1EVGT470BAKAaYteCxa8qTwEAAAAAylB5CgCQgZpSKR15yOu+AAC0TnnGrkWLX1WeAgAAAACUofIUAKCl71haoHfuAQAoeOxasPhV5SkAAAAAQBkqTwEAslBbSpo75XdvAACohti1YPFrRStPt9tuu6ipqfnQOPPMMys5LQAAKEv8CgDQulS08vSRRx6JtWvX1h0/+eST8fnPfz6OPfbYSk4LAKDx9DxtFcSvAEAh6HlaHcnTLbfcst7xD37wg9hhhx3i4IMPrticAABgQ8SvAACtS4vpebp69eq44YYbYvTo0enS/XJWrVqVjnWWLVvWjDMEAPgoee5YWpyeUUUifgUAqleesWux4teK9jxd3/Tp0+Ptt9+Ok046aYPXTJo0Kbp27Vo3evfu3axzBACAdcSvAADF12KSpz/72c/i8MMPj6222mqD14wdOzaWLl1aNxYuXNiscwQA+Ni+UXkNWhzxKwBQtfKOXUvFiV9bxLL9+fPnx9133x233XbbR17XoUOHdAAAQCWJXwEAWocWkTy99tpro3v37nHEEUdUeioAAE1Tm7y7Xsrx3rQk4lcAoKrlGbsWLH6t+LL92traNPgcMWJEtGvXInK5AACwQeJXAIDWo+LZymS5/oIFC+KUU06p9FQAAJquVPv+yENe96VJxK8AQNXLM3YtWPxa8eTpkCFDolSgJrIAABSb+BUAoPWoePIUAKAQ8txV1BvNAABkHV/mGWOWilMoWfGepwAAAAAALZHKUwCAlr5jaYF2KwUAoOCxa8HiV5WnAAAAAABlqDwFAMiCnqcAAFQLPU8bTOUpAAAAAEAZKk8BALKQto3KqbdTcVpGAQBQ9Ni1YPGrylMAAAAAgDJUngIAZEHPUwAAqoWepw2m8hQAAAAAoAyVpwAAWaitTf5fjvcGAIAs48scY8za4sSvKk8BAAAAAMpQeQoAkAU9TwEAqBZ6njaYylMAAAAAgDJUngIAZEHlKQAA1ULlaYOpPAUAAAAAKEPlKQBAFmpLyVv4Od4bAACyjC9zjDFrixO/qjwFAAAAAChD5SkAQAZKpdp05CGv+wIA0DrlGbsWLX5VeQoAAAAAUIbKUwCArHYszau3U3JvAADIMr7Msy9pqTjxq8pTAAAAAIAyVJ4CAGT27rrKUwAAqkCesWtC5SkAAAAAQLGpPAUAyEJtbURNTruKFmi3UgAACh67Fix+1fMUAAAAAKAMlacAAFnQ8xQAgGqh52mDqTwFAAAAACruiiuuiO222y46duwY++23Xzz88MMbvHbNmjUxceLE2GGHHdLr+/fvHzNmzKh3zYQJE6Kmpqbe2GWXXRo1J5WnAAAZKNXWRimnvlGlAvWMAgCg2LFrU+PXm2++OUaPHh1TpkxJE6eXXnppDB06NJ577rno3r37h64fN25c3HDDDXHNNdekCdG77rorjjnmmHjggQdi7733rrtut912i7vvvrvuuF27xqVDVZ4CAAAAAJlbtmxZvbFq1aoNXnvxxRfHyJEj4+STT45+/fqlSdRNN900pk6dWvb6adOmxbnnnhvDhg2L7bffPs4444z048mTJ9e7LkmW9uzZs25069atUd+D5CkAQFZ9o/IcAABQLbFr6f34tXfv3tG1a9e6MWnSpLLTWb16dcydOzcGDx5cd65Nmzbp8Zw5c8q+JknEJsv119epU6e4//776517/vnnY6uttkoTrCeccEIsWLCgUY/Ksn0AAAAAIHMLFy6MLl261B136NCh7HVvvPFGrF27Nnr06FHvfHL87LPPln1NsqQ/qVY96KCD0r6ns2bNittuuy29zzrJ8v/rrrsudt5551i0aFF897vfjQMPPDCefPLJ6Ny5c4O+B8lTAIAs1JYianKqEFV5CgBAtcSu68WvSeJ0/eRpli677LJ0mX/S7zTZCCpJoCZL/tdf5n/44YfXfbznnnumydQ+ffrELbfcEqeeemqDvo5l+wAAAABAxXTr1i3atm0bS5YsqXc+OU76lJaz5ZZbxvTp02PFihUxf/78tEJ1s802S5fnb8jmm28en/70p+OFF15o8NwkTwEAspD2dqrNaeh5CgBAtcSutY2OX9u3bx8DBgxIl96vU1tbmx4PGjToI1+b9D3deuut47333otbb701jjrqqA1eu3z58vjrX/8avXr1avDcJE8BAAAAgIoaPXp0XHPNNXH99dfHM888E2eccUZaVZosxU8MHz48xo4dW3f9Qw89lPY4ffHFF+OPf/xjHHbYYWnCdcyYMXXXfPvb34577703/vd//zceeOCBOOaYY9IK1+OPP77B89LzFAAgA6XaUpRy6htVUnkKAECVxK5NjV+PO+64eP311+P888+PxYsXx1577RUzZsyo20RqwYIF0abNP+pAV65cGePGjUuTp8ly/WHDhsW0adPSpfnrvPzyy2mi9M0330yX+X/2s5+NBx98MP24oSRPAQAAAICKGzVqVDrKmT17dr3jgw8+OJ5++umPvN9NN9200XOSPAUAyELS2ymSkde9AQAgy/gyxxizVJz4Vc9TAAAAAIAyVJ4CAGRAz1MAAKpFS+x52lKpPAUAAAAAKEPlKQBAFvQ8BQCgWuh52jqSp+tKgN+LNRHFqQZuEWpKNZWeQiG9997KSk+hkNqsXVXpKRTS2lV+XvNQ++57udy3tapdubLFLAvKMx5J700hrPtZrX3X79isrf2beCAPazqszuW+rV2ppjgbqbQkK/33Mhd/W7s2nxu3Un9bvrZFxK9559LeK9D/HmtKlf7b2ggvv/xy9O7du9LTAAAqbOHChbHNNttU5GuvXLky+vbtG4sXL8716/Ts2TNeeuml6NixY65fh3yJXwGASsavzRW7Fil+rerkaW1tbbz66qvRuXPnqKlp2ZWSy5YtSxO9yf84unTpUunpFIbn6rlWEz+vnms1qZaf1ySMeeedd2KrrbaKNm0q18o9CUJXr863Oqt9+/ZVH3gifqV6fr9WG8/Vc60WflY915YQvzZH7Fqk+LWql+0nP2SVqjJpqiRAEiR5rtXCz6vnWk38vLbe59q1a9dKTyENCosQGJI/8SvV9Pu1Gnmunmu18LPaup9rpeNXsWvjVK5EAwAAAACgBZM8BQAAAAAoQ/K0mXTo0CHGjx+f/onn2tL5efVcq4mfV88V8HugmvjvludaTfy8eqbVws8qearqDaMAAAAAAPKi8hQAAAAAoAzJUwAAAACAMiRPAQAAAADKkDwFAAAAAChD8jRnV155Zey5557RpUuXdAwaNCh+97vf5f1lC2/ChAlRU1NTb+yyyy6VnlbVW7t2bZx33nnRt2/f6NSpU+ywww5xwQUXhH3lGue+++6LI488Mrbaaqv0Z3P69On1Pp88z/PPPz969eqVPufBgwfH888/n+nfZWt6pmvWrIn/+I//iD322CM+8YlPpNcMHz48Xn311YrOuQg/qyeddNKHftcedthhFZsv0DzEr/kQv2ZP7JoNsWs+xK/N/1wT4lfyIHmas2222SZ+8IMfxNy5c+PRRx+Nz33uc3HUUUfFU089lfeXLrzddtstFi1aVDfuv//+Sk+p6l144YXpP5h+8pOfxDPPPJMeX3TRRXH55ZdXempVZcWKFdG/f/+44ooryn4+eaY//vGPY8qUKfHQQw+lCb+hQ4fGypUrm32uRXimf/vb3+Kxxx5LE//Jn7fddls899xz8cUvfrEicy3Sz2oiSZau/7v2F7/4RbPOEWh+4tf8iF+zJXbNhtg1H+LX5n+u64hfyVq7zO9IPck7Iuv7/ve/nyanHnzwwTR4ounatWsXPXv29Agz9MADD6TJ/SOOOCI93m677dJEycMPP+w5N8Lhhx+ejnKSqtNLL700xo0blz7rxM9//vPo0aNH+q7pv/zLv3jWjXymXbt2jZkzZ9Y7l7wBsO+++8aCBQti22239Uyb8LO6TocOHfyuhVZG/Jof8Wu2xK7ZELvmQ/za/M91HfErWVN52szLSm666ab0nZJk+T4bJ1nmnJTqb7/99nHCCSekSRI2zv777x+zZs2Kv/zlL+nxn/70p7Si9+P+40TDvfTSS7F48eJ0qf76yb/99tsv5syZ41FmZOnSpekyns0339wz3UizZ8+O7t27x8477xxnnHFGvPnmm54ptCLi12yJX7Mlds2f2LX5iF+zI34laypPm8ETTzyRJkuTJbmbbbZZ3H777dGvX7/m+NKFlSSarrvuuvQf88ky0u9+97tx4IEHxpNPPhmdO3eu9PSq1ne+851YtmxZ2j+2bdu26T+YkmrpJDlNNpLEaSKpNF1fcrzuc2yc5Hdt0gP1+OOPT3tN03TJkqcvfelLaR/kv/71r3Huueemb6Ykif7kdwRQXOLX7Ilfsyd2zZ/YtXmIX7MjfiUPkqfNIEnwzZs3L30n6Ve/+lWMGDEi7r33XgnUjbB+JWSyIVcSjPbp0yduueWWOPXUU7P4a2uVkuf3P//zP3HjjTembSWSn9uzzjorrfBNfm6hpUs2j/rqV7+atkdIWqSwcdZvI5FsyJX8vk02kkvezf/nf/5njxcKTPyaPfFr9sSuFIH4NVviV/Jg2X4zaN++fey4444xYMCAmDRpUtrc+LLLLmuOL91qJEtzP/3pT8cLL7xQ6alUtXPOOSd9Bz/5D06SKDnxxBPj7LPPTn9uyca6Pr1Lliypdz451sM3m8Bz/vz5aQ9UVafZS9qkdOvWze9aaAXEr/kTv248sWv+xK75Er/mT/xKFiRPK6C2tjZWrVpViS9dWMuXL0+XlPbq1avSU6lqya7lbdrU/7WQLM1NfmbJRrL8OQlCk96y6yStEh566CG9kDMIPJNecnfffXd86lOfyuKviw94+eWX056nftdC6yN+zZ74deOJXfMnds2P+LV5iF/JgmX7ORs7dmy6RCfZ7fmdd95Jl0Mnyx3vuuuuvL90oX37299Od4JNluq/+uqrMX78+DTJl/Q4pOmSZ5r0OE1+XpNl+48//nhcfPHFccopp3isjfzH0PpV0Emj/aQFwhZbbJE+26QVwve+973Yaaed0oD0vPPOS1sjHH300Z5zE55pksj7yle+Eo899ljccccdaa/edf25ks8n1VM0/rkmI+kn/eUvfzlN+CdvUI0ZMyZdSTF06FCPFApM/JoP8Wv2xK7ZELvmQ/za/M9V/EpuSuTqlFNOKfXp06fUvn370pZbbln653/+59Lvf/97T30jHXfccaVevXqlz3XrrbdOj1944QXPdSMtW7as9K1vfau07bbbljp27FjafvvtS//5n/9ZWrVqlWfbCPfcc08p+fX6wTFixIj087W1taXzzjuv1KNHj1KHDh3S3wvPPfecZ9zEZ/rSSy+V/VwyktfRtOf6t7/9rTRkyJD0v12bbLJJ+t+ykSNHlhYvXuyRQsGJX/Mhfs2e2DUbYtd8iF+b/7mKX8lLTfL/8kvNAgAAAABUJz1PAQAAAADKkDwFAAAAAChD8hQAAAAAoAzJUwAAAACAMiRPAQAAAADKkDwFAAAAAChD8hQAAAAAoAzJUwAAAACAMiRPgVajpqYmpk+fXulpAABAg4hfASpP8hSouJNOOikNDJOxySabRN++fWPMmDGxcuXKSk8NAAA+RPwK0Hq0q/QEABKHHXZYXHvttbFmzZqYO3dujBgxIk2mXnjhhR4QAAAtjvgVoHVQeQq0CB06dIiePXtG79694+ijj47BgwfHzJkz08+9+eabcfzxx8fWW28dm266aeyxxx7xi1/8ot7rDznkkPjmN7+ZVqxuscUW6b0mTJjwkV9z/Pjx0atXr/jzn/+c6/cGAEDxiF8BWgfJU6DFefLJJ+OBBx6I9u3bp8fJ8v0BAwbEnXfemX7u61//epx44onx8MMP13vd9ddfH5/4xCfioYceiosuuigmTpxYl4BdX6lUim984xvx85//PP74xz/Gnnvu2WzfGwAAxSN+BSiumlKSRQCocM+oG264ITp27BjvvfderFq1Ktq0aRO33HJLfPnLXy77mi984Quxyy67xI9+9KO6ytO1a9emydB19t133/jc5z4XP/jBD9LjpA3AL3/5y7j99tvj8ccfTxOrSTUrAACIXwEoR89ToEU49NBD48orr4wVK1bEJZdcEu3atatLnCZJ0f/6r/9Kk6mvvPJKrF69Ok2wJkv41/fBCtJkSf5rr71W79zZZ5+dLrF68MEHo1u3bs3wnQEAUETiV4DWwbJ9oEVIltvvuOOO0b9//5g6dWq69P5nP/tZ+rkf/vCHcdlll8V//Md/xD333BPz5s2LoUOHpknU9W2yySb1jpNK09ra2nrnPv/5z6cJ2LvuuqsZvisAAIpK/ArQOkieAi1OsmT/3HPPjXHjxsW7774b//f//t846qij4mtf+1qaXN1+++3jL3/5S5Pu/cUvfjFuvPHGOO200+Kmm27KfO4AALQ+4leA4pI8BVqkY489Ntq2bRtXXHFF7LTTTml/0mQTqWeeeSb+7d/+LZYsWdLkex9zzDExbdq0OPnkk+NXv/pVpvMGAKB1Er8CFJOep0CLlPQ8HTVqVFx00UXp5k4vvvhiulQ/6XP69a9/PY4++uhYunRpk+//la98JV3Sf+KJJ6aVAl/60pcynT8AAK2L+BWgmGpKpVKp0pMAAAAAAGhpLNsHAAAAAChD8hQAAAAAoAzJUwAAAACAMiRPAQAAAADKkDwFAAAAAChD8hQAAAAAoAzJUwAAAACAMiRPAQAAAADKkDwFAAAAAChD8hQAAAAAoAzJUwAAAACA+LD/BzVTVhwrfDYFAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "(
,\n", + " array([,\n", + " ,\n", + " ], dtype=object))" ] }, + "execution_count": 14, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Optimal parameters based on MASE:\n", - " n_delays: 5\n", - " rank: 15\n", - " MASE: 0.4495\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Create heatmaps for different metrics\n", - "fig, axes = plt.subplots(2, 2, figsize=(14, 12))\n", - "\n", - "# AIC (Akaike Information Criterion - lower is better)\n", - "im1 = axes[0, 0].imshow(all_aics, cmap='viridis', aspect='auto')\n", - "axes[0, 0].set_title('AIC (lower = better)')\n", - "axes[0, 0].set_xlabel('Rank')\n", - "axes[0, 0].set_ylabel('n_delays')\n", - "axes[0, 0].set_xticks(range(len(ranks_range)))\n", - "axes[0, 0].set_xticklabels(ranks_range)\n", - "axes[0, 0].set_yticks(range(len(n_delays_range)))\n", - "axes[0, 0].set_yticklabels(n_delays_range)\n", - "plt.colorbar(im1, ax=axes[0, 0])\n", - "\n", - "# MASE (Mean Absolute Scaled Error - lower is better)\n", - "im2 = axes[0, 1].imshow(all_mases, cmap='viridis', aspect='auto')\n", - "axes[0, 1].set_title('MASE (lower = better)')\n", - "axes[0, 1].set_xlabel('Rank')\n", - "axes[0, 1].set_ylabel('n_delays')\n", - "axes[0, 1].set_xticks(range(len(ranks_range)))\n", - "axes[0, 1].set_xticklabels(ranks_range)\n", - "axes[0, 1].set_yticks(range(len(n_delays_range)))\n", - "axes[0, 1].set_yticklabels(n_delays_range)\n", - "plt.colorbar(im2, ax=axes[0, 1])\n", - "\n", - "# Non-normality (lower = more normal, better behaved)\n", - "im3 = axes[1, 0].imshow(all_nnormals, cmap='viridis', aspect='auto')\n", - "axes[1, 0].set_title('Non-normality')\n", - "axes[1, 0].set_xlabel('Rank')\n", - "axes[1, 0].set_ylabel('n_delays')\n", - "axes[1, 0].set_xticks(range(len(ranks_range)))\n", - "axes[1, 0].set_xticklabels(ranks_range)\n", - "axes[1, 0].set_yticks(range(len(n_delays_range)))\n", - "axes[1, 0].set_yticklabels(n_delays_range)\n", - "plt.colorbar(im3, ax=axes[1, 0])\n", - "\n", - "# L2 Norm (transient growth measure)\n", - "im4 = axes[1, 1].imshow(all_l2norms, cmap='viridis', aspect='auto')\n", - "axes[1, 1].set_title('L2 Norm of DMD matrix')\n", - "axes[1, 1].set_xlabel('Rank')\n", - "axes[1, 1].set_ylabel('n_delays')\n", - "axes[1, 1].set_xticks(range(len(ranks_range)))\n", - "axes[1, 1].set_xticklabels(ranks_range)\n", - "axes[1, 1].set_yticks(range(len(n_delays_range)))\n", - "axes[1, 1].set_yticklabels(n_delays_range)\n", - "plt.colorbar(im4, ax=axes[1, 1])\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "# Find optimal parameters\n", - "best_idx = np.unravel_index(np.argmin(all_mases), all_mases.shape)\n", - "best_n_delays = n_delays_range[best_idx[0]]\n", - "best_rank = ranks_range[best_idx[1]]\n", - "print(f\"\\nOptimal parameters based on MASE:\")\n", - "print(f\" n_delays: {best_n_delays}\")\n", - "print(f\" rank: {best_rank}\")\n", - "print(f\" MASE: {all_mases[best_idx]:.4f}\")\n" + "#our function for visualizing is as follows:\n", + "plot_sweep_results(all_aics, all_mases, all_nnormals, n_delays=n_delays_range, ranks=ranks_range, cmap='viridis', name='DMD')" ] }, { @@ -1025,7 +977,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1040,38 +992,10 @@ "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/5 [00:00,\n", - " array([,\n", - " ,\n", - " ], dtype=object))" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -1090,7 +1014,7 @@ " n_delays=n_delays_range,\n", " ranks=ranks_range,\n", " model_class='SubspaceDMDc', # can be 'DMDc' or 'SubspaceDMDc' for control systems\n", - " train_frac=0.7, # Use 70% for training, 30% for testing\n", + " train_frac=0.7, \n", " reseed=5,\n", " return_residuals=False,\n", " device='cpu'\n", @@ -1108,7 +1032,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1117,14 +1041,14 @@ "text": [ "DMD Matrix Statistics:\n", "==================================================\n", - "MAE : 0.0077\n", - "MASE : 0.2627\n", - "NMSE : 0.1039\n", + "MAE : 0.0079\n", + "MASE : 0.1737\n", + "NMSE : 0.0400\n", "MSE : 0.0001\n", - "R2 : 0.8832\n", - "Correl : 0.9397\n", - "AIC : -9.2117\n", - "logMSE : -9.2521\n" + "R2 : 0.9479\n", + "Correl : 0.9736\n", + "AIC : -9.1654\n", + "logMSE : -9.2058\n" ] } ], From 17b025b0dae22970876f92638fcbcd078a4f7832 Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 6 Nov 2025 22:31:29 -0500 Subject: [PATCH 43/51] dmdc model tutorial notebook --- examples/dmdc_linear_system_test.ipynb | 765 +++++++++++++++++++++++++ 1 file changed, 765 insertions(+) create mode 100644 examples/dmdc_linear_system_test.ipynb diff --git a/examples/dmdc_linear_system_test.ipynb b/examples/dmdc_linear_system_test.ipynb new file mode 100644 index 0000000..3ae5bc9 --- /dev/null +++ b/examples/dmdc_linear_system_test.ipynb @@ -0,0 +1,765 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DMDc Test: Controlled Linear Dynamical System\n", + "\n", + "This notebook demonstrates:\n", + "1. Generating data from a controlled linear dynamical system\n", + "2. Fitting a DMDc model to recover the system matrices\n", + "3. Visualizing the eigenvalues of A and singular values of B to verify the fit\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "sys.path.append('../')\n", + "\n", + "from DSA.dmdc import DMDc\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Generate Ground Truth Linear Dynamical System\n", + "\n", + "We'll create a controlled linear dynamical system of the form:\n", + "$$x_{t+1} = A x_t + B u_t$$\n", + "\n", + "where:\n", + "- $x_t \\in \\mathbb{R}^n$ is the state\n", + "- $u_t \\in \\mathbb{R}^m$ is the control input\n", + "- $A \\in \\mathbb{R}^{n \\times n}$ is the state transition matrix\n", + "- $B \\in \\mathbb{R}^{n \\times m}$ is the control input matrix\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ground truth A eigenvalues: [-0.87865666+0.3611959j -0.87865666-0.3611959j -0.63342513+0.09350672j\n", + " -0.63342513-0.09350672j 0.50029664+0.40533415j 0.50029664-0.40533415j\n", + " 0.50450346+0.10018783j 0.50450346-0.10018783j 0.18230014+0.j\n", + " -0.14354022+0.j ]\n", + "Ground truth B singular values: [3.3561271 2.53100558 1.62794133]\n", + "\n", + "A matrix spectral radius: 0.9500\n", + "System is stable: True\n" + ] + } + ], + "source": [ + "# System dimensions\n", + "n_state = 10 # state dimension\n", + "n_control = 3 # control dimension\n", + "n_timesteps = 1000 # number of time steps\n", + "n_trials = 5 # number of trials\n", + "\n", + "# Sample random matrix for A and normalize to have max eigenvalue of 0.95\n", + "A_random = np.random.randn(n_state, n_state)\n", + "eigs_A = np.linalg.eigvals(A_random)\n", + "max_eig = np.max(np.abs(eigs_A))\n", + "A_true = A_random / max_eig * 0.95\n", + "\n", + "# Sample random matrix for B\n", + "B_true = np.random.randn(n_state, n_control)\n", + "\n", + "# Compute actual eigenvalues and singular values\n", + "eigenvalues_A = np.linalg.eigvals(A_true)\n", + "singular_values_B = np.linalg.svd(B_true, compute_uv=False)\n", + "\n", + "print(f\"Ground truth A eigenvalues: {eigenvalues_A}\")\n", + "print(f\"Ground truth B singular values: {singular_values_B}\")\n", + "print(f\"\\nA matrix spectral radius: {np.max(np.abs(eigenvalues_A)):.4f}\")\n", + "print(f\"System is stable: {np.max(np.abs(eigenvalues_A)) < 1}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eigs = np.linalg.eigvals(A_true)\n", + "plt.scatter(eigs.real,eigs.imag)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Generate Data from the System\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated data shape:\n", + " State data X: (5, 1000, 10)\n", + " Control data U: (5, 1000, 3)\n" + ] + } + ], + "source": [ + "def generate_controlled_trajectory(A, B, n_timesteps, n_trials, noise_std=0.01):\n", + " \"\"\"\n", + " Generate data from a controlled linear dynamical system.\n", + " \n", + " Parameters:\n", + " -----------\n", + " A : ndarray (n_state, n_state)\n", + " State transition matrix\n", + " B : ndarray (n_state, n_control)\n", + " Control input matrix\n", + " n_timesteps : int\n", + " Number of time steps per trial\n", + " n_trials : int\n", + " Number of trials\n", + " noise_std : float\n", + " Standard deviation of process noise\n", + " \n", + " Returns:\n", + " --------\n", + " X : ndarray (n_trials, n_timesteps, n_state)\n", + " State trajectories\n", + " U : ndarray (n_trials, n_timesteps, n_control)\n", + " Control inputs\n", + " \"\"\"\n", + " n_state = A.shape[0]\n", + " n_control = B.shape[1]\n", + " \n", + " X = np.zeros((n_trials, n_timesteps, n_state))\n", + " U = np.zeros((n_trials, n_timesteps, n_control))\n", + " \n", + " for trial in range(n_trials):\n", + " # Initialize with random state\n", + " X[trial, 0] = np.random.randn(n_state) * 0.1\n", + " \n", + " # Generate control inputs (random walk with some structure)\n", + " U[trial] = np.cumsum(np.random.randn(n_timesteps, n_control) * 0.1, axis=0)\n", + " \n", + " # Simulate system\n", + " for t in range(n_timesteps - 1):\n", + " # x_{t+1} = A x_t + B u_t + noise\n", + " X[trial, t + 1] = (A @ X[trial, t] + \n", + " B @ U[trial, t] + \n", + " np.random.randn(n_state) * noise_std)\n", + " \n", + " return X, U\n", + "\n", + "# Generate training data\n", + "X_train, U_train = generate_controlled_trajectory(A_true, B_true, n_timesteps, n_trials)\n", + "\n", + "print(f\"Generated data shape:\")\n", + "print(f\" State data X: {X_train.shape}\")\n", + "print(f\" Control data U: {U_train.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n", + "\n", + "# Plot first few state dimensions\n", + "ax = axes[0, 0]\n", + "for i in range(min(3, n_state)):\n", + " ax.plot(X_train[0, :200, i], label=f'$x_{{{i+1}}}$', alpha=0.7)\n", + "ax.set_xlabel('Time')\n", + "ax.set_ylabel('State Value')\n", + "ax.set_title('Sample State Trajectories (Trial 1, first 200 steps)')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# Plot control inputs\n", + "ax = axes[0, 1]\n", + "for i in range(n_control):\n", + " ax.plot(U_train[0, :200, i], label=f'$u_{{{i+1}}}$', alpha=0.7)\n", + "ax.set_xlabel('Time')\n", + "ax.set_ylabel('Control Value')\n", + "ax.set_title('Control Inputs (Trial 1, first 200 steps)')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# Plot state norm over time\n", + "ax = axes[1, 0]\n", + "for trial in range(n_trials):\n", + " state_norm = np.linalg.norm(X_train[trial], axis=1)\n", + " ax.plot(state_norm, alpha=0.5, label=f'Trial {trial+1}')\n", + "ax.set_xlabel('Time')\n", + "ax.set_ylabel('$||x_t||_2$')\n", + "ax.set_title('State Norm Over Time (All Trials)')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# Plot control norm over time\n", + "ax = axes[1, 1]\n", + "for trial in range(n_trials):\n", + " control_norm = np.linalg.norm(U_train[trial], axis=1)\n", + " ax.plot(control_norm, alpha=0.5, label=f'Trial {trial+1}')\n", + "ax.set_xlabel('Time')\n", + "ax.set_ylabel('$||u_t||_2$')\n", + "ax.set_title('Control Norm Over Time (All Trials)')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Fit DMDc Model\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing Hankel matrices ...\n", + "Hankel matrices computed!\n", + "Computing SVD on H and U matrices ...\n", + "SVDs computed!\n", + "Computing DMDc matrices ...\n", + "DMDc matrices computed!\n", + "\n", + "DMDc model fitted successfully!\n", + "Recovered A matrix shape: torch.Size([10, 10])\n", + "Recovered B matrix shape: torch.Size([10, 3])\n" + ] + } + ], + "source": [ + "# Create and fit DMDc model\n", + "dmdc = DMDc(\n", + " data=X_train,\n", + " control_data=U_train,\n", + " n_delays=1,\n", + " n_control_delays=1,\n", + " delay_interval=1,\n", + " rank_input=None, \n", + " rank_output=None, \n", + " lamb=0, \n", + " device='cpu',\n", + " verbose=True\n", + ")\n", + "\n", + "# Fit the model\n", + "dmdc.fit()\n", + "\n", + "print(\"\\nDMDc model fitted successfully!\")\n", + "print(f\"Recovered A matrix shape: {dmdc.A.shape}\")\n", + "print(f\"Recovered B matrix shape: {dmdc.B.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Compare True vs Recovered Matrices\n", + "\n", + "### 5.1 Eigenvalues of A\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Eigenvalue Comparison (sorted by magnitude):\n", + "======================================================================\n", + "Index True Recovered Error \n", + "======================================================================\n", + "0 -0.8787-0.3612j -0.8780-0.3617j 0.000828 \n", + "1 -0.8787+0.3612j -0.8780+0.3617j 0.000828 \n", + "2 0.5003-0.4053j 0.5015-0.4058j 0.001296 \n", + "3 0.5003+0.4053j 0.5015+0.4058j 0.001296 \n", + "4 -0.6334-0.0935j -0.6324-0.0882j 0.005358 \n", + "5 -0.6334+0.0935j -0.6324+0.0882j 0.005358 \n", + "6 0.5045-0.1002j 0.5048-0.0906j 0.009595 \n", + "7 0.5045+0.1002j 0.5048+0.0906j 0.009595 \n", + "8 0.1823 0.1814 0.000874 \n", + "9 -0.1435 -0.1413 0.002219 \n", + "======================================================================\n" + ] + } + ], + "source": [ + "# Compute eigenvalues\n", + "A_recovered = dmdc.A.cpu().numpy() if hasattr(dmdc.A, 'cpu') else dmdc.A\n", + "eigenvalues_A_recovered = np.linalg.eigvals(A_recovered)\n", + "\n", + "# Sort eigenvalues by magnitude for easier comparison\n", + "idx_true = np.argsort(np.abs(eigenvalues_A))[::-1]\n", + "idx_recovered = np.argsort(np.abs(eigenvalues_A_recovered))[::-1]\n", + "\n", + "eigenvalues_A_sorted = eigenvalues_A[idx_true]\n", + "eigenvalues_A_recovered_sorted = eigenvalues_A_recovered[idx_recovered]\n", + "\n", + "# Plot eigenvalues in complex plane\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "# Complex plane plot\n", + "ax = axes[0]\n", + "ax.scatter(eigenvalues_A.real, eigenvalues_A.imag, \n", + " s=100, alpha=0.6, label='Ground Truth', marker='o', color='blue')\n", + "ax.scatter(eigenvalues_A_recovered.real, eigenvalues_A_recovered.imag, \n", + " s=100, alpha=0.6, label='DMDc Recovered', marker='x', color='red', linewidths=3)\n", + "\n", + "# Draw unit circle\n", + "theta = np.linspace(0, 2*np.pi, 100)\n", + "ax.plot(np.cos(theta), np.sin(theta), 'k--', alpha=0.3, label='Unit Circle')\n", + "\n", + "ax.set_xlabel('Real Part')\n", + "ax.set_ylabel('Imaginary Part')\n", + "ax.set_title('Eigenvalues of A (Complex Plane)')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "ax.axis('equal')\n", + "\n", + "# Magnitude comparison\n", + "ax = axes[1]\n", + "x_pos = np.arange(len(eigenvalues_A))\n", + "width = 0.35\n", + "ax.bar(x_pos - width/2, np.abs(eigenvalues_A_sorted), width, \n", + " alpha=0.6, label='Ground Truth', color='blue')\n", + "ax.bar(x_pos + width/2, np.abs(eigenvalues_A_recovered_sorted), width, \n", + " alpha=0.6, label='DMDc Recovered', color='red')\n", + "ax.axhline(y=1, color='k', linestyle='--', alpha=0.3, label='Stability Boundary')\n", + "ax.set_xlabel('Eigenvalue Index (sorted by magnitude)')\n", + "ax.set_ylabel('Magnitude')\n", + "ax.set_title('Eigenvalue Magnitudes Comparison')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print numerical comparison\n", + "print(\"\\nEigenvalue Comparison (sorted by magnitude):\")\n", + "print(\"=\"*70)\n", + "print(f\"{'Index':<8} {'True':<25} {'Recovered':<25} {'Error':<10}\")\n", + "print(\"=\"*70)\n", + "for i in range(len(eigenvalues_A)):\n", + " error = np.abs(eigenvalues_A_sorted[i] - eigenvalues_A_recovered_sorted[i])\n", + " true_str = f\"{eigenvalues_A_sorted[i].real:.4f}\"\n", + " if np.abs(eigenvalues_A_sorted[i].imag) > 1e-10:\n", + " true_str += f\"+{eigenvalues_A_sorted[i].imag:.4f}j\" if eigenvalues_A_sorted[i].imag > 0 else f\"{eigenvalues_A_sorted[i].imag:.4f}j\"\n", + " rec_str = f\"{eigenvalues_A_recovered_sorted[i].real:.4f}\"\n", + " if np.abs(eigenvalues_A_recovered_sorted[i].imag) > 1e-10:\n", + " rec_str += f\"+{eigenvalues_A_recovered_sorted[i].imag:.4f}j\" if eigenvalues_A_recovered_sorted[i].imag > 0 else f\"{eigenvalues_A_recovered_sorted[i].imag:.4f}j\"\n", + " print(f\"{i:<8} {true_str:<25} {rec_str:<25} {error:<10.6f}\")\n", + "print(\"=\"*70)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2 Singular Values of B\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Singular Value Comparison:\n", + "============================================================\n", + "Index True Recovered Relative Error \n", + "============================================================\n", + "0 3.356127 3.355637 0.000146 \n", + "1 2.531006 2.529212 0.000709 \n", + "2 1.627941 1.628247 0.000188 \n", + "============================================================\n" + ] + } + ], + "source": [ + "# Compute singular values\n", + "B_recovered = dmdc.B.cpu().numpy() if hasattr(dmdc.B, 'cpu') else dmdc.B\n", + "singular_values_B_recovered = np.linalg.svd(B_recovered, compute_uv=False)\n", + "\n", + "# Plot singular values\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "# Bar plot comparison\n", + "ax = axes[0]\n", + "x_pos = np.arange(len(singular_values_B))\n", + "width = 0.35\n", + "ax.bar(x_pos - width/2, singular_values_B, width, \n", + " alpha=0.6, label='Ground Truth', color='blue')\n", + "ax.bar(x_pos + width/2, singular_values_B_recovered[:len(singular_values_B)], width, \n", + " alpha=0.6, label='DMDc Recovered', color='red')\n", + "ax.set_xlabel('Singular Value Index')\n", + "ax.set_ylabel('Singular Value')\n", + "ax.set_title('Singular Values of B')\n", + "ax.set_xticks(x_pos)\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# Log scale plot (if needed for wide range)\n", + "ax = axes[1]\n", + "ax.semilogy(singular_values_B_recovered, 'o-', label='DMDc Recovered (all)', alpha=0.7)\n", + "ax.semilogy(range(len(singular_values_B)), singular_values_B, 'x-', \n", + " label='Ground Truth', markersize=10, linewidth=2)\n", + "ax.set_xlabel('Singular Value Index')\n", + "ax.set_ylabel('Singular Value (log scale)')\n", + "ax.set_title('Singular Value Spectrum of B')\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3, which='both')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print numerical comparison\n", + "print(\"\\nSingular Value Comparison:\")\n", + "print(\"=\"*60)\n", + "print(f\"{'Index':<8} {'True':<15} {'Recovered':<15} {'Relative Error':<15}\")\n", + "print(\"=\"*60)\n", + "for i in range(len(singular_values_B)):\n", + " rel_error = np.abs(singular_values_B[i] - singular_values_B_recovered[i]) / singular_values_B[i]\n", + " print(f\"{i:<8} {singular_values_B[i]:<15.6f} {singular_values_B_recovered[i]:<15.6f} {rel_error:<15.6f}\")\n", + "print(\"=\"*60)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Prediction Performance\n", + "\n", + "Let's verify that the model can accurately predict future states.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'MAE': 0.0080215854461753,\n", + " 'MASE': 0.03452452148384243,\n", + " 'NMSE': 2.7266879462026973e-06,\n", + " 'MSE': 0.00010147284380389543,\n", + " 'R2': 0.9999937456506395,\n", + " 'Correl': 0.9999968409538269,\n", + " 'AIC': -9.175519344010073,\n", + " 'logMSE': -9.195719344010072}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from DSA import compute_all_stats\n", + "# Generate test data\n", + "X_test, U_test = generate_controlled_trajectory(A_true, B_true, n_timesteps=500, n_trials=2)\n", + "\n", + "# Make predictions\n", + "X_pred = dmdc.predict(test_data=X_test, control_data=U_test, reseed=1)\n", + "X_pred_np = X_pred.cpu().numpy() if hasattr(X_pred, 'cpu') else X_pred\n", + "\n", + "\n", + "# Plot predictions vs ground truth\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n", + "\n", + "trial_idx = 0 # Plot first trial\n", + "time_window = slice(0, 200)\n", + "\n", + "# Plot first few dimensions\n", + "for dim_idx in range(min(4, n_state)):\n", + " ax = axes[dim_idx // 2, dim_idx % 2]\n", + " ax.plot(X_test[trial_idx, time_window, dim_idx], \n", + " label='Ground Truth', linewidth=2, alpha=0.7)\n", + " ax.plot(X_pred_np[trial_idx, time_window, dim_idx], \n", + " label='DMDc Prediction', linewidth=2, linestyle='--', alpha=0.7)\n", + " ax.set_xlabel('Time')\n", + " ax.set_ylabel(f'$x_{{{dim_idx+1}}}$')\n", + " ax.set_title(f'Dimension {dim_idx+1} Prediction')\n", + " ax.legend()\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "\n", + "\n", + "compute_all_stats(X_test, X_pred,rank=dmdc.A.shape[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Matrix Reconstruction Error\n", + "\n", + "Let's compute how well we recovered the A and B matrices.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Matrix Reconstruction Errors:\n", + "============================================================\n", + "A Matrix:\n", + " Frobenius Norm Error: 0.023059\n", + " Relative Error: 0.008991 (0.90%)\n", + "\n", + "B Matrix:\n", + " Frobenius Norm Error: 0.008771\n", + " Relative Error: 0.001946 (0.19%)\n", + "============================================================\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "A_frobenius_error = np.linalg.norm(A_true - A_recovered, 'fro')\n", + "A_relative_error = A_frobenius_error / np.linalg.norm(A_true, 'fro')\n", + "\n", + "B_frobenius_error = np.linalg.norm(B_true - B_recovered, 'fro')\n", + "B_relative_error = B_frobenius_error / np.linalg.norm(B_true, 'fro')\n", + "\n", + "print(\"\\nMatrix Reconstruction Errors:\")\n", + "print(\"=\"*60)\n", + "print(f\"A Matrix:\")\n", + "print(f\" Frobenius Norm Error: {A_frobenius_error:.6f}\")\n", + "print(f\" Relative Error: {A_relative_error:.6f} ({A_relative_error*100:.2f}%)\")\n", + "print(f\"\\nB Matrix:\")\n", + "print(f\" Frobenius Norm Error: {B_frobenius_error:.6f}\")\n", + "print(f\" Relative Error: {B_relative_error:.6f} ({B_relative_error*100:.2f}%)\")\n", + "print(\"=\"*60)\n", + "\n", + "# Visualize matrix differences\n", + "fig, axes = plt.subplots(2, 3, figsize=(16, 10))\n", + "\n", + "# A matrix visualization\n", + "vmax_A = max(np.abs(A_true).max(), np.abs(A_recovered).max())\n", + "im0 = axes[0, 0].imshow(A_true, cmap='RdBu_r', vmin=-vmax_A, vmax=vmax_A, aspect='auto')\n", + "axes[0, 0].set_title('True A Matrix')\n", + "axes[0, 0].set_xlabel('Column')\n", + "axes[0, 0].set_ylabel('Row')\n", + "plt.colorbar(im0, ax=axes[0, 0])\n", + "\n", + "im1 = axes[0, 1].imshow(A_recovered, cmap='RdBu_r', vmin=-vmax_A, vmax=vmax_A, aspect='auto')\n", + "axes[0, 1].set_title('Recovered A Matrix')\n", + "axes[0, 1].set_xlabel('Column')\n", + "axes[0, 1].set_ylabel('Row')\n", + "plt.colorbar(im1, ax=axes[0, 1])\n", + "\n", + "A_diff = A_true - A_recovered\n", + "im2 = axes[0, 2].imshow(A_diff, cmap='RdBu_r', vmin=-vmax_A, vmax=vmax_A, aspect='auto')\n", + "axes[0, 2].set_title(f'Difference (Relative Error: {A_relative_error*100:.2f}%)')\n", + "axes[0, 2].set_xlabel('Column')\n", + "axes[0, 2].set_ylabel('Row')\n", + "plt.colorbar(im2, ax=axes[0, 2])\n", + "\n", + "# B matrix visualization\n", + "vmax_B = max(np.abs(B_true).max(), np.abs(B_recovered).max())\n", + "im3 = axes[1, 0].imshow(B_true, cmap='RdBu_r', vmin=-vmax_B, vmax=vmax_B, aspect='auto')\n", + "axes[1, 0].set_title('True B Matrix')\n", + "axes[1, 0].set_xlabel('Column')\n", + "axes[1, 0].set_ylabel('Row')\n", + "plt.colorbar(im3, ax=axes[1, 0])\n", + "\n", + "im4 = axes[1, 1].imshow(B_recovered, cmap='RdBu_r', vmin=-vmax_B, vmax=vmax_B, aspect='auto')\n", + "axes[1, 1].set_title('Recovered B Matrix')\n", + "axes[1, 1].set_xlabel('Column')\n", + "axes[1, 1].set_ylabel('Row')\n", + "plt.colorbar(im4, ax=axes[1, 1])\n", + "\n", + "B_diff = B_true - B_recovered\n", + "im5 = axes[1, 2].imshow(B_diff, cmap='RdBu_r', vmin=-vmax_B, vmax=vmax_B, aspect='auto')\n", + "axes[1, 2].set_title(f'Difference (Relative Error: {B_relative_error*100:.2f}%)')\n", + "axes[1, 2].set_xlabel('Column')\n", + "axes[1, 2].set_ylabel('Row')\n", + "plt.colorbar(im5, ax=axes[1, 2])\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "This notebook demonstrated:\n", + "\n", + "1. **Data Generation**: Created a controlled linear dynamical system with known eigenvalues of A and singular values of B\n", + "2. **Model Fitting**: Successfully fit a DMDc model to recover the system matrices\n", + "3. **Verification**: Compared the recovered eigenvalues and singular values with ground truth\n", + "4. **Prediction**: Tested the model's ability to predict future states\n", + "\n", + "The results show that DMDc can accurately recover the dynamics of a controlled linear system from data, with the eigenvalues and singular values closely matching the ground truth values.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dsa_test_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 0be3dd88098a34cbc6dfe729b5be59660467c7ee Mon Sep 17 00:00:00 2001 From: ostrow Date: Thu, 6 Nov 2025 22:37:03 -0500 Subject: [PATCH 44/51] input dsa figure 2 working! --- examples/inputdsa_fig2_tutorial.ipynb | 2789 +++++++++++++++++++++++++ 1 file changed, 2789 insertions(+) create mode 100644 examples/inputdsa_fig2_tutorial.ipynb diff --git a/examples/inputdsa_fig2_tutorial.ipynb b/examples/inputdsa_fig2_tutorial.ipynb new file mode 100644 index 0000000..72cdd0c --- /dev/null +++ b/examples/inputdsa_fig2_tutorial.ipynb @@ -0,0 +1,2789 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "900a4676", + "metadata": {}, + "source": [ + "# InputDSA tutorial (Huang and Ostrow 2025 Fig. 2). InputDSA accurately distinguishes partially observed, input-driven dynamical systems\n", + "\n", + "In this analysis, we are going to look at how to appropriately compare partially observed systems\n", + "\n", + "we will look at 4 different dynamical systems, made up of 2 pairings: \n", + "1. (1,2), (3,4) have the same intrinsic dynamics\n", + "2. (1,3) (2,4) have the same read in dynamics -- how the input affects the state\n", + "\n", + "We will compare different types of DMDs (and therefore DSAs): \n", + "1. Dynamic Mode Decomposition (DMD) with delay embeddings (Hankel DMD / Havok). This method must ignore the input\n", + "2. DMD with control (DMDc, Proctor et al., 2016). This method does joint regression on the state and the input to learn an input and a state dynamics operator. However, it assumes full observation of the state, and if not, naive application of delay embeddings to resolve partial observations result in intrinsic dynamics leakage into the input operator (Fig 2a). \n", + "3. Subspace DMDc (N4SID on lifted states, Huang and Ostrow 2025). This method uses subspace identification methods to appropriately separate the effect of input and state on delay embedded data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "52fcf42e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shared parameters:\n", + " System: n=20, m=1, p_out=10, N=10000\n", + " Dynamics: rho1=0.92, rho2=0.82, g1=0.5, g2=2.0\n", + " Noise: obs_noise=0.01, process_noise=0.0\n", + " Nonlinearity: nonlinear_eps=0.1\n", + " Model: n_delays=150, rank=20, pf=150\n", + " Evaluation: n_iters=10\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Figure 2 InputDSA Data Analysis \n", + "\"\"\"\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "n = 20 # latent state dim\n", + "n_large = 50\n", + "m = 1 # input dim \n", + "p_out = 10 # observed dim (partial observation) - gets overridden in some cells\n", + "p_out_small = 2\n", + "N = 10000 # sequence length\n", + "N_small = 1000\n", + "n_Us = 4\n", + "obs_noise = 0.01\n", + "process_noise = 0.0\n", + "nonlinear_eps = 0.1\n", + "input_alpha = 0.001\n", + "g1 = 0.5\n", + "g2 = 2.0\n", + "rho1 = 0.92\n", + "rho2 = 0.82\n", + "seed1 = 11\n", + "seed2 = 12\n", + "n_delays = 150\n", + "rank = 20\n", + "pf = 150\n", + "n_iters = 10\n", + "backend = 'n4sid'\n", + "\n", + "print(f\"Shared parameters:\")\n", + "print(f\" System: n={n}, m={m}, p_out={p_out}, N={N}\")\n", + "print(f\" Dynamics: rho1={rho1}, rho2={rho2}, g1={g1}, g2={g2}\")\n", + "print(f\" Noise: obs_noise={obs_noise}, process_noise={process_noise}\")\n", + "print(f\" Nonlinearity: nonlinear_eps={nonlinear_eps}\")\n", + "print(f\" Model: n_delays={n_delays}, rank={rank}, pf={pf}\")\n", + "print(f\" Evaluation: n_iters={n_iters}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4b891d5e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "# Updated to use DSA package imports\n", + "import sys\n", + "sys.path.insert(0, '..') # Add parent directory to path to import DSA\n", + "\n", + "plt.rcParams['pdf.fonttype'] = 42\n", + "plt.rcParams['ps.fonttype'] = 42\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f3cdd518", + "metadata": {}, + "outputs": [], + "source": [ + "from DSA import InputDSA\n", + "from DSA import SimilarityTransformDist as SimDist\n", + "from DSA import ControllabilitySimilarityTransformDist as ControlSimDist\n", + "from tqdm import tqdm\n", + "\n", + "def compare_systems_with_InputDSA(Ys, Us, n_delays=150, rank=10, backend='n4sid'):\n", + " \"\"\"\n", + " Compare controlled systems using InputDSA from DSA package.\n", + " Uses the new update_compare_method() to avoid refitting DMDs multiple times.\n", + " \n", + " Parameters:\n", + " - Ys: list of output data arrays (p_out, N)\n", + " - Us: list of control input arrays (m, N)\n", + " - n_delays: number of delays for DMD\n", + " - rank: rank for DMD\n", + " - backend: 'n4sid' or 'custom' for SubspaceDMDc\n", + " \n", + " Returns:\n", + " - sims_full: joint similarity scores\n", + " - sims_control_joint: control scores from joint optimization\n", + " - sims_state_joint: state scores from joint optimization\n", + " - sims_control_separate: control scores from separate optimization\n", + " - sims_state_separate: state scores from separate optimization\n", + " \"\"\"\n", + " # Transpose data for InputDSA (expects time_first=True by default)\n", + " Ys_T = [Y.T for Y in Ys]\n", + " Us_T = [U.T for U in Us]\n", + " \n", + " # Configure DMD\n", + " # dmd_config = SubspaceDMDcConfig(\n", + " # n_delays=n_delays,\n", + " # rank=rank,\n", + " # backend=backend\n", + " # )\n", + " dmd_config = dict(\n", + " n_delays=n_delays,\n", + " rank=rank,\n", + " backend=backend\n", + " )\n", + " \n", + " # Create InputDSA with joint comparison\n", + " # This will fit the DMDs once and return joint comparison results\n", + " inputDSA = InputDSA(\n", + " X=Ys_T,\n", + " X_control=Us_T,\n", + " dmd_config=dmd_config,\n", + " compare='joint',\n", + " return_distance_components=True\n", + " )\n", + " \n", + " # Fit DMDs and get joint comparison results\n", + " sims_full, sims_state_joint, sims_control_joint = inputDSA.fit_score()\n", + " \n", + " # Update comparison method to 'state' without refitting DMDs\n", + " inputDSA.update_compare_method(compare='state')\n", + " sims_state_separate = inputDSA.score()\n", + " \n", + " # Update comparison method to 'control' without refitting DMDs\n", + " inputDSA.update_compare_method(compare='control')\n", + " sims_control_separate = inputDSA.score()\n", + " \n", + " return sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate\n", + "\n", + "\n", + "#strict comparison metrics, for when we fit and compare separately\n", + "def compare_A(A1,A2):\n", + " simdist = SimDist(iters=1000,score_method='wasserstein',lr=1e-3,verbose=True)\n", + " return simdist.fit_score(A1,A2)\n", + "\n", + "def compare_A_full(As):\n", + " sims = np.zeros((len(As),len(As)))\n", + " for i in range(len(As)):\n", + " for j in range(i+1,len(As)):\n", + " sims[i,j] = compare_A(As[i],As[j])\n", + " sims[j,i] = sims[i,j]\n", + " return sims\n", + "\n", + "def compare_B(B1,B2):\n", + " csimdist = ControlSimDist(score_method='euclidean',compare='control')\n", + " sim = csimdist.fit_score(None, None, B1, B2)\n", + " return sim\n", + "\n", + "def compare_systems_full(As,Bs):\n", + " csimdist = ControlSimDist(score_method='euclidean',compare='joint',return_distance_components=True)\n", + " sims_full = np.zeros((len(As),len(As)))\n", + " sims_control_joint = np.zeros((len(As),len(As)))\n", + " sims_state_joint = np.zeros((len(As),len(As)))\n", + " sims_control_separate = np.zeros((len(As),len(As)))\n", + " sims_state_separate = np.zeros((len(As),len(As)))\n", + " for i in tqdm(range(len(As))):\n", + " for j in range(i+1,len(As)):\n", + " all_sims = csimdist.fit_score(As[i],As[j],Bs[i],Bs[j])\n", + " sims_full[i,j] = sims_full[j,i] = all_sims[0]\n", + " sims_state_joint[i,j] = sims_state_joint[j,i] = all_sims[1]\n", + " sims_control_joint[i,j] = sims_control_joint[j,i] = all_sims[2]\n", + " \n", + " for i in tqdm(range(len(As))):\n", + " for j in range(i+1,len(As)):\n", + " sims_state_separate[i,j] = compare_A(As[i],As[j])\n", + " sims_control_separate[i,j] = compare_B(Bs[i],Bs[j])\n", + " sims_state_separate[j,i] = sims_state_separate[i,j]\n", + " sims_control_separate[j,i] = sims_control_separate[i,j]\n", + "\n", + " return sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7ba785c8", + "metadata": {}, + "outputs": [], + "source": [ + "def make_stable_A(n, rho=0.9, rng=None):\n", + " rng = np.random.default_rng(rng)\n", + " M = rng.standard_normal((n, n))\n", + " # Make it diagonally dominant-ish and scale spectral radius\n", + " A = M / np.max(np.abs(np.linalg.eigvals(M))) * rho\n", + " return A\n", + "\n", + "def simulate_system(A, B, C, U, x0=None,rng=None,obs_noise=0.0,process_noise=0.0,\n", + " nonlinear_eps=0.0,nonlinear_func= lambda x: np.tanh(x),nonlinear_eps_input=0.0):\n", + " n, m = B.shape\n", + " p_out = C.shape[0]\n", + " N = U.shape[1]\n", + " X = np.zeros((n, N+1))\n", + " C_full = np.eye(A.shape[0])\n", + " C_full[np.where(C == 1)[1],np.where(C == 1)[1]] = 0.0\n", + "\n", + " if x0 is not None:\n", + " X[:, 0] = x0\n", + " else:\n", + " X[:, 0] = np.random.default_rng(rng).standard_normal((n,))\n", + " Y = np.zeros((p_out, N))\n", + " for t in range(N):\n", + " X[:, t+1] = A @ (X[:, t]) + nonlinear_eps * C_full @ nonlinear_func(A @ X[:, t]) + \\\n", + " B @ ((1-nonlinear_eps_input) * U[:, t] + nonlinear_eps_input * nonlinear_func(U[:, t])) + \\\n", + " np.random.normal(0, process_noise, (n,))\n", + " Y[:, t] = C @ X[:, t] + np.random.normal(0, obs_noise, (p_out,))\n", + " return X[:, 1:], Y # states aligned with Y\n", + "\n", + "def smooth_input(m, N, alpha=0.9, rng=None):\n", + " rng = np.random.default_rng(rng)\n", + " w = rng.standard_normal((m, N))\n", + " U = np.zeros_like(w)\n", + " for t in range(N):\n", + " U[:, t] = alpha*(U[:, t-1] if t>0 else 0) + (1-alpha)*w[:, t]\n", + " return U" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "87d14512", + "metadata": {}, + "outputs": [], + "source": [ + "def simulate_As_Bs(latent_dim, input_dim, observed_dim, seq_length,rho1=rho1,\n", + " rho2=rho2, g1=g1,g2=g2, seed1=seed1, seed2=seed2, input_alpha=input_alpha,same_inp=False,n_Us=n_Us,\n", + " obs_noise=obs_noise,process_noise=process_noise,nonlinear_eps=nonlinear_eps,nonlinear_func= lambda x: np.tanh(x)):\n", + "\n", + " A1_true = make_stable_A(latent_dim, rho=rho1, rng=seed1)\n", + " cov_matrix_B1 = np.random.default_rng(seed1).standard_normal((latent_dim, latent_dim))\n", + " cov_matrix_B1 = cov_matrix_B1 @ cov_matrix_B1.T # Make it symmetric positive definite\n", + " B1_true = np.random.default_rng(seed1).multivariate_normal(np.zeros(latent_dim), cov_matrix_B1, input_dim).T * g1\n", + "\n", + " A2_true = make_stable_A(latent_dim, rho=rho2, rng=seed2)\n", + " C = np.linalg.qr(np.random.default_rng(seed2).standard_normal((latent_dim, latent_dim)))[0]\n", + " cov_matrix_B2_rotated = C @ cov_matrix_B1 @ C.T \n", + " B2_true = np.random.default_rng(seed2).multivariate_normal(np.zeros(latent_dim), cov_matrix_B2_rotated, input_dim).T * g2\n", + "\n", + " # Random partial observation: select p_out of n states\n", + " idx_obs = np.sort(np.random.default_rng(seed1).choice(latent_dim, size=observed_dim, replace=False))\n", + " C_true = np.zeros((observed_dim, latent_dim))\n", + " C_true[np.arange(observed_dim), idx_obs] = 1.0\n", + " \n", + " X_trues, Ys,Us = [], [], []\n", + " i = 0\n", + " if same_inp:\n", + " U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1+i) \n", + " control_labels = []\n", + " state_labels = []\n", + " for a1, As in enumerate([A1_true, A2_true]):\n", + " for b1, Bs in enumerate([B1_true, B2_true]):\n", + " i += 1\n", + " if not same_inp:\n", + " for j in range(n_Us):\n", + " U = smooth_input(input_dim, seq_length, alpha=input_alpha, rng=seed1+ i + j) \n", + " X_true, Y = simulate_system(As, Bs, C_true, U, x0=np.zeros(latent_dim),rng=seed1+i,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", + " X_trues.append(X_true)\n", + " Ys.append(Y)\n", + " Us.append(U)\n", + " control_labels.append(b1)\n", + " state_labels.append(a1)\n", + " else:\n", + " X_true, Y = simulate_system(As, Bs, C_true, U, x0=np.zeros(latent_dim),rng=seed1+i,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", + " X_trues.append(X_true)\n", + " Ys.append(Y)\n", + " Us.append(U)\n", + " control_labels.append(b1)\n", + " state_labels.append(a1)\n", + "\n", + " return X_trues, Ys, Us, control_labels, state_labels, (A1_true, A2_true), (B1_true, B2_true)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "728cf5a2", + "metadata": {}, + "outputs": [], + "source": [ + "from DSA import DMD,DMDc, SubspaceDMDc\n", + "from tqdm import tqdm\n", + "\n", + "def get_dmds(Ys,n_delays=1,rank=None):\n", + " As = []\n", + " for Y in Ys:\n", + " dmd = DMD(Y.T,n_delays=n_delays,rank=rank)\n", + " dmd.fit()\n", + " As.append(dmd.A_v.numpy())\n", + " return As\n", + "\n", + "def get_dmdcs(Ys,Us,n_delays=1,rank=None):\n", + " As = []\n", + " Bs = []\n", + " for Y, U in zip(Ys, Us):\n", + " dmdc = DMDc(Y.T, U.T,n_delays=n_delays,n_control_delays=n_delays,rank_input=rank,rank_output=rank)\n", + " dmdc.fit()\n", + " As.append(dmdc.A_v.numpy())\n", + " Bs.append(dmdc.B_v.numpy())\n", + " return As, Bs\n", + "\n", + "\n", + "def get_subspace_dmdcs(Ys, Us, p=20, rank=None, backend='n4sid'):\n", + " \"\"\"Fit SubspaceDMDc models using DSA package.\"\"\"\n", + " As, Bs, Cs, infos = [], [], [], []\n", + " for Y, U in zip(Ys, Us):\n", + " model = SubspaceDMDc(Y.T, U.T, n_delays=p, rank=rank, backend=backend)\n", + " model.fit()\n", + " As.append(model.A_v)#.numpy())\n", + " Bs.append(model.B_v)#.numpy())\n", + " Cs.append(model.C_v)#.numpy())\n", + " infos.append(model.info)\n", + " return As, Bs, Cs, infos\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "db4d50cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000), (2, 1000)]\n" + ] + } + ], + "source": [ + "X_trues, Ys, Us, control_labels, state_labels, A_trues, B_trues = simulate_As_Bs(n,m,p_out_small,\n", + " N_small,input_alpha=input_alpha,g1=g1,g2=g2,same_inp=False,n_Us=n_Us,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps)\n", + "print([i.shape for i in Ys])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3ef1f7f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot examples of the inputs and the outputs\n", + "fig, ax = plt.subplots(2,2,figsize=(4,2),sharex=True,sharey=True)\n", + "ax = ax.flatten()\n", + "for i in range(4):\n", + " ind = 4*i\n", + " ax[i].plot(Us[ind].T[:100] + 10*np.mean(np.abs(Us[ind])), color=plt.cm.Set2(1), label='Input (u)')\n", + " ax[i].plot(Ys[ind].T[:100, 0], color=plt.cm.Set2(2), label='Output (y)')\n", + " #remove all ticks and lines\n", + " ax[i].set_xticks([])\n", + " ax[i].set_yticks([])\n", + " ax[i].spines['top'].set_visible(False)\n", + " ax[i].spines['right'].set_visible(False)\n", + " ax[i].spines['bottom'].set_visible(False)\n", + " ax[i].spines['left'].set_visible(False)\n", + " \n", + "ax[0].text(1, 0.4, 'Input', transform=ax[0].transAxes, color=plt.cm.Set2(1), va='top')\n", + "ax[0].text(1, 0.2, 'Output', transform=ax[0].transAxes, color=plt.cm.Set2(2), va='top')\n", + "plt.tight_layout()\n", + "# plt.savefig(f'{folder_path}/input_output_examples.pdf', format='pdf', dpi=300, bbox_inches='tight')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eef05f5d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_89440/1787994131.py:36: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " ax[1].legend(title=\"Delays\", loc='upper right', bbox_to_anchor=(1.5, 1),\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use SubspaceDMDc from DSA package to analyze singular values\n", + "\n", + "\n", + "fig, ax = plt.subplots(2,2,figsize=(9,6),sharey=True,sharex=True)\n", + "ax = ax.flatten()\n", + " \n", + "for j, (Y, U) in enumerate(zip(Ys[::n_Us], Us[::n_Us])):\n", + " # Test different numbers of delays for subspace identification\n", + " nds_all = [10, 25, 50, 75, 100, 125, 150, 175, 200]\n", + " for k, nds in enumerate(nds_all):\n", + " # Fit SubspaceDMDc with varying number of delays\n", + " model = SubspaceDMDc(\n", + " Y.T, # SubspaceDMDc expects (T, p_out)\n", + " U.T, # SubspaceDMDc expects (T, m)\n", + " n_delays=nds,\n", + " rank=rank, # Use fixed rank for comparison\n", + " backend='n4sid'\n", + " )\n", + " model.fit()\n", + " \n", + " # Extract singular values from model info\n", + " singular_vals = model.info['singular_values_O']\n", + " \n", + " # Convert to numpy if needed\n", + " if hasattr(singular_vals, 'numpy'):\n", + " singular_vals = singular_vals.numpy()\n", + " \n", + " # Plot singular values\n", + " ax[j].plot(singular_vals, '-', label=f'{nds}', \n", + " color=plt.cm.Blues_r(k / (len(nds_all) + 4)))\n", + " ax[j].set_yscale('log')\n", + " ax[j].axvline(x=rank, color='k', linestyle=':', alpha=0.5)\n", + " \n", + " ax[j].set_xlabel('Mode Number')\n", + " ax[j].set_title(f'System {j+1}')\n", + " ax[1].legend(title=\"Delays\", loc='upper right', bbox_to_anchor=(1.5, 1), \n", + " fontsize=12, title_fontsize=15)\n", + "\n", + "ax[0].set_ylabel('Singular Value')\n", + "ax[2].set_ylabel('Singular Value')\n", + "plt.tight_layout()\n", + "# plt.savefig(f'{folder_path}/singular_values_subspace_dmdc.pdf', format='pdf', dpi=300, bbox_inches='tight')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3636fc5c", + "metadata": {}, + "outputs": [], + "source": [ + "dec = 0 #can change this to look at the efect of using the incorrect ranks\n", + "A_dmd = get_dmds(Ys,n_delays=n_delays,rank=rank- dec)\n", + "A_cs, B_cs = get_dmdcs(Ys,Us,n_delays=n_delays,rank=rank - dec)\n", + "As, Bs, Cs, infos = get_subspace_dmdcs(Ys,Us,p=pf,rank=rank-dec,backend='custom')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5ae5efa9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N4SID - A matrix shapes: [(20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20), (20, 20)]\n", + "N4SID - Ranks used: [20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]\n", + "N4SID - Backend info: ['unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown']\n", + "\\nEigenvalue comparison (first system):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\nComputing similarity matrices...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 196.85it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 42.53it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 120.82it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 49.00it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Custom backend silhouette score: 0.975\n", + "N4SID backend silhouette score: 0.956\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "As_n4sid, Bs_n4sid, Cs_n4sid, infos_n4sid = get_subspace_dmdcs(Ys, Us, p=pf, rank=rank-dec, backend='n4sid')\n", + "print(f\"N4SID - A matrix shapes: {[A.shape for A in As_n4sid]}\")\n", + "print(f\"N4SID - Ranks used: {[info['rank_used'] for info in infos_n4sid]}\")\n", + "print(f\"N4SID - Backend info: {[info.get('backend', 'unknown') for info in infos_n4sid]}\")\n", + "\n", + "# Quick comparison of eigenvalues (first system)\n", + "print(\"\\\\nEigenvalue comparison (first system):\")\n", + "eigs_custom = np.linalg.eigvals(As[0])\n", + "eigs_n4sid = np.linalg.eigvals(As_n4sid[0])\n", + "eigs_real = np.linalg.eigvals(A_trues[0])\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(eigs_real.real, eigs_real.imag, alpha=0.7, label='True', s=100)\n", + "plt.scatter(eigs_custom.real, eigs_custom.imag, alpha=0.7, label='Custom backend', s=50)\n", + "plt.scatter(eigs_n4sid.real, eigs_n4sid.imag, alpha=0.7, label='N4SID backend', s=50, marker='x',c='k')\n", + "plt.xlabel('Real part')\n", + "plt.ylabel('Imaginary part')\n", + "plt.title('Eigenvalue comparison (first system)')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)\n", + "plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)\n", + "plt.show()\n", + "\n", + "# Compute distances using both backends for comparison\n", + "print(\"\\\\nComputing similarity matrices...\")\n", + "_, _, _, _, sims_state_custom = compare_systems_full(As, Bs)\n", + "_, _, _, _, sims_state_n4sid = compare_systems_full(As_n4sid, Bs_n4sid)\n", + "\n", + "from sklearn.metrics import silhouette_score\n", + "silh_custom = silhouette_score(sims_state_custom, state_labels, metric='precomputed')\n", + "silh_n4sid = silhouette_score(sims_state_n4sid, state_labels, metric='precomputed')\n", + "\n", + "\n", + "print(f\"Custom backend silhouette score: {silh_custom:.3f}\")\n", + "print(f\"N4SID backend silhouette score: {silh_n4sid:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "79bb2540", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 50.42it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 52.21it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 48.77it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 51.64it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 203.23it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 50.05it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 239.30it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 61.68it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABTEAAAFPCAYAAACVlIpbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYjxJREFUeJzt3QeYFEXawPGasAF2lyVnJCoqYlZURFQQUTwwoGIERUzcGRHDfYKYEBXlxOwpYDgUzIcneJ6gKJhFMKASBCUKkpdNM/U9b+nMdPfuzqbZ3Zrd/+95hp2e7unuSS8171S95dNaawUAAAAAAAAAlvLX9AkAAAAAAAAAQDwkMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAEgCU6dOVT6fT/3888+lbtuhQwc1bNgwVd3k3OQc77///mo/NuquY4891lwqQt6vt912W4U+Z1VFHst+++2n6pp58+aZ517+AgAAFIckJgAANeTbb79V559/vmrTpo1KS0tTrVu3Vuedd565vTrs3LlTjR071iRMMjIyVJMmTdSBBx6orr76arV27dpqOYfaRhJikoiJXOrXr6/22GMP9Ze//EVNmTJF5eXlFbmPJJxl2wYNGqjdu3cXWf/TTz9F9+dMEEeSPpGLvIdatGhhkmB33323+u2336r88UbOPXKRx3DAAQeoiRMnFvtYK+q7774zz21NJhcrY9asWap///7mM5aenq722msvNWrUKLV58+aaPjUAAICkEazpEwAAoC569dVX1TnnnKMaN26shg8frjp27GgSNE8//bR6+eWX1YsvvqhOO+20Kjt+QUGBOuaYY9TSpUvV0KFD1d/+9jeT1JQE6r/+9S9zbEmqomIee+wxlZmZaRJ5a9asUXPmzFEXX3yxmjRpkklotWvXzrV9MBhUOTk56t///rc666yzXOteeOEFk/jKzc0t9lhXXXWVOuyww1QoFDKJywULFpjk9AMPPKBmzJihjj/++Cp9GSV5+s9//tNc37p1q3rllVdMgu6zzz4z7+NEJTHHjRtnErTS09jpnXfeUTaT50KSupLcvfHGG81n/ssvv1QPP/yweX7+97//qa5du9b0aQIAAFiPJCYAANVs+fLl6oILLlCdOnVSH3zwgWrWrFl0nfSC7NWrl1m/ePFis01VeP3119VXX31lEmTnnnuua50ky/Lz86vkuHXF4MGDVdOmTaPLY8aMMc/1hRdeqM4880z18ccfF0kE9uzZU02fPr1IElOSygMGDDDJweLI+0WO5/T111+rfv36qTPOOMMkAFu1aqWqiiRgpUdxxJVXXql69OihXnrpJZNIrUwyXN6LqampcbcpbX1NktdTEphnn322ef0DgYCrF+txxx1n3g+S1JTn0SaR597vZ+AWAACwA60SAACq2X333Wd63T355JOuBKaQxNcTTzyhdu3ape699964+9FaqzvvvFO1bdvWDFuWhEhZh6JLIlVI4sxLev3JsODSag5KEsbbKy7iwQcfVO3bt1f16tVTvXv3Vt98841r/fr169VFF11kzl0SeJJkGzRokGu4sOz7lFNOMT3tZJi7nNe+++5rerE6/f7776a3W/fu3U3vRzn3k046ySTyikvMyLBkGc4r+5Pjnn766dHnQ4TDYdNjslu3bmYbGaJ92WWXqS1btqjKkFIBl1xyifrkk0/Uf//73yLrJZn89ttvm96MEdKbUYaTexPNpZFef/IYZF/S489JeoZK719JLspzL72Ar7jiioQlriXpFXm/yOtZ1tcnMjxeeif+3//9nymzIO/rhx56yCT6hLzHI0PXI7UTve9PeRySND7kkENUdna2KZUgid65c+eW+7FIL2X5TErPZS9JEpfWg1J6jzZq1Mh81p0JTHH44YebnplLliwxva+9vvjiC3XUUUeZz5C8Ro8//niRbSZPnmzep/I8yXEOPfRQk/T2vt7SC1jex/J6y/bPPPNMmZ57Sa7K7dOmTStybOldLOukZ3F5jiV+/fVXdeqpp5rXpnnz5uraa69NaPkBAABQO5HEBACgmsmQYUnQSWKlODLMW9a/9dZbcfcjiZpbb73VJKwkMSq9NiWxIgnQ0kiCUTz77LMmGZpIsk9JPI0cOVLdfPPNJoEpQ5o3bNgQ3UZ6CL722msmkfnoo4+aIdE7duxQq1evdu1LEnjSi02SXuPHjze91SSh5UwCrlixwvQslYSn9Py74YYbTGJIkqfO2p4y3Fq2kcSSJLikh5z0fN22bZsrySoJS9mHJHj/8Y9/mHOUXnQnnnhiscms8pAetiUNgZZkqiSFnElaSUjtvffe6uCDDy73saR3piTAnMeS50OSZ5KskudVXic5p/fff98k1hMlkhSWGpBlfX0i7rjjDvPel8Sn1PaU97S8P8Qtt9yinnvuOXPZZ599ij329u3bzfB2SWxOmDDBJK1lmL28fosWLSrX45DnRupWSsLOm4R/7733XD1QveS9+8MPP5jkvPNHASfpmSuciUAhCfOTTz7ZvE/lxwxJ9kui2ZkQfOqpp8zzIol9SVjL+1qS/ZIkj5DP3BFHHKHeffdd9de//tW8n7t06WKS2HKf0p572bfEFSlL4CU9bSVxKs9reY4ldV/79OljnlPZ7u9//7uaP3++Gj16dInPJQAAgKEBAEC12bp1q2QM9aBBg+JuN3DgQLPd9u3bzfKUKVPM8sqVK83yxo0bdWpqqh4wYIAOh8PR+91yyy1mu6FDh8bdf05Oju7atavZtn379nrYsGH66aef1hs2bCiybe/evc3FS44h942Qc5P91atXT//666/R2z/55BNz+7XXXmuWt2zZYpbvu+++uOco+5btXnnlleht27Zt061atdIHHXRQ9Lbc3FwdCoVc95VzSUtL07fffnv0tmeeecbs74EHHihyrMhzOH/+fLPNCy+84Fo/e/bsYm/3Gjt2rNnut99+K3Z95LGfdtpprucxIyPDXB88eLDu06ePuS6PqWXLlnrcuHHR59b5nM2dO9fcNnPmzBLP54ADDtCNGjWKLl944YXa7/frzz77rMTnoDwi5y6PVy7Lli3Td999t/b5fHr//fcv1+sTeTydOnUy708neYyyTrYp7f1ZWFio8/LyijzvLVq00BdffLHrdtmnvGYR3s+ZnHfbtm312Wef7bqfvIfkMa5YsaLE5+b11183+3rwwQd1PA0aNNAHH3yw6/HI/SZOnBi9TR7PgQceqJs3b67z8/PNbRJDunXrFnffw4cPN5+XTZs2uW4fMmSIzs7Ojj7P8Z77m2++WaekpOjff//ddT4NGzZ0PZ9lPdakSZPMsWbMmBHdZteuXbpLly4lvsYAAACCnpgAAFQj6W0osrKy4m4XWS+9yoojvZ1k2KxMyCO99yKuueaaMp2H9NCTHlvSK05MnTrV9JiS4dWyz8oM7ZRhojIcNUJ6/kmNxP/85z/RY0utPRnCWtoQbRny7JzgSHq0Se81qecpveGEDFuN1O2T3pbSc06GLctQXxkOGyE1JWVosDw+r8hzOHPmTDME+YQTTlCbNm2KXqRHnOyzIkOSnWQfzveBlwwbl+cl0tNP/pZ3KLn3eJFjyTB56REpM6XLsGMv5/uoPKTnr5RFkIv0vJPekkceeaTpaVue18c5hFveIxUlw7YjdTLlMctw9sLCQvOYiztePHLeUgbgzTffdL1m0jNXhnrLMO9EfNa9n3PpcSw9giPk8cjyxo0bzTBz0bBhQzMsW0oOFEdytPKel9dbrjvfz9J7Unoge5+P4p576bErPZCdPYSld6+UKpB15T2WxAGJM846rjJ0/dJLL437PAEAAJDEBACgGkUSGiUlscqaAFm1apX5u+eee7pul0SSDPEsC0nWyVBVqVsYmRldEktSQ1GGlVaU95yE1KCM1LuUpJYM85X6j1I7T4bPy3lEkpJOkhTzJtdkXyKyP0lUSQ1OOa7sWxKV8jzIxEiSPHEOcZbHF28CFRkCLPeROn2RxFzkIrO3SxKpMmQf8V5XGUIs62SoriTKZNZxeQ4qc7zIsWRItSTL9ttvP5VIUjdUhvfLRSaq+uWXX9RHH30UnZSqrK9PRLzEYFlJDcf999/fnJsMaZfjyTDp4o5XGkmayxDoSFJWhohLIjFSGiARn3Xv+0GS91IvMt77XuppSjJYfiSQ51bKN8jzHiGvtyQaI7V3nRcpkSC87+finnspVyElDeQ9GSHX5XWUMhHlPZbEruI+18zQDgAASmPXNIgAANRykjiUXkiSwIlH1ktvxpJq6SWa1MiUCTmk16MknySBJpMGCUk2FFc3U3rVVZT0GJVeW9IzUGrjSW1PqXkpvQ8POuigcu1LavfJ/eX8JfnauHFj04NOjiEJtPKQ7SWBKY+/ON6JmMorUnuzpMSkJPmkNqYk4aSWpNRzrCjpPffjjz8mPGlZXM/Hvn37Juz1qUwvTPH888+bSaekR7D0NJbXU85R3l/OCZzKSupCSk9c2a8kNOWv9Iz0ziLvFanZGe+zLgk9SSzLMcpL9i8JVamnOXv2bNMTUurLSq1cqY8ZeW6lbqf0sCyOJHrL8txLj8u77rrL9KyUhKv0TD3nnHOiPwhU5FgAAADlRRITAIBqJhOcyKQcH374oTr66KOLrJdJLqS3lXM4aUkT80jPwUiPt0iPqMrMoi29ODt37uya6EZuk4RaSb1BveScvCSZ5p3JXI5z/fXXm4vcRyYlkcl2JEkUsWzZMpNAdfbakn2JyP5kZmeZtVp6kjpJzzDpLeY8ngyhl+ReSkpKsecu28hQfZnUp7LJtOLIhDQiMhlKcWT4uEzgIom+IUOGVPhY8rxID8LIsSQBK0lx70zxVa2sr0885RnqLseTz4QMf3beb+zYsaqiJHl53XXXqXXr1pnJlgYMGFBqj2fpOSkXSdTLJDfF9b6VSbAiMcFJJjySYfrO3pje972Q9ZJglIuUl5AEuCQbZUIteb3lmPJjQ7wkc1nI/iUxKolS6T0tiVfne7M8x5LYJe9B7+daErIAAADxMJwcAIBqJr3DJEEmSUqpD+gk9fsuv/xyUyMuUq+yOJIokETc5MmTXb0ki5txuDhff/216VVVXGLyu+++cw3tlMTe0qVLTYLUeX/n0FUnSdqsWbMmuvzpp5+a5KHMMC5kFuzc3FzXfeQYkgTx1uKUZE5kGK+Q5IkkfiTh2bJlS3Ob9LLz9hSV2pbOc4jMiC6PWYbLe0XuL73rJBFT3HB6qasoibeKkuSXzJot9SJlduaSSMJPji/nGXmM5SWvj/R0lESbDDMWkhSV3on//ve/1eeff17kPomepT6irK9PPJFkXlmefzmecB5T3n8LFy5UFSW9DiXhJrPZS0I/3qzkTtIrUn5UkM+0t+eyDEmXsgrSU1bem9732hNPPBFdlgSlLEuyUHqFCm/skN6h0qNTHrck6uV5kP1K4rG4xLXz81yWXp/du3c3w8jlIr3JpQxERHmOJSUT5HMtyeYIiQkyFB0AACAeemICAFDNpH6dDBeWCUMkMSAT6kgtukhdSkm0TZ8+3ST2SiLJjFGjRpkhstKLSxIDMtmN1JksS+82qV8oPdMGDhyojjjiCFNbT5Iz0gNQEonOYcwyDPiBBx4wPfrkXKW23eOPP666detW7MRDMlRaepheccUVZl+SWJW6hKNHj472KJMkniQMJekiQ1IlUblhw4YiPQ+lJ5scUyYvkR5gcn6y3ZQpU6LbyOO//fbbTe09mWxlyZIlZji4s4dqpDedJEClR50kVnv16mV6u0nPyyuvvFINGjRI9e7d2ySX5XldtGiR6tevn0kWS09RSbxJjzrnhCQlkQSNPKeSfJJknQyZl6Sv1BeU/cQjycb/+7//U2UlPXclKRyZNEeOI8N9pXSBPK/ORKgM7ZZJWeRxykQqkpyS3oVyTtIzWCaLcfb2i9RfrIyyvj7xSNJaEmWS9JO6ljLsXuoxylDx4o4nvTClNIL0mFy5cqV5v8p7LVKTtLzk89a/f3/zPMlzJPstC/mMy3tX3jfy44AsS2JZJrmR97J8LuS94u0ZLDUx5bHK8y+fAUkcyvtREn2RbeW9Ka+t9BqWz8b3339vEt9ybpFen/fcc4+ZjEom1hoxYoR5DuSHEjm+vO/lenl6Y0pSVuqMymcyMllTRFmPJevkPOXzKIlcSYhKD2X54QYAACAuJmkHAKBmLF68WJ9zzjm6VatWOiUlRbds2dIsL1mypMi2U6ZMkW5leuXKldHbQqGQHjdunLl/vXr19LHHHqu/+eYb3b59ez106NC4x16xYoUeM2aMPuKII3Tz5s11MBjUzZo10wMGDNDvvfdeke2ff/553alTJ52amqoPPPBAPWfOHHMMOVaEnJuc43333acnTpyo27Vrp9PS0nSvXr30119/Hd1u06ZNeuTIkXrvvffWGRkZOjs7W/fo0UPPmDHDdUzZt5yPHGv//fc3+5L7zJw507Vdbm6uvv7666PPQ8+ePfXChQt17969zcUpJydH//3vf9cdO3aMPueDBw/Wy5cvd2335JNP6kMOOcTsLysrS3fv3l2PHj1ar127Nu7zOnbsWPMcRC7p6em6bdu2+pRTTtHPPPOMOVcveR7leYjH+dxGzJ0713UseTzyGh5zzDH6rrvu0hs3bix2X6tWrdIXXnih2VaeU3ld5fXIy8uLbtO0aVPz3ihNWc69rK9P5PF4X9+Ip556ypxrIBAw28n2wrufcDis7777bvP+kcd30EEH6VmzZhV5vwrZj7xm8T5nEfL+lHWXXnqpLq/XX39dn3DCCbpRo0bmnLp06WKek99++63ItvJYunXrpj///HN95JFHmveQnPfDDz/s2u6JJ54wr3WTJk3MPjt37qxvuOEGvW3bNtd2GzZsMK+vfB4j7/k+ffqY93hZn3vx008/Rd9rH374YbHblOVYkffgwIEDdf369c177eqrr9azZ892va4AAABePvknfpoTAACg+klvQBlqKxOXoPpIj0HpZSvPe1l7HNYFb7zxhhmOLzOwSy9eAAAAVC9qYgIAACBKhgRL3U4SmG4yGZcMgS9uMi4AAABUPWpiAgAAIEomAopMBgSlXnzxRbV48WL11ltvmdqW5ZkpHQAAAIlDEhMAAACIMzO5TNIkk9nIBFAAAACoGdTEBAAAAAAAAGA1amICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAqGEzZsxQjRs3Vjt37kzI/jp06KCGDRumEmn27NkqMzNT/fbbbwndLwC7/Pzzz8rn86mpU6eWaXviF4CySnS8qGuOOOIINXr06Jo+DSDp1XRbp645IsGxiyQmgKS1ZMkSNXjwYNW+fXuVnp6u2rRpo0444QQ1efJk13Z33323ev311yt8nO+++07ddttt5j+8RAuFQmrs2LHqb3/7m0kSOhORp5xyiqpujz76aLH/offv31916dJFjR8/vtrPCbDV8uXL1WWXXaY6depkYlCDBg1Uz5491T/+8Q+1e/fuKjtuVcak8iB+AdWjNrd38vPzTcw86KCDTAxt2LCh6tatm7r00kvV0qVLVW3xn//8xzy3lXHjjTeqRx55RK1fvz5h5wWUhrYOses222KXBoAk9NFHH+nU1FTdpUsXfccdd+innnpKjxkzRvfr10937tzZtW1GRoYeOnRohY81c+ZMLeFy7ty5OtFee+017fP59K+//uq6vX379nrAgAEV2mdubq7Oz8+v0H27deume/fuXey6Rx99VNevX19v3769QvsGapNZs2bpevXq6YYNG+qrrrpKP/nkk/rhhx/WQ4YM0SkpKXrEiBFVduyqjEkrV640+54yZUqp2xK/gKpX29s7p5xyig4EAvr888/XjzzyiJ40aZK+/PLLddu2bcsUh5LFyJEjzXNbGaFQSLds2VLfeuutCTsvIB7aOsSukRbGrmBiUqEAUL3uuusulZ2drT777DPzq73Txo0bk+blmDJlium5Jb0qEiUtLU1VhTPOOMP0oJg5c6a6+OKLq+QYQDJYuXKlGjJkiOkV9d5776lWrVpF140cOVItW7ZMvfXWW8oGWmuVm5ur6tWrl/B9E7+Aqleb2zvymGbNmmUe4y233OLa/uGHH1Zbt25Vttq1a5fKyMio1mP6/X7TI/fZZ59V48aNM8NhgapCW+cPxC77YhfDyQEk7dAGGW7kbdCL5s2bR69LkJSG5rRp08x1uUTqRa5atUpdeeWVqmvXruYLfpMmTdSZZ57pGkYlQ6vlNnHcccdF9zFv3rzoNm+//bbq1auXacxmZWWpAQMGqG+//bbUxyCJBak12bdv3zI9Znkc119/vWrXrp1JVMp533///SZJEa8mpjwGOeePPvpIXXfddapZs2bmXE877TRXjUu5n5z3+++/H32cxx57rOt53X///dUbb7xRpvMFaqt7773X1EV6+umnXQnMCCm9cPXVV0eXCwsL1R133KE6d+5sPrvyWZMv7Hl5ea77RcpIfPjhh+rwww83w0ZlqLo0+soakyL7mDNnjjr00ENNbHviiSfMuhUrVpj7Sl2n+vXrmxpFFU22Er+A6lGb2zvy2IQkN70CgYA5T6c1a9aYH1FbtGhhYqk8L88884xrGzlfOe+XXnrJxNmWLVua8x04cKD65ZdfXNvOnz/fPOY99tjD7E/aV9dee22RciDyPMoQeDnfk08+2Tz28847r8z7kPvLUMrI6xS5RITDYTVp0iTzeCTuy+OTUiVbtmwp8rxIGQF5PRctWlTq8w5UBm0dYtcwS2MXPTEBJCXpAbVw4UL1zTffqP3226/E7Z577jl1ySWXmISA1FcSkkiI9ABYsGCB6VHVtm1b05h/7LHHTOJO6kLJl/xjjjlGXXXVVeqhhx4yjeF99tnH3DfyV/Y/dOhQdeKJJ6oJEyaonJwcs4+jjz5affXVVyahUJIvvvjC1II6+OCDS328kqiUBvjcuXPV8OHD1YEHHmiSFDfccINp1D/44IOl7kN6UTZq1MjUpJLHKv/p/PWvfzUNfSHLkVpVf//7381t8p+R0yGHHFKpeltAbfDvf//bJBePOuqoMm0vMUgSC/IrtPwQ8cknn5j6st9//7167bXXXNtKL07ZTj7nElvkC7o0IuWzJ43E0mKS+OGHH9Q555xjGpIjRowwiYsNGzaY85UYJfeX5ICck8SVl19+2fyoUR7EL6B61Ob2jjw28cILL5hEZjBY8ldTiWHyw4t8gZa2i/wgK0lViZXbt29X11xzjWt76d0p20otNumxKm0cSaLKF+hIz3QZWSKP44orrjAx8dNPPzV1Rn/99Vezzkl+jJLHLo9XfkCW56ys+5BYvHbtWvXf//7XPI9esl6SyBdddJF5DaQHnPREledVfoBOSUmJbiv/Fwi5XeqIAlWFtg6x6zJbY1dCBqUDQDV75513TA0luRx55JF69OjRes6cOcXWgiypRlROTk6R2xYuXGjqfjz77LOl1ojasWOHqYfnrX23fv16nZ2dXWpNvH/+859mv0uWLCmyzlsT8/XXXzfb3nnnna7tBg8ebGpMLVu2zHVf5+OVmlJy3759++pwOBy9/dprrzXP39atW8tUE1PcfffdZl8bNmyI+9iA2mrbtm3mMzBo0KAybb9o0SKz/SWXXOK6fdSoUeb29957z/XZlds++OCD6G0bN27UaWlp+vrrry9T3brIPmbPnu26/ZprrjG3z58/3xXDOnbsqDt06GDqFZWnJibxC6getbm9I20SaXPIuhYtWuhzzjnH1MVctWpVkX0MHz5ct2rVSm/atMl1u9QhlnOIPEY5d9lfmzZtXDW8Z8yYYW7/xz/+Efd5GT9+vGlXOc9BnlO570033VRk+7Luo6S6chKT5fYXXnjBdbvE8OJuF1Ij9YorrihyO5AotHX+QOzSVsYuhpMDSErSJV16Jkgvoq+//toMeZBfyKXW0ptvvlmmfThrxBUUFKjNmzebYaAyZOvLL78s9f7yq5TUa5IeT5s2bYpeZAhUjx49TK/JeOR4QnpHlmVWS9mv/MrlJL26pJem9EYojfTMcA4BkCFhMluodO0vq8i5yuME6iLp8SNkOGFZyGdXSCkH72dXeIdz77vvvuazGSG9jaQnpQwFL6uOHTuaeOg9D+mhJb2IIqTXtcQF6ZUlvbHKg/gFVI/a3N6RNomMKrnzzjvNuunTp5u6wtJD8+yzz47WxJR2ziuvvKL+8pe/mOvOc5DnYtu2bUUex4UXXuiK09LDXcp/RGKy93mRofiyP+mxLseQnkRe0tvSq7z78JLemlLzVF5n5+OSXksSo4t7buW5oh2GqkRb5w/ELjtjF8PJASStww47TL366qtmiJI07GVYpgyrloaqDBeSZEA8Uq9IhnRKwWYZku2sLSkN4tL89NNP5u/xxx9f7PoGDRqU6XF4a1oWRxKNrVu3LpI4iQzzKksiUuo1OUW+TBRXt6S0c6WYPOqqyOd6x44dZdpePptS0FwSBk5Sp00SCN7PrvdzGvmsludzKknM4s5Dkg1ezhgSb6hqSYhfQNWrze0dqSMpJWzksm7dOlOX+x//+IeaMWOGGYr4/PPPm/rdktB88sknzaU43kmO9txzT9eytFskDjvrgK5evVqNGTPGJIO9Mdb7vMhQdxmK71WefZT03Mp2zvqm8R5X5HmkHYaqRFun6GfOi9j1U43FLpKYAJJeamqqaeDLZa+99jJ1OeTXIan9GI/Uf5QGvdRROvLII82vSRJYpWaUFCouTWQbqREiCQmveLWdRKRgvTR6i2sYJ5r0mKhoEiIi0kBv2rRpws4LSLaGvfygIPXpyqOsjbZEfE6rYiZyL+IXUP1qe3tHekrKOZ1xxhmmBrAkMqXeWuT4559/vqnLWRyZeLA8ZCSK9CD6/fffTd3Mvffe20wAJEleqUPsfV4kYSE/SFVmH8WRbSQJIHVBiyO98b0koUs7DFWJts4fiF12xi6SmABqFZmNV8iv+aUlD2QyC2kMT5w40TWDZmT4Umn3jxTMlwBe1hnGnaSxK6QIcvfu3eNuK0Or3n33XdP7y9kbc+nSpdH1iVBaokXOVf7zKe4/JqCukNm/pTeQDPGUhEA88tmUhp70tnFOviOTVEisqchntyK/YstxZMIfr4rGEOIXULNqa3tHSA9MSUpK3JShh9LmkLaPJA3LevxI71HnD0EycVok2blkyRL1448/mgnOZOi5c+h8WZVnH/GeW2nfycRGZfkBShKk0iPX+f8JUBVo6xC7bI1d1MQEkJSkzkZxPZMitY6khlyE/CrubahHejx59yEzSkoj2UnuL7z7kDpM8kvl3XffbWpMecnwp3ikZoj0qvj8889VaU4++WRzXjLjm5MMJ5P/XE466SSVCCU9V84ZRktL2gC13ejRo81nRWYClmSk1/Lly81wyMhnV8jMuE4PPPCA+TtgwIByH7+kmBSPnIfMmiuJV2f9NknGyqzCpQ1H9SJ+AdWjNrd3JNEow7G95PgSq6SUhiQw5fyld6bUxSyuF3xxx3/22WddZT8kkSsJ30h7KdLr3fm8yPVI7C6L8uyjpOf2rLPOMq/DHXfcUeQ+MiO6d3tphwmpuwlUJdo6xC5bYxc9MQEkJRkalZOTo0477TTzC7/8srNgwQL10ksvmS/kMsTK2XiWX4okaSDDQKVenNSGk18YZWiUDKuSL/DSYJbtIkMHIg488EDTUJ0wYYKp/SFDiqQulPRIeOyxx9QFF1ygDj74YDMEShrb0iCXyTrklylv0tEpPT1d9evXzxzz9ttvj/t4pZj9cccdZ2pGST2nAw44QL3zzjvqjTfeMMPDIr0kKkueK3lMUmRfakfJY4zUwJLaJosXLzZF94G6TD5v//rXv8zEE/KLsvTAkXqSkTgkwztlKKGQz6r0gJJkoTToevfubZKJ0nPn1FNPNZ/r8ooXk0py0003mUkz5Au8TBDWuHFjcw7SM0oSA95hkqUhfgHVoza3d6S+57nnnmvikkxoJnFJeutIbFq7dq358SeSKLznnntMQlcez4gRI8zjkGHcMqGP7FeuO8m+ZCIzeX7kxybZl7Rr5L5CnkuJ5aNGjTLHlCStxMLy1B8uzz7ktRESfyUpLI9Lnkf5P+Gyyy4zNUulvqk8T9ITVRK88n+JJESl9qmzl6fUTj7ooIPKfJ5ARdDWIXZZG7sqPb85ANSAt99+W1988cV677331pmZmTo1NVV36dJF/+1vf9MbNmxwbbt06VJ9zDHH6Hr16slP5Xro0KHm9i1btuiLLrpIN23a1OzjxBNPNNu2b98+uk3EU089pTt16qQDgYDZx9y5c6Pr5LrcNzs7W6enp+vOnTvrYcOG6c8//7zUx/Hqq69qn8+nV69e7bp9jz320AMHDnTdtmPHDn3ttdfq1q1b65SUFL3nnnvq++67T4fDYdd23vOfMmWKOefPPvvMtZ2ct/exrF+/Xg8YMEBnZWWZdb17946ue+yxx3T9+vX19u3bS31cQF3w448/6hEjRugOHTqYGCSfm549e+rJkyfr3Nzc6HYFBQV63LhxumPHjuaz265dO33zzTe7tol8duXz5yWfQ+dnMV5MKmkfYvny5Xrw4MG6YcOGJlYdfvjhetasWa5tVq5cafYncaM0xC+g6tXm9o6c/z333GPiW6tWrXQwGNSNGjXSxx9/vH755ZeL7EO2HzlypImhEktbtmyp+/Tpo5988knXOcp5T58+3cTZ5s2bm+dD4uKqVatc+/vuu+903759zXMiz43E86+//rpIDJTnKCMjo9jHVdZ9FBYWmtesWbNm5nnwfg2Xx3DIIYeYc5X/S7p3765Hjx6t165dG90mFAqZ5+n//u//Sn2+gUShrUPs+ptlscsn/1Q+FQoAqAjphi+9CaRLvrM7vvQgkGGm0nPCFvLL2bHHHmuGsAMA8QtAZeNFos2bN8/0cJeeQM5eQLXB66+/bnquSskSmQQJQNUjdtkXu6iJCQA1SLrky9CqRx55RO3cudPcJgFehiKVt0ZdVZo9e7YZHnDzzTfX9KkAsATxC0Bl4gXKR4b5//WvfyWBCVQjYpd9sYuemABgiRUrVphC/VJ3SmbQlFmDpZ4VANiO+AXABrW5JyaA2ovYVXb0xAQAS3zwwQfquuuuMzN4yoQ9JDABJAviFwAAAKoaPTEBAAAAAAAAWI2emAAAAAAAAACsVquTmFOnTlU+n0/9/PPPNX0qAAAAAAAAAGpzEjOSjPz888+r7Zjfffeduu2220iAAiiXp59+Wu2zzz4qPT1d7bnnnmry5Mllut+wYcNMnCvpsmbNmui2xx57bLHb9O/fn1cLQI3FJqetW7eq5s2bm21efvllXhUACY9P4osvvjDtnwYNGqisrCzVr18/tWjRoiLbhcNh9fjjj6sDDzxQZWZmqhYtWqiTTjpJLViwgFcGgHUxCyULqlrsggsuUEOGDFFpaWkVSmKOGzfOJAs6dOhQJecHoHZ54okn1OWXX67OOOMMM0HP/Pnz1VVXXaVycnLUjTfeGPe+l112merbt6/rNq212Z/EoDZt2rjWtW3bVo0fP951W+vWrRP4aADUFtUZmyLGjBlj9g8AVRWfvvzyS3X00Uerdu3aqbFjx5pE5aOPPqp69+6tPv30U9W1a9fotjfccIN64IEH1Pnnn6+uvPJK80OLHFu2/eijj9Thhx/OCwXAmpiFOHQSmDJlipZT/eyzz6rtmDNnzjTHnDt3brUdE0DyysnJ0U2aNNEDBgxw3X7eeefpjIwM/fvvv5d7n/Pnzzdx6K677nLd3rt3b92tW7dKnzOA2q86Y1PEkiVLdDAY1LfffrvZTtpUAJDo+HTyySfrRo0a6U2bNkVvW7t2rc7MzNSnn3569LaCggJdr149PXjwYNf9V6xYYWLUVVddxYsDwJqYhfiSYjh5cd577z3Vq1cvlZGRoRo2bKgGDRqkvv/++1JrYkqvgVNOOUV9+OGH5hc36QLcqVMn9eyzz7rud+aZZ5rrxx13XHTI1Lx586rxEQJIJnPnzlWbN282v+47jRw5Uu3atUu99dZb5d7nv/71LxN7zj333GLXFxYWqp07d1b4nAHUfjURm66++mp12mmnmXYaAFRVfJIeUNJTvEmTJtHbWrVqZXo1zZo1K9pGKigoULt37zZDyJ2k5IXf71f16tXjRQJgTcxCfEmZxHz33XfViSeeqDZu3GjqVko3Xqln0rNnzzLVsFy2bJkaPHiwOuGEE9TEiRNVo0aNTM2nb7/91qw/5phjTJdgccstt6jnnnvOXKTuAQAU56uvvjJ/Dz30UNfthxxyiGkgR9aXlTS4Z8yYoY466qhiS1r8+OOP5kccqaXSsmVLdeutt5r7AEBNxqaZM2eaNtm9997LCwGgSuNTXl5esQnI+vXrq/z8fPXNN9+YZdmmR48epqPKCy+8oFavXq0WL15svv/J98BLL72UVwqANTELtbAmptQ0ady4sVq4cKH5K0499VR10EEHmdoC06ZNi3v/H374QX3wwQfRHgJnnXWWqUswZcoUdf/995uembLuoYceMolOqYsJAPGsW7dOBQIB86u+U2pqqvm1be3ateV6AufMmWN+6TvvvPOKrOvcubPpJd69e3fzq59MmnHnnXeaxOZLL73ECwWgRmKT9HQaNWqUuvbaa02Csyw/LAOouyobn6R+3Mcff6xCoZDZj5BEwCeffGKuOycee/7559XZZ59tamJGyHc+qYcpfwHAppiFWtQTU944MnuT/HIWSWCK/fff3yQc//Of/5S6j3333dc1xKlZs2bmDbVixYoqO28AtZt8eZf/wIojZStkfXmHa6akpJgfWYqbEU9+sDn99NPNBGZvvPGGGjFihOkdJf8xAkBNxKZ77rnH9NSUUSwAUNXxSYZ0yg+4w4cPN5OySi+mCy+80HxfjOw/QkaudOvWzQz7fPXVV81kGlKWRzrCbNq0iRcLgFUxC7Uoiblq1Srzt7iZm2S4t/wnJD2T4tljjz2K3CZDCbZs2ZLAMwVQl8jQAPklrTi5ubnlqrck9VAkMSllM5w1U+K5/vrro+U2AKC6Y5P0urzvvvvUXXfdpTIzM3kBAFR5fJIZguVHE/lxRRKUMkJl+fLlavTo0WZ9JBZJslLq0GVnZ6uHH37Y1Oy94oorTJtJtpfYBQC2xCzUsiRmIkS67nppLRPUAUD5SVFmGRogtXqd5D86GXrZunXrMu/r9ddfVzk5OcUO1yyJlMQQv//+eznOGkBtV12xacyYMapNmzamBI8kNOWyfv16s+63334zy+FwOAGPCEBtkYj4JD+cbNiwwUyYIXUuP/vss2is2WuvvcxfKSMmPZ4GDhzouu+ee+5pOsHIkHIAsCVmoZYlMdu3bx+ta+m1dOlS1bRpUzPZRWXJrJsAUFYHHnig+fv555+7bpdl+Y8psr4spOi8/BLnbWzHEymHIeUxAKC6Y5NMlCETJ0ptuY4dO5rLOeecEx0+Jcvbt2/nhQGQ8PgkI+qOPvpo06tJSA/Ltm3bqr333tssS8JASPLBS0pgSE9NALAlZqGWJTEl+y1vDpm8Z+vWrdHb5de1d955R5188skJOU4kEeo8BgCU5Pjjjzd1eh977DHX7bIsM84NGDAgepuUvZAfXaRHk5f0WJL/yGSok9zPS5IAMrOdtxe5TOwjZJgnAFR3bJIY9Nprr7kud9xxh1knw6RkORE/MgOoPRIVn5xkgkPp2XTNNdeY2YKdvZtefPFF17Zffvml6Rgjk8MCgC0xC7VwdnKpW3LSSSepI4880hRFlQKokydPNnVObrvttoQcQxKlMux8woQJatu2bSotLc28ab0zUQGAkBoo8oVdCsafeeaZJpkowwRkNkwZNuCciEzqMY0bN07NnTvXDL30/kcmPQJKGkouDW7p3SSXLl26mPgnyQEZCnXppZeqgw8+mBcEQLXHJulR4NWwYUPz97DDDjOTZwBAIuOTDBO//fbbVb9+/UydXpnccMqUKap///7q6quvjt73kEMOMRPASicY+TFYtpeJNOT7o5yDJA8AwJaYhfiSIokZqVUZqWUphZlnz55tZueVGkwyS2bv3r1NwlGGKyVCy5Yt1eOPP67Gjx9vEqUy/EDegCQxAZREhkxKPJo4caJ68803TZ3KBx98sFz/KclwTYkzEudKKqnRq1cvk7iUenPyi53Uc5J4JUlMAKiJ2AQA1R2fpA6vfD+UDi47duww3wOlV/h1112ngkH311yZlOz+++83vTHle6TMMCztKUlIFDdhLADUZMxCyXw6CWazeeihh8ybQmotde7cuaZPBwAAAAAAAEA1SopB91IjQOooRSb1AQAAAAAAAFB3WN1n9ZVXXlHz5s0zQ5guueQSutgCAAAAAAAAdZDVw8mlRoDUCpCZMCdNmsSslgAAAAAAAEAdZHUSEwAAAAAAAACSoiYmAAAAAAAAgLqLJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVqJIn5yCOPqA4dOqj09HTVo0cP9emnn6pkNX78eHXYYYeprKws1bx5c3XqqaeqH374oaZPC0Ati0+33Xab8vl8rsvee+9d06cFoIZj0MyZM00skO27d++u/vOf/yT945o6dWqReCf3A2Cn6m47leX717HHHlskjlx++eVVel4Akq+dpLVWY8aMUa1atVL16tVTffv2VT/99FOljvvUU0+pXr16qUaNGpmL7NO7/bBhw4rEqP79+5f7+aiLqj2J+dJLL6nrrrtOjR07Vn355ZfqgAMOUCeeeKLauHGjSkbvv/++GjlypPr444/Vf//7X1VQUKD69eundu3aVdOnBqCWxadu3bqpdevWRS8ffvhhTZ8SgBqMQQsWLFDnnHOOGj58uPrqq6/MF3m5fPPNN0kfWxs0aOCKd6tWrarWcwZgb9uprN+/RowY4Yoj9957b5WdE4DkbCdJXHjooYfU448/rj755BOVkZFh9pmbm1vh486bN88cd+7cuWrhwoWqXbt2JkatWbPGtZ0kLZ0xavr06Ql7rmo1Xc0OP/xwPXLkyOhyKBTSrVu31uPHj9e1wcaNG7U8re+//35NnwqAWhSfxo4dqw844ICaPg0AFsWgs846Sw8YMMB1W48ePfRll12W1I9rypQpOjs7uxrPEEAyt52K+/7Vu3dvffXVV1fbOQBIvnZSOBzWLVu21Pfdd190/datW3VaWpqePn16hY/rVVhYqLOysvS0adOitw0dOlQPGjSoTPeHW7X2xMzPz1dffPGF6U4b4ff7zbJkqGuDbdu2mb+NGzeu6VMBUMvikwxtaN26terUqZM677zz1OrVq2v6lADUYAyS253bC+kZYEvMqkxs3blzp2rfvr3pvTBo0CD17bffVtMZA0i2tlNJ379eeOEF1bRpU7Xffvupm2++WeXk5FTbOQGwv520cuVKtX79etc22dnZZrh4ZJtExDmJPdJj3BujpMemlMTo2rWruuKKK9TmzZvLtL+6rlqTmJs2bVKhUEi1aNHCdbssy5sn2YXDYXXNNdeonj17mv8sASQP2+OT/GcqdeJmz56tHnvsMfOfrtRa2bFjR02fGoAaikFyu60xqzKPSxrzzzzzjHrjjTfU888/b9pXRx11lPr111+r6awBJEvbqaTvX+eee66JHzKcUxKYzz33nDr//POr5ZwAJEc7KfI33jaJiHM33nij6YjiTITKUPJnn31W/e9//1MTJkwwZTJOOukkcyzEFyxlPcpBarNIfQXq1AFINPlPLWL//fc3SU3ppTRjxgxT5wUAaosjjzzSXCIkgbnPPvuoJ554Qt1xxx01em4AkuP716WXXhq9LpN5yKQdffr0UcuXL1edO3eugTMFUBfdc8896sUXXzS9Lp2TFA4ZMsQVo+T7ncQm2U5iFSzpiSnd+QOBgNqwYYPrdllu2bKlSmZ//etf1axZs8yvfW3btq3p0wFQy+NTw4YN1V577aWWLVtW06cCoIZikNxue8xKRGxNSUlRBx10EPEOsExNt53K8/1LfvwVtJuA5FQV7aTI33jbVCbO3X///SaJ+c4775gkZTxSLkyORYyyLImZmpqqDjnkENNl1jkEQJadv7gnE621+Q/0tddeU++9957q2LFjTZ8SgDoQn6RenPQmkJ4FAOpmDJLbndsLmanXppiViNgqQ6uWLFlCvAMsU1Ntp4p8/1q0aJH5S7sJSE5V0U6S2CGJSOc227dvN7OUR7apaJyTWc9l9IiUAjv00ENLfXxSMkdqYhKjykBXsxdffNHM9jR16lT93Xff6UsvvVQ3bNhQr1+/XiejK664wsygOW/ePL1u3broJScnp6ZPDUAtik/XX3+9iTMrV67UH330ke7bt69u2rSpmZETQN2IQRdccIG+6aabottLLAgGg/r+++/X33//vR47dqxOSUnRS5Ys0cn8uMaNG6fnzJmjly9frr/44gs9ZMgQnZ6err/99tsafBQAbGk7lfb9a9myZfr222/Xn3/+uWk3vfHGG7pTp076mGOO4UUEklhVtJPuuecesw+JE4sXLzYzhnfs2FHv3r27wseVfaampuqXX37ZFaN27Nhh1svfUaNG6YULF5oY9e677+qDDz5Y77nnnjo3N7danstkVu1JTDF58mS9xx57mBdWpqv/+OOPdbKSPHBxlylTptT0qQGoRfHp7LPP1q1atTLn1aZNG7MsjXQAdScG9e7dWw8dOtS1/YwZM/Ree+1ltu/WrZt+6623dLI/rmuuuSa6bYsWLfTJJ5+sv/zyyxo6cwC2tZ1K+/61evVqk7Bs3LixSTx06dJF33DDDXrbtm28mECSS3Q7KRwO61tvvdW0NyRe9OnTR//www+VOm779u2LjVGSRBXyg0u/fv10s2bNTFJVth8xYoQVHWeSgU/+KUuPTQAAAAAAAACo9TUxAQAAAAAAAKC8SGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgtRpLYubl5anbbrvN/K0tauNjAuoa2z/Htp8fgKpTWz//tfVxAXWFLZ9hW84DgD1qIi4Qi6qWT2utVQ3Yvn27ys7OVtu2bVMNGjRQtUFtfExAXWP759j28wNQdWrr57+2Pi6grrDlM2zLeQCwR03EBWJR1WI4OQAAAAAAAACrkcQEAAAAAAAAYLVgTZ+AdLWtLSKPRf6mpqaq9PT0mj4lALUsNjnjTEURn4DkZmt8quzjyc3NZQgokMRqOjYloo1UEtpOQHKrzvhUlbHIqy7GphqriSk1CZo0bKpCqlDVRi1btlQrV66sc28oINn9EZuaqJAKqdqK+AQkJ9pOAGxU22OToO0EJKfaHp9a1sG8U431xPT5fOaNdEy9M1RKWobypaYqlRJUKi1V6ZQUpVICKpwaUFr+pvhVONWvwgGf+RtK8alwilI66DPXdVCpUIpS4YDcpsy6cFApLcvmuv7jb0ArZa6HlS+olT8QUoGUsPIHwio1JaTSgoUqJRBS6cEClRYIqfrBAlUvkG8uGcEClRnIVfX8BSojkKuy/LtVfV++yvTnqgy//M1Xmb6QyvD7VWhnUO116K8qPz+/Tr2ZgNrgj9gUUseknaZSUusrX1qaUhKTUv+4SEzSqUEVlr+R2BT0q3DKH/FI/v4RmyT2/BmrAn/EpEhsMvHpz0s4RSsd0Eqb2KSVLyjxKaz8f15SgmGVllKoUvx/xqZgoaoXLFT1g/kq3V+g6gfyVWYgz8Qp+Vvfn6cyfXkqKxCJUXkqy1+o6vuUyvAFVXhXimp/yM/EJyAJudpO6ZnKJ7EpTdpM0nYKmtikU/1KB6UNJXHpj4uJTRKPUuVvLDaZ6xKfTJvqzxgV+KN1aGJTilZhKTyUEjYxKhKbAuYSMm2n1EBIpQYLVVogEpsKVJq0lYL5KkNikrShJEb5803bKcufp+r58lQDiVX+fFXPF1ZZ/oAq2Bmg7QQke2yStlMkNkm7KS1VqWAkNgVU+M/YJO2nkLSdUp2x6c/4ZOKVu73k/m6n/7z+R4wysUm+2wX+jE8Sl0z7SeLTn7EppcDEp/RAgarvzzdtKPmbEcxV9f0F5vvcH9/p/mxD+aU9FVKZPqXq0XYCakV86p1xpgpGvtulBpUKpiid9md8MvEoYP6GIu0n01b681JMbDJxyNGWkuuR73ORvJNKkb9/5JskNgUieadASKWY73SR2FSo6gXyVGagQKX/2W4y3/FMbMr7Izb5d5t2U4ZPYlZY1fcFTN6py6G/1LnvddTEBAAAAAAAAGC1GuuJKWP3pevrB+tfUWq3qnXkscljBJBcYrHpNaXylFI7VK1DfAKSE20nAEnRdqqFaDsByR2f3l8/U6ldqtZpWQfzTjVWEzNSwF26vtZGdbHAKlBb1ObYJIhPQPKqzfGJ2AQkr9ocmwTxCUhetTk+pdbBvFONJjEBAAAAAAAAwNrh5Cf4z3SfSKcO0euhRhnujcPuxR+urB+9npIVf8yCzxe7nr4wM+622lsh1HFfX68trlV+nzv363Ms5+S6u/P+OHhM3OMCsIc3NgX26hy97iv0zFhe4J7lbkvPtrEFXXI8MYuOuPbRpMdd677Ic/9S2NjvXu6YEotlm0LucREpvpJLHa8tdJ9Utz3WlLgtALtjk9/5q3tAZuOJ0XnutlG/Rb9Hr7dP3RT3OAFHcHrsgtPdK8OewOZ3BzbtWA7d7m43SfF6py259aLXt+6KXRffn3Zb3HMEYHd8Kg9fSjmGQepYfJq9+nPXqgmb93Qt75PubuMMzMiJXv84192eaxZw1zbLd3wpfHvnfq51o/adU/bzBWBt2ymcm1ty4kgpddHSn6PXO6S4205+5xc5aTs5vviN6XWaa50ucLd/VKH7+6OZ4DqynxfdmzZIcZ/jht1Z0eubd8VyYmLRKXequoKJfQAAAAAAAABYjSQmAAAAAAAAAKvV2HBy5/BxUbgi1l3Xv//ernW+As8QTn9s2JHf7x7aFA67uwF717t4VnlGiLuGsYe1e78Bv7sLcSjsL6knMoAk4hw+LkI/Li9xnS9OSQrPKAPlCSFKO0Z/hhzDo4rjXVugYzGxoEhZ45L3FeZ3KyBpuYaPe4ZB+TM8ZXg8w8szA7Fts/zuYZPxhpP7QvHLpmvP8HJfnOHjmSnuIe55oVgTdHdKStzjAMAfQSbW0MrT7hiTE3YPS88Jp3mWt0avbw+7Y2a6zz28M+SIZt79AqgdbSdfWlrckjkNA7ESFNl+dxsm4EkcOYeTa+8w9Xx3rNKe4eTO42YG4w8n31kQO+ec1LrbdqInJgAAAAAAAACrkcQEAAAAAAAAUDuHk69du1Z9+OGHauPGjSocdg9fvOqqq0q9v3cGcucQ8vDipa51gW5d3Xd2DBkvyHc/BF+R4eOxcyusV8ps5HFSuoW57u66BZ6hWs5h7IFA/OFXAKpOZWOTdwZy5xBy59Dy4spiOEtUeIePF5md3HGYQJwZxUWK574pvlj8CXjqV3hnJw87hpv7i0yZDiBp4pOn3eEcQh7etSvu8Kmdodjy1kD9EodAeYeTh4Ol/NZdJM75ih0uLoKeGhu7C2LtqoKQ+7EBSK62U8L4fXGHdzql+dzfzer78z3L7uGf9f2xYeEZRdZ5hpM7GnHe/QJInvjknYHcOYRc57njgLcm4NZQrL3U0B8bWl7a7OQ+TxtMe9pvPs/wcl9aLDbleEaa+z3D1ncVxrbdnV93h5NXKIk5depUddlll6nU1FTVpEkT5XO84HK9Wv+zAwBiEwDL0XYCYCNiEwBbEZ+QsCTmrbfeqsaMGaNuvvlm5fczIh2AHYhNAGxFfAJgI2ITAFsRn1CcCmUgc3Jy1JAhQ0hgArAKsQmArYhPAGxEbAJgK+ITEpbEHD58uJo5c6aqlLD74isIRS9SA9N5CX37g+vilJJa6Lqkei7BYDh68Rco96XQc/Gs9xXGLuGw33UJFQZcF+e6woKA6wKgeiQkNhUUui5SIzNykRqYzkvhip9dFylbErn4Q+6Lz3OJR+qqOC/xhLR2XcKei1NY+VwXAMkTn6R2k+tSWBi9SA1M50VqQDkvUrspckn1hVwXqYHpvPhV7OILuS/+QvfF5704tgVQh9pO1UWHY5cqRFsJqCXxScoeOi9SZzdy8a6T702Oi7PtlOILuS7e72qu722e/biOKRdnHNNhpbWOXpzHLPaidPTi87kvdUmFhpOPHz9enXLKKWr27Nmqe/fuKiXFXVT0gQceSNT5AQCxCUDSo+0EwEbEJgC2Ij4hoUnMOXPmqK5d/5g13DuxDwDUBGITAFsRnwDYiNgEwFbEJyQsiTlx4kT1zDPPqGHDhlXk7gBQJYhNAGxFfAJgI2ITAFsRn5CwJGZaWprq2bOnqowfrqzvvsFfL3Y97O3NeZhraa8Rn0Wv7zqjh2udDrjvG3Y8wr2vWhL3nII+d32VsI7ta1zr2a51Df3upy7Tnx69vrxgp2fPf497XACJkYjYtKVnW9eydlYO9pQb8R3e0rWc9eLH0evBtm3cGwdKLkG8Lbzbtbw1nOFa9nvqnDQO50av73DEKVFgCg3HhBx33Rr2xF0ASROf+i363bWcGYjFgZ2hWBtESN0kp7e7NYxeDzTb073jsLtIry81NXr9qU8ec63L9cSbkGc53XHcE2aOch/H07Rz3tVzugCSrO3kS4nFjfLSBfkVut//drvnHfjo986u5XWZ2a7lDP9X0esLd+3tWtcouMu1HHY0/j707NcT2QBYHJ8uWvqza7lhICd6fWuofty209N7dYxeDzQ62L1jv6dR4xiNPPmLGa5Vu7Q7b5Sr3bEry1cQvX7taSPc2+a646NuGDvn7Cx3SUc1QNUZFZrY5+qrr1aTJ09O/NkAQCUQmwDYivgEwEbEJgC2Ij4hYT0xP/30U/Xee++pWbNmqW7duhWZ2OfVV1+tyG4BoFKITQBsRXwCYCNiEwBbEZ+QsCRmw4YN1emnn64qIyUrz7Xs98fGPBbku08rJbXQtewcQp7xyieudVuGHem+b05sv30bfedalxt2J19TfO7jOLUI1PNs6+4G/EVerKtvuyCTGwE1IRGxqciQccfIAs/IySJDIJ1DyAt/XeNe18o99Nwp4B1nmUCeChsAkjQ+tU/d5FrO8sfKUGwNuIdEpfrcQ8SdQ8hDv/3mXteggWs5vCs21GqPYKZrXZ6ODXky+9K6xLZRONUTTL0csamULQHY3naKxzvs0kIBTymesGOworekD4DkiU8dUtxtp2x/LAfV0B9r74gUb9vJMYQ8tGVL/AM5hpN3CLrbZLu1e0h4jmc50xfLSRVmp7nW+dPdebGCBrFtC7Lc+ai6pEJJzClTpiT+TACgkohNAGxFfAJgI2ITAFsRn5CwmpiisLBQvfvuu+qJJ55QO3bsMLetXbtW7dzpndQGAKoPsQmArYhPAGxEbAJgK+ITEtITc9WqVap///5q9erVKi8vT51wwgkqKytLTZgwwSw//vjjFdktAFQKsQmArYhPAGxEbAJgK+ITEpbElFmiDj30UPX111+rJk2aRG8/7bTT1IgR7mnhyyocjtUR8DnqY3rrZQrtKPLmrYHZaOpC1/L2c46IXt8VdtcYKPBMb5+rU+LWRXAKaXftlBRHcbzNIXftl5Ir4QFIpITEJk/pJlcdzHjrRMBfYg3MwnXrXcvB9u2i10OeinAhz4HCngOFHLWbQkXWuffljFShine+B1BJVdF2igiUVlUyHCqxBmZo+3b3vhpml9jWKbJbTx05ORMAyaUqY5MRrpmakt62Uzy0j4DaGZ/8ngkMAo4at951xdy5IqdcdDee719+5am96ainWeo0Cc5t67AKJTHnz5+vFixYoFJTU123d+jQQa1Z457MAgCqC7EJgK2ITwBsRGwCYCviE4pToW454XBYhUJFeyn++uuvZlg5ANQEYhMAWxGfANiI2ATAVsQnJCyJ2a9fPzVp0qToss/nMxP6jB07Vp188skV2SUAVBqxCYCtiE8AbERsAmAr4hMSNpx84sSJ6sQTT1T77ruvys3NVeeee6766aefVNOmTdX06dPLtA/vcH533ctSajA5zjolR5dYA1M0mP5x9HrGbXmudd5acl7p/oLYcXzuOk87w7mu5R3h2ND6dsGcuPsFUDUSEps84cdZOjdOmdxSOWtgisJVv5S5vp3fUb+lyLaedY6SwX9wrA6UElsB2BufAkXqOoVLXOf3fNZ9jvI/4V05JdbAFKGt2xz7df/WHdbueJPibcuVWszJeVKO6zVTMg9AgtpOyls/1xM74m5bRbWA47Wd/J77Fmkf+cq2HwCWt52KfNZ1mdYZrlqVpbRvHO0jb9sp4GkbBTw5KGfNTF0kSeZedt5VJ6hmZ51JYrZt29YUV33ppZfMX+mFOXz4cHXeeeepevXqJf4sAYDYBCCJ0XYCYCNiEwBbEZ+QsCTmBx98oI466iiTtJRLRGFhoVl3zDHHVGS3AFApxCYAtiI+AbARsQmArYhPKI5Pa8/YoDIIBAJq3bp1qnnz5q7bN2/ebG4rbtIfr+7XPVjiukJPZ07HqG7j0MFLotf7NvrOtW5XOM21nOGPDSF/tqt7OGegaxfXsk5z53T9O2NDxrc96u4WXBh2L+/MjR133+brXetePupx9wMAUCUSEZvC6/d0LYccw568wwO8toV3lzh0IBRn2NNZbY90La8dfZRrOWONe5hT4zk/Ra9vP9Ydx4qMhHDcdVdL9/kveuS6Es8JgF3x6YSj7nAt+0KxD3s46P5s+0LumPHUy49Fr+8RzCwxxnnj3ImtD3TvNyXVvZya4lrWhYXR663ed2+bFXSX4Vm7OzaMfXNuhmvd+33udy0DSK62U56OfXlL87njhNf/dgfKfq6ORs74zvu71gVbtnCfk6d0RnjHjuh1X5r7+6IKxxl6nuH+Yjr793+W+XwB1Gx8OmmPa1zLOjfWFvGlp7s39qTFHlowI3q9Q7B+/POM13YKBkss8SPCubF81WFf5rvWZXvKFP6S27jYdpR4tWesrVfbVWhiH8l7ymQ+XvJmyshwN0QBoLoQmwDYivgEwEbEJgC2Ij6h0sPJTz/9dPNXEpjDhg1TaY5fsSQLvnjxYjPMHACqE7EJgK2ITwBsRGwCYCviExKWxMzOzo5mxLOyslyT+KSmpqojjjhCjRgxojy7BIBKIzYBsBXxCYCNiE0AbEV8QsKSmFOmTDF/O3TooEaNGpXYoeOOEgTaM8hdxymVkht211kp8GwccsxD762BGfphmWs5sO9eruVwlrMGSqxWQXF8vtgD8DuuA6h6iYxNX+S5a5GUtTaT2Bou+bghT41M5329NTBb37vAtbzj7CNcy79c3DV6vdBTosUXK0lnOEOkp6wKgGSKT3Fqtnl5myG5jraQs1Zd8YfRJdbA1AWe+Oipp+ms+7Q75G6fBZ0FepVS+eHYtgWhstfEA2Bf22nCZndNzJxwLHbU98dvV330e+cKHTPY0h3oCtdvcC37s7Jcy4EWjpp63jp63ikiHGXTdDnahQDsik+6wNPmyY8t60Agbjtrl3a0abQ7Dvg9VRmdcyF4a2A664UXf5LhEttO6X738u5QLLY621F1TYVqYo4ePdpVE3PVqlVq0qRJ6p133knkuQFAuRCbANiK+ATARsQmALYiPiFhScxBgwapZ5991lzfunWrOvzww9XEiRPN7Y89VndmRQJgF2ITAFsRnwDYiNgEwFbEJyQsifnll1+qXr16mesvv/yyatmypemNKYnNhx56qCK7BIBKIzYBsBXxCYCNiE0AbEV8QnEqNJA+JyfHTOwjZAi5zB7l9/vNxD6SzCwLb91LV/0mb2rVXUrOVVcpxVMALlenlHzMtGDcGpih7350Lfv331uVVWFhrKaC31MnD0D1SERsauyp3eSs4pbiiUVe8erhhh016bzbZqwJx62BmfXSx65lfW5sfTjg3q/PU9cpHHTUdarQz1YAEqHS8cnv/qxrZ+0mT2zyhBtXffCQN0a4opw7zvlSU+LWwPTWefKlxmo1FYbdAScv7K49le+og+ndFkBytZ32SV/j3mc4LXq9vj/+vALrMv+YOLa8bacfdtWLWwMzvGOHe33YHb/KzFs/E0DyxCdPO8XZbvE56mP+sdIdI3Idc63kFKmJ6Y4LAUescraFilOk7eSoP54Xdse8HEcNzD/Wx84pr5CamOXSpUsX9frrr6tffvlFzZkzR/Xr18/cvnHjRtWgQYPy7QwAEoTYBMBWxCcANiI2AbAV8QnFqdBP32PGjDGzRMlsUT169FBHHnlkNDt+0EEHVWSXAFBpxCYAtiI+AbARsQmArYhPKE6F+qAOHjxYHX300WrdunXqgAMOiN7ep08fddppp1VklwBQacQmALYiPgGwEbEJgK2IT0hYEnPKlClqyJAhZkIfJ5mlvMy8teXilCnx1nby1kdxSvG56xOk+2O1Dvw7c937yaoXtwZmePHS6PW04B7uc/LUIPD7Yw8g6Kd2ClATEhGbOqZkupYLdOzznOJz13Tzahx2xxinUJwg13jOT67lXy7uWmINTNHgX7EambvO6OHemSc8+gtjx93Ruu7WTgGSPT5pT01M15LP+8F3L6e7aol745h72e/Yc5G6TUF3DPHWfQrn5MSOGXCvywy660ntdCznBkuuZw7A/rbTwIzYZ1/khLdGr9f3x68Pl+H/SlXE9zu6u5YDLZrHrYEZ3rUret2XFqvZWSxHzWF/hvv7IoDkiU9F6lM6Ptu+NPc67akZnuWL5ZEyfe52SsDT7vI7BjiHc/Pi1tp01sA0qwti7aEMz1e1zEBeiW2p7UFPTc86pELDyW+66SbVokULNXz4cLVgwYLEnxUAVACxCYCtiE8AbERsAmAr4hMSlsRcs2aNmjZtmtq0aZM69thj1d57760mTJig1q9fX5HdAUBCEJsA2Ir4BMBGxCYAtiI+oTg+7e03W04bNmxQzz//vElqLl26VPXv39/00PzLX/6i/P6Sc6Td3xxT4hDxvFx3d91w2L2feb0mR6+3CMTv4u8cNnX04tNVeaQFY8Oogn1Xu9blnXSYa3nj8N3R66Efslzrfrr5unIdF0DlVTQ2bVzT2rVc4AiR3qEDIU/43BGn1EXIsy7gi9334uvdMWLzfu7hnQ2Wu4+TkhMblpDxyifu/Xbp6Fr2FcTi2O493UOt5r1zU4nnC8Cu+HTce9e7lus5hhHlheKXilj5VZvo9XBq2Zt9vQ//zrW8O+RunxV62mfpgVi8+e2o2HBS4U9Pd+88EItzvswM16rZ6x4p8zkCqPm204KfO7mWt4djn/cMv2dopcfcnfuW+fz8Kha/PjisoXtdlrsckN7tLvHjLI+h8+Kfk2u/9eu7lufsnFbm+wKo2fh0yvy/uZYzg7HPfk6he1i331F6x6y/Ova9qTDbU4LC85VPO74jHvnAp3HbTnlh93KG45wWeebI9radnKm7QCN3DHx77cOqrqhQT0wnGVYuk/zIDOXy5lmyZIkaOnSo6ty5s5o3b15izhIAiE0AagnaTgBsRGwCYCviEyqdxJRM+P3336+6detmhpRv375dzZo1S61cudJ0+z3rrLNMMhMAqhOxCYCtiE8AbERsAmAr4hMSksSULrvt2rVTU6dOVSNGjDBJy+nTp6u+ffua9RkZGer6669Xv/zyS0V2DwAVQmwCYCviEwAbEZsA2Ir4hOLEL6JUgubNm6v333/fDCEvSbNmzUyvzJL4HfXgRMAfq0FQ4KiTJLSnllxDf7DYmpci5JnCfmc4t8TaTaXRhY7jeGpgpr39mWs5//jYc+HrGKuPCaD6JCI2pfi8cSJc4rqwozaTKHBs6xXybBtwhjVPiTpfoWfZW7rYV3INzNAy92MLtmoZvV6Y6Y6XAJInPjlrYIrMlFgNpaCnjlMRJZfrjSsr6K4p5z1OXtgdUzKD+dHrmz11nMK57n0FmjSOnV66p9YUgKRqOzULuL/7pDsaMvX9nkaNR6Pgruj1gKcdFfL0t3GtD2e7d1S5aR5K5qmHDiB54lODlNwSl735KG9NzNzcWJvGn15K2swfixPZwRzXqnS/uwZmTshdizMzEGvP+dMbxW87NXKsr8Ntp3Jl9RYuXGiGjD/99NPRN9Kzzz6rOnbsaN5gl156qcr7s1Cyz+dT7du3r5qzBgBiE4AkQNsJgI2ITQBsRXxCwpKYt99+u/r222+jyzKJj8wIJcPIb7rpJvXvf/9bjR8/vjy7BIBKIzYBsBXxCYCNiE0AbEV8QsKSmIsWLVJ9+vSJLr/44ouqR48e6qmnnlLXXXedeuihh9SMGTPKs0sAqDRiEwBbEZ8A2IjYBMBWxCckrCbmli1bzNT2EVKf4KSTToouH3bYYWWezMfnqUEQctSrDIfdtUe8FU4y/bE6S1/kxWoViBRPLYMd4VjNgZ25aXHPobDQXdvJ76jTqYfvLrEGpuh8w8Lo9TO+3+g54797lgEkUiJjUzzhUuothXQJNS9dlTX/5NjWW84u7C6dosJB9878hbE7+AoKS6yBKQrXrXcs7RHn7AHYHJ+25NZzLeeFYk243QWeoOHhKi1eWnk3x/q1u9015/LD7mZjfsjdbtrpqImpAjkl1sAUoc2/x9aVckoA7G475Wt3v5iQI5CEPHMbhD1BKOy4b7i0/jW+StSuDFewZmZV1doEUOXxacPuLNfyzoJYPmhXobs2pd+TddIN60evFzRIiRtvnGHul1x3e2e3pwZmvHri2hNvXDUwJZ5u2RJb55kLpi4pV09MeSNFiqbm5+erL7/8Uh1xxBHR9Tt27FApKfEb0gCQaMQmALYiPgGwEbEJgK2IT0hYEvPkk082tS/nz5+vbr75ZlW/fn3Vq1ev6PrFixerzp07l2eXAFBpxCYAtiI+AbARsQmArYhPSNhw8jvuuEOdfvrpqnfv3iozM1NNmzZNpabGusc+88wzql+/fmXaV05uaok9cgMBT1deT0/Z5QU7o9fbeYZZbg65l9s5prjft7lzWKVSfs9wcm8X4qA/FL3+yXvd3Ofb0T283DmE/JV9mrvWXV53e/oC1SKRsWltoTsOOIc2eWOEd0jU1nBs2IFXyPObUcAxwHxXS/c6R9gyPKO01I7WsdAd3OmON4WZ3oGZsSHk9V7/tMTzA2B3fNq6yz2cfLdj5EuBZ1i3l7NkRakDIx0bbM7NcK3yHqfQUQpI5AZj51Q/0x0ffenukj6BEoaWA0i+ttPbO/dzLec4ynnV97tLf3l9+HvnEr+beTnX+zPc5XS0p8SYCsW+x/2xfSyG6vxg/KHojiGd4RxPowxA0sSnzbvc381yUmPtlN35KXFLDWZnOdpZWfHbWdofiyGlleLJK3Qvbw8WRK8H3KPHlfK2nRyJsdDWbaquKlcSs2nTpuqDDz5Q27ZtM2+mQMD9Ys6cOdPcDgDVidgEwFbEJwA2IjYBsBXxCQlLYkZkZ7uzyxGNG7uLmAJAdSI2AbAV8QmAjYhNAGxFfEKla2ICAAAAAAAAQHXzae887gAAAAAAAABgEXpiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWrkpi//fabuuKKK9Qee+yh0tLSVMuWLdWJJ56oPvroo0rve9iwYerUU09NyHkCqFuITQBsRXwCYCNiEwAbEZuSX1BZ5IwzzlD5+flq2rRpqlOnTmrDhg3qf//7n9q8eXNNnxqAOozYBMBWxCcANiI2AbARsakW0JbYsmWLltOZN29esesvuugiPWDAANdt+fn5ulmzZvqf//ynWZ45c6beb7/9dHp6um7cuLHu06eP3rlzpx47dqzZt/Myd+5cc5/Vq1frM888U2dnZ+tGjRrpgQMH6pUrV0aPMXToUD1o0CB911136ebNm5vtxo0bpwsKCvSoUaPMfdq0aaOfeeaZKn1+ANQMYhMAWxGfANiI2ATARsSm2sGaJKYkBTMzM/U111yjc3Nzi6z/6KOPdCAQ0GvXro3e9uqrr+qMjAy9Y8cOc3swGNQPPPCASUIuXrxYP/LII2adXM466yzdv39/vW7dOnPJy8szSdB99tlHX3zxxWb77777Tp977rm6a9euZn0kiZmVlaVHjhyply5dqp9++mmTBD3xxBNNYvPHH3/Ud9xxh05JSdG//PJLtT5nAKoesQmArYhPAGxEbAJgI2JT7WBNElO8/PLLpmej9KQ86qij9M0336y//vrr6Pp9991XT5gwIbr8l7/8RQ8bNsxc/+KLL0xy8eeffy5235EelU7PPfecSViGw+HobZK8rFevnp4zZ070fu3bt9ehUCi6jdynV69e0eXCwkKTTJ0+fXpCngcAdiE2AbAV8QmAjYhNAGxEbEp+ftvqE6xdu1a9+eabqn///mrevHnq4IMPVlOnTjXrL7nkEjVlyhRzXeplvv322+riiy82ywcccIDq06eP6t69uzrzzDPVU089pbZs2RL3eF9//bVatmyZysrKUpmZmebSuHFjlZubq5YvXx7drlu3bsrvjz1VLVq0MMeJCAQCqkmTJmrjxo0Jf04A1DxiEwBbEZ8A2IjYBMBGxKbkZ1USU6Snp6sTTjhB3XrrrWrBggVmVvGxY8eadRdeeKFasWKFWrhwoXr++edVx44dVa9evaKJxP/+978msbnvvvuqyZMnq65du6qVK1eWeKydO3eqQw45RC1atMh1+fHHH9W5554b3S4lJcV1P5/PV+xt4XA4wc8GAFsQmwDYivgEwEbEJgA2IjYlN+uSmF6SkNy1a5e5Lr0dTz31VNMbU3pnXnTRRUUSiT179lTjxo1TX331lUpNTVWvvfaaWSfXQ6GQa3vp5fnTTz+p5s2bqy5durgu2dnZ1fgoASQbYhMAWxGfANiI2ATARsSm5GJNEnPz5s3q+OOPNz0sFy9ebHpQzpw5U917771q0KBB0e1kSPm0adPU999/r4YOHRq9/ZNPPlF33323+vzzz9Xq1avVq6++qn777Te1zz77mPUdOnQw+/3hhx/Upk2bVEFBgTrvvPNU06ZNzf7nz59vjilD2K+66ir166+/1sjzAMAuxCYAtiI+AbARsQmAjYhNtUNQWULqUfbo0UM9+OCDph6lJBnbtWunRowYoW655Zbodn379lWtWrUydSpbt24dvb1Bgwbqgw8+UJMmTVLbt29X7du3VxMnTlQnnXSSWS/7kQTloYceaoaRz507Vx177LHmPjfeeKM6/fTT1Y4dO1SbNm1MbU3ZHwAQmwDYivgEwEbEJgA2IjbVDj6Z3UclEUlASqJRhpRL4hEAbEBsAmAr4hMAGxGbANiI2GQ3a3pilkYmzZFh4NK7smHDhmrgwIE1fUoAQGwCYC3aTgBsRGwCYCNiU3JImiSm1LmU2cjbtm1rJvUJBpPm1AHUYsQmALYiPgGwEbEJgI2ITckh6YaTAwAAAAAAAKhbrJmdHAAAAAAAAACKQxITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAAlM3+H37gIyCSF/SnAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import silhouette_score\n", + "A_type = [A_dmd, A_cs, As, As_n4sid]\n", + "B_type = [A_dmd, B_cs, Bs, Bs_n4sid]\n", + "names = ['DMD, Partially Observed', 'DMDc, Partially Observed', 'Old Subspace DMDc, Partially Observed', 'Subspace DMDc, Partially Observed']\n", + "for Ai, Bi, name in zip(A_type, B_type, names):\n", + "\n", + " sims_full, sims_control_joint, sims_state_joint, sims_control_separate, sims_state_separate = compare_systems_full(Ai,Bi)\n", + "\n", + " fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + " \n", + " # Define data and titles for each subplot\n", + " sims_data = [sims_full, sims_state_joint, sims_control_joint, sims_state_separate, sims_control_separate]\n", + " titles = ['Joint', \n", + " f'State (Joint) \\n {np.round(silhouette_score(sims_state_joint,state_labels,metric=\"precomputed\"),2)}',\n", + " f'Control (Joint) \\n {np.round(silhouette_score(sims_control_joint,control_labels,metric=\"precomputed\"),2)}',\n", + " f'State (Separate) \\n {np.round(silhouette_score(sims_state_separate,state_labels,metric=\"precomputed\"),2)}',\n", + " f'Control (Separate) \\n {np.round(silhouette_score(sims_control_separate,control_labels,metric=\"precomputed\"),2)}']\n", + " \n", + " # Loop through all subplots\n", + " for i, (data, title) in enumerate(zip(sims_data, titles)):\n", + " im = ax[i].imshow(data)\n", + " cbar = plt.colorbar(im, ax=ax[i], shrink=0.2, location='top')#, label='Distance')\n", + " cbar.ax.tick_params(labelsize=10)\n", + " cbar.ax.spines['top'].set_visible(False)\n", + " cbar.ax.spines['right'].set_visible(False)\n", + " cbar.ax.spines['bottom'].set_visible(False)\n", + " cbar.ax.spines['left'].set_visible(False)\n", + " ax[i].set_title(title,y=1.8)\n", + " #loop through all of them and remove x and yticks, then add System as text label for each\n", + " for i in range(5):\n", + " ax[i].set_xticks([])\n", + " ax[i].set_yticks([])\n", + " # ax[i].text(0.5, -0.1, 'System', transform=ax[i].transAxes, ha='center', va='top')\n", + " ax[i].set_ylabel('System')\n", + " ax[i].set_xlabel('System')\n", + " ax[i].spines['top'].set_visible(False)\n", + " ax[i].spines['right'].set_visible(False)\n", + " ax[i].spines['bottom'].set_visible(False)\n", + " ax[i].spines['left'].set_visible(False)\n", + " plt.suptitle(name,y=1.1)\n", + " plt.tight_layout()\n", + " # plt.savefig(f'{folder_path}/{name}.eps', format='eps', dpi=300, bbox_inches='tight')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2b529073", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 39.36it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 55.38it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 44.85it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 55.31it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 173.94it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 48.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette Scores:\n", + "DMD State: 0.901\n", + "DMDc State: 0.887\n", + "DMDc Control: 0.064\n", + "SubspaceDMDc State: 0.956\n", + "SubspaceDMDc Control: 0.747\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the similarity matrices for each method\n", + "sims_full_dmd, sims_control_joint_dmd, sims_state_joint_dmd, sims_control_separate_dmd, sims_state_separate_dmd = compare_systems_full(A_dmd, A_dmd)\n", + "sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc = compare_systems_full(A_cs, B_cs)\n", + "sims_full_subdmdc, sims_control_joint_subdmdc, sims_state_joint_subdmdc, sims_control_separate_subdmdc, sims_state_separate_subdmdc = compare_systems_full(As_n4sid, Bs_n4sid)\n", + "\n", + "# Print silhouette scores\n", + "print(\"Silhouette Scores:\")\n", + "print(f\"DMD State: {np.round(silhouette_score(sims_state_separate_dmd, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"DMDc State: {np.round(silhouette_score(sims_state_separate_dmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"DMDc Control: {np.round(silhouette_score(sims_control_joint_dmdc, control_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc State: {np.round(silhouette_score(sims_state_separate_subdmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc Control: {np.round(silhouette_score(sims_control_joint_subdmdc, control_labels, metric='precomputed'), 3)}\")\n", + "\n", + "# Create 2x3 subplot\n", + "fig, axes = plt.subplots(2, 3, figsize=(6, 5))\n", + "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", + "\n", + "# Column headers (bold)\n", + "column_headers = ['DMD', 'DMDc', 'SubspaceDMDc']\n", + "for i, header in enumerate(column_headers):\n", + " axes[0, i].text(0.5, 1.75, header, transform=axes[0, i].transAxes, ha='center', va='bottom', fontweight='bold', fontsize=16)\n", + "\n", + "# Row headers\n", + "row_headers = ['State DSA', ['Not Available', 'Input DSA', 'Input DSA']]\n", + "for i in range(3):\n", + " axes[0, i].text(0.5, 1.55, 'State DSA', transform=axes[0, i].transAxes, ha='center', va='bottom', fontsize=12)\n", + "\n", + "axes[1, 0].text(0.5, 1.55, 'Not Available', transform=axes[1, 0].transAxes, ha='center', va='bottom', fontsize=12)\n", + "axes[1, 1].text(0.5, 1.55, 'Input DSA', transform=axes[1, 1].transAxes, ha='center', va='bottom', fontsize=12)\n", + "axes[1, 2].text(0.5, 1.55, 'Input DSA', transform=axes[1, 2].transAxes, ha='center', va='bottom', fontsize=12)\n", + "\n", + "# Data for each subplot\n", + "data_matrices = [\n", + " sims_state_separate_dmd, # top left\n", + " sims_state_separate_dmdc, # top middle \n", + " sims_state_separate_subdmdc, # top right\n", + " None, # bottom left (gray matrix)\n", + " sims_control_joint_dmdc, # bottom middle\n", + " sims_control_joint_subdmdc # bottom right\n", + "]\n", + "\n", + "# Create gray matrix for bottom left - use same size as other matrices\n", + "matrix_size = sims_state_separate_dmd.shape[0]\n", + "gray_matrix = np.ones((matrix_size, matrix_size)) * 0.5\n", + "\n", + "# Plot each subplot\n", + "for idx, (ax, data) in enumerate(zip(axes.flat, data_matrices)):\n", + " row = idx // 3\n", + " col = idx % 3\n", + " \n", + " if idx == 3: # Bottom left - gray matrix with diagonal lines\n", + " im = ax.imshow(gray_matrix, cmap='gray', vmin=0, vmax=1, extent=[-0.5, matrix_size-0.5, matrix_size-0.5, -0.5])\n", + " \n", + " # Add diagonal lines from bottom-left to top-right\n", + " for i in range(matrix_size):\n", + " for j in range(matrix_size):\n", + " ax.plot([j-0.5, j+0.5], [i-0.5, i+0.5], 'k--', linewidth=1)\n", + " \n", + " # Set axis limits to match other plots\n", + " ax.set_xlim(-0.5, matrix_size-0.5)\n", + " ax.set_ylim(matrix_size-0.5, -0.5)\n", + " \n", + " # Remove ticks and labels\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_xlabel('')\n", + " ax.set_ylabel('')\n", + " \n", + " # Remove spines\n", + " for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + " \n", + " else:\n", + " im = ax.imshow(data, cmap='viridis')\n", + " \n", + " # Add colorbar on top with only 2 ticks\n", + " cbar = plt.colorbar(im, ax=ax, shrink=0.4, location='top', pad=0.02)\n", + " vmin, vmax = data.min(), data.max()\n", + " cbar.set_ticks([vmin, vmax])\n", + " cbar.set_ticklabels([f'{vmin:.2g}', f'{vmax:.2g}'])\n", + " cbar.ax.tick_params(labelsize=10)\n", + " \n", + " # Remove colorbar spines\n", + " for spine in cbar.ax.spines.values():\n", + " spine.set_visible(False)\n", + " \n", + " # Set custom tick positions and labels (every 4 positions)\n", + " tick_positions = [1.5, 5.5, 9.5, 13.5] # Middle of each group of 4\n", + " tick_labels = ['1', '2', '3', '4']\n", + " \n", + " ax.set_xticks(tick_positions)\n", + " ax.set_xticklabels(tick_labels,fontsize=10)\n", + " ax.set_yticks(tick_positions)\n", + " ax.set_yticklabels(tick_labels,fontsize=10)\n", + " \n", + " # Set axis labels\n", + " ax.set_xlabel('System',fontsize=10)\n", + " ax.set_ylabel('System',fontsize=10)\n", + " \n", + " # Remove spines\n", + " for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2edb4f13", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 16/16 [00:00<00:00, 52.96it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 52.17it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 234.84it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 49.00it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette Scores:\n", + "DMDc Full (state): 0.036\n", + "SubspaceDMDc Full (state): 0.342\n", + "DMDc Full (control): 0.05\n", + "SubspaceDMDc Full (control): 0.218\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the similarity matrices for each method\n", + "sims_full_dmdc, _, _, _, _ = compare_systems_full(A_cs, B_cs)\n", + "sims_full_subdmdc, _, _, _, _ = compare_systems_full(As_n4sid, Bs_n4sid)\n", + "\n", + "# Print silhouette scores\n", + "print(\"Silhouette Scores:\")\n", + "print(f\"DMDc Full (state): {np.round(silhouette_score(sims_full_dmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc Full (state): {np.round(silhouette_score(sims_full_subdmdc, state_labels, metric='precomputed'), 3)}\")\n", + "print(f\"DMDc Full (control): {np.round(silhouette_score(sims_full_dmdc, control_labels, metric='precomputed'), 3)}\")\n", + "print(f\"SubspaceDMDc Full (control): {np.round(silhouette_score(sims_full_subdmdc, control_labels, metric='precomputed'), 3)}\")\n", + "\n", + "# Create 1x2 subplot\n", + "fig, axes = plt.subplots(1, 2, figsize=(6, 3))\n", + "plt.subplots_adjust(wspace=0.1, hspace=0.2)\n", + "\n", + "# Column headers (bold)\n", + "column_headers = ['DMDc', 'SubspaceDMDc']\n", + "for i, header in enumerate(column_headers):\n", + " axes[i].text(0.5, 1.55, header, transform=axes[i].transAxes, ha='center', va='bottom', fontweight='bold', fontsize=16)\n", + "\n", + "# Data for each subplot\n", + "data_matrices = [\n", + " sims_full_dmdc, # left\n", + " sims_full_subdmdc # right\n", + "]\n", + "\n", + "# Plot each subplot\n", + "for idx, (ax, data) in enumerate(zip(axes.flat, data_matrices)):\n", + " im = ax.imshow(data, cmap='viridis')\n", + " \n", + " # Add colorbar on top with only 2 ticks\n", + " cbar = plt.colorbar(im, ax=ax, shrink=0.4, location='top', pad=0.02,label='Joint DSA')\n", + " vmin, vmax = data.min(), data.max()\n", + " cbar.set_ticks([vmin, vmax])\n", + " cbar.set_ticklabels([f'{vmin:.2g}', f'{vmax:.2g}'])\n", + " cbar.ax.tick_params(labelsize=10)\n", + " \n", + " # Remove colorbar spines\n", + " for spine in cbar.ax.spines.values():\n", + " spine.set_visible(False)\n", + " \n", + " # Set custom tick positions and labels (every 4 positions)\n", + " tick_positions = [1.5, 5.5, 9.5, 13.5] # Middle of each group of 4\n", + " tick_labels = ['1', '2', '3', '4']\n", + " \n", + " ax.set_xticks(tick_positions)\n", + " ax.set_xticklabels(tick_labels, fontsize=10)\n", + " ax.set_yticks(tick_positions)\n", + " ax.set_yticklabels(tick_labels, fontsize=10)\n", + " \n", + " # Set axis labels\n", + " ax.set_xlabel('System', fontsize=10)\n", + " ax.set_ylabel('System', fontsize=10)\n", + " \n", + " # Remove spines\n", + " for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d85b184f", + "metadata": {}, + "outputs": [], + "source": [ + "#collect statistics now: \n", + "#sample random systems from the set of 4 pairings\n", + "#sample 4 input drives for each system, making 16 diferent systems in total \n", + "#compute silhouette score based on A labels and B labels\n", + "\n", + "def get_silhouette_scores(n,m,p_out,N,n_iters,\n", + " input_alpha=input_alpha,g1=g1,g2=g2,same_inp=False,n_Us=n_Us,\n", + " n_delays=n_delays,pf=pf,rank=rank,process_noise=process_noise,obs_noise=obs_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=lambda x: np.tanh(x),\n", + " y_feature_map = lambda x: x, u_feature_map = lambda x: x,backend=backend,\n", + " use_joint_control=True):\n", + "\n", + " silhouette_state_dmdc = []\n", + " silhouette_control_dmdc = []\n", + "\n", + " silhouette_state_subspace_dmdc = []\n", + " silhouette_control_subspace_dmdc = []\n", + "\n", + " silhouette_state_dsa = []\n", + " silhouette_control_dsa = []\n", + "\n", + "\n", + " for i in tqdm(range(n_iters)):\n", + " X_trues, Ys, Us, control_labels, state_labels, *_ = simulate_As_Bs(n,m,p_out,\n", + " N,input_alpha=input_alpha,g1=g1,g2=g2,same_inp=same_inp,n_Us=n_Us, seed1=seed1+i,seed2=seed2+110*i,\n", + " obs_noise=obs_noise,process_noise=process_noise,\n", + " nonlinear_eps=nonlinear_eps,nonlinear_func=nonlinear_func)\n", + " Ys = list(map(y_feature_map, Ys))\n", + " Us = list(map(u_feature_map, Us))\n", + "\n", + " A_cs, B_cs = get_dmdcs(Ys,Us,n_delays=n_delays,rank=rank)\n", + " print('dmdc:', [i.shape for i in A_cs])\n", + " As, Bs, Cs, infos = get_subspace_dmdcs(Ys,Us,p=pf,rank=rank,backend=backend)\n", + " print('subspacedmdc:', [i.shape for i in As])\n", + " A_dmds = get_dmds(Ys,n_delays=n_delays,rank=rank)\n", + " print('dmd:', [i.shape for i in A_dmds])\n", + " sims_full_dmdc, sims_control_joint_dmdc, sims_state_joint_dmdc, sims_control_separate_dmdc, sims_state_separate_dmdc = compare_systems_full(A_cs,B_cs)\n", + " sims_full_subspace_dmdc, sims_control_joint_subspace_dmdc, sims_state_joint_subspace_dmdc, sims_control_separate_subspace_dmdc, sims_state_separate_subspace_dmdc = compare_systems_full(As,Bs)\n", + "\n", + " sims_state_dmd = compare_A_full(A_dmds)\n", + "\n", + " #compute silhouette scores\n", + " silhouette_state_dmdc.append(silhouette_score(sims_state_separate_dmdc,state_labels,metric='precomputed'))\n", + " if use_joint_control:\n", + " silhouette_control_dmdc.append(silhouette_score(sims_control_joint_dmdc,control_labels,metric='precomputed'))\n", + " silhouette_control_subspace_dmdc.append(silhouette_score(sims_control_joint_subspace_dmdc,control_labels,metric='precomputed'))\n", + " else:\n", + " silhouette_control_dmdc.append(silhouette_score(sims_control_separate_dmdc,control_labels,metric='precomputed'))\n", + " silhouette_control_subspace_dmdc.append(silhouette_score(sims_control_separate_subspace_dmdc,control_labels,metric='precomputed'))\n", + " \n", + " silhouette_state_subspace_dmdc.append(silhouette_score(sims_state_separate_subspace_dmdc,state_labels,metric='precomputed'))\n", + "\n", + " silhouette_state_dsa.append(silhouette_score(sims_state_dmd,state_labels,metric='precomputed'))\n", + " silhouette_control_dsa.append(silhouette_score(sims_state_dmd,control_labels,metric='precomputed'))\n", + "\n", + " print(silhouette_state_subspace_dmdc[-1],silhouette_state_dmdc[-1])\n", + " print(silhouette_control_subspace_dmdc[-1],silhouette_control_dmdc[-1])\n", + "\n", + " # print(silhouette_state_subspace_dmdc,silhouette_control_subspace_dmdc)\n", + " return silhouette_state_dmdc, silhouette_control_dmdc, silhouette_state_subspace_dmdc, silhouette_control_subspace_dmdc, silhouette_state_dsa, silhouette_control_dsa\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e32ce5f0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "methods = [ 'DMD','DMDC', 'Subspace DMDC']\n", + "state_means = [np.mean(silh_state_dsa),np.mean(silh_state_dmdc), np.mean(silh_state_subdmdc)]\n", + "state_stds = [np.std(silh_state_dsa) / np.sqrt(n_iters), np.std(silh_state_dmdc) / np.sqrt(n_iters), np.std(silh_state_subdmdc) / np.sqrt(n_iters)]\n", + "control_means = [np.mean(silh_ctrl_dsa),np.mean(silh_ctrl_dmdc), np.mean(silh_ctrl_subsdmdc)]\n", + "control_stds = [np.std(silh_ctrl_dsa) / np.sqrt(n_iters), np.std(silh_ctrl_dmdc) / np.sqrt(n_iters), np.std(silh_ctrl_subsdmdc) / np.sqrt(n_iters)]\n", + "\n", + "# Create bar plot\n", + "x = np.arange(len(methods))\n", + "width = 0.35\n", + "\n", + "fig, ax = plt.subplots(figsize=(6,4))\n", + "# Prepare data for violin plots\n", + "state_data = [silh_state_dsa, silh_state_dmdc, silh_state_subdmdc]\n", + "control_data = [silh_ctrl_dsa, silh_ctrl_dmdc, silh_ctrl_subsdmdc]\n", + "\n", + "# Option to create either violin plots or bar plots\n", + "plot_type = 'bar' # Change to 'bar' for bar plots\n", + "\n", + "if plot_type == 'violin':\n", + " # Create violin plots\n", + " violin_parts1 = ax.violinplot(state_data, positions=x - width/2, widths=width, showmeans=True, showmedians=False)\n", + " violin_parts2 = ax.violinplot(control_data, positions=x + width/2, widths=width, showmeans=True, showmedians=False)\n", + "\n", + " # Color the violin plots\n", + " for pc in violin_parts1['bodies']:\n", + " pc.set_facecolor(plt.cm.Paired(0))\n", + " pc.set_alpha(0.8)\n", + " \n", + " for pc in violin_parts2['bodies']:\n", + " pc.set_facecolor(plt.cm.Paired(1))\n", + " pc.set_alpha(0.8)\n", + "\n", + " # Set the color for violin lines (edges) as well\n", + " for key in ['cbars', 'cmins', 'cmaxes', 'cmedians', 'cmeans']:\n", + " if key in violin_parts2:\n", + " violin_parts2[key].set_color(plt.cm.Paired(1))\n", + " # Create legend manually\n", + " # ax.plot([], [], color=plt.cm.Paired(0), alpha=0.8, label='State')\n", + " # ax.plot([], [], color=plt.cm.Paired(1), alpha=0.8, label='Control')\n", + "\n", + "elif plot_type == 'bar':\n", + " # Create bar plots\n", + " ax.bar(x - width/2, state_means, width, yerr=state_stds, alpha=0.8,color=plt.cm.Paired(0))\n", + " ax.bar(x + width/2, control_means, width, yerr=control_stds, alpha=0.8,color=plt.cm.Paired(1))\n", + "\n", + "\n", + "ax.text(0.1, 0.8, 'State', color=plt.cm.Paired(0), fontsize=18, ha='center', va='center', transform=ax.transAxes)\n", + "ax.text(0.1, 0.7, 'Input', color=plt.cm.Paired(1), fontsize=18, ha='center', va='center', transform=ax.transAxes)\n", + "\n", + "\n", + "# Add labels and formatting\n", + "ax.set_xlabel('Method')\n", + "ax.set_ylabel('Silhouette Score')\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(methods)\n", + "# ax.legend(loc='upper left')\n", + "\n", + "plt.tight_layout()\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "5f1c041a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "methods = ['DMD','DMDc','Subspace DMDc']\n", + "#on two plots, plot the mean and std of the silhouette scores for each method across p_out / n\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(8,3),sharex=True)\n", + "\n", + "# Plot state silhouette scores\n", + "\n", + "for i, state in enumerate([silh_state_dsas,silh_state_dmdcs,silh_state_subdmdcs]):\n", + " ax[0].plot(rs, np.mean(state, axis=1), label=methods[i] + ' (State)',color=plt.cm.Set2(i))\n", + " ax[0].fill_between(rs, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "for i, state in enumerate([silh_ctrl_dsas,silh_ctrl_dmdcs,silh_ctrl_subsdmdcs]):\n", + " ax[1].plot(rs, np.mean(state, axis=1), label=methods[i] + ' (Control)',color=plt.cm.Set2(i),linestyle='--')\n", + " ax[1].fill_between(rs, np.mean(state, axis=1) - np.std(state, axis=1) / np.sqrt(n_iters),\n", + " np.mean(state, axis=1) + np.std(state, axis=1) / np.sqrt(n_iters), alpha=0.2,\n", + " color=plt.cm.Set2(i))\n", + "\n", + "# ax[0].set_xscale('log')\n", + "# ax[1].set_xscale('log')\n", + "ax[0].set_ylim(-0.05,1.05)\n", + "ax[1].set_ylim(-0.05,1.05)\n", + "# Create custom legend with colored text\n", + "from matplotlib.lines import Line2D\n", + "ax[0].text(1.4, 0.8, 'SubspaceDMDc', color=plt.cm.Set2(2), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "ax[0].text(1.4, 0.65, 'DMDc', color=plt.cm.Set2(1), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "ax[0].text(1.4, 0.5, 'DMD', color=plt.cm.Set2(0), fontsize=12, ha='center', va='center', transform=ax[0].transAxes)\n", + "\n", + "# Add subplot titles\n", + "ax[0].set_title('State', fontsize=16, pad=10)\n", + "ax[1].set_title('Input', fontsize=16, pad=3)\n", + "ax[1].set_xlabel('Rank of DMD')\n", + "fig.text(-0.05, 0.5, 'Silhouette Score', va='center', rotation='vertical',fontsize=16)\n", + "plt.tight_layout()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dsa_test_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 4e1a652f0a7b3a952d7582fdbc4be4ac09d518b4 Mon Sep 17 00:00:00 2001 From: ostrow Date: Sat, 8 Nov 2025 18:10:31 -0500 Subject: [PATCH 45/51] compatibility bw local dmd and pykoopman --- DSA/dmd.py | 2 ++ DSA/dmdc.py | 4 ++-- DSA/subspace_dmdc.py | 3 +++ 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/DSA/dmd.py b/DSA/dmd.py index 6746d67..2140976 100644 --- a/DSA/dmd.py +++ b/DSA/dmd.py @@ -412,6 +412,7 @@ def compute_havok_dmd(self, lamb=None): @ self.Vt_plus[:, : self.rank] ).T self.A_v = A_v + self.A = A_v #for compatibility with pydmd self.A_havok_dmd = ( self.U @ self.S_mat[: self.U.shape[1], : self.rank] @@ -471,6 +472,7 @@ def compute_reduced_rank_regression(self, lamb=None): @ self.S_mat_inv[: self.A_v.shape[0], : self.U.shape[1]] @ self.U.T ) + self.A = self.A_v if self.verbose: print("Reduced Rank Regression complete! \n") diff --git a/DSA/dmdc.py b/DSA/dmdc.py index 25a005f..0ac43f2 100644 --- a/DSA/dmdc.py +++ b/DSA/dmdc.py @@ -480,8 +480,8 @@ def compute_dmdc(self, lamb=None): ) # Set the A and B properties for backward compatibility and easier access - self.A = self.A_havok_dmd - self.B = self.B_havok_dmd + self.A = self.A_v + self.B = self.A_v if self.verbose: print("DMDc matrices computed!") diff --git a/DSA/subspace_dmdc.py b/DSA/subspace_dmdc.py index 8fe7d6f..cd9f242 100644 --- a/DSA/subspace_dmdc.py +++ b/DSA/subspace_dmdc.py @@ -80,6 +80,9 @@ def fit(self): backend=self.backend, lamb=self.lamb) + self.A = self.A_v + self.B = self.B_v + self.C = self.C_v # Send to CPU if requested (inherited from BaseDMD) if self.send_to_cpu: self.all_to_device(device='cpu') From 6abae78ebe2460f76cf5749b8feaffc12544b456 Mon Sep 17 00:00:00 2001 From: ostrow Date: Sun, 9 Nov 2025 12:49:46 -0500 Subject: [PATCH 46/51] replicate rings with new dsa! --- examples/ring_attractors.ipynb | 1346 ++++++++++++-------------------- 1 file changed, 483 insertions(+), 863 deletions(-) diff --git a/examples/ring_attractors.ipynb b/examples/ring_attractors.ipynb index 45e927a..88e5258 100644 --- a/examples/ring_attractors.ipynb +++ b/examples/ring_attractors.ipynb @@ -21,14 +21,14 @@ "\n", "# #install netrep\n", "# ! git clone https://github.com/ahwillia/netrep\n", - "# ! cd netrep/\n", + "# ! cd netrep #if this does not work, install it via the terminal\n", "# ! pip install -e .\n", "# ! cd .." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "tags": [ "{hidden}" @@ -490,17 +490,17 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "def plot_results(ts,nruns,diffs_dmrsa,diffs_proc,parameter): \n", + "def plot_results(ts,nruns,diffs_dsa,diffs_proc,parameter): \n", " df = pd.DataFrame(dict(ts=np.tile(ts,nruns),\n", - " diffs_dmrsa=diffs_dmrsa.flatten(),diffs_proc=diffs_proc.flatten()))\n", + " diffs_dsa=diffs_dsa.flatten(),diffs_proc=diffs_proc.flatten()))\n", " palette = None \n", " errorbar = 'se'\n", " hue = None\n", - " g = sns.lineplot(data=df, x=\"ts\", y=\"diffs_dmrsa\", hue=hue,\n", + " g = sns.lineplot(data=df, x=\"ts\", y=\"diffs_dsa\", hue=hue,\n", " palette=palette,errorbar=errorbar,c=\"blue\",marker='o',label=\"DSA\")\n", " k = sns.lineplot(data=df, x=\"ts\", y=\"diffs_proc\", hue=hue,\n", " palette=palette,errorbar=errorbar,c=\"orange\",marker='o',label=\"Procrustes\")\n", @@ -511,14 +511,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "cuda\n" + "cpu\n" ] } ], @@ -537,8 +537,8 @@ "\n", "#parameters for the run here\n", "nruns = 10 #will do multiple tests and average over\n", - "n_delays = 50\n", - "rank = 1000\n", + "n_delays = 10\n", + "rank = None\n", "diffeo = sigmoid\n", "nneurons = 100 #here we'll keep them fixed across runs, but we varied them in the original code\n", "burn_in = 200\n", @@ -556,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "scrolled": true }, @@ -566,79 +566,35 @@ "output_type": "stream", "text": [ "on run 0\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 25.36it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 26.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 199.13it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "on run 1\n" ] }, @@ -646,545 +602,274 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_90468/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", - " centers = np.sum(\n" + "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 2\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 3\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 4\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 5\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n" + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 24.53it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 25.73it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 6\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 7\n", - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 238.37it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + " centers = np.sum(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 25.23it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 21.33it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 258.48it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + " centers = np.sum(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 15.86it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 18.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 220.03it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + " centers = np.sum(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 17.86it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 21.92it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 252.79it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + " centers = np.sum(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 20.98it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 22.40it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 226.50it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 13.66it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 10.81it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", - "on run 8\n" + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 286.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 7\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_90468/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", " centers = np.sum(\n" ] }, @@ -1192,79 +877,80 @@ "name": "stdout", "output_type": "stream", "text": [ - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 23.87it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 26.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 220.12it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + " centers = np.sum(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 18.30it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 24.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 254.26it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "on run 9\n" ] }, @@ -1272,7 +958,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_90468/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + "\n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", " centers = np.sum(\n" ] }, @@ -1280,84 +967,36 @@ "name": "stdout", "output_type": "stream", "text": [ - "DSA\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 8)\n" + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 18.95it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 20.08it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 241.30it/s]\n" ] } ], "source": [ - "diffs_dmrsa = np.zeros((nruns,ts.size))\n", + "from sklearn.decomposition import PCA\n", + "\n", + "diffs_dsa = np.zeros((nruns,ts.size))\n", "diffs_proc = np.zeros((nruns,ts.size))\n", "\n", "for j in range(nruns):\n", @@ -1368,28 +1007,33 @@ " sim.simulate(2,2000,wNoise=0.0) #simulate wth a drive of 2 for 3000 timesteps\n", " run_data = sim.gsR[burn_in:] #remove the burn-in period\n", " d0 = diffeo(run_data,ts[0]) #compare all to d0 (the smallest scale transform)\n", + " d0 = PCA(n_components=15).fit_transform(d0)\n", " data = []\n", " for i,beta in enumerate(ts):\n", " d = diffeo(run_data,beta)\n", + " pca = PCA(n_components=15)\n", + " d = pca.fit_transform(d)\n", + " # print(np.cumsum(pca.explained_variance_ratio_))\n", + " data = []\n", " data.append(d)\n", " proc_score = comparison_shape.fit_score(d, d0)\n", " diffs_proc[j,i] = proc_score\n", " print(\"DSA\")\n", " #we're doing 1-to-many analysis here!\n", - " dsa = DSA(d0,data,n_delays=n_delays,rank=rank,device=device,verbose=True,iters=500,lr=0.01)\n", + " dsa = DSA(d0,data,n_delays=n_delays,rank=rank,device=device,verbose=True,iters=500,lr=0.01,score_method='wasserstein')\n", " dsa_score = dsa.fit_score()\n", - " print(dsa_score.shape)\n", - " diffs_dmrsa[j,:] = dsa_score\n" + " # print(dsa_score.shape)\n", + " diffs_dsa[j,:] = dsa_score\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1399,7 +1043,7 @@ } ], "source": [ - "plot_results(ts,nruns,diffs_dmrsa,diffs_proc,parameter)" + "plot_results(ts,nruns,diffs_dsa,diffs_proc,parameter)" ] }, { @@ -1411,7 +1055,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -1434,7 +1078,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1443,15 +1087,45 @@ "text": [ "on run 0\n", "0.0\n", + "[0.25369717 0.45654168 0.61520462 0.73780483 0.82856849 0.88754471\n", + " 0.92879732 0.95389112 0.9700081 0.97930919 0.9854652 0.98951094\n", + " 0.99130669 0.99260625 0.99388587]\n", "0.1\n", + "[0.19048048 0.32985884 0.45220731 0.56204825 0.64656907 0.72225737\n", + " 0.78645379 0.8387057 0.88046408 0.91326671 0.93781133 0.95550473\n", + " 0.96743091 0.9754896 0.98078049]\n", "0.2\n", + "[0.45967021 0.61126547 0.72997665 0.81298848 0.87317053 0.91252379\n", + " 0.94365227 0.96314694 0.9755494 0.98291577 0.98769552 0.99125876\n", + " 0.99318308 0.99419832 0.99518581]\n", "0.30000000000000004\n", + "[0.23221853 0.43225934 0.59113581 0.71408954 0.80805437 0.87151854\n", + " 0.91953221 0.94998535 0.96778991 0.97754717 0.98465794 0.98913341\n", + " 0.99109576 0.99240676 0.99366563]\n", "0.4\n", + "[0.19048048 0.32985886 0.45220733 0.56204827 0.64656909 0.72225738\n", + " 0.7864538 0.83870572 0.8804641 0.91326672 0.93781133 0.95550473\n", + " 0.96743092 0.9754896 0.98078049]\n", "0.5\n", + "[0.19227735 0.33898624 0.46312195 0.57362714 0.66190565 0.7406905\n", + " 0.80478509 0.85580001 0.89642329 0.92684243 0.94889075 0.96370089\n", + " 0.97341818 0.97962759 0.98485685]\n", "0.6000000000000001\n", + "[0.16155528 0.28339831 0.38959138 0.49323849 0.57274959 0.64213237\n", + " 0.70436733 0.76123389 0.80881667 0.84990632 0.8839797 0.91123191\n", + " 0.93278742 0.94931456 0.96168152]\n", "0.7000000000000001\n", + "[0.41582455 0.47106512 0.52099833 0.57023939 0.61476138 0.65558472\n", + " 0.69136598 0.7251092 0.75488265 0.78261983 0.80822032 0.83151158\n", + " 0.85187938 0.87028326 0.88678245]\n", "0.8\n", + "[0.67329322 0.70255427 0.73088931 0.75639627 0.77912073 0.79779598\n", + " 0.8133835 0.82872582 0.84370986 0.85798003 0.87175487 0.88467783\n", + " 0.89732628 0.90904598 0.92008426]\n", "0.9\n", + "[0.68293678 0.71278328 0.74169053 0.76762367 0.79037159 0.80888744\n", + " 0.8247635 0.84028549 0.85518636 0.86945398 0.88327483 0.89639464\n", + " 0.9088834 0.92034872 0.93094254]\n", "1.0\n" ] }, @@ -1459,7 +1133,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_104513/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_74501/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", " centers = np.sum(\n" ] }, @@ -1467,109 +1141,52 @@ "name": "stdout", "output_type": "stream", "text": [ - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Computing Hankel matrix ...\n", - "Hankel matrix computed!\n", - "Computing SVD on Hankel matrix ...\n", - "SVD complete!\n", - "Computing least squares fits to HAVOK DMD ...\n", - "Least squares complete! \n", - "\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "Finished optimizing C\n", - "(1, 11)\n" + "[0.1106887 0.21309875 0.30240264 0.38665383 0.45767216 0.52288068\n", + " 0.58136988 0.6394324 0.69465593 0.74241949 0.78972251 0.82641405\n", + " 0.86284668 0.88916518 0.91540882]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:01<00:00, 1.17s/it]\n", + "Fitting DMDs: 100%|██████████| 11/11 [00:00<00:00, 23.75it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing DMD similarities: 100%|██████████| 11/11 [00:00<00:00, 1261.34it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(11,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" ] } ], "source": [ "nruns = 1\n", - "ndelays = 50\n", - "rank = 200\n", + "ndelays = 10\n", + "rank = 16\n", "da = 0.1\n", "tSetup = 1000\n", "time = 8000\n", @@ -1585,7 +1202,7 @@ "alphas = np.arange(0,1+da,da)\n", "lneurons = 100 #varying \n", "hneurons = 150\n", - "diffs_dmrsa = np.zeros((nruns,alphas.size))\n", + "diffs_dsa = np.zeros((nruns,alphas.size))\n", "diffs_proc = np.zeros((nruns,alphas.size))\n", "\n", "for k in range(nruns):\n", @@ -1604,24 +1221,27 @@ "\n", " sim.simulate(drive,time,wNoise=wnoise)\n", " d = torch.relu(torch.tensor(sim.gsR))\n", + " pca = PCA(n_components=15)\n", + " d = pca.fit_transform(d)\n", + " print(np.cumsum(pca.explained_variance_ratio_))\n", " data.append(d) \n", " \n", " diffs_proc[k,i] = comparison_shape.fit_score(d0,d)\n", "\n", - " dsa = DSA(d0,data,n_delays=n_delays,rank=rank,device=device,verbose=True)\n", + " dsa = DSA(d0,data,n_delays=n_delays,rank=rank,device=device,verbose=True,score_method='wasserstein')\n", " dsa_score = dsa.fit_score()\n", " print(dsa_score.shape)\n", - " diffs_dmrsa[k,:] = dsa_score\n" + " diffs_dsa[k,:] = dsa_score\n" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1631,7 +1251,7 @@ } ], "source": [ - "plot_results(alphas,nruns,diffs_dmrsa,diffs_proc,r\"$\\alpha$\")" + "plot_results(alphas,nruns,diffs_dsa,diffs_proc,r\"$\\alpha$\")\n" ] }, { @@ -1644,7 +1264,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "dsa_test_env", "language": "python", "name": "python3" }, @@ -1658,7 +1278,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.18" } }, "nbformat": 4, From 3b273a63fd4a1c0c758433b58c686229ae4d8ba9 Mon Sep 17 00:00:00 2001 From: ostrow Date: Sun, 9 Nov 2025 12:50:06 -0500 Subject: [PATCH 47/51] fix scaling of wasserstein --- DSA/simdist.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DSA/simdist.py b/DSA/simdist.py index 36044a4..2b1f5dd 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -279,7 +279,7 @@ def fit( self.C_star = ot.emd(a, b, self.M) self.score_star = ( - ot.emd2(a, b, self.M) * a.shape[0] + ot.emd2(a, b, self.M) #* a.shape[0] ) # add scaling factor due to random matrix theory # self.score_star = np.sum(self.C_star * self.M) self.C_star = self.C_star / torch.linalg.norm( From c7ecae90cc3decc60bbcdd460b41ed90a219a1d3 Mon Sep 17 00:00:00 2001 From: ostrow Date: Wed, 12 Nov 2025 13:39:56 -0500 Subject: [PATCH 48/51] remove subset index bug for time delays (too few timepoints are selected, throwing an error) --- DSA/pykoopman/regression/_base_ensemble.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DSA/pykoopman/regression/_base_ensemble.py b/DSA/pykoopman/regression/_base_ensemble.py index 41c4949..65b6eda 100644 --- a/DSA/pykoopman/regression/_base_ensemble.py +++ b/DSA/pykoopman/regression/_base_ensemble.py @@ -278,9 +278,9 @@ def _check_inverse_transform(self, X): Args: X (array-like): Input data to be checked for inverse transform consistency. """ - idx_selected = slice(None, None, max(1, X.shape[0] // 100)) + # idx_selected = slice(None, None, max(1, X.shape[0] // 100)) # X_round_trip = self.inverse_transform(self.transform(X[idx_selected])) - self.inverse_transform(self.transform(X[idx_selected])) + self.inverse_transform(self.transform(X)) # if not _allclose_dense_sparse(X[idx_selected], X_round_trip): # warnings.warn( # "The provided functions are not strictly" From ea2b4833965b7290de1eb1ead74c02a17b742b00 Mon Sep 17 00:00:00 2001 From: mitchellostrow Date: Tue, 2 Dec 2025 12:48:58 -0500 Subject: [PATCH 49/51] bug fix --- DSA/base_dmd.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DSA/base_dmd.py b/DSA/base_dmd.py index 32c5d28..49c2365 100644 --- a/DSA/base_dmd.py +++ b/DSA/base_dmd.py @@ -131,7 +131,7 @@ def _process_single_dataset(self, data): return processed_data, True elif isinstance(data, np.ndarray): - return torch.from_numpy(data), False + return torch.from_numpy(data.copy()), False return data, False From a145afed83042c85a3f5d1c1e36ff9d758c95182 Mon Sep 17 00:00:00 2001 From: ostrow Date: Tue, 9 Dec 2025 15:13:45 -0500 Subject: [PATCH 50/51] bug fix for data handling --- DSA/pykoopman/koopman.py | 227 ++++++--- DSA/pykoopman/observables/_base.py | 13 +- .../observables/_custom_observables.py | 11 +- DSA/pykoopman/observables/_identity.py | 21 +- DSA/pykoopman/observables/_polynomial.py | 21 +- .../observables/_radial_basis_functions.py | 11 + .../observables/_random_fourier_features.py | 11 +- DSA/pykoopman/observables/_time_delay.py | 10 + DSA/pykoopman/regression/_base_ensemble.py | 21 +- examples/how_to_use_dsa_tutorial.ipynb | 146 ++++-- tests/pykoopman_test.py | 439 ++++++++++++++++++ 11 files changed, 796 insertions(+), 135 deletions(-) create mode 100644 tests/pykoopman_test.py diff --git a/DSA/pykoopman/koopman.py b/DSA/pykoopman/koopman.py index 8b008dd..d6de0c7 100644 --- a/DSA/pykoopman/koopman.py +++ b/DSA/pykoopman/koopman.py @@ -11,6 +11,7 @@ from pydmd import DMD from pydmd import DMDBase from sklearn.base import BaseEstimator +from sklearn.base import TransformerMixin from sklearn.metrics import r2_score from sklearn.pipeline import Pipeline from sklearn.utils.validation import check_is_fitted @@ -27,6 +28,73 @@ from .regression import PyDMDRegressor +class FlattenTransformer(BaseEstimator, TransformerMixin): + """ + Flatten various data structures to 2D for regressor consumption. + + Handles: + - 3D arrays (trials, time, features) → 2D (trials*time, features) + - Lists of arrays → concatenated 2D + - 2D arrays → pass through + - 1D arrays → reshape to column vector + + This transformer is inserted after observables to ensure regressors + always receive 2D input, while allowing observables to process + structured data (lists, 3D) that preserves trial boundaries. + """ + + def fit(self, X, y=None): + """Fit method - stateless transformer.""" + return self + + def transform(self, X): + """ + Flatten input to 2D array. + + Args: + X: Input data - can be list, 1D, 2D, or 3D array + + Returns: + 2D numpy array suitable for regressor + """ + if isinstance(X, list): + # Observable returned list of arrays - flatten and stack + flattened = [] + for x in X: + if isinstance(x, np.ndarray): + if x.ndim == 3: + # Flatten 3D: (trials, time, features) → (trials*time, features) + flattened.append(x.reshape(-1, x.shape[2])) + elif x.ndim == 2: + flattened.append(x) + elif x.ndim == 1: + flattened.append(x.reshape(-1, 1)) + else: + flattened.append(x) + return np.vstack(flattened) if flattened else np.array([]) + + elif isinstance(X, np.ndarray): + if X.ndim == 3: + # Flatten 3D: (trials, time, features) → (trials*time, features) + return X.reshape(-1, X.shape[2]) + elif X.ndim == 2: + # Already 2D - pass through + return X + elif X.ndim == 1: + # Reshape to column vector + return X.reshape(-1, 1) + + # Fallback - return as-is + return X + + def inverse_transform(self, X): + """ + Inverse transform - not typically used in this pipeline. + Included for completeness. + """ + return X + + class Koopman(BaseEstimator): """Discrete-Time Koopman class. @@ -146,47 +214,51 @@ def fit(self, x, y=None, u=None, dt=1): "Control input u was passed, " "but self.regressor is not DMDc or EDMDc" ) + # Create FlattenTransformer and composed transform function for Y + # This ensures Y goes through same transformations as X (observable + flatten) + flatten_transformer = FlattenTransformer() + + def transform_y(y_data): + """Apply observable transform then flatten for Y.""" + y_obs = self.observables.transform(y_data) + y_flat = flatten_transformer.transform(y_obs) + return y_flat + if y is None: # or isinstance(self.regressor, PyDMDRegressor): # if there is only 1 trajectory OR regressor is PyDMD y_flag = True - # regressor = self.regressor - x, y = self._detect_reshape(x, offset=True) + x, y = self.split_xy(x, offset=True) + if isinstance(self.regressor, HAVOK): regressor = self.regressor y_flag = False else: regressor = EnsembleBaseRegressor( regressor=self.regressor, - func=self.observables.transform, + func=transform_y, # Composed: observable + flatten inverse_func=self.observables.inverse, ) - # regressor = self.regressor elif isinstance(self.regressor, NNDMD): regressor = self.regressor y_flag = False + # NNDMD handles its own data - skip pipeline setup and return early + # (will add full NNDMD handling in next step) else: - # multiple 1-step-trajectories + # multiple 1-step-trajectories (X and Y provided separately) regressor = EnsembleBaseRegressor( regressor=self.regressor, - func=self.observables.transform, + func=transform_y, # Composed: observable + flatten inverse_func=self.observables.inverse, ) - # if x is a list, we need to further change trajectories into 1-step-traj - x, _ = self._detect_reshape(x, offset=False) - y, _ = self._detect_reshape(y, offset=False) y_flag = False - # if isinstance(x, list): - # x_tmp = [] - # y_tmp = [] - # for traj_dat in x: - # x_tmp.append(traj_dat[:-1]) - # y_tmp.append(traj_dat[1:]) - # x = np.hstack(x_tmp) - # y = np.hstack(y_tmp) + # Create pipeline with observable + flatten + regressor + # X will go through: Observable → Flatten → Regressor + # Y will go through: func (observable + flatten) → Regressor steps = [ ("observables", self.observables), + ("flatten", FlattenTransformer()), ("regressor", regressor), ] self._pipeline = Pipeline(steps) # create `model` object using Pipeline @@ -198,12 +270,12 @@ def fit(self, x, y=None, u=None, dt=1): self._pipeline.fit(x, y, regressor__dt=dt) else: self._pipeline.fit(x, y, regressor__u=u, regressor__dt=dt) - # update the second step with just the regressor, not the + # update the third step with just the regressor, not the # EnsembleBaseRegressor - if isinstance(self._pipeline.steps[1][1], EnsembleBaseRegressor): - self._pipeline.steps[1] = ( - self._pipeline.steps[1][0], - self._pipeline.steps[1][1].regressor_, + if isinstance(self._pipeline.steps[2][1], EnsembleBaseRegressor): + self._pipeline.steps[2] = ( + self._pipeline.steps[2][0], + self._pipeline.steps[2][1].regressor_, ) # pykoopman's n_input/output_features are simply @@ -212,30 +284,49 @@ def fit(self, x, y=None, u=None, dt=1): # of states. but the output features can be really high self.n_input_features_ = self._pipeline.steps[0][1].n_input_features_ self.n_output_features_ = self._pipeline.steps[0][1].n_output_features_ - if hasattr(self._pipeline.steps[1][1], "n_control_features_"): - self.n_control_features_ = self._pipeline.steps[1][1].n_control_features_ + + if hasattr(self._pipeline.steps[2][1], "n_control_features_"): + self.n_control_features_ = self._pipeline.steps[2][1].n_control_features_ # compute amplitudes if isinstance(x, list): self._amplitudes = None elif y_flag: + # Extract data for amplitude computation, handling 3D/list structures if hasattr(self.observables, "n_consumed_samples"): - # g0 = self.observables.transform( - # x[0 : 1 + self.observables.n_consumed_samples] - # ) - self._amplitudes = np.abs( - self.psi(x[0 : 1 + self.observables.n_consumed_samples].T) - ) + n_samples_needed = 1 + self.observables.n_consumed_samples + + # Handle different input structures + if isinstance(x, np.ndarray) and x.ndim == 3: + # 3D: (trials, time, features) - take from first trial + x_for_amp = x[0, 0:n_samples_needed, :] + elif isinstance(x, list): + # List - take from first element + x_for_amp = x[0][0:n_samples_needed] if isinstance(x[0], np.ndarray) else x[0] + else: + # 2D (original behavior) + x_for_amp = x[0:n_samples_needed] + + self._amplitudes = np.abs(self.psi(x_for_amp.T)) else: - # g0 = self.observables.transform(x[0:1]) - - self._amplitudes = np.abs(self.psi(x[0:1].T)) + # Non-temporal observables + if isinstance(x, np.ndarray) and x.ndim == 3: + # 3D: take first sample from first trial + x_for_amp = x[0, 0:1, :] + elif isinstance(x, list): + # List - take first sample from first element + x_for_amp = x[0][0:1] if isinstance(x[0], np.ndarray) else x[0] + else: + # 2D (original behavior) + x_for_amp = x[0:1] + + self._amplitudes = np.abs(self.psi(x_for_amp.T)) else: self._amplitudes = None self.time = { "tstart": 0, - "tend": dt * (self._pipeline.steps[1][1].n_samples_ - 1), + "tend": dt * (self._pipeline.steps[2][1].n_samples_ - 1), "dt": dt, } @@ -589,50 +680,52 @@ def _regressor(self): # my idea is to manually call xN observables then concate the data to let # the _regressor.fit to update the model coefficients. # call this function with _regressor() - return self._pipeline.steps[1][1] + return self._pipeline.steps[2][1] - def _detect_reshape(self, X, offset=True): + def split_xy(self, X, offset=True): """ - Detect the shape of the input data and reshape it accordingly to return - both X and Y in the correct shape. + Split data into X and Y pairs with temporal offset. + + Preserves input structure (list/2D/3D) so observables can handle + trial boundaries appropriately. Does NOT flatten or transform - + just performs the temporal split. + + Args: + X: Input data (1D, 2D array, 3D array, or list of arrays) + offset: If True, split with temporal offset X[:-1], X[1:] + If False, return (X, X) - used when Y provided separately + + Returns: + Tuple (X_split, Y_split) preserving input structure """ - s1 = -1 if offset else None - s2 = 1 if offset else None + if not offset: + # No split needed when Y provided separately + return X, X + + s1, s2 = -1, 1 # X[:-1], X[1:] + if isinstance(X, np.ndarray): if X.ndim == 1: X = X.reshape(-1, 1) - + if X.ndim == 2: self.n_samples_, self.n_input_features_ = X.shape self.n_trials_ = 1 return X[:s1], X[s2:] + elif X.ndim == 3: self.n_trials_, self.n_samples_, self.n_input_features_ = X.shape - X, Y = X[:, :s1, :], X[:, s2:, :] - return X.reshape(-1, X.shape[2]), Y.reshape( - -1, Y.shape[2] - ) # time*trials, features - + # Keep 3D structure: (trials, time-1, features) + return X[:, :s1, :], X[:, s2:, :] + elif isinstance(X, list): - assert all(isinstance(x, np.ndarray) for x in X) - self.n_trials_tot, self.n_samples_tot, self.n_input_features_tot = ( - [], - [], - [], - ) - X_tot, Y_tot = [], [] + # Recursively process each element in list + X_list, Y_list = [], [] for x in X: - x, y = self._detect_reshape(x) - X_tot.append(x) - Y_tot.append(y) - self.n_trials_tot.append(self.n_trials_) - self.n_samples_tot.append(self.n_samples_) - self.n_input_features_tot.append(self.n_input_features_) - X = np.concatenate(X_tot, axis=0) - Y = np.concatenate(Y_tot, axis=0) - - self.n_trials_ = sum(self.n_trials_tot) - self.n_samples_ = sum(self.n_samples_tot) - self.n_input_features_ = sum(self.n_input_features_tot) - - return X, Y + x_split, y_split = self.split_xy(x, offset=offset) + X_list.append(x_split) + Y_list.append(y_split) + return X_list, Y_list + + # Fallback for unknown types + return X, X diff --git a/DSA/pykoopman/observables/_base.py b/DSA/pykoopman/observables/_base.py index 62b0fca..e0b1ad3 100644 --- a/DSA/pykoopman/observables/_base.py +++ b/DSA/pykoopman/observables/_base.py @@ -182,7 +182,8 @@ def fit(self, X, y=None): Args: X (numpy.ndarray): Measurement data to be fit, with shape (n_samples, - n_input_features_). + n_input_features_). Can also be 3D (n_trials, n_samples, n_features) + or list of arrays. y (numpy.ndarray, optional): Time-shifted measurement data to be fit. Default is None. @@ -197,10 +198,18 @@ def fit(self, X, y=None): # first, one must call fit of every observable in the observer list # so that n_input_features_ and n_output_features_ are defined + # Each observable's fit() now handles lists/3D internally for obs in self.observables_list_: obs.fit(X, y) - self.n_input_features_ = X.shape[1] + # Get n_input_features from first element/trial if needed + X_for_shape = X + if isinstance(X, list): + X_for_shape = X[0] + if X_for_shape.ndim == 3: + X_for_shape = X_for_shape[0] + + self.n_input_features_ = X_for_shape.shape[1] # total number of output features takes care of redundant identity features # for polynomial feature, we will remove the 1 as well if include_bias is true diff --git a/DSA/pykoopman/observables/_custom_observables.py b/DSA/pykoopman/observables/_custom_observables.py index 541087f..8c5398b 100644 --- a/DSA/pykoopman/observables/_custom_observables.py +++ b/DSA/pykoopman/observables/_custom_observables.py @@ -79,7 +79,8 @@ def fit(self, x, y=None): Args: x (array-like, shape (n_samples, n_input_features)): Measurement data to be - fitted. + fitted. Can also be 3D (n_trials, n_samples, n_features) or list of + arrays. y (None): This is a dummy parameter added for compatibility with sklearn's API. Default is None. @@ -87,6 +88,14 @@ def fit(self, x, y=None): self (CustomObservables): This method returns the fitted instance. """ x = validate_input(x) + + # Handle lists and 3D by fitting on first element/trial + if isinstance(x, list): + x = x[0] # Fit on first element + if x.ndim == 3: + x = x[0] # Fit on first trial + + # Now x is 2D, proceed as normal n_samples, n_features = x.shape n_output_features = 0 diff --git a/DSA/pykoopman/observables/_identity.py b/DSA/pykoopman/observables/_identity.py index 47d24c0..c252578 100644 --- a/DSA/pykoopman/observables/_identity.py +++ b/DSA/pykoopman/observables/_identity.py @@ -29,8 +29,9 @@ def fit(self, x, y=None): Fit the model to the provided measurement data. Args: - x (array-like): The measurement data to be fit. It must have a shape of - (n_samples, n_input_features). + x (array-like): The measurement data to be fit. Can be 2D (n_samples, + n_input_features), 3D (n_trials, n_samples, n_input_features), or + list of arrays. y (None): This parameter is retained for sklearn compatibility. Returns: @@ -40,12 +41,16 @@ def fit(self, x, y=None): only identity mapping is supported for list of arb trajectories """ x = validate_input(x) - if not isinstance(x, list): - self.n_input_features_ = self.n_output_features_ = x.shape[1] - self.measurement_matrix_ = np.eye(x.shape[1]).T - else: - self.n_input_features_ = self.n_output_features_ = x[0].shape[1] - self.measurement_matrix_ = np.eye(x[0].shape[1]).T + + # Handle lists and 3D by fitting on first element/trial + if isinstance(x, list): + x = x[0] # Fit on first element + if x.ndim == 3: + x = x[0] # Fit on first trial + + # Now x is 2D, proceed as normal + self.n_input_features_ = self.n_output_features_ = x.shape[1] + self.measurement_matrix_ = np.eye(x.shape[1]).T self.n_consumed_samples = 0 diff --git a/DSA/pykoopman/observables/_polynomial.py b/DSA/pykoopman/observables/_polynomial.py index f749a4f..b18b206 100644 --- a/DSA/pykoopman/observables/_polynomial.py +++ b/DSA/pykoopman/observables/_polynomial.py @@ -91,7 +91,8 @@ def fit(self, x, y=None): Args: x (np.ndarray): The measurement data to be fit, with shape (n_samples, - n_features). + n_features). Can also be 3D (n_trials, n_samples, n_features) or + list of arrays. y (array-like, optional): Dummy input. Defaults to None. Returns: @@ -101,17 +102,29 @@ def fit(self, x, y=None): ValueError: If the input data is not valid. """ x = validate_input(x) + + # Handle lists and 3D by fitting on first element/trial + if isinstance(x, list): + x = x[0] # Fit on first element + if x.ndim == 3: + x = x[0] # Fit on first trial + + # Now x is 2D, proceed as normal self.n_consumed_samples = 0 - y_poly_out = super(Polynomial, self).fit(x.real, y) + super(Polynomial, self).fit(x.real, y) + + # Set custom attributes that our code expects + self.n_input_features_ = x.shape[1] + # n_output_features_ is already set by superclass fit() - self.measurement_matrix_ = np.zeros([x.shape[1], y_poly_out.n_output_features_]) + self.measurement_matrix_ = np.zeros([x.shape[1], self.n_output_features_]) if self.include_bias: self.measurement_matrix_[:, 1 : 1 + x.shape[1]] = np.eye(x.shape[1]) else: self.measurement_matrix_[:, : x.shape[1]] = np.eye(x.shape[1]) - return y_poly_out + return self def transform(self, x): """ diff --git a/DSA/pykoopman/observables/_radial_basis_functions.py b/DSA/pykoopman/observables/_radial_basis_functions.py index 2363722..e1c9924 100644 --- a/DSA/pykoopman/observables/_radial_basis_functions.py +++ b/DSA/pykoopman/observables/_radial_basis_functions.py @@ -98,6 +98,9 @@ def fit(self, x, y=None): Initializes the RadialBasisFunction with specified parameters. Args: + x (array-like): The input data, shape (n_samples, n_input_features). + Can also be 3D (n_trials, n_samples, n_features) or list of arrays. + y (None): Dummy parameter for sklearn compatibility. rbf_type (str, optional): The type of radial basis functions to be used. Options are: 'gauss', 'thinplate', 'invquad', 'invmultquad', 'polyharmonic'. Defaults to 'gauss'. @@ -122,6 +125,14 @@ def fit(self, x, y=None): n_centers is not equal to centers.shape[1]. """ x = validate_input(x) + + # Handle lists and 3D by fitting on first element/trial + if isinstance(x, list): + x = x[0] # Fit on first element + if x.ndim == 3: + x = x[0] # Fit on first trial + + # Now x is 2D, proceed as normal n_samples, n_features = x.shape self.n_consumed_samples = 0 diff --git a/DSA/pykoopman/observables/_random_fourier_features.py b/DSA/pykoopman/observables/_random_fourier_features.py index af9f690..08a2085 100644 --- a/DSA/pykoopman/observables/_random_fourier_features.py +++ b/DSA/pykoopman/observables/_random_fourier_features.py @@ -65,7 +65,8 @@ def fit(self, x, y=None): Args: x (numpy.ndarray): Measurement data to be fit. Shape (n_samples, - n_input_features_). + n_input_features_). Can also be 3D (n_trials, n_samples, n_features) + or list of arrays. y (numpy.ndarray, optional): Time-shifted measurement data to be fit. Defaults to None. @@ -73,6 +74,14 @@ def fit(self, x, y=None): self: Returns a fitted RandomFourierFeatures instance. """ x = validate_input(x) + + # Handle lists and 3D by fitting on first element/trial + if isinstance(x, list): + x = x[0] # Fit on first element + if x.ndim == 3: + x = x[0] # Fit on first trial + + # Now x is 2D, proceed as normal np.random.seed(self.random_state) self.n_consumed_samples = 0 diff --git a/DSA/pykoopman/observables/_time_delay.py b/DSA/pykoopman/observables/_time_delay.py index 038dd2b..8e3f244 100644 --- a/DSA/pykoopman/observables/_time_delay.py +++ b/DSA/pykoopman/observables/_time_delay.py @@ -88,6 +88,8 @@ def fit(self, x, y=None): Args: x (array-like): The input data, shape (n_samples, n_input_features). + Can also be 3D (n_trials, n_samples, n_input_features) or + list of arrays. y (None): Dummy parameter for sklearn compatibility. Returns: @@ -95,6 +97,14 @@ def fit(self, x, y=None): """ x = validate_input(x) + + # Handle lists and 3D by fitting on first element/trial + if isinstance(x, list): + x = x[0] # Fit on first element + if x.ndim == 3: + x = x[0] # Fit on first trial + + # Now x is 2D, proceed as normal n_samples, n_features = x.shape self.n_input_features_ = n_features diff --git a/DSA/pykoopman/regression/_base_ensemble.py b/DSA/pykoopman/regression/_base_ensemble.py index 65b6eda..c89e812 100644 --- a/DSA/pykoopman/regression/_base_ensemble.py +++ b/DSA/pykoopman/regression/_base_ensemble.py @@ -80,16 +80,23 @@ def fit(self, X, y, **fit_params): # transformers are designed to modify X which is 2d dimensional, we # need to modify y accordingly. - - self._training_dim = y.ndim - if y.ndim == 1: - y_2d = y.reshape(-1, 1) + + # Handle list inputs (convert to array if list) + if isinstance(y, list): + # Lists should be flattened by observable/flatten transformers + # For now, just note it's a list and it will be transformed by func + y_for_transform = y + self._training_dim = None # Will be determined after transform else: - y_2d = y - self._fit_transformer(y_2d) + y_for_transform = y + self._training_dim = y.ndim + if y.ndim == 1: + y_for_transform = y.reshape(-1, 1) + + self._fit_transformer(y_for_transform) # transform y and convert back to 1d array if needed - y_trans = self.transformer_.transform(y_2d) + y_trans = self.transformer_.transform(y_for_transform) # FIXME: a FunctionTransformer can return a 1D array even when validate # is set to True. Therefore, we need to check the number of dimension # first. diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb index 6a30413..e3da50b 100644 --- a/examples/how_to_use_dsa_tutorial.ipynb +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -34,16 +34,16 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -218,15 +218,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 187.58it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:03<00:00, 3.10s/it]\n" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 523.14it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:03<00:00, 3.15s/it]" ] }, { @@ -238,6 +238,13 @@ "Similarity between systems: 0.8746\n" ] }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, { "data": { "image/png": "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", @@ -287,14 +294,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 225.10it/s]\n", + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 375.01it/s]\n", "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.16s/it]" ] }, @@ -355,7 +362,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -371,7 +378,7 @@ "((8, 100, 5), torch.Size([15, 15]))" ] }, - "execution_count": 6, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -417,15 +424,32 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Automatic pdb calling has been turned ON\n" + ] + } + ], + "source": [ + "%pdb" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 1it [00:00, 273.82it/s]\n", - "Fitting DMDs: 1it [00:00, 440.95it/s]\n" + "Fitting DMDs: 1it [00:00, 186.40it/s]\n", + "Fitting DMDs: 1it [00:00, 386.57it/s]\n" ] }, { @@ -439,14 +463,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 26.33it/s]" + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 209.64it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Similarity with PyKoopman: 0.2337\n", + "Similarity with PyKoopman: 0.1168\n", "(8, 100, 5)\n", "(2, 2)\n" ] @@ -511,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -522,12 +546,17 @@ "Control shape: (8, 100, 2)\n" ] }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 328.84it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 451.49it/s]" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 481.44it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 654.85it/s]" ] }, { @@ -586,15 +615,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 40.68it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 817.76it/s]" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 9.19it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 203.05it/s]" ] }, { @@ -652,16 +681,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 19, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "control similarity: 0.0131\n" - ] - }, { "name": "stderr", "output_type": "stream", @@ -674,6 +696,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "control similarity: 0.0131\n", "state similarity: 0.3775\n", "joint similarity: 1.8671\n" ] @@ -741,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -797,15 +820,20 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 21, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, { "name": "stderr", "output_type": "stream", "text": [ - "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 367.31it/s]\n", - "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 3.00s/it]" + "Fitting DMDs: 100%|██████████| 2/2 [00:00<00:00, 327.50it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:03<00:00, 3.46s/it]" ] }, { @@ -863,7 +891,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -875,11 +903,16 @@ "Running hyperparameter sweep...\n" ] }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:00<00:00, 15.20it/s]" + "100%|██████████| 5/5 [00:00<00:00, 15.70it/s]" ] }, { @@ -936,7 +969,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -948,7 +981,7 @@ " ], dtype=object))" ] }, - "execution_count": 14, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, @@ -977,7 +1010,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -992,10 +1025,33 @@ "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/5 [00:00,\n", + " array([,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1032,7 +1088,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1133,7 +1189,7 @@ ], "metadata": { "kernelspec": { - "display_name": "py39", + "display_name": "dsa_test_env", "language": "python", "name": "python3" }, @@ -1147,7 +1203,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.10.18" } }, "nbformat": 4, diff --git a/tests/pykoopman_test.py b/tests/pykoopman_test.py new file mode 100644 index 0000000..22e8147 --- /dev/null +++ b/tests/pykoopman_test.py @@ -0,0 +1,439 @@ +""" +Test suite for PyKoopman with 3D data and various observables. +Tests the implementation that prevents trial boundary crossing. +""" +import pytest +import numpy as np +from DSA.pykoopman.observables import ( + TimeDelay, Identity, Polynomial, + RadialBasisFunction, RandomFourierFeatures +) +from DSA.pykoopman import Koopman +from pydmd import DMD as pDMD + +TOL = 1e-10 # Tolerance for Frobenius norm comparisons + + +@pytest.fixture +def basic_3d_data(): + """Create basic 3D test data with distinct values per trial.""" + np.random.seed(42) + n_trials = 3 + n_timesteps = 10 + n_features = 2 + + data = np.zeros((n_trials, n_timesteps, n_features)) + for trial_idx in range(n_trials): + for t in range(n_timesteps): + data[trial_idx, t, 0] = trial_idx * 100 + t + data[trial_idx, t, 1] = trial_idx * 100 + t + 0.5 + + return data + + +@pytest.fixture +def variable_length_data(): + """Create list of 3D arrays with different shapes.""" + np.random.seed(42) + n_features = 2 + + # First array: 2 trials, 12 timesteps each + data_var1 = np.zeros((2, 12, n_features)) + for trial_idx in range(2): + for t in range(12): + data_var1[trial_idx, t, 0] = trial_idx * 100 + t + data_var1[trial_idx, t, 1] = trial_idx * 100 + t + 0.5 + + # Second array: 3 trials, 8 timesteps each + data_var2 = np.zeros((3, 8, n_features)) + for trial_idx in range(3): + for t in range(8): + data_var2[trial_idx, t, 0] = (trial_idx + 10) * 100 + t + data_var2[trial_idx, t, 1] = (trial_idx + 10) * 100 + t + 0.5 + + return [data_var1, data_var2] + + +def compute_manual_embedding(data, n_delays, rank): + """ + Manually embed data with TimeDelay to get ground truth. + This is the reference implementation. + """ + delay_computer = TimeDelay(n_delays=n_delays) + X_list = [] + Y_list = [] + + # Handle 3D array + if isinstance(data, np.ndarray) and data.ndim == 3: + for trial_idx in range(data.shape[0]): + traj = data[trial_idx, :, :] + embedded_traj = delay_computer.fit_transform(traj) + X_list.append(embedded_traj[:-1]) + Y_list.append(embedded_traj[1:]) + + # Handle list of arrays + elif isinstance(data, list): + for data_array in data: + if data_array.ndim == 3: + # List of 3D arrays + for trial_idx in range(data_array.shape[0]): + traj = data_array[trial_idx, :, :] + embedded_traj = delay_computer.fit_transform(traj) + X_list.append(embedded_traj[:-1]) + Y_list.append(embedded_traj[1:]) + elif data_array.ndim == 2: + # List of 2D arrays + embedded_traj = delay_computer.fit_transform(data_array) + X_list.append(embedded_traj[:-1]) + Y_list.append(embedded_traj[1:]) + + X_all = np.vstack(X_list) + Y_all = np.vstack(Y_list) + + # Fit with Identity since embedding already done + k_manual = Koopman( + observables=Identity(), + regressor=pDMD(svd_rank=rank) + ) + k_manual.fit(X_all, Y_all) + + return k_manual.A + + +class TestKoopman3DData: + """Test Koopman with 3D data structures.""" + + def test_3d_timedelay_vs_manual(self, basic_3d_data): + """Test that 3D input with TimeDelay matches manual approach.""" + n_delays = 3 + rank = 5 + + # Manual approach (ground truth) + A_manual = compute_manual_embedding(basic_3d_data, n_delays, rank) + + # New implementation + k_new = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=rank) + ) + k_new.fit(basic_3d_data) + A_new = k_new.A + + # Compare + diff = np.linalg.norm(A_manual - A_new, 'fro') + assert diff < TOL, f"Matrices differ by {diff:.10e}" + assert A_manual.shape == A_new.shape + + def test_2d_timedelay_backward_compatible(self): + """Test that 2D input still works (backward compatibility).""" + np.random.seed(42) + data_2d = np.random.randn(10, 2) + + k = Koopman( + observables=TimeDelay(n_delays=3), + regressor=pDMD(svd_rank=5) + ) + k.fit(data_2d) + + assert k.A.shape == (5, 5) + + def test_list_of_2d_timedelay(self, basic_3d_data): + """Test list of 2D arrays with TimeDelay.""" + n_delays = 3 + rank = 5 + + # Convert 3D to list of 2D + data_list = [basic_3d_data[i, :, :] for i in range(basic_3d_data.shape[0])] + + # Manual approach + A_manual = compute_manual_embedding(basic_3d_data, n_delays, rank) + + # List approach + k_list = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=rank) + ) + k_list.fit(data_list) + A_list = k_list.A + + # Compare + diff = np.linalg.norm(A_manual - A_list, 'fro') + assert diff < TOL, f"List approach differs from manual by {diff:.10e}" + + +class TestKoopmanObservables: + """Test various observables with 3D data.""" + + def test_identity_3d(self, basic_3d_data): + """Test Identity observable with 3D data.""" + k = Koopman( + observables=Identity(), + regressor=pDMD(svd_rank=2) + ) + k.fit(basic_3d_data) + assert k.A.shape == (2, 2) + + def test_polynomial_3d(self, basic_3d_data): + """Test Polynomial observable with 3D data.""" + k = Koopman( + observables=Polynomial(degree=2), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + assert k.A.shape == (5, 5) + + def test_rbf_3d(self, basic_3d_data): + """Test RadialBasisFunction observable with 3D data.""" + k = Koopman( + observables=RadialBasisFunction(n_centers=5, rbf_type='gauss'), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + assert k.A.shape == (5, 5) + + def test_rff_3d(self, basic_3d_data): + """Test RandomFourierFeatures observable with 3D data.""" + k = Koopman( + observables=RandomFourierFeatures(D=10, random_state=42), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + assert k.A.shape == (5, 5) + + +class TestKoopmanVariableLength: + """Test Koopman with variable-length trials.""" + + def test_variable_length_timedelay(self, variable_length_data): + """Test TimeDelay with list of different-shaped 3D arrays.""" + n_delays = 3 + rank = 5 + + # Manual approach + A_manual = compute_manual_embedding(variable_length_data, n_delays, rank) + + # New implementation + k = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=rank) + ) + k.fit(variable_length_data) + A_new = k.A + + # Compare + diff = np.linalg.norm(A_manual - A_new, 'fro') + assert diff < TOL, f"Variable-length differs from manual by {diff:.10e}" + + def test_variable_length_sample_count(self, variable_length_data): + """Verify correct number of samples (no boundary crossing).""" + n_delays = 3 + + k = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=5) + ) + k.fit(variable_length_data) + + # Array 1: 2 trials * (12 - n_delays - 1) = 2 * 8 = 16 + # Array 2: 3 trials * (8 - n_delays - 1) = 3 * 4 = 12 + # Total: 28 samples + expected_samples = 2 * (12 - n_delays - 1) + 3 * (8 - n_delays - 1) + actual_samples = k._regressor().n_samples_ + + assert actual_samples == expected_samples, \ + f"Expected {expected_samples} samples, got {actual_samples}" + + def test_variable_length_identity(self, variable_length_data): + """Test Identity with variable-length trials.""" + k = Koopman( + observables=Identity(), + regressor=pDMD(svd_rank=2) + ) + k.fit(variable_length_data) + assert k.A.shape == (2, 2) + + def test_variable_length_polynomial(self, variable_length_data): + """Test Polynomial with variable-length trials.""" + k = Koopman( + observables=Polynomial(degree=2), + regressor=pDMD(svd_rank=5) + ) + k.fit(variable_length_data) + assert k.A.shape == (5, 5) + + +class TestKoopmanPrediction: + """Test prediction functionality.""" + + def test_predict_timedelay(self, basic_3d_data): + """Test prediction with TimeDelay observable.""" + n_delays = 3 + + k = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + + # Need n_delays + 1 samples for prediction with TimeDelay + test_point = basic_3d_data[0, 0:n_delays+1, :] + pred = k.predict(test_point) + + assert pred.shape == (1, 2), f"Expected shape (1, 2), got {pred.shape}" + + def test_predict_identity(self, basic_3d_data): + """Test prediction with Identity observable.""" + k = Koopman( + observables=Identity(), + regressor=pDMD(svd_rank=2) + ) + k.fit(basic_3d_data) + + test_point = basic_3d_data[0, 0:1, :] + pred = k.predict(test_point) + + assert pred.shape == (1, 2), f"Expected shape (1, 2), got {pred.shape}" + + def test_predict_polynomial(self, basic_3d_data): + """Test prediction with Polynomial observable.""" + k = Koopman( + observables=Polynomial(degree=2), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + + test_point = basic_3d_data[0, 0:1, :] + pred = k.predict(test_point) + + assert pred.shape == (1, 2), f"Expected shape (1, 2), got {pred.shape}" + + def test_predict_rbf(self, basic_3d_data): + """Test prediction with RadialBasisFunction observable.""" + k = Koopman( + observables=RadialBasisFunction(n_centers=5, rbf_type='gauss'), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + + test_point = basic_3d_data[0, 0:1, :] + pred = k.predict(test_point) + + assert pred.shape == (1, 2), f"Expected shape (1, 2), got {pred.shape}" + + def test_predict_rff(self, basic_3d_data): + """Test prediction with RandomFourierFeatures observable.""" + k = Koopman( + observables=RandomFourierFeatures(D=10, random_state=42), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + + test_point = basic_3d_data[0, 0:1, :] + pred = k.predict(test_point) + + assert pred.shape == (1, 2), f"Expected shape (1, 2), got {pred.shape}" + + def test_predict_multiple_steps(self, basic_3d_data): + """Test prediction with multiple samples.""" + k = Koopman( + observables=Identity(), + regressor=pDMD(svd_rank=2) + ) + k.fit(basic_3d_data) + + # Predict for multiple samples + test_points = basic_3d_data[0, 0:3, :] + pred = k.predict(test_points) + + assert pred.shape == (3, 2), f"Expected shape (3, 2), got {pred.shape}" + + def test_predict_after_variable_length_fit(self, variable_length_data): + """Test prediction after fitting on variable-length trials.""" + k = Koopman( + observables=Identity(), + regressor=pDMD(svd_rank=2) + ) + k.fit(variable_length_data) + + # Predict on new data + test_point = variable_length_data[0][0, 0:1, :] + pred = k.predict(test_point) + + assert pred.shape == (1, 2), f"Expected shape (1, 2), got {pred.shape}" + + +class TestKoopmanNoBoundaryCrossing: + """Test that trial boundaries are never crossed.""" + + def test_no_boundary_crossing_in_embedding(self, basic_3d_data): + """ + Verify that time-delay windows never span across trials. + We do this by checking that manually processing each trial + independently gives the same result as the automatic 3D processing. + """ + n_delays = 3 + rank = 5 + + # Manual approach: explicitly process each trial + A_manual = compute_manual_embedding(basic_3d_data, n_delays, rank) + + # Automatic 3D approach + k = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=rank) + ) + k.fit(basic_3d_data) + A_auto = k.A + + # If boundaries were crossed, the matrices would differ + diff = np.linalg.norm(A_manual - A_auto, 'fro') + assert diff < TOL, \ + f"Boundary crossing detected! Manual and auto differ by {diff:.10e}" + + def test_sample_count_matches_expectation(self, basic_3d_data): + """Verify that the number of samples matches expected value.""" + n_delays = 3 + n_trials = basic_3d_data.shape[0] + n_timesteps = basic_3d_data.shape[1] + + k = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=5) + ) + k.fit(basic_3d_data) + + # Each trial contributes (n_timesteps - n_delays - 1) samples + expected_samples = n_trials * (n_timesteps - n_delays - 1) + actual_samples = k._regressor().n_samples_ + + assert actual_samples == expected_samples, \ + f"Expected {expected_samples} samples, got {actual_samples}" + + +@pytest.mark.parametrize("n_delays", [1, 2, 3, 5]) +@pytest.mark.parametrize("rank", [2, 5]) +def test_parametrized_timedelay(basic_3d_data, n_delays, rank): + """Test various combinations of n_delays and rank.""" + k = Koopman( + observables=TimeDelay(n_delays=n_delays), + regressor=pDMD(svd_rank=rank) + ) + k.fit(basic_3d_data) + + # Should successfully fit without errors + # Note: actual rank may be less than requested if not enough features + n_features = basic_3d_data.shape[2] + n_output_features = n_features * (1 + n_delays) + expected_rank = min(rank, n_output_features) + assert k.A.shape == (expected_rank, expected_rank), \ + f"Expected shape ({expected_rank}, {expected_rank}), got {k.A.shape}" + + # Verify we can predict + test_point = basic_3d_data[0, 0:n_delays+1, :] + pred = k.predict(test_point) + assert pred.shape[1] == basic_3d_data.shape[2] + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) + From fb047cf5e091872f2eb6e80742457126bcee7867 Mon Sep 17 00:00:00 2001 From: ostrow Date: Sat, 10 Jan 2026 16:10:15 -0500 Subject: [PATCH 51/51] dataclass bug fix --- DSA/dsa.py | 8 +++-- examples/how_to_use_dsa_tutorial.ipynb | 49 ++++++-------------------- 2 files changed, 17 insertions(+), 40 deletions(-) diff --git a/DSA/dsa.py b/DSA/dsa.py index df6ba76..b0871df 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -332,10 +332,14 @@ def __init__( if isinstance(dmd_config,type): dmd_config = dmd_config() if is_dataclass(dmd_config): - dmd_config = asdict(dmd_config) + # for dataclasses with default entries, __dataclass_fields__ ends up being empty + # dmd_config = asdict(dmd_config) ends up with an empty dictionary + #hardcode fix here + dmd_config = {k: v for k, v in dmd_config.__class__.__dict__.items() if not k.startswith("__") and not callable(v)} + self.dmd_config = ( {} - ) # This will store {'param_name': broadcasted_value_list_of_lists} + ) for key, value in dmd_config.items(): cast_type = CAST_TYPES.get(key) diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb index e3da50b..6e16a4e 100644 --- a/examples/how_to_use_dsa_tutorial.ipynb +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -441,45 +441,18 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting DMDs: 1it [00:00, 186.40it/s]\n", - "Fitting DMDs: 1it [00:00, 386.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pre-computing eigenvalues for Wasserstein distance...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 209.64it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Similarity with PyKoopman: 0.1168\n", - "(8, 100, 5)\n", - "(2, 2)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" + "ename": "NameError", + "evalue": "name 'pk' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Use TimeDelay observables with SubspaceDMD regressor from pydmd\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m observables \u001b[38;5;241m=\u001b[39m \u001b[43mpk\u001b[49m\u001b[38;5;241m.\u001b[39mobservables\u001b[38;5;241m.\u001b[39mTimeDelay(n_delays\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m)\n\u001b[1;32m 3\u001b[0m regressor \u001b[38;5;241m=\u001b[39m SubspaceDMD(svd_rank\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Create configuration\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'pk' is not defined" ] } ], @@ -493,8 +466,8 @@ "\n", "@dataclass\n", "class CustomPyKoopmanConfig:\n", - " observables = observables\n", - " regressor = regressor\n", + " observables: object = observables\n", + " regressor: object = regressor\n", "\n", "gdsa = GeneralizedDSA(\n", " data1, data2,\n",

h@SmF7-ljDq9dS$ilB)qwZuHu2+Q@ON}7%$Lg{1B=uMI{aa^YLe=&naB3{V|89}5dyo?GLvRPlV)}}7EfrFCAWjO z18@j%7|;!Xe%mu>4BNgTEs-;#)8d+yjb(>3Ms#|QOlvyEh8|;X$$sixg<~uJ>RvLj z!%>gzZfds0pe=?*-L^1oG2qD8E7`J399K76-fNr?mr0mE3E(-doh%KXrizd`B1Rrn zE81$++13Th-&)axojLo65k<$BqF=WAut}r@uMg8gTA=GyXY0Uxmhk9Wc2taWS(0s? zQa@`w8ZJieplV+IQ2sQOdPdBQJO(|-d6+O#Maxcz{aPl2A`P-)IYM&L@L0;k$f6z8 zlX@&+QYj9B7dmXl#@M!>h+eZV8h}W;$B9zJgI&yUIsRiWlHD}az18>p4`JL`_blW9GdFk&e!X-u}QtFCrUbQG?& zcX-2`BpD=aGnPf(jhEsl4bY?n1*OigY$rQ8FDI=Ao z>6CG5is^Fd13IOk(*&XwnyzI~%TE4HIt_bfE<=fHOqeYEcT2=wSqsl`N!`6qKQf_K zZ)+Cas(;(?{Eudm9bA{tl0CY%zM1Y;nN#<-ZJLP+lwSgr2&?YxH)79V@-hJhodvok zNnxl6*045=o+IdzUnZmsD{3ABuS7kD&#V3&kvw-ePTF&rD08avr5!l}B zNj)i_C35^Uu-vI*%g9>tB1BQ>wl_g90>|qqjN8FpGaIAYR+T%4>d1Q+l3^2ltRV`d zE_C-r*IAKuopB9_towpneowu&b45PEGhUt<(S2uJG5QSnbx%&n8_e^AXWhVTpCGX78lo$c!G7$|!4QjmC^-%2TFgs6RYr z91cn@ZO*+Y2|6{(ck1I9@}0_k)Xja=F3TDzD=lO6Kb4uBbw_E*Ub1X;svqsCsVNg7 z;ipeXl)34{6pae^_Z)Hi;g*c3zyQu26Rltj!}1wlAB@Bn-)scmZo(1Ox#b zj`N^6Shy#hx5pw-O8^%L>;UyNqtB4CnMeJarDf?kx&Q(kNWT+EADxGml)EA2N#_=l z3`9_hj?cV7-kU~qXA3VMd`^7&>k#)@@w7DLXC_1^!eCEB=`s6Ts;B#jZ~`(;Xw|*$ zr`pjBY)?mQ$QB*!&Zu*)|JS1+SJ7v19mkSdR+^_@SLcq*QSThKwtSbkbb~-y)YA!N zovch=qnSxbVb2=ZGX6SnwB0J4J95W6m(zf{f=hCv=h&Rsv};l4rtBd zE2OJhUC|m!9)Lf8_&P?; z+P)D(rY)z(pTmTgu0hN8(YHLxOC+iD^etWod=p%OXuvv|GmH^~z6>HhQGY6i#rx>8 zrnX@fW5_D(fHbUJg6@W|VX@yC$=6{5d!lQKBlHF)INtT3UL*L0y4#b^cM#PT5nYkl zQ+?O7Lz|6Wjr4Ecy;(khl`Viz0V)9~F*zL&1`GlWKpdb0J_kV6NHiy@0gw+8sk6{Y z68KY+wZ+res{S5t4=)Qvf|bE=Ff6yK4SMggM@f9Eldh|=aur}5ppAgiWG(1cK)ZTZ zKbrpuk&&>|H@LO#0gqcNKaTiW%8yAt$wT1s;dEo6hw43-p@zcS^JA*q2_`opR>*2T zx~}L&8^0B!A-uK+PieBxavpWCI4bOEG3R*{imAi_2n*d$xKLyZ0EpZ#^>j#_9|i?`G&bCtNH2FRLSAgVR!<-71RKVH?RT}7t}^jTLCyB f3GYhWX5Zm9J#d}xGV9TS=r2Gw2cn+SmG%DvLy8v! diff --git a/DSA/__pycache__/subspace_dmdc.cpython-39.pyc b/DSA/__pycache__/subspace_dmdc.cpython-39.pyc index 9c4763aa8c1936cd2dfb70d438c2db6c5f42a047..1f0f87ffcacf3207ce03f652445ee414096e6ae1 100644 GIT binary patch delta 8188 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 delta 6265 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 27\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mdsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_score\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 28\u001b[0m sim\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m#TODO: check generalized dsa with other data structures for data and inputs\u001b[39;00m\n\u001b[1;32m 31\u001b[0m \u001b[38;5;66;03m#TODO: check generalized dsa with the other comparison metric and changing the config\u001b[39;00m\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:692\u001b[0m, in \u001b[0;36mGeneralizedDSA.fit_score\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 680\u001b[0m \u001b[38;5;124;03mStandard fitting function for both DMDs and PAVF\u001b[39;00m\n\u001b[1;32m 681\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 689\u001b[0m \u001b[38;5;124;03m data matrix of the similarity scores between the specific sets of data\u001b[39;00m\n\u001b[1;32m 690\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 691\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfit_dmds()\n\u001b[0;32m--> 692\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscore\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:797\u001b[0m, in \u001b[0;36mGeneralizedDSA.score\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 792\u001b[0m loop \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 793\u001b[0m pairs\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose\n\u001b[1;32m 795\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(pairs, desc\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComputing DMD similarities\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 796\u001b[0m )\n\u001b[0;32m--> 797\u001b[0m results \u001b[38;5;241m=\u001b[39m [compute_similarity(i, j) \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m loop]\n\u001b[1;32m 799\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:797\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 791\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 792\u001b[0m loop \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 793\u001b[0m pairs\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose\n\u001b[1;32m 795\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(pairs, desc\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComputing DMD similarities\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 796\u001b[0m )\n\u001b[0;32m--> 797\u001b[0m results \u001b[38;5;241m=\u001b[39m [\u001b[43mcompute_similarity\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mj\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m loop]\n\u001b[1;32m 799\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[1;32m 800\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/dsa.py:768\u001b[0m, in \u001b[0;36mGeneralizedDSA.score..compute_similarity\u001b[0;34m(i, j)\u001b[0m\n\u001b[1;32m 761\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msimdist_has_control \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmd_has_control:\n\u001b[1;32m 762\u001b[0m simdist_args\u001b[38;5;241m.\u001b[39mextend(\n\u001b[1;32m 763\u001b[0m [\n\u001b[1;32m 764\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_dmd_control_matrix(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmds[\u001b[38;5;241m0\u001b[39m][i]),\n\u001b[1;32m 765\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_dmd_control_matrix(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmds[ind2][j]),\n\u001b[1;32m 766\u001b[0m ]\n\u001b[1;32m 767\u001b[0m )\n\u001b[0;32m--> 768\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimdist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_score\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msimdist_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 770\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_jobs \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 771\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcomputing similarity between DMDs \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mj\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:471\u001b[0m, in \u001b[0;36mSimilarityTransformDist.fit_score\u001b[0;34m(self, A, B, iters, lr, score_method, wasserstein_weightings)\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 469\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m--> 471\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 472\u001b[0m \u001b[43m \u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 473\u001b[0m \u001b[43m \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 474\u001b[0m \u001b[43m \u001b[49m\u001b[43miters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 475\u001b[0m \u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 476\u001b[0m \u001b[43m \u001b[49m\u001b[43mwasserstein_weightings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwasserstein_weightings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 477\u001b[0m \u001b[43m \u001b[49m\u001b[43mscore_method\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscore_method\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 478\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 480\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscore(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mB, score_method\u001b[38;5;241m=\u001b[39mscore_method)\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:254\u001b[0m, in \u001b[0;36mSimilarityTransformDist.fit\u001b[0;34m(self, A, B, iters, lr, score_method, wasserstein_weightings)\u001b[0m\n\u001b[1;32m 248\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star \u001b[38;5;241m/\u001b[39m torch\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mnorm(\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, keepdim\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 250\u001b[0m )\n\u001b[1;32m 251\u001b[0m \u001b[38;5;66;03m# wasserstein_distance(A.cpu().numpy(),B.cpu().numpy())\u001b[39;00m\n\u001b[1;32m 252\u001b[0m \n\u001b[1;32m 253\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 254\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlosses, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msim_net \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize_C\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morthog\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 257\u001b[0m \u001b[38;5;66;03m# permute the first row and column of B then rerun the optimization\u001b[39;00m\n\u001b[1;32m 258\u001b[0m P \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39meye(B\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], device\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:334\u001b[0m, in \u001b[0;36mSimilarityTransformDist.optimize_C\u001b[0;34m(self, A, B, lr, iters, orthog, verbose)\u001b[0m\n\u001b[1;32m 332\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m 333\u001b[0m \u001b[38;5;66;03m# Compute the Frobenius norm between A and the product.\u001b[39;00m\n\u001b[0;32m--> 334\u001b[0m loss \u001b[38;5;241m=\u001b[39m simdist_loss(A, \u001b[43msim_net\u001b[49m\u001b[43m(\u001b[49m\u001b[43mB\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 336\u001b[0m loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[1;32m 338\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:64\u001b[0m, in \u001b[0;36mLearnableSimilarityTransform.forward\u001b[0;34m(self, B)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, B):\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39morthog:\n\u001b[0;32m---> 64\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m \u001b[38;5;241m@\u001b[39m B \u001b[38;5;241m@\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 66\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC \u001b[38;5;241m@\u001b[39m B \u001b[38;5;241m@\u001b[39m torch\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39minv(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/utils/parametrize.py:368\u001b[0m, in \u001b[0;36m_inject_property..get_parametrized\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m get_cached_parametrization(parametrization)\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 367\u001b[0m \u001b[38;5;66;03m# If caching is not active, this function just evaluates the parametrization\u001b[39;00m\n\u001b[0;32m--> 368\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mparametrization\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/utils/parametrize.py:273\u001b[0m, in \u001b[0;36mParametrizationList.forward\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 271\u001b[0m curr_idx \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 272\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28mstr\u001b[39m(curr_idx)):\n\u001b[0;32m--> 273\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mcurr_idx\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 274\u001b[0m curr_idx \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 275\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/dsa_test_env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py:128\u001b[0m, in \u001b[0;36mCayleyMap.forward\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, X):\n\u001b[1;32m 127\u001b[0m \u001b[38;5;66;03m# (I + X)(I - X)^{-1}\u001b[39;00m\n\u001b[0;32m--> 128\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinalg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mId\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mId\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[0;32m/Users/mitchellostrow/Desktop/Projects/DSAv2/DSAPublic2/DSA/DSA/simdist.py\u001b[0m(128)\u001b[0;36mforward\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m 126 \u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 127 \u001b[0;31m \u001b[0;31m# (I + X)(I - X)^{-1}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m--> 128 \u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mId\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mId\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 129 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[0;32m 130 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0m\n" - ] + "data": { + "text/plain": [ + "(3, 3)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -357,29 +335,187 @@ " dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", " verbose=True)\n", "sim = dsa.fit_score()\n", - "sim.shape\n", - "\n", - "#TODO: check generalized dsa with other data structures for data and inputs\n", - "#TODO: check generalized dsa with the other comparison metric and changing the config\n" + "sim.shape" ] }, { "cell_type": "code", - "execution_count": null, - "id": "ab0dbe0a", + "execution_count": 46, + "id": "2ea88dc2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/n/home00/ahuang/DSA/DSA/dsa.py:618: UserWarning: When using cross-comparison with a list of arrays, gDSA treats each array as its own system.\n", + "If arrays within X (and Y) are samples from the same system, switch to using X=[X,Y], X_control=[X_control,Y_control], Y=None, and Y_control=None.\n", + " warnings.warn(\n", + "/n/home00/ahuang/DSA/DSA/dsa.py:408: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", + " warnings.warn(\n", + "\n", + "Fitting DMDs: 100%|██████████| 9/9 [00:00<00:00, 2031.58it/s]\n", + "\n", + "Fitting DMDs: 100%|██████████| 9/9 [00:00<00:00, 2208.82it/s]\n", + "\n", + "\u001b[A\n", + "\u001b[A\n", + "\u001b[A\n", + "\u001b[A" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[46], line 35\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Check generalized dsa with other data structures for data and inputs\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# Self-comparison (using X and X_control)\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;66;03m# Should return a 3x3 distance matrix\u001b[39;00m\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m#TODO: when doing cross-comparison and using a list of arrays, gDSA treats each array as its own system\u001b[39;00m\n\u001b[1;32m 31\u001b[0m dsa \u001b[38;5;241m=\u001b[39m GeneralizedDSA(X\u001b[38;5;241m=\u001b[39md3, X_control\u001b[38;5;241m=\u001b[39mu3,\n\u001b[1;32m 32\u001b[0m Y\u001b[38;5;241m=\u001b[39md3, Y_control\u001b[38;5;241m=\u001b[39mu3,\n\u001b[1;32m 33\u001b[0m dmd_class\u001b[38;5;241m=\u001b[39mDMDc,dmd_config\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mdict\u001b[39m(n_delays\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,rank_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,rank_output\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m),\n\u001b[1;32m 34\u001b[0m verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m---> 35\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[43mdsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_score\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 36\u001b[0m sim\u001b[38;5;241m.\u001b[39mshape\n", + "File \u001b[0;32m~/DSA/DSA/dsa.py:704\u001b[0m, in \u001b[0;36mGeneralizedDSA.fit_score\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 691\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 692\u001b[0m \u001b[38;5;124;03mStandard fitting function for both DMDs and PAVF\u001b[39;00m\n\u001b[1;32m 693\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 701\u001b[0m \u001b[38;5;124;03m data matrix of the similarity scores between the specific sets of data\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 703\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfit_dmds()\n\u001b[0;32m--> 704\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscore\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/DSA/DSA/dsa.py:809\u001b[0m, in \u001b[0;36mGeneralizedDSA.score\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 803\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 804\u001b[0m loop \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 805\u001b[0m pairs\n\u001b[1;32m 806\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose\n\u001b[1;32m 807\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(pairs, desc\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComputing DMD similarities\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 808\u001b[0m )\n\u001b[0;32m--> 809\u001b[0m results \u001b[38;5;241m=\u001b[39m [compute_similarity(i, j) \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m loop]\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/DSA/DSA/dsa.py:809\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 803\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 804\u001b[0m loop \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 805\u001b[0m pairs\n\u001b[1;32m 806\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose\n\u001b[1;32m 807\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(pairs, desc\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComputing DMD similarities\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 808\u001b[0m )\n\u001b[0;32m--> 809\u001b[0m results \u001b[38;5;241m=\u001b[39m [\u001b[43mcompute_similarity\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mj\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m i, j \u001b[38;5;129;01min\u001b[39;00m loop]\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m result \u001b[38;5;129;01min\u001b[39;00m results:\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/DSA/DSA/dsa.py:780\u001b[0m, in \u001b[0;36mGeneralizedDSA.score..compute_similarity\u001b[0;34m(i, j)\u001b[0m\n\u001b[1;32m 773\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msimdist_has_control \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmd_has_control:\n\u001b[1;32m 774\u001b[0m simdist_args\u001b[38;5;241m.\u001b[39mextend(\n\u001b[1;32m 775\u001b[0m [\n\u001b[1;32m 776\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_dmd_control_matrix(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmds[\u001b[38;5;241m0\u001b[39m][i]),\n\u001b[1;32m 777\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_dmd_control_matrix(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdmds[ind2][j]),\n\u001b[1;32m 778\u001b[0m ]\n\u001b[1;32m 779\u001b[0m )\n\u001b[0;32m--> 780\u001b[0m sim \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimdist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_score\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msimdist_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 782\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_jobs \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 783\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcomputing similarity between DMDs \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mi\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mj\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/DSA/DSA/simdist.py:471\u001b[0m, in \u001b[0;36mSimilarityTransformDist.fit_score\u001b[0;34m(self, A, B, iters, lr, score_method, wasserstein_weightings)\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 469\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m--> 471\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 472\u001b[0m \u001b[43m \u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 473\u001b[0m \u001b[43m \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 474\u001b[0m \u001b[43m \u001b[49m\u001b[43miters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 475\u001b[0m \u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 476\u001b[0m \u001b[43m \u001b[49m\u001b[43mwasserstein_weightings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwasserstein_weightings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 477\u001b[0m \u001b[43m \u001b[49m\u001b[43mscore_method\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscore_method\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 478\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 480\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscore(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mB, score_method\u001b[38;5;241m=\u001b[39mscore_method)\n", + "File \u001b[0;32m~/DSA/DSA/simdist.py:254\u001b[0m, in \u001b[0;36mSimilarityTransformDist.fit\u001b[0;34m(self, A, B, iters, lr, score_method, wasserstein_weightings)\u001b[0m\n\u001b[1;32m 248\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star \u001b[38;5;241m/\u001b[39m torch\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mnorm(\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, keepdim\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 250\u001b[0m )\n\u001b[1;32m 251\u001b[0m \u001b[38;5;66;03m# wasserstein_distance(A.cpu().numpy(),B.cpu().numpy())\u001b[39;00m\n\u001b[1;32m 252\u001b[0m \n\u001b[1;32m 253\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 254\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlosses, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mC_star, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msim_net \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize_C\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morthog\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 257\u001b[0m \u001b[38;5;66;03m# permute the first row and column of B then rerun the optimization\u001b[39;00m\n\u001b[1;32m 258\u001b[0m P \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39meye(B\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], device\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n", + "File \u001b[0;32m~/DSA/DSA/simdist.py:338\u001b[0m, in \u001b[0;36mSimilarityTransformDist.optimize_C\u001b[0;34m(self, A, B, lr, iters, orthog, verbose)\u001b[0m\n\u001b[1;32m 334\u001b[0m loss \u001b[38;5;241m=\u001b[39m simdist_loss(A, sim_net(B))\n\u001b[1;32m 336\u001b[0m loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[0;32m--> 338\u001b[0m \u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 339\u001b[0m \u001b[38;5;66;03m# if _ % 99:\u001b[39;00m\n\u001b[1;32m 340\u001b[0m \u001b[38;5;66;03m# scheduler.step()\u001b[39;00m\n\u001b[1;32m 341\u001b[0m losses\u001b[38;5;241m.\u001b[39mappend(loss\u001b[38;5;241m.\u001b[39mitem())\n", + "File \u001b[0;32m~/.conda/envs/py39/lib/python3.9/site-packages/torch/optim/optimizer.py:493\u001b[0m, in \u001b[0;36mOptimizer.profile_hook_step..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 488\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 489\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[1;32m 490\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must return None or a tuple of (new_args, new_kwargs), but got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 491\u001b[0m )\n\u001b[0;32m--> 493\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 494\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_optimizer_step_code()\n\u001b[1;32m 496\u001b[0m \u001b[38;5;66;03m# call optimizer step post hooks\u001b[39;00m\n", + "File \u001b[0;32m~/.conda/envs/py39/lib/python3.9/site-packages/torch/optim/optimizer.py:91\u001b[0m, in \u001b[0;36m_use_grad_for_differentiable.._use_grad\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 89\u001b[0m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefaults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdifferentiable\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 90\u001b[0m torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n\u001b[0;32m---> 91\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 93\u001b[0m torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n", + "File \u001b[0;32m~/.conda/envs/py39/lib/python3.9/site-packages/torch/optim/adam.py:218\u001b[0m, in \u001b[0;36mAdam.step\u001b[0;34m(self, closure)\u001b[0m\n\u001b[1;32m 210\u001b[0m \u001b[38;5;129m@_use_grad_for_differentiable\u001b[39m\n\u001b[1;32m 211\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstep\u001b[39m(\u001b[38;5;28mself\u001b[39m, closure\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 212\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Perform a single optimization step.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \n\u001b[1;32m 214\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[1;32m 215\u001b[0m \u001b[38;5;124;03m closure (Callable, optional): A closure that reevaluates the model\u001b[39;00m\n\u001b[1;32m 216\u001b[0m \u001b[38;5;124;03m and returns the loss.\u001b[39;00m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cuda_graph_capture_health_check\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 220\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m closure \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/.conda/envs/py39/lib/python3.9/site-packages/torch/optim/optimizer.py:436\u001b[0m, in \u001b[0;36mOptimizer._cuda_graph_capture_health_check\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_cuda_graph_capture_health_check\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 421\u001b[0m \u001b[38;5;66;03m# Note [torch.compile x capturable]\u001b[39;00m\n\u001b[1;32m 422\u001b[0m \u001b[38;5;66;03m# If we are compiling, we try to take the capturable path automatically by\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[38;5;66;03m# Thus, when compiling, inductor will determine if cudagraphs\u001b[39;00m\n\u001b[1;32m 430\u001b[0m \u001b[38;5;66;03m# can be enabled based on whether there is input mutation or CPU tensors.\u001b[39;00m\n\u001b[1;32m 431\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 432\u001b[0m \u001b[38;5;129;01mnot\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcompiler\u001b[38;5;241m.\u001b[39mis_compiling()\n\u001b[1;32m 433\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mbackends\u001b[38;5;241m.\u001b[39mcuda\u001b[38;5;241m.\u001b[39mis_built()\n\u001b[1;32m 434\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcuda\u001b[38;5;241m.\u001b[39mis_available()\n\u001b[1;32m 435\u001b[0m ):\n\u001b[0;32m--> 436\u001b[0m capturing \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcuda\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mis_current_stream_capturing\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 438\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m capturing \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mall\u001b[39m(\n\u001b[1;32m 439\u001b[0m group[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcapturable\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m group \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparam_groups\n\u001b[1;32m 440\u001b[0m ):\n\u001b[1;32m 441\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[1;32m 442\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAttempting CUDA graph capture of step() for an instance of \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 443\u001b[0m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\n\u001b[1;32m 444\u001b[0m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m but param_groups\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m capturable is False.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 445\u001b[0m )\n", + "File \u001b[0;32m~/.conda/envs/py39/lib/python3.9/site-packages/torch/cuda/graphs.py:30\u001b[0m, in \u001b[0;36mis_current_stream_capturing\u001b[0;34m()\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mis_current_stream_capturing\u001b[39m():\n\u001b[1;32m 26\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Return True if CUDA graph capture is underway on the current CUDA stream, False otherwise.\u001b[39;00m\n\u001b[1;32m 27\u001b[0m \n\u001b[1;32m 28\u001b[0m \u001b[38;5;124;03m If a CUDA context does not exist on the current device, returns False without initializing the context.\u001b[39;00m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 30\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_cuda_isCurrentStreamCapturing\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ - "\n" + "# Check generalized dsa with other data structures for data and inputs\n", + "\n", + "# Self-comparison (using X and X_control)\n", + "# d4s = [d4 for _ in range(3)]\n", + "# u4s = [u4 for _ in range(3)]\n", + "# dsa = GeneralizedDSA(d4s,X_control=u4s,\n", + "# dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", + "# verbose=True)\n", + "# sim = dsa.fit_score()\n", + "# sim.shape\n", + "\n", + "# d5s = [d5 for _ in range(3)]\n", + "# u5s = [u5 for _ in range(3)]\n", + "# dsa = GeneralizedDSA(d5s,X_control=u5s,\n", + "# dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", + "# verbose=True)\n", + "# sim = dsa.fit_score()\n", + "# sim.shape\n", + "\n", + "# Cross-comparison (using X and X_control, Y and Y_control)\n", + "# Should return a 3x3 distance matrix\n", + "# dsa = GeneralizedDSA(X=d3s, X_control=u3s,\n", + "# Y=d3s, Y_control=u3s,\n", + "# dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", + "# verbose=True)\n", + "# sim = dsa.fit_score()\n", + "# sim.shape\n", + "\n", + "# Should return a 3x3 distance matrix\n", + "#TODO: when doing cross-comparison and using a list of arrays, gDSA treats each array as its own system\n", + "dsa = GeneralizedDSA(X=d3, X_control=u3,\n", + " Y=d3, Y_control=u3,\n", + " dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", + " verbose=True)\n", + "sim = dsa.fit_score()\n", + "sim.shape" ] }, { "cell_type": "code", - "execution_count": null, - "id": "57132dea", + "execution_count": 39, + "id": "997a05d3", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/n/home00/ahuang/DSA/DSA/dsa.py:408: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", + " warnings.warn(\n", + "\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 1006.55it/s]\n", + "\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 1508.20it/s]\n", + "\n", + "\u001b[A\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:01<00:00, 1.72s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "()" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dsa = GeneralizedDSA(X=d2, X_control=u2,\n", + " Y=d2, Y_control=u2,\n", + " dmd_class=DMDc,dmd_config=dict(n_delays=5,rank_input=5,rank_output=5),\n", + " verbose=True)\n", + "sim = dsa.fit_score()\n", + "sim.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "6a5de212", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/n/home00/ahuang/DSA/DSA/dsa.py:408: UserWarning: Warning: You are using a DMD model that fits a control operator but comparing with a DSA metric that does not compare control operators\n", + " warnings.warn(\n", + "\n", + "Fitting DMDs: 100%|██████████| 3/3 [00:00<00:00, 190.57it/s]\n", + "\n", + "Computing DMD similarities: 100%|██████████| 3/3 [00:00<00:00, 1423.73it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "(3, 3)" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check generalized dsa with the other comparison metric and changing the config\n", + "dmdconfig = DMDConfig(n_delays=20)\n", + "dmdcConfig = DMDcConfig()\n", + "subspaceDmdcConfig = SubspaceDMDcConfig()\n", + "\n", + "simdistconfig = SimilarityTransformDistConfig(score_method='wasserstein')\n", + "csimdistconfig = ControllabilitySimilarityTransformDistConfig(compare='joint',\n", + " score_method='euclidean', align_inputs=False,return_distance_components=True)\n", + "\n", + "\n", + "dsa = GeneralizedDSA(d3s,X_control=u3s,\n", + " dmd_class=SubspaceDMDc,\n", + " dmd_config=subspaceDmdcConfig,\n", + " simdist_config=simdistconfig,\n", + " verbose=True)\n", + "sim = dsa.fit_score()\n", + "sim.shape" + ] } ], "metadata": { From 00bffc18cc03bf24ba9921abfeb894d987c9a26b Mon Sep 17 00:00:00 2001 From: Ann Huang Date: Mon, 3 Nov 2025 19:51:28 -0500 Subject: [PATCH 29/51] updated import section --- examples/all_dsa_types.ipynb | 23 +---------------------- 1 file changed, 1 insertion(+), 22 deletions(-) diff --git a/examples/all_dsa_types.ipynb b/examples/all_dsa_types.ipynb index af6e2cd..ad52778 100644 --- a/examples/all_dsa_types.ipynb +++ b/examples/all_dsa_types.ipynb @@ -2,34 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "773aa0fd", "metadata": {}, "outputs": [], "source": [ "import numpy as np \n", "import matplotlib.pyplot as plt\n", - "import sys\n", - "import importlib\n", - "\n", - "# Remove any local DSA packages from sys.path to force using the installed package\n", - "paths_to_remove = [p for p in sys.path if 'Degeneracy' in p and 'DSA' in p]\n", - "for p in paths_to_remove:\n", - " sys.path.remove(p)\n", - "\n", - "# Also remove the current directory's parent if it contains a DSA package\n", - "# This prevents importing from /n/home00/ahuang/DSA if it's in the path\n", - "# Uncomment the next lines if needed:\n", - "# if '/n/home00/ahuang/DSA' in sys.path:\n", - "# sys.path.remove('/n/home00/ahuang/DSA')\n", - "\n", - "# Force reload to ensure we get the installed package\n", - "if 'DSA' in sys.modules:\n", - " del sys.modules['DSA']\n", - " # Also remove any submodules\n", - " modules_to_remove = [k for k in sys.modules.keys() if k.startswith('DSA.')]\n", - " for k in modules_to_remove:\n", - " del sys.modules[k]\n", "\n", "# Now import from the installed package\n", "from DSA import DSA, GeneralizedDSA, InputDSA\n", From 6fa708d598627993b1d1d971cbff29ec571239cc Mon Sep 17 00:00:00 2001 From: Ann Huang Date: Mon, 3 Nov 2025 20:59:37 -0500 Subject: [PATCH 30/51] Remove tracked .pyc files --- DSA/__pycache__/__init__.cpython-39.pyc | Bin 846 -> 0 bytes DSA/__pycache__/base_dmd.cpython-39.pyc | Bin 8329 -> 0 bytes DSA/__pycache__/dmd.cpython-39.pyc | Bin 18690 -> 0 bytes DSA/__pycache__/dmdc.cpython-39.pyc | Bin 15331 -> 0 bytes DSA/__pycache__/dsa.cpython-39.pyc | Bin 27422 -> 0 bytes DSA/__pycache__/preprocessing.cpython-39.pyc | Bin 10398 -> 0 bytes DSA/__pycache__/resdmd.cpython-39.pyc | Bin 5768 -> 0 bytes DSA/__pycache__/simdist.cpython-39.pyc | Bin 12712 -> 0 bytes .../simdist_controllability.cpython-39.pyc | Bin 6329 -> 0 bytes DSA/__pycache__/stats.cpython-39.pyc | Bin 14707 -> 0 bytes DSA/__pycache__/subspace_dmdc.cpython-39.pyc | Bin 19805 -> 0 bytes DSA/__pycache__/sweeps.cpython-39.pyc | Bin 12913 -> 0 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 682 -> 0 bytes .../__pycache__/koopman.cpython-39.pyc | Bin 19495 -> 0 bytes .../koopman_continuous.cpython-39.pyc | Bin 6336 -> 0 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 390 -> 0 bytes .../__pycache__/_base_analyzer.cpython-39.pyc | Bin 3340 -> 0 bytes .../__pycache__/_ms_pd21.cpython-39.pyc | Bin 12954 -> 0 bytes .../__pycache__/_pruned_koopman.cpython-39.pyc | Bin 5478 -> 0 bytes .../common/__pycache__/__init__.cpython-39.pyc | Bin 482 -> 0 bytes .../__pycache__/validation.cpython-39.pyc | Bin 2548 -> 0 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 338 -> 0 bytes .../__pycache__/_derivative.cpython-39.pyc | Bin 2980 -> 0 bytes .../_finite_difference.cpython-39.pyc | Bin 762 -> 0 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 582 -> 0 bytes .../__pycache__/_base.cpython-39.pyc | Bin 12894 -> 0 bytes .../_custom_observables.cpython-39.pyc | Bin 9876 -> 0 bytes .../__pycache__/_identity.cpython-39.pyc | Bin 3250 -> 0 bytes .../__pycache__/_polynomial.cpython-39.pyc | Bin 10395 -> 0 bytes .../_radial_basis_functions.cpython-39.pyc | Bin 10514 -> 0 bytes .../_random_fourier_features.cpython-39.pyc | Bin 6841 -> 0 bytes .../__pycache__/_time_delay.cpython-39.pyc | Bin 7618 -> 0 bytes .../__pycache__/__init__.cpython-39.pyc | Bin 616 -> 0 bytes .../regression/__pycache__/_base.cpython-39.pyc | Bin 5446 -> 0 bytes .../__pycache__/_base_ensemble.cpython-39.pyc | Bin 13641 -> 0 bytes .../regression/__pycache__/_dmd.cpython-39.pyc | Bin 12168 -> 0 bytes .../regression/__pycache__/_dmdc.cpython-39.pyc | Bin 14310 -> 0 bytes .../regression/__pycache__/_edmd.cpython-39.pyc | Bin 8341 -> 0 bytes .../__pycache__/_edmdc.cpython-39.pyc | Bin 7728 -> 0 bytes .../__pycache__/_havok.cpython-39.pyc | Bin 10095 -> 0 bytes .../regression/__pycache__/_kdmd.cpython-39.pyc | Bin 15216 -> 0 bytes .../__pycache__/_nndmd.cpython-39.pyc | Bin 43155 -> 0 bytes 42 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 DSA/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/__pycache__/base_dmd.cpython-39.pyc delete mode 100644 DSA/__pycache__/dmd.cpython-39.pyc delete mode 100644 DSA/__pycache__/dmdc.cpython-39.pyc delete mode 100644 DSA/__pycache__/dsa.cpython-39.pyc delete mode 100644 DSA/__pycache__/preprocessing.cpython-39.pyc delete mode 100644 DSA/__pycache__/resdmd.cpython-39.pyc delete mode 100644 DSA/__pycache__/simdist.cpython-39.pyc delete mode 100644 DSA/__pycache__/simdist_controllability.cpython-39.pyc delete mode 100644 DSA/__pycache__/stats.cpython-39.pyc delete mode 100644 DSA/__pycache__/subspace_dmdc.cpython-39.pyc delete mode 100644 DSA/__pycache__/sweeps.cpython-39.pyc delete mode 100644 DSA/pykoopman/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/pykoopman/__pycache__/koopman.cpython-39.pyc delete mode 100644 DSA/pykoopman/__pycache__/koopman_continuous.cpython-39.pyc delete mode 100644 DSA/pykoopman/analytics/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/pykoopman/analytics/__pycache__/_base_analyzer.cpython-39.pyc delete mode 100644 DSA/pykoopman/analytics/__pycache__/_ms_pd21.cpython-39.pyc delete mode 100644 DSA/pykoopman/analytics/__pycache__/_pruned_koopman.cpython-39.pyc delete mode 100644 DSA/pykoopman/common/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/pykoopman/common/__pycache__/validation.cpython-39.pyc delete mode 100644 DSA/pykoopman/differentiation/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/pykoopman/differentiation/__pycache__/_derivative.cpython-39.pyc delete mode 100644 DSA/pykoopman/differentiation/__pycache__/_finite_difference.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_base.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_custom_observables.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_identity.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_polynomial.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_radial_basis_functions.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_random_fourier_features.cpython-39.pyc delete mode 100644 DSA/pykoopman/observables/__pycache__/_time_delay.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/__init__.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_base.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_base_ensemble.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_dmd.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_dmdc.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_edmd.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_edmdc.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_havok.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_kdmd.cpython-39.pyc delete mode 100644 DSA/pykoopman/regression/__pycache__/_nndmd.cpython-39.pyc diff --git a/DSA/__pycache__/__init__.cpython-39.pyc b/DSA/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 951b9747a7023ebe1ff6aba5df18b772b0791e24..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 846 zcma)4&5qMB5RRLq`Dxnima@ADxFMth+t^rMU~B}jF%2ws0f#hH5sg$#W9#$42f4_#wl60tp^3#~IaM<{vpA4P zYEI`Chw@l0=)&Si-cw7uv^bXcudrtKD=rhohwUZ{_U}7irdpBFZ?w`M@t5(-i zvTGqlyITt-B-4PdG^@;})+!UGg{+O(_OrLV;+jeEiI>O@-&IZ5B6|E!VoLgX#y6~! zZFZUMi=}SAXm;=Gx>2n9i?%Fi0;NU8Tw()PAj`SGD*DmfrV28^Ll!pnRlS4At zr+=9WLQns1amXakKBN!&0Jc0Y4b%AYw!QWc`6%p20iZsDN%m9g5F-%^{FR0Rs?-y( zXlTo+vd{^d$7q^i^Sng=6iE~77pjCe&@;?@c;Ly4KOavYAt$mKEo%*pE&RxNWA-f? z%^O`8+!#@9_hHQq^t*HP36QP${$y3HZfeCZE>`TOW7T#Ab?letq7rSMpEtWce4*;H Xll&zCqB#Tch$Li5<{*FGkl_6R*x=^2 diff --git a/DSA/__pycache__/base_dmd.cpython-39.pyc b/DSA/__pycache__/base_dmd.cpython-39.pyc deleted file mode 100644 index a7657d2844e5f6c098e7fa73accd739ca9d4e83b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8329 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 BX}tgd diff --git a/DSA/__pycache__/dmdc.cpython-39.pyc b/DSA/__pycache__/dmdc.cpython-39.pyc deleted file mode 100644 index 9533bd2f75f1e39a42a2698d3771a31d046a2b4b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 15331 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 diff --git a/DSA/__pycache__/dsa.cpython-39.pyc b/DSA/__pycache__/dsa.cpython-39.pyc deleted file mode 100644 index e21f06b33a81577000b57dd0428a44dd0ffbfc2d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 27422 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 diff --git a/DSA/__pycache__/resdmd.cpython-39.pyc b/DSA/__pycache__/resdmd.cpython-39.pyc deleted file mode 100644 index 739410ca5d8a8a488e27839efcada6d350d730c5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5768 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 diff --git a/DSA/__pycache__/simdist.cpython-39.pyc b/DSA/__pycache__/simdist.cpython-39.pyc deleted file mode 100644 index a17978e8c78cec264e3208a4079d262387141786..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12712 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 diff --git a/DSA/__pycache__/stats.cpython-39.pyc b/DSA/__pycache__/stats.cpython-39.pyc deleted file mode 100644 index 08967db9ccf0c2fd6403600d2a0846b410fbd394..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14707 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 diff --git a/DSA/__pycache__/subspace_dmdc.cpython-39.pyc b/DSA/__pycache__/subspace_dmdc.cpython-39.pyc deleted file mode 100644 index 1f0f87ffcacf3207ce03f652445ee414096e6ae1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 19805 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 diff --git a/DSA/__pycache__/sweeps.cpython-39.pyc b/DSA/__pycache__/sweeps.cpython-39.pyc deleted file mode 100644 index be6992b3b06e7a111aa0472e55d93fe8c92af800..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12913 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 diff --git a/DSA/pykoopman/__pycache__/koopman.cpython-39.pyc b/DSA/pykoopman/__pycache__/koopman.cpython-39.pyc deleted file mode 100644 index 7e90f78f96d4be1277e46d326c22bb6fe022fea1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 19495 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 diff --git a/DSA/pykoopman/analytics/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/analytics/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 5ab5adcfe56b69f3367abd069369628976a26b8a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 390 zcmYjMJx{|h5Ve!0NlOX?zak51J26yt+$0{x4xWq2Fa>z+yWVgB;~!5h;l+6aJ(~v! z$v|3Y*>VxYjl5_f3}%}Jj$^<(H{cjV^078 diff --git a/DSA/pykoopman/analytics/__pycache__/_base_analyzer.cpython-39.pyc b/DSA/pykoopman/analytics/__pycache__/_base_analyzer.cpython-39.pyc deleted file mode 100644 index b1a6539a9da43facb3ab6c475f5c47e23b885280..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3340 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 diff --git a/DSA/pykoopman/analytics/__pycache__/_pruned_koopman.cpython-39.pyc b/DSA/pykoopman/analytics/__pycache__/_pruned_koopman.cpython-39.pyc deleted file mode 100644 index 65135340eee983210a5b595302963a235ae111cf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5478 zcmcIo%X8dF8P{tb9*@VGs6kZ~QGBb>%|-0tzn6?`ui(^2Di7K~vNE)aw5F*WbIv7Zw@@ zuIO(y?_bvq;~(@ee%W~V+%U}e0SIAq3}Fh(H~Ut{GKsc*yW`;Q_?3ROQ`LPHzt*pJ z>Zb7vLsUiWl_6>`t+mmR}h!%}xXKinylfdC=Fz2bykz zUKKYqy#V^AxTWbu&}-thrk6n95g%%L8T5C=N19#{cOe#*Ej)oNq$qaC|6VZ+-NTZe zWQX1}8L&`!hhD(_p}6+7y!IJS*na$6%EgRPf> z++y1S^MW|xL07WyfbB=8$GI}v<-HgSuEc<@v9;KG5VZrrmExzZEw(Ft*@Zg5Q+Qn& zUMR*y4i{WMf#!bhC3@%N z*3ewOvz#YO6a+)QE_lM(J{hUDB{Y$eFqWLflbp^4IJPv|IC(-KPe9}r!uwI-8I$Z{ zZ~esWhCUE|L1G8;oZo~(Mq3AKUNF+zoI=+dvAcI~Crp^vk9^se0qp$Vz0o#OwZ*O+ zu>F?z58m?r;TC(M!bqy*w9S4ilT^Xd_JQb^BS2p$6{<1W?#-G*f*dznZ6MV779$yI zj5If9Ff1O^)JP!OZ{D=NnDQUQp5f{<9VYie9cbRfa~1=}V`%q>kC>i00!Oau1!&EM!_)MY~BhKNh#T&R8ZR+QR=KW#RiE2G+oEje&{Q z6z0J8h(h0yd4%M4?5Ix?=Z{Et=&c9?$;IBuERiS^b6Zta!!28!3_qDeh_mYf+$Km= z=(`7!!@gwfX4hvJSY~azEhlpz@B>u^L(NsyL49MWCEWh=v&~?$7xv}-`QarNBlfZyl%Yd<{`r^b53-c)m>yWFLB*_U>7&h7*^G)nhm>YI@Z~ZiG0~E z2X{$S2s6B+8AiDp8a!Xz{``h4s(T*Aw1<7nfzvym50`|F}#LdCv1xaX+JtG zlk4ye@pw8BOsSGmlIkFeujI#NjQ`ze*&<#H*%V6-pGlQib3&@am)dszU5d55x8^fD zioMKynpr`VRedT>4zr3MC-GOAwdZCIdAXXy1oToC&8@GRdtA#=i}cDo>8zBl>uTSR zdR|tA^`(BIttoGoX|Rob{scs<>(<3ZbJ1!#%syM0K;FivOQt~PpuOlb5HJJOug8|U zF)+{JN5X;;kfPy9=QiFt7v{3@g8Zs7ut3>K^}IH)sh@m`--JJv*=jugy){#fbn-q- zVRtO_QsSbDONGxjo_nzzt@JkSpXj`LmB~%4Gdmd%&E++Pn%CdrYSl9bm0&-sL7P2} z+;tnT6iyn3`T$L4?x|I}J4$lDFbMS_dODRu!jx4sv}r4-6*a?eFtV_OhS@Z)Sq<}S zb&l#@gJ6KbW{KTMUBF%r1=OOuiz6lv|8ZRVy?RHh=t0R;z4 z*5l74PCh+vpW!gU!oWYpW9;pJV=7|PvUH$QpMsu(i3r&9evkfGCm!n(#GcnBZzwOK zuY`E_Du}7tSL@&aTogH{u~@141G-Bn%ae|fs&_;3h^A9U(ei-vMmU2ax@gU9#1Zex zHrov$L8{yi+S?=H>E}G)6I?|pd>X8|{gSY1?OK*;eS5YviFfz<oFW_GjO7?4`1$1=<43Cc-X#9nQ+8U{ zsMZefsmOJ+hD#qL@O=(+({;Z}xnI1gxvmJiuB%oE(?`^NLXFPlEl^oKDo&^B`}E=m z)ND}GriLsjSApKykLZz33S$jfs-l9OwjI;_y6N0qUZ~%$uj1!eDE{%U6n~=2KG1q* ztD%03d9;s%luj@JOdgX}bTyq98>={qw1>x#@KuZi3M diff --git a/DSA/pykoopman/common/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/common/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index f60137089be86dda8f3b4f7309ba050654ecb63a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 482 zcmZ8dJx{|h5ViBIwyC=CBeIYR!B!!VIwF>CUQQ-<+bI4Bc9JUm95yxveoa=U{sktS z2qDB-etP$GXTLj|rZeQCeviu!jL_$p{0+|~cL-s-afBg;1(KLxjF`uK;YpwP6Av5@ zNHFox@sNZV9T1CNF^O2bLs@bj-_7tar%LIDHle2%s4=v6B`Gty21OMZ zeX>qic2ty%HXKS-w@tP(fonA32$2I4Fk>ybpsb^+;2=uHsR7&DhD)++v}rA{UQt;V zmPA4uu3kvou^O~3h;OQEk{I3ra}rrSOzl_O-;UG@eF8~Uxz~b`Kncr<-#u{>7S9L4 z2d}b^Sv<@D_HEM|4q(RB4YMEPZrFd8hZukg0q};*e4Jy1ubW)uM=kk!ozr7W)gj;R r?x$P#mDaVhkQZ7?t#WX?C>wywx*w8_)T|Z!cHE~;94x#AcE|e$_Y#K_ diff --git a/DSA/pykoopman/common/__pycache__/validation.cpython-39.pyc b/DSA/pykoopman/common/__pycache__/validation.cpython-39.pyc deleted file mode 100644 index 311f5df999b16a344ca7e8ce4a2d6f3ee2ed9b85..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2548 zcmZ`)&2Jk;6rb5$f5c7Fs`M)rpasFfRqIqB0jjD(p{L6trAjO~rrv+m3| zi6iGiiU0{JkT@VtE#lG(;=~d0XP~`uArc29Zd}UmjqNxEb*$Ze^ZY)3^S(wbEL0d) z|EE&&-66()r_I3?V)F)L++G7AndB+!@ioqg4$@#P#5YW%USX}snJVqFwX!O=xQt}s zE?=9IMOnJb)(WyL=kTq_V3k!Xd*q?Y^Fu=G%n6rd+TNgjv!j~bx-dozn*j+;7NIEO zd5e%d%NcWQ#2jA_b^{xGI`mW|`7ZyM>$j&ov*HS_IAXitUtzaS>;$efVxwS*jreXr z)J1mZl@VKoz4fvTx`FA8*!?*f%HTn;!(4@QcOdN!4ft2woE~w>2F!fnA{lvK_Z+`p z9`OfU7NGqrJaab>G(UQ3VHZ5;6uR8}0-d7QS@ZvS{IGcx2!Rg>7G+_Hbp!hcBugX- z+lR@c3_tOhWgr<*UG@NI>}klAy~Xkr51pktcVqkPR@@s{7vEN~kLS5G>8kkMl~}}S z0)Eyyz~4hi+1?|p?dRM~FSbpQ3KM7MfNaf>@b=M}TtBmkOE%Q@3)huyyAIiQvF&7o zRK`8wnw@y7W;>#+8xtsMXSFc@u|N6~5Oti}jtuzz(c#%95X<7|)zLj&A^W-5jr=axDtIK-1ll9d3 z^UI<$fWzf0tC#)LA9k~>-xGSdne}>^UYRL zm!k?V^Gfi%e=qW*_{P|m1FzYn=ucM!qJ-xi>We=?ICdX(^njahP)&j4sK|BjLgJzJ zBXA26_2awYwVjZ9V-zm2^-_x`sN5g;JuYWlbn=vYjGaWcj6(Fw*%7*!H2<%){vVB1 zrf=>e`R$2Fo}M9@d7OCrdFpNU&nl)5syw=}N9ptRI0SKE{q=fv&QN6X`NSd%{Zwsb zx7W=gu`1ijWVTKXVKDQUd5XA)Z8xnS7(jW15=`?b>4|nVGRH}#*xeMSZSx|^XOKE` zlC-HB#;+x!2vQY~J%bmcNzkSZbW|hm2pc!*x?j^mH)5sHmCDvC-pYHzh@NuFSie2Dzx)>J z@r76qdi`N-(w?4A{x8#1ho8(&KnSB^A8#c+1bCY{BMn-Y^>7TinQ12yO(Ow<76S=p z{E?t-vR>Tq;2W{fGN!{JQG*`9kAae{zOWX)HWJ~5+qTiDd3a|isQ|tqOd@WlD#qZT zIW{%1KQW(hGAS|tGA+m{4vB~opm9iDHi7AnG4@Abt_s9^-@#;9b_6oyIx4mZGR5(> z!t`y8BS2YcP=bKk!(LHtVDw{&m}Y@MT!`HObx-*0XmZsSzrD;+)`vu^IeW<5#H&ouZ_am`|EF_o=`<2h1DEX3eI58(@b3}B;d#vWdTF+=U2 zFFa=PO|UGTk{v(F4GsM2p}bPBw+2X^s@Dx2G%xu4jQuQN3@KrBZQzpB`l(=^A)zAX smufn51RH-7cykA)kDo&xL-}GalY>-UqLA8oyyk;4pAU-Rd|Y1o7guYdvj6}9 diff --git a/DSA/pykoopman/differentiation/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/differentiation/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index f30cf1995ee178433546d00e0379099e34f94dc4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 338 zcmYjMOKQU~5S8R#>Nrq(3vVhPAcPi7m)&Hi%^)f{5z)uUb|5Dz-Ss@)c9ko1Rmr8F zfq8l}ym^}8n@x#A^zVgw4ev)R{s#%g144Lc0ue}HjSOZOBSA!>iAh+p@KmQJV_D#t z$Pa|&qS&K)b&Xy%p4Z%3H}X+AJ6!R1uWY4P=g>RLptyZfR*kY%T_?S?FVd$$=Cc6L zbupI!-84>K0{FPoyaw?*zDU^}bc+RuKaV&*7XVyqfH&lCqGyE99kul6jBFapj}x~C s+U_5h>@O$hdc!UKF&fpfIR%Ix0NnSNd9^i8Oj_>ZHA5btA{DO47t`NYj{pDw diff --git a/DSA/pykoopman/differentiation/__pycache__/_derivative.cpython-39.pyc b/DSA/pykoopman/differentiation/__pycache__/_derivative.cpython-39.pyc deleted file mode 100644 index 489e8936c4a0684c00fe5e68ed81968c99a6cc9c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2980 zcmcgu&u`l{6c%OKmK7)M+O1emBhX=}hR*JFMo_F>iXI9SMH6g*FES(2v1&=wNGgc~ z_p$`&Y5N;GV3z_r?7!ImpzBUOZ>OF19_83h+M(NJ48-s^-}~PCKALTA1`d?s*LLzp z$8mng&U*2n^OfTey$22M3>{9mo07~Ox&+&ew2^s3&$hj^nYD&3+is@q%pdyDZt-^7 z$%0`(oJS7#dFRaG9pRrgh8sNCb;6C4U%pkWD1@SM%Cr`mj-{eJ8IOe$xk;EwWKJ_- zCX&OPk{LA454A}$ zW~6%K*4wtgj)XHKq9iX$6XR*?1@VSL^fuJO84|$UP;|8zG8xdtywX2mSskxIHBphgA@B z-AiO&71!sr0=Z7_q*Vq{}fCJjy)Cy zfW@&W4BJlyoz@uXo}G+|rAS>Nt?+w{oIxp@lerUtQUL?V6C~vH2%y!WTX|ZfV+A7T zymr(E{QK*EKkrXKB<|krvq=fO?eFZ~w_h=vN?Bwq?_bKHezb~iub5SS1Vm0u6nzE< zYP7^5C)anD#Os~Uzh!j;mRhSnhQ^#|e-1X!o#)OgGABO~0&Vo+q-F*Ne^&sdK>3Pg z_E9;85#Spzq1Ks2tZ?}=VM>+P5ySo>NiBxhM>v+9(6z`^t+GIMf-Zttwd`Hm!c|vY z91gTFQ9TtxU;9uwzUO*w*FE`Y&HL55z1V_-3!$L%i;w8r&@s;G!tocbaRG*g@lIX! z>D+zQ#GVDjwSZiC1URfP=!LDSsY`f2s^DO0Ruv>V$+cm5ENag@q@mh^yTV58oX3SI z)D;+cO{xx19iN{lTKTE2!Q7Yd)eeGlU2@66)r|_%GG6F6G#wD)`uqC){WO@Jpyofg zFNlGbaZO|Ff}7hg>P{W?x$$`8lzdN2b55SOxO>w%g>@e~07@J8j$Q7}8wuq2bN^@Z zBLP5~>`%CP8OWzX0edo<0|!+C>h;!3x<8{RYDs=jQ`c(B=#s)=f;`1MTZ$ZxT+}%n zIUdlw=;fR##X#QlgcX9`&LhzIA{F`$&7-kkkcdKuOB-?H4l`^ab?X!pyhoqOBMm3X zGUYUu3bqz9w^F!VdEux+Ca9b6Y6A)2se!ezOv@~{TDsgr&kb4QhjUNMvO+sqtV(O@8jWd#N~VKco&SIZp7HMI|&WVN^S7rU|^t5@D~xF zU>RU2%4rTy48*AN*m0u6j%q`8s_Rfy4S=s|j#J4@6?}uglO8GsxMThTwJ@X#$!d8N zdNp~-u|nZeH?cxBUC{=ma6ag|Tf~RIYwjg^tXGC)FC^BNu!H+^cweKa z3Zf{JyiBp(jiT>LmM&)65x^D$TQ~9Ut5_jh)hAF@n+r0>0w3=+^KRf0G)SRjA@%K} z;S=wM-|(+)b?o?)u&Zvt99};zF?rz-l&>mSslSD!Y68!SSq)WJPgB8E-rI*?eyWM< kTd~YCnb% zV+$y` z?--VK?{N>3q-@~w2isA$kffC>~(gveKVbI zciXmIqim+1XZvbWnaOgZBoFn%Y`WbTOUY#^W5Vqxe)#?TU-p|rSHX)o7{`46D)4ZR zd;E!8a0{vvbz!?PzIIAi#`-jHJY~dhBl=0m>{vV#DO6occ}m&;h|FEIAQ$nB=PP0W zs~RKaxRSDI^-y!1NcnY8_58&#wmW0TYdmsH!SVCrE%zM6xC*99x@5p|@Pi{j$155m sJ2c(SB^)RHZEcjZn=kZ&9PeZL?Ff9DHH&;T6MN0Cq30bXBE}^614qND$p8QV diff --git a/DSA/pykoopman/observables/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 3736b70de496ba45d757df35f93e0f102b434e50..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 582 zcmYk3J5Izf5QgpSBd=W$LI|#~4WUK|@mQ@y0|=xJ(X9ONThI*mCDqzA zv=K(T56=~58>g*njJjAlZlCB)zb^NKR>PN)-Z(dxU9 z<;PoBR5PO%rnQ3G1*c7GV^V%26rXcRyV=+d{YpCuG7gdk$%5ow&S&d=0kCSrRR9~l z5!r;hhzI76FUIsah#$t7*q2cMa>jVF4K}jEGQj%aZ(0}kk{y2FU8KzPDG=hnDL5YJPnj-@1D=rdCu}|IjM{p+y6* YTX%hSpbTpzKMa4ug}6yF!M{)P1&lzQwg3PC diff --git a/DSA/pykoopman/observables/__pycache__/_base.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_base.cpython-39.pyc deleted file mode 100644 index 8f38a1a29ecc6e8794f638f8039b45ab03550305..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12894 zcmc&*-ESP%b)T>Oie-HiN+Y_k1XtL?7!G%4$suQF zR(EDa?qXRKp^Ov;0=RDm+6EMm7Xy80i}p3oed-@DK%WW(@N-`ZKZO0Ad*^d!rPxl8 zF152Wb3f0y=brOB=UkbKi%kii;Xl`$i#H_czv&_Wso>!qNs@zI+*ndqvSdqf<$=;w zWV%;fwX5=9ty{sb=2i!_ZjF~!a9{7%`F+)G44U1hEd7~e)vWq6$*S9RyLO~?7x1QG zHSwltFC3}emZd(F+6$Ab4}5Fn+Irt-`j#2kde1e3zz+C}U}*Q8zSGnFt-xka%`H@n z%R8Ub{M&N0V0xY(nxW%+!3Lfe-$gHXgU}h6q0jJQ`4Ka{0R0ba_P{xCJiI&A+p&9l zh7%ZlCk$dWk%eQ9!Ko5G(o)cbjZIgK&-k>MvxJdV^_{zZwZbB)Pr_zyftUQ-UUO=!i8S{oj z<9*Kw9n*Ctwr=V(Y{1Y#XnH-nBgiY(7qkscW_w{GA^N@(?r@re(a>gkf8_N@O2kB| z{YG1jD!hpRE~eQ*miI&?SnY-SYPvo9nUfuGso>~ z`Xeqe!%?VPW@u)dqq^gK-F4j`5_3&AZWWqr+Ya@oraQ8O+?em14uq>X>V_ZQ9}Hc4 zfYr0DyNvmahKBsc(#w-wG!b{hAy%xt72eh;OBr3;huvn)+(eObnuE5AwXA$6(Pd*%RY z&+qd+(6`NS#0tV#-T;mVVKOU(|P&1??Isea}>-RhZ4C3EDK3N^CkK&wUSn> zE3++WL+-p8otLRup=EvMY&%e&rN(pgNkS2zRh!4xt~#gOEkbhwK9y=>S4K zVF>L504k_hombEFWpvtu<;zRH5uF*>W`O-dO4&dc%sDU$)}7QJ;l?wx@~`4%TbfEA zE**m3$5`9v^4}>>w1+}7Kp)o}!R*hJNauhW+6`GeujM=1Fp ze5J|vW@R$&t8?A;d!`%Q#7)xbb26G=d!p<-TC;D^r8qJ6I^KOi@4to1=cM;PKf&jV zAN(crVP(D1U<)7vD=?!8?j}4RcR1Jo>e5>u>NoT+R{xYk8r!t=Vo4--+AT($jhar7 zz@A7W3M0+4oI#{`!>Gb-bX0>zqqPT+;Xf;$;g7=NQZ_SzVXM@y{3y}ggvtc>Ik{vA z*=xAm#W&D#krtQaro4jhs?wBO%CfBBPdm|+`md`eT6J>n1#45%60|NH$h?W05V8`= z&n>)?uHY4hr=??; z=#q&L#~K`FXaVpoxmf}CF_gMIIXlZjs?rAC_;-p>DJf~gh?<5m;NBAMTZZvuWV&$) z$g=#NVQ`=sspeKMS~6pgL0~9`Z7Q*|bfLY<7nyw@cTs)FeBk47%>I}j7h}NNvt1V* zW*}*SnsEUkzR~-DgsCoTwN_n|TZ@|9Y~i<6|5m-K$Q)AlP@(Wi{i=I-o%gFO_(1Ti z$Uro@nzbanDma_mpXyfOE0OyMFDv$=>fC2)K&daYx6ql{20-RIH|P2ExWL$+8It?6 z@9Xd~2R^g)%^8+&rv62MyU^E79b0ePwRw-5CBe(;$CiSSa&9y$=duPm{1Sb~^eh*u z*YWgV1buAk`{o#y#{|CcT)Klx=CB~-BW7ZqxiO9fRqTXgDD>fwkRt%{o;?iL^?iU~ zVa3XIJl-Gm4owkK8|ZWZX{*E0eE`wY(Vy!Ohrpn0bBW2(+=sq9_WS|Vb-<@1nBsUn zcVyYdmSYAt9%MP; zx4D^NNy<~B+Vn}d4KFyf^|dYE=dKpmt~-55lM5H$gqJH&uD<4U?9Mu0fnXejHk@^8 z*v1m1e93jor2(tsz`j7mVw?0#Pv5cKA#qPgRevl-VzxDciwIAInTFTj}uTCeMNXS=hWc1T2!oaL#^kWJYd{^s#gr^L1{3tL(k zY-S>S@SK?B$Hv+Qqk(N1*k$luwNDi!WPzk;|1ov@f^-)ejjT41I=J5|p7wVL=Y~W2MXkNd=NpnM@r?0r03pAsq=P0zOXoda!V02J6ony7S|qwo?D5YhPxPZF@KhyN<|e>IF;F=LBsJ7f1I$AZ{Jdnrp$*o5Bv~qVFypto z71XL&aCzDl^WT9Lvv4MDncK7271CFVXcjFYNq=r3e>-cKF`l}m4_rq;zo$^{mXKTy zKXN1LJnpt*LNh_*Y!)ogW?`kNJ2Nq#0$4yG$;gTbAno;>rKRfg0#&yV`DYYHEIPNP zc>!f?mKd|Cryeg&xjerT3Arh!wHbl@Xt6-+=hZx^D$1`lb@EzCpwb|6A%;wd zodEl7l5Gv{3#3@OBYn7hs7}>mgh!^za|CLhR1rEshT}ZS4VCIx%6aKfvy{WiRNK|q zbxZaXJXJ$H6HY%;*u3 zR7U$JznC_r3!tTe``xro3wJH}Lf|aQQRAHSk92*lJf%>K{){&5cVHhMisdVqn;+c|pxW)RMUEXb9Z6N0TE2VNEBk9bsta7tpf)BZ_`(WeAq08d1TxKgw*KWf2|c|;g3 z*l}PftpYi*ZHp&U?2-D79ff&{bzZo!q%2@_`9gD#RM?>eZ}WUtE&%!^H8o{pUa}{>}AZ8rKB_VZ75J-8Cr>DAiwtB23O*fPLA#el&j)4vq)6VGCYb9rR&Z328Boy zMVYWau~VV6DMrU*t4$vJmU3~`wwzdz3#b&Sm`5&R!-F*xxBOpxdE9c+E(t;hvOX`4 z+CIz8m53XyQwQhhLPjg90WWeB_CtDgiC(D#^MKu=$2L7yCN}c}5p7f<8BqoC@ohU& zUEAYPsHh6((R8d_GrM?>6`Wm1ul7r}V{0bxl4u+%><7bmaGU919fCCEV59l|09e+}${kfh85s~31Y4QCY!2^XAPKsx1S zs2*#)9QHjar-VybLGq?Ti5sASs#WDlmfEUxs8E81o(VPVHkfPGfCj3ETG)h*u3HVD zfxn60!D_>9!ZJ;j1*Bv?QeZK0?ZYx{%ZJr%>9EFotI=DI7ycD?S+i6wnjwY6o+xi@DL$6!Ako8$K@026bWScVTgXZa6)#zuL4? zX!k){0$g&uIBh(aftLOaIHX3%1Dsr%R$+yk(sfoCcdoiMt9%w&n7pkqhT)9tul?xp5B&*B3Zg;ZsN>tlOsA5f%@LWYT- zhFYjfu|2+fNXybT;ipUB*Jc{J2SAQZMqw%or!%0mawPo!nOK@Ij51Fl!SBw@^IUVB z+MC#a&Ek8c;b#pr{Ly#;$!@?rWUB~AjxXa^00*<#nD)!2UaFj9_B=C;GYVXW{Z3G4n2?(QMq!c$G`yYzmIE@aLarL06=hg-s1 z^vGQ{GKUPVRh(KO6B$(zPPaWPs_tNK_4e8enN{na0TfK2q%j%-<=Gbdb87#9E*rf4 znA^AR!q}jYJ%13EurfA0d!KRB$o<4DX-AozS3pfbxqRs?Qg*OGtFR@@usXs%y$+kR zA}`6hasjrcdQw%%&M5NP6HRN$^=ea|eB&i6Rj@mh$03;k>2l!VhEib`5_%#TMqUUV z@;W3RglBbPP5&=g`>N&~Ms2=pH^5l&|S>ZkOY|T`mXT^5b z(@0cqqvkeFUeSuMB*kNrh<&UPMJGI!Ldh8l%rk`2p?$Zq18Pu$2#!-aiF7F`+Cpo+ zPlw`6*DYv_oEMavR9STvBW^D~dXgZ2P5_L=#e*vs*KvId*G^|9GJf&E!|Q!yLT%kc z+SyAEegyM!4KLS|3CD02=9>QFIR8>)0F)&F-ZuQEQq(p_`|nbd2~?VH;|=x>gz;Xx zB6cg^qdecq_b6@8wkEbC9mngQ6)T!BMVyA=duvMK>vO`xpf(=F8by{3EU(nE-Amr`~y0XYa`RS7Uw4d zoTQ9>&H)`c6`tHB;kmU_SwyhR3Hp?tyw*cB;@T#i%}1ifj6N{5T0MR1%p-{y9z=BZ1-L_)3W~ z!I^yrsu0nXB4>(v?kh27rfHs#Ime{FE;u3vXD4Q^QJkFEIETR$haTtR&OEeGV#a1k z7aIAk^7VnvOV28O3}q$Y*QK&*N<@0j`KjL$e7$r|KTGB$v^E_dVHfH09lHDhUH%Xk zAf`9y{^cNy!VauM7v2vKAc*t593VyVfzaU@MxujFL(<_C6Oqox7zvtu=1^0uB~Q-3 zkZJM39C@SNWIv$c-=+(}F7_vMp>x`EPut)>UgXcoX6I?>_)3Ux(82}hY1&I?npXXX z%?mtr&|c*I(&?Z6h)%HLR1UC@#IE5IRrqcdL6=srCywH8;qV0`1H%ZXMXSksM8e#l w11Hjf9)NQrj3ikhk)+_5GP^8MpF diff --git a/DSA/pykoopman/observables/__pycache__/_custom_observables.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_custom_observables.cpython-39.pyc deleted file mode 100644 index e2211bba18c13a6d111c4dc38d582ec7ec37e66f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9876 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 XW|>X1iJ+&B6A@LaocXcQsaO93)yl!Y diff --git a/DSA/pykoopman/observables/__pycache__/_identity.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_identity.cpython-39.pyc deleted file mode 100644 index 98a67135214f1c47d11d7c3e7a86c15606e135e0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3250 zcmb_fO>f*p7@o2BE6ye%1xic#80D0e7AIUdgs38=rBp%z(TKxJ$epZbvrhcgnQ@w3 zZ7(EJ&z!4DEw|qIJ-))FXKq}|``T--cN4?~Cw9i;nR&mS=a~s#S+NLQ@$XGeqsQLjKF6j}Mx`s~!qi0ZTo4(nr!QYx+4;sA&^wr&l-way47POmg%U=qt zo<+%h;x4(?1#vB5otwR7*L+Ai%j1uO$W45~29adnd7rs-OLDEcRkr<{SOwQ%1U`MA|n?t3oR!tug5(Qjzpy>^Ey@%?PsJ}z6m z%>0F_U1$i>qY$a#(w_N@3?N?Dyl6p`%NW}Q?bR`^3({-2?JOqRYd#}2(rZCPD{1S2 zD?;t*(fE$V;M!wu5(J}aSgh}JrI;Ra&6F3!{)kDT6B#PzX}HmMJDc3c2#O2a7$|s4 z)qBv;uuLxFRLL9?2zyovqTQ(JKKL|bTK}yB~j0skFmfN?ja@@htQ>+ik)iUX8 zD1}!}L^l^_vL{2YKm1qM%VnPoMaZ<|p@Q-T!p&ns#}4*8W?ENCEM(eppjw`GoOHzt z`+njIM?tLx)V-#JKY)5KIZl=`$9YZu{&Fka8b*QG-rnNFgoj64cOUL$cRV_YqB!8; zRs};_jyElc9gienoUFsG5ZI(?(eZkb6}#|bzdywT4#8|gaS8bvvo4{b$%LNMr&QAk z)yBD@b|&=Lbm>hP234rRUDu75&7$`eJ#InYQfN;AOE<~YV`pEA@vZ^0tO>!I@;{;Y zWnRDWbXFDMj_{d|vX@v!rx2;j0>M=xMF1#dzy)5Z^PW6XJLNK1h%>gyrR1Z}eD6eb zcGv+FdvO7@a0nFjw9Ou979>iuAwLz2Gd1L~V9{W1O~bQA|<3)N*|&PHb-IDlNJ z&I|`Qbi_9IqcArPFpRn6fzSd#sE`&MRKd;kL7n)Z45Q3)Tr0w248$D@j+{YZ;>Gf@a6E`Y`Y9>-pIgb@J7 z<4A%=Wg++;*@MpUY+z> z=tPMI^(b@gq(&I0rWlEo9;EM9O6vq%OYbb3gw#)fphe9(rd&bW^em+#`3}02J&-x6 z2`Rh<4TW7~twk+*jb1md(;G&^7`Kaj*)Xh+a#dVY>B@<;3cWxi5Uz9BNG23OZt!6h z5PIisG{svJjtj$6<&Z9 zeg%R72lIBeXOu>A-&j7!0}amf9X7!k^W^(b0g2+)F|uOIkFaB*)=Q-aU%=N~G}|DW z*NVE><$z1IE=BV@m|Cs1Ya~Q&x~5yZARwaT*f^(m2}&w>YNEJe--#)|)it+{?dQa8 zyfDw{FCe*qlqMfkk#b+;au`BBRKe+-2dvPX3VAP!V3xd+GHkP8DQt(p;x3C~Jb7?` zs*ia$%gy1zWlv3tod9ru?sLy?M z8ydyLad)ABvmI(NV-DLKTOB6+Y${{byp ztFje+i20Y(WY(lAIo%W;s5{u diff --git a/DSA/pykoopman/observables/__pycache__/_polynomial.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_polynomial.cpython-39.pyc deleted file mode 100644 index 218dea4fa29e5ae449d923bc76302761d63d7c16..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10395 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 diff --git a/DSA/pykoopman/observables/__pycache__/_radial_basis_functions.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_radial_basis_functions.cpython-39.pyc deleted file mode 100644 index 2bc819d07cb9276a82918ee4aa3f926f5de04fab..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10514 zcmcgy&5s<%b?@%!`P?sZN%2FHs9L(8H_QD$hZ0CEulV-wBZ>6)G1 z?dcv?_bg{7vpI;AEd&UloDBgaU98Hsw|&;^x{bj0T;}cgTpXA? z4)>oB$5l0)GhNpUOnU5Z;X2RTouH3OL71-PwNYDYw0L9RuzjOx2LZR9Xi?Y21JkiB zGvJ2pcDlh6HM+g@zUlLiMJ>=gM0hNkI+(EiYw^U*J4HpQ zFnqRKkVnHYeV+;55!~l);3v|OeOS`TXR9~gzgA^kpIglIv%;%MTA4XAQ%JeDqo(MG z_DvSFIP)P~&JIjrOS!Kx+YPwD(2yjNb@{!hjii~jt5xLnHLRuWf`;4RYs_T6?e1cU z$BDAdwi&cG@BFm48dPuJVGXbASZs$gjuq-+cngz2M@g~WbppEs8VyXH3xAFEZSGij z4Dym09uV)Dy;6(BX1CF;jb3uMFu&XBcp~sqzP+x`f_{g~sY?;qZo}zH(kr`W*Y{V} z*hl*{UCi>Lxhmk{Ozcn57Kh)gu|v@bcENlVNayLh)mdD-8l5T zP8-|I>u_NPp4eo(7jRdqw$*pdw%y3kgdgI};-n#-FPFP^CiD0&ysp3oAbr~MT*r2~ zDcCLAfZ**STRp#V?rm(Vb8l^YfBoEB7cQn2F3+0N6=@ix0MYttBpsifuboe)cK*Wm*Uw*kJLP1Z z-GG*uSW?@8lxaCX;sd*ZmE842+6)Z;B$5`~hh;ag5OD4=18yqDcrh@r-}eLF_BTO# zeC=49^Vn)fJD8TsVKGVU0%)Tf2+tXt;N@=M(XMEi?47sdM1DYPbm5)#a~C%xhhbjY z_$LI8w*H6$pa1;Pb_1?A{ZO6ILyq9lzn~H*_mzk0BSlpLZK&Q?gWP^jycPf+-B&+V zaZkg&Jno&xJ=8x{hnkh!SH$~4!P4cmF0XImIxnyD@_Gl?1$hlXai9u;>k?gqChiAC z(EK@QmSvlqrF2#Cs~}I~4Rd=X^!OEeR3ZvP#VE(m6r(cC;d*YUqnsb+Q7#M%C>JdS z0Ay}!a60ux?XDk?kAdHY$8vWEr$+uIedZD(5ConEug`c)i|g`Th#o70mV?zX|B#Xy zYbTw?pq4e|u^)I&`)WQcr`}o2fuXP%JLqr@mBc-V^I5us*V5?%NRm>U2PU>LK&EuS zgTyIBUc+Z24#OJN?6g^RFcz>U~}VT3v%hA@Z43Cr84ejtP=!W^U=R{j#uDZZf-qv%aMgr#J< zVL4?xEXI6>^V!7-m$QP379d<0bE4H^sQcV$idP_R@hTPHqT)3wzD)%~@mLMZh9P0A zVLVp8x_;I@+w$6cW8YDEE*{ioM%WtQ@AF2D{i*VA}&i^&2=aU0!VuR*hZ*i#u`i1%Y3*+yJ-WzbWCBk5!DC)(Ui_*v713J z@JHpbSujd6~WfwE!96kkcB z7vko66DYwuuq|#Oj16FSWuVzI;hEs#$UKt$f4(73w?;HWHZ}*~L4>)80PeMHfUyRE zvD|(Mn-peuT^pFE?erP2ZX5_&Q&hbJL?jU+Cwx0DnyitIBcmzFL~Xt~)=H-FjHQyE zcw(Vy6Du|CC7#7pw&i5tHYI|w#xjt5)_!^sCdb?sld<2J%w9AKoMLkaBQ<| zi!RTYnwzHWXG0}gnAE9nGHl+|^u#D5fn^z>z>-H2m0^Ne^c^krxFC}Dj4;CZE*l{T zIeKa#*4Wto1Afo0RE*PzZjAcYrbIS5ktxtcjHgHmq!P7d$eK)1OBqWh|7`S?_LX>b zTaY)u_SMBtgok)_WaB0xVfI0ff+zThUJB$8Tz_@)&!M4+Qp|}5p<3Ijo)8o)h?h}> z%U}`t$u81shHp|D$`31UQZ>S(lhDtQuu0-6>O2|xi&I2e0xe3`hC1as!#v7e9u|$Z z?Y7Ncn8Pm$)aDJ6xMMd1fcQ{zJ7ED~tLf~9dB+d@yP>)r9&2;cM^b_kWCkK7VfTz` zN&FenS9_t_C%l+pKFKnKI@RjMUNmYw-=lHF8^ob3-Xsb+q+ai!;$K3cyjmjor4azD zsLS}4w32p&pqZ*a)wR;sg{OL9UR%}{)f4)6)bD=1oL_yqtXH%X+Ti32S6&142E}E` zhfo`(Y4NN2U!W2wpUX7%u67?u>;Q-@KuvsCCTw$-{-87jKDw{o0;1c?S^0fU{3OsH z=H+ulYRU6QXb}K`#i*}n6;FfmUI`fO(*PKZ>cC}XP?672uS6K_bLC-0q8P-46la;g z1HXnkepIDeQ@ zC#Oh>z)?67ulBV5PHtC(C)WegKIElolY>DsV8XkHT(u{V=<0Y#34n3li+2As$;e@n zf28;hvjSuw04YY$?IuT#&7DARBZ(lz zn#dJYNt(}^KCsb*0#>ub%rM(Xnq8Ae4Kg5;){~ZO1>1B5>5HJ{S*%65b4+!IBW=|% z9S2aS1@jd9AG*Asn3?v^?(LBBg+Eo7pD!YLDw-*mpC2^o$*nPu@VdW-j{xI#s0{=`*W{uAB$fC}cm#4BTLy9Z_&fN+`S{e5=mM5g7ZWp7fIy@sEc=~kPJvx-lWSPq4;}zeTG6=UL@nI zRn${6jBiC9eCxT=n=-e=K88~L&rv}b3v)}R7NI5uzpEA*Su(uJ9#T|fY7bRta*j+X z-Gc%BG16HS5X590U3@OVOHhvCwcj3#hG&rQoo}2uCS--6*GonK=ZcSP~ z3w!yO%9mPX`Kqdr+DnT2SQD4=6RLKk$5NT49$&@nf5lf?lfgT)^mIyav#i}2gnX~)1WOh^IkeQJ}B(o>o z$B{!Ez{`=;FLSXNwLzuRvRCOmdA;$K8jUG#5LGG0aasO*G8*tM(HD3tLXpNb%wZoz zXq(|)Scr~|BruQ7ZMZlt#BgZ>EKH0T9-Ug7e+Frva;M5MKwXsN*f|g32Xb~ zAr2BO-O@kPESbdo3~gl^FMp^50xNsc)_$SheuI*Vd$7yYHcBZT7J~8~;O>xq=b|T+ zRy?Ix`D3u|RuSVB(QDo+0c!u_uo#pdF5tU3EItAbIIbL)kV-A#&eE{-NWG-E{~%kJ z(faqedjwZUiPoGlEFPy6X371zY*E?QkOtM!W*Mo{xD~ZI8MV42Tg}N<8`KKl#p#xk z;sx1uUbg)i(vHgBF)RNH;0yXpaO;+WlLjpK|QX#3`y*Z?JTo%n-)*D@? z7Z~UyF@}T^H6z1MSpOL>b;R#4wLX~jn}WHBl1&%tiyniRsTTkv8VXd%v_sOqEHheaeq47|LAirJ&e z@k1g)A%TEDRivy1u@x@FM|BPEIA}a_m}jV+L?CoVP8-yx z^cI$61qa~C-+wQzRj!rZth`=&TTr{|qTu);zM5Tn?FBSRz+qn6B^la8o0UW#p7Qr` zs4CoAH?SSQ2HDX&dU%^73Xlqj@$fR041&Tuod|M4ZcYxB;WhQ}Vd+vNj&~^%^+}I( OZC;}TLHud>=Kcrmm4AT% diff --git a/DSA/pykoopman/observables/__pycache__/_random_fourier_features.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_random_fourier_features.cpython-39.pyc deleted file mode 100644 index 340fc0ba5975f2d0847b1847090293d0d0281e43..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6841 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 Gb?ZOM-$R@L diff --git a/DSA/pykoopman/observables/__pycache__/_time_delay.cpython-39.pyc b/DSA/pykoopman/observables/__pycache__/_time_delay.cpython-39.pyc deleted file mode 100644 index 4ef6abd0a296320ad834e51c1f5c2940c50fb048..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7618 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 diff --git a/DSA/pykoopman/regression/__pycache__/__init__.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 96d5c9a71de456bbf5a70b340a6b8b6a93589d65..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 616 zcmZ9Jv2NQi5Qa%vvSdqg>coBsFHzP4MbQ)vP#}mCG(ZO~1Z^_5VUjW^JAn5-Nw#d= z`zBgD1^xW~J5qNzsj}=dSld78`Y&hfADZJ8f%(Q5Z+-)4rnzN~3(lF2 zbjL=nBRa&fja?!V;>31cDpKOE&0J6Ph*R5lxyXq#Tewn`#63H3C*p*-Z$G)A7!v39 z)SZbl&X!CUPh5<2dCw+;7wm7s+gy2H@6>Kx`{o6D$5{DYHRh*T2GcZkfWY|5H^$Aa z`Is2o9i}(aDV_y?L1ND&qM!xOy%m~@fZ diff --git a/DSA/pykoopman/regression/__pycache__/_base.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_base.cpython-39.pyc deleted file mode 100644 index e232c90eb7e82e28e790e99ae2b60d8d2f6ba90d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5446 zcmbtY-EZ5-5$EzlqGZ{z9be)ky(`-*aM3ljeJPq2X^_Ubq}RJ1j3NmNN4Nt`YblEk zMJl^g5(zR;oZUVY=ppDsABy6T^eu0F>R-`^KJ&Fj(LDF9K#~4tNlBDr2RVc^N3*-L zGdr_0v$OVQXR8{X?qAA5e@WB+L5<>Lp>a*qn7jpqYYmMvu7|9nH*`k05gHw{VJh4N zZZ#~0TVbhD#&{{TJC#O-X&-64%+kVA2_svF?Ter1(W$^7z%zL5lv|{0Gd(wBB zp(mviw;bW`2w%!rJf{`aSvuoIQJi>55JwVCWBvMv_?h#zWg@(0((#ja%s0?AdmW5! z$|UG`Ni3Q)z4#btTqC9a1jN@G42tQTH4LtE<3MYe{2gxb(gAB&*`gaI{!L!xGw3Pv z8lMFX)Zlac#DTWY8dc!)d_mzez!&*Rh1Y;D@wXH{3;Yy6t?)VE%lwSOPXIs5&nbK! z_&5053SZzAn8(Rfxizwcw}cI;I(SIK+*D+_U-W+-$K8$>O{^wYs*3VXJCHeLSHuqj z?n}pW9tyA9^@TF~*wE7HNuN7G9??cn?)w8HwtV)>Zb?Sl0{>a==Mld_|O zzn$QLA35Ahyn>Pw#`5(U%hzDs6O#oN7S(gbu}b!k%tePB$LB6>t~{DWflT>;IvZ#! zN46(tXzGOoPq>NiL(1`=07c`X*W?;9vbB*K$X6A7mY9VJo@wF)e*SxDHCk=Q z9e-_Y)ob^>XlM1t?RE8a`}eXVWHsjiM_P4N&h7S7+jS|>U3U#!ztc2`Hh-wtDB)8(^LM6cLtWUMMLO5_4B$)LP`F7ulCWJJd-Crg z+cmgxPZyVm?1@Q5$5VX|dxBmQy! zvM}pkYF0*@&!jm-na#}bmO&gcJmWLz*R?&iXJu<5ZrnVhJ=KR6t#N3L+9Wmlr_!gg zuRmtuZ%LJxc=-T)Z=ibEXOEezeWHEAb~JhoP1m5o489t^S?YtN(q5V9KfkqS549(A zL;ETFOy9HjD#Ox~6VzhbunerCFl~1RxVD@1Yr8eoD&=Fds#T`eV|ITHcAg)WxXmlS zgI!e%rJ8D4$pW~{?34f73a=@=r0`jVV_idwwB-2e)xp8|8-*$`wV^ht!J1SB@PiJ)|AUm%qA3T47XX80M zOnXl0;5m6=lbWMvlq4i2iL>Y(YM(DceQZnSc)!$`c3-EUf5tZIMp_MIRwOk2RFAr8 zIpUrWULRqmudJo)kqWR3%!6NAxq=hLf7BIMsd)Ym2_CE+iW06&x<$vnqry28GzJ`c+g49`TW#UY|?7vN{`Ad>81-20vGmnTc}fd zAav78;Y#I0>yTq1Q^@VNL*s`uOy#JfGs>}vO74ID0MS@6Mc=f^CuiTEQLxs{- z8J|jBe+2?h!3}6%mzR(N5FophIJ8~ksiBgS$&or#g1U$V0-SnpBbfJa$=EXzD?z&2 zEmHzOSa0o_2qOb8`i4j(__gVGNjt4k@gacV;6AVcSg=}0ocfs>XUd=1^2l8 zP+SXTKrDitAo9XV8rYmn74N~AVvzv(x;P22QJ)bNYB&VGL*QKk-vUT2fny7975Y&& z_dE^N349lzUQ(_mR;c6q0BH#a>H{}PS&$l=Zg9x4(nW+H6`?LI(^a|$m?qx=(BM7f zF*Y*|lbOIBf;jT3>?|9oYgpmXdx_D;)bU42h;&pwWCKZ%_9?@NQ)oP6=}BB)J|5kZ ze6CLPx{>KaVIh7%fDZCWo)P4gzrrU~4a5cu(@u>lWXh3=>i9*7D;Tcp1(AoO(X#go z(%zbume(#*sg|UTB~oEFR#|EBjAhcM1*Mj{Dg0(EN*|n@7Ny3&jv#Rr%nn&Eot?Tz z{I($O+_bnUx;GbFyiK@Y9xrx^?v2IPGIrVhUFw(RX?S*;=h#y{i9Q{I%;*PeI>KZ TRZ3%$)@kZBDk5~7)r|iGX+C&T diff --git a/DSA/pykoopman/regression/__pycache__/_base_ensemble.cpython-39.pyc b/DSA/pykoopman/regression/__pycache__/_base_ensemble.cpython-39.pyc deleted file mode 100644 index eec5a218fefd3cbf00ab0c46ca6d9edd297ae56d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13641 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