diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9c4218a --- /dev/null +++ b/.gitignore @@ -0,0 +1,63 @@ +# Python cache files +__pycache__/ +*.py[cod] +*$py.class + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +*.manifest +*.spec + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# IDEs +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db diff --git a/DSA/__init__.py b/DSA/__init__.py index 3a12098..8614237 100644 --- a/DSA/__init__.py +++ b/DSA/__init__.py @@ -1,8 +1,15 @@ -from DSA.dsa import DSA +__version__ = "2.0.0" + +from DSA.dsa import DSA, ControllabilitySimilarityTransformDistConfig, GeneralizedDSA, InputDSA, SimilarityTransformDistConfig +from DSA.dsa import DefaultDMDConfig as DMDConfig +from DSA.dsa import pyKoopmanDMDConfig, SubspaceDMDcConfig, DMDcConfig +from DSA.dsa import SimilarityTransformDistConfig, ControllabilitySimilarityTransformDistConfig 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.sweeps import PyKoopmanSweeper, DefaultSweeper from DSA.preprocessing import * -from DSA.resdmd import * \ No newline at end of file +from DSA.resdmd import ResidualComputer diff --git a/DSA/base_dmd.py b/DSA/base_dmd.py new file mode 100644 index 0000000..37fd166 --- /dev/null +++ b/DSA/base_dmd.py @@ -0,0 +1,282 @@ +"""Base class for DMD implementations.""" + +import numpy as np +import torch +import warnings +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. + 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 + 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 _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. " + "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.", + 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.""" + 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.copy()), 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 _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(): + 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/dmd.py b/DSA/dmd.py index a245a81..57b3847 100644 --- a/DSA/dmd.py +++ b/DSA/dmd.py @@ -3,6 +3,11 @@ 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,61 +71,35 @@ 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__( self, - data, - n_delays, + data=None, + n_delays=1, delay_interval=1, rank=None, 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 ---------- - data : np.ndarray or torch.tensor + data : np.ndarray or torch.tensor, optional 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. + as defined above. If None, data must be provided when calling fit(). n_delays : int Parameter that controls the size of the delay embedding. Explicitly, @@ -151,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. @@ -162,13 +143,18 @@ 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 + ) + + # 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) + + # Allow data=None for deferred fitting + self.data = self._init_single_data(data) if data is not None else None self.n_delays = n_delays self.delay_interval = delay_interval @@ -176,11 +162,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 +177,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 +211,12 @@ 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) + + # Ensure data is available + if self.data is None: + raise ValueError("Data must be provided either at initialization or when calling fit()/compute_hankel().") self.n_delays = self.n_delays if n_delays is None else n_delays self.delay_interval = ( @@ -337,9 +278,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 +371,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 + cumulative_explained = self.cumulative_explained_variance - 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() - ) - + # 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): """ @@ -504,28 +416,16 @@ 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 = A_v #for compatibility with pydmd + 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") @@ -577,26 +477,11 @@ 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") - 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, @@ -667,8 +552,11 @@ def fit( """ # if parameters are provided, overwrite them from the init self.steps_ahead = self.steps_ahead if steps_ahead is None else steps_ahead - self.device = self.device if device is None else device self.verbose = self.verbose if verbose is None else verbose + + # Validate and set device with graceful fallback + if device is not None: + self.device, self.use_torch = self._setup_device(device, use_torch=None) self.compute_hankel(data, n_delays, delay_interval) self.compute_svd() @@ -684,6 +572,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): """ Returns @@ -723,34 +613,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,22 +637,23 @@ 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) - # project Vt_minus onto the eigenvectors - projections = self.V[:, : self.rank] @ eigvecs - projections = projections.reshape( - self.data.shape[0], self.data.shape[1] - self.n_delays + 1, -1 - ) - - # get the data that matches the shape of the original data - return projections, self.data[:, : -self.n_delays + 1] + # Minimal: eigenfunction values per Hankel row + matching time indices + data slice + if self.A_v is None or self.V is None: + raise ValueError("Call fit() first.") + k = int(self.rank or self.A_v.shape[0]) + eigvals, W = torch.linalg.eig(self.A_v) + Winv = torch.linalg.inv(W) + Vslice = self.V[:, :k].to(dtype=Winv.dtype, device=self.device) + phi = Vslice @ Winv.T.to(dtype=Vslice.dtype, device=self.device) # (T_embed, k) + offset = (self.n_delays - 1) * self.delay_interval + if self.data.ndim == 3: + x = self.data[:, offset : offset + phi.shape[0], :] # keep all features + phi = phi.reshape(x.shape[0], x.shape[1], -1) + else: + x = self.data[offset : offset + phi.shape[0], :] + return eigvals, phi, x diff --git a/DSA/dmdc.py b/DSA/dmdc.py new file mode 100644 index 0000000..95cb2b6 --- /dev/null +++ b/DSA/dmdc.py @@ -0,0 +1,634 @@ +"""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 + 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. + + 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 + ) + + # 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) + self._check_same_shape() + + self.n_delays = n_delays + self.n_control_delays = n_control_delays + self.delay_interval = delay_interval + + self.rank_input = rank_input + self.rank = 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: + 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: + 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 _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, + 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 + if data is not None and control_data is not None: + 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) + + self.Hu_shapes = [h.shape for h in self.Hu] + 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.H_shapes if self.is_list_data else None) + self.Vut_minus, _ = self.get_plus_minus(self.Vu, self.Hu,self.Hu_shapes if self.is_list_data else None) + + if self.verbose: + print("SVDs computed!") + + def get_plus_minus(self, V, H,H_shapes=None): + 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, 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, + ) + self.rank = self.rank_input + + 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_v + self.B = self.A_v + + 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.verbose = self.verbose if verbose is None else verbose + + # Validate and set device with graceful fallback + if device is not None: + self.device, self.use_torch = self._setup_device(device, use_torch=True) + + 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 424245e..ffae8a6 100644 --- a/DSA/dsa.py +++ b/DSA/dsa.py @@ -1,279 +1,700 @@ -from DSA.dmd import DMD -#from DSA.kerneldmd import KernelDMD +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 import numpy as np from omegaconf.listconfig import ListConfig +import tqdm +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, ClassVar, Final +import warnings -class DSA: + +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, +} + + +# ___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 + rank: int = None + lamb: float = 0 + backend: str = "n4sid" + +@dataclass() +class DMDcConfig: """ - Computes the Dynamical Similarity Analysis (DSA) for two data matrices + 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 + rank_input: int = None + rank_output: int = None + lamb: float = 0 + delay_interval: int = 1 + + +# __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. + """ + + 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: """ - 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 - ): + 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. + '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: 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. + + 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__( + self, + X, + Y=None, + X_control=None, + Y_control=None, + dmd_class=DefaultDMD, + similarity_class=None, + dmd_config: Union[Mapping[str, Any], dataclass] = DefaultDMDConfig, + simdist_config: Union[ + Mapping[str, Any], dataclass + ] = SimilarityTransformDistConfig, + device="cpu", + verbose=False, + n_jobs=1, + ): """ 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: - 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 + 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. - 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 + 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. - 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. + dmd_class : class + DMD class to use for decomposition. Default is DefaultDMD. + + 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'. + + 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 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 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 + """ + self.X = X + self.Y = Y + self.X_control = X_control + self.Y_control = Y_control - group : {'SO(n)','O(n)', 'GL(n)'} - specifies the group of matrices to optimize over + if isinstance(simdist_config, type): #if it's the class itself (not an object) initialize + simdist_config = simdist_config() + self.simdist_config = simdist_config - 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 - whether or not print when sections of the analysis is completed + if is_dataclass(simdist_config): + self.simdist_config = asdict(self.simdist_config) - 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 + # 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 + self.verbose = 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': + 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. + if isinstance(dmd_config,type): + dmd_config = dmd_config() + if is_dataclass(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 = ( + {} + ) + + for key, value in dmd_config.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_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) + + 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" + ) + + 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_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 \ + 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" + 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( + 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. - 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) + Parameters + ---------- + compare : str + 'state', 'joint', or 'control' + simdist_config : dict, dataclass, or None + Configuration to adapt. If None, uses current self.simdist_config - 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)] - else: - raise ValueError('KernelDMD not implemented yet') + 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 + + + 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: + n_jobs = ( + self.n_jobs if self.n_jobs > 0 else -1 + ) # -1 means use all available cores - self.simdist = SimilarityTransformDist(iters,score_method,lr,device,verbose,group,wasserstein_compare) + if self.dmd_api_source == "local_dmd": + for dmd_sets in self.dmds: + if self.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.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_dmd": + for dmd_sets in self.dmds: + loop = ( + dmd_sets + if not self.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.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): + # 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 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" + if self.Y_control is not None and not isinstance(self.Y_control, list): + self.Y_control = [self.Y_control] + if tensor_or_np(self.Y[0]): + has_control = self.X_control is not None or self.Y_control is not None + if has_control: + suggestion = ("If arrays within X (and Y) are samples from the same system, " + "switch to using GeneralizedDSA(X=[X,Y], X_control=[X_control,Y_control], Y=None, Y_control=None.)") + else: + suggestion = ("If arrays within X (and Y) are samples from the same system, " + "switch to using GeneralizedDSA(X=[X,Y], Y=None)") + warnings.warn( + "When using cross-comparison with a list of arrays, gDSA treats each array as its own system.\n" + + suggestion + ) 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 + if self.Y_control is not None: + self.Y_control = [self.Y_control] 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.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' + 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.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') + 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,str)) + 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") 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 - - 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,56 +702,303 @@ 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): + + 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) """ - Rescore DSA with precomputed dmds if you want to try again + if self.dmd_api_source == "local_dmd": + matrix = dmd.A_v + elif self.dmd_api_source == "pykoopman": + 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": + 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) + n_sims = ( + 3 + if ( + self.simdist_has_control + and self.simdist_config.get("return_distance_components") + and self.simdist_config.get("compare") == "joint" + ) + else 1 + ) - 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) + self.sims = np.zeros((len(self.dmds[0]), len(self.dmds[ind2]), n_sims)) - if self.method == 'self-pairwise': - self.sims[j,i] = self.sims[i,j] - + # 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...") - if self.method == 'default': - return self.sims[0,0] + cache_iter = lambda items, desc: ( + tqdm.tqdm(items, desc=desc) if self.verbose else items + ) + # Compute cached compare objects once per DMD. In self-pairwise mode, X and Y + # refer to the same DMD list, so avoid doubling expensive work. + cached_x = [ + self.get_compare_objects(dmd) + for dmd in cache_iter(self.dmds[0], "Caching compare objects X") + ] + if ind2 == 0: + cached_y = cached_x + else: + cached_y = [ + self.get_compare_objects(dmd) + for dmd in cache_iter(self.dmds[ind2], "Caching compare objects Y") + ] + + self.cached_compare_objects = [cached_x, cached_y] + + def compute_similarity(i, j): + if self.method == "self-pairwise" and j >= i: + return None + + if self.verbose and self.n_jobs != 1: + print(f"computing similarity between DMDs {i} and {j}") + + simdist_args = [ + self.cached_compare_objects[0][i], + self.cached_compare_objects[1][j], + ] + + if self.simdist_has_control and 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.verbose and self.n_jobs != 1: + print(f"finished 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)) - return self.sims + if self.n_jobs != 1: + n_jobs = self.n_jobs if self.n_jobs > 0 else -1 + if self.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.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].item() + return self.sims.squeeze() + + +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, + Y=None, + dmd_class=DefaultDMD, + device="cpu", + verbose=False, + n_jobs=1, + # simdist parameters + score_method: Literal["angular", "euclidean","wasserstein"] = "angular", + iters: int = 1500, + lr: float = 5e-3, + **dmd_kwargs, + ): + simdist_config = { + "score_method": score_method, + "iters": iters, + "lr": lr, + } + + 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, + verbose=verbose, + n_jobs=n_jobs, + ) + + +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, + X_control, + 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", + verbose=False, + n_jobs=1, + ): + # similarity_class will be inferred from simdist_config in parent __init__ + super().__init__( + X, + Y, + X_control, + Y_control, + dmd_class, + 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, "InputDSA requires X_control to be provided" + assert self.dmd_has_control, "InputDSA requires a DMD class with control" 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..57b9473 100644 --- a/DSA/preprocessing.py +++ b/DSA/preprocessing.py @@ -4,7 +4,11 @@ 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 @@ -76,7 +80,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 +94,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,17 +217,20 @@ 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`") - + raise ImportError( + "umap-learn is not installed. Please install it with " + "`pip install umap-learn` or install DSA with the 'umap' extra: " + "`pip install dsa-metric[umap]`" + ) + model = UMAP(n_components=n_components, **kwargs) else: raise ValueError( f"Unknown dimensionality reduction method: {method}. " - f"Supported methods are 'isomap', 'lle', 'pca', and 'kernel_pca'." + f"Supported methods are 'isomap', 'lle', 'pca', 'kernel_pca', and 'umap'." ) reduced_data = model.fit_transform(data) @@ -237,7 +244,7 @@ def nonlinear_dimensionality_reduction( def featurize_data( - data, method="id", pca_downsample=False, pca_n_components=3, **kwargs + data, method="id", pca_downsample=False, pca_n_components=3, include_state=False, **kwargs ): if data.ndim == 3: shape = data.shape @@ -245,6 +252,9 @@ def featurize_data( else: shape = data.shape + # Store original data if we need to concatenate it later + original_data = data.copy() if include_state else None + if method.lower() == "id": pass elif method.lower() in {"rbfsampler", "rbf_sampler"}: @@ -269,12 +279,17 @@ def featurize_data( if pca_downsample: data = pca_reduce(data, n_components=pca_n_components) + # Concatenate original state if requested + if include_state and original_data is not None: + data = np.concatenate([data, original_data], axis=-1) + 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. @@ -289,7 +304,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: @@ -299,9 +314,128 @@ 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 \ 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 + 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 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/__init__.py b/DSA/pykoopman/__init__.py new file mode 100644 index 0000000..49cb69f --- /dev/null +++ b/DSA/pykoopman/__init__.py @@ -0,0 +1,19 @@ +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", + "KoopmanContinuous", + "common", + "differentiation", + "observables", + "regression", + "analytics", +] diff --git a/DSA/pykoopman/analytics/__init__.py b/DSA/pykoopman/analytics/__init__.py new file mode 100644 index 0000000..73a9c1a --- /dev/null +++ b/DSA/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/analytics/_base_analyzer.py b/DSA/pykoopman/analytics/_base_analyzer.py new file mode 100644 index 0000000..dce5aec --- /dev/null +++ b/DSA/pykoopman/analytics/_base_analyzer.py @@ -0,0 +1,90 @@ +"""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/analytics/_ms_pd21.py b/DSA/pykoopman/analytics/_ms_pd21.py new file mode 100644 index 0000000..8306b81 --- /dev/null +++ b/DSA/pykoopman/analytics/_ms_pd21.py @@ -0,0 +1,463 @@ +"""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 DSA.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/analytics/_pruned_koopman.py b/DSA/pykoopman/analytics/_pruned_koopman.py new file mode 100644 index 0000000..2333511 --- /dev/null +++ b/DSA/pykoopman/analytics/_pruned_koopman.py @@ -0,0 +1,163 @@ +"""Module for pruning Koopman models.""" + +from __future__ import annotations + +import numpy as np +from DSA.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/common/__init__.py b/DSA/pykoopman/common/__init__.py new file mode 100644 index 0000000..8240aa0 --- /dev/null +++ b/DSA/pykoopman/common/__init__.py @@ -0,0 +1,11 @@ +from __future__ import annotations + +from .validation import check_array +from .validation import drop_nan_rows +from .validation import validate_input + +__all__ = [ + "check_array", + "drop_nan_rows", + "validate_input", +] diff --git a/DSA/pykoopman/common/validation.py b/DSA/pykoopman/common/validation.py new file mode 100644 index 0000000..69ef91f --- /dev/null +++ b/DSA/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/differentiation/__init__.py b/DSA/pykoopman/differentiation/__init__.py new file mode 100644 index 0000000..285c279 --- /dev/null +++ b/DSA/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/differentiation/_derivative.py b/DSA/pykoopman/differentiation/_derivative.py new file mode 100644 index 0000000..26fc6ba --- /dev/null +++ b/DSA/pykoopman/differentiation/_derivative.py @@ -0,0 +1,90 @@ +"""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/differentiation/_finite_difference.py b/DSA/pykoopman/differentiation/_finite_difference.py new file mode 100644 index 0000000..0f50070 --- /dev/null +++ b/DSA/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/koopman.py b/DSA/pykoopman/koopman.py new file mode 100644 index 0000000..dca95c3 --- /dev/null +++ b/DSA/pykoopman/koopman.py @@ -0,0 +1,729 @@ +"""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.base import TransformerMixin +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 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. + + 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=-1)) + 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" + ) + + # 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 + x, y, u = self.split_xy(x, u=u, offset=True) + + if isinstance(self.regressor, HAVOK): + regressor = self.regressor + y_flag = False + else: + regressor = EnsembleBaseRegressor( + regressor=self.regressor, + func=transform_y, # Composed: observable + flatten + inverse_func=self.observables.inverse, + ) + else: + # multiple 1-step-trajectories (X and Y provided separately) + regressor = EnsembleBaseRegressor( + regressor=self.regressor, + func=transform_y, # Composed: observable + flatten + inverse_func=self.observables.inverse, + ) + y_flag = False + + # 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 + + 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 third step with just the regressor, not the + # EnsembleBaseRegressor + 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 + # 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[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"): + 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: + # 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[2][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[2][1] + def split_xy(self, X, u=None, offset=True): + """ + 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) + u: Control input (same shape as X), optional + offset: If True, split with temporal offset X[:-1], X[1:] + If False, return (X, X, u) - used when Y provided separately + + Returns: + Tuple (X_split, Y_split, u_split) preserving input structure + """ + if not offset: + # No split needed when Y provided separately + return X, X, u + + 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 + u_split = u[:s1] if u is not None else None + return X[:s1], X[s2:], u_split + + elif X.ndim == 3: + self.n_trials_, self.n_samples_, self.n_input_features_ = X.shape + # Keep 3D structure: (trials, time-1, features) + u_split = u[:, :s1, :] if u is not None else None + return X[:, :s1, :], X[:, s2:, :], u_split + + elif isinstance(X, list): + # Recursively process each element in list + X_list, Y_list, u_list = [], [], [] + for i, x in enumerate(X): + u_elem = u[i] if u is not None else None + x_split, y_split, u_split = self.split_xy(x, u=u_elem, offset=offset) + X_list.append(x_split) + Y_list.append(y_split) + u_list.append(u_split) + u_result = u_list if u is not None else None + return X_list, Y_list, u_result + + # Fallback for unknown types + return X, X, u diff --git a/DSA/pykoopman/koopman_continuous.py b/DSA/pykoopman/koopman_continuous.py new file mode 100644 index 0000000..b02fcad --- /dev/null +++ b/DSA/pykoopman/koopman_continuous.py @@ -0,0 +1,155 @@ +"""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/observables/__init__.py b/DSA/pykoopman/observables/__init__.py new file mode 100644 index 0000000..8a26f3a --- /dev/null +++ b/DSA/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/observables/_base.py b/DSA/pykoopman/observables/_base.py new file mode 100644 index 0000000..e0b1ad3 --- /dev/null +++ b/DSA/pykoopman/observables/_base.py @@ -0,0 +1,418 @@ +"""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_). 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. + + 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 + # Each observable's fit() now handles lists/3D internally + for obs in self.observables_list_: + obs.fit(X, y) + + # 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 + + 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/observables/_custom_observables.py b/DSA/pykoopman/observables/_custom_observables.py new file mode 100644 index 0000000..8c5398b --- /dev/null +++ b/DSA/pykoopman/observables/_custom_observables.py @@ -0,0 +1,249 @@ +"""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. 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. + + Returns: + 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 + 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/observables/_identity.py b/DSA/pykoopman/observables/_identity.py new file mode 100644 index 0000000..c252578 --- /dev/null +++ b/DSA/pykoopman/observables/_identity.py @@ -0,0 +1,95 @@ +"""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. 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: + 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) + + # 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 + + 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/observables/_polynomial.py b/DSA/pykoopman/observables/_polynomial.py new file mode 100644 index 0000000..b18b206 --- /dev/null +++ b/DSA/pykoopman/observables/_polynomial.py @@ -0,0 +1,277 @@ +"""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). Can also be 3D (n_trials, n_samples, n_features) or + list of arrays. + 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) + + # 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 + + 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], 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 self + + 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/observables/_radial_basis_functions.py b/DSA/pykoopman/observables/_radial_basis_functions.py new file mode 100644 index 0000000..e1c9924 --- /dev/null +++ b/DSA/pykoopman/observables/_radial_basis_functions.py @@ -0,0 +1,305 @@ +"""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: + 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'. + 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) + + # 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 + + 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/observables/_random_fourier_features.py b/DSA/pykoopman/observables/_random_fourier_features.py new file mode 100644 index 0000000..08a2085 --- /dev/null +++ b/DSA/pykoopman/observables/_random_fourier_features.py @@ -0,0 +1,203 @@ +"""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_). 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. + + Returns: + 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 + + 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/observables/_time_delay.py b/DSA/pykoopman/observables/_time_delay.py new file mode 100644 index 0000000..8e3f244 --- /dev/null +++ b/DSA/pykoopman/observables/_time_delay.py @@ -0,0 +1,227 @@ +"""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). + Can also be 3D (n_trials, n_samples, n_input_features) or + list of arrays. + y (None): Dummy parameter for sklearn compatibility. + + Returns: + TimeDelay: 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 + + 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/regression/__init__.py b/DSA/pykoopman/regression/__init__.py new file mode 100644 index 0000000..ae84260 --- /dev/null +++ b/DSA/pykoopman/regression/__init__.py @@ -0,0 +1,20 @@ +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 + +__all__ = [ + "PyDMDRegressor", + "EDMD", + "KDMD", + "DMDc", + "EDMDc", + "EnsembleBaseRegressor", + "HAVOK", +] diff --git a/DSA/pykoopman/regression/_base.py b/DSA/pykoopman/regression/_base.py new file mode 100644 index 0000000..cf76532 --- /dev/null +++ b/DSA/pykoopman/regression/_base.py @@ -0,0 +1,164 @@ +"""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/regression/_base_ensemble.py b/DSA/pykoopman/regression/_base_ensemble.py new file mode 100644 index 0000000..c89e812 --- /dev/null +++ b/DSA/pykoopman/regression/_base_ensemble.py @@ -0,0 +1,374 @@ +"""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. + + # 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_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_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. + # 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)) + # 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/regression/_dmd.py b/DSA/pykoopman/regression/_dmd.py new file mode 100644 index 0000000..ee68057 --- /dev/null +++ b/DSA/pykoopman/regression/_dmd.py @@ -0,0 +1,375 @@ +"""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) + if hasattr(regressor, '_tlsq_rank'): + self.tlsq_rank = regressor._tlsq_rank + elif hasattr(regressor, '_dmd_operator_kwargs'): + self.tlsq_rank = regressor._dmd_operator_kwargs['tlsq_rank'] + else: + raise ValueError("can't find tlsq_rank") + + if hasattr(regressor._Atilde, '_svd_rank'): + self.svd_rank = regressor._Atilde._svd_rank + elif hasattr(regressor, '_dmd_operator_kwargs'): + self.svd_rank = regressor._dmd_operator_kwargs['svd_rank'] + else: + raise ValueError("can't find svd_rank") + if regressor._Atilde is not None: + self.forward_backward = regressor._Atilde._forward_backward + else: + self.forward_backward = False + 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/regression/_dmdc.py b/DSA/pykoopman/regression/_dmdc.py new file mode 100644 index 0000000..da37439 --- /dev/null +++ b/DSA/pykoopman/regression/_dmdc.py @@ -0,0 +1,469 @@ +"""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/regression/_edmd.py b/DSA/pykoopman/regression/_edmd.py new file mode 100644 index 0000000..c27d781 --- /dev/null +++ b/DSA/pykoopman/regression/_edmd.py @@ -0,0 +1,249 @@ +"""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/regression/_edmdc.py b/DSA/pykoopman/regression/_edmdc.py new file mode 100644 index 0000000..56e8c81 --- /dev/null +++ b/DSA/pykoopman/regression/_edmdc.py @@ -0,0 +1,240 @@ +"""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/regression/_havok.py b/DSA/pykoopman/regression/_havok.py new file mode 100644 index 0000000..ada1a16 --- /dev/null +++ b/DSA/pykoopman/regression/_havok.py @@ -0,0 +1,342 @@ +"""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/regression/_kdmd.py b/DSA/pykoopman/regression/_kdmd.py new file mode 100644 index 0000000..550ff20 --- /dev/null +++ b/DSA/pykoopman/regression/_kdmd.py @@ -0,0 +1,461 @@ +"""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/resdmd.py b/DSA/resdmd.py index 82dce85..2ec6619 100644 --- a/DSA/resdmd.py +++ b/DSA/resdmd.py @@ -1,129 +1,861 @@ +""" +ResDMD: Residual-based analysis of DMD eigenvalues. + +This module provides tools for computing and analyzing eigenvalue residuals +for DMD-type models, including both local DMD and PyKoopman models. + +Supports DMD with control (DMDc) models by subtracting out control effects +before computing residuals on the autonomous dynamics. +""" + +import warnings import numpy as np -import matplotlib.pyplot as plt -from matplotlib import cm -from matplotlib import colors as mcolors -from DSA.dmd import DMD +from typing import Literal, Tuple + +try: + from .dmd import DMD, embed_signal_torch + from .dmdc import embed_data_DMDc + from .subspace_dmdc import SubspaceDMDc +except ImportError: + from dmd import DMD, embed_signal_torch + try: + from dmdc import embed_data_DMDc + from subspace_dmdc import SubspaceDMDc + except ImportError: + DMDc = None + SubspaceDMDc = None + embed_data_DMDc = None + import torch -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 -): + +# ============================================================================= +# Control Input Handling Helpers +# ============================================================================= + +def _requires_control(model) -> bool: """ - Compute DMD eigenvalues, eigenvectors, and residuals for each mode. + Check if a model requires control input for residual computation. + + Parameters + ---------- + model : DMD, DMDc, SubspaceDMDc, or pk.Koopman + Fitted model. + + Returns + ------- + bool + True if the model is a control model requiring control_data. + """ + # Local DMDc or SubspaceDMDc + if hasattr(model, 'B_v') and model.B_v is not None: + return True + + # PyKoopman with control (check via B property) + if hasattr(model, '_pipeline'): + if getattr(model, 'B', None) is not None: + return True + + return False + +def _validate_control_input(model, control_data, data) -> None: + """ + Validate control data matches model requirements. + Parameters ---------- - dmd : DMD object, np.ndarray, or torch.Tensor - DMD object (with A_v, Vt_minus, Vt_plus, rank) or matrix. - X : np.ndarray, optional - Left-hand side data matrix. - Y : np.ndarray, optional - Right-hand side data matrix. - rank : int, optional - Rank of the DMD model. - matrix : Literal["A_v", "A_havok_dmd"], optional - Matrix to compute residuals on. Must be either "A_v" or "A_havok_dmd". Default is "A_v". - return_num_denom : bool, optional - Whether to return the numerator and denominator of the residual. Default is False. + model : fitted model + The DMD-type model. + control_data : array-like or None + Control input data. + data : array-like + State data (for shape validation). + + Raises + ------ + ValueError + If model requires control but none provided. + + Warns + ----- + UserWarning + If control_data provided but model doesn't use control. + """ + requires = _requires_control(model) + + if requires and control_data is None: + raise ValueError( + f"Model of type {type(model).__name__} requires control input, " + "but control_data was not provided." + ) + + if not requires and control_data is not None: + warnings.warn( + f"control_data was provided, but model of type {type(model).__name__} " + "does not use control input. Control data will be ignored.", + UserWarning + ) + return + + if control_data is not None: + # Validate temporal structure matches + data_arr = data.cpu().numpy() if hasattr(data, 'cpu') else np.asarray(data) + ctrl_arr = control_data.cpu().numpy() if hasattr(control_data, 'cpu') else np.asarray(control_data) + + # Check dimensionality matches + if data_arr.ndim != ctrl_arr.ndim: + raise ValueError( + f"data and control_data must have the same number of dimensions. " + f"Got data.ndim={data_arr.ndim}, control_data.ndim={ctrl_arr.ndim}" + ) + + # Check temporal dimension matches (axis 0 for 2D, axis 1 for 3D) + if data_arr.ndim == 2: + if data_arr.shape[0] != ctrl_arr.shape[0]: + raise ValueError( + f"data and control_data must have the same number of time points. " + f"Got data.shape[0]={data_arr.shape[0]}, control_data.shape[0]={ctrl_arr.shape[0]}" + ) + elif data_arr.ndim == 3: + if data_arr.shape[0] != ctrl_arr.shape[0] or data_arr.shape[1] != ctrl_arr.shape[1]: + raise ValueError( + f"data and control_data must have the same number of trials and time points. " + f"Got data.shape={data_arr.shape[:2]}, control_data.shape={ctrl_arr.shape[:2]}" + ) + +def _subtract_control_effects( + Y: np.ndarray, + B: np.ndarray, + U: np.ndarray +) -> np.ndarray: + """ + Subtract control effects to isolate autonomous dynamics. + + Computes Y_corrected = Y - B @ U.T (or Y - U @ B.T depending on shape). + + Parameters + ---------- + Y : np.ndarray + Output data matrix. Shape (T, rank). + B : np.ndarray + Control matrix. Shape (rank, control_dim) or compatible. + U : np.ndarray + Control input matrix. Shape (T, control_dim) or compatible. + Returns ------- - L : np.ndarray - Eigenvalues. - G : np.ndarray - Eigenvectors. - residuals : np.ndarray - Residuals for each eigenpair. - normalized_residuals : np.ndarray or None - Normalized residuals (if available, else None). + Y_corrected : np.ndarray + Y with control effects removed. Shape (T, rank). """ + # Y is (T, rank), U is (T, control_dim), B is (rank, control_dim) + # We want Y_corrected = Y - (B @ U.T).T = Y - U @ B.T + if B.ndim == 1: + B = B.reshape(-1, 1) + if U.ndim == 1: + U = U.reshape(-1, 1) + + # Compute control contribution: (T, control_dim) @ (control_dim, rank) = (T, rank) + control_contribution = U @ B.T + Y_corrected = Y - control_contribution + + return Y_corrected - # 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) - 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] - - elif matrix == "A_v": - X = ( - dmd.Vt_minus.cpu().detach().numpy()[:, : dmd.rank] - if hasattr(dmd.Vt_minus, "cpu") - else dmd.Vt_minus[:, : dmd.rank] - ) - Y = ( - dmd.Vt_plus.cpu().detach().numpy()[:, : dmd.rank] - if hasattr(dmd.Vt_plus, "cpu") - else dmd.Vt_plus[:, : dmd.rank] - ) - rank = dmd.rank - elif isinstance(dmd, np.ndarray): - 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.") - 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.") - else: - raise ValueError("dmd must be a DMD object or a numpy array/torch tensor") - # L = L[np.abs(L) > tol] - # G = G[:, np.abs(L) > tol] - # rank = len(L) - if hasattr(dmd, "rank"): - L = L[:rank] - G = G[:, :rank] +# ============================================================================= +# Core Residual Computation +# ============================================================================= +def _compute_residuals_from_matrices( + X: np.ndarray, + Y: np.ndarray, + eigenvalues: np.ndarray, + eigenvectors: np.ndarray, +) -> Tuple: + """ + Core residual computation from projected data matrices and eigendecomposition. + + shared implementation used by both local DMD and PyKoopman. + + Parameters + ---------- + X : np.ndarray + Projected input data matrix. Shape (T, rank). + Y : np.ndarray + Projected output data matrix. Shape (T, rank). + eigenvalues : np.ndarray + Eigenvalues of the state matrix. Shape (rank,). + eigenvectors : np.ndarray + Eigenvectors of the state matrix. Shape (rank, rank). + + Returns + ------- + residuals : np.ndarray + Residuals for each eigenpair. + normalized_residuals : np.ndarray + Normalized residuals (relative to persistence baseline). + """ + rank = len(eigenvalues) + + # Compute Gram matrices XtX = np.dot(X.T, X) XtY = np.dot(X.T, Y) YtY = np.dot(Y.T, Y) YtX = np.dot(Y.T, X) - residuals = np.zeros(rank, dtype=np.complex64) - persistence_residuals = np.zeros(rank, dtype=np.complex64) - numerators = [] - denominators = [] + + residuals = np.zeros(rank, dtype=np.complex128) + persistence_residuals = np.zeros(rank, dtype=np.complex128) + for i in range(rank): - denominator = np.dot(G[:, i].conj().T, np.dot(XtX, G[:, i])) + g = eigenvectors[:, i] + lam = eigenvalues[i] + + denominator = np.dot(g.conj().T, np.dot(XtX, g)) numerator = np.dot( - G[:, i].conj().T, + g.conj().T, np.dot( - YtY - np.conj(L[i]) * XtY - L[i] * YtX + np.abs(L[i]) ** 2 * XtX, - G[:, i], + YtY - np.conj(lam) * XtY - lam * YtX + np.abs(lam) ** 2 * XtX, + g, ), ) residuals[i] = numerator / denominator - numerators.append(np.real(numerator)) - denominators.append(np.real(denominator)) + + # Persistence baseline (lambda = 1) persistence_numerator = np.dot( - G[:, i].conj().T, np.dot(YtY - XtY - YtX + XtX, G[:, i]) + g.conj().T, np.dot(YtY - XtY - YtX + XtX, g) ) persistence_residuals[i] = persistence_numerator / denominator + normalized_residuals = np.abs(residuals) / (np.abs(persistence_residuals) + 1e-10) - if return_num_denom: - return L, G, residuals, normalized_residuals, numerators, denominators + + return residuals, normalized_residuals + + +def compute_residuals( + dmd: "DMD", + data: "np.ndarray | torch.Tensor", + Y: "np.ndarray | torch.Tensor" = None, + control_data: "np.ndarray | torch.Tensor" = None, + matrix: Literal["A_v", "A_havok_dmd"] = "A_v", +): + """ + Compute DMD eigenvalues, eigenvectors, and residuals for each mode. + + Parameters + ---------- + dmd : DMD or DMDc object + Fitted DMD object (with A_v or A_havok_dmd, U, S_mat_inv, rank, n_delays, delay_interval). + For DMDc models, also requires B_v and control-related SVD matrices. + data : np.ndarray or torch.Tensor + Input data matrix. Can be 2D (T x N) or 3D (K x T x N). + If Y is not provided, X and Y will be constructed by splitting along the time axis. + Y : np.ndarray or torch.Tensor, optional + Right-hand side data matrix. If not provided, will be constructed from data. + control_data : np.ndarray or torch.Tensor, optional + Control input data. Required for DMDc models. Must have the same temporal + structure as data (same number of time points and trials). + matrix : Literal["A_v", "A_havok_dmd"], optional + Matrix to compute residuals on. Must be either "A_v" or "A_havok_dmd". Default is "A_v". + + Returns + ------- + eigenvalues : np.ndarray + Eigenvalues of the state matrix. + eigenvectors : np.ndarray + Eigenvectors of the state matrix. + residuals : np.ndarray + Residuals for each eigenpair. + normalized_residuals : np.ndarray + Normalized residuals. + + Notes + ----- + For DMDc models (when control_data is provided), residuals are computed on the + autonomous dynamics by subtracting out the control effects: + + Y_corrected = Y - B @ U + + This allows assessment of eigenvalue quality for the A matrix alone. + """ + # Validate control input + _validate_control_input(dmd, control_data, data) + + # Check if this is a DMDc model + is_dmdc = hasattr(dmd, 'B_v') and dmd.B_v is not None and control_data is not None + + # Get parameters from the DMD model + n_delays = dmd.n_delays + delay_interval = dmd.delay_interval if hasattr(dmd, 'delay_interval') else 1 + steps_ahead = dmd.steps_ahead if dmd.steps_ahead is not None and hasattr(dmd,'steps_ahead') else 1 + device = dmd.device + + # For DMDc, we need rank_output for state and rank_input for control + if is_dmdc: + rank_output = dmd.rank_output if hasattr(dmd, 'rank_output') else dmd.rank + rank_input = dmd.rank_input if hasattr(dmd, 'rank_input') else dmd.rank + rank = rank_output + else: + rank = dmd.rank + + # Convert to torch tensor if needed + if isinstance(data, np.ndarray): + data = torch.from_numpy(data).to(device) + else: + data = data.to(device) + + if control_data is not None: + if isinstance(control_data, np.ndarray): + control_data = torch.from_numpy(control_data).to(device) + else: + control_data = control_data.to(device) + + # Construct X and Y if Y is not provided + if Y is None: + if data.ndim == 3: + X_data = data[:, :-steps_ahead] + Y_data = data[:, steps_ahead:] + if control_data is not None: + # Control at time t affects transition from x_t to x_{t+1} + U_data = control_data[:, :-steps_ahead] + else: + X_data = data[:-steps_ahead] + Y_data = data[steps_ahead:] + if control_data is not None: + U_data = control_data[:-steps_ahead] + else: + if isinstance(Y, np.ndarray): + Y = torch.from_numpy(Y).to(device) + else: + Y = Y.to(device) + X_data = data + Y_data = Y + if control_data is not None: + U_data = control_data + + # Compute delay embeddings for state data + H_X = embed_signal_torch(X_data, n_delays, delay_interval) + H_Y = embed_signal_torch(Y_data, n_delays, delay_interval) + + # Compute delay embeddings for control data if present + if is_dmdc: + n_control_delays = dmd.n_control_delays if hasattr(dmd, 'n_control_delays') else 1 + H_U = embed_data_DMDc( + U_data, + n_delays=n_delays, + n_control_delays=n_control_delays, + delay_interval=delay_interval, + control=True + ) + if isinstance(H_U, np.ndarray): + H_U = torch.from_numpy(H_U).to(device) + + # Flatten if 3D (combine trials and time) + if H_X.ndim == 3: + H_X = H_X.reshape(-1, H_X.shape[-1]) + H_Y = H_Y.reshape(-1, H_Y.shape[-1]) + if is_dmdc: + H_U = H_U.reshape(-1, H_U.shape[-1]) + + # Get the appropriate matrix and compute eigendecomposition + A = getattr(dmd, matrix) + if hasattr(A, "cpu"): + A = A.cpu().detach().numpy() + # Note: The DMD convention uses Y ≈ X @ A^T, so for the residual + # ||Yg - λXg||^2 to be small, we need g to be an eigenvector of A^T + eigenvalues, eigenvectors = np.linalg.eig(A.T) + + # Project into appropriate coordinates based on matrix type + if matrix == "A_havok_dmd": + # For A_havok_dmd, data is already in the right space (observation space) + X = H_X.cpu().detach().numpy() if hasattr(H_X, "cpu") else H_X + Y = H_Y.cpu().detach().numpy() if hasattr(H_Y, "cpu") else H_Y + + if is_dmdc: + # Get B_havok_dmd and project control + B = dmd.B_havok_dmd + if hasattr(B, "cpu"): + B = B.cpu().detach().numpy() + U = H_U.cpu().detach().numpy() if hasattr(H_U, "cpu") else H_U + # Subtract control effects + Y = _subtract_control_effects(Y, B, U) + + elif matrix == "A_v": + # For A_v, project into V coordinates: X_proj = X @ U @ S_mat_inv[:rank, :rank] + # DMDc uses Uh/Sh_mat_inv, regular DMD uses U/S_mat_inv + if is_dmdc: + U_proj_mat = dmd.Uh[:, :rank] + S_inv_mat = dmd.Sh_mat_inv[:rank, :rank] + else: + U_proj_mat = dmd.U[:, :rank] + S_inv_mat = dmd.S_mat_inv[:rank, :rank] + + X_proj = H_X @ U_proj_mat @ S_inv_mat + Y_proj = H_Y @ U_proj_mat @ S_inv_mat + + X = X_proj.cpu().detach().numpy() if hasattr(X_proj, "cpu") else X_proj + Y = Y_proj.cpu().detach().numpy() if hasattr(Y_proj, "cpu") else Y_proj + + if is_dmdc: + # Project control into its reduced space + Uu = dmd.Uu[:, :rank_input].cpu().numpy() + Su_mat_inv = dmd.Su_mat_inv[:rank_input, :rank_input].cpu().numpy() + U_proj = H_U @ Uu @ Su_mat_inv + U = U_proj.cpu().detach().numpy() if hasattr(U_proj, "cpu") else U_proj + + # Get B_v and subtract control effects + B_v = dmd.B_v + if hasattr(B_v, "cpu"): + B_v = B_v.cpu().detach().numpy() + + # Subtract control effects: Y_corrected = Y - B_v @ U.T + Y = _subtract_control_effects(Y, B_v, U) else: - return L, G, residuals, normalized_residuals + raise ValueError(f"matrix must be 'A_v' or 'A_havok_dmd', got {matrix}") + + # Truncate eigenvalues/vectors to rank + eigenvalues = eigenvalues[:rank] + eigenvectors = eigenvectors[:, :rank] + + # Use shared core computation + residuals, normalized_residuals = _compute_residuals_from_matrices( + X, Y, eigenvalues, eigenvectors + ) + + return eigenvalues, eigenvectors, residuals, normalized_residuals + + +def compute_residuals_pykoopman( + model, + test_data: np.ndarray, + control_data: np.ndarray = None, +): + """ + Compute residuals for a fitted PyKoopman model. + + Parameters + ---------- + model : pk.Koopman + Fitted PyKoopman model. Can use DMD, EDMD, DMDc, EDMDc, or PyDMD regressors. + test_data : np.ndarray + Test data. Shape (T, N) or (K, T, N). + control_data : np.ndarray, optional + Control input data. Required for models with control (DMDc, EDMDc, PyDMD DMDc). + Must have the same temporal structure as test_data. + + Returns + ------- + eigenvalues : np.ndarray + Eigenvalues of the state matrix. + eigenvectors : np.ndarray + Eigenvectors of the state matrix. + residuals : np.ndarray + Residuals for each eigenpair. + normalized_residuals : np.ndarray + Normalized residuals. + + Notes + ----- + For control models (DMDc, EDMDc, PyDMD DMDc), residuals are computed on the + autonomous dynamics by subtracting out the control effects: + + Y_corrected = Y - B @ U + + This allows assessment of eigenvalue quality for the A matrix alone. + """ + # Ensure test_data is numpy + if isinstance(test_data, torch.Tensor): + test_data = test_data.cpu().numpy() + if control_data is not None and isinstance(control_data, torch.Tensor): + control_data = control_data.cpu().numpy() + + # Validate control input + _validate_control_input(model, control_data, test_data) + + # Check if this is a control model + is_control = _requires_control(model) and control_data is not None + + # Split data into X and Y with temporal offset BEFORE transforming + # This correctly handles trial boundaries - each (X[k,t], Y[k,t]) pair is aligned + if test_data.ndim == 3: + X_data = test_data[:, :-1] # (K, T-1, N) + Y_data = test_data[:, 1:] # (K, T-1, N) + if is_control: + U_data = control_data[:, :-1] # (K, T-1, control_dim) + else: + X_data = test_data[:-1] # (T-1, N) + Y_data = test_data[1:] # (T-1, N) + if is_control: + U_data = control_data[:-1] # (T-1, control_dim) + + # Transform to observable space - handles 3D structure automatically + H_X = model.observables.transform(X_data) + H_Y = model.observables.transform(Y_data) + + # Flatten if 3D (combine trials and time) + if H_X.ndim == 3: + H_X = H_X.reshape(-1, H_X.shape[-1]) + H_Y = H_Y.reshape(-1, H_Y.shape[-1]) + if is_control: + # Account for samples consumed by observable (e.g., TimeDelay) + n_consumed = getattr(model.observables, 'n_consumed_samples', 0) + U_data = U_data[:, n_consumed:] # (K, T-1-n_consumed, control_dim) + U_data = U_data.reshape(-1, U_data.shape[-1]) + elif is_control: + n_consumed = getattr(model.observables, 'n_consumed_samples', 0) + U_data = U_data[n_consumed:] + + # Get state matrix and eigendecomposition + # Note: PyKoopman uses Y ≈ X @ A^T convention, so for the residual + # ||Yg - λXg||^2 to be small, we need g to be an eigenvector of A^T + A = model.A + eigenvalues, eigenvectors = np.linalg.eig(A.T) + + # Get projection matrix and project into reduced space + ur = model.ur + rank = ur.shape[1] + + X = H_X @ ur # (total_samples, rank) + Y = H_Y @ ur # (total_samples, rank) + + # Handle control if present - subtract control effects + if is_control: + B = model.B + # Subtract control effects: Y_corrected = Y - U @ B.T + Y = _subtract_control_effects(Y, B, U_data) + + # Truncate eigenvalues/vectors to rank + eigenvalues = eigenvalues[:rank] + eigenvectors = eigenvectors[:, :rank] + + # Use shared core computation + residuals, normalized_residuals = _compute_residuals_from_matrices( + X, Y, eigenvalues, eigenvectors + ) + + return eigenvalues, eigenvectors, residuals, normalized_residuals + + +def compute_residuals_subspace_dmdc( + model: "SubspaceDMDc", + test_data: np.ndarray = None, + control_data: np.ndarray = None, + use_training_latents: bool = False, + projection_method: str = 'smooth', +): + """ + Compute residuals for a fitted SubspaceDMDc model. + + Parameters + ---------- + model : SubspaceDMDc + Fitted SubspaceDMDc model. + test_data : np.ndarray, optional + Test data (observations). Shape (T, N) or (K, T, N) or list of arrays. + If None and use_training_latents=True, uses training data. + control_data : np.ndarray, optional + Control input data. Must have the same temporal structure as test_data. + If None and use_training_latents=True, uses training control data. + use_training_latents : bool, default=False + If True, uses the exact latent states from training (stored in model.info['X_hat']). + This should give near-zero residuals for training data since A was fit to these states. + If False, projects test_data to latent space using Kalman filtering/smoothing. + projection_method : str, default='smooth' + Method for projecting observations to latent states (only used if use_training_latents=False): + - 'smooth': Kalman smoothing (uses all observations, better estimates) + - 'filter': Kalman filtering (causal, uses only past observations) + + Returns + ------- + eigenvalues : np.ndarray + Eigenvalues of the state matrix A. + eigenvectors : np.ndarray + Eigenvectors of the state matrix A. + residuals : np.ndarray + Residuals for each eigenpair. + normalized_residuals : np.ndarray + Normalized residuals. + + Notes + ----- + For SubspaceDMDc, the system operates in latent state space: + + x_{t+1} = A @ x_t + B @ u_t + y_t = C @ x_t + + Residuals are computed in the latent space by: + 1. Projecting observations to latent states via Kalman smoothing/filtering + 2. Subtracting control effects: X_next_corrected = X_next - B @ U + 3. Computing residuals on (X, X_next_corrected) using the A matrix eigenstructure + """ + # Get model parameters + rank = model.info['rank_used'] + A = model.A_v + B = model.B_v + + if use_training_latents: + # Use the exact latent states from training - should give near-zero residuals + X, X_next, U = model.get_training_latent_states(return_aligned=True) + else: + if control_data is None: + raise ValueError("control_data is required for SubspaceDMDc residual computation.") + + # Convert to numpy if needed + if isinstance(test_data, torch.Tensor): + test_data = test_data.cpu().numpy() + if isinstance(control_data, torch.Tensor): + control_data = control_data.cpu().numpy() + + # Project test data to latent space using Kalman filtering/smoothing + # Returns time-aligned (X, X_next, U) in row-major format + X, X_next, U = model.project_to_latent( + test_data, control_data, return_aligned=True, method=projection_method + ) + + # Subtract control effects: X_next_corrected = X_next - B @ U.T + Y_corrected = _subtract_control_effects(X_next, B, U) + + # Compute eigendecomposition of A + # Note: SubspaceDMDc uses X_next = A @ X + B @ U in column format, + # but after transposing to row format, we have Y ≈ X @ A^T. + # So for ||Yg - λXg||^2 to be small, we need g to be an eigenvector of A^T + eigenvalues, eigenvectors = np.linalg.eig(A.T) + + # Truncate to rank + eigenvalues = eigenvalues[:rank] + eigenvectors = eigenvectors[:, :rank] + + # Use shared core computation + residuals, normalized_residuals = _compute_residuals_from_matrices( + X, Y_corrected, eigenvalues, eigenvectors + ) + + return eigenvalues, eigenvectors, residuals, normalized_residuals + + +# ============================================================================= +# ResidualComputer Class +# ============================================================================= + +class ResidualComputer: + """ + Computes and plots eigenvalue residuals for DMD-type models. + + Supports local DMD, local DMDc, SubspaceDMDc, and PyKoopman models + (including those with control: DMDc, EDMDc, PyDMD DMDc). + + Parameters + ---------- + model : DMD, DMDc, SubspaceDMDc, or pk.Koopman + A fitted DMD-type model. + test_data : np.ndarray + Test data for residual computation. Shape (T, N) or (K, T, N). + control_data : np.ndarray, optional + Control input data. Required for models with control. + Must have the same temporal structure as test_data. + model_type : str, optional + Model type: "auto", "local_dmd", "subspace_dmdc", or "pykoopman". + Default "auto". + + Attributes + ---------- + eigenvalues : np.ndarray + Eigenvalues of the state matrix. + eigenvectors : np.ndarray + Eigenvectors of the state matrix. + residuals : np.ndarray + Residuals for each eigenpair. + normalized_residuals : np.ndarray + Normalized residuals. + + Example + ------- + >>> # For autonomous DMD + >>> rc = ResidualComputer(model, test_data) + >>> eigenvalues, eigenvectors, residuals, norm_resid = rc.compute() + >>> rc.plot(title="Eigenvalue Residuals") + + >>> # For DMDc with control + >>> rc = ResidualComputer(dmdc_model, test_data, control_data=control_test) + >>> eigenvalues, eigenvectors, residuals, norm_resid = rc.compute() + """ + + def __init__( + self, + model, + test_data: np.ndarray, + control_data: np.ndarray = None, + model_type: str = "auto" + ): + self.model = model + self.test_data = test_data + self.control_data = control_data + self.model_type = self._detect_model_type(model) if model_type == "auto" else model_type + + # Validate control input + _validate_control_input(model, control_data, test_data) + + # Results (computed lazily) + self.eigenvalues = None + self.eigenvectors = None + self.residuals = None + self.normalized_residuals = None + self._computed = False + + def _detect_model_type(self, model) -> str: + """Detect the model type for dispatch.""" + # Check for SubspaceDMDc first (it has A_v but also has 'info' with Gamma_hat) + if hasattr(model, 'A_v') and hasattr(model, 'info') and model.info is not None: + if 'Gamma_hat' in model.info: + return "subspace_dmdc" + + # Local DMD or DMDc + if hasattr(model, 'A_v') and hasattr(model, 'n_delays'): + return "local_dmd" + + # PyKoopman + if hasattr(model, '_pipeline') and hasattr(model, 'A'): + return "pykoopman" + + raise ValueError(f"Cannot detect model type for {type(model)}. " + "Please specify model_type explicitly.") + + def compute(self): + """ + Compute residuals for the model. + + Returns + ------- + eigenvalues : np.ndarray + Eigenvalues. + eigenvectors : np.ndarray + Eigenvectors. + residuals : np.ndarray + Residuals for each eigenpair. + normalized_residuals : np.ndarray + Normalized residuals. + """ + if self.model_type == "local_dmd": + result = compute_residuals( + self.model, + self.test_data, + control_data=self.control_data + ) + elif self.model_type == "subspace_dmdc": + result = compute_residuals_subspace_dmdc( + self.model, + self.test_data, + self.control_data + ) + elif self.model_type == "pykoopman": + result = compute_residuals_pykoopman( + self.model, + self.test_data, + control_data=self.control_data + ) + else: + raise ValueError(f"Unknown model_type: {self.model_type}") + + self.eigenvalues, self.eigenvectors, self.residuals, self.normalized_residuals = result + self._computed = True + return self.eigenvalues, self.eigenvectors, self.residuals, self.normalized_residuals + + def plot( + self, + cmin: float = None, + cmax: float = None, + ax=None, + figsize: tuple = (6, 6), + title: str = None, + ): + """ + Plot eigenvalues on the complex plane, colored by residuals. + + Parameters + ---------- + cmin : float, optional + Minimum value for color scale. + cmax : float, optional + Maximum value for color scale. + ax : matplotlib.axes.Axes, optional + Axes to plot on. If None, creates new figure. + figsize : tuple + Figure size if creating new figure. + title : str, optional + Plot title. + + Returns + ------- + fig, ax : matplotlib figure and axes + """ + import matplotlib.pyplot as plt + from matplotlib import cm + from matplotlib import colors as mcolors + + if not self._computed: + self.compute() + + residuals_real = np.real(self.residuals) + + if cmin is None: + cmin = np.min(residuals_real) + if cmax is None: + cmax = np.max(residuals_real) + + if ax is None: + fig, ax = plt.subplots(1, 1, figsize=figsize) + else: + fig = ax.get_figure() + + cmap = cm.viridis + norm = mcolors.Normalize(vmin=cmin, vmax=cmax) + + # Plot unit circle + theta = np.linspace(0, 2*np.pi, 100) + ax.plot(np.cos(theta), np.sin(theta), 'k--', alpha=0.3, linewidth=1) + + sc = ax.scatter( + np.real(self.eigenvalues), + np.imag(self.eigenvalues), + c=residuals_real, + cmap=cmap, + norm=norm + ) + cbar = plt.colorbar(sc, ax=ax, orientation="vertical") + cbar.set_label("Residual") + + ax.set_xlim(-1.1, 1.1) + ax.set_ylim(-1.1, 1.1) + ax.set_xlabel("Real") + ax.set_ylabel("Imaginary") + ax.set_aspect('equal') + + if title: + ax.set_title(title) + + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + + return fig, ax + + def get_average_residual(self) -> float: + """Return mean absolute residual.""" + if not self._computed: + self.compute() + return float(np.mean(np.abs(self.residuals))) + +# ============================================================================= +# Utility Functions +# ============================================================================= -def plot_residuals(L, residuals, cmin=None, cmax=None): +def plot_residuals(eigenvalues, residuals, cmin=None, cmax=None): """ Plot eigenvalues on the complex plane, colored by residuals. Parameters ---------- - L : np.ndarray + eigenvalues : np.ndarray Eigenvalues. residuals : np.ndarray Residuals for each eigenpair. @@ -132,71 +864,139 @@ def plot_residuals(L, residuals, cmin=None, cmax=None): cmax : float, optional Maximum value for color scale. """ + import matplotlib.pyplot as plt + from matplotlib import cm + from matplotlib import colors as mcolors - plt.scatter(np.real(L), np.imag(L), c=residuals) + residuals_real = np.abs(residuals) if cmin is None: - cmin = np.min(residuals) + cmin = np.min(residuals_real) if cmax is None: - cmax = np.max(residuals) + cmax = np.max(residuals_real) cmap = cm.viridis norm = mcolors.Normalize(vmin=cmin, vmax=cmax) - sm = cm.ScalarMappable(cmap=cmap, norm=norm) - sm.set_array([]) - cbar = plt.colorbar(sm, orientation="vertical") + sc = plt.scatter(np.real(eigenvalues), np.imag(eigenvalues), c=residuals_real, cmap=cmap, norm=norm) + cbar = plt.colorbar(sc, orientation="vertical") cbar.set_label("Residual") plt.xlim(-1, 1) plt.ylim(-1, 1) plt.xlabel("Real") plt.ylabel("Imaginary") - # plt.show() def compute_inverse_participation_ratio(residuals): + """Compute inverse participation ratio from residuals.""" if isinstance(residuals, list): residuals = np.array(residuals) - - inv_resid = 1 / residuals + residuals = np.abs(residuals) + inv_resid = 1 / (residuals + 1e-10) num = np.sum(inv_resid) ** 2 denom = np.sum(inv_resid**2) return num / denom -def clean_spectrum(L, G, residuals, epsilon): +def clean_spectrum(eigenvalues, eigenvectors, residuals, epsilon): """ - remove the eigenvalues with value greater than epsilon + Remove eigenvalues with residual greater than epsilon. + + Parameters + ---------- + eigenvalues : np.ndarray + Eigenvalues. + eigenvectors : np.ndarray + Eigenvectors. + residuals : np.ndarray + Residuals. + epsilon : float + Threshold. + + Returns + ------- + eigenvalues, eigenvectors, residuals : filtered arrays """ - mask = residuals < epsilon - return L[mask], G[:, mask], residuals[mask] + residuals_real = np.abs(residuals) + mask = residuals_real < epsilon + return eigenvalues[mask], eigenvectors[:, mask], residuals[mask] -def thresh_topn(L, G, residuals, n): - # pick the top n eigenvalues with the smallest residuals - sorted_resid = np.sort(residuals) +def thresh_topn(eigenvalues, eigenvectors, residuals, n): + """ + Keep the top n eigenvalues with smallest residuals. + + Parameters + ---------- + eigenvalues : np.ndarray + Eigenvalues. + eigenvectors : np.ndarray + Eigenvectors. + residuals : np.ndarray + Residuals. + n : int + Number to keep. + + Returns + ------- + eigenvalues, eigenvectors, residuals : filtered arrays + """ + residuals_real = np.abs(residuals) + sorted_resid = np.sort(residuals_real) if n > len(sorted_resid): n = -1 topn = sorted_resid[n] - mask = residuals <= topn - return L[mask], G[:, mask], residuals[mask] - + mask = residuals_real <= topn + return eigenvalues[mask], eigenvectors[:, mask], residuals[mask] -def format_eigs(eig1): - if isinstance(eig1, list): - eig1 = np.array(eig1) - # sort eigenvalues by real magnitude - eig1 = eig1[np.argsort(np.abs(eig1.real))] - eig1 = np.vstack([eig1.real, eig1.imag]).T - return eig1 +def format_eigs(eigenvalues): + """Format eigenvalues as 2D array sorted by real magnitude.""" + if isinstance(eigenvalues, list): + eigenvalues = np.array(eigenvalues) + # Sort by real magnitude + eigenvalues = eigenvalues[np.argsort(np.abs(eigenvalues.real))] + return np.vstack([eigenvalues.real, eigenvalues.imag]).T def compute_ot_distance(a, b): - # check if a has imaginary compnents, if so convet to 2d array + """ + Compute optimal transport distance between two sets of eigenvalues. + + Parameters + ---------- + a, b : np.ndarray + Eigenvalue arrays (can be complex). + + Returns + ------- + score : float + OT distance. + C : np.ndarray + Transport plan. + """ + import ot + + # Convert complex to 2D if needed if np.iscomplexobj(a): a = np.vstack([a.real, a.imag]).T if np.iscomplexobj(b): b = np.vstack([b.real, b.imag]).T M = ot.dist(a, b) - a, b = np.ones(a.shape[0]) / a.shape[0], np.ones(b.shape[0]) / b.shape[0] - score = ot.emd2(a, b, M) - C = ot.emd(a, b, M) + a_weights = np.ones(a.shape[0]) / a.shape[0] + b_weights = np.ones(b.shape[0]) / b.shape[0] + score = ot.emd2(a_weights, b_weights, M) + C = ot.emd(a_weights, b_weights, M) return score, C + + +# Module exports +__all__ = [ + "ResidualComputer", + "compute_residuals", + "compute_residuals_pykoopman", + "compute_residuals_subspace_dmdc", + "plot_residuals", + "compute_inverse_participation_ratio", + "clean_spectrum", + "thresh_topn", + "format_eigs", + "compute_ot_distance", +] diff --git a/DSA/simdist.py b/DSA/simdist.py index 8d73078..17babba 100644 --- a/DSA/simdist.py +++ b/DSA/simdist.py @@ -1,31 +1,53 @@ import torch import torch.nn as nn import torch.optim as optim -from typing import Literal +from typing import Literal, Final 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 warnings -def pad_zeros(A,B,device): +from ot import dist, emd, emd2, sinkhorn2 + +try: + from .dmd import DMD +except ImportError: + from dmd import DMD + + +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 +55,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 +84,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 +103,57 @@ 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, + eps=1e-5, + rescale_wasserstein=False, + compare: Final = 'state', + differentiable=False, + sinkhorn_reg=0.1, + ): """ 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 +164,18 @@ 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} - specifies whether to compare the singular values or eigenvalues - if score_method is "wasserstein", or the shapes are different + eps : float + early stopping threshold + + compare : str (final). dummy variable for inference of types / config + + differentiable : bool + If True, use ot.sinkhorn2 instead of ot.emd/ot.emd2 for Wasserstein + distance, enabling gradient flow through the score. + + sinkhorn_reg : float + Entropy regularization for Sinkhorn (only used when differentiable=True). """ self.iters = iters @@ -149,94 +186,204 @@ 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 + self.wasserstein_compare = 'eig' # for backwards compatibility + self.compare = compare + self.differentiable = differentiable + self.sinkhorn_reg = sinkhorn_reg + + def fit( + self, + A, + B, + iters=None, + lr=None, + score_method=None, + wasserstein_weightings=None, + ): """ Computes the optimal matrix C over specified group Parameters __________ - A : np.array or torch.tensor - first data matrix - B : np.array or torch.tensor - second data matrix + A : np.array or torch.tensor or DMD object + 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 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 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 """ - 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 - 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 + + if score_method == "wasserstein": + if not precomputed_eigenvalues: + a, b = self._get_wasserstein_vars(A, B) + device = a.device + # a = a # .cpu() + # b = b # .cpu() + self.M = 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) + + if self.differentiable: + self.score_star = sinkhorn2( + a, b, self.M, reg=self.sinkhorn_reg + ) + # No transport plan needed for differentiable mode + self.C_star = None + else: + self.C_star = emd(a, b, self.M) + self.score_star = ( + 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'} + 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'") + + # 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 +393,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): """ Given an optimal C already computed, calculate the metric @@ -271,77 +421,77 @@ def score(self,A=None,B=None,score_method=None,group=None): score : float similarity of the data under the similarity transform w.r.t C """ - 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 score_method = self.score_method if score_method is None else score_method - group = self.group if group is None else group + if score_method != "wasserstein": + assert self.C_star is not None + assert A.shape == self.C_star.shape + assert B.shape == self.C_star.shape 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 - ) - 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 + 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 self.differentiable: + score = self.score_star # keep as tensor for gradient flow else: - score = norm_tensor.detach().cpu().numpy().item() + 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 - 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, 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 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 @@ -350,50 +500,108 @@ 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): - A = torch.from_numpy(A).float() - 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()) + 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 + 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: - - self.fit(A, B,iters,lr,group) - score_star = self.score(self.A,self.B,score_method=score_method,group=group) + 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, + 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") - return score_star + # Check matrix is square + if mat.shape[0] != mat.shape[1]: + raise ValueError(f"matrix must be square") + return mat \ No newline at end of file diff --git a/DSA/simdist_controllability.py b/DSA/simdist_controllability.py new file mode 100644 index 0000000..03c87b9 --- /dev/null +++ b/DSA/simdist_controllability.py @@ -0,0 +1,213 @@ +from typing import Literal +import numpy as np +from scipy.linalg import orthogonal_procrustes +import torch + + +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", + align_inputs: bool = False, + return_distance_components: bool = False, + ): + """ + Parameters + ---------- + score_method : {"euclidean", "angular"} + Distance method to use. Euclidean uses Frobenius norm, angular uses principal angles. + 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). + 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 + 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): + """ + 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): + 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( + 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": + 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 + ) + 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": + return sims_joint_euc + elif self.score_method == "angular": + return sims_joint_ang + else: + raise ValueError("Choose between Euclidean or angular distance") + + 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" + ) + + else: + return self.compare_B(A_control, B_control, score_method=self.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): + """ + 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 + #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 + 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"): + """ + 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") + # return np.linalg.norm(B1 - R.T @ B2, "fro") ** 2 + elif score_method == "angular": + 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") diff --git a/DSA/stats.py b/DSA/stats.py index 1085183..fefb42b 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 @@ -105,6 +106,34 @@ def mse(x, y): return ((x - y) ** 2).mean().item() +def nmse(x, y, eps=1e-10): + """ + 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. + eps : float, optional + Small constant to prevent division by zero when x has zero variance. + Default is 1e-10. + + Returns + ------- + nmse_val : float + The normalized mean squared error between the provided arrays. + """ + x = torch_convert(x) + y = torch_convert(y) + mse = ((x - y) ** 2).mean().item() + variance = ((x - x.mean()) ** 2).mean().item() + if variance < eps: + # If x is constant (zero variance), NMSE is undefined + # Return 0.0 if predictions are perfect, inf otherwise + return 0.0 if mse < eps else float('inf') + return mse / variance + + def r2(true_vals, pred_vals): """ Compute the R-squared value between two sets of data. For arrays with multiple observed dimensions, @@ -253,6 +282,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), @@ -499,7 +529,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. @@ -520,27 +550,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..99ea075 --- /dev/null +++ b/DSA/subspace_dmdc.py @@ -0,0 +1,812 @@ +"""This module computes the subspace DMD with control (DMDc) model for a given dataset.""" +import numpy as np +import warnings +import torch +from .base_dmd import BaseDMD + +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=None, + n_delays=1, + rank=None, + lamb=1e-8, + device='cpu', + verbose=False, + send_to_cpu=False, + backend='n4sid', + ): + """ + 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) + 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) + 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) + + self._init_data(data, control_data) + self._check_same_shape() + + # 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 + 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 + self.info = None + self.n_delays = n_delays + self.rank = rank + self.backend = backend + + def fit(self,data=None,control_data=None): + """Fit the SubspaceDMDc model.""" + if data is None and control_data is None: + data = self.data + control_data = self.control_data + self.A_v, self.B_v, self.C_v, self.info = self.subspace_dmdc_multitrial_flexible( + y=data, + u=control_data, + p=self.n_delays, + f=self.n_delays, + n=self.rank, + 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') + + + 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: + 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: + 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 _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 _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[-1] + m = u_list[0].shape[-1] + + U_p_all = [] + Y_p_all = [] + U_f_all = [] + Y_f_all = [] + valid_trials = [] + T_per_trial = [] + + def hankel_stack(X, start, L): + # X is now (n_timepoints, n_features), so we transpose for slicing + # 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)): + N_trial = Y_trial.shape[0] + T_trial = N_trial - (p + f) + + if T_trial <= 0: + 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 time points for given number of delays") + elif len(valid_trials) < len(y_list) // 2: + warnings.warn( + f"Only {len(valid_trials)} out of {len(y_list)} trials have sufficient time points " + f"relative to the number of delays. This may affect model quality. Consider reducing the number of delays.") + else: + # print(f"Using {len(valid_trials)} out of {len(y_list)} trials with sufficient time points.") + pass + + 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]) + + 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._collect_data(y_list, u_list, p, f) + + H = np.vstack([U_f, Z_p, Y_f]) + + dim_uf = f * m + dim_zp = p * (m + p_out) + + def calculate_projection_and_svd(H, Z_p): + # Check if inputs are torch tensors + is_torch = isinstance(H, torch.Tensor) or isinstance(Z_p, torch.Tensor) + + if is_torch: + Q, R_upper = torch.linalg.qr(H.T) + L = R_upper.T + + 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] + + O = R32 @ torch.linalg.pinv(R22) @ Z_p + Uo, s, Vt = torch.linalg.svd(O, full_matrices=False) + else: + Q, R_upper = np.linalg.qr(H.T, mode='reduced') + L = R_upper.T + + 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] + + 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) + + Uo = self._to_numpy(Uo) + s = self._to_numpy(s) + Vt = self._to_numpy(Vt) + else: + 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 + X_hat = S_half @ V_n + + 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, Y_curr, C_hat) + + 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, + 'X_hat': X_hat + } + + return A_hat, B_hat, C_hat, info + + 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] + X_trial_curr = X_trial[:, :-1] + X_trial_next = X_trial[:, 1:] + + original_trial_idx = valid_trials[trial_idx] + U_trial = u_list[original_trial_idx] + # 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 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 + + 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) + 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.""" + Z = np.vstack([X, U_mid]) + if self.use_torch and Z.shape[1] > 100: + Z_torch = self._to_torch(Z) + X_next_torch = self._to_torch(X_next) + + 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) + else: + 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:] + + return A_hat, B_hat + + 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 = 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) + N_res = V_hat.shape[1] + denom = max(N_res - 1, 1) + + R_hat = (V_hat @ V_hat.T) / denom + Q_hat = (W_hat @ W_hat.T) / denom + S_hat = (W_hat @ V_hat.T) / denom + + 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]]) + + 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 using custom method.""" + U_p, Y_p, U_f, Y_f, Z_p, valid_trials, T_per_trial, T_total, p_out, m = \ + self._collect_data(y_list, u_list, p, f) + + 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 + + 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 + X_hat = S_half @ V_n + + 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) + + 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, Y_curr, C_hat) + + 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, + 'X_hat': X_hat + } + + return A_hat, B_hat, C_hat, info + + + def _convert_to_subspace_dmdc_data_format(self,y, u): + """Convert the data and control data to the format required for SubspaceDMDc.""" + if isinstance(y, list) and isinstance(u, list): + y_list = [] + u_list = [] + 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]) + u_list.append(u_trial[t]) + elif y_trial.ndim == 2 and u_trial.ndim == 2: + 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: + if y.ndim == 2: + y_list = [y] + u_list = [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 for y_trial in y_list] + u_list = [u_trial for u_trial in u_list] + return y_list, u_list + + + 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 + """ + y_list, u_list = self._convert_to_subspace_dmdc_data_format(y, 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) + + + def get_training_latent_states(self, return_aligned=True): + """ + Get the latent states from training data. + + Parameters + ---------- + return_aligned : bool, default=True + If True, returns time-aligned (X, X_next, U) triplets. + If False, returns raw X_hat matrix. + + Returns + ------- + If return_aligned=True: + X : np.ndarray, shape (T_total, rank) + Current latent states (row-major format). + X_next : np.ndarray, shape (T_total, rank) + Next latent states (row-major format). + U : np.ndarray, shape (T_total, m) + Control inputs aligned with X (row-major format). + If return_aligned=False: + X_hat : np.ndarray, shape (rank, T_total) + Raw latent states from training. + """ + X_hat = self.info['X_hat'] + + if not return_aligned: + return X_hat + + # Need to re-align using stored info + p = self.n_delays + valid_trials = self.info['valid_trials'] + T_per_trial = self.info['T_per_trial'] + + # Get training data in list format + y_list, u_list = self._convert_to_subspace_dmdc_data_format(self.data, self.control_data) + + X, X_next, U, _ = self._time_align_valid_trials( + X_hat, u_list, y_list, valid_trials, T_per_trial, p + ) + + return X.T, X_next.T, U.T + + def project_to_latent(self, test_data, control_data, return_aligned=True, method='smooth'): + """ + Project new observations to latent states using Kalman filtering/smoothing. + + This method uses the learned state-space model (A, B, C) to infer latent + states from observations, which projects into the same latent space as training. + + Parameters + ---------- + test_data : np.ndarray or list + Test observations. Shape (T, N), (K, T, N), or list of (T_k, N) arrays. + control_data : np.ndarray or list + Control inputs. Must have the same structure as test_data. + return_aligned : bool, default=True + If True, returns time-aligned (X, X_next, U) triplets ready for dynamics. + If False, returns raw latent states per trial. + method : str, default='smooth' + 'filter' - use Kalman filtering (causal, uses only past observations) + 'smooth' - use Kalman smoothing (non-causal, uses all observations) + + Returns + ------- + If return_aligned=True: + X : np.ndarray, shape (T_total, rank) + Current latent states (row-major format). + X_next : np.ndarray, shape (T_total, rank) + Next latent states (row-major format). + U : np.ndarray, shape (T_total, m) + Control inputs aligned with X (row-major format). + If return_aligned=False: + x_latents : list of np.ndarray + Latent states for each trial, each shape (T_trial, rank). + """ + # Convert to list format for consistent processing + y_list, u_list = self._convert_to_subspace_dmdc_data_format(test_data, control_data) + + X_all = [] + X_next_all = [] + U_all = [] + x_latents_all = [] + + for trial_idx, (y_trial, u_trial) in enumerate(zip(y_list, u_list)): + T_trial = y_trial.shape[0] + + # Run Kalman filter forward pass + kalman = OnlineKalman(self) + for t in range(T_trial): + kalman.step(y=y_trial[t], u=u_trial[t]) + + # Get latent states + if method == 'smooth': + # Run backward smoothing pass + x_smoothed, _ = kalman.smooth() + # Stack into (T, rank) array + x_latent = np.hstack(x_smoothed).T # (T, rank) + else: + # Use filtered states + x_latent = np.hstack(kalman.x_filtereds).T # (T, rank) + + x_latents_all.append(x_latent) + + if return_aligned: + # Create (X[t], X[t+1], U[t]) triplets + X_all.append(x_latent[:-1]) # (T-1, rank) + X_next_all.append(x_latent[1:]) # (T-1, rank) + U_all.append(u_trial[:-1]) # (T-1, m) + + if not return_aligned: + return x_latents_all + + # Concatenate across trials + X = np.concatenate(X_all, axis=0) + X_next = np.concatenate(X_next_all, axis=0) + U = np.concatenate(U_all, axis=0) + + return X, X_next, U + + 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(test_data, list): + self.kalman = OnlineKalman(self) + Y_pred = [] + for trial in range(len(test_data)): + self.kalman.reset() + trial_predictions = [ + 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 test_data.ndim == 2: + return np.concatenate( + [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(test_data.shape[0]): + self.kalman.reset() + trial_predictions = [ + 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( + "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.""" + 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.""" + + def __init__(self, dmdc): + """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 + self.R = dmdc.info['R_hat'] + self.S = dmdc.info['S_hat'] + self.Q = dmdc.info['Q_hat'] + + self.y_dim, self.x_dim = self.C.shape + self.u_dim = self.B.shape[1] + + self.reset() + + def step(self, y=None, u=None, reg_coef=1e-6): + """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) + + 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 = 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._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) + 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) + + 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 = [] + 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 + } + + def smooth(self, reg_coef=1e-6): + """ + Perform RTS (Rauch-Tung-Striebel) smoothing on the filtered states. + + This is the backward pass that uses future observations to improve + state estimates. Must be called after running the forward filter pass. + + Parameters + ---------- + reg_coef : float + Regularization coefficient for numerical stability. + + Returns + ------- + x_smoothed : list of np.ndarray + Smoothed state estimates, shape (x_dim, 1) each. + p_smoothed : list of np.ndarray + Smoothed covariance estimates. + """ + if len(self.x_filtereds) == 0: + raise ValueError("Must run forward filter pass before smoothing.") + + T = len(self.x_filtereds) + + # Initialize with final filtered state + x_smoothed = [None] * T + p_smoothed = [None] * T + x_smoothed[-1] = self.x_filtereds[-1].copy() + p_smoothed[-1] = self.p_filtereds[-1].copy() + + # Backward pass + for t in range(T - 2, -1, -1): + # Get filtered and predicted values at time t + x_filt_t = self.x_filtereds[t] + p_filt_t = self.p_filtereds[t] + + # Predicted values for t+1 (computed during forward pass at time t) + # p_predicteds[t] is P_{t+1|t} computed after processing observation t + p_pred_tp1 = self.p_predicteds[t] + + # Regularize for numerical stability + p_pred_tp1_reg = p_pred_tp1 + reg_coef * np.eye(self.x_dim) + + # Smoother gain: J_t = P_{t|t} @ A^T @ P_{t+1|t}^{-1} + J_t = p_filt_t @ self.A.T @ np.linalg.pinv(p_pred_tp1_reg) + + # x_{t+1|t} = A @ x_{t|t} + B @ u_t + x_pred_tp1 = self.A @ x_filt_t + self.B @ self.us[t] + + # Smoothed state: x_{t|T} = x_{t|t} + J_t @ (x_{t+1|T} - x_{t+1|t}) + x_smoothed[t] = x_filt_t + J_t @ (x_smoothed[t + 1] - x_pred_tp1) + + # Smoothed covariance: P_{t|T} = P_{t|t} + J_t @ (P_{t+1|T} - P_{t+1|t}) @ J_t^T + p_smoothed[t] = p_filt_t + J_t @ (p_smoothed[t + 1] - p_pred_tp1) @ J_t.T + p_smoothed[t] = self._regularize_and_symmetrize(p_smoothed[t], reg_coef) + + self.x_smoothed = x_smoothed + self.p_smoothed = p_smoothed + + return x_smoothed, p_smoothed \ No newline at end of file diff --git a/DSA/sweeps.py b/DSA/sweeps.py index 04e89ce..38d5876 100644 --- a/DSA/sweeps.py +++ b/DSA/sweeps.py @@ -1,479 +1,942 @@ +""" +Sweeps: Parameter sweep utilities for DMD-type models. + +This module provides object-oriented sweeping over hyperparameters +for both local DMD and PyKoopman models. +""" + 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 -import matplotlib.pyplot as plt -from typing import Literal +from .dmd import DMD +from .dmdc import DMDc +from .subspace_dmdc import SubspaceDMDc +from .stats import measure_nonnormality_transpose, compute_all_stats +from .resdmd import ResidualComputer +from typing import List, Dict, Any, Optional, Union, Tuple +from abc import ABC, abstractmethod +import warnings +import torch +from matplotlib.pyplot import plot, savefig, subplots, cm, tight_layout +from . import pykoopman as pk +from .pykoopman.observables import TimeDelay, Identity -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): + """Split data into train and test sets.""" + 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]) :] - test_data = data[:, : int(train_frac * data.shape[1])] + train_data = data[:, int(train_frac * data.shape[1]):] + test_data = data[:, :int(train_frac * data.shape[1])] 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 + 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 dim = data.shape[-1] return train_data, test_data, dim -def sweep_ranks_delays( - data, - n_delays, - ranks, - train_frac=0.8, - reseed=5, - return_residuals=True, - featurize=False, - ndim=None, - return_transient_growth=False, - return_mse=False, - error_space='X', - **dmd_kwargs -): - """ - Sweep over combinations of DMD ranks and delays, returning AIC, MASE, non-normality, and residuals. +class BaseSweeper(ABC): + """Abstract base class for parameter sweeps over DMD-type models. + + This class provides the core infrastructure for sweeping over two hyperparameters + of DMD-type models, computing various metrics (AIC, MASE, MSE, non-normality), + and optionally computing residuals. Subclasses must implement the abstract methods + to define how models are created, how predictions are made, and how to extract + model properties. + Parameters ---------- data : np.ndarray - Input data (trials, time, features). - n_delays : iterable - List or array of delays to sweep. - ranks : iterable - List or array of ranks to sweep. - train_frac : float - Fraction of data to use for training. If greater than or equal to 1, tests on the training set - reseed : int - 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 - Whether to return the mean squared error of the prediction in place of MASE - dmd_kwargs : dict - Additional keyword arguments for DMD. - - Returns - ------- - all_aics, all_mases, all_nnormals, all_residuals, all_num_abscissa, all_l2norm : np.ndarray - Arrays of results for each (delay, rank) pair. + Input data for the sweep. Can be 2D (time, features) or 3D (trials, time, features). + Will be automatically split into train/test sets based on `train_frac`. + param1_name : str + Name of the first parameter to sweep over. + param1_values : list or np.ndarray + Values to sweep over for the first parameter. + param2_name : str + Name of the second parameter to sweep over. + param2_values : list or np.ndarray + Values to sweep over for the second parameter. + train_frac : float, optional + Fraction of data to use for training (default: 0.8). + reseed : int, optional + Number of reseeding steps for prediction (default: 1). + compute_residuals : bool, optional + Whether to compute residuals using ResDMD (default: False). + control_data : np.ndarray, optional + Control/actuation data for controlled systems (default: None). + Will be split into train/test sets matching the data split. + **model_kwargs + Additional keyword arguments passed to the model constructor. + + Attributes + ---------- + train_data : np.ndarray + Training portion of the input data. + test_data : np.ndarray + Test portion of the input data. + train_control : np.ndarray or None + Training portion of control data (if provided). + test_control : np.ndarray or None + Test portion of control data (if provided). + dim : int + Dimensionality of the data (number of features). + aics : np.ndarray + AIC values for each parameter combination (after sweep). + mases : np.ndarray + MASE values for each parameter combination (after sweep). + mses : np.ndarray + MSE values for each parameter combination (after sweep). + nnormals : np.ndarray + Non-normality values for each parameter combination (after sweep). + residuals : np.ndarray or None + Residual values for each parameter combination (after sweep, if computed). + fitted_models : list of lists + Fitted model objects for each parameter combination (after sweep). """ - 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 = [] - aics, mases, nnormals, l2norms = [], [], [], [] - for r in ranks: - if r is None or r > nd * dim: - aics.append(np.inf) - mases.append(np.inf) - nnormals.append(np.inf) - rresiduals.append(np.inf) - l2norms.append(np.inf) - 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(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 - elif error_space == 'X': - pred = pred - test_data_err = test_data - else: - raise ValueError(f"Invalid error space: {error_space}") + + def __init__( + self, + data: np.ndarray, + param1_name: str, + param1_values: Union[List, np.ndarray], + param2_name: str, + param2_values: Union[List, np.ndarray], + train_frac: float = 0.8, + reseed: int = 1, + compute_residuals: bool = False, + control_data: np.ndarray = None, + **model_kwargs + ): + self.data = data + self.param1_name = param1_name + self.param1_values = np.array(param1_values) + self.param2_name = param2_name + self.param2_values = np.array(param2_values) + self.train_frac = train_frac + self.reseed = reseed + self.compute_residuals = compute_residuals + self.model_kwargs = model_kwargs + self.control_data = control_data + + self.train_data, self.test_data, self.dim = split_train_test(data, train_frac) + + # Split control data if provided + if control_data is not None: + self.train_control, self.test_control, _ = split_train_test(control_data, train_frac) + else: + self.train_control = self.test_control = None + + self._aics: np.ndarray = None + self._mases: np.ndarray = None + self._mses: np.ndarray = None + self._nnormals: np.ndarray = None + self._residuals: np.ndarray = None + self._fitted_models: List[List] = None + self._swept = False + + def _validate_control_data(self, model_class) -> None: + """Validate control data against the model class, warning if incompatible. + + Args: + model_class: The model class to validate against. + """ + if self.control_data is not None and model_class is not None: + if not self._is_control_model_class(model_class): + warnings.warn( + f"control_data was provided, but model class ({model_class.__name__}) " + f"may not support control input. Control data may be ignored.", + UserWarning + ) + + @abstractmethod + def _is_control_model_class(self, model_class) -> bool: + """Check if a model class supports control input. + + Args: + model_class: The model class to check. + + Returns: + True if the model class supports control input, False otherwise. + """ + pass + + @abstractmethod + def make_model(self, p1_val, p2_val): + pass + + @abstractmethod + def get_state_matrix(self, model) -> np.ndarray: + pass + + @abstractmethod + def get_rank(self, model) -> int: + pass + + @abstractmethod + def predict(self, model, test_data: np.ndarray, n_steps: int) -> np.ndarray: + pass + + def _is_valid_param_combo(self, p1_val, p2_val) -> bool: + return True + + def sweep(self) -> "BaseSweeper": + """Run the parameter sweep.""" + n1, n2 = len(self.param1_values), len(self.param2_values) + + self._aics = np.full((n1, n2), np.nan) + self._mases = np.full((n1, n2), np.nan) + self._mses = np.full((n1, n2), np.nan) + self._nnormals = np.full((n1, n2), np.nan) + self._residuals = np.full((n1, n2), np.nan) if self.compute_residuals else None + self._fitted_models = [[None for _ in range(n2)] for _ in range(n1)] + + for i, p1 in tqdm(enumerate(self.param1_values), total=n1, desc="Sweeping"): + for j, p2 in enumerate(self.param2_values): + if not self._is_valid_param_combo(p1, p2): + continue + # try: + model = self.make_model(p1, p2) + self._fitted_models[i][j] = model + + pred = self.predict(model, self.test_data, self.reseed) + pred_np = self._to_numpy(pred) + test_np = self._to_numpy(self.test_data) + pred_np, test_np = self._align_predictions(pred_np, test_np) + + rank = self.get_rank(model) + stats = compute_all_stats(test_np, pred_np, rank) + + self._aics[i, j] = stats["AIC"] + self._mases[i, j] = stats["MASE"] + self._mses[i, j] = stats["MSE"] + + A = self.get_state_matrix(model) + A_np = self._to_numpy(A) + self._nnormals[i, j] = measure_nonnormality_transpose(A_np) + + if self.compute_residuals: + # try: + rc = ResidualComputer(model, self.test_data, self.test_control) + self._residuals[i, j] = rc.get_average_residual() + # except Exception as e: + # warnings.warn(f"Residual computation failed: {e}") + # self._residuals[i, j] = np.nan + # except Exception as e: + # warnings.warn(f"Failed for {self.param1_name}={p1}, {self.param2_name}={p2}: {e}") + # continue + + self._swept = True + return self + + def _to_numpy(self, x) -> np.ndarray: + if hasattr(x, 'cpu'): + return x.cpu().detach().numpy() + if isinstance(x, list): + return np.concatenate([self._to_numpy(xi) for xi in x], axis=0) + return np.array(x) + + def _align_predictions(self, pred: np.ndarray, test: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + if pred.ndim == 3 and test.ndim == 3: + min_t = min(pred.shape[1], test.shape[1]) + return pred[:, :min_t], test[:, :min_t] + elif pred.ndim == 2 and test.ndim == 2: + min_t = min(pred.shape[0], test.shape[0]) + return pred[:min_t], test[:min_t] + return pred, test + + @property + def aics(self) -> np.ndarray: + self._check_swept() + return self._aics + + @property + def mases(self) -> np.ndarray: + self._check_swept() + return self._mases + + @property + def mses(self) -> np.ndarray: + self._check_swept() + return self._mses + + @property + def nnormals(self) -> np.ndarray: + self._check_swept() + return self._nnormals + + @property + def residuals(self) -> Optional[np.ndarray]: + self._check_swept() + return self._residuals + + @property + def fitted_models(self) -> List[List]: + self._check_swept() + return self._fitted_models + + def _check_swept(self): + if not self._swept: + raise RuntimeError("Must call sweep() before accessing results.") + + def get_results(self) -> Dict[str, Any]: + self._check_swept() + return { + "param1_name": self.param1_name, + "param1_values": self.param1_values, + "param2_name": self.param2_name, + "param2_values": self.param2_values, + "aics": self._aics, + "mases": self._mases, + "mses": self._mses, + "nnormals": self._nnormals, + "residuals": self._residuals, + "train_frac": self.train_frac, + "reseed": self.reseed, + } + + def plot( + self, + x_axis_param: str = None, + legend_param: str = None, + metrics: List[str] = None, + figsize: Tuple[float, float] = None, + cmap: str = "viridis", + save_path: str = None, + mase_scale: str = "log", + title: str = None, + ): + """Plot sweep results.""" + self._check_swept() + + if x_axis_param is None: + x_axis_param = self.param2_name + if legend_param is None: + legend_param = self.param1_name + + if x_axis_param == self.param2_name: + x_values = self.param2_values + legend_values = self.param1_values + transpose = False + else: + x_values = self.param1_values + legend_values = self.param2_values + transpose = True + + if metrics is None: + metrics = ["AIC", "MASE", "nnormal"] + if self._residuals is not None: + metrics.append("residual") + + metric_data = { + "AIC": self._aics, "MASE": self._mases, "MSE": self._mses, + "nnormal": self._nnormals, "residual": self._residuals, + } + metric_labels = { + "AIC": "AIC", "MASE": "MASE", "MSE": "MSE", + "nnormal": "Non-normality", "residual": "Avg. Residual", + } + + metrics = [m for m in metrics if metric_data.get(m) is not None] + n_metrics = len(metrics) + + if figsize is None: + figsize = (4 * n_metrics, 4) + + fig, axes = subplots(1, n_metrics, figsize=figsize) + if n_metrics == 1: + axes = [axes] + + cmap_obj = cm.get_cmap(cmap) + n_legend = len(legend_values) + + for ax_idx, metric in enumerate(metrics): + ax = axes[ax_idx] + data = metric_data[metric] + if transpose: + data = data.T + + for leg_idx, leg_val in enumerate(legend_values): + color = cmap_obj(leg_idx / (n_legend + 2)) + y_data = data[leg_idx, :] + ax.plot(x_values, y_data, label=f"{leg_val}", color=color, marker='o', markersize=3) + + if metric == "MASE": + ax.axhline(1, color="black", linestyle="--", linewidth=0.7) + if metric in ["MASE", "MSE"]: + ax.set_yscale(mase_scale) + + ax.set_xlabel(x_axis_param) + ax.set_ylabel(metric_labels[metric]) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + + axes[-1].legend(title=legend_param, loc="upper right", bbox_to_anchor=(1.4, 1), fontsize=8) + + if title: + fig.suptitle(title, y=1.02) + tight_layout() + if save_path: + savefig(save_path, bbox_inches='tight') + return fig, axes - if hasattr(pred,"cpu"): - pred = pred.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 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: - mase = stats["MSE"] - nnormal = measure_nonnormality_transpose( - dmd.A_v.cpu().detach().numpy() if hasattr(dmd.A_v, "cpu") else dmd.A_v +class DefaultSweeper(BaseSweeper): + """Sweeper for the local DSA DMD model classes (DMD, DMDc, SubspaceDMDc). + + This sweeper performs parameter sweeps over the local DMD implementations, + typically sweeping over `n_delays` and `rank` parameters. It supports both + autonomous systems (DMD) and controlled systems (DMDc, SubspaceDMDc). + + Parameters + ---------- + data : np.ndarray + Input data for the sweep. See `BaseSweeper` for details. + param1_name : str, optional + Name of the first parameter to sweep (default: "n_delays"). + param1_values : list or np.ndarray, optional + Values to sweep for the first parameter. + param2_name : str, optional + Name of the second parameter to sweep (default: "rank"). + param2_values : list or np.ndarray, optional + Values to sweep for the second parameter. + model_class : str, optional + Model class to use: "DMD", "DMDc", or "SubspaceDMDc" (default: "DMD"). + control_data : np.ndarray, optional + Control/actuation data. Required for "DMDc" and "SubspaceDMDc". + **kwargs + Additional arguments passed to `BaseSweeper` (train_frac, reseed, + compute_residuals) and to the model constructor. + + Examples + -------- + >>> sweeper = DefaultSweeper( + ... data=X, + ... param1_values=np.arange(1, 5), + ... param2_values=np.arange(1, 15), + ... model_class="DMD" + ... ) + >>> sweeper.sweep() + >>> print(sweeper.mases) + + >>> # With control input + >>> sweeper = DefaultSweeper( + ... data=X, + ... control_data=U, + ... param1_values=np.arange(1, 5), + ... param2_values=np.arange(1, 15), + ... model_class="DMDc" + ... ) + + See Also + -------- + BaseSweeper : Base class with full parameter documentation. + PyKoopmanSweeper : Sweeper for PyKoopman models. + """ + + # Model class names that support control input + CONTROL_MODEL_NAMES = ('DMDc', 'SubspaceDMDc') + + def __init__( + self, + data: np.ndarray, + param1_name: str = "n_delays", + param1_values: Union[List, np.ndarray] = None, + param2_name: str = "rank", + param2_values: Union[List, np.ndarray] = None, + model_class: str = "DMD", + control_data: np.ndarray = None, + **kwargs + ): + super().__init__(data=data, param1_name=param1_name, param1_values=param1_values, + param2_name=param2_name, param2_values=param2_values, + control_data=control_data, **kwargs) + self.model_class_name = model_class + + # Validate control data + if model_class in self.CONTROL_MODEL_NAMES and control_data is None: + raise ValueError(f"control_data required for {model_class}") + if control_data is not None and model_class not in self.CONTROL_MODEL_NAMES: + warnings.warn( + f"control_data was provided, but model class '{model_class}' " + f"may not support control input. Control data will be ignored.", + UserWarning ) - if return_transient_growth: - 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) - aics.append(aic) - mases.append(mase) - nnormals.append(nnormal) - rresiduals.append(np.mean(residuals)) - l2norms.append(l2norm) - all_aics.append(aics) - all_mases.append(mases) - all_nnormals.append(nnormals) - all_residuals.append(rresiduals) - all_l2norm.append(l2norms) - all_aics = np.array(all_aics) - all_mases = np.array(all_mases) - all_nnormals = np.array(all_nnormals) - all_residuals = np.array(all_residuals) - all_l2norm = np.array(all_l2norm) - - return_tuples = [all_aics, all_mases, all_nnormals] - if return_residuals: - return_tuples.append(all_residuals) - if return_transient_growth: - return_tuples.append(all_l2norm) - return tuple(return_tuples) - - -def plot_sweep_results( - aics, - mases, - nnormals=None, - residuals=None, - l2norm=None, - n_delays=None, - ranks=None, - name=None, - save_path=None, - figsize=(10,4), - return_mse=False, - cmap="gist_gray", - error_space='X', -): - to_plot = [aics, mases] - if nnormals is not None: - to_plot.append(nnormals) - if residuals is not None: - to_plot.append(residuals) - 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 - 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[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]}") - if residuals is not None: - 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].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") - 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) - for k in range(len(to_plot)): - ax[k].set_xlabel("Rank") - ax[k].spines["top"].set_visible(False) - ax[k].spines["right"].set_visible(False) - plt.suptitle(f"{name if name else ''}_tuning_{error_space}") - plt.tight_layout() - if save_path is not None: - plt.savefig(f"{save_path}.pdf") - # plt.close() - 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"): - pred = pred.cpu() - if hasattr(H_test_pred,"cpu"): - H_test_pred = H_test_pred.cpu() - if hasattr(H_test_true,"cpu"): - H_test_true = H_test_true.cpu() - if hasattr(V_test_pred,"cpu"): - V_test_pred = V_test_pred.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) - 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 _is_control_model_class(self, model_class) -> bool: + """Check if a model class supports control input.""" + if isinstance(model_class, str): + return model_class in self.CONTROL_MODEL_NAMES + return model_class.__name__ in self.CONTROL_MODEL_NAMES + + def _is_valid_param_combo(self, p1_val, p2_val) -> bool: + n_delays = p1_val if self.param1_name == "n_delays" else (p2_val if self.param2_name == "n_delays" else None) + rank = p1_val if self.param1_name == "rank" else (p2_val if self.param2_name == "rank" else None) + if n_delays is None or rank is None: + return True + return rank <= n_delays * self.dim + + def make_model(self, p1_val, p2_val): + kwargs = {self.param1_name: p1_val, self.param2_name: p2_val, **self.model_kwargs} + if self.model_class_name == 'DMD': + model = DMD(data=self.train_data, **kwargs) + elif self.model_class_name == 'DMDc': + model = DMDc(self.train_data, self.train_control, **kwargs) + elif self.model_class_name == 'SubspaceDMDc': + model = SubspaceDMDc(self.train_data, self.train_control, **kwargs) + else: + raise ValueError(f"Unknown model class: {self.model_class_name}") + model.fit() + return model + + def get_state_matrix(self, model) -> np.ndarray: + A = model.A_v + return A.cpu().detach().numpy() if hasattr(A, 'cpu') else A + + def get_rank(self, model) -> int: + return getattr(model, 'rank', getattr(model, 'rank_output', 1)) + + def predict(self, model, test_data: np.ndarray, n_steps: int) -> np.ndarray: + if self.model_class_name == 'DMD': + return model.predict(test_data, reseed=n_steps) + return model.predict(test_data, self.test_control, reseed=n_steps) -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. +class PyKoopmanSweeper(BaseSweeper): + """Sweeper for PyKoopman models with dotted parameter names. + + This sweeper performs parameter sweeps over PyKoopman Koopman models, + allowing sweeps over both observable parameters (e.g., time delays) and + regressor parameters (e.g., SVD rank). Parameters are specified using + dotted notation: "component.parameter" where component is "observables" + (or "observable", "obs"), "regressor" (or "reg"), or "extra_obs.{index}" + for extra observables. + Parameters ---------- data : np.ndarray - Input data (trials, time, features). - n_delays : iterable - List or array of delays to sweep. - ranks : iterable - List or array of ranks to sweep. - train_frac : float - Fraction of data to use for training. If greater than or equal to 1, tests on the training set - reseed : (int, list) - Reseeds for DMD prediction. - dmd_kwargs : dict - Additional keyword arguments for DMD. - - Returns - ------- + Input data for the sweep. See `BaseSweeper` for details. + param1_name : str, optional + Name of the first parameter in "component.param" format + (default: "observables.n_delays"). Supported components: + - "observables", "observable", "obs": base observable parameters + - "regressor", "reg": regressor parameters + - "extra_obs.{index}": extra observable parameters (e.g., "extra_obs.0.D") + param1_values : list or np.ndarray, optional + Values to sweep for the first parameter. + param2_name : str, optional + Name of the second parameter in "component.param" format + (default: "regressor.svd_rank"). + param2_values : list or np.ndarray, optional + Values to sweep for the second parameter. + base_observable_class : class, optional + Observable class to use (default: TimeDelay). + base_observable_kwargs : dict, optional + Additional kwargs for the observable constructor. + base_regressor_class : class, optional + Regressor class to use. If None and control_data is provided, + defaults to pk.regression.DMDc. Otherwise uses PyDMDRegressor. + base_regressor_kwargs : dict, optional + Additional kwargs for the regressor constructor. + extra_observables : list, optional + Additional observable objects or classes to combine with the base observable. + Can be a mix of: + - Observable instances (fixed, not swept) + - Observable classes (can be swept via "extra_obs.{index}.param" syntax) + extra_observable_kwargs : list of dict, optional + Default kwargs for each extra observable class. Only used when the + corresponding entry in extra_observables is a class (not an instance). + Length must match extra_observables. + control_data : np.ndarray, optional + Control/actuation data for controlled systems. + **kwargs + Additional arguments passed to `BaseSweeper` (train_frac, reseed, + compute_residuals). + + Examples + -------- + >>> # Sweep over time delays and SVD rank + >>> sweeper = PyKoopmanSweeper( + ... data=X, + ... param1_name="observable.n_delays", + ... param1_values=[1, 2, 3, 4], + ... param2_name="regressor.svd_rank", + ... param2_values=[5, 10, 15, 20], + ... ) + >>> sweeper.sweep() + >>> sweeper.plot() - Arrays of results for each (delay, rank) pair. + >>> # Sweep TimeDelay n_delays and RandomFourierFeatures D + >>> sweeper = PyKoopmanSweeper( + ... data=X, + ... param1_name="obs.n_delays", + ... param1_values=[3, 5, 7], + ... param2_name="extra_obs.0.D", + ... param2_values=[50, 100, 200], + ... base_observable_class=pk.observables.TimeDelay, + ... extra_observables=[pk.observables.RandomFourierFeatures], # class, not instance + ... extra_observable_kwargs=[{"include_state": True}], # default kwargs + ... ) + + >>> # With control input + >>> import pykoopman as pk + >>> sweeper = PyKoopmanSweeper( + ... data=X, + ... control_data=U, + ... param1_name="observable.n_delays", + ... param1_values=[1, 2, 3], + ... param2_name="regressor.svd_rank", + ... param2_values=[5, 10], + ... base_regressor_class=pk.regression.DMDc, + ... ) + + See Also + -------- + BaseSweeper : Base class with full parameter documentation. + DefaultSweeper : Sweeper for local DMD models. + + Notes + ----- + The component names in param1_name/param2_name are flexible: + - For observables: "observable", "observables", or "obs" + - For regressor: "regressor" or "reg" + - For extra observables: "extra_obs.{index}" (e.g., "extra_obs.0", "extra_obs.1") """ - train_data, test_data, dim = split_train_test(data,train_frac) - - if not isinstance(reseeds,list) and reseeds in set([1,'none',None,'',0]): - reseeds = [1] - 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))) - elif d == 2: - 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() - - 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.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"] + + def __init__( + self, + data: np.ndarray, + param1_name: str = "observables.n_delays", + param1_values: Union[List, np.ndarray] = None, + param2_name: str = "regressor.svd_rank", + param2_values: Union[List, np.ndarray] = None, + base_observable_class=None, + base_observable_kwargs: dict = None, + base_regressor_class=None, + base_regressor_kwargs: dict = None, + extra_observables: Union[List,Any] = None, + extra_observable_kwargs: List[dict] = None, + control_data: np.ndarray = None, + **kwargs + ): + super().__init__(data=data, param1_name=param1_name, param1_values=param1_values, + param2_name=param2_name, param2_values=param2_values, + control_data=control_data, **kwargs) + + self.base_observable_class = base_observable_class or TimeDelay + self.base_observable_kwargs = base_observable_kwargs or {} + self.base_regressor_class = base_regressor_class + self.base_regressor_kwargs = base_regressor_kwargs or {} + self.extra_observables = extra_observables or [] + if not isinstance(self.extra_observables, list): + self.extra_observables = [self.extra_observables] + self.extra_observable_kwargs = extra_observable_kwargs or [{} for _ in self.extra_observables] + + # Validate extra_observable_kwargs length + if len(self.extra_observable_kwargs) != len(self.extra_observables): + raise ValueError( + f"extra_observable_kwargs length ({len(self.extra_observable_kwargs)}) must match " + f"extra_observables length ({len(self.extra_observables)})" + ) + + # Warn if the regressor class doesn't support control input + if control_data is not None and base_regressor_class is not None: + if not self._is_control_model_class(base_regressor_class): + warnings.warn( + f"control_data was provided, but base_regressor_class ({base_regressor_class.__name__}) " + f"may not support control input. Consider using a DMDc-type regressor (e.g., pk.regression.DMDc, " + f"pk.regression.EDMDc, or pydmd.DMDc). Control data may be ignored.", + UserWarning + ) + + # Parse parameter names into components + self._param1_parsed = self._parse_param_name(param1_name) + self._param2_parsed = self._parse_param_name(param2_name) + # Keep legacy attributes for backward compatibility + self._param1_component, self._param1_attr = param1_name.split('.', 1) + self._param2_component, self._param2_attr = param2_name.split('.', 1) + # Handle extra_obs.N.param format for legacy attrs + if self._param1_parsed['type'] == 'extra_obs': + self._param1_attr = self._param1_parsed['attr'] + if self._param2_parsed['type'] == 'extra_obs': + self._param2_attr = self._param2_parsed['attr'] + + def _is_control_model_class(self, model_class) -> bool: + """Check if a model/regressor class supports control input. + + Args: + model_class: The model class to check. - 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} + Returns: + True if the model class supports control input, False otherwise. + """ + # Simple check: class name ends with 'DMDc' (covers DMDc, EDMDc, etc.) + return model_class.__name__.endswith('DMDc') + + @staticmethod + def _is_observable_component(component: str) -> bool: + """Check if a component name refers to observables.""" + return component in ("observable", "observables", "obs") + + @staticmethod + def _is_regressor_component(component: str) -> bool: + """Check if a component name refers to regressor.""" + return component in ("regressor", "reg") + + @staticmethod + def _is_extra_obs_component(component: str) -> bool: + """Check if a component name refers to extra observables.""" + return component.startswith("extra_obs") + + def _parse_param_name(self, param_name: str) -> dict: + """Parse a parameter name into its components. + + Handles formats: + - "obs.n_delays" -> {'type': 'observable', 'attr': 'n_delays', 'index': None} + - "reg.svd_rank" -> {'type': 'regressor', 'attr': 'svd_rank', 'index': None} + - "extra_obs.0.D" -> {'type': 'extra_obs', 'attr': 'D', 'index': 0} + + Args: + param_name: Parameter name in dotted notation. + + Returns: + Dict with 'type', 'attr', and 'index' keys. + """ + parts = param_name.split('.') + + if len(parts) < 2: + raise ValueError(f"Invalid parameter name: {param_name}. Expected 'component.param' format.") + + component = parts[0] + + if self._is_observable_component(component): + return {'type': 'observable', 'attr': parts[1], 'index': None} + elif self._is_regressor_component(component): + return {'type': 'regressor', 'attr': parts[1], 'index': None} + elif self._is_extra_obs_component(component): + # Format: "extra_obs.{index}.{attr}" or "extra_obs{index}.{attr}" + if len(parts) == 3: + # "extra_obs.0.D" + try: + index = int(parts[1]) + except ValueError: + raise ValueError(f"Invalid extra_obs index in: {param_name}. Expected integer.") + return {'type': 'extra_obs', 'attr': parts[2], 'index': index} + elif len(parts) == 2: + # Try "extra_obs0.D" format + import re + match = re.match(r'extra_obs(\d+)', component) + if match: + return {'type': 'extra_obs', 'attr': parts[1], 'index': int(match.group(1))} + raise ValueError(f"Invalid extra_obs format: {param_name}. Use 'extra_obs.N.param' or 'extra_obsN.param'.") + else: + raise ValueError(f"Invalid extra_obs format: {param_name}. Use 'extra_obs.N.param'.") + else: + raise ValueError(f"Unknown component: {component}. Expected 'obs', 'reg', or 'extra_obs'.") + + @staticmethod + def _cast_to_int(val): + return int(val) if isinstance(val, np.integer) else val -def plot_sweep_results_all_error_types( - return_dict, - name=None, - save_path=None, - figsize=(2, 4), - xscale='log', - aic_scale='symlog', - plot_herror=False, - new_plot_reseeds=False, - cmap="gist_gray", - metrics_order=['AIC','MASE','MSE'] -): - """ - Plot all error types from sweep_ranks_delays_all_error_types as a 3 x (3*len(reseeds)) grid, - or, if separate_by_space is True, make 3 separate plots (one for each of X, H, V), with columns as metrics and rows as reseeds. + def _build_observable(self, p1_val, p2_val): + """Build the composite observable with swept parameters. + + Args: + p1_val: Value for param1. + p2_val: Value for param2. + + Returns: + Combined observable (base + extras). + """ + # Build base observable + kwargs = dict(self.base_observable_kwargs) + if self._param1_parsed['type'] == 'observable': + kwargs[self._param1_parsed['attr']] = self._cast_to_int(p1_val) + if self._param2_parsed['type'] == 'observable': + kwargs[self._param2_parsed['attr']] = self._cast_to_int(p2_val) + obs = self.base_observable_class(**kwargs) - Parameters - ---------- - return_dict : dict - Output from sweep_ranks_delays_all_error_types. - name : str or None - Title for the plot. - save_path : str or None - If provided, save the figure to this path (as .pdf). - figsize : tuple - Figure size. - column_order : {'by_reseed', 'by_metric'} - If 'by_reseed', columns are [aics[0], mases[0], mses[0], aics[1], mases[1], mses[1], ...] (grouped by reseed). - 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 - """ - 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): - return_dict_new[k] = [] - return [] - elif k in ['n_delays','ranks']: - return_dict_new[k] = v - return_dict_plot[k] = v + # Build and add extra observables + for i, extra in enumerate(self.extra_observables): + extra_kwargs = dict(self.extra_observable_kwargs[i]) + + # Check if param1 targets this extra observable + if self._param1_parsed['type'] == 'extra_obs' and self._param1_parsed['index'] == i: + extra_kwargs[self._param1_parsed['attr']] = p1_val + # Check if param2 targets this extra observable + if self._param2_parsed['type'] == 'extra_obs' and self._param2_parsed['index'] == i: + extra_kwargs[self._param2_parsed['attr']] = p2_val + + # Build extra observable: if it's a class, instantiate it; if instance, use as-is + if isinstance(extra, type): + # It's a class, instantiate with kwargs + extra_obs = extra(**extra_kwargs) 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) - 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'] + # It's already an instance + if extra_kwargs: + warnings.warn( + f"extra_observables[{i}] is an instance, not a class. " + f"Cannot apply swept parameters. Pass a class instead to sweep its parameters.", + UserWarning + ) + extra_obs = extra + + obs = obs + extra_obs + return obs + + def _build_regressor(self, p1_val, p2_val): + kwargs = dict(self.base_regressor_kwargs) + if self._is_regressor_component(self._param1_component): + kwargs[self._param1_attr] = self._cast_to_int(p1_val) + if self._is_regressor_component(self._param2_component): + kwargs[self._param2_attr] = self._cast_to_int(p2_val) + if self.base_regressor_class: + # Return the regressor instance directly - pk.Koopman handles pydmd regressors + return self.base_regressor_class(**kwargs) + # Default regressor: DMDc if control data is provided, else pydmd.DMD + if self.control_data is not None: + return pk.regression.DMDc(**kwargs) + from pydmd import DMD as PyDMD_DMD + svd_rank = int(kwargs.pop('svd_rank', -1)) + return PyDMD_DMD(svd_rank=svd_rank, **kwargs) + + def make_model(self, p1_val, p2_val): + obs = self._build_observable(p1_val, p2_val) + reg = self._build_regressor(p1_val, p2_val) + model = pk.Koopman(observables=obs, regressor=reg) + train = self.train_data + if isinstance(train, torch.Tensor): + train = train.cpu().numpy() + if train.ndim == 3: + train = train.reshape(-1, train.shape[-1]) + + # Prepare control data for fitting if provided + train_u = None + if self.train_control is not None: + train_u = self.train_control + if isinstance(train_u, torch.Tensor): + train_u = train_u.cpu().numpy() + if train_u.ndim == 3: + train_u = train_u.reshape(-1, train_u.shape[-1]) + + model.fit(train, u=train_u) + return model + + def get_state_matrix(self, model) -> np.ndarray: + """Get the reduced-order state transition matrix. + + Returns the state matrix A from the regressor, which should be + of shape (svd_rank, svd_rank) when SVD truncation is applied. + """ + A = model.A + if hasattr(A, 'cpu'): + A = A.cpu().detach().numpy() + return np.asarray(A) + + def get_rank(self, model) -> int: + reg = model._regressor() + if hasattr(reg, 'svd_rank') and reg.svd_rank > 0: + return reg.svd_rank + return model.A.shape[0] + + def predict(self, model, test_data: np.ndarray, reseed: int) -> np.ndarray: + """Generate one-step predictions using model.predict. + + Uses PyKoopman's predict method which does one-step-ahead prediction. + The predictions are offset by n_consumed samples due to time delays. + + Args: + model: Fitted PyKoopman model. + test_data: Test data to predict on. + reseed: Not used currently (kept for API compatibility). + + Returns: + Predictions aligned with test_data. + """ + test_np = test_data.cpu().numpy() if isinstance(test_data, torch.Tensor) else test_data + + # Prepare test control data if available + test_u = None + if self.test_control is not None: + test_u = self.test_control + if isinstance(test_u, torch.Tensor): + test_u = test_u.cpu().numpy() + + if test_np.ndim == 3: + if test_u is not None and test_u.ndim == 3: + return np.stack([self._predict_single(model, t, u=test_u[i]) + for i, t in enumerate(test_np)]) + return np.stack([self._predict_single(model, t, u=test_u) for t in test_np]) + return self._predict_single(model, test_np, u=test_u) + + def _predict_single(self, model, data: np.ndarray, u: np.ndarray = None) -> np.ndarray: + """One-step predictions for a single trajectory. + + Args: + model: Fitted PyKoopman model. + data: 2D array of shape (time, features). + u: Optional control data. + + Returns: + Predictions array of same shape as data. + """ + n_consumed = getattr(model.observables, 'n_consumed_samples', 0) + n_samples = data.shape[0] + + # Need at least n_consumed + 1 samples to predict + if n_samples <= n_consumed + 1: + return data.copy() + + # Use model.predict for one-step-ahead predictions + # Input: data[:-1], Output: predictions for data[1:] + # But with time delays, we lose n_consumed samples + try: + # Predict uses all but the last sample to predict the next + x_input = data[:-1] # Shape: (n_samples - 1, n_features) + u_input = u[:-1] if u is not None else None + + pred = model.predict(x_input, u=u_input) + + # pred has shape (n_samples - 1 - n_consumed, n_features) + # We need to align this with the original data + predictions = np.zeros_like(data) + predictions[:n_consumed + 1] = data[:n_consumed + 1] + predictions[n_consumed + 1:] = pred + + return predictions + except Exception as e: + warnings.warn(f"Prediction failed: {e}") + return data.copy() - n_reseeds = len(reseeds) - 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 []) - ] - data_arrays = [data_arrays[metrics.index(metric)] for metric in metrics_order] - metrics = metrics_order +def sweep_local_dmd(data, n_delays_values, rank_values, **kwargs) -> DefaultSweeper: + """Convenience function to create and run a DefaultSweeper.""" + sweeper = DefaultSweeper(data=data, param1_values=n_delays_values, param2_values=rank_values, **kwargs) + sweeper.sweep() + return sweeper - 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' - ) - if len(reseeds) == 1: - if len(metrics) == 1: - axes = [axes] - else: - 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) - for metric_idx, metric in enumerate(metrics): - for reseed_idx, reseed in enumerate(reseeds): - arr = data_arrays[metric_idx][space_idx] - 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))) - # 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)) - if metric == "MASE": - ax.axhline(1, color="black", linestyle="--", linewidth=0.7) - if metric in {"MASE", "MSE"}: - ax.set_yscale("log") - if aic_scale in {'symlog','log','linear'} and metric == "AIC": - ax.set_yscale(aic_scale) - if xscale == 'log': - ax.set_xscale("log") - if reseed_idx == 0: - ax.set_ylabel(f"{space} {metric}", fontsize=10) - else: - ax.set_ylabel("") - if metric_idx == 0: - ax.set_title(f"reseed {reseed}") - else: - ax.set_title("") - 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) - # 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] - for reseed_idx in range(n_reseeds): - ax = axes[metric_idx][reseed_idx] - # Remove all yticks and labels before setting new ones - ax.set_yticks([]) - 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) +def sweep_pykoopman(data, param1_name, param1_values, param2_name, param2_values, **kwargs) -> PyKoopmanSweeper: + """Convenience function to create and run a PyKoopmanSweeper.""" + sweeper = PyKoopmanSweeper(data=data, param1_name=param1_name, param1_values=param1_values, + param2_name=param2_name, param2_values=param2_values, **kwargs) + sweeper.sweep() + return sweeper - 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.close() - figs_axes.append((fig, axes)) - return figs_axes + fig_axes \ No newline at end of file +def sweep_ranks_delays(data, n_delays, ranks, control_data=None, train_frac=0.8, reseed=5, + return_residuals=True, model_class='DMD', **model_kwargs): + """Backward-compatible wrapper around DefaultDMDSweeper.""" + sweeper = DefaultSweeper(data=data, param1_values=n_delays, param2_values=ranks, + model_class=model_class, control_data=control_data, + train_frac=train_frac, reseed=reseed, + compute_residuals=return_residuals, **model_kwargs) + sweeper.sweep() + result = (sweeper.aics, sweeper.mases, sweeper.nnormals) + if return_residuals: + result += (sweeper.residuals if sweeper.residuals is not None else np.full_like(sweeper.aics, np.nan),) + return result diff --git a/README.md b/README.md index 58538b5..2d14c7b 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,36 @@ -# 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 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 + +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: ``` +@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 +39,7 @@ If you use this code, please cite: archivePrefix={arXiv}, primaryClass={q-bio.NC} } + ``` ## Install the repo using `pip`: @@ -30,14 +53,33 @@ cd DSA/ pip install -e . ``` +You can also create an envirnoment with `uv` for fast, reliable dependency managemen +``` +# 1. Create virtual environment +uv venv + +# 2. Install DSA with all dependencies +uv pip install -e ".[dev]" --python .venv/bin/python + +# 3. Install Jupyter support +uv pip install ipykernel jupyter --python .venv/bin/python + +# 4. Register kernel for VS Code/Jupyter +.venv/bin/python -m ipykernel install --user --name=dsa-uv --display-name="DSA (uv)" +``` + ## 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 +89,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)) +``` -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. +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 + +``` +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 +176,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/all_dsa_types.ipynb b/examples/all_dsa_types.ipynb new file mode 100644 index 0000000..692b603 --- /dev/null +++ b/examples/all_dsa_types.ipynb @@ -0,0 +1,560 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "773aa0fd", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "\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" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d452743b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(18, 9)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "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", + "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", + "\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "88cad354", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 10)\n", + "(10, 2)\n" + ] + } + ], + "source": [ + "\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", + "# 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", + "# 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", + "# # 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", + "# passing list of 3D arrayss\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" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b7b308b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 10)\n", + "(500, 9)\n" + ] + } + ], + "source": [ + "# 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,autonomous=False):\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.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", + "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", + "\n", + "\n", + "\n", + "print(X.shape)\n", + "print(Y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8c4c9ea2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.9 +0.j 0.80763046+0.32343476j 0.80763046-0.32343476j\n", + " 0.06137112+0.71249655j 0.06137112-0.71249655j -0.49680702+0.j\n", + " -0.25875772+0.32447627j -0.25875772-0.32447627j 0.39053652+0.j\n", + " 0.180503 +0.j ]\n", + "(500, 9) (500, 2)\n", + "[-0.9 +0.j 0.80763046+0.32343476j 0.80763046-0.32343476j\n", + " 0.06137112+0.71249654j 0.06137112-0.71249654j -0.49680702+0.j\n", + " -0.25875772+0.32447626j -0.25875772-0.32447626j 0.180503 +0.j\n", + " 0.39053651+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": 6, + "id": "e59db62a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DMD prediction MASE: 2.4295793244821465e-07\n", + "DMDC prediction MASE: 0.5514180132934315\n", + "DMDC prediction MASE: 0.39012201230797877\n" + ] + } + ], + "source": [ + "from DSA.stats import mase\n", + "X_auto, Y_auto = simulate_system(A, np.zeros_like(B), C, U.T, 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", + "dmdc = DMDc(X, U, 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, 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)}')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "721bc598", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 3/3 [00:00<00:00, 586.86it/s]\n", + "Caching compare objects X: 100%|██████████| 3/3 [00:00<00:00, 40590.04it/s]\n", + "Computing DMD similarities: 100%|██████████| 3/3 [00:00<00:00, 1557.68it/s]\n", + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/DSA/dsa.py:412: 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, 662.82it/s]\n", + "Caching compare objects X: 100%|██████████| 3/3 [00:00<00:00, 88612.06it/s]\n", + "Computing DMD similarities: 100%|██████████| 3/3 [00:07<00:00, 2.36s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "(3, 3)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "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", + "#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" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2ea88dc2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/DSA/dsa.py:622: 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 GeneralizedDSA(X=[X,Y], X_control=[X_control,Y_control], Y=None, Y_control=None.)\n", + " warnings.warn(\n", + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/DSA/dsa.py:412: 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", + "Fitting DMDs: 100%|██████████| 9/9 [00:00<00:00, 1970.70it/s]\n", + "Fitting DMDs: 100%|██████████| 9/9 [00:00<00:00, 1698.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 9/9 [00:00<00:00, 9346.06it/s]\n", + "Caching compare objects Y: 100%|██████████| 9/9 [00:00<00:00, 11335.96it/s]\n", + "Computing DMD similarities: 100%|██████████| 81/81 [00:00<00:00, 1378.46it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "(9, 9)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 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", + "# 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,simdist_config={'score_method':'wasserstein'})\n", + "sim = dsa.fit_score()\n", + "sim.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "997a05d3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/DSA/dsa.py:412: 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", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 812.38it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 646.57it/s]\n", + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 26886.56it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 5309.25it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:01<00:00, 1.57s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 9, + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6a5de212", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 3/3 [00:00<00:00, 171.00it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 3/3 [00:00<00:00, 2990.95it/s]\n", + "Computing DMD similarities: 100%|██████████| 3/3 [00:00<00:00, 928.49it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "(3, 3)" + ] + }, + "execution_count": 10, + "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": { + "kernelspec": { + "display_name": "DSA (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/dmd_lorenz.ipynb b/examples/dmd_lorenz.ipynb index 4a616f4..6e3c630 100644 --- a/examples/dmd_lorenz.ipynb +++ b/examples/dmd_lorenz.ipynb @@ -1,53 +1,12 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "a61e6f81-6e9e-49c0-babf-a16219290dbc", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "167784bf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: tqdm in /Users/mitchellostrow/opt/anaconda3/envs/dsapublic/lib/python3.11/site-packages (4.65.0)\n", - "Requirement already satisfied: scipy in /Users/mitchellostrow/opt/anaconda3/envs/dsapublic/lib/python3.11/site-packages (1.11.1)\n", - "Requirement already satisfied: numpy<1.28.0,>=1.21.6 in /Users/mitchellostrow/opt/anaconda3/envs/dsapublic/lib/python3.11/site-packages (from scipy) (1.25.1)\n" - ] - } - ], - "source": [ - "! pip install tqdm\n", - "! pip install scipy" - ] - }, { "cell_type": "code", "execution_count": 3, "id": "d29cfc8e-40bf-4a51-8420-345b8e54bb06", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/mitchellostrow/opt/anaconda3/envs/dsapublic/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ - "%autoreload 2\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from scipy.integrate import solve_ivp\n", @@ -128,11 +87,18 @@ "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:10<00:00, 10.17s/it]\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "911b78bf93f44442b6bd8662cec429b6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00" ] @@ -271,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "44c64307-90c4-426b-bba0-4929375f36db", "metadata": {}, "outputs": [ @@ -279,22 +245,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.12 ms, sys: 3.67 ms, total: 6.79 ms\n", - "Wall time: 16.1 ms\n" + "CPU times: user 9.73 ms, sys: 8.38 ms, total: 18.1 ms\n", + "Wall time: 3.1 ms\n" ] }, { "data": { "text/plain": [ - "{'MAE': 2.5213026358451924,\n", - " 'MASE': 0.5486326863713192,\n", - " 'MSE': 12.68645078434762,\n", - " 'R2': 0.8358856973464476,\n", - " 'Correl': 0.9128922820091248,\n", - " 'AIC': 8.923584201972321}" + "{'MAE': 2.5167064420307153,\n", + " 'MASE': 0.5478299945180521,\n", + " 'NMSE': 0.17307321464288092,\n", + " 'MSE': 12.60745008437796,\n", + " 'R2': 0.8366451689614438,\n", + " 'Correl': 0.9133078455924988,\n", + " 'AIC': 8.917337561150338,\n", + " 'logMSE': 2.534287915760268}" ] }, - "execution_count": 13, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -306,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "35d37dc0-efdd-49fb-a296-feb6c17c4aeb", "metadata": {}, "outputs": [], @@ -317,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "f7628177-2a3b-4c7a-a859-3cc203d3e367", "metadata": {}, "outputs": [], @@ -327,13 +295,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "29a2c838-9367-40e3-927c-b805c394a6db", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -355,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "a5a1bd0a-472b-429a-80e9-0998855b957e", "metadata": {}, "outputs": [ @@ -363,22 +331,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.77 ms, sys: 729 µs, total: 2.5 ms\n", + "CPU times: user 4.97 ms, sys: 1.15 ms, total: 6.12 ms\n", "Wall time: 1.68 ms\n" ] }, { "data": { "text/plain": [ - "{'MAE': 2.5992292470271003,\n", - " 'MASE': 0.5639169094725991,\n", - " 'MSE': 13.477207460761758,\n", - " 'R2': 0.8256031498871144,\n", - " 'Correl': 0.9070751070976257,\n", - " 'AIC': 10.70919812055686}" + "{'MAE': 2.5789991592384194,\n", + " 'MASE': 0.571164058723301,\n", + " 'NMSE': 0.1865428760401078,\n", + " 'MSE': 13.510877507404555,\n", + " 'R2': 0.8233529400789129,\n", + " 'Correl': 0.9058391451835632,\n", + " 'AIC': 10.711693300496558,\n", + " 'logMSE': 2.6034951022983597}" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -399,9 +369,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "DSA (uv)", "language": "python", - "name": "python3" + "name": "dsa-uv" }, "language_info": { "codemirror_mode": { @@ -413,7 +383,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.19" } }, "nbformat": 4, diff --git a/examples/dmdc_linear_system_test.ipynb b/examples/dmdc_linear_system_test.ipynb new file mode 100644 index 0000000..418ddc5 --- /dev/null +++ b/examples/dmdc_linear_system_test.ipynb @@ -0,0 +1,750 @@ +{ + "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": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ground truth A eigenvalues: [-0.47397087+0.82331745j -0.47397087-0.82331745j -0.45512345+0.j\n", + " -0.00880071+0.70984946j -0.00880071-0.70984946j 0.21876129+0.j\n", + " 0.20142906+0.39072123j 0.20142906-0.39072123j 0.01263768+0.35684693j\n", + " 0.01263768-0.35684693j]\n", + "Ground truth B singular values: [4.32455287 3.18211775 1.78226893]\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": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "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": 4, + "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": 5, + "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": 6, + "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, 10])\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": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAJOCAYAAADMCCWlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/tNJREFUeJzs3Qd4VNXWxvFFh9BL6L2j9CogVgL2yrVdr4oNsbdrF+y9X7mKfmLDHrF7UbCiFOmIghRBpIdeAoRAvufd8YyTySSZhEmm/X/PMwwzc+bktJnZZ5211y6VlZWVZQAAAAAAAACAqFA60gsAAAAAAAAAAPgbQVsAAAAAAAAAiCIEbQEAAAAAAAAgihC0BQAAAAAAAIAoQtAWAAAAAAAAAKIIQVsAAAAAAAAAiCIEbQEAAAAAAAAgihC0BQAAAAAAAIAoQtAWAAAAAAAAAKIIQVsAuZQqVcruuuuuuNwyy5cvd+v3yiuvWKx7/fXXrX379lauXDmrUaNGsf+9HTt2WN26de2NN96weBHtx8O3337rlk/30eCQQw6xm266KdKLAQCIU7RBEanjQX9Hfw+J3dYFog1BWyBBKCilH8S8blOnTo30IqIQFi5caBdccIG1atXKXnzxRXvhhRdCep8CbtrfZ555ZqG399NPP21Vq1a1s846K9drc+bMsXPPPdeaNGliFSpUsFq1atnAgQPt5Zdftn379hX6byXa57FixYrWtm1bu/LKK23dunUWrW6++WYbNWqUrV27NtKLAgCIEbRBI88LSJYuXdr+/PPPXK9v27bNKlWq5KZRWyRaTZ482a3Lli1bLJ4oYHnaaadZ/fr1rXz58i5J4sQTT7Rx48ZFetEARFjZSC8AgJJ1zz33WIsWLXI937p1a9//d+3aZWXL8vUQ7Y27/fv3u0Cq/77LT1ZWlr311lvWvHlz++STT2z79u0uCBuKvXv3ur913XXXWZkyZXK89n//93922WWXWb169exf//qXtWnTxs37q6++sosuusjWrFljt912W5HWM1E+j7t377YffvjBnnvuOfv8889t/vz5lpSUZNHm5JNPtmrVqtl///tft+wAAISKNmjk6cK62oKBvWaiNTgYeE6ioO3dd9/tEhdKopdZSRg5cqT7bKj9PGzYMGvWrJlt3LjRtQdPP/1018PtnHPOsXh12GGHuf2sYDWA3IjKAAnm2GOPtZ49e+Y7jbL+EN3Wr1/v7gvTYFWgd+XKlfb111/b4MGDXQP9/PPPD+m9n376qaWlpdkZZ5yR43llaCtg27dvX9e49A8CX3vttTZjxgwXgETBn8eLL77YateubU888YR99NFHdvbZZ0fdZlOGzpAhQ+y1115zJ010IwQAhIo2aOQdd9xxQYO2b775ph1//PH2/vvvWzSJ93OS1NRUF7BV20r7QCXPPP/+97/tiy++cIkT8UgJCwrUqm0Z7/sZOBCURwAQUv0oBfwUXNKPqrrkjx49Os/aT2PHjrUePXq4blbqJq/u9IFdsY444gjr2LGj/frrr3bkkUe6rMJGjRrZI4884ptG3cR1dV3BoUC//fab+9vPPvuse7xp0ya78cYbrVOnTlalShWXDaiTg7lz5xa4h7UsugXSVXxlpfpTdutTTz1lBx98sNsWyi7VVfHNmzfnmE7BSgVG69Sp47aDsikvvPBCC4WyGDV/ZUM0bNjQrrjiihzdwLRMuiovycnJIdf70pX6gw46yG1vlS4oTG3aDz/80P1d7Xt/XuBO8wqWtatjRtvRs3PnTrvhhht8ZRTatWtnjz32mMsC9ud1z3vvvffcMmsbKjD8888/u9d1/CnDWPtA+061aYMdXzNnzrR+/fr59sHzzz8fcvkJNaB1/OpvaD0+/vjjHEFzbXv9Hf9lX7JkiVWuXLlI5SfkqKOOcvfLli3Lc5pJkybZP/7xD2vatKnbhtqWyoBWloI/bXd9FlatWmWnnHKK+7+WWZ+TwJIVoR7XkpKSYn/88YcriQEAQDjRBj3wNmh+lLGp32+1czwqeaQL+sGyOTMyMmzEiBGuXV+9enXXxhkwYIB98803uaZVdqh6XKkNrqQCJQaoHR44dkBh2if+x4PuFcgUtem8ElNqA+Y3RkGwY0q9m3r16pXjvCYvoZzXLF682GXFqryB5tm4cWM33datWy0/d955p5vnmDFjcgRsPTqXOOGEE3K0P9WLTftef6dLly726quv5niPty3UvlZJq5YtW7rzrEGDBrnlVrv13nvvdcuodVIvKp1H+dOxp7/75ZdfWteuXd3fUns8MCM71PMvr27t22+/bXfccYc759MyqSxHsJq2oWzPzMxMtx7af2oPa5nVs2/Pnj1B10X7vHfv3m5+2iZKQABiAZm2QILRj92GDRtyPKcfSmX45WX27Nl2zDHHWIMGDVyQTg0qXRVWAyvQ/fff7xogyshU5qCyM//zn/+4ri+aj39mqBqZmq9qOGl6XW1WzUz98OsHXw2Sww8/3N59911fkNLzzjvvuG76Cl7J77//7gKLeqyGnAK+aoDp/QoMK/gZDmocq0E4dOhQu/rqq11wTYFjrduPP/7oGlxqUKlhpO1zyy23uHVWAyqUrmdqVGobK6g6fPhwF5xWl/np06f75q8GuxoaH3zwgXtNjaTOnTvnO181YJQ9oYCpKItT66CGuhpEBVF3tO7du+d4Lj093ZVA0L5VALEgaiSedNJJrqGvBqcagcogUANcDfcnn3wyV3BSgVIFreXBBx90jS5lhyiwffnll7tjSIF+BcR1wuFPrymjRMeW1lfHkbaprurnF0D/5ZdfrH///q5Bqf2nExS9VycW2oannnqqqzWmba/jTce3jgWdTOlERMFrLV9RLF261N3n93lUIFvbXuui6X766Se3DMqi1mv+9FlVg79Pnz6u8T5x4kR7/PHHXQNX7y/Mce3RiYvo+W7duhVpPQEAiYc26IEpzG91XtRmUwBMWZ1emSO1qdWWVKZtIAXVVAZL7ahLLrnElb966aWXXNtC7Q+15URtINVg1XNqX2igXPUayqtHV6jtE386X1i0aJHLFFabUYkRova2zjdCpQQAr52udreCfzrP0HlHUc5rFNjWuqitfdVVV7l2tdq16qWmpAsFu4NRYFLBc7VJQylXpovzShZQgoASG3S+o3af2p76O9dcc02O6ZVQoWXTMim4qvay1kMJAgqQ6pxL89L6KPCqwHHg8ikJQT3qtB81ToXavePHj3cX8Ity/qUgq9rh+nvaXsFKIoS6PbU/FLBWkoXOb6ZNm+bOFRYsWODOkfxpPTWdzj+0LlpXbTe1aXURBIhqWQASwssvv6x0wKC3ChUq5JhWz40cOdL3+MQTT8xKSkrKWrVqle+5xYsXZ5UtW9ZN61m+fHlWmTJlsu6///4c8/v555/dtP7PH3744e69r732mu+5PXv2ZNWvXz/r9NNP9z03evRoN53m4e+ggw7KOuqoo3yPd+/enbVv374c0yxbtsyt2z333JPjOc1P28N/WXQLdP7552c1a9bM93jSpEnuvW+88UaO6caPH5/j+Q8++MA9nj59elZhrF+/Pqt8+fJZgwYNyrEuzz77rJvfmDFjfM9p/+i5tLS0kOadmprqptd+k23btmVVrFgx68knnyzwvXv37s0qVapU1g033JDj+blz57p5XnPNNSEtw4cffuimv++++3I8P2TIEDf/JUuW+J7zjkvtr8BjQceIlt9z6623uuf9p/WOr8cffzzH8dW1a9esunXrZmVkZOR5PBx99NFZnTp1cseUZ//+/Vn9+vXLatOmTY5lP/vss91nY9GiRVmPPvqom5fWM9TP48SJE90+/PPPP7PefvvtrNq1a2dVqlQpa+XKlW66b775xk2ne096enqu+T344INuG/7xxx85jl+91//4l27dumX16NGj0Me1Px2nw4cPL3A9AQCgDVpybdC8+Lcbb7zxxqzWrVv7XuvVq1fW0KFD3f81zRVXXOF7LTMz07Wf/G3evDmrXr16WRdeeKHvuffff9+996mnnvI9p7as2uqB6xxq+yTYOYnX1vJv8+W1bfOaxymnnOLawP5tpl9//dWdwxTlvGb27Nnufe+9915WYXz00UfufaG0xUXbVtOPHTvW95zas3379s2qUqWKr23sbYvk5OSsLVu25Govd+nSxbXt/duyatf5t3t17Gla7VfP1q1bsxo0aOD2U2HPv7z2bMuWLXO1YwPbuqFszzlz5rhpLr744hzP69jW819//XWudfn+++9znHNpGQPPbYBoRHkEIMGom8yECRNy3P73v//lOb2uhOvqt7IM/a+Wqmu6smH9KZNUV9p1FVfZvN5NV0hVXD+wK5Wu6p977rm+x7raqm4rumrrf1VdJRKUBeBRjVRdvfXvgq5uMaqJ5C2zumhp/up+P2vWLAsHXc3W1V1dXfZfP12l1d/y1s/LJtYV4cLUodJ21tVl1YL11kWU2aDuRp999lmRl11X29XF3xu0TFf0lVERSokEXZ1Xm7dmzZq5si+8eYVCNW+VHa3sEH+6Oq75Bx6HRx99dI6ugcrGEHWX8v+b3vP+x43ouFFWiv/xpcfKhFbZhLzWVRm7OoaVTeLtYx1PuuqvrANd7fcow0XHhK7eKxND3QLVzSxUyqhWpodKHKjbl44jZQcoyzcv6srmX25Cy6cSENqGyvoIpAwJf+rW6L+tQj2u/elYCMzYBwAgP7RBi64ov9V5URkEZR6qF5d3n9dAV2q3edmQauOrnaTMVLUp/dvXyr5Upq/arB61Zb3eUsEU1D4pDjpHUC8vndf49xLr0KGDa+cV5bzGy/zUfNUTKlRFaUfrb/uPeaBtrnb1jh077LvvvssxvbJf/bN8vfayzr38B3fT8zr/8G/fis771LvMo3OR8847z7U11VOvKOdfynL1b8cGE8r21LaQ66+/PsfzXo/CwHMmlXbQ8eVR21vLWNzHGxAOlEcAEoyCogUNROZPAS51x/GCff4Cn1NAS4EjNWSCCey2pe5ZgTVxFQyaN2+e77G6Pil4p+7p6lIjCuCqsaGArkeNqqefftp1S1d3Mf+aWPl1NS8MrZ+69qlrfH6Dg6lLkAKLKnOg7lvqyqTGoRrEatzkRXVCRY0If2osq/aS93phqSuRGjfqSqXGuUclANTdX13N2rZtW+B8AuvOqvEmCm6GQsuvBmBg41QNZe91f4ElF7xGnAKcwZ4PrOmmv6XSBv689VS5ikMOOSTXMmr7aD0VgNUtr/3sBVVVh+yZZ55xDWN1q9P/C3sCq2XS8az3a9/7B+yDWbFihasvp9IRgescWDtNdbsCy5joM+b/vlCPa3/aRgxCBgAoDNqgRVeU3+q8qLSRyheoRIISDRQI9GrqB6Mu6CpdoK78/skI6g7vURtOZdRUp9RfsPOHUNsnxUHlDXReE+xcRW0wLxhYmPMabQcFDzWQrJIhFBxUOTAFR/MqjVDUdrSWJbCdWFztaO27wLaefztax01hz7/8j5m8hLI9ta7aDoHHl5ZJx3RB26KkjjcgHAjaAggb/XDrx10Zk7oyH0hXXv0FmyZYcFAZiKrfpYETVDtLAVwFcr1aVvLAAw+4IJvqQim4q2CafsyVtarlyo+WOfBvSrDBmtRYzis71Wt8an6qzzt16lT75JNP3JViLZcavHoucDsUN2VnqC6U/r5ugbQ+wQZ782hbap2CNeYUbPQGBwu3vI6PUI+bovCOFdXaCsy48AQ2ELV/RdtHdWX96zaH+wRWx6SybJTpolpkOulSYFrZEarNFXis57WtinJcB14I8P/8AQAQSbRBc/9W50eJBKrNrwvp6rmW1wVjDcKl9oWSDzQGgdoLaluodqhXh78oQmmfFEZeF5ID2/LFdUypfa3tpDq+GrxL2a/aRmr3K0klGLXhJJbb0YU9/yooy7aw2zPUBILiPHcAihtBWwD5UuNMV8P9MzQ9gc9p8AD9+OkKaSiZm6FSQ1Hd2r0SCcoMvfXWW3NMoyDpkUce6QZHKGxwSVdag3WPCbxKq/VTCQNlqIbS6FAmp24axEDZDP/85z/dqKkqnB9Ms2bN3L0GH1NmrUddlnT1Wl3pi0LBuI4dO+YazE00WICWLb+grQKzWnctgz9lUygzQ+UENBpt4JX7YOun7aeMAv9sW28EY2/9w2X16tWufIB/tq2OHQkckdnjbXdlT4SyvdUdUAN0aHA0bWd1+9JACP7dzsJJDXutg7Je1EXNozInRVXY41oBYh2TXmYHAADFgTZo0X+rQwnaqtfOmjVr7PXXX89zOrWv1TZSqQD/AFlgm1JtOJULUHd2/2zbYOcPByKvIJ1Xwkvt/vza8roQre2nLNpAan8fyHmNBlLW7Y477nAD+GpfPf/883bfffcFnV7zVHavApPKVi0oqUPbWL0RFQz1D7IXVzva633mv80D29EHcv51INtT66rtoP3o3x7VQGj62+HeFkAkUdMWQIFXJhW80sigCoL5/5AH1iBVuQJNrwBg4JVLPVado6JQ5qKyHpVhq6CnygUokBu4nIF/UxmmgfWZglGjTA0e/5Fn586d60bi9aeaVrpi75Vp8Kf6Xl5DURmXgcvija6rjNe8aDtr3dTF3v/9agipS1ywUX0LomDq999/75ZddVcDb8pg1r5UoDE/ffv2tRkzZuR6Xo12LatquaqeViDVjlWAUY477ji3/VQH1p9KSKhBGFgj+UBpnygo7VGgUY/VYFcNuLxOEFXOQtPpRCaQ/zGi/a0AvLJllWmg4K3qd+n/xcXLFPA/PvR/NfaLKtTj2uPVA1YdXQAAigtt0KL/VofS9n3qqadc9qLaMfntg8B2h9qMU6ZMyTGd2ukqnfDiiy/6nlNQTWWgwsm7EB+4vio1oCCh2rz+1G0/cH20rDqvUbkpz4IFC3w9pwp7XqPatNoH/hRsVGA1v3a/aN6aj9qTgfMQZZlqjAyvHa1asv7jfOg9//nPf1zAV+XZwknnfRpnwaP1fO2119w5jcoQHOj5V15C2Z7aFqJj2J9KKkhRzpmAaEWmLZBgFGj1rsj6UwDGP7vT31133eUaDbrCOXz4cF/gTdmbKlng3wDU1U9lwarWkQKryqhUhqZ+9C+99FLX7bwo1HVLtYzU+FJjK7AL+gknnGD33HOPC0JqXZSRqMzHvNbJn7r06Ede873oootcXTBdyT344IN9gwSIGkPK+FUDV+s9aNAgl5Gpq7xqoChwpkCogpRaThXv1zZRZqkasWpQeo2MYBRM1LZTA+6YY45x9Zt01V/z6tWrV45B20KlLFo1pjSvYLQ8ygrVtvIGKAhGg2spEyOw/q22tRrkl19+uevmpeCt6m1pnb/99ltXd9XLMDjxxBPd1fjbb7/dHR9dunRxx5UyDNSNStsqnFTT9uGHH3Z/S8usRq722wsvvJCrvrI/rc+hhx7qGogaUEPHkK7c6wRF5Q8U0JdrrrnGNbSV+aJGq/aZGt1aX20vrV+4aRtrO+lzpAaxjinVJT6QmlyhHtf+Wb2qDaaaeAAAhIo2aPG3QQtD7ZiCqH2tLFu1aRUIU5tey6eBnfwv1qvNr+CvBoJSMoDaK2oDqpyThKsOvnfRXW1JlU/TNlD7UsFctcEeeughd6/SUwrgepmh/tTOVk8p1UpV+9ULfGqb+4+rEep5jXqcadwIjW+g9qbmpzaz2oYa46Kg8xuds6hXngb40iBjyhJV+1LL+NVXX7m2vOjvKalAZQN0AV3Zrsp0VZKJgpehDmgWKq2LjkkNVKdxF8aMGePawy+//HJYzr/yEsr2VBtbvdvUplcAX5+Pn376yZ2DaT/pfAOIG1kAEsLLL7+sy6B53vS6R49HjhyZ4/1fffVVVrdu3bLKly+f1apVq6z/+7//y7rhhhuyKlasmOtvvf/++1mHHnpoVuXKld2tffv2WVdccUXWb7/95pvm8MMPzzr44INzvff888/PatasWa7nt23bllWpUiW3bGPHjs31+u7du93yNGjQwE3Xv3//rClTpri/o5tn2bJludZXNM+WLVu69evatWvWF198keeyvPDCC1k9evRwf6dq1apZnTp1yrrpppuyVq9e7V6fNWtW1tlnn53VtGnTrAoVKmTVrVs364QTTsiaMWNGViieffZZt83KlSuXVa9evazhw4dnbd68Occ02j9aj7S0tHznpWXTcuTniCOOcMu4d+/ePKfZs2dPVp06dbLuvffeoK/PnDkz65xzzslq2LChW+6aNWtmHX300Vmvvvpq1r59+3zTbd++Peu6667zTdemTZusRx99NGv//v055qd10zHjz9t3mt7fN998455/7733ch1f2uZ9+/Z1x6n2pbZtsHkGHg9Lly7NOu+887Lq16/vlrNRo0ZuH6amprrXP/roI/e+xx9/PNdxqr/TpUuXrIyMjAI/j9OnT89zGv91073n119/zRo4cGBWlSpV3D655JJLsubOnZtrPXT86vMXyDt2Cntci/alPmN33HFHvssNAEDgbx5t0OJvg+Yl1HZjYPtL7bMHHnjALYvatDoX+PTTT4Mun+attqCWq3r16lkXXHBB1o8//ujm+fbbbxepfRLsnERtUbXLSpcu7V5XW07S09OzLrroIve3tQxnnHFG1vr164PO47vvvnPbUdtc2/7555/Ps31U0HnN77//nnXhhRe68yO1N2vVqpV15JFHZk2cODErVDrPOvnkk117vGzZslnJyclZJ554omtv+lu3bl3W0KFDXftPy679H3g8Faa9nFebVPv2+OOPd8di586d3b7Xege+N9Tzr7z+drC2bqjbU+ctd999d1aLFi1cW71JkyZZt956q1smf966BApcRiBaldI/kQ4cA4hNupL5yy+/BK0LhfijLnm6uq79He4BJMJNJQ42bNhg8+fPj/SixBV1J1QdPA0+olGiAQCIBNqgsdNuUJbuDz/84HrsITYoi1c9Kr3SDAAih5q2AEKya9euHI8VuPv8889dcAyJ4brrrnNd4VRXGIlJ5SbUZY2ALQCgpNAGjc39pHJqKjugUk7du3eP2HIBQCyjpi2AkKg2kWoo6V4jsT733HNu0KybbrqJLZggNMiBaq0hcQUOPAIAQHGjDRobrrrqKhe41eC1GjBKtXAnT57sBmitVKlSpBcPAGISQVsAIdEgS2+99ZYbtbRChQquQaZGmAadAgAAAIoDbdDYcNRRR9njjz/uutTv3r3bWrdu7TJt1UMHAFA01LQFAAAAAAAAgChCTVsAAAAAAAAAiCIEbQEAAAAAAAAgilDTNgz2799vq1evtqpVq1qpUqXCMUsAAAAcgKysLNu+fbs1bNjQSpdO3DwF2qkAAACx2U4laBsGCtg2adIkHLMCAABAGP3555/WuHHjhN2mtFMBAABis51K0DYMlGHrbexq1aqFY5YJk/mRlpZmycnJCZ0BEw/Yl/GDfRkf2I/xg31ZdNu2bXMX1b12WqKK9XYqn4H4wv6MH+zL+ML+jB/sy/hqpxK0DQOvJIIawrHYGI7kl8nu3bvdNiNoG9vYl/GDfRkf2I/xg3154BK9dFWst1P5DMQX9mf8YF/GF/Zn/GBfxlc7lfRGAAAAAAAAAIgiBG0BAAAAAAAAIIoQtAUAAAAAAACAKEJNWwAAUKB9+/bZ3r172VIRqEum7a4a8NR/z6lcuXJWpkwZjkkAAADEJYK2AAAgT1lZWbZ27VrbsmULWylC21+B2+3btyf8gFrB1KhRw+rXr8+2AQAAQNwhaAsAAPLkBWzr1q1rSUlJBMciELTNzMy0smXLsu0Dtkt6erqtX7/ePW7QoEFJ7xoAAACgWBG0BQAAeZZE8AK2tWvXZitFAEHbvFWqVMndK3CrY5RSCQAAAIgnDEQGAACC8mrYKsMWiEbesUm9ZQAAAMQbgrYAACBfpUqVYgshKnFsAgAAIF5RHgEAABSrrCyznTvN9uwxq1DBrHJlBdvY6AAAAACQF4K2AACgWKSnm02ZYvbFF2aLFpllZpqVLWvWtq3Z4MFmffuqezsb399dd91lH374oc2ZMyfiG+aII46wrl272lNPPRXpRQEAAAASDuURAABA2P3yi9kVV5jdfbfZtGlmpUtnB2h1r8d6Xq9ruuKwdu1au+aaa6x169ZWsWJFq1evnvXv39+ee+45S1c0OUYDuioHkN+tKL799lv3Xg06BwAAACA6kGkLAADCSoHYu+4yW7fOrFUrs/Llc76enGyWkWG2dGn2dLodfHD4/v7vv//uArQ1atSwBx54wDp16mQVKlSwn3/+2V544QVr1KiRnXTSSUHfqwGtypUrZ9HoxhtvtMsuu8z3uFevXnbppZfaJZdcEnT6jIwMKx+48QEAAADEBDJtAQBA2CiJ9bHHsgO27dvnDth69Lxe13SaPpzJr5dffrmVLVvWZsyYYWeccYZ16NDBWrZsaSeffLJ99tlnduKJJ/qmVYapsm8VxK1cubLdf//97nk916pVKxf0bNeunb3++uu+9yxfvty9z7+EgbJU9ZyyVv2zV7/66ivr2bOnJSUlWb9+/ey3337LsawPPfSQywKuWrWqXXTRRbZ79+4816tKlSpWv359361MmTLufd7js846y6688kq79tprrU6dOjZ48OACl1WvH3nkke75mjVruucvuOAC37T79++3m266yWrVquX+hrJ9AQAAABQ/grYAACBsVMNWGbTKsC2ot75e13SafurU8Pz9jRs32pdffmlXXHGFC8IG/7s5F0yByFNPPdVl4l544YX2wQcfuNIKN9xwg82fP9+GDRtmQ4cOtW+++abQy3P77bfb448/7gLICiRr/p53333X/W1lA+v1Bg0a2H//+187EK+++qoLNP/444/2/PPPFzh9kyZN7P3333f/V0B5zZo19vTTT+eYn7bjtGnT7JFHHrF77rnHJkyYcEDLCAAAAKBglEcAAABhkZWVPeiYYqKh9srXdJp+/HgzJXwWsSyrz5IlSywrK8tlx/pT5qmXxaqA7sMPP+x77ZxzznFBWc/ZZ5/tsk2VsSvXX3+9TZ061R577DFfVmqolLl7+OGHu//fcsstdvzxx7vlUJ1dDfCl7Frd5L777rOJEyfmm21bkDZt2rjgqkeZtPlRtq6yaKVu3bqupIS/zp0728iRI33zfvbZZ132cEpKSpGXEQAAAECcZdp+//33rktjw4YNXZaMRlcuiLr+de/e3dWy02Akr7zySq5pRo0aZc2bN3cnUH369LGffvqpmNYAAID4tXOn2aJFZrVrF+59ml7vK87xwfTbrhIBBx98sO3ZsyfHaypf4G/BggWuJq4/PdbzhaWgp0eZtLJ+/Xrf31G7w1/fvn3tQPTo0cPCyX/5vXXwlh8AAABA8YmpoO3OnTutS5cuLsgaimXLlrmMFmXF6ERNNd4uvvhi+0JpQH955513XAaNskhmzZrl5q8acJyQAABQOIqFZmaalS1kPx5Nv2+f2QEkmProAq0u7AbWjlVNW71WqVKlXO/Jq4xCXkqXzm4+KaPXfwCzYPwHNfPKMqhObHEJXJfCLGswgYOyaR2Kc/njXXElIAAAACD+xFTQ9thjj3VdB1V3LhSq5daiRQtXS06DkGhwjiFDhtiTTz7pm+aJJ55woy6rW+RBBx3k3qPBQsaMGVOMawIAQPypUCE7AKvAbWFo+jJlzCpWPPBlqF27tuu6r278uthbFGozqCasPz1WO0GSk5Pdveq/evwH+irM31GtWH8qwxBOoSyrauDKPkXOEXMJCAAAAIhPcV3TdsqUKTZw4MAczymLVg1eycjIsJkzZ9qtt96aIyNF79F786Julf5dK7dt2+bulXlC9knotK2U+cM2i33sy8jS50jfZ5mZme6mC09edtyOHTssLS3NPa+AjDeN91hZWwpyyaZNm2zhwoW2detWN4q8al3qO1HZYLppwCLVBfUCD6qVqWCP/02ZYLrX3w8c7Amx95n05uPdCpKUpLqnKkWgGrKh/52NG8169zZTEmwIf6ZACogdeuihruyBetKoi7+O5enTp7tjXFmL/usTuH433nijnXnmmda1a1fXJvjkk09s3LhxbgAuTadySocccog99NBDrrySeufccccdOeblzS/w//7PXX311e6isUoaqPzCG2+8Yb/88ovLCg5cPv97f4HLHvg4lGVt2rSp+7xqPY877jiXjVylSpWg8wtcpkjzli9YGywa2xdKQNAtVP4JCF6g/4cffnAJCGrTFoa+84MF5rXvvYxsb7r86LehJKfVfvSW3TvuSmIZvO+/aJ7W+42OpWmLsm4F/Z75H8PxPG1Bx3BJTxvssxmJ74hITRtv3xH+YuX7hO+I4J/PvD6b0fB9Eo2f5X0R+o4IVVwHbdeuXWv16tXL8ZweK8i6a9cu27x5s9vowabRSV1eHnzwQbv77rtzPa/AyIEMHpJodBArOKQD2f9DjtjDviw++nzoIpGCoN6PwMaNG23lypXueX3n6N7/B0GBJg0o5GXX/fzzz3nOX0FW78dHwRwN4pSenu6+zwI/l/4nFhs2bLDZs2fnOd+2bdu6AJEX4F28eLFbB//groLLupUtbF96lNhnUt3oNS8v0B+KgQNL2dSppW3PnqyQBiPLyNDylrKUFDUwwxMIbNasmathq8HGbrvtNvd50TGngNd1111nl112WY718S5oeE444QTXE0eBMl3o1bH84osvukCwN93o0aNt2LBhLjCs411tAwU8vXl5nyv/bed/r9vpp5/uPhs333yz+yyrJ9Gll17qgsPetNqH3ryCXQjx9o83rW6B+6qgZVW7Z8SIEe4i9oUXXmjnnnuuvfTSS0Hn5wVHQz0eipuWQ8uj78XAUg7bt2+3eE9AKExywfjx4913biD9XvjXVv7f//6X50mJLvL169fP9/jLL790Fw2D0aB2AwYM8D3WAHZqfwdTtWpVO+KII3yPv/vuO9/+0zGo77Pq1au7z4AuKvhvEwWxt2zZEnS++r3xD25re+pYCUa/sfpceJQFn1+5NJW58MyYMSNHNnsgzdf7DVfG9J9//pnntFpeL/tdv9/5DSZ49NFH+/bpr7/+akuXLs1zWm1fbWdR+ZhFKiSeB+03b1BCzVPzzouOB+/ir5Y1vzZH7969Xfa/9qm2wbx58/KcVhezVEZEVq9e7RJt8qJ2jy4sy7p16/Idn6RTp06+9omOhcmTJ+c5rXpXtGrVyv1fx9ikSZPynFbfrd4AmDp2VdYkL5qn13NDbS59NvKiZdUyiz5r+WXZaxtoW4g+w59//nme06o+uX89908//TTPafP6jgj8bEbqOyIQ3xFF+4447LDDfG19tU0i9R3hxWb0HZFfLya+I/L+jgj22YzEd0QwfEf8zRuouCCcKReBTmpUB9e/MawPgBoh1apVK8osE5J+EPQlou1G0Da2sS8PnBrtOjnUvRqsCuB49/rhVSPGC8QqkOZdIFIgSjdR8FM3ZcN60yqIoaCG95pOGv3/r1HjvRqYahDrx10BWz3v1a70Ajf+33FeA1DLogaCAgS6103P6YfeWwatV2AQIa+TIr1fAWEtk24EdCP7mdRxppMi75gJxaGHqq6s2ZIlpax9ewUa855W1xqWLcuevn9/HZsWNvpdVomEguSV4XTFFVe4W17UQA482fefl06UAuetxm/gc8p69TJf8xMYkPS6zvvLK0hQ0LKKMpJ1K2h+H330kUUTHZc6xnUSoKxif4GP4zEBIViN5rySC/SeYPWMdWz5Byd1opfXyZa2tf+0CmTlVSNZvxuB0+aV3KC/Fziteop4x6p+G72LUPot8Z9WSRheYLqgddO0Wr9g9JsY6rTiP616qhQ0rRe0DWVaL2gbyrTe77ECkPlNq992LyAWyrReoC2Uab3jpaBp9fvuBRO0fwua1vvd0f8LmtZrCxU0rZbR22YFbV9N6wW6NV1B03rHREHr5j+tju38ptUyetNqn+Q3rdpN3rTaJ/lNq+0V+LnPS17fEYGfzUh9RwTiO6Lo3xFeMD6S3xFekDGUzz3fEcG/I4J9NiPxHREM3xE5PxuhKJUVLf3bCkkf5g8++MBOOeWUfK8WqQvkU0895Xvu5ZdfdtkJOpB0UOtLLDU1Ncd8zj//fPdDEOqJiRqKCnRongRtQ6cvE324FdghaBvb2Jehbyc1MBUE0/dGo0aNfN8ZygTMK3NV33eqgehlkShzVZkkOllXUEL3+mENRzmCcOxLLxjkvV8niZqnf3BXz2k99Fjf09oWwTJktF5eAFe3+vXr+06gULz7UXTypMCgumcXJgD2yy9md92l/amMImW75Z5GbX0lfCgepfjSX0lHCOBluurEhJIjhTtGo719FkpbVtl7KqHhX8pLmTGqc6sTsmBB22CZtvr90AlusO0Q7d0a9X2mExv/i1DR0K0xGqaNti7KoUyr17U/daElv+80uj7HRnmEwM9mNHZR5jsi9PII+p3wauHHwvcJ5RHyLo8Q7LMZDd8n0fhZ3hehdoTOhVWSsKB2alxn2vbt2zdXyre6HOp50VVspdWrK4bXYNaG1WMNWgYAB0KBSQVjvSCtAraBtSa9L2gFFhRgUx1J/2BssICsgpeqeRmtAoOEWgd1Vw9GwSj/ddN7leWrbeUFeXXTVWTRhTYvaKvtqi6T6p6lm5dlg8g7+ODsoO1jj2UHZrWL1TPOG6RMvZP1UVBA99//JmAL5EUXqnQxy58e67cjWMA2sAdGYCZMsIztQIW50FMS06ptrosWWvZg84i25WXa0HqCeFnyofI/EU7kaaPpWCvos1kSy8C04dsO3mdT08Xa9o2Wz2c0TKvtFspn05u2MPNlWgvrdgh1XjEVtNVJvOotepRZoTonOsHXIBrKQli1apW99tpr7nXVrFPXyJtuusnVaPv666/t3Xfftc8++8w3D5U5UGatuiyq+7GychXxVlYDABSmfqi6/Oj7SDcvaBtYH1s/oDrZVuDR/4qaHvvXAkoUgV3udUXYu8Kv7nTKJNN3v76XdfPfZrqC7F9vSwEMXa30gri6FaaRg/AHbkeNMps6VbU0zbSr1DNXu0SH+jHH6OJq9uBjAIqWgAAAAID4FVNBWxX5P/LII32PvbqyCrq+8sorbgCAFStW+F5XVzkFaDXoyNNPP22NGze2//u//8sxIIFGh9aJvwbgUN0wFWbWQA2B9cMAwL9bhEqoKEirmzeooVcM3gvaKsDolUDwgrR5ZUYhN10dVgaybsFom+p73atrpiC5bsq+lf79+/v2hQK+ynJWJjNKjsqoHXWUmX6609PVlV0Z5tnPh6GaBxBziiMBAQAAAPEppoK2GjEyv5oQCtwGe09+I5yLSiFQDgFAXvS943XhV5d9ZTkFDuKjciv+WbZeFqnqtaJ4BGblKttZAVzdvBFT/QMjuilorveoFIUGbAulqzAOnD4+Gu/urzHvgIRVHAkIAAAAiE8xFbQFgJLgjZqqgZx0r/qyvXr18gVn9VhBWw2ioSCt7pXBySBBkaPgq4KwuuVXN0iZuAqI6Kb9pRIKCuK2adOGAREBxGwCAgAAAOIPQVsA+GtALJVKUZkUDfKizE3/gKB/tu2AAQNc8Baxo2PHjtahQwcXhNd+VkBe3ZRV2kKjz7dr1843rV73BoQDAAAAACASCNoCgJn99NNPLqDnUVBWta2VhalsWv8sWgK2sUmDkqksgm4HH3ywy7pVgNY/603/nzlzpgvaK3Cr/a/R25VNTSY1AAAAAKCkELQFkFA0IJWyaXXr3bu3r6apAnnKuFSATreaNWsSpItzyqTVwD/+9uzZ4wY4UwauMnF1Uy1clcRo2LChqyeZ18Bo8DNpUvaoYykpBW+WCROyRycbMIBNCAAAAAB/IWgLIO5pYCoFaTXAi4JwHnWRb9Sokft/y5YtrXXr1hFcSkQDBWf79+/vMm03bNjgjhEdNwro//777y5bl6BtCAHbsWP/fpxf4FYB29TUvx8TuEWA5s2b27XXXutuAAAAQCIpHekFAIDiomzJr7/+2iZNmmSLFy92AVt1cVeX906dOuUYtEqDVAEeZWA3aNDAunTpYoMGDXJZ2Qrwe0F+Ue3jb7/91h1byuBGkICtArIKzIYSsNX79P4wuOCCC9xnXTftS5U6SUlJsTFjxrhBBAODgpru7bffzjUfldHQa/6DQ3nT66ZsbT0+44wz3HfNgVi+fLlvvrqpLMvhhx/uvr8AAAAAJB6iFADihoIxyoj0KKCSnp7usiPVtb179+42ePBgO+SQQ1ygpUKFChFdXsQGBfQV9NPxo9IJntWrV9v27dtt4cKFvosDS5cuzXEMJpxg6x4scBsYsM3v/UV0zDHHuCxpBUP/97//2ZFHHmnXXHONnXDCCW7gQX9NmjSxl19+OcdzU6dOdRn6lStXzjXve+65x837t99+s9dee81q1KhhAwcOtPvvv/+Al3vixIlu3t9//7373jrxxBPdBYJYlpGREelFAAAAAGIOQVsAMW/btm32yy+/2IQJE2zOnDk5urorQ1KZkj169HBZkl4NW+BAdezY0bp27eoyt5UZqTIcv/76qzsOJ0+enJiBKpVCGDIk/8BtXgFbvS+UGrgh0kUZ1afW514B99tuu80++ugjF8D1z5yVf/7zn/bdd9/Zn3/+6XtOWbl6vmzZ3JWkFLzXvFUT+bDDDrMXXnjB7rzzThsxYoQL5Hr0vaQgcbVq1dx7BgwY4AL7+dGgd5q3ji8ts77fNFCiZ/78+Xbssce6gfJ0MeFf//qXK+Xhf/HqkUceceVetA20jP7B5J9//tmOOuood1FLf+vSSy/1lY358ssv3femjmV/CnbrPZ4ffvjBrYvmoYD31VdfnSPbXBfF7r33XjvvvPPcuutvhPI+lSNRkFqvt2jRwt544418txUAAAAQzwjaAohJqjmqDDplNyrYonqjCpIp83Hfvn2+6TTAWLCgC3CgdAFAgSdlbqvrvUpuqEu7d3yWL1/eN21gZmfCBm5vvrlEArZ5UeBRJS/GjRuX43kFP5WF/+qrr7rHytB/55137MILLwx53gpsZmVlucCwrFq1ygV0FThVJvbMmTPd/EI9Fnbt2uWyeMU7lhRM1Tp069bNZsyYYePHj3dZuCrP4Ln11lvtoYceckFkXUR488033fqJAqRaTw20OH36dHvvvfdcZu+VV17pXj/66KNd1vD777/vm5++T7UtFMAWBZ2VxXz66afbvHnz3GsKxnrz8Dz22GNuW8+ePdstSyjvU1kLBc6/+eYbS01Ntf/+978ukAsAAAAkIiIZAGKOaoguWrTIV5vS676ujDIv6xEoSQrMKbtQNwXb/LNsFaRTYExZjXpdx2jc8wKwgQHagAzOkgzYetq3b++ChoEUUL3hhhvs9ttvdwHDVq1auUzqUClgr4tEupgko0aNcoPWqVaul+Hftm3bAufTr18/952mwLGCwOol4GW5Pvvssy5g+8ADD+TICNbFA30nqg7z008/7aY7//zz3etaj0MPPdT9XwFcle9QMNgr+6Bpld368MMPu+/Rs846y0130UUXude/+uorFyxWsFUefPBBF8D1BgZr06aNPfPMM67+7nPPPecydUXLrO3pufjii/N934oVK1wWtLKKe/Xq5aZ56aWXrEOHDiHvAwAAACCeELQFEPWU6aVArDdYmAJkCtiq262CFY0bN86R1QhEkrp26+ZR13Vl3qo+qm7q1q7grY7buC7XkVfgNoIBW1EgNNiFneOPP96GDRvmaskqEFqYLNtg81apFpUCKOw+VgaqAssqg3DTTTe5WrvePObOneuyUHUMBVImq4Kre/bscRmzwSxYsMBlv/rX6e3fv7/7PlVZBwVtFVhV9rhqNqumrkoUaNsoA9dbBgW9/UsXaL01j2XLlvmCrD179szxtwt6n4LO6hWhILVH28H7uwAAAECiIWgLIGopW1En88pcU4aaahyKAgkK2HIyj1ig+qRHHHGEO45Xrlzp6ocqIKcAmgK3yjj0D/LGFQVkJ04MnmGrYFwJB2xF2937LvGngKHqw44cOdKmTZtmH3zwQaHmu3HjRktLS/PNu6j7VBeidEzopizt0047zZUY0PLp2PGyYgMpy1ZlYg6UslyVnasM4eHDh7vt4F8DWMug4Lbq0QZSbwdP4ABuBb1PQVsAAAAAf6OmLYCoo7qLysjSgE46kVfw1n/0dAUvCNgilmgQKtW89WrfKlNSGeR//PGHyzaMWxp0LFjAVvS8NzhZCVFtWQ3E5XX1D6TsWtXIPvnkk13d18JQWQL1BjjllFPc486dO7ua28qyLqohQ4a477vnn3/ePdaAahrcTJnaGmjM/6YgqXcBQCUNglEWrDJe/Qf/+vHHH91yt2vXzvecsm2VEfvJJ5+415Rp69EyqFZu4N/XLb8eDwW9T1m1ClKr9q9H2b+Bg6IBAAAAiYKgLYCosXnzZje4jgIrCmap26yCs+ou26dPn0gvHnDAFIBTwO3II4+0vn37uiBaUlKS73UFtbxjP+YpIJtfaQTR68UUuFWZAJWj0IBgs2bNcnVgFYw94YQT7Lzzzgv6Hu0PlbNQSYL8aMBDzVuDZqmcwqWXXmr33Xef3X///S4IKRpga9u2ba5GrL7XVIv79ddfd4HIUKnUwlVXXWWPPvqoq3F7xRVX2KZNm+zss892A4mpJMIXX3xhQ4cOdRcBVE/25ptvdmUVVLdWr0+dOtXVhvWCsZpG9W6V7a1SC5q/Moy9wcq86bTNtD4KHKskjUfznzx5sls/lYDQemnwtcCByAIV9D4FjTVQmbJxlems4K3q4MZtFjoAAABQAIK2AKLGkiVLbM2aNe7/CiBoQB7VhFQ5BAYXQ7ypU6eOL8DndR9XkE1Z5rpwoXIKMRu8zStgG6w+aTEFbsePH+9KBihIrmCgApQa+EqBwjJlyuT5Pg0YV1CgcMSIEW7e2n8KeG7dutVltyow6T8f7UftVw22pYtPL774YqFr3CrAqmxdDRim70JlxipAO2jQIJe1rYG9dHHLq/l95513ugHAtIwKQp955pm2fv1695ouECjIq8CvyiAoIKv6t5q3P61X79693bGoAK4/ZRArG1m9IPT9rIHR9Le0bPkJ5X0KluuxtpfKQigYrsHdAAAAgERUKiuu+2WWDGXSaIRonbSpziZCo2CETiR1QuadbCJx9qXeo/qeClx5mYYKJGgEcdVTVHdylDw+l5GjQJyOf1282L17t3tOWZEKoDVr1qxQ35Ph2o9aDtWVVp1WLcsBBWy9QccKeh05qJmmsgHK0ubiVeGOUdpn8bEd+F2KL+zP+MG+jC/sz/jBvoyv9hkDkQEo8R8RBaaUbaXuyzrR7tixo3utVq1a7gYkImV/6vOgAK1KJHjBW3Vj1/+VGRn1tZxDCch694HTeY8J3AIAAAAAQVsAJZcttnr1alfP0RsER12QyagFclJmrBe89TJvlWmpwcuiXrBs3GAZtHkFbkPN5gUAAACAOEemLYBip4F9NMCSUv9Fg9q0bdvWmjZtSmkMIJ/greqx6nOiga/UPd6jgZqSk5NdYDe/+qwlbsCA7PuxYwsueRAYuD333L/fDyCmDRsWvnmVKmV2V/Ios7Q0XQEOz0xHj4669ZTRFu4Zhmc9AQBAZBC0BVDs1q1b5wK2CjqpXm3Lli1zBKAA5B+8Vb0jj2rVejdl4armrYK7UVMb3Au8qi5vQaUOvNeVYUvAFgAAAAB8iJoACDuVP1A5BK87d5s2bdwAOgoulS9fni0OHAAN3telSxdbvHixpaen2y+//GLLly93taE18FhUKEwAlhq2AAAAAJALQVsAYaNBk5T5pzqctWvXtr59+7rnFag96KCD2NJAGCijViUTGjdubCtXrrSFCxe6CyUqmaCgbbdu3chkBwAAAIAYR9AWwAHbu3evy/pTCQRl2IrqbO7bty+66m0CcRi8bdiwoS1atMiWLVvmLpyUK1fO9zkEAAAAAMQmgrYADsiff/5p8+fPt7S0NFd3Uxm2yqqtVasWWxYoAaoPrc+cBiXThRKVIlHQVv/X51OBXT0HAAAAAIgdBG0BFNmqVatszpw5tn//fqtcubL16tXLZf0BKHn6DPpTndsNGzb46t3qggoAAAAAIDZEyVDTAGJRgwYNrGbNmtahQwdXv7Z+/fqRXiQAf1EtaZVK2LZtm02ePNlmzJjhBi5D4TRv3tyeeuqpYtlsr7zyitWoUSPi8wAAAAAQfQjaAgiZSiD89NNPLrPWfYGULm39+/e31q1bW+kFC8wmTvRNq5KaO3aYbdyYfZ+jxOaECWaTJrHlgWLUpEkTO+qoo1zQUeUR1qxZY998840buEylE+LZEUccYddee21YApzTp0+3Sy+91PdY2/LDDz8M6b3a3scdd5zLck5KSnJlLG644QbXS0HOPPNMV48YAAAAAAJRHgFAgfbs2WO//PKLL9CgAY9atWrl/u/qZyoA++23iura7j2l7MekFPviCzPFIjIzVXPTrG1bs8GDzfqnT7CKn6b+PfMBA9gDQDFm23bq1MnVu9VnWOUSNGigBizr2rUr2z0EycnJRdpOo0ePtssvv9zOP/98e//9913wfMWKFfbaa6/Z448/bk888YRVqlTJ3fKSkZHhsqUBAAAAJB4ybQHkSYMZ/fHHHy5bTAFbBWhbtGjhAkA+Cti++ab77+bNZlNvTLXPrp1g06YpE9csKSn7Xo/1vF7ftPmv944dS8YtUAKqVavmSpio7nSVKlWsra6iwC644AI75ZRT7LHHHnPlXpQRe8UVV9jevXuDlkfQ/+XUU09134fe40ArV660q6++2t3GjBnjMn817WGHHWb/93//ZyNGjAia+XvXXXe5YLqm0XdtxYoV3fNbtmyxYcOGWb169dxzqlH86aef5rkHP/roI+vevbubtmXLlnb33Xdbpq6gAQAAAIgZZNoCCEp1MOfNm2ebFYk1s+rVq1uXLl3cfQ67d7u77TvMls00273T7KRqqda0itmC5BTfZIftmWBd16batm1mM2eY9ehpVqvm3+8HUPxUd1qBPwUcPcq8rVWrVqEHKsuvxILmr/IpoUwrZcqUyXda/9fDTRelFLDV/ZIlS1zJAgVOL7nkkqClEurWrWsvv/yyHXPMMXku13vvveeyZG+66aagr+dXokHLoMzccePGufmrHM2JJ55oO3bssLFjx7peDr/++muef3vSpEl23nnn2TPPPGMDBgywpUuX+so7jBw5MsStAgAAACDSCNoCCGrBggUuYFu2bFlr3769ry5mLikptntXli0fM8l27TKr+Vcsovvv2SUQFjROsQ4rJ2Q/Lq1ghbLGzObNNTvksSFWMeXvwC6A4uf/Od64caOrcSvK7NSggqEGSD///PM8X1Ngs0+fPr7HX3zxRZ6BWwWL+/Xr53s8ceJEF/D0p6BlcdFgis8++6xbb33XHX/88fbVV18FDdp6pRIUdM1v4EUFwpXdrGBwYWndVULB+1vadgoWK1Dbrl0795yyZ/OirNpbbrnFlWXwpr333ntdAJmgLQAAABA7CNoCCErdb3/77Tc3cI7XRTcvk5MG2k9l91m/ah/leF6B2g6rJlqlPVtyPF+tmtnH5YfY/sopdhTbH4gYBRabNm3qaq2qVvW6detclmlhs25j2cEHH5wjUK1A688//3zApWWCXuQKgcrP+NfRnTNnjjVu3DjkkhZz5861H3/80e6//37fcwqYq45xenq6GxANAAAAQPQjaAvABRh+//13N+CYgrRSuXJlVxOxIFlZZl9+aZZWtZtVblXGui99P8frgQFbmdN6iM3ckWJlx5sdeaQy/9gJQCRokCuVPWnYsKEL9imoN3nyZJdZr6zb/Bx33HF5vhYYsBysUQhDNHDgQAtHMHrr1q25nldt2MASL4EDfWnZVZLgQCjAqr+/Zs2aQmfb6rvXX34DlQWjMgrKtj3ttNNyvVbQBTgAAAAA0YOByIAEp+yrqVOnuq63qn2ooEZh7NyprsBmVauaLWw80Ga1HJLv9HpdJROUyLdokVl6+gGuAIADpsxODZblDTK4fPlymzJlSr7vUXZqXjf/erYFTRtYjqGg10OhMgKzZs3K9byeO9BB2BTkLahG75AhQ6x8+fL2yCOPBH29MN+znTt3dgObLdIXZgh0sU29JFq3bp3rFrhfAAAAAEQvMm2BBLZ27VrX9VYjpSswopII+Q2QE8yePWYalNyLq7gatkFKIsiuCjXc61K2rLkauBqHLCCxDEAEqH61AoTKDFXWbX51U6Pd8OHDXZ3aq6++2i6++GKrUKGCffbZZ/bWW2/ZJ598ckDzVhayat7279/fzVc1cQM1adLEnnzySbvyyivdoI4aGEzvU/BV9WqrVKlijz/+eEh/7/DDD3cDiikQ/MQTT7jgq+oQKyNYg6EFGjFihJ1wwgmu7IXeo0Ct9uf8+fPtvvvuO6B1BwAAAFBySLkAEpCyxHQSr8FtFLBVd+HDDjvMneQXVoUK2QFYL/FMg44FC9iKntfr4gV66a0LRF/W7ZFHHmmNGjXyPZeZmVlgdmk0UcD5+++/d8FNlVvQoGjvvvuuvffee0EDnYWhYOuECRNcYLZbt255Tnf55Zfbl19+aatWrbJTTz3VDXKmALJKN9x4442F+pvvvPOO9ezZ084++2xXwkaDiuW1P1SK4tNPP3V/u1evXnbIIYe4ALKXRQ0AAAAgNpTKUjFLHBBl0Sjopfp1OhlDaFQzcP369W6UcbpslqwffvjBNm/e7P6vrC11JS7qPtA3yM0377e0tPXWJW1erpq2eZVI+GBHimlw+YcfpqZtNOFzGR/CtR9VPkX1rhXIVXd/1VfVPUqOmmkKmisTuqiDm8UzHaMaRK9Fixa5avbSPovcdhg2LHzzKlVqv92VPNLqpqVZ6XCdtoweHXXrKaMt3DMMz3qGE+2M+MG+jC/sz/jBvoyv9hmZtkACUhaaTm779u3rBhs6kKCOYgiDBpm13j7buiwdF7QkQqCuS1Ktx6YJpoQ3YhBA9NN3hIKHGqhMN673AgAAAEDxoqYtkAB27drlbrVq1XKPNVJ8vXr1ijTATzD90idaVuZk27bNrGa13IOOqSRC999Tfc9rupOqpdohO/Uou8YtgOik7M6kpCR3r6zGjIwM1zVfz4XrOwQAAAAAkBOZtkCcUxfp7777zmbMmGF7NGrYX8IWbJkwwSp+Ps6atzCrVEmjoqtLxt8BW9G9Hut5va7punQxq/hpqns/gOimgK2y8ytXruz+r6Dtjh07XAAXAAAAABB+ZNoCcWzp0qW2YMEC15W5Ro0axTOQ0F81BKtWMevRw+znOWYflx9iM3ekWO207EHKNOjYwh0ptqJ8doatAra+AdcZiQyIGeXKlbOqVau6Egmqs6obNW4BAAAAIPwI2gJxSMHZuXPnulHLpWnTptapU6fiGfBtwIDs0cgmTHCB2EMeG2L7K6dY2fFmixapNIOyes0NOnbMMSnWN92swid/lUo499zs9wOIav41bPU9ooxbZe5XqFAhossFUF8ZAAAA8YqgLRBnVLt2+vTpbhRCdWPu2LGjNW/evHj/6KGHmu3dq2ixVRyUYkeZ2ZFHmqWna2Tv7GTapCRv0LEUM8V59CQBWyDqM2tFmbWVVNckoFyCf+BM3z2a3nsPUBJ0bPofqwAAAEC8IGgLxJnFixe7gK26LPfs2dNq165dMn/44IPN6tb1PVSAtnLl7FsuKQw+BsQC1b5WaRXVxhZvQLJAqm2rQcpE3z3KwA02HQpPAXGVoShbtizbNGC7KGCrY1PHKIPiAQAAIN4QtAXizMEHH+xO8Nu3b+8CLABwIOrXr+/uvcBtXgG0vXv3uu8eUQBNwVsCtwdO23b//v2uLAXbMzcFbL1jFAAAAIgnBG2BGKeT+ZUrV7q6tV6wpHv37pFeLABxQoHCBg0aWN26dV1gNj/r1q3zDX6oAcs6d+7MQGVh+I7fuHGj6zVRLHXJY5hKIpBhCwAAgHgVc0HbUaNG2aOPPmpr1661Ll262H/+8x/r3bt30GmPOOII++6773I9f9xxx9lnn33m/n/BBRfYq6++muP1wYMH2/jx44tpDYDwUZfkGTNmuBN6DQrUpk0bNi+AYqHgWEEBsmbNmrlg7U8//WSbN2929bX79OljVapUYa8cQNBWwUnVECZoCwAAACSOmErZeOedd+z666+3kSNH2qxZs1zQVgHWvLpsjhs3ztasWeO7zZ8/351w/uMf/8gx3THHHJNjurfeequE1ggoum3bttn333/vAraqdVitWjU2J4CIq1Wrlg0YMMAqV67s6tzq4hIAAAAAII4zbZ944gm75JJLbOjQoe7x888/7zJmx4wZY7fcckvQE0d/b7/9tqvxGRi01YAp1ENDLFGmuS5c7Nu3zwVGlG1OJhuAaKHvpUMPPdQNihj4WwwAAAAAiKNMW2XqzJw50wYOHOh7Tt0E9XjKlCkhzeOll16ys846y51M+vv2229drb527drZ8OHDXeYiEK1WrFjhSiIoYJucnOwy2gjYAog2GohM31H+vQMWL14c0WUCAAAAgFgRM5m2GzZscEGqevXq5XhejxcuXFjg+1VfT+URFLgNLI1w2mmnWYsWLWzp0qV222232bHHHusCwXnV7lPtUN38T0S9unO6ITTaVt6o2AhNenq6zZ07120zDTymQX40SFCktyH7Mn6wL+NDtO3HzMxM97uqcgnbt293313UZ43NfRlL2GYAAACIZTETtD1QCtZ26tQp16Blyrz16HWdSLZq1cpl3x599NFB5/Xggw/a3Xffnev5tLQ0d0KK0E+m1HVWJ6OcvIeucePGLuih0dx1zEUD9mX8YF/Gh2jcjyqToIusuoC6evVqV5deA2wh9vZlrNBvJQAAABCrYiZoW6dOHZf5um7duhzP63FB9Wh37tzp6tnec889Bf6dli1bur+1ZMmSPIO2t956qxsQzT/TtkmTJq4bKINBFe5EVFmi2m6ciOZNJ+rK7NbI4aJSHtGGfRlDfvjBTBeX/ErNZGXpe1JlaMzKllU2XymrWzfZSn/9tZmOu0MPjegiIz4+k/ru0m+lSh0p81alEvr06WOVKlWK9KJFtWjcl7HC+90EAAAAYlHZWKqN16NHD/vqq6/slFNO8Z3I6PGVV16Z73vfe+89F/Q699xzC/w7K1eudDVtlcWYFw1cplsgnUxxQlU4OhFlu+VNx/js2bNdllX//v2j+gSUfRkDJk0ye+ON7P+XKmXp/VNMJcG/+MJs0SJ1YTdT4mPv3qVscJmvrdNv71s5/UqUKmU2YECklx5x8JnURVbV4Z42bZq7oPrjjz9a3759rWrVqpFetKgWjfsyFrC9AAAAEMtiqvWv7NYXX3zRXn31VVuwYIEbNEwnfUOHDnWvn3feeS4LNlhpBAV6a9euneP5HTt22L///W+bOnWqLV++3AWATz75ZGvdurUNHjy4xNYLCEaZaApsrFmzxpXd8GonA0UO2I4d63u46cVUG3XqBFOll2nTFNwwS0rKvt8/a7b9+fQ4+/EHs02bLft9ej8QBuqRosCt7nVBNZS69AAAAACQaGIm01bOPPNMV8NzxIgRtnbtWuvatauNHz/eNzjZihUrcmVV/Pbbb/bDDz/Yl19+mWt+Krcwb948FwTesmWLNWzY0AYNGmT33ntv0ExaoKRkZGS4gK2Oy7Jly1qvXr1c2Q6gyPzqbSsQO3OGWbtdqWadzZY0T/G91mHVROtYfrKVqWa2bUv2dD16mtWiXjfCSL0G+vXr5y7AHnTQQWxbAAAAAIjloK2oFEJe5RA0eFigdu3auZqgwaiO3hfqFwxEkV27drnsb2WCqyyIaj7WqFEj0ouFWJeSHZjd+3aqzZur48xMh1WfFamuBMKCxinWYeUE67Z8nO1tp9qZ2a9v2WL20tYhdkX/FEuK9DogrmgQMg3+6U+Zt1w0BQAAAIAYDNoC8UzlPqZMmeICt8pEU63HKlWqRHqxEC9SUmz+bLNtn6datWp/P93991SXYVtpzxbLKl0qx1t+6zzEPtmVYj2mmh11VMkvMhKHBgDV7ZBDDuFCFQAAAICEF1M1bYFEyDxT2Q4Fag899FACtggrdTp4a0OKfZc8xGXS+lPANtCslkNc6QSNQzZ+fPb7geIadHHdunW2d+9ed+Fq82YVUwYAAACAxEXQFogiKoeg7Nr+/fu78h1AOO3cabZokdmy1ikuIJuf2S1OcyUTRGM46n3p6ewPFA/Vo1cpGA0YqkEYVSJm06ZNbG4AAAAACYugLRBhKoWwZs0a32OVRVDwFgi3PXvMMjPNyv5Vw3ZXheC1kjPKVraFjQf6Hmv6fftyjGUGhJ0GXVTgVoMueoHbjRs3sqUBAAAAJCSCtkAE7d6923UFnjFjhq1atYp9gWJVoUJ2AFaBWw06FqwkgpTP3GntV070Pdb0ZcroggI7CMVL5WF69+5tycnJtm/fPps2bRqBWwAAAAAJiaAtECEZGRkuk0yDjyUlJbluwUBxqlzZrG1bsxZLJrjBx/LTbdk4F9gVJTvqfUlJ7B+UTOC2V69evsDttm3b2OwAAAAAEk7ZSC8AkIg02I4Cttu3b3flEFTHVvdAcdKAYmfXmWB/pqXa/mqqI/r3ayqVEJh5q8Du3kyzBVkpdswx2e8HSjLjVoOTNWjQgI0OAAAAIOGQaQuUMNVqVJffrVu3WoUKFVzAVpm2QLGbMME6/pZq1aqZ+ScvalCycX0eDjo4Wbt5qXZipQl2yCHsH5T84GT+AVt9d+7YsYPdAAAAACAhELQFStD+/ftt+vTptnnzZitXrpwdcsghVqVKFfYBit+ECWapqVaurFnnLmaVKplt2WI2rekQNyiZ6H52i9P+OlazX9d0F1dPtaQfs0slAJGwZ88emzx5srulp6ezEwAAAADEPYK2QEl+4EqXturVq7tR0hWwraaUR6Ak+JXfqFXTrEdPs986D7FPdqXYwoVmaWlmmzebTaow0KaV6ecycXV49uxpVrNmzvcDkSiXkJWV5YK3Ki2jmuAAAAAAEM8I2gIl7KCDDrIjjjjCatSowbZHyRkwwOzcc30Pa10yxK74IMXuususT5/szNpdu7LvS3fvZk2uOc0OPfSvgK3ep/cDEaILXX369HGlZDR4o0rMaJAyAAAAAIhXDEQGFDNlhy1fvtyaNWvmMm2lkvqcAyXNC7zu3m2WkmKqpHzUUWZHHmmmHud6unx5M5UNrVdvoJX+qlR2hi0BW0QBDdaowO2PP/5oW7ZssZkzZ1qvXr2sFCPkAQAAAIhDZNoCxey3336z+fPn208//cS2RuQpAJuSXcPWo5hX5cpmtWtn3/tiYJqOgC2iiGqA9+7d25VLWLdunc2bNy/SiwQAAAAAxYKgLVCMVq5caYsXL3b/b9SoEdsaAA5QzZo1rUePHi7DVoHb3UoRBwAAAIA4Q3kEoJhs2rTJ5s6d6/7funVra9KkCdsaAMKgXr161r17d1cbXGUTAAAAACDeELQFikF6erpNnz7d9u/fb/Xr17f27duznQEgjBo2bJjjcWZmphuwDAAAAADiAeURgDBT4ED1azMyMqx69eouG4yBcgCg+Kxdu9YmTpzoejgAAAAAQDwgaAuE2Y4dO1yNRXXZ9QbMAQAUnz///NP27t3rLpjt3LmTTQ0AAAAg5hG0BcJMNRYPPfRQF7Cl1iIAFD/1aNAAZQrcqjSNejwAAAAAQCwjaAuEyb59+3z/r1KliiuNAAAofurR0LNnT6tQoYJt377dNwgkAAAAAMQqgrZAGGzYsMHVU0xLS2N7AkAEqGeDAreqIb569Wr7/fff2Q8AAAAAYhZBW+AAqX7ijBkz3MBjK1euZHsCQITUqlXLDj74YPf/X3/91bZs2cK+AAAAABCTykZ6AYBYpvqJ06ZNc/eqp9i5c+dILxIAJLQWLVq4YG358uUpUwMAAAAgZhG0BYooKyvLZs2a5TJtK1WqZL169XJ1FQEAkdW1a1dXJgEAAAAAYhXlEYAiUr3E9evXW+nSpa13795uABwAQOT5B2z379/vatwCAAAAQCwh0xYogq1bt9qCBQvc/zt27GjVqlVjOwJAFPaImDp1qm3cuNH27dtnTZo0ifQiAQAAAEBIyLQFiqBKlSrWtGlTa9CggTVr1oxtCABRmnFbp04d9/958+a5C24AAAAAEAsI2gJFoNq1GnSsR48ebD8AiGJt2rSxevXquTIJ06dPt4yMjEgvEgAAAAAUiKAtUAjbtm1z3W09DHQDANFN39PdunWzypUr265du9wAkv7f4wAAAAAQjQjaAiHavn27/fDDDzZt2jTLzMxkuwFAjChXrpz17NnT9ZJIS0uzpUuXRnqRkMBGjRplzZs3t4oVK1qfPn3sp59+ynf6p556ytq1a2eVKlVydZmvu+462717d4ktLwAAACKDoC0QAg1gM3PmTHcvOvEHAMQODRjZqVMn9/8lS5bY3r17I71ISEDvvPOOXX/99TZy5EiX9d2lSxcbPHiwrV+/Puj0b775pt1yyy1ueg2A+tJLL7l53HbbbSW+7AAAAChZBG2BEMyfP99l2laoUMF1s6UsAgDEHmUpqsbtgAEDXPYtUNKeeOIJu+SSS2zo0KF20EEH2fPPP29JSUk2ZsyYoNNPnjzZ+vfvb+ecc47Lzh00aJCdffbZBWbnAgAAIPaVjfQCANFu9erVtmLFCvf/7t27u8AtACA2tW/fPtKLgASlQfDUa+fWW2/1PVe6dGkbOHCgTZkyJeh7+vXrZ2PHjnVB2t69e9vvv/9un3/+uf3rX//K8+/s2bPH3fzr8YsG49OtJJQqFc557TdVod4fzpmGaTuEc5Fkv4V7hiWzvwtDx6DqipfUsYjiw76ML+zP+MG+jA2h/g4StAXykZ6ebnPnznX/V3ZWnTp12F4AECc2btzogmY1a9aM9KIgAWzYsMGVWapXr16O5/V44cKFQd+jDFu979BDD3WBLtXUv+yyy/Itj/Dggw/a3Xffnet51XMuqVq4ycnhDdpuqVbdskqVstLhGkQwj3IUkVxPWW/hnmF41jPcJ6lbt251x7O+fxG72Jfxhf0ZP9iXsUE9uUNB0BbIx+zZs90JUq1atdwgIACA+OlFoaxHdU0//PDDrWxZmkSIPt9++6098MAD9t///tcNWqZ6zNdcc43de++9dueddwZ9jzJ5VTfXP9NWpUGSk5NdbeeSkJYW3qBtjaytlrxhQ/iCtnXrRt16Sl0L9wzDs57hDiaozJiOR4K2sY19GV/Yn/GDfRkbNCBtKDhDAfKhQWvmzZvnyiJQxxYA4kfdunWtUqVKrkfFr7/+ap07d470IiHOqbeOBjJdt25djuf1uH79+kHfo8CsSiFcfPHFvnbJzp077dJLL7Xbb789aNBLZZyClXLStCUVJAtXbNWjogEK2IYtaBum7RDu9Sxt4Z5hdGayqk1dkscjig/7Mr6wP+MH+zL6hfobyC8lkA9lpKhLok7sAQDxQ5m1GlhS/vjjD1sfhd2IEV/Kly9vPXr0sK+++ipHNowe9+3bN+h7dFEhsFGvwK+oezkAAADiF0FbIIBOgpTFAgCIb7Vr17aWLVu6/8+ZM8cNFAUUJ5UtePHFF+3VV1+1BQsW2PDhw12bY+jQoe718847L8dAZSeeeKI999xz9vbbb9uyZctswoQJLvtWz3vBWwAAAMQnyiMAAZRx9csvv7gRxlu1asX2AYA41qFDBzdAkwYDUDmcnj17RnqREMfOPPNMd7yNGDHC1q5da127drXx48f7BidbsWJFjszaO+64w3Vx1P2qVatcHVAFbO+///4IrgUAAABKAkFbwM+uXbtc5ou6K5LBAgDxTwEylUmYNGmSrVmzxjZs2OBqjwLF5corr3S3vAYeCyzjMXLkSHcDAABAYiFoC/hRllVmZqbVqlXLmjVrxrYBgARQvXp1l3GrmqMEbAEAAABEA4K2wF/U7VAD0SjrqkuXLq47IgAgMVAOBwAAAEA0YSAywMwNPjN//ny3Ldq0aWNVqlRhuwBAglKPC9W4BQAAAIBIIWgLmLmBxxS4rVq1qrVu3ZptAgAJasuWLfb111/b9OnTXX1zAAAAAIgEgraAmVWrVs0N9qGyCP6jNgMAEot6Wqg8zs6dO23p0qWRXhwAAAAACYroFPBXLcOBAwdazZo12R4AkMB0Ae+ggw5y/1+8eLHt2rUr0osEAAAAIAHFXNB21KhR1rx5c6tYsaL16dPHfvrppzynfeWVV1y2jP9N7/OXlZVlI0aMsAYNGlilSpVc4E4naUgM2v+ecuXKRXRZAADRoVGjRla7dm3bt2+fr945AAAAAJSkmAravvPOO3b99dfbyJEjbdasWa4r++DBg239+vX5dntfs2aN7/bHH3/keP2RRx6xZ555xp5//nmbNm2aVa5c2c1z9+7dJbBGiKStW7fad999Z5s2bWJHAABy6NSpk7vYu3bt2nzbGQAAAABgiR60feKJJ+ySSy6xoUOHuq6LCrQmJSXZmDFj8nyPTrjq16/vu9WrVy9HluVTTz1ld9xxh5188snWuXNne+2112z16tX24YcfltBaIVJ+/fVXNzr48uXL2QkAgBw0MGWLFi3c/5Vty6BkAAAAAEpSzARtMzIybObMma58gUcDRunxlClT8nzfjh07rFmzZtakSRMXmP3ll198ry1btsxl0PjPs3r16q7sQn7zROxbt26dbdiwwR1D7du3j/TiAACiULt27VxZJdU7V6kEAAAAACgpZS1GKMCmEyb/TFnR44ULF+Z5sqUsXGXQqiv8Y489Zv369XOB28aNG7uArTePwHl6rwWzZ88ed/Ns27bN3SsLh0yc0GlbKdu5pLeZ/qaXNdWyZUt3Qs5+i819ifBjX8YH9mN46MLeYYcd5qt5HonvOPblgW07AAAAIFbFTNC2KPr27etuHgVsO3ToYKNHj7Z77723yPN98MEH7e677871fFpaGrVwC3kypWC6gn06MS4pf/75p61atcqdhKvmMbUKY3dfIvzYl/GB/Rg/2JdFpxJIAAAAQKyKmaBtnTp1rEyZMq5buz89Vq3aUChI161bN1uyZIl77L1P82jQoEGOeXbt2jXP+dx6661uQDT/TFuVX0hOTnZBQIR+Iqqaw9puJRXoy8zMtDlz5rgyGB07dnQjhCM29yWKB/syPrAfw2/Xrl2ul0bz5s3dd11JYV8WnXrSAAAAALEqZoK25cuXtx49ethXX31lp5xyiu9ERo+vvPLKkOah8go///yzHXfcce6xBhhR4Fbz8IK0CsBOmzbNhg8fnud8KlSo4G6BFKwiYFU4CvSV5HbTIHN79+71DTDD/ordfYniw76MD+zH8Prjjz9cz4ydO3faEUccUaLfdezLouH3CAAAALEsZoK2ouzW888/33r27Gm9e/e2p556yp08DR061L1+3nnnucxJlS+Qe+65xw455BBr3bq1bdmyxR599FF30nXxxRf7ToKuvfZau++++6xNmzYuiHfnnXdaw4YNfYFhxBdlSCngXrZsWU7mAAAhUztB5XXU7li5cqU1bdqUrQcAAACg2MRU0PbMM890dWNHjBjhBgpTduz48eN9A4mtWLEiRyBu8+bNdskll7hpNfKzMnUnT55sBx10kG+am266yZ2AXXrppS6we+ihh7p50qUufvmXwgAAINQSSwrcajDTRYsWuQFNyeQEAAAAUFxiKmgrKoWQVzmEb7/9NsfjJ5980t3yo2xbZeTqhviuRagTbmXYAgBQ1N4aS5cudb8pulCsxwAAAABQHCg+iYQwe/ZsV7tYmdoAABSFMmvbtm3r/q9sW9XKBwAAAIDiQNAWcW/dunW2ceNGy8zMtCpVqkR6cQAAMaxJkyaWlJRke/bscXXyAQAAAKA40FcccW3//v3266+/uv+3bNnSKlWqFOlFAgDEeLZthw4dXD18BiMDAAAAUFwI2iKurVq1ynbs2GHly5e31q1bR3pxAABxoGHDhpFeBAAAAABxjvIIiFtZWVm2ZMkS9/9WrVq5gcgAACiOXh0AAAAAEE4EbRG31q5d67JsFaxlhG8AQLipXvr333/vBiUDAAAAgHAiaIu4tXXrVnffokULK1uWSiAAgPDau3ev+61ZtmyZZWRksHkBAAAAhA2RLMSt9u3bW+PGjV09WwAAwq1+/fpWvXp1F7hVOZ6DDjqIjQwAAAAgLMi0RVyrUqUKQVsAQLFeIBRl2+7evZstDQAAACAsCNoi7qiObXp6eqQXAwCQAOrWrWu1atVyg5F5g18CAAAAwIEiaIu48+uvv9rXX39tK1asiPSiAAASQNu2bd29fndU5xYAAAAADhRBW8SVbdu22bp169z/a9euHenFAVACsrKUYW+2cWP2vR4DJSk5OdmqVq1q+/bts1WrVrHxAQAAABwwBiJDXPG6pjZs2NAqV64c6cUBUFwmTbLdW3bbj0kp9sUXZosWmWVmmpUtq6xHs8GDzfr2NUtKMrMJE8wqVjQbMID9gWKjQchUIqFevXpsZQAAAAAHjKAt4sbOnTtt9erV7v+tW7eO9OIAKC6TJtmm/4y1eXPNPitvNrNWiimxXgFaBW6nTTObOtWsVSuzkf0mWPMZqX+/l8AtirG2LQAAAACEC0FbxFWWbVZWlstyqlatWqQXB0AxBmxnzjDbtcvspGqp1rSK2YLkFN8kyclmGRlmNWdMsMXfpVq1nma1aprZ2LHZExC4RTFTxm3p0lSgAgAAAFB0nFEgLuzevdtWrlzp/k+WLRC/VBJBGbYK2NaoYaa4WPffU63Dygk5puuyfoKdkpnqptP0ezO9GeyOyHIjsS4gTpw40bZs2RLpRQEAAAAQwwjaIi7o5FhZTRp8rFatWpFeHADFRDVsPy4/xAKT6f0Dt7rXY9F027aZrdf4hEOGmKX8nZELFIft27fbnj177Pfff2cDAwAAACgyyiMgLtSvX99SUlIsQ32iARTepEnZWahHH13wtBEa2Csry9ygY6phq5IIXmA2R+B21USrtOfvDEevh/rnSUPs4oEpVqpElxiJqGXLlq7nh2qsa3CyivqsAAAAAEAhEbRF3Chbtqy7AShCwNar96rIaOfO+QdsUyMzsNfOnWaLFpkbdMyrYRsYuPUP2HpmtxpiszNS7Jx0s8qVS2xxkaCqV6/uenxs2rTJli9fbu3bt4/0IgEAAACIQZRHQFx0RQUQhoCtjBtnNnu2i93u2GG2cWP2vR7nCtjqfXp/CdmzxywzUxdosh8vaJxis1oOyfc9ev2Xhim2bx/lbFGy2bbyxx9/2D4dfAAAAABQSKQlIqbt3LnTvv32W6tWrZoNGDCA0bqBwgoYmEsDdm38ZLJ98koZ+2zPIF+Q9PjyE+y49FSrW8+snP8vRwkO7FWhQvayaJk8CtwGlkTw7KpQw72emWZWpkx2RQegpEr2JCUlWXp6uq1atcqaNm3KhgcQk4YNC+/8SpUyuyt5lFla2l9XhMNg9OioW8/RFuYZhmk9AQCxhUxbxLQVK1a4e9UM1EBkAApJA3NpgC4z27TZbPKPZkuWmNX9YZx12zDBkpLM3deblGozZ5r9+EP2dE4JD+yl0gZt22Zn/3o06FiwgK3oeb2u6fU+rQtQEkqVKmUtWrRw/2dAMgAAAABFQaYtYtb+/ft9QdtmzZpFenGA2JWSYsuXmy1+MNXS92QHN8vXMDtyY6odsuOvLNYa+syZbdtmNnOGWZtbh1jzEgzYetk5gwebTZ1qpjEHu6yfkKumbaCuS1JtRXmzY45Jce8HSkqTJk1sx44d1rx5czY6AAAAgEIjNRExa+3atZaRkeGybOvVqxfpxQFiVnq62d2TU+x/lYdYjRpmpfx+GfyzWJXMrtc1nabX+0pa375mrVqZ1ZwRPGCrkgj+FGQ+KSPV+u2cUIJLCZiVK1fOOnfu7Mr3AAAAAEBhEbRFzNIAL6JageqKCqBopkwxW7rUbHPPFJvd4rQCB/bSdJpeGa8lTVnAI/tNsGN3ptqWLdnZv/7LNq7Pw+5ez+v1SpXMunQxq/hpavZAagAAAAAAxACCtojZAcg2bNjg/s8AL0DRaQyQL77ILj1QvrzZwsYDLaNs5aDTegN7aTpNP358+MYQCdmECdZ8Rqr16GmmBEZl0io4+03tITa5coob1+SDHSn2cfkh7vWePc1q1vzrvakEblHytmzZYnPmzHEDkgEAAABAqAjaIiZ5J79169a1SkqlA1AkO3eaLVpkVrt29uP2Kyda+cyd+Q7sJZpe7yvxEgkVK7q7WjXN+h9q1qOH2boBQ2x2nRTbtSs787ZPH7MTnk6xvo8P+TtgG/B+oKToAuOff/7p6x0CAAAAAKFgIDLEpDZt2liNGjVczUAARbdnj1lmZnbZAQVkuy0fZ3vbJec5vVdHdnPl7CDp7t1mlYMn5haPAQOy78eOtXJlzRpdM8QuHphi56RnL4tislqX7IopKWYV/sqwlXPP/fv9QAlp3LixLViwwDZu3Gjp6emWpAMUAAAAAApA0BYxSTVslWUL4MBUqGBWtqzZwasnWPeNqZZVulSukgj+g5F5gduttc1lt0YkcdULvCpKm5JiWmIFjoMGj1NSsu+1oARsEQEaLLNOnTou41a9RHTREQAAAAAKQtAWABKYAp3Hl59g9ZammtXI+ZoG9FINW2Xgehm2nm5LU61hQ2W1/hUULWmFCcB6gVsggtm2XpkEgrYAAAAAQkFNW8SU3bt328SJE+2XX36xrBIfAQmIP6UmTrDj0rMDsqoH65nd4jQXsBXdK4Dr8abT+/R+APlr0KCBlSlTxg2iqYHJAAAAAKAgBG0RU9auXWu7du2yzZs3uxIJAA5QxYpWt55ZtWpm27ZlP7W0Xj9b2Hhgjsn8A7eaTtPrfQzsBRSsbNmyVr9+fff/lStXsskAAAAAFIjyCIgpa9as8WUtAQiDAQNMw/l13j7WZs4w+6jsaVahRmezzbknnVs3xVasMDu2Uqp16WJW7gIG9gIKUyJBWbYMRAYAAAAgFARtETP27NnjRt8WgrZAGA0YYLXMrM3C3fbWlKNt/5r1tny5Wa1a2YOUZWaa6aOniiSteqZY2/5mNdsxsBdQGMnJyXbUUUex0QAAAACEhKAtYqo0gurYVq9enUwlINwGDLDmA8yeOXu/TZ5sNnGi2aJFZrt2mZUpY9anj9kxx5j17WtWqRIDewGFRUkfAAAAAIVB0BYxVxqhoYasB1AskpLMOnc2O/poDfyXfatYMft5ykgDB27//v22bt06q1OnjpUrp+IkAAAAAJAbA5EhJmRkZNiGDRvc/ymNABQ/BWgrVzarXTv7noAtEB5TpkyxGTNm+C5EAgAAAEAwBG0RM5lJzZs3t7p161plRZAAAIhB+h3zSv4AAAAAQF4oj4CYULFiRevYsWOkFwMAgANSr149W7hwoes9sm/fPiujotEAAAAAEIBMWwAAgBJSrVo1dyFSAduNGzey3QEAAAAERdAWUW/z5s0uIykrKyvSiwIAQFiybUUDkgEAAABAMARtEfUWL17sBm5ZsmRJpBcFAIADRtAWAAAAQEEI2iKqZWZmWlpamvt//fr1I704AAAcsDp16ljp0qVt165dtmPHDrYoAAAAgFwYiAxRTV1H9+/fb1WqVLGqVatGenEAADhgGnyse/fu7ndNv28AAAAAEIigLaIaWbYAgHjUoEGDSC8CAAAAgChGeQRENQ1A5nUlBQAAAAAAABIBQVtErZ07d7p6f6r7V6tWrUgvDgAAYS8BNGPGDFu7di1bFgAAAEBsB21HjRplzZs3t4oVK1qfPn3sp59+ynPaF1980QYMGGA1a9Z0t4EDB+aa/oILLrBSpUrluB1zzDElsCYoyMaNG9299p3q/wEAEG+/c2vWrHE3AAAAAIjZoO0777xj119/vY0cOdJmzZplXbp0scGDB9v69euDTv/tt9/a2Wefbd98841NmTLFmjRpYoMGDbJVq1blmE5BWu+kSbe33nqrhNYI+dH+Ouyww6xDhw5sKABA3KlXr567VzsmKysr0osDAAAAIIrEVND2iSeesEsuucSGDh1qBx10kD3//POWlJRkY8aMCTr9G2+8YZdffrl17drV2rdvb//3f/9n+/fvt6+++irHdBUqVLD69ev7bsrsROQp67l69ersDwBAXFJ7o1y5cpaRkWFbtmyJ9OIAAAAAiCJlLUbohGbmzJl26623+p5TrVOVPFAWbSjS09Nt7969ueqjKiO3bt267uTpqKOOsvvuu89q166d53z27Nnjbp5t27a5ewWEdUNotK2UWcQ2i33sy/jBvowP7MfYofbG6tWrXU8fXagMxL4sOtoXAAAAiGUxE7TdsGGD7du3z9eV0KPHCxcuDGkeN998szVs2NAFev1LI5x22mnWokULW7p0qd1222127LHHukBwXnVUH3zwQbv77rtzPZ+Wlma7d+8u9Lol8snU1q1bXeBWAXh/KmGxefNma9CgQb4BdET/vkRsYV/GB/ZjbPUq0fen2iDBBt1kXxbd9u3bD2jfAAAAAJEUM0HbA/XQQw/Z22+/7bJqNYiZ56yzzvL9v1OnTta5c2dr1aqVm+7oo48OOi9l+6q2rn+mreqvJicnW7Vq1Yp5TeKHTkR1sqrtFhjoW758ue3cudPKly/vsqARu/sSsYV9GR/Yj7FDZZ50oVLfoXXq1Mn1Hcq+LDr/9h4AAAAQa2ImaKsTGWW+rlu3Lsfzeqw6tPl57LHHXNB24sSJLiibn5YtW7q/tWTJkjyDtqqBq1sgnWgRsCocnaQGbjdlayrLVs8pYMs2jd19idjEvowP7MfYULVqVatUqZK7ZWZmBg00si+Lht8jAAAAxLKYia4o47JHjx45BhHzBhXr27dvnu975JFH7N5777Xx48dbz549C/w7K1eutI0bN7pu+YgMDcaiE1cNzkLmMgAgnikgq7JNAwYMIDMUAAAAQOwFbUUlCV588UV79dVXbcGCBTZ8+HDXhX7o0KHu9fPOOy/HQGUPP/yw3XnnnTZmzBhr3ry5rV271t127NjhXtf9v//9b5s6darrjq8A8Mknn2ytW7e2wYMHR2w9E53qF4synnUyCwBAPCMjFAAAAEDMlkeQM8880w32NWLECBd87dq1q8ug9QYnW7FiRY4Tn+eee84yMjJsyJAhOeYzcuRIu+uuu1y5hXnz5rkgsLI7NUjZoEGDXGZusPIHKPmgLQAAiUIDruY1CCoAAACAxBJTQVu58sor3S0YDR7mT9mz+VH9uC+++CKsy4cDo5IXmzZtcv8naAsASASq5f7jjz+6C8gqlcAAWgAAAABiqjwC4t/u3bvdSNrKdK5SpUqkFwcAgGKnUkC6aKngrXfhEgAAAEBiK3TQtmXLlm6grkDKDtFrwIFQwPbII490mUYAACSKmjVruvvNmzdHelEAAAAAxGLQViUHVHMt0J49e2zVqlXhWi4kOAZlAQAkklq1arl7Mm0BAAAAFKqm7ccff+z7v+rAVq9e3fdYQdyvvvrKmjdvzlYFAAAoYqbt1q1bGZAMAAAAQOhB21NOOcX3//PPPz/Ha+XKlXMB28cff5xNiiJTLb8vv/zS1bLt1auXlS9fnq0JAEiY8kAagEy13RW49TJvAQAAACSmkIO2GiBDWrRoYTNmzLDatWsX53IhAe3YscMyMjJs27Zt7kIAAACJlm27Zs0aVyKBoC0AAACQ2EIO2srevXvdYGM6mSBoi3BTZpFUq1bNjaQNAEAiqVu3rvv9q1q1aqQXBQAAAEAsBW2V/Thv3rziWxokNC9o618vGQCARNG0aVN3AwAAAIDShd0E5557rr300ktsOYQdQVsAAAAAAACgkJm2kpmZaWPGjLGJEydajx49rHLlyjlef+KJJ9iuKNIgZARtAQCJTr+H6enpbjBO6rsDAAAAiavQmbbz58+37t27u3prixYtstmzZ/tuc+bMKZ6lRNzTCaouCJQuXdqqVKkS6cUBACAipk6dal9//bWtW7eOPRCnRo0aZc2bN7eKFStanz597Keffsp3+i1bttgVV1xhDRo0sAoVKljbtm3t888/L7HlBQAAQIxk2n7zzTfFsyRIaPv377d69eq5/ytwCwBAIlIPpg0bNtiOHTsivSgoBu+8845df/319vzzz7uA7VNPPWWDBw+23377zQ1EFygjI8NSUlLca6mpqdaoUSP7448/rEaNGuwfAACAOFfooC1QHJS53bt3bzYuACCheb1Ntm/fHulFQTFQGbFLLrnEhg4d6h4rePvZZ5+50mO33HJLrun1/KZNm2zy5Mm+chnK0gUAAED8K1LQdsaMGfbuu+/aihUrXAaAv3HjxoVr2QAAABLuIqaQaRt/1GaeOXOm3Xrrrb7n1Lto4MCBNmXKlKDv+fjjj61v376uPMJHH31kycnJds4559jNN99sZcqUCfqePXv2uJtn27Ztvl5NupWEUqXCOa/9lqXlD+dMw7QdwrlIst/CPcP9UbeO0bo/o35fupmWzOc3VPo+UR32kvpeQfFif8YP9mVsCPW7s9BB27ffftvOO+8815Xryy+/tEGDBrnatqq9duqppxZlWQFXz7ZsWRK/AQCJzcu03blzJyfCcUZlL/bt2+crB+XR44ULFwZ9z++//+5qHP/zn/90dWyXLFlil19+ue3du9dGjhwZ9D0PPvig3X333bmeT0tLs927d1tJSE4Ob5BvS7XqllWqlJXOUrgvDNavj7r1lPUW7hmuj7p1jNb9GfX7MozHbTgDDhpIWoFbytvFPvZn/GBfxoZQe9UVOkr2wAMP2JNPPumu+Csb5Omnn7YWLVrYsGHD3AAJQFG+VP73v/+5bn9HHXWUGzEbAIBEVKlSJZdBqeCeBulMSkqK9CIhwm0k1bN94YUX3HHRo0cPW7VqlT366KN5Bm2Vyau6uf6Ztk2aNHFZutWqVSuR5U5LC2+Qr0bWVkvesCF8Qb4g9YMjvZ5S18I9w7pRt47Ruj+jfl+G8bgN5/dTqVKl3HcLQdvYx/6MH+zL2KABaYslaLt06VI7/vjj3f8VXFMmiL6sr7vuOhdwC3ZlH8jPrl27fF8uBGwBAIlO2bbKXtIVeIK20UfZqqE2tP3VqVPHBV7VO82fHtevXz/oe5QQoYva/qUQOnToYGvXrnXlFoK1mypUqOBugRRUKanASrhicR51NFeAL2xBvjBth3CvZ2kL9wxLR906Ruv+jPp96WYafYM1Kw5Qkt8tSLz9qYvY6l2C0Cmuop7MaidE075MNOUC2m+BQt03hQ7a1qxZ05fGqxFs58+fb506dbItW7a4jBCgsLzjRtlFAAAkOmVFKrvSK5WA6DgBuv/++93AYQqyqjRYy5Yt7c4773QDg1100UUFzkMBVmXKfvXVV3bKKaf45qvHV155ZdD39O/f39588003nde4199WMJcL3QCAeKWyG7pAqTgTCr/t1G5Q3E6BeEROjRo13IX5A9kPhQ7aHnbYYTZhwgQXqP3HP/5h11xzjau1peeOPvroIi8IEpeXaUs2EQAA5spOeRjgJTrcd9999uqrr9ojjzxil1xyie/5jh072lNPPRVS0FZUtuD888+3nj17Wu/evd171Wtt6NCh7nWNG6GkCNWlleHDh9uzzz7r2ttXXXWVLV682JUqu/rqq4tpTQEAiDwvYKuL2IoTEHwsXNDWGzOI7Ra5faDkxPV/1SI/kFKyhQ7aquHoDWJw++23u5TfyZMn2+mnn2533HFHkRcEicvLtCVoCwAAotFrr73m6soqQeGyyy7zPd+lS5c8BxEL5swzz3QDgo0YMcKdkHbt2tXGjx/vG5xsxYoVObrLKev6iy++cGXIOnfu7AK6CuDefPPNYV5DAACipySCF7CtXbt2pBcn5hC0jQ5eT3IFbnUs51cqIWxB2+XLl7uMWtXGOPzww112wS233FKkPwx4CNoCAJC7F8qOHTusVq1abJoooMG/Wrdunet5ZUIXttaeSiHkVQ7h22+/zfVc3759berUqYX6GwAAxCrvd5WkLsQ67xjWMV3sQdtvvvnGTjjhBF9XdqVajxkzxs4999wi/WHAQ9AWAIC/eXVOlSlB6anocNBBB9mkSZOsWbNmOZ5PTU21bt26RWy5AACIV3TtR6wLxzEcctBWAy2kpKTYc88950bMVSmEm266iaAtDphGU9Yoxwy4AgBA9miy+l1UOSqvJBUiS+UMVItWGbcKqo8bN85+++03Vzbh008/ZfcAAAAg7P4umlWA+fPnu4EPVEC3Zs2a9uijj7raDBs3bgz/UiGhtG/f3vr06WNVq1aN9KIAABAVdIFc9uzZE+lFgZmdfPLJ9sknn9jEiROtcuXKLoi7YMEC95ySGgAAAIpT8+bN3QCmBWV2fvjhh77ypno8Z84cXwkmPVa94ERzwQUX2CmnnGJxHbTdtm2by4j0r82gwrpbt24trmUDAABISMq0FTJto8eAAQPc2A5KWlBppx9++MEGDRoU6cUCAABRQoONDh8+3Jo2beracvXr17fBgwfbjz/+GDSwGm5r1qyxY489Nuhr/fr1c69Xr17dPX7llVesRo0aB/w3veCwdytfvrwbB+C+++5zpb5wYAo1EJlGr/V2sH/NNWXhek466aQDXCQkkszMTFeU2Ts5BQAAfwdtlWnrjT4LAACA6HX66adbRkaGvfrqq9ayZUtbt26di5mVVA91BYkVKFWcJZCCqXq9uKg30sEHH+zarrqwffHFF7ue+hdddJHFg71791q5cuWiN9NWVMtLKcXeTYOSDRs2zPf41FNPLb4lRVzSlZ7x48fbrFmzIr0oAABEXXkEMm0jR+XAatWqFdINAAAkNpUd0KClDz/8sB155JFu8NLevXvbrbfe6ktuVIkDUexMWane46VLl7pSTPXq1XNj/fTq1csFQQNt377dzj77bFeqqVGjRjZq1Kgcr+eXxetfHkH/Hzp0qOs572XI3nXXXXbPPfdYx44dc723a9eubpyr/NSuXdsFhbXe//znP61///454jxK+tT8Gzdu7JITNE/FgoItn2fOnDnuOWXz+mcHK6G0Q4cOblsdc8wxLq7k2bdvn11//fVuOi2TxuIKzPjV3z300EN905xwwgluHwRmD7/zzjt2+OGHu3b5Cy+8YNWqVXOD0PrT9tb+0L6JaNBWG7igmzYOUBjqXihk2gIAEDzTFpGhunFPPvmku2kAXlEXR53U6Kb/S0EnMQAAIDwUc8rrpphUqNMGxq5CmaYgCiDqpiBeXu236dOnu/uXX37ZBRq9xzt27LDjjjvOZeXOnj3bBSJPPPFEW7FiRY73a2ypLl26uGluueUWu+aaa1zppsJSqQS1cxSE1HLoduONN9qFF17oavZ7yyX6W/PmzXNB3lDNmDHDZs6c6cYu8jz99NP2+OOP22OPPebmp3aUgtmLFy8udAzpscces9dff92+//57t4207B79DQV3x4wZ4zJ+N23aZB988EGOeezcudMFdrWc2uYaBFiB9MBjyNvG2iannXaanXXWWW7f+dPjIUOGFNsYTYUqjwCEm5dBRNdPAAByZnm2bdvWNf4RGeph5t/dUdkhV155pe+5q6++2p599lmXCXPddddFaCkBAEgcn3/+eZ6v1a1bN0eQUNmYeQVelV2pwKVHv+UqaxBIgdNQlS1b1gULL7nkEnv++eete/fuLktTgb7OnTu7aZKTk929Mjz9SxUoEKub595773WBxo8//jhH20PZqwokitqJqpWri8uFHRRVpRJU+lTZpP7LoXangqkKRCrbV/R/rYfKPeRH21PBT21HlRK49NJL7bzzzvO9rkDrzTff7LaHKCP5m2++ccHjwIzh/Ozdu9dt31atWrnH2j5qo3k0P2U3K8gqmlbHgj+16/wpwKt98+uvv+bINL722mt98xGVfPBqA6v0g8Y50DEZLCs6IuURgHDTB07ItAUA4G9qSLdr1841CBF5auwr6yWQnivOhjoAAIgdCgauXr3aBVvVRlCXfwVvFczNjzJtlS2qLv8K6Cp4quzOwEzbvn375nqs6cJJQee33nrLJdgpAPvmm2+6DNyCqJSAyhnMnTvX3n33Xfvoo498AeZt27a57aKgsz89LuzyJyUl+QK24gVPReUeFFD1D94rmN6zZ88c81B2r8pMKBCtbGOvTEXg9g58n8pdqG6vahbL2LFjXTmIww47zIoLmbaIeNBWV2MiUdAZAAAgFMrI0cnHDTfckON5PafXAABA8VMJgbwoa9SfV8YoFAMHDrRwUf1TZb7qphJKys4cOXKkXXDBBXm+RwFblTlQNmrr1q1dT2R1uQ+W/VvclF2spDpl+iojVzEbLUtBmjRp4pZdFHxWjVitv0pKhUJxIfGvP7v3ryQ/f4GxI+33wJq1oayjgq0vvviiNWzY0JVFUIZt4PZWrdpA2p/KDFZAWlnIKhsReOyFE0FbRJRGNdQXAUFbAAAsV70tDfoaWF8LJe/uu+92jXRlzHjZG9OmTXMDWajBDwAAil+ZMmUiPm1hHXTQQTkGB1PsI7Bsg8ocKKiruqpe5q03+Ja/qVOn5nqsAGlRKA4TrHyEMlNVIkoBSU2jcgZFKWepbap4jwKhymZVcFTrqVILHj1W9qp/6QhlyqpMmMyZM6fQPdWUeas2mpf9qmVQfV1lPMvGjRvtt99+c+23AQMGuOdU+zZU5557rhvc7JlnnnHlFPzLaRUHgraIKF05IWgLAEBuGoFYA1kEG8UXJUsnUjopUgN93Lhx7jk9ViPfvwseAABITAoG/uMf/3ClBFTDVgNTaaCrRx55xE4++WTfdOqKr8GvVBpAGa0KULZp08a1L5QBqqxNZagGu2ivIKfmd8opp7jM3Pfee88+++yzIi2vlkPBYS2L6umq7IBuogvVXjBYfzPU9V+7dq0Lkv78889u4LEjjzzSBWzl3//+t8s4VmmDrl27uqCwgrJvvPGGe11ZusrWVWbu/fffb4sWLXKDihWWBg576KGH3DZt3769PfHEE7Zlyxbf69re6iX1wgsvuACvSiJ4ZRxCoferzq3WZ9CgQda4cWOLqqCtosgXXXRRsdZsQOJQ0WvVa1HgFgAA/E0NeQVtvUE7EVkKznonFgAAAP4U11BbQQODqTSAEtQUhFSN2Ntuu803nQKR119/vcv0bNSokcuoVWBRwV4NclWnTh03YJfqwAZSmSYFgtUDSMFQva8wZSD86W9ddtllduaZZ7qAqwKqXikDBTz1+qZNm0K+OO2VmFCGrYKhKmWh4Kv/AK6qOat1UA1aZSCr9q/+lpeBrFq6w4cPd0FvDYR23333uUB4YWj+ytZV7FIlF7RdlcGsvy167u2333bLo8QIjSGhi/JHHHFEyH9DMdFQa/0eqFJZhSz+oIi+RkdT/QfVbtCG0IGWyPRhUhq2DgLvKgIKpitH+rBqlEevfgliE/syfrAv4wP7MT5MmTLF/U42bdrUZUDwWxm59lngwBSBtI+iVSTaqcOGhW9epUrtt7uSR1rdtDQrXciadXkaPTrq1lNGW7hnODrq1jFa92fU78swHrfhQlsjvkTT/tTF6mXLllmLFi1cfVgUjkJ8ynZVmYOi1lrVPBRMvfzyy12AGTm9/vrrdt1117nB1fJLQMzvWA61fVboTFvV4khLS3MLqRHTFI1XRF2RZqV8U5sUAAAgPJm2omxbRJa6EOZ34hOsJhwAAECsUbxPmagqdaBETfwtPT3dZfGq/MKwYcNKpMd4kS6hqECwou1z5851BX5Ve+Jf//qXKyysaPPixYvDv6SIy6t5ugIEAABy8y6E81sZebNnz7ZZs2b5bmr/Pv/889a2bVtXTw4AACAeKNv6nnvucTVfvQHBkE31hFUnV2U+b731VisJBzQQmSLMKn6sm+pWqGaFCg6rNoVWRgFcIC+bN2+2r7/+2hVuPuqoo9hQAAD48bonksUZeSpPEahnz54uYeHRRx91A1IAAADEukJWUE0od911l6/ub0kpdKatiim///77dsIJJ7i6tsouuPbaa10tB5VLmDhxor377rsuMg8UdCyJaq0AAICcdEFcaDxHLw1eMX369EgvBgAAAOJQoaNlGgVO3drPPvts++mnn6xr1665pjnyyCOtRo0a4VpGxHnQljrIAADkptGDhfIIkRc4grMC6epxpmwLb9RjAAAAIKJB2yeffNL+8Y9/5DuKnwK2GiENyA9BWwAA8g/a1qpVy43mjMhS2zZwIDIFbps0aeIG6wAAAAAiGrRVkE2jx3Xr1s06duwY9oVBYiFoCwAAYsE333yTq96wBubVYLyUeQIAAEDEg7bqxt60aVMGxEBYELQFACD/38mdO3daeno6mynClGXbr1+/XAFala74/vvv7bDDDovYsgEAACA+FXogsttvv91uu+0227RpU/EsERKGNxq2N9AK4sykSWYTJvgeahDKHTvMNm7Mvs8xKKWm0/RAGI63fI81jjfEEJVF+O6772zBggWRXpSEp/EagrV9t27d6l4DAAAAIl7T9tlnn7UlS5ZYw4YNrVmzZla5cuUcr8+aNSucy4c4Vr16datbt65VrVo10ouC4gigjR3r/rt7t9mPSSn2xRdmixYpK8lMiUpt25oNHmzWP32CVfw09e/3DhjA/kCRjre9mWbzZ5u9tSEl6LHWt69Z0o8TzFI53hAb1AXf/yInIkf1awNr2srGjRtztYUBAABijQZX/fDDD23OnDmRXhQ74ogjrGvXrvbUU09Zoit00PaUU04pniVBwmnevLklJSW5wC3iM2C7abPZvBtT7bPyZjNrpVjt2mZJSdnBtGnTzDL/N8HKZKRa5y5mtWqa730EblHY480da3PNtn2eavuSzUq3TslxrE2danZipQl2UfXU7GNNON4QI0Hb/fv3R3pREtZpp53m7hWwveCCC6xChQq+1xRMnzdvniubAAAAit+wYSW7lUePLvx71q5daw8++KB99tlntnLlSpesphr45557rp1//vkuBhKLAd277767wAvchfXtt9+6HkubN292g74iDEHbkSNHWiSNGjXKHn30UfdB6NKli/3nP/+x3r175zn9e++9Z3feeactX77c2rRpYw8//LAdd9xxOQ4srdOLL75oW7Zssf79+9tzzz3npgVQBEqt/StgO3OG2a5dZidVS7WmVcwWJKf4JjtszwTrujbVtm3Lnq5Hz78Ct3+9Hwj1ePM/1qpVMzt5b6rN2vP38ZacbNZ6+QRrNy/VZlbyO9b8jlcgGnnlgwjaRo5OtLz2onoGVapUyfda+fLl7ZBDDrFLLrkkgksIAACixe+//+5iSgpAPvDAA9apUyd3wffnn3+2F154wRo1amQnnXRSnmMZaBypaHTjjTfaZZdd5nvcq1cvu/TSS/NsA2VkZLh2EiJQ0zaS3nnnHbv++utdkFVlGBS0HTx4sKv5FszkyZPt7LPPtosuushmz57tsoR1mz9/vm+aRx55xJ555hl7/vnnbdq0aa6Lm+a5mxN5oGhSUmz3CUNc1qOCaLpgpmSx7r+nWoeV2TVHda/Hel6vazpNr/fp/UCo0vun2Etbh+Q41iTweOuzIjXHsaZSCjaE4w3RjUzbyHv55ZfdTW3Pl156yfdYt9GjR9utt95qderUifRiAgCAKHD55Ze7QUtnzJhhZ5xxhnXo0MFatmxpJ598ssu8PfHEE33TqhePEgYVxFUc6v7773fP67lWrVq5oGe7du3s9ddf971HyYh6n38JAyUf6jllrYru9d6vvvrKevbs6TJ71Svot99+y7GsDz30kNWrV89dlFbMLL8YWJUqVax+/fq+mxIL9D7v8VlnnWVXXnmlXXvtta5dpJhaQcuq171xAWrWrOnr1eRR0sJNN91ktWrVcn9D2b6JqNBBW3UFe+yxx1x2qzacNqD/rTg98cQTLpI/dOhQO+igg1ygVQfgmDFjgk7/9NNP2zHHHGP//ve/3Yfl3nvvte7du7u6vF7WhGpk3HHHHe5D1LlzZ3vttdds9erVrpYHitfcuXPtyy+/tMWLF7Op44xq2H5cfojLevSnQNpp02529/40naafXJmALQpnyhSzT3al2G+dh+R6LdjxpmNN2d3z2xGwRfQj0zZ6KGhL7VoAAJAX1blXfOOKK67Is80QWB9fgchTTz3VZeJeeOGF9sEHH9g111xjN9xwg0s2HDZsmIt/ffPNN4Xe8IpzPf744y6ArECy5u9599133d9WNrBeb9Cggf33v/89oJ376quvumDxjz/+6GJ1BWnSpIm9//777v8KKK9Zs8bF8PznV7lyZZdcqWTLe+65xyb4DXSeKAodtFUdCwVPzzzzTDdirjJfVe9L2SDFGflWevXMmTNt4MCBvuf0N/V4is7ag9Dz/tOLIv7e9MuWLXNlFvynUTe4Pn365DlPAPlTKRsNOqYatnNa5w6kVdqzJddzmk7Tjx+f/X6gMMea2j5LmqfYrJYFH2/KxP0ueYgbrIxjDdGOgcgiSxf6VWNNunXr5h7ndQMAAIltyZIlLjFQ2bH+lHmqTFXdbr755hyvnXPOOS4oq2zcpk2bugRJZZsqY7dt27a+eJueL6z77rvPDj/8cJfweMstt7ie6F42rZIXlV2rm5ZX02q6A6ESowquan6B2yCv5AQv8VPjHCkp1CtLJUqqHDlypJvveeed57KGlT2caApd0/aNN95w9V+PP/54F6RV+QGlbmuDTp061a6++upiWdANGza4LF+lb/vT44ULFwZ9jwKywabX897r3nN5TRPMnj173M2zTWlbf6VvU3cudNpW+lJju8XXvkxPN1PytHqLLkw+2qxUlnVbNi7P985ucZotbHy01Unb7963Y4cZA3FHx76MdjpWvGNNgduFTUI73pZXONr2L94f18daLO1H5E370BvUgX1ZeAe6zdQLyxt4jIF4AQBAUfz000+uTfLPf/4zRxxJFIj0t2DBAlcr1p9q5PpnoIZKMTqPMmlFpUUVHNbf8a9RK3379i1SRq+nR48eFk7+y++tQ16lUeNZoYO2CmaqmLLoSoGybeWEE05wA34lAo0EGGzkvLS0NGrhFsKmTZts586drhtBIn744ol+hPRdoODCjh2lTb8JOs+tUsVsY3Jn25k0y8pn7sz1voyylW1ju86WbOtNY7tkZJitWZPdhR2R35dell+00vUy/2NNQjnemu5YH/fHWiztR+Rtx44drvaXBqbQ7yT7snC2b99+QIeX/+C7kR6IFwAARLfWrVu78geBtWOVRSv+g5l6Clt6yWsLehf1Re3EYPwHNfPKMhRnEkDguhRmWYMJHJStVKlSCZnEUOigbePGjV2tCUXnlWGrmh3qFjZ9+nRfNkJxUEq50qfXrVuX43k9Vhp1MHo+v+m9ez3nXXnwHnft2jXPZdGgE0pT98+0VT2O5ORkqxavEYBioFR4fbBr167t0uERu/TlqS9RfQaqVCntgmH6jk5ONmu/cqJVXrY86PvKWZrVTp9nCxsPtLQ0zSc7CBev2Y+xti+jPUCUlGQ5jjUJ5Xj7tcLAuD/WYmk/Im9qV2n0YXVl0+8k+7JwKlasWCzluhRADzxpULsYAAAkLsU1UlJS3BhKV111VZFq4WssJtWEPf/8833P6bFXukBte1FMTqWbxH+gr8L8HdWKVdkBj3rOh1Moy6oauKJe9QhT0FZFklVHQnVfdSCee+65bjTdFStW2HXXXWfFRTtT6db6214XNTWY9Vij1AWj9G69rhHsPCpcrOelRYsWLnCrabwgrQKwOniHDx+e70lUsAC1TqY4oQqdtpWCCmy3+ODty6pVS1ubNmbTppkN2D3Buv+eXVw8L92Xvm+WVcoW7EixPn2yMyYD6rOjhMXK57JqVfMdayqR0GFlaMfbn+VKWZljUuL+WIuV/Yi8KTNB+1GDR7AvCy+cx/6iRYtc3TfVgwu2jzjZAAAAGsxL5QxU9kDlRNXFX+0RJTmqrGdBJQT+/e9/2xlnnOGCnBp76ZNPPrFx48bZxIkTfdm6hxxyiD300EMunqULyRpwrLA02Jlq52o5tbwqg/rLL7/4soLDIZRlbdasmWtHffrpp3bccce596hHPw4gaKsN7tFgZMos0KBdKg584oknWnFSdquuOOjA6t27tyuerO71KtwsukrQqFEjV77AOxBVeFkj5qkG79tvv+1GxnvhhRfc6zo4FNBV0WUtvw4klXho2LAhtcuAIlIQbPBgs8z/TbCua1NzDXe4q0KNXINDdV2SaivKmx1zTEpcB9FQPMeaLgq3Xj7Buq9IzTVN4PGm5LjD01KtiauDm8IuQVTzsjkJvEee2poKnuukQr2zAkd/BgAAUG/02bNn2wMPPOB6aK9cudIl/ClT9sYbb3QDjOVHCYqqX6uBxxTPUozq5ZdftiOOOMI3zZgxY9yFZAWANeCXBv8aNGhQoTa+YnlLly61m266yfXoOv30013i4hca5TmMClpWxe9UelQDpamtpZjeK6+8EtZlSLigbSBlrXqZq8VNB5bqxo4YMcLV1lV27Pjx430DiSnb1//Epl+/fvbmm2+6aP5tt93mArMffvihdezY0TeNDlIFflXsWXXjDj30UDfP4uhSh5yqVq3qyl4UpdsAolv/9AlWJiPV1RytUePv52e1HGILGqf8lRH5d4BN051ULdUOcWVICaQhdPr5ObHSBGs3L9XM71jL63jTsaYqNh1/SzWboMON4w3RS20RNdZV2xaRpe58M2fOtPbt27MrAACIkNGjo3/T6+Luf/7zH3fLj3+tV38KnubX81ulDYL1/PEowKtyTrrY7FHsLPDvKUamm7+HH37YQrF8ec5ydN9++22RllWUOBk4Plaw+X344YeWiIoUtF28eLEbVS5YTS8FVIuTSiHkVQ4h2I79xz/+4W55UabEPffc424oWUq9V+o79WzjzIQJVvHTVOvcxWzmDLMtW7KDZHNaZwfQxLtXhq2CaKrJ3qWLufeZrpcQSEOIkn6cYBdVT7WZlf4+1nTtzgvYesfb3kxzgV3vWCunX7/Uvy4ccLwhSuk3UheaGawz8pQhs2HDhkgvBgAAABJIoYO2L774oov6K0NS9WD9u4fp/8UdtAUQ5f7KUq9V06xHT7N5c80+Lj/EZu5IsdppZrrgl5lptnBHiiuJoAxbBdFq1sz5fiDU483/WNNFgO+Sh9iyCilWdnP2sbZxo9mCrBSzzmYXV0/9+1jjeAMQImWeqHeWujt26tQp14jGDEQLAACAiAdtVf/1/vvvt5tvvjnsC4PElFe3AMSoAQOy78eOdcG0Qx4bYvsrp1jZ8RrIxWzXLrMyZcwNOqYatn3TzSp88lfG47nn/v1+oBDHW62xY63/oWbz2w2xMhtSbH+uY02lFFKs0g9+GbYcb4hymZmZtnfvXnePyNJgIHL00UfneJ6ByAAAABA1QdvNmzfnW24ACNWSJUvsp59+chkrXZRqifjhBV5377aKKSl2lJkdeaRZerp7yiXTJiVlDyTlathW+CvDloAtDuB4K7d7t3VLSbGuWXkda36lEDjeEAP+/PNPmzdvnqttq0FSETkqCwYAAABEddBWAdsvv/zSLrvssuJZIiQMDRqnmsjKIkIcCgjAKmimMeeCjjtHTVGE8XjL91jjeEMM8cYN8B9kFZFx+OGHs+kBAAAQ3UHb1q1bu5Hdpk6dGrSm19VXXx3O5UMc844dgrYAAORG0DZ6KOM5GI3noEzopk2bWoUK6jYCAAAARCho+8ILL7jRjL/77jt3C2y4ErRFqAjaAgCQt3379rn7MirOjIjq2rVrjsF3g7VpzjzzTBs9erQL4gIAAAAlHrRdtmzZAf9RwB18ZbMPPzJtAQDIO9M2v2AhSsYHH3zgBuH997//bb1793bPqS7/448/biNHjnSDxd1yyy12xx132GOPPcZuAQAAQMkHbYFwKV++vLtnVGwAAHIj0zZ63H///fb000/b4MGDfc+pTFjjxo1d2TAFcCtXrmw33HADQVsAAIAY17x5c7v22mvdLZJCGtni+uuvt507d/r+n98NKGymbUZGBhsNAIAAXk8U7/cSkfPzzz9bs2bNcj2v5/SaV0JhzZo1EVg6AAAQDS644ALXQ0o3lU6qV6+epaSk2JgxY3w9qPyDgpru7bffzjWfgw8+2L32yiuv5Jpet0qVKrnHZ5xxhn399dcHtMzLly/3zVe3WrVquQFYJ02adEDzRXiEdBYwe/Zs34mD/p8Xuu+hsJm2NWrUsOTkZMvKyuL4AQDAT506ddw9A1xFXvv27e2hhx5yYzt4PYXUNtZzek1WrVrlTs4AAEAxGTasZDft6NGFfssxxxxjL7/8susxtW7dOhs/frxdc801lpqaah9//HGOi/FNmjRx05511lm+56ZOnWpr1651PXgC3XPPPXbJJZe4xDcFW8eOHWsDBw60e++9126//fYDWFGziRMnumDxhg0bXA+jE044wRYtWhTTbZuMjAxfuy1WhZRp+80337jgmvf/vG4HGuFHYtGXlerC6UbAHwCAnJo2beqyN2vXrs2mibBRo0bZp59+6soh6ORIN/1fzz333HNumt9//90uv/zySC8qAACIIF1sr1+/vjVq1Mi6d+9ut912m3300Uf2v//9L0fmrPzzn/+07777zv7880/fc8rK1fPBelpVrVrVzVttxMMOO8xdTFaZphEjRthvv/3mm+6XX36xE0880apVq+beM2DAAFu6dGm+y632pubdsWNHt8zbtm2zadOm+V6fP3++HXvssValShUXyP3Xv/7lArweZRI/8sgj1rp1a7cNtIwK/nrUM+moo45yWcL6W5deeqnt2LHDvfbll1+6gVy3bNmSY5muueYa9x7PDz/84NZF81DA++qrr/ZVBRBlHyuAfd5557l1198I5X3r169320uvt2jRwt544w2LqaAtAAAAkKj69evnBuNVhkvnzp3dTf/Xc4cccoibRicvGqgMAADAnwKPXbp0sXHjxuV4XsFP1ct/9dVX3eP09HR755137MILLwx5AyqwqZ7LCgx7PX+OPvpoFzhVYuXMmTPd/EIdS2jXrl322muvuf97WaoKpmodunXrZjNmzHDZw8oiVnkGz6233up6ICmI/Ouvv9qbb77py9JVgFTrWbNmTZs+fbq99957LrP3yiuvdK9reZUo+v777/vmp0zld955xwWwRUFnZTGffvrpNm/ePPeagrHePDwaEFbbWlUCtCyhvE9lLRQ4VzKqMqL/+9//ukBuNCh0kbRTTz01aFaknlNkXFH1c845x9q1axeuZQQAAEgoanzv3r3b1UNDdFCmymWXXRbpxQAAADFI5ZQUNAykgKoGMlV5AwUMW7Vq5XpahUo1aOvWrevKJXi9g6pXr25vvfWWL+jatm3bkC5Qly5d2gWO1Q7t0aOHC6bKs88+6wK2DzzwQI6MYGWtqoRCgwYN3ICtmu788893r2s9Dj30UPd/BXDVrlUw2Cv7oGmV3frwww+74K5KRGi6iy66yL3+1VdfuWCxgq3y4IMPugCuNzBYmzZt7JlnnnH1d9XrSfFIUXBZ29Nz8cUX5/u+FStWuCxoDSrbq1cvN81LL71kHTp0sJgM2mrnf/jhhy4Krp0os2bNchtz0KBBLmqtja4N3L9//+JYZsQRXfXRF4JKJOiLBgAAmGvYKgNBvAYkIk+ZI2rcBw6ietJJJ0VsmQAAQPTLaxyf448/3oYNG2bff/+9C4QWJss22Lznzp3rYnGFvfCvWJ4CyyqDcNNNN7lSDt48NE9loao0QiBlsioeuGfPHl+QN9CCBQtc9qt/nV4to0oqqKyDgrYKrKr30urVq61hw4auRMHxxx/vK9WqZVDQ2790gdZb81DPJy/I2rNnzxx/u6D3KeisUhRefFO0Hby/G3NBW9W4UCatouKKwotWVinZykDQyHfKQrj55ptdyjGQH31YlPbuDXQHAACyg7bCIGTRQfVq1dtM9dh0UqT2i3gnSGrLAAAA5EWBS9VLDaSAoUosjRw50tWQ/eCDDwq1ETdu3GhpaWm+easua1Eoa1ZZqLqplILaPQrgqi2q2rNeVmwgZdmqnXSglKSg7FzFFIcPH+62wyt+NYC1DApuqx5tINXP9QQO4FbQ+xS0jWaFrmmrNGGlFXsBWzeT0qXtqquuckWQ1XhVbQjtXKAgXnHtwIwVAAASmbIVxOvqhchScoJOhlTfLCkpyQ3woYwYZXN8++237B4AAJAn1ZbVhV+vq38gZddqQLKTTz7Z1X0tDJUlUEzulFNOcY87depkP/744wElxg0ZMsTFalTbVTSgmto+GuhLJVH9bwqSKtCrYLF63AejLFhlvPoP/qVl1HL7l1ZVtq0yYj/55BP32vHHH+97TcugHk+Bf183rwxEMAW9T1m1ClKrF7hH2b+Bg6LFTNBWK7Nw4cJcz+s5L8tAJxjB0r6BQN5VINVNAQAAOYO2ZNpGhylTpriBx+rUqeNOInRTnTbVVwuWuQEAABK3Dbd27Vo3IJhKiaoOrIKxJ5xwgp133nl5BjU3bNhgL7/8cr7z3r59u5u3Bs3SxeNLL73U7rvvPrv//vtdEFKURLlt2zY7++yz3aBhixcvttdff90FIkOleJ7aNxpYTLGaK664wjZt2uTmqYHEVBLhiy++sKFDh7o4oGKA6m2vsgqqW6vXp06d6pI+vWCsplG9WyV4qtSCEj+VYewNVuZNp22m9VHguEKFCr7XNP/Jkye79ZszZ45bLw2+FjgQWaCC3qegsQYqUzauMp0VvFUd3KJmLEc8aKuNqsLATz75pCt/oJv+r+e8A1BXCA4++ODiWF7EGYK2AADkRnmE6KITEpUBEwVuVW9NmjVrVqiTIAAAEN/Gjx/vSgYoK1XBQAUoNfCVAoVlypTJ8321a9cuMFA4YsQIN28FaBWb27p1q8tuVWDSfz4KqKosgAbbUq3WF198sdA1bhVgVbauSqOqxqwyY9Ue0lhWyuZVD3zVffV64d95551uADAto4LQZ555puuhJOqlpGVS4FdlEBSQVf1bzduf1kvjHakGrQK4/jp37uxijSpnMGDAADcwmv6Wli0/obxPwXI91vY67bTTXDA8WsZcKnRNWwVoFQl/5JFHbN26de45Pb7uuut8B4p2og5OoCAEbQEAyI3yCNGlY8eOrlufSiT06dPHtYPVpU6lwVq2bBnpxQMAIDGMHm3RTDVY/euw5mf58uX5vh7YPb+g6QMDlQoeh9IDXsFlr1a/PwVaFWT1qATCuHHj8pyPgre33367uwWjQK/KRBRE2a556dWrl3355Zd5vp7XNirofRq769NPP83xnILiMRm01ZUBb0co5VqqVauWZxFgIJSg7a5du9hQAAD8hfII0eWOO+7w1WG7++673WAcytZQNosGzAAAAAAiHrT1FxisBYoStFVKfZUqVWz//v05BrgDACBRJScnu25samsdyEASCI/BgwfnyDTRWA7KPtFgIYzjAAAAgKgJ2qamptq7775rK1assIyMjByvqWgwUJjMbWWqEKwFACBnVzXRBU2vHhhKnkZzDsWYMWOKfVkAAACQWAqd1qgCyhohTnVsZ8+e7YoEq2vY77//bscee2zxLCUAAABQwlSXTgOIqK7c5s2b87wBAAAAEc+0/e9//+sGXTj77LNdQ/amm25yAzBo9DX/IsVAYajwtbKJ8htNEQCARJCZmWm7d++2ypUrR3pREt7w4cPtrbfesmXLlrmkhXPPPddq1aqV8NsFAAAAUZhpq5II/fr189Uj3b59u29kNTVqgcJasmSJff7557ZgwQI2HgAg4W3YsMFld/7www8Jvy0ibdSoUbZmzRqXpPDJJ59YkyZN7IwzzrAvvvgi6EjLAAAgPPidRawLxzFc6KBt/fr1fRm1TZs2talTp7r/KwOBDxWKQgOtKMs2PT2dDQgASHg7duxw24BM2+hQoUIF18NswoQJ9uuvv9rBBx9sl19+uas77O0rAAAQvviAEB9ArPOOYe+YLpHyCEcddZR9/PHH1q1bN9dN7LrrrnMDk82YMcNOO+20Ii8IEldSUpK750sZAADzBQKrVKnC5ogyGji1VKlSLlFh3759kV4cAIisUaPM0tKUThae+Y0eHZ75IKapZGKNGjV8A7EqXqDfXoRGbRSV2ipbtizbLYL7QPEtHcM6lg+kDGihg7aqZ6usSLniiivcIGSTJ0+2k046yYYNG1bkBUHiImgLAMDfvNJTVatWZbNEgT179ti4ceNszJgxrmTFCSecYM8++6wdc8wxLogLALEinKfriqHdlRy++QGBPbzFC9yi8OMFeReaETkK2HrHcokFbbXj/RuoZ511lrsBRaXayKKMFZ0YqRsiAACJikzb6KEyCG+//barZXvhhRe68Rvq1KkT6cUCACCuKdjYoEEDq1u3ru3duzfSixNTFLDduHGjS7Dk4nLkqCTCgWTYFjloKxrReN68ee6qh5d161HGLVAY+iKpWLGiO66UQk7QFgCQqPRbqC5tOlmhpm3kPf/8824Mh5YtW9p3333nbsEoExcAAISXgl7hCHwlEsXoFDBUjIWgbewrdNB2/Pjxdt5557mRjQPpBIP6XigKdQHVieq2bdusZs2abEQAQEKXRlDpIDW0Ay+Oo2SpzUvXQgAAAMRE0Paqq66yf/zjHzZixAirV69e8SwVEo66PehqkFcqAQCARKRgbdu2bd3gEYi8V155JdKLAAAAgARV6DOCdevW2fXXX0/AFmGlbocAACQ6lURo165dpBcDAAAAQIQVesjbIUOG2Lfffls8SwMAAAAAAAAACa7QmbbPPvusK48wadIk69Spk+vS7u/qq68O5/IhwezcudPKly+f67gCACARpKWluWxblQuilioAAACQuAodtH3rrbfsyy+/dCPRKePW/4RC/ydoi6KaOnWqO1nt1q2bNW7cmA0JAEgoe/fudb+Fcuyxx1LXFgCAIhg2LLybbfTo+F9HhXXuuiu88wQQgaDt7bffbnfffbfdcsstblRjIFyqVKnigrZbt24laAsASDjbt29397owzkBkAABEiUSIAsuoUeryY5aVFd/rCcSQQkddMzIy7MwzzyRgi7CrXr26u1fQFgCARLNly5Ycv4cAAAAAElehg7bnn3++vfPOO8WzNEho/kHbrHBd3QMAIEZs3rzZ3desWTPSiwIAAAAg1soj7Nu3zx555BH74osvrHPnzrkGjHriiSfCuXxIsPIIKrmRmZlp6enpbiAWAAASxaZNm9x9rVq1Ir0oAAAAAGItaPvzzz+7gaJk/vz5OV5jlGMcCAVsq1at6jJtt23bRtAWAJAwdu3aZbt373ZtqRo1akR6cQAAAADEWtD2m2++KZ4lAf4qkaCgrW4NGjRgmwAAEqo0QrVq1axMmTKRXhwAAAAAsRa0BYpT/fr1rUKFCla3bl02NAAgYdSuXdu6d+/OQK8AAAAAChe0Pe2000Kabty4caHOEsilXr167gYAQCLRBctGjRpFejEAAAAAxFrQVt3WAQAAAAAAAABRErR9+eWXi3dJgL9kZma6EbTLlStnNWvWZLsAAOLa9u3bbd26dVanTh0GIQMAAADglLYYoSDeP//5TzdAh0ZVvuiii2zHjh35Tn/VVVdZu3btrFKlSta0aVO7+uqr3QBX/jRKc+Dt7bffLoE1Ql5+//13mzZtmrsHACDeKWC7YMECW7JkSaQXBQAAAECUiJmByBSwXbNmjU2YMMH27t1rQ4cOtUsvvdTefPPNoNOvXr3a3R577DE76KCD7I8//rDLLrvMPZeampori/iYY47xPVZQGJGjTKPffvvNNmzYYFlZWS6QDgBAvNq8ebO7r1WrVqQXBQAAAECUiImgrbJPxo8fb9OnT7eePXu65/7zn//Ycccd54KyDRs2zPWejh072vvvv+973KpVK7v//vvt3HPPdd3vy5YtmyNIW79+/RJaGxRE+6NMmTKWkZHhuowquxoAgHil3kFCSSAAAAAAMVUeYcqUKS6Q5wVsZeDAgVa6dGnXjT5UKo2gAKB/wFauuOIKl93Zu3dvGzNmjMvuRORov9auXdv9X9m2AADEq507d7qLlPrtY9DXxDBq1Chr3ry5VaxY0fr06WM//fRTSO9T+S71PjrllFOKfRkBAAAQeTGRabt27VqrW7dujucUeFU3Qr0WCgX/7r33XldSwd8999xjRx11lCUlJdmXX35pl19+uauVq/q3edmzZ4+7ebZt2+bu9+/f724IjbaVAuTBtpm3b9evX+9ObBC7+xKxhX0ZH9iPsUPtE+0vrzRT4Pco+7LoovE36Z133rHrr7/enn/+eRewfeqpp2zw4MGuLFRgW9ff8uXL7cYbb7QBAwaU6PICAAAgQYO2t9xyiz388MMFlkY4UAqqHn/88a627V133ZXjtTvvvNP3/27durmMl0cffTTfoO2DDz5od999d67n09LSbPfu3Qe8vIl0MqXsZwX7lGHkT8/pNQXQmzVrRl3bGN6XiC3sy/jAfowdCtbp+1OlEXShMhD7suhUYinaPPHEE3bJJZe4sRlEwdvPPvvM9fRSuziYffv2ubEd1PacNGmSbdmypYSXGgAAAAkXtL3hhhvsggsuyHeali1bunqzgScyqkurGnAF1aJVg12DjFWtWtU++OADK1euXL7TK+tBGbnKpK1QoULQaW699VaXJeEfFG7SpIklJydTf7UQdCKqbn7aboGBPj2nUbQ16Fz58uWp8xfD+xKxhX0ZH9iPscMri6ALy8EGImNfFp3KD0QTlcGYOXOma0f673+V/FIpsLyoV5iycC+66CIXtAUAAEBiiGjQVgEe3QrSt29fl1Wghm6PHj3cc19//bU7kVGQNS8KpqrLmYKvH3/8cUiN9zlz5rgAYV4BW9FrwV5Xw5uAVeEo0JfXdlMNY5WtqFKlSiHnimjbl4gt7Mv4wH6MDSrRtHnzZhew1T4Lhn1ZNNH2e6RSGMqarVevXo7n9XjhwoVB3/PDDz/YSy+95NqnoYqGMl55HMpFnNd+02gT+8M50zBth3Aukuy3cM9wf9StY7Tuz6jfl1G4ntG6L2Nif0bZvoz2/YnCbnZKF8aCUNtkMVHTtkOHDi5bVt3J1I1M2ZdXXnmlnXXWWdawYUM3zapVq+zoo4+21157zQ0opgbqoEGDLD093caOHesee41WBYrLlCljn3zyia1bt84OOeQQF9CdMGGCPfDAA65mGCIvv9puAADE2+CbQGBvsX/961/24osvugFzQxUNZbxCyMkoVCBhS7XqlqWLw+EaLDhIKZJIr6est3DPcH3UrWO07s+o35dRuJ7Rui9jYn9G2b6M9v2JwqG0VnyV8YqJoK288cYbLlCrwKxOcE4//XR75plnfK8rkKu6cArSyqxZs2zatGnu/61bt84xr2XLlrnBrVQqQSP4Xnfdda4Wp6bzao0BAAAA4aLAq5IGlDDgT4+DlftaunSpG4DsxBNPzJWVoQF51e5t1apVVJbxSksLbyChRtZWS96wIXyBhDAlBoRzPaWuhXuGdaNuHaN1f0b9vozC9YzWfRkT+zPK9mW0708UDqW14quMV8wEbdVt8M0338zzdQVhFXj1HHHEETkeB6PsXd0QvZRBvXbtWmvRokXQWn8AAMSiXbt22eTJk12w7uCDD4704qAEqEa/ynx99dVXdsopp/hOrPRYiQmB2rdvbz///HOO5+644w6XmfH000+7QGy0lvEK1/m+R511FUQIWyAhTNsh3OtZ2sI9w9JRt47Ruj+jfl9G6XpG476Mif0ZhfsymvcnCo/SWtEv1DZZzARtkZg0AN3q1autcuXKBG0BAHH1+6beQarZj8ShDNjzzz/f1e1XOa+nnnrKdu7caUOHDnWvn3feedaoUSNX4kAZGB07dszx/ho1arj7wOcBAAAQfwjaIqqpK9/KlStd10FlnAAAEA+8LvLUb08sZ555pqstO2LECNeTqGvXrjZ+/Hjf4GQrVqyIugHUAAAAEBkEbRHVdBKj1H7VY9uxY4dVqVIl0osEAMAB2bdvn23YsMH93wvWIXGoFEKwcgjy7bff5vveV155pZiWCgAAANGGS/mIahosTtm2smbNmkgvDgAAB2zjxo0ucKvu7yU1MBQAAACA2ELQFlGvQYMG7l61bQEAiJfSCGTZAgAAAMgLQVtEPY2s7ZVI0GAdAADEMoK2AAAAAApCTVtEvfLly1udOnVcV9K9e/dGenEAACgy/ZYpw1Y1bfXbBgAAAADBELRFTOjduzejKQMAYl6ZMmWsU6dOkV4MAAAAAFGO8giICaVLc6gCAAAAAAAgMRAJQ0xReYTt27dHejEAACi09PR0S0tLs6ysLLYeAAAAgHwRtEXMWLt2rX3xxRc2d+7cSC8KEPcUU9qxw2zjxux7YkzAgfvjjz9s6tSp/I4BAAAAKBA1bREzatSo4bKTNm/ebLt27bJKlSpFepGAuJOebqbrIl99ZbZokVlmplnZsmZt25oNHmzWt69ZUlKklxKIPfr9Wrlypfu/BiIDAAAAgPwQtEXMqFixotWqVcs2bdpka9assZYtW0Z6kYD4MWmSLV+42+6ZcrTt32+2fLlZrVrZAVoFbqdNM5s61axVK7OR/SZY8/YVzQYMiPRSAzFj48aNtnv3bitXrhxBWwAAAAAFImiLmNKgQQOCtkC4TZpkm/4z1hbPMKtRNcsqHNfZKlbMWRIhOdksI8Os5owJtvi7VKvW06yWXiBwC4TEy7Jt2LAhg2sCAAAAKBBBW8QUnez+8ssvLnCrjCVl3wI4AJMm2d5Xxtq8uWa7dpmdXGmcLdyyzzbb4FyTdlk/wbpnptqWXeam7//KWCunFwjcAvnat2+frV692v2/cePGbC0AAIBIGDYs/PMcPdqizqhRZmlp4RuYJBrXMUEwEBliskSC/Pnnn5FeHCD27d5t69eZbdtmVq1a9lOt1k229isn5pisw8oJ1v33VPd/Tafp9T69H0DBA2kqcJuUlOT7DQMAAACA/BC0Rcxp1qyZuydoCxy4rIEp9nnSEPf/0n6/CN2WjXOB2sCArf90ep/eDyB/GzZscPdk2QIAAAAIFeUREJN1bTMyMjj5BcJg506zzzJSrFsrsyM3/h2YFQVqO6yaaJX2bMn1vtmthtjsjBQ7J92scuUI7IpJk7KzfFNCCBpPmKA0fco4IGK6dOniLjhS0gcAACBy1QxGJ8B6lipldldy+OaHyCJoi5hTpkwZa9myZaQXA4gLe/aYZWaa/dIwxapXN+u2/P0crwcL2M5qOcR+qZxi+3Zlx01LPGirgO3Ysb6HyvZV8FnrUqFC9vKoseIL2Kb6BaOpv4sIqVGjBtseAAAAQMgI2iLmZWVlWSlfhAZAYSjIWbZsduB2QeMUs1JZ1tEm5Tm9AraaLjNNF1CyE1gjFbDdm2m2/ulU+/zF7GxhrYPWpW1bs8GDzfqnT7CKn/oFbL1AL4FblKD9+/dbaf/aIwAAAAAQAs4iELPS0tLsxx9/tCVLlkR6UYCYpaxUBTk3bsx+vLDxQMsoGzx1dleFGtmBXcueXu9LSirJpf174LNNm81+/MFs5kyzepNSrduGCW5ZFBubNs3ss2sn2NQbU910wd4PlIRt27bZF198YT///DMbHAAAAEChELRFzNqzZ49t2rTJ/vjjD5dtC6DwlKSurFR9hDIyzNqvnGjlM3cGnValEjQomabT9Mcc41eGoKSkpNjynkNs5gwFxMyqVVO38+x6vP12TrDkZLNTq0ywkzJS3euazhe4HTIktBq4QJhowMzMzEzbzcUCAAAAAIVE0BYxq2HDhlauXDnbtWuXy7oFUDR9+5q1amVWc8YE67ZsXL7TanAyTafpDzmk5Ld4errZ3ZNT7H+Vh7hgrX+vcy3badNudvd6Xq/v2mU2b67Z7hMI2KJkKViroK00bdqUzQ8AAACgUAjaImapRmCTJk3c/5VtC6BoVFZgZL8JduzOVNuyxSxrf86SCJ79+829runu6p9djqCkTfn/9u4DTqrq/P/4s4Vd2IUFlt5770UQsFPFGDVirFH5G/xZo9FYSFQsQdQYYzREo7ElQjQSNaIGg4qN3kF67x2Wso2Fnf/re9Y7mV12l2WZ3Sn7eb9el9mZuTNz556Z4dznPuc5M83WrTM70Huwq69bUMGJ05SJ+1HCCJuRTIYtypcCtjk5OZacnGx169Zl9wMAAAA4JQRtEdGaNWvmLnft2sXwU6C0pk615vMmWa/eeUFOZbMqODut1gh7re3T7lLXvXIEvXubNZs7yT2uPKkkw2ef5ZVkSEjImzitsMBtoEWtR9j81ME2ZUre44HyoJI9GzZscH+3bNmSyTIBAAAAnDKCtohoVatWtdTUVHeAvHnz5lBvDhB5FHidNMn9mVrTrP8As9atzXaf9RNbWHuwKy+gy11nj7BevczOOsusZs0fHjupfAO36elmq1eb1ar1v9sUuA3MBi5s4jStr8cpGA2Uh927d1t6eror4dO4cWN2OgAAAIBTFn/qDwHCS/Pmzd2EZAratmnThowm4FRUrpzvaqV4s1oX97f/N2SQXZNlpvmTtEpS0mCL+fyHQG0xjy9L2dmqE5pXzsGjidEKlkQoOHHageS84LPeS3JyuW0uKjAvy1a1bOPj6WoBAAAAOHUcSSDiNWjQwOrXr2+NGjUK9aYAkefss/Mu33477/InPzHr2tWVIFCAM1+Qc/APdWG9wO111/3v8eUgMdFM8S8FbkUBWU06Vhzdf7BWXrZwOcaXUcF1797dNm7c6C/hAwAAAACniqAtomJCsjPOOCPUmwFELi/wqlTUgQM1trvodb3ArSKg5RiwFQWQ27Y1mz3b7JzswgO2KolQMPO2x7pJ1rBhXrYwUB4qV65s7du3Z2cDAAAAKDWCtgCA/wVgc3NPvje8wG05U/bv0KFmx/4z1brvnHRCVXZNSqYatoEZuN7bGZ4xKa+8Q4i2HQAAAACAU0HQFlEjJyfHDUfNzMy0rl27hnpzAJSBARlTLe7oJDt0yKxGjRMDtuJdKnCr9VJSzOrWCyjrQOAWZWTNmjWuxnrbtm2tpn/GPgAAAAA4dQXylIDIlZWVZStXrrRNmzbZ4cOHQ705AMpA5RqVrWs3sypVzNLS8jJpAwO2nsV1B9uH8SPcet265U2wlvcEFLZF2cjNzXUTkO3evdsyMjLYzQAAAABOC0FbRI1q1aq5Cclk7dq1od4cAGXh7LMt9c7rrFfvvAzajxJG2AdHBtuePWYHDpi7XLnSbN06swO9B1vbX48wf8JjOU+chopl+/btlp2d7erZaoJMAAAAADgdlEdAVGnTpo3t3LnTtm3bZu3atbOkpKRQbxKAsgjcmtmZaVmWmzzY4qeYrV5tlplpFhdn1rev2bBhZv36KSN3sFmz0Eychopl/fr17rJ58+ZugkwAAAAAOB0EbRFVatSoYXXq1LE9e/bYunXrrEuXLqHeJABl4eyzTYUOLjCz888302j0rKy82KzO1WjSMj9q2KKM7du3zw4ePOiCtc2a6SwBAAAAAJweUkEQldm2snnzZjdUFUB0U4A2OdmsVq28y3wBW6AcrFaqt5k1adLEEhIS2OcAAAAAThtBW0SdWrVquVm7NSmMN1wVAICyyrLdu3evy7L1ThoCAAAAwOmiPAKiUtu2bV1d28aNG4d6UwAAUSw1NdW6devmRnZUqVIl1JsDAAAAIEoQtEVUqlu3rlsAAChLMTEx1rRpU3YyAAAAgKCiPAIAAEApqAwPAAAAAJQFgraIakeOHLGFCxfahg0bQr0pAIAosmPHDvvyyy9dKR4AAAAACDaCtoj6CWK2bt1qa9assWPHjoV6cwAAUcDn89mqVassMzPTnRwEAAAAgGAjaIuo1qRJE0tKSnITxKxfvz7UmwMAiALbt2+3w4cPW6VKlaxly5ah3hwAAAAAUYigLaJabGysdejQwf29du1ay8rKCvUmAQCiIMtWWrVq5QK3AAAAABBsBG0R9Ro2bGg1a9a048eP+w+0AQAoDZXcSU9Pt4SEBGvRogU7EQAAAECZIGiLCqFTp07ucvPmzXbo0KFQbw4AIALl5ub6T/61bt3a4uPjQ71JAAAAAKIUQVtUCMq0VcatVyYBAIBTtXv3bjf5WOXKla158+bsQAAAAABlJmKCtvv377drr73WUlJSrEaNGnbTTTeddMbm8847z2JiYvItt9xyS751lHl50UUXucmq6tata/fdd58dO3asjN8NQkG1bdu2bWtdu3alAQAAp6x+/fo2YMAA69Kli8XFxbEHAQAAAJSZiBnXp4Dtjh07bOrUqZaTk2MjR460m2++2SZOnFjs40aNGmWPP/64/7qCsx7VOFXAVgdhM2bMcM9//fXXu0lFnnzyyTJ9Pyh/avt27dqx6wEApZaamsreAwAAAFDmIiLTdsWKFTZlyhT761//an379rWzzjrLXnzxRXvnnXds+/btJw3UKSjrLcrU9fz3v/+15cuX29tvv23du3e3Cy+80J544gkbP368HT16tBzeGUI5+3dGRgYNAAA4Kf1/obIIAAAAAFBeIiLTdubMma4kQu/evf23DRo0yGJjY2327Nl22WWXFfnYCRMmuKCsArYXX3yxPfzww/5sWz2vhjjWq1fPv/7QoUPt1ltvtWXLllmPHj0Kfc7s7Gy3eLyJrTRBiRaUjPaVgqflvc904D1v3jx3ecEFFzCRTAS3JYKPtowOtGNwLVq0yJVp0glerz56eaEtT2/fAQAAAJEqIoK2O3fudPVmA2nGZg1R1H1Fueaaa6xZs2buAGvJkiX2wAMPuFmf33//ff/zBgZsxbte3POOGzfOHnvssRNu37Nnj2VlZZ3y+6vIB1MHDx50wT4F4MvzddVWypyaM2eOmwEckdmWCD7aMjrQjsGza9cuN4Glfts0CkeTkZUn2rL0Dh8+HMSWAAAAACpQ0PbBBx+0p59++qSlEUpLNW89yqht0KCBDRw40NatW2etWrUq9fOOHj3a7rnnnnyZtk2aNLE6derkK7+Akx+IanI47bfyDvT169fPZdumpaW5NtNM4IjMtkRw0ZbRgXYMDtW+10nf6tWrW5s2bax58+ZW3mjL0uP/dgAAAESykAZt7733XrvxxhuLXadly5autEHBzJZjx465oYq6r6RUD1eUMaOgrR6rTMuCGTVS3PMmJia6pSAFqwhYnRoF+kKx3xo1amQbN250n6HVq1e7Ia+IzLZE8NGW0YF2PH36/0HlkJKTk91ElqH6faMtS4f/jwAAABDJQhq0VVaelpJkRSojcv78+darVy9325dffumyT7xAbElr0okybr3nHTt2rAsIe+UXpk6d6jIvO3bsWMp3hUihNv7uu+9sy5YtLlO6Vq1aod4kAECYSE9PdyNzpHPnzhYXFxfqTQIAAABQgURESlyHDh1s2LBhNmrUKJcZO336dLvjjjvsqquu8k8Ism3bNmvfvr0/c1YHWk888YQL9Cqj8qOPPrLrr7/ezjnnHOvatatbZ8iQIS5w97Of/cwWL15sn332mT300EN2++23F5pJi+hSs2ZNV/NY1P4aBgsAgCxdutSdHNZJ3VMZ1QMAAAAAFSZoKxMmTHBBWdWkHT58uJ111ln2yiuv+O/Pyclxk4xpcilJSEiwzz//3AVm9TiVYrj88stt8uTJ/scoa+bjjz92l8q6ve6661xg9/HHHw/Je0RoTgio5p0+L/oMAQCgSRVr1KjhJj1Vli0AAAAAVKjyCKciNTXVJk6cWOT9mhxEB1keDXf/+uuvT/q8yrT89NNPg7adiCyVKlWy/v37W1JSkqsZCACA/j/QCV/Vv9f/EwAAAABQ3iImaAuUFU0wAwBAQQRsAQAAAIRKxJRHAMqaatquWLHC1q9fz84GgAo6+Zjq5mvyUwAAAAAIJYK2wA927txpa9eutZUrV7oDdwBAxaESS4sWLbL9+/e7GvkAAAAAEEoEbYEfNGrUyGrXru0ybpcsWcJ+AYAKRKMsFLDV5GNdunQJ9eYAAAAAqOAI2gIBunbtarGxsbZ3717bsmUL+wYAKoDDhw+7URbSqVMnNzklAAAAAIQSQVugwKRkmjFcli1bZtnZ2ewfAIhiubm5tmDBAndZr149a9q0aag3CQAAAAAI2gIFtWzZ0qpXr245OTn2/fffs4MAIIqtXr3aDh06ZAkJCdatW7dQbw4AAAAAOGTaAgXExMRY9+7d3eXu3bstMzOTfQQAUTr52IEDB/zlcRITE0O9SQAAAADgxOddAAiUkpLiAre1atWyKlWqsHMAIArp5NyZZ55pe/bssbp164Z6cwAAAADAj6AtUITGjRuzbwCgAgRuCdgCAAAACDeURwBKQGUSNmzYwL4CgCigzNqlS5fa8ePHQ70pAAAAAFAoMm2Bk0hLS7PZs2e7bCxNUJaamso+A4AIpUkmFy1aZFlZWW7ysXbt2oV6kwAAAADgBGTaAidRo0YNa9SokZuwZsGCBe6AHwAQmZRhq4BtcnKytW7dOtSbAwAAAACFImgLlIBmFdcBfmZmpsvQAgBEnu3bt9u2bdvcyImePXtaXFxcqDcJAAAAAApF0BYogfj4eOvVq5fFxsbazp07bePGjew3AIgg6enptnjxYvd3mzZt3CgKAAAAAAhXBG2BElI92w4dOri/ly1bZocOHWLfAUAEOHbsmM2dO9ddqi65grYAAAAAEM4I2gKnoGXLllavXj3Lzc11GbcAgPCXkZFh2dnZVrlyZf+oCQAAAAAIZ/Gh3gAg0nTv3t327t1rDRs2DPWmAABKICUlxc455xx/4BYAAAAAwh1BW+AUJSQkELAFgAjg8/ncpGNSpUoVtwAAAABAJGB8IHAalLU1b948O3LkCPsRAMJIVlaWTZs2jVI2AAAAACISQVvgNHz//fe2Y8cOmzNnjh09epR9CQBhQHXHdUItPT3dVq1a5TJuAQAAACCSELQFTkPnzp0tKSnJBQYUIFCgAAAQ+hNqBw4csEqVKtkZZ5zhL5EAAAAAAJGCoC1wGhITE61Pnz4WHx9v+/bts6VLl7I/ASCEtmzZYps2bXJ/9+zZ051YAwAAAIBIQ9AWOE3VqlVzgQFlcm3evNnWr1/PPgWAEDh48KAtWbLE/d2uXTurW7cu7QAAAAAgIsWHegOAaFCvXj3r2LGjLVu2zC3JycnuNgBA+VBd8blz57oyNfr9bdOmDbseAAAAiFb/93/Bfb6//MXCDZm2QJC0bNnSmjZt6gK2WgAA5UdlaurXr+9+f3v06EEdWwAAAAARjUxbIIi6dOlix48fd5PfAADKT2xsrJscMicnh99gAAAAINoTYy36kWkLBPMLFRubL1ig2cs1VBcAUDa2bduW73eWk2YAAAAAogFBW6AMZzCfPn26LV68mH0MAGVg3bp1tmDBApszZ475fD72MQAAAICoQdAWKCNVqlRxl1u3brU1a9awnwEgyBm2y5cvd3/XqVOHGrYAAAAAogpBW6CM1K5d29W4lZUrV9r27dvZ1wAQBHv37rVFixb5J4Fs1aoV+xURY/z48da8eXOrXLmy9e3b12WKF+XVV1+1s88+22rWrOmWQYMGFbs+AAAAogdBW6AMNWvWzFq0aOH+Xrhwoe3Zs4f9DQCn4dChQzZ37lxXx7Zhw4bWsWNH9icixrvvvmv33HOPjRkzxpX26Natmw0dOtR2795d6PpfffWVXX311TZt2jSbOXOmNWnSxIYMGeIyzQEAABDdCNoCZaxTp07WoEEDF2BQoGHfvn3scwAohYyMDJs1a5YdO3bMjWbo0aMHZREQUZ577jkbNWqUjRw50p1wePnlly0pKclef/31QtefMGGC3Xbbbda9e3dr3769/fWvf3X9iS+++KLctx0AAADli6AtUMZiYmKsZ8+eVrduXTt+/HiR2TRAufj2W7OpU/PdpPmbjhwx0/kEXfrnc9J6Wh8IE1lZWe53NCUlxXr37m2xsXRjEDmOHj1q8+fPdyUOPPoM67qyaEt64iInJ8dSU1PLcEsBAAAQDuJDvQFARaCDMgUYNJyxadOmod4cVFQKwL79tv9qxoDBpjjBZ5+ZrV5tduyYWaVKZn36mA2N+9y6rPqXVfL+lzj77JBtNuBRoGrAgAGWkJBglfRhBSKsFrNOOtSrVy/f7bqu2vcl8cADD7iyIIGB34Kys7PdElhSRJShq6U8xMQE87lyTecSc4P5pEHaD8HcJMm1YD9hbti9x3Btz7BvyzB8n+HalhHRnmHWluHcnmHflmH4PsO1LSOiPXPLp5+U91Iley2CtkA5iYuLyxew1ZdUB1VVqlShDVDuAdv9r06y1541m5w52P3nWauWWVKS2fHjZrkLFtqWGf+2Q1XNunYzS/UeR+AWIeDz+SwzM9MNIRdl2QIV0VNPPWXvvPOOq3OrScyKMm7cOHvsscdOuF119ZWtXh7q1AnuwWdaSnXzxcRYrH8oyGkK0qinYL5P2W3BfsLdYfcew7U9w74tw/B9hmtbRkR7hllbhnN7hn1bhuH7DNe2jIj23F1+o6IPHz5covUI2gIhoEybefPmuewXZY15wQigzAQcqO8/YDZ/nlm7zElmXc3WNh/sv6/Dts+tc8IMi0sxO5SWt16v3map5XSgDxQM2GoSR5WV6dOnD0PCEdFUh1kncHft2pXvdl2vX79+sY999tlnXdD2888/t65duxa77ujRo91kZx71NTSBWZ06dcrtpEcw513VwWcN30Grs3dv8A4+69YNytMEe37ZuhbsJ6wbdu8xXNsz7NsyDN9nuLZlRLRnmLVlOLdn2LdlGL7PcG3LiGjPusF5nyVR3An4QARtgRAFbVWXThkvqmOnwG1Jv7RAqQzOC8zmvDPJliw2y8w0q1HDrO/mSa4EworGg63D1qnWY+P7ltOujqlUqO5PSzN77eAIu33AYOPUAsqTRiMoYLt9+3ZXG1z1QIFIprIevXr1cpOIXXrppe42b1KxO+64o8jHPfPMMzZ27Fj77LPPXKmlk0lMTHRLYaWayqsOdLCOET0a/KgDz6AdfAZpPwT7fcZasJ8wNuzeY7i2Z9i3ZZi+z3Bsy4hozzBsy3Btz7BvyzB9n+HYlhHRnrHlN19GSftkzOABhOjArV+/fi7DVsFbBW4JSKDMDR5s37cbYSpvGJhs1XP9JPvJ7AfcZUGruo5wJRRmzaJ9UH4UyFqwYIEL2Ho1wU+WiQhEAmXAvvrqq/bWW2/ZihUr7NZbb7X09HQbOXKku//66693mbKep59+2h5++GF7/fXXrXnz5rZz5063HNGskQAAAIhqBG2BEFFmrQK3utTBlwK3mhEaKCs6s/mPvYPt6zojTjiJWCU77YT1F7Qc4UonqObtlCllc0YfKCxgO3/+fNuxYwcBW0SdK6+80pU6eOSRR6x79+62aNEimzJlin9yss2bN7vPvuell15yJ3VHjBhhDRo08C96DgAAAEQ3yiMAIaRM2/79+9v06dNdzbnZs2fbmWeeafHxfDURfOnpZqtXm8W2HmwLsvMybIuysMVPbEWjvJIKmqRMj8vIMEtOpmVQtgFb1ftWjU9l2J5xxhlWtxxrSwHlQaUQiiqHoEnGAm3cuJFGAQAAqKDItAVCLDk52QVqK1Wq5GYQZMgjykp2ttmxY2bxP9SwzUysUeh6R+OTbWXjQf7rWv/48XxzmQFlNvGYArcK2GriMQK2AAAAACoq0vmAMKDZnBW4VcCihmZ/AsqA5qVRAFaBW006VlhJBEk4lm7tt35uKxoNcde1flycSnrQLChbcXFxLrtWJ7D4LQQAAABQkZFpC4QJBShq1qzpv56WluYmKQOCRaUN2rY1a7F2arGlEaTHhvddYFf27ct7XFISbYHgO378uKvjGRi4JWALAAAAoKIj0xYIQ8oymzVrlgteKAO3WrVqod4kRAFNKHZ17am2Zc8ky02xfJORqVRCwcxbBXZzjpmt8A22YcPyHg8EO2CrWt779u2zrKwsa6uzAwAAAAAAMm2BcKT6tpUrV3ZBDE1SduDAgVBvEqLB1KnWedUkS0kxO3TofzcvaDnC3u/7tLssqN2SSXZxlal25pnlu6mIfseOHXMnpxSw1eSLtWvXDvUmAQAAAEDYiJjyCPv377drr73W1f7UsMmbbrqp2AmbNNtuTExMoct7773nX6+w+995551yeldA4RSwHTBggCuXkJOTYzNnzrQ9e/awu1B6U6eaTZpkleLNunYzq1JFJTjMZjcd4SYlE10ubPET93dubt79Wu/n1SdZ0vS8UglAMGRnZ7uArf5vV8BWIwpSU1PZuQAAAAAQaUFbBWyXLVtmU6dOtY8//ti++eYbu/nmm4tcv0mTJrZjx458y2OPPWZVq1a1Cy+8MN+6b7zxRr71Lr300nJ4R8DJs2379evnZk/XEOI5c+bY9u3b2W0onYBZxFJrmvXqbbaq6wibnDnYVq400zkBJXR/mzjIZsf1d5m4ysjt3dvMlVpmFjIEiU64fvfdd24Egfc7F1jPGwAAAAAQITVtV6xYYVOmTLG5c+dab0UQzOzFF1+04cOH27PPPmsNGzY84TGqBVq/fv18t33wwQf205/+1AVuAylzt+C6QDjNpL5o0SLbtm2bzZ8/32WlKZALnJKzz867fPttd5E6aoTdPmCw9ZplNmWK2erVZpmZZvHxZrG9e1iTM+Ks66p/uet23XX/ezxwmiURVPLl6NGjlpSUZH379j3h/2QAAAAAQIQEbTU0XIFVL2ArgwYNstjYWDeByWWXXXbS51CwS4Gv8ePHn3Df7bffbj//+c+tZcuWdsstt9jIkSNdmQQgHOhz3qNHD5eRpgnKqPuIUvMCr1lZZoMHW5KZXXCB2fnnm2Vk5N2ckKBMSLN69QZZ7BcxeRm2BGwRJDrp1KFDB9u8ebP16dPHEvSBAwAAAABEZtB2586dJ2QW6sBP9e90X0m89tpr7kCxf//++W5//PHH7YILLnAZP//973/ttttuc0M3f/GLXxRbi0+L59APM/rk5ua6BSWjfeXz+dhnJdSpUydXJsHbd6L9Fw4nGGjLCDJgQN5lgd8q1a7VorY8cuSH7+XAgYWui/AXbt9JZdZ6AdrGjRtbo0aN3G9XuGxfOAu3towk7DMAAABEspAGbR988EF7+umnT1oa4XRlZmbaxIkT7eGHHz7hvsDblM2Ynp5uv/vd74oN2o4bN87Vxy1IE0VlKVUNJT6YOnjwoDsYVTYpTs3q1astIyPDOnfu7E5ihBJtGT1oy+gQLu2o7Vi+fLmlpaWRWRvhbRmJNDoFAAAAiFQhjfTce++9duONNxa7jkoWqN7s7t27T6iLp1mnS1KLdtKkSS64df311590XdXXe+KJJ1wmbWJiYqHrjB492u655558mbaa+KxOnTqWopl7UOIDUWVaab9xIHpqlA2ug3jtwzVr1ri6t8oWDxXaMnrQltEhHNoxJyfHlSbSyVBl2apGN/W4I7MtI1VlJlAEAABABAtp0FYHIFpORjNLK0tHB3+9evVyt3355ZfuQEZB1pKURvjxj39cotdS3VvNYl1UwFZ0X2H362CKA6pTowNR9tup08mBAQMG2Lx581wAVxP76LsRynq3tGX0oC2jQyjbUSNcVHNemY6qx63fp3r16pX7dkQLvpOlQ58MAAAAkSwiUjZUi3bYsGE2atQomzNnjgtQ3XHHHXbVVVdZw4YN3Trbtm2z9u3bu/sDrV271r755hs30VhBkydPtr/+9a/2/fffu/Veeukle/LJJ+3OO+8st/cGlJZqOp9zzjlukj7Vi5w1a5Zt2LCBHQogpDQK4Ntvv3UBW2U66gQTAVsAAAAAiMKJyGTChAkuUDtw4ECXOXH55ZfbCy+8kG8Y5qpVq1wZhECvv/66m/RkyJAhJzynsn/Gjx9vv/zlL12tuNatW9tzzz3ngsNAJFBARJPrLVmyxLZu3epOQGgosurcAkB5U9kinUDSpIkaEdCnTx+rohnuAAAAAADRGbRVVqEmEytK8+bNXeC1IGXOaimMsne1AJFMdSI1iZ4CJJq4r1atWqHeJAAVVLVq1Vz5oOTkZOvdu3fIJ0kEAAAAgEjF0RQQJVq1amUNGjTINyGZ6j5T0w9AWdJIF41cEV2qDr1GAfDbAwAAAABRXtMWQMkEBmyzsrLchH0qmwAAZWHv3r02bdo027RpU77fIQK2AAAAAHB6CNoCUUqTkmkG94ULF9qyZcsKLR8SVMuWmX3+uf+qXu7IEbN9+/Iu87381Klm335bttsDoMzo92TNmjWufm12drZt3ry57H9jAAAAAKACoTwCEKXat2/vst1Wr15t69evdzO69+zZ0w1bDrrvvjP76iuzPXssKzvGpicNts8+M1u92uzYMTOVtWzb1mzoULMBGVOt8seT/vfYs88O/vYAKDNHjx51J4N2797trjdp0sS6dOliMTEx7HUAAAAACBKCtkCUUgClXbt2boIyBVj27dtnX331lXXr1s3Vvg0aZcxqksA6dezAAbOlv5pknySYzU8dbJoTTRUbFLidPdvs2H+mWtzRSda1m1lqTTN7++285yBwC0SEAwcO2Lx581z5FZ0U6tq1qwvaAgAAAACCi6AtEOUUoFXgdsGCBZaWluYCLsq4bdSoUXBeICvLXRw+YrZhvllWutmPUyZZ06pmK+oM9q92TvZU675zkh06ZDZ/nlmv3j8Ebn94PIDwpkDtjBkz3ASHycnJ1rt3b/fbAgAAAAAIPmraAhWAAiwDBgywNm3aWLVq1ax+/frBe/LBgy1r+E9s4wazzEyzGjXMYmPNeq6fZB22TnWr6FLXdbvu13pLFptl/WiEezyA8KfSKm3btrWGDRvaOeecQ8AWAAAAAMoQmbZABaGhzKpzq6CLN7O7Jg7aunWrNW7c+LTqUc5IGmRz4o9b/5R/57vdBW63fW5VstPy3a7kvI8SRlhu8mC7oNSvCqA8yiEkJCS4Ez/SunVratcCAAAAQDkg0xaoYLyAraxbt84WLVrkhjxnKv21FDRh/H//a7a2Wg9b3OonJ9xfMGAri1qPcDVvp0zJezyA8HL8+HFbvny5TZ8+3ebOneuuC5ONAQAAAED5IGgLVPDhzvHx8bZ//377+uuvbdu2baf8HOnpZmvWmFWrZray8SBb0HJEsevr/hWN8yYpW73aLCPjNN4AgDLJrv3mm2/cSR1l41evXt3VsQUAAAAAlB/KIwAVmMoi1KxZ0xYuXOgCNZqsbPfu3dalSxcXzC2J7GyzY8fM4uLyrisgW1hJBMlMrOHuFz29kns1D9kPI68BhJCyaVetWuWCtZKYmGhdu3YNbg1sAAAAAECJkGkLVHCqVdm/f39X61ZDn1XjVlm3Bw8eLNHjExPzArA/jJ52k44VFrAV3e5NTuYFeitXDt57AVA6WVlZ7nvvBWx1Quf8888nYAsAAAAAIUKmLQBX57Zdu3ZWp04dl22rAE6clzp7EsqSbdPGbM8es257Pree6/9V7PqanExWHhlsffuaJSXRAECoKatWi7JtlV1br169UG8SAAAAAFRoBG0B+KWmptq5555r+/bts6pVq/pvV+kElVEoTEyM2ZAhZrNfXmjd1v270JIIBTNvu6+dZJsTzIYNG+weD6D86XudkpLiTtAoy75nz56uLEqlSpVoDgAAAAAIMcojAMhHAZvAGpZpaWn23Xff2YwZM+zIkSOF7q3+GZ9bn2Mz7NChEycde7/v0ydMTqb1fnx0kvVPzyuVAKD8KJt22bJl7nu9cuVK/+1VqlQhYAsAAAAAYYKgLYBipaenu0w8Zd+q5qWCPAr6+E2dapU/fd+at1DQR0FeM000r0CtN+mYLnVdt+t+rdetm1nljye5xwMoH3v37nXf4/Xr17vrx44dM5/Px+4HAAAAgDBDeQQAxWrUqJErjfD999/brl27bM2aNbZ9+3br0qWLq4HrzSRWrapZr15mSxeZfZQwwuYfGWy19uRNUqZJx1TDViURfpwyyQVs/dUWmIkMKJeTL8uXL7edO3f+8LWrTO1aAAAAAAhjBG0BnFRSUpL16dPHduzY4YK3CgDNmjXLmjVrZl3PPttMmXpTp7pA7JnPjrDc5MEWP8Vs9WqzzEwzzWmmScdUw7Zfhlni5LzJyOy668z0eABlRt9bTTCYm5vratc2b97cTTxI7VoAAAAACF8EbQGUWIMGDVx27apVq2zDhg1WvXr1vDvOOsssJ0fFMq3ykMF2gZmdf75ZRoZZVlZeMm1SUt6kZWaDzRJ/yLAlYAuUywSDsbGxVqtWLevUqZNVq1aNvQ4AAAAAYY6gLYBT+9GIj3eBn6ZNm1rVqlX9t++tV89i69a1uj9cV4A2OTlvOcHgvFq3AILvwIEDroSJgrSSmJho5557rsuYBwAAAABEBoK2AEolMFtPw65VL3PdunVWr14969Chw/+ycAGUi6ysLPc93LZtm/tOaoKxunXzTqMQsAUAAACAyELQFsBpU4BIwaHDhw/bnj173KIJzFQ3M7nQVFsAwXL8+HF3wmTt2rXub1EmPGUQAAAAACByEbQFcPo/JPHx1r59e1cuYfXq1S7TT4uGaGuysrZt27oh2gCCR5m0mmRM2bWZmvHvh/q1nTt3dgHb3bt3s7sBAAAAIEIRtAUQNBqC3bNnT2vdurWtWLHCBY02btxoDRs2JGgLlIGVK1e6gG3lypWtY8eOLsPdy34HAAAAAEQugrYAgi4lJcX69u1re/fudaUSvAmRvEmSVO9Ws9kDOLXM2p07d7q60fr+xMTEuAz3I0eOWKtWrSwuLo7dCQAAAABRgqAtgDJTu3ZttwROlDRz5kxLSEhwwSZlBSrwBKD4YK1Kjaj0iAK0Xbp0sebNm7v7lMUOAAAAAIg+BG0BlJuMjAyrVKmSG869cOFCW7NmjcsQbNy4MZm3QCHBWtWG1vdEwVrR9wcAAAAAEP0I2gIoN5ok6YILLrANGza4me4ViFq8eLGry9miRQu3aFIzoKLbunWry6xNT0/3B2t1goPvCAAAAABUDERHAJQr1d3URGUa3r1582Zbv369y7xVgKpp06YEbQEzl2GrgK1KibRs2ZJgLQAAAABUMARtAYTmxyc+3gWjFLxVvU7Vu01MTPTfryHhdevWdZOWAdHs6NGjtmXLFqtfv74lJye729q1a+cm8NP3g+xzAAAAAKh4CNoCCKnY2FhX0zbQwYMHXckELZrITMPCFcAFoklaWppt3LjRZdXm5ua6ExedOnVy99WoUcMtAAAAAICKiaAtgLCjzMJGjRq5DNy9e/e6JSUlxQVvGzZsyKRliFgKzupzrWDtgQMH/Lcro5wgLQAAAADAQ9AWQNjREPGePXtahw4dXM3bTZs22aFDh2zhwoW2fPly69+/v1WtWjXUmwmcEp/PZ1999ZV/cjFlmTdo0MDVq61ZsyZ7EwAAAADgR9AWQNiqUqWKGy7etm1bF7hVAFe8up9eKQVdp+4nwjFIu3//flebVmJiYqxevXou01a1ajXxXmAdZwAAAAAAPARtAYS9SpUqWevWrd3EZcpSVPDLC4rNmTPHcnJyXNmEJk2a+ANkQCgnFtu6dasrgaDPa79+/VxtZm+CsY4dO/o/wwAAAAAAFIagLYCIoeHk1apV81/PzMx0GbaawGnLli1uUdatgrdaKleuHNLtRcVx7Ngx27lzp5tUbM+ePe6EgujzmZGR4V+PjHAAAAAAQEkQtAUQsZKSkuz88893Q9AVsNWwc2U2rly50latWuVKK6heKFCWFJSdNm2am2TMo4nzmjVrZo0bNyZQCwAAAAA4ZQRtAUS81NRUtyhIu2PHDtu8ebML5AZO7qSJzJSZW6dOHZexC5SGArN79+512d2qSeudPFD9ZWnUqJFbmCgPAAAAAHA6CNoCiBoaeu6VRlD2o4Jpng0bNrhgblxcnNWtW9fq16/vJoVSvVygJBOKqfSBTgqoZq0+N8qi9U4ADBgwgEnFAAAAAABBQ9AWQFQKDNiK6ttqUYakAm9aNBmUJi5TALd58+ZMDoV80tLSXKBWZTf0ufEkJia6ie9UxzYhIcF/GwAAAAAAwULQFkCF0K5dO7ccPHjQBWx37drlSiZ4Q90Da9+qjII33B0Vx+HDh127e5OFaUKx9evXu7+VWdugQQMXrK1duzYBfgAAAABAmSJoC6BCqV69ulvat2/vJi1T8NYL0nk1SzWplDIolYGrGriql0sZheijMgcK2is4u3v3bhe879mzp6tJKyqfoc+IPgcqqUEtZAAAAABAeSFoC6DCSk5OtpYtW+a7Tdm3Xrat6uBqkZSUFFdKQZmWCuIiMmVnZ9vGjRtdkFblDwIpKBtYBkFt3r179xBsJQAAAACgoiNoCwABatSoYUOHDnXZl8rC1QRUR44cccFcLRo+7wVtFQDUegrmUk4h/KjmrMphqHax12aaVGz16tX+dapVq+ayqZVJq3U0UR0AAAAAAKFG0BYAClDgTkPitXjBWQVv9+3b5wJ8HgVsFy5c6P5W0FbBW29RFi/Kj8paKKiu7FlvUY1aUZudeeaZ7m9NRqfsagVrFajVdQAAAAAAwg1BWwA4icTERDcJlZaCwV1l5iqbU+UUtm7d6hb34xof7wKFNWvW9NdPVcYntXFPn7JlFUgPDLh+/vnn7raCFEwvmAXdqVOnIGwFAAAAAABlJ2KCtmPHjrVPPvnEFi1a5CYIKliLsKgD+zFjxtirr77q1h8wYIC99NJL1qZNG/86yp678847bfLkya6e4eWXX25//OMfrWrVqmX8jgBEOi+Qq2H4Bw4ccJm4+k3R37otMFi4fv16W7NmjQs0qlaqMj11qUW/N0xyVXj2bEZGhpsMzFtUqkK/5wqkX3DBBf51tT+1voLkCqR7i9YDAAAAACDSREzQVllqV1xxhfXr189ee+21Ej3mmWeesRdeeMHeeusta9GihT388MOuVuXy5cv9GVrXXnut7dixw6ZOnWo5OTk2cuRIu/nmm23ixIll/I4ARAtl1WoIvlc6QcFDBRgDM0G9LFBNdKVFE2F5lIE7cOBAf5DXC/rq8bpNzx+ttK+Upaz9pf3StGlT/32zZs1ygfCiTsppH3n7pnfv3mQxAwAAAACiRsREAh577DF3+eabb5ZofR3QP//88/bQQw/ZJZdc4m7729/+ZvXq1bMPP/zQrrrqKluxYoVNmTLF5s6d6w745cUXX7Thw4fbs88+62aJB4BTpaxZZX4G6tatm3Xs2NHVWdXiTWymvxW4DAzwrlu3zp1M8igwqeCtF8Tt3Lmzf8IsBYP1d7gFdo8fP+5OtmmpXr26/3aVj1A2sheoVSatfq+94HXjxo39WcdJSUkuq1b1gb1FWcl6Pu1fre+h7AQAAAAAIJqE11F+EG3YsMF27txpgwYN8t+mA/2+ffvazJkzXdBWlxo+6wVsResrYDB79my77LLLQrT1AKKRAoupqaluCaTAa2AAUoFZlU1QYFMjAJRR6gV79fukALBn6dKlLsCroK23eEFcLWeccYb/ubdv3+6CpAXX0/0KnAZOsqbAqrZLtyuorMvARaMXvOdV6QdlDntBWi0K2np0IswLMu/du9e2bNmS7/3rPgVkFaTVe1UJHOnSpYt17949yK0AAAAAAED4i9qgrQK2oszaQLru3adLzR4eSAEMBVS8dQqjQEbghDfKlhMFNrSgZLxAEPss8tGWpx/MDfwedOjQwf+3gpgqG6AAri51PXBd/RbpuhcsDaQArxdklc2bN9uuXbuK3I6LL77Y35bK9i3ud1AZsV52r7JhC3tevb4CsNour7asfnP1t7KGvcxZXQ8MWnvvT7fx+1A6fCejB215evsOAAAAiFQhDdo++OCD9vTTTxe7jkoYtG/f3sLJuHHj/OUaAu3Zs8cFVVDyg6mDBw+6ABGTMEU22rJ8KLipJbAebqtWraxZs2YuMKqArhfU9S4D19X3TIFS3adMWC3626PAq76P+l4qw9fLwvUW7zn0t37vvOxZBWAVxFWAVgFoXWrxgrp6vsBt0GRhou3zTnohuPhORg/asvQ0OgEAAACIVCEN2t5777124403FrtOy5YtS/Xc9evX9wchNLu7R9e94bZaJzCgIQpgaFiw9/jCjB492u655x7/dQUdmjRp4oYWa0gzSn4gquCP9htB28hGW0aGgiMLimvLNm3alPh7WZLnRfniOxk9aMvSC6wVDgAAAESakAZtA2dbDzbVW1Tg9YsvvvAHaRVcVa3aW2+91V3v16+fG9Y7f/5869Wrl7vtyy+/dAdIqn17smy3ghTgIPh4ahQcYr9FB9oyetCW0YF2jB60ZenQJwMAAEAkK1kaVRhQLcZFixa5Sw3p1d9ajhw54l9HZRQ++OAD/wHO3Xffbb/97W/to48+cpP1XH/99dawYUO79NJL/XUjhw0bZqNGjbI5c+bY9OnT7Y477nCTlGk9AAAAAAAAAChvETMR2SOPPGJvvfWW/3qPHj3c5bRp0+y8885zf69atSpf7cT777/f0tPT7eabb3YZtWeddZZNmTIl33C5CRMmuEDtwIEDXUbG5Zdfbi+88EK5vjcAAAAAAAAAiLig7ZtvvumW4ngzpHuUbfv444+7pSipqak2ceLEoG0nAAAAAAAAAFSI8ggAAAAAAAAAUBEQtAUAAAAAAACAMELQFgAAAAAAAADCCEFbAAAAAAAAAAgjBG0BAAAAAAAAIIwQtAUAAAAAAACAMELQFgAAAAAAAADCCEFbAAAAAAAAAAgjBG0BAAAAAAAAIIwQtAUAAAAAAACAMELQFgAAAAAAAADCCEFbAAAAAAAAAAgjBG0BAACAcjJ+/Hhr3ry5Va5c2fr27Wtz5swpdv333nvP2rdv79bv0qWLffrpp7QVAABABUDQFgAAACgH7777rt1zzz02ZswYW7BggXXr1s2GDh1qu3fvLnT9GTNm2NVXX2033XSTLVy40C699FK3fP/997QXAABAlCNoCwAAAJSD5557zkaNGmUjR460jh072ssvv2xJSUn2+uuvF7r+H//4Rxs2bJjdd9991qFDB3viiSesZ8+e9qc//Yn2AgAAiHIEbQEAAIAydvToUZs/f74NGjTofx3x2Fh3febMmYU+RrcHri/KzC1qfQAAAESP+FBvQDTw+Xzu8tChQ6HelIiSm5trhw8fdjXadNCCyEVbRg/aMjrQjtGDtiw9r1/m9dNCbe/evXb8+HGrV69evtt1feXKlYU+ZufOnYWur9uLkp2d7RbPwYMH3WVaWpr7PJWHnJzgPVdMTK4dys62hJwciw1WW6alhd37lDQL9hOmhd17DNf2DPu2DMP3Ga5tGRHtGWZtGc7tGfZtGYbvM1zbMiLaMy047zOY/dQYX7j0ZCPY1q1brUmTJqHeDAAAABSwZcsWa9y4ccj3y/bt261Ro0auTm2/fv38t99///329ddf2+zZs094TEJCgr311luurq3nz3/+sz322GO2a9euQl/n0UcfdfcDAAAgsvupZNoGQcOGDd2OrlatmsXExATjKSsEnVlQsFv7LiUlJdSbg9NAW0YP2jI60I7Rg7YsPeUlaESP+mnhoHbt2hYXF3dCsFXX69evX+hjdPuprC+jR492k515lF27f/9+q1WrVkT2U/kORBfaM3rQltGF9owetGV09VMJ2gaBhvaHQwZHpFLAlqBtdKAtowdtGR1ox+hBW5ZO9erVLVwoa7ZXr172xRdf2KWXXuoPqOr6HXfcUehjlJGr+++++27/bVOnTs2XqVtQYmKiWwLVqFHDIh3fgehCe0YP2jK60J7Rg7aMjn4qQVsAAACgHCgD9oYbbrDevXtbnz597Pnnn7f09HQbOXKku//66693JRTGjRvnrt9111127rnn2u9//3u76KKL7J133rF58+bZK6+8QnsBAABEOYK2AAAAQDm48sorbc+ePfbII4+4ycS6d+9uU6ZM8U82tnnz5nyTs/bv398mTpxoDz30kP3617+2Nm3a2IcffmidO3emvQAAAKIcQVuEjIbujRkz5oQhfIg8tGX0oC2jA+0YPWjL6KNSCEWVQ/jqq69OuO2KK65wS0XFdyC60J7Rg7aMLrRn9KAto0uMT9VvAQAAAAAAAABh4X/jrwAAAAAAAAAAIUfQFgAAAAAAAADCCEFbAAAAAAAAAAgjBG1RrsaOHetmQk5KSrIaNWqU6DEqu6xZlhs0aGBVqlSxQYMG2Zo1a8p8W1G8/fv327XXXmspKSmuLW+66SY7cuRIsY8577zzLCYmJt9yyy23sKvL2fjx46158+ZWuXJl69u3r82ZM6fY9d977z1r3769W79Lly726aefltu2Ijjt+Oabb57w3dPjEFrffPONXXzxxdawYUPXJh9++OFJH6OJqnr27OkmmWjdurVrWyCaner/WQg/48aNszPOOMOqVatmdevWtUsvvdRWrVoV6s1CEDz11FPu/6+7776b/Rmhtm3bZtddd53VqlXLHWurrz9v3rxQbxZK4fjx4/bwww9bixYtXFu2atXKnnjiCRdPQeQiaItydfToUTcD8q233lrixzzzzDP2wgsv2Msvv2yzZ8+25ORkGzp0qGVlZZXptqJ4CtguW7bMpk6dah9//LELPtx8880n3W2jRo2yHTt2+Be1L8rPu+++a/fcc4+NGTPGFixYYN26dXPfp927dxe6/owZM+zqq692QfmFCxe6Ay0t33//Pc0WQqfajqITLIHfvU2bNpXrNuNE6enpru0UlCqJDRs22EUXXWTnn3++LVq0yB0k//znP7fPPvuM3YuoVJrfOoSfr7/+2m6//XabNWuW6zfm5OTYkCFD3G8gItfcuXPtL3/5i3Xt2jXUm4JSOnDggA0YMMAqVapk//nPf2z58uX2+9//3mrWrMk+jUBPP/20vfTSS/anP/3JVqxY4a7rWPvFF18M9abhNMT4CLsjBJQZpIPNtLS0YtfTx1MZSPfee6/96le/crcdPHjQ6tWr557jqquuKqctRiD9J9CxY0fXWevdu7e7bcqUKTZ8+HDbunWra7OiMm27d+9uzz//PDs0RJSlpGwX/Wcuubm51qRJE7vzzjvtwQcfPGH9K6+80h1UKTDvOfPMM1076kQKIqMdS/qbi9BRptIHH3zgTooU5YEHHrBPPvkk30kT/T+odtVvMFDRf+sQGfbs2eMybhXMPeecc0K9OSgFja7TqI8///nP9tvf/pb+fYTS7+j06dPt22+/DfWmIAh+9KMfuTjJa6+95r/t8ssvd1m3b7/9Nvs4QpFpi7CmrKKdO3e6kgie6tWru078zJkzQ7ptFZn2vUoieAFbURvFxsa6bOjiTJgwwWrXrm2dO3e20aNHW0ZGRjlsMbxM9/nz5+f7PqnNdL2o75NuD1xflOXE9y+y2tE7wGrWrJkLeFxyySUuUx6Rhe8jKpLS/tYh/CkBQ1JTU0O9KSglZU5r5EfBPiIiy0cffeSO5zQSVidSevToYa+++mqoNwulpDKUX3zxha1evdpdX7x4sX333Xd24YUXsk8jWHyoNwAojgK2ojNGgXTduw/lT/te/7EHio+Pd53v4trlmmuucUEjZeIuWbLEZY2pptn7779fDluNvXv3ulpHhX2fVq5cWegOUnvy/Yv8dmzXrp29/vrrbgijDpafffZZ17FT4LZx48bltOU4XUV9Hw8dOmSZmZkukwKoyL91CH/KltbIDw3J1gl8RJ533nnHlSvRiDtEtvXr17vh9CpD8+tf/9q16S9+8QtLSEiwG264IdSbh1JkTqtPqLlI4uLi3P+hmlNIZQ0RuQjaIig/DqqXcrLh9PrxQHS0ZWkF1rxVkXtNLjdw4EBbt26dK5QOoGz069fPLR4FbDt06OBq0WmCAgAAyitDUyVelP2FyLNlyxa76667XG1iJjSNjpMoyrR98skn3XVl2ur7qRJoBG0jzz//+U83qnXixInWqVMn//wHSpiiPSMXQVucNtWbvfHGG4tdp2XLlqV67vr167vLXbt2uQCfR9dVUxOhaUu1S8FJQI4dO2b79+/3t1lJqMyFrF27lqBtOVBZCp111fcnkK4X1W66/VTWR3i2Y0GacEIdc333EDmK+j5qkjmybBFtgvFbh/Byxx13+CevZZRHZFLJEh0DqJ6tR9l8alPVns7OznbfW0QGHV9rnpJAOqn/r3/9K2TbhNK77777XBKWN++PkqQ08fC4ceMI2kYwatritNWpU8dl0Ra3aIhFabRo0cJ1zFWbxaOUf9VNDcwaQ/m2pfa9Jr5Rx83z5ZdfurO1XiC2JHT2TwID8ig7artevXrl+z6pzXS9qO+Tbg9cX5RdwfcvstqxIB1gLV26lO9ehOH7iIokGL91CA+aWFgBW022qP6i+veITBohp/6D+vDeokxNDb/W3wRsI4vKlKhUXSDVQ1U5O0QezRWj2u+B9J3U/52IYD6gHG3atMm3cOFC32OPPearWrWq+1vL4cOH/eu0a9fO9/777/uvP/XUU74aNWr4/v3vf/uWLFniu+SSS3wtWrTwZWZm0nYhNGzYMF+PHj18s2fP9n333Xe+Nm3a+K6++mr//Vu3bnVtqftl7dq1vscff9w3b94834YNG1x7tmzZ0nfOOeeE8F1UPO+8844vMTHR9+abb/qWL1/uu/nmm933a+fOne7+n/3sZ74HH3zQv/706dN98fHxvmeffda3YsUK35gxY3yVKlXyLV26NITvAqfajvrN/eyzz3zr1q3zzZ8/33fVVVf5Kleu7Fu2bBk7M4T0f5/3/6C6ZM8995z7W/9XitpQbelZv369LykpyXffffe57+P48eN9cXFxvilTpoTwXQCh+61DZLj11lt91atX93311Ve+HTt2+JeMjIxQbxqC4Nxzz/Xddddd7MsINGfOHNfPHzt2rG/NmjW+CRMmuH7G22+/HepNQynccMMNvkaNGvk+/vhjd7ytmErt2rV9999/P/szghG0Rbn/kOjAtOAybdq0/30ozXxvvPGG/3pubq7v4Ycf9tWrV8913AcOHOhbtWoVLRdi+/btc0FaBd9TUlJ8I0eOzBd8138UgW27efNmF6BNTU117di6dWsXeDh48GAI30XF9OKLL/qaNm3qS0hI8PXp08c3a9asfB1vfU8D/fOf//S1bdvWrd+pUyffJ598EoKtxum049133+1fV7+lw4cP9y1YsICdGmL6fSzs/0Sv7XSptiz4mO7du7u21ImvwP8vgYr2W4fIUNjvXMH+PiIXQdvINnnyZF/nzp3d8Vn79u19r7zySqg3CaV06NAhdwJF/2cqOUP9xN/85je+7Oxs9mkEi9E/oc72BQAAAAAAAADkoaYtAAAAAAAAAIQRgrYAAAAAAAAAEEYI2gIAAAAAAABAGCFoCwAAAAAAAABhhKAtAAAAAAAAAIQRgrYAAAAAAAAAEEYI2gIAAAAAAABAGCFoCwAAAAAAAABhhKAtAFRwN954o1166aWh3gwAAIAixcTE2Icffhhxe2jjxo1u2xctWmSRoHnz5vb888+X+eu89tprNmTIEIsUX331lWvHtLS0qPuMno7zzjvP7r777rA4Rlm+fLk1btzY0tPTy2R7gFAgaAsAYUodFXX+tFSqVMlatGhh999/v2VlZYWkk+ot9erVs8svv9zWr19f5p1fAABQsfo8gcuwYcP86+zYscMuvPDCkG5nOHv00Uete/fuFgnUl3344YdtzJgxZfo69DXL3vvvv29PPPFEuQf9C9OxY0c788wz7bnnngvJ6wNlgaAtAIQxHazoIEUB0j/84Q/2l7/8pcw7uEVZtWqVbd++3d577z1btmyZXXzxxXb8+PFSPVdOTk7Qtw8AAER+nydw+cc//uG/v379+paYmBjSbURwTJo0yVJSUmzAgAFltkvpa5aP1NRUq1atmoWLkSNH2ksvvWTHjh0L9aYAQUHQFgDCmA5OdJDSpEkTNzxo0KBBNnXqVP/9ubm5Nm7cOJeFW6VKFevWrZvrCHsUVL3pppv897dr187++Mc/lmpb6tataw0aNLBzzjnHHnnkETcEae3atTZ37lwbPHiw1a5d26pXr27nnnuuLViwIN9jlS2jDtSPf/xjS05OtlGjRtn555/v7qtZs6a7X1k2AACgYvd5Ahf1EYoaej5jxgyXWVq5cmXr3bu3u69gGYLvv//eZedWrVrVjRT62c9+Znv37s03tPsXv/iFG8mk4JNeUxmrnmuuucauvPLKE4KB6vP87W9/c9enTJliZ511ltWoUcNq1aplP/rRj2zdunVFvs8333zTrRvI2/ZA//73v61nz57u/bVs2dIee+yxUwpEeUPLn332Wdd/07bdfvvt+YKZu3fvdifh1UdUX3HChAknPI9GRP385z+3OnXquEDrBRdcYIsXL3b37dmzx+2zJ598Ml+7JCQk2BdffFHktr3zzjvudQtmxfbp08f1E7V/FNDdtGmT/371I1u1auWeW/3Zv//976Xua56s/yyffvqptW3b1t2v51GZi5LwMsL1OLVb4PNq391xxx351tc+LG5/eRnUr7/+ujVt2tR9lm+77TbXx3/mmWfc/lcffezYsfkep2zTLl26uH2h4wg95siRI/nWefXVV919SUlJdtlll7nHBH42vdfWvlYGrfr5V111lR0+fLjQ8gj6W232y1/+0p8tH/g8gZSNq+f06P3cc889/u+RvpM+ny/fY0rSbjom2b9/v3399ddFthEQSQjaAkCE0IGH1xH2qOOig4aXX37ZZb+qk3Tdddf5Oyrq3Ki2k7JjFWRVsPXXv/61/fOf/zytbVFHSY4ePeo6bjfccIN99913NmvWLGvTpo0NHz48X4fO67CpQ7h06VJ34PGvf/3Ln8GrDm5pg8kAAKBiOXTokAv6KSilE8Uanv3AAw+cEGxUkKxHjx42b948F1zdtWuX/fSnP8233ltvveUCW7Nnz3ZBsMcff9x/gvzaa6+1yZMn5wt2ffbZZ5aRkeH6NKL6mQo26TUUeIuNjXX3qQ9WWt9++61df/31dtddd7n+m0ZaKdhbMDB3MtOmTXMBZF3qfeo5tHgUxNyyZYu7X8GvP//5zy6QG+iKK65wt/3nP/+x+fPnu0DywIEDXWBMgVwFE9XH0/tX30+BcQUmtU5R1GdUoN2jYLQCzDrxv2TJEps5c6bdfPPN/qDfBx984PbFvffe6/rD//d//+cyKrXdpelrnqz/rH3yk5/8xH3GdBJAQesHH3ywRPtcZR9URkyBbX1+FORcsWKFu0/PM3HiRMvOzvav//bbb1ujRo3cZ7UoakPtf32GlX2uesAXXXSRbd261W3z008/bQ899JD7DHv0OXzhhRfc+1Pbf/nlly4Q6pk+fbrdcsstbr/qPSrYWdjnS6+tkwoff/yxW/R6Tz31VJGlEnTcoe+Qly1fUr///e/dZ1OfJ30+9PlSuwc6WbuJjpMUINZ3CIgKPgBAWLrhhht8cXFxvuTkZF9iYqJONftiY2N9kyZNcvdnZWX5kpKSfDNmzMj3uJtuusl39dVXF/m8t99+u+/yyy/P9zqXXHJJketPmzbNvfaBAwfc9e3bt/v69+/va9SokS87O/uE9Y8fP+6rVq2ab/Lkyf7b9Pi777672OcFAAAVU2CfJ3AZO3asfx31GT744AP390svveSrVauWLzMz03//q6++6tZZuHChu/7EE0/4hgwZku91tmzZ4tZZtWqVu37uuef6zjrrrHzrnHHGGb4HHnjA/Z2Tk+OrXbu2729/+5v/fvWxrrzyyiLfy549e9xrLF261F3fsGFDvu164403fNWrV8/3GL2vwEPzgQMH+p588sl86/z973/3NWjQoMjXHTNmjK9bt2759mmzZs18x44d8992xRVX+Ldd+0CvOWfOHP/9K1ascLf94Q9/cNe//fZbX0pKiutzBmrVqpXvL3/5i//6bbfd5mvbtq3vmmuu8XXp0uWE9QOp36fX+Oabb/y37du3z9321VdfFfoY9TtHjRqV7za9l+HDh59yX7Mk/efRo0f7OnbsmO9+fSZO1m/V/bfccku+2/r27eu79dZb3d/6vNasWdP37rvv+u/v2rWr79FHHy22XbW9hw4d8t82dOhQX/PmzV2f29OuXTvfuHHjinye9957z31nPPocXHTRRfnWufbaa/N9Ngt77fvuu8+9J4++Q3fddZf/uj5z3uenqM+maB2t69Fn+5lnnvFf13evcePG/mOUUznuueyyy3w33nhjkfsCiCTxoQ4aAwCKpuFYGuqlLA7VtI2Pj3dn70WlCZTpoTPjgZT9qqwSz/jx491Z682bN1tmZqa7vzQTVejMufqjek0NR1L2gs5mK2tFZ/c1rE2ZGBrepHX0eoECMyoAAAAK6/MEUsmCwihzsmvXrq50gEdD6wMp01GZmBpOXlj2oIa+i54nkEoJeNmm6ncpM1dlA5RBqv6YyhZoeL9nzZo1biSTshxVesHLsFU/qHPnzqVqZG27MiEDMx/Vv9IEXupjaTh7SXTq1Mni4uLyvTdloYqyP/X+evXq5b+/ffv2+YbHazuUZazh6oHUnwwsAaESDHqvGtmlbNziag/rsRLYdmpnZf0OHTrU9WtVDkz7XdvrbasybwOpfELBUVol6WuWpP+s1+vbt2+++/v163fS5y5sPV33SnboPetzpH653p+yxJU5/NFHHxX7nCojEFg3VqU+1K7Kpg28LTBL+vPPP3eZqStXrnSZ6cpmDvz86DvkZYsHfoeUTVvcawd+P4Ll4MGDLis3cJ/rs6n29EoklPS4xxsRqHWBaEDQFgDCmIbrtW7d2v2tDp6CpRoSpTq13lC9Tz75xA2rCuR1lnVQ8atf/coNOVKnUZ2u3/3ud/mGT5WUhhmplpnqZgV23lQaYd++fa7j3KxZM/faei11ogq+FwAAgJP1eYJB/SQNb9fQ8YK8YKBUqlQp330akh9Y2kBD3DVsX4EqlU1QQEiTpnn0Gur/qD5ow4YN3WMVwCzYD/Io0FawVmfBSbO07RreryH6BQUGO0/mZO/tZLQd2lc6MV9QYHBXAVxNVqvnVu1Xla0oigLA2o4DBw7ku/2NN95w9YVVAuDdd991CQHa32eeeWaJt7ckfc2S9J/LkkokKHlCpQ30nlUWQZ+fU23H4tpWbaDayrfeeqsL/CsorpIDOn7Q57KkQf+iXvtUS3+U5DMfzHZTaQXVPwaiAUFbAIgQ6vCoHq3qpmlijI4dO7pOijI5dDBRGGVp9O/f300+4ClucoziqOh/wYkzvNdQDTTVsfXqgAVO8lEUrzavMkcAAABKShNRqRaoaoN6ARtNjBpItVc1KkiZgsraKy31ozRZkwKJqiuqGq9eIEsnrZWxqIDt2Wef7W5TcKw4qgOr2q/K2vWCjIGTp3nbrucNZhC7IGXVKvtSmbFnnHGGu02vqVrAgduxc+dOt/8CJ40KpCCg6opqwja1i4KSyubVSf6i+n/qw6pW75AhQ/Ldp4xJLaNHj3YJAKr/qqBthw4dXH9TiQIeXdfznGpfsyT9Z71ewexXzdtQElpP9YgDrwdmgiqgrQxSfWb0/v70pz9ZsKlNFVhV0oaXjVtwPgu1VcHvTMHrpaF9XrBvr8+8PkcK3Hp1igM/85rgTCcHlFSiCY/F+2zqM1jSdvMoe3nEiBGn/V6AcMBEZAAQQXSgoOFQKnmgbFdl0aoIvyYYUDBWw6xefPFFd100KZgmhtCkGatXr3aTIwSjQxZIr6FZZTWUTJ0tZaR4E5UVR1kF6rhpGJZmzi04oy0AAKg4FIBVYCdwKeoksE5eKyilIfPqf6ifoyH64gWFbr/9dpdxd/XVV7u+j/pJWk8TWJ3qCWO9niY/Uuan+jmemjVruszRV155xQ3f1mRPOrleHA0BV6ajTsRrmxS4C5wcTFRuQRMuKdtWEy7pPWr0lLJPg0VBO2UMa1Iv9d8UIFPANbAPpzIFCp5qkrD//ve/LoNTk+L+5je/cf1L0d8a3q5JrzQZnMpO/L//9/+KfW2VQQgMbm/YsMEFajUB2aZNm9xrqeyEgqdy3333uX2k8hm6/bnnnnOTXqkffKp9zZL0nzVBl15Hr6tAdmFtVBSViNDoOPW7x4wZY3PmzHETswXSftZkXgpiFixREAwK9iuTVe9p/fr1rp+uz2+gO++80z799FO3L/VeNdmdTkp435/SUnD/m2++sW3btvm/v+edd57b/5roT/tbxzF6rUCaEE37RJOeqaSDEk4CTyCUpN1En1G9tj67QDQgaAsAEUSZDur4qdOjDA3NlqxArGpWqWOrzreGDSkrVtQR19A6ZT/oIEEZIYFZt8Ggcg0a4qYz4arTpaFtRWVXBNLQJh2MaDZe1eEq2KEFAAAVh4bFK9sucDnrrLMKXVflmiZPnuyy9TTUXIFDBToDyweoVIGyMRWgVUanMhzvvvtuN2oosBZoSShQq8xQ9V1US9Wj51EwVQFPlURQQEllqIqjoerKElbATNv0j3/8wx599NETgpoKNCp4qSxYZZtqboOTDaM/VRqer/2kzEX1FxUED+zDKYCn7VT2o4LdCsheddVVLrCqvpvKJjz//PMuKKg20f7Q3yqpVbA+cSAN09fzKtgrCmIrUKd5G/Qa2g4F3dWPFQWNVYZLgXnV6VWAUduuYGBp+pon6z83bdrUZWkrgKjSZAp4PvnkkyXap3o9fSZUK1mBd7VvwYxgnUhQn16Xp1LuoqS0zQrGqjSIPpeqyaz3GkifY70vraf19f3T5/d0t+fxxx93gVOVJ1CGrWgfa1SegrV6LQWyCwbc7733XnccoWxqr6RbwYD2ydpNtL/1fQ/2dwUIlRjNRhayVwcAAAAA4DQpMKXAogKBJRnxg9CPHtMJf2XYVjReUFMZ4N7w/3AwatQoFzxX0D0SqVSHRgAqMzrw5AoQyahpCwAAAACIKMpibNmypcumXLx4sRua/9Of/pSAbYRQRrKypSsSlSzQqDeVuVD2dKgDtspcHjx4sKutrHIFKjOgjNhIpXq3KjtCwBbRhExbAAAAAEBEUakoBZhU+1alFDSEfuzYsW6oPRCOVE7i/PPPdyUgJk2a5MpjhJJOcmibNDGeToCozq3q+QIIHwRtAQAAAAAAACCMMBEZAAAAAAAAAIQRgrYAAAAAAAAAEEYI2gIAAAAAAABAGCFoCwAAAAAAAABhhKAtAAAAAAAAAIQRgrYAAAAAAAAAEEYI2gIAAAAAAABAGCFoCwAAAAAAAABhhKAtAAAAAAAAAFj4+P+6pEaQoXhsygAAAABJRU5ErkJggg==", + "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.4740-0.8233j -0.4736-0.8233j 0.000363 \n", + "1 -0.4740+0.8233j -0.4736+0.8233j 0.000363 \n", + "2 -0.0088-0.7098j -0.0116-0.7094j 0.002827 \n", + "3 -0.0088+0.7098j -0.0116+0.7094j 0.002827 \n", + "4 -0.4551 -0.4571 0.002004 \n", + "5 0.2014-0.3907j 0.2046-0.3867j 0.005143 \n", + "6 0.2014+0.3907j 0.2046+0.3867j 0.005143 \n", + "7 0.0126-0.3568j 0.0138-0.3626j 0.005851 \n", + "8 0.0126+0.3568j 0.0138+0.3626j 0.005851 \n", + "9 0.2188 0.2231 0.004293 \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": 11, + "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 4.324553 4.321076 0.000804 \n", + "1 3.182118 3.182414 0.000093 \n", + "2 1.782269 1.781281 0.000554 \n", + "============================================================\n" + ] + } + ], + "source": [ + "# Compute singular values\n", + "B_recovered = dmdc.B_havok_dmd.cpu().numpy() if hasattr(dmdc.B_havok_dmd, 'cpu') else dmdc.B_havok_dmd\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": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'MAE': 0.007963265021941862,\n", + " 'MASE': 0.028261797795356862,\n", + " 'NMSE': 5.2669074036781514e-05,\n", + " 'MSE': 0.00010040799290876968,\n", + " 'R2': 0.999892774142037,\n", + " 'Correl': 0.9999464154243469,\n", + " 'AIC': -9.186068743230287,\n", + " 'logMSE': -9.206268743230288}" + ] + }, + "execution_count": 12, + "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": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Matrix Reconstruction Errors:\n", + "============================================================\n", + "A Matrix:\n", + " Frobenius Norm Error: 46.949720\n", + " Relative Error: 17.623318 (1762.33%)\n", + "\n", + "B Matrix:\n", + " Frobenius Norm Error: 0.007565\n", + " Relative Error: 0.001337 (0.13%)\n", + "============================================================\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABigAAAPeCAYAAACWaJK3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAxa5JREFUeJzs3QmYHGWdP/C3ZyAHkIT7DjfKfcgl4AIKgoAI6qKsIOFYz4BgvGBVUAEjgoggcq2AqCgqIuquQUQEQZBLEFRABCUe4VAkEJaEzPT/+ZX0/HsmM0nPTE9XdfXn8zxFmJ6emuqqnn6/9Z6VarVaTQAAAAAAAC3U1cpfBgAAAAAAEDRQAAAAAAAALaeBAgAAAAAAaDkNFAAAAAAAQMtpoAAAAAAAAFpOAwUAAAAAANByGigAAAAAAICW00ABAAAAAAC0nAYKAAAAAACg5TRQAGPiZz/7WapUKtm/AECxKKdTWm+99dIRRxyR96UAaJlPfOIT2T1avYULF6YPf/jDaerUqamrqysddNBB2ePPPfdc+s///M+0+uqrZz9z/PHHd/yVmj17dpowYUK65ZZbWn6dRku5TxEdcsgh6S1veUveh0EBaKCgtKJAb2QrUgX6jjvumB3T+eef3/DP/PGPf+x7Laeeeuqgzzn00EOz7y+33HIjOq4rrrginX322SP6WQBolssuu6xfGb7UUkultdZaK6tk/stf/uJEj7EvfelL2XnfaaedhvVze+yxR/ZzG2+88aDfv+666/qu6Xe+851hH9dvf/vbrDInMhFAp5aJUXG+5pprpn322Sedc8456dlnn21oP5dcckk644wz0r//+7+nr3zlK+n9739/9vinP/3p7He85z3vSV/96lfT29/+9tTpPvWpT2Vl4K677tr3WGSQ+uswfvz49LKXvSyddNJJ6YUXXsilrI7rVhS1hpGhtm9+85upnVx55ZXpsMMOyzJNHH9knMEMfF8M3Abm1gULFmR/c5tsskn2t7zaaqul/fffP/35z3/ue84dd9yRjjnmmLT55punZZddNq2zzjpZ5f5DDz3U0LHfdNNN6Q1veEPWGBm/IxofX/e61w3a4BbH8spXvjKtssoq2XPj9UYj5ZNPPtnvef/85z+z+qYVVlghbbDBBunLX/7yIvu688470zLLLJMeffTRRb73kY98JF111VXp3nvvbeg1UF5L5X0AMFYiRNW7/PLLsxvggY9vuummhbgIv//977MCJ3rzff3rX8+C4HBEofGNb3wjfexjH+v3+Lx589I111yTfX+kooHi/vvvH1avmd122y393//9Xxo3btyIfy8ADFVBsP7662c3/rfddlt2I37zzTdnZdVoyjsWL/JJ5JTbb789Pfzww2mjjTZq+JTFdYmfiZ+NDhkD9xvfH2lFTjRQfPKTn8wqCeL4GvXggw9mvYUBylAmvvjii2nOnDlZhXDct5111lnp+9//ftpqq636nhv3iieccEK/n//pT3+aNfZ//vOfX+TxqKA8+eSTW/ZaiiwqZqMBJ7aBolHiv//7v7P/f+aZZ7L771NOOSX94Q9/yMq4VjdQrLzyyouMEMz7/vx973tf2mGHHRZ5fOedd07tJDqT3nXXXdlr+fvf/z7k8971rnelvfbaq99j1Wo1vfvd786ySvzN1cTfbjRG/OIXv0jveMc7sr/Zp59+Ov3yl7/M3k9rr7129rzTTz89a0w4+OCDs+fE3/sXv/jF9IpXvCLLw1tsscVijz0aMiL3xDFE40T8jq997WvZe+N//ud/ssaKmniN22yzTTbCYdKkSel3v/tduvjii7Pn3XPPPVkDSfjgBz+YfeZEDoucF8cfdWy77LJL32uOax+fSfE5NdC2226btt9++/S5z30uq7Ojg1WhQ0yfPr3ayFt+3rx51TycdNJJ1VVXXbV61VVXVSuVSvXRRx9t6OfiefG63vSmN2X/3nPPPf2+//Wvf7269NJLVw844IDqsssuO6Jj23///avrrrtuQ8/9v//7v2pPT8+Ifg8ALM6ll16alXV33HFHv8c/8pGPZI9feeWVpT+BUcZGWTtaN9xwQ3bO4t9GPPLII9nzv/vd71ZXWWWV6ic+8YmGf9fuu+9e3Xzzzasvf/nLq8cff3y/78VrmTx5cvXNb35ztv9vf/vbw34t8TONvpbe3t7q888/P+zfAdAuZWK4/vrrqxMnTszu4Zb0mffqV786+4weaP3118/uA4tWfuXlrLPOys7ps88+2+/xadOmLXKfHWXNK1/5yuy+fs6cOcP+XSeffHJDdReDiWsZ5W5R1PLGSMr3xb1nnnvuuVEf20jqfh577LG++o7hnuuf//zn2bk47bTT+j1++umnZ3U2v/zlLxf787fcckt1/vz5/R576KGHquPHj68eeuih1ZGeg9VWW626zz77LPG53/nOd7Lj/8Y3vtH3WPzsV77ylb6v43yccMIJfV9/9atfra655pqL/N3UO/PMM7O/ocU9h/LTZYiOFj3topU5Woej1TiGnf3Xf/1X9r0YdhfTBTQyX3EMa4sW4RgqF70nokdhtG739vYOa5RCDKt9/etfn6ZMmZJ9PRzR8yBapAf+XPTYiJbwFVdccZGfiZ4d0VIfQ4HjuDfccMOsp0dPT0+/cxSt5H/605/6hiPWeifWhmvGsMzojRO9AOIczp07d5E5LqPFfeLEienwww/vdwzR47W7uzsb2gcAI/Fv//Zv2b/RU7HeAw88kJWtUQZGD/3ooRW9SQeKcjymtIjyLcrD6KkW5dVTTz3V95wnnngiHX300dmQ+9jX1ltv3a8XZfR+i99z5JFHLrL/KBfjZ6KXWc38+fOzXqmRGeJ3RoaIOcDj8XpRlsZw/ijPY0h/PHfWrFnZ92J6gKOOOio7png8vh9TdQwU0wPEnOLR223VVVfNXuvA37Mk8ftj+H7khjinI+kR+h//8R/Z1Aj1+egHP/hBev755wedfziyx3vf+9708pe/PMsQK620UtZrsH4qpxg9E4+FV7/61YtM4RnXNLLVtddem13/2M+FF164SKaLHn7x8zGVQVzr+ikXttxyyywjxahUgHbwmte8Jn384x/PPkejh/RgaxvUpgq+4YYb0m9+85t+n5/xb0zHEveBtcdrn72tKr9qx/Gtb30rnXbaaVnZHGXpnnvumfXUHih6m++3335ZWRXlXfQw/8IXvjCiXDCY733ve9n0To1MmxzH/apXvSorWx555JF+3/vRj36U5ZY4xuiZHuVqnP8lufTSS7PrGuV4nLPNNttskamho1yLfd1444191602BdHA+/O4NvFaogwerLyOHvb19QIjPe7hGOo9U5vOLF5X5II4B7VRBbVRI7XnR93G9OnTs2zXaN3P3/72t+y9EVluSWprtYxE1NXE63jb297W91hkonifvvGNb8xGmMaaMINdkxCjEgaOgImpl+K1R33LSMR5iOwz8HwNplYPVP/cGJUTf3M18bdVO/7ITTFia+bMmYv9u3nta1+bPTdmPKFzmeKJjhfD8vbdd99s6FrMJRghaTjiw3f33XfPQlYM44t5AGNo3oknnpgVdI2s3RBhKkJWhI4ocN70pjdlhXKtwGxUBIkIoJ/5zGeygi8qVn784x9n01rVwmC9KOijoJgxY0b2bwzjjbkyoyIl5iENH/3oR7NhhVG5URv2O7BwiUaNOO6oeIlgOtiw0RjmF8/70Ic+lIXCmPswCqGoGIh5FmNoMgCMRK3SpP4GKW6aY47oaDyPm6O4oY5Kjqioj7lu40awtgho3HDHjV1UlsQw+Sg/o8Iiyr6YJiFuvuLGNsrquHGODgHf/va3szIsbtKOO+64tPTSS2f7/O53v5tVgNeXhVGpEeVjZI3azWiUg9FI/853vjMrI++7776snI3h9/H8elE+x7HH747jiRvExx9/PJt6o3YzHzeXUXkQjShRjtemZYxjj8qcxx57LBtiHzfukQtin8MRuSTySbyuyBtRKRJTUw42XcNQ4oY8KseiciQqWWo363F8UdkwUOw/MlWct6iIiOscvzeuRUzrFDfVUckQryvmW4/cVJu6s34Kz5jKKY45clpMPRANHgPFeYzKsajQiqkP4jqGqISL91Icc206A4B2EGtGxOdi3A/GZ99AUW5EeRCV/1EWRiVi7fMzHo/G7Pjs/cAHPtD3/FaWXzVxbxsVwnGvGfeln/3sZ7M57+MeuiYqNqMxeo011sjK5Khcj3L9hz/8Yfb1cHLBYKLiOsqk4UzDPFg2ifM6bdq0bJ2Q6NAYdQlRrkVjxq9+9avFTlMYz4uK6Dj/sQZXNPBHZX1ck6iQD1H3cOyxx2b363EfH4aq33jrW9+azjvvvKwRqtbQH+KYYt+RcaIj4WiPuybWRKnv+FETnQ/qFwQf7D0TUwqFeL3xfok6i1qngcgVMb1QTKcU1yfK/FpGiemQIp8tqe4n6m6i00k0yg1nqsjhiPdQvK5oZKj/HZFn/vrXv2b5I/6m4jhqnSOi4SI6TyxONILF31S8NxoVf2fxO+J6xLRKMUXqYHVPse84Z9FoElOSx99NvCfq192IHBjTyUWdTjTGRb1TTAVVW8ci/t6WtH5NNLZFB5K4Xov7O6Tk8h7CAXlO8RTDz+KxCy64YJHnx+MxtHKgGCYbwzhrTjnllGw4WgytqxfD2rq7u7MhgEtyzDHHVKdOnZoNBQ0//vGPs9//q1/9quEpns4444zq/fffn/1/DB0M5513XnW55ZbLhu0NNvR0sOG+73rXu6rLLLNM9YUXXljiFE+14ZobbLDBIvsabOqIGAr5qle9KhsG+NRTT2XXZKmllhp0WDIADDWdxU9+8pPqk08+WZ09e3Y23DymHIrh7fF1zZ577lndcsst+5VnUc7usssu1Y033rjfFIu1qYsGqpXLZ599dvacr33ta33fW7BgQXXnnXfOytm5c+dmj1177bXZ837wgx/0289+++2XlZX1w927urr6yuuayCPx8zGEvya+juf+5je/6ffco48+urrGGmtk5Wm9Qw45pDplypS+crl27N/61rf6nhO5YKONNmp4WqQ777wze+51113Xd17WXnvt6nHHHVcdzhRPYfvtt8+OPTz99NPVcePGZVMDDDYFxGA55dZbb82ed/nllzc0xVPkl/jerFmzlpjpwoUXXth3rW+77bYsyw2clgqg6FM81UR5sO222y526qD6z+iBn5EDp3hqZflVKxc23XTTftPafOELX8gev++++7KvFy5cmE1HFccb5cpg5fhwcsFgHn744ex3nnvuuYt8r3afHbkktnhuTFkT0zttscUWfccQ09csv/zy1Xe84x39fj6mgIrXXf/4YNdpsDIxpuWpzxeLm3Zo4P15HNdaa62VTbFYL/JCPO+mm24a9nEPpvZ7h9r+9re/LfE9U3uvR11CXO+aJ554IssRe++9d79ppr/4xS9mz7/kkksaqvuJaxjfa3Sa7ZrhTPEU2TB+x5e+9KV+j0f+jMdXWmml7H0YrzW2+P94bffee+9i9xt/k/HzX/7ylxs+7njf1M5//I6oAxpsKq24NvXXKrLfwOlUf/3rX2eP154T76e4FjE1aEyJFrmtES972cuq++67b8OvgfIxxRMdL4YBDjYdQ6OiB2X0vIyeEdECXduiBT+GRN50002L/flojY7pDqIHQ63nQG3o5nCnT4hW82h5j8Wya70SDzzwwKyH4WCilXpgj4Z4LdEjIoY4Nip6U9TvayjR8yVGbUQPnei5EEMxo7dCDK0FgEZFGRs96GKYfYzKi16QMeKhNtz/H//4R9YDL6YNqpVvsUUvsOj9F73AYuRjiF6TMV3TYD22auXy//7v/2a9MaMXfk30yIue+1GmxZQDtfI7evtFuV4TCxBGz84o5+uzQ/Q6jd5m9dmhNqogptuoFyM1o3dZTdzDx3EfcMAB2f/X7yNeX/Qwvfvuu/uOPXqUxnmqiVwQvfQaFXkkehnWevHFeYnXE1M81k//0OgoihidED33vvOd72Q98YbqLVefLaLnYVy/mFJk+eWX73t9jYgRL3FeGhHnJZ4bPVCjx19M7RQ9AAHaUfSkj3KwWVpZftXEvXr9qMTatI61qZOiB3/0fI+RF1E+DFaODycXDKa2GHL9aIh60Zs/cklsUU7FaI8YrRFTKteOIbJAjLqMLFH/uqMcjKmjBp67xZWJcZ7iZ+P8xnmIr4crjitGTkROiCxTExkmer3H6IhmHHdNjHqIfQ3cBk5FPfA9Uy9GAtVGdYSf/OQnWZ6Ia18/7VI8b/LkydnokEbqfqKOIt6PYzV6olY3E9lx4JSWtXMf78vrr78+G7kSW7y2OKYYMTSUqLOJ0TMx3XfUyTQqRiXFyKovf/nL2WimOIdRLzVQXJu4RjGiJma8iIxb/14JMdIj/n5ixEr8G9kurkWMvHrzm9+c7T9yX2TtyGOxn3+1RfVXq0+jc5niiY4Xhe9gUxI1Kj6Ef/3rX2dhZDD18xgPJgqGJ598MptvsH4uzagEiIaGGEI5nDkO48b/c5/7XDYkN6ZFWNw0UTHMNdaOiLAWw/zqDSfkREHTqLjRj2GYMdVTzAEZc6MCwHDElAQve9nLsrIqpuWJzgBx01kT5Wnc/EQZM1Q5E+VzZIBYtyJuoBYn5vCOOX4Hlse1aYTi+yGmXIh9xU1oTOkUxxQ3ZVG5Xt9AEdkhpp5oNDsMLGcjN0RlwUUXXZRti9tHHFtUltRPnxAGm+ZoMNEAEQ0RkUuiAqgmKiUib8TN9N57750aFdMqRMVNTOcRDR8xJUfMZT2YmJ4qphyJKTCj4qj+hnasckqIG/bIK3GdIks10gkDoIiiMnGwKfRGqpXlV01MoVyv1kgQHQDq15+Ke8uhDCcXLM5gFash1rOIStwQ00NGpXLsr778iHMXao05A0WF+uLE9Dcx7eCtt966yBoFUSbGOpbDFdkkpoWKTh5RjxDvl2iwiCkRa7lhtMddX5EdHUxGU2YP/F4tfw3MNFG/s8EGG/R9v1l1PyMV5zUaq6IxLKa0qld7j0SDVnS8qX/fRyNR5JDBzJkzJ1sHJK57rcNHo7bZZpu+/4+prmJ602gUif3Ui3NVu2aR12JKzjjO+EyJr2tq67nURP1S1HPFdFuxRfaL6U+jASgauuJ1Dmwoir+tgVmVzqKBgo433JvOgT0FY87HWNQnFgYbTFSgLE5tlMRgi0OG6JW5pHkH68UHfoxKiF4DUfgNVWkQwTB6J0SgiFbsuBGPgiV6rMSC1cNZ4Hu45zAKqxBzLUZvlOiVCgCNikb92o1QzB0dN3BxYx03QdFbtFaGRUX4UD3no9J+LNRuwqICPo4t5huOnqbRc6wmji9u1GPO3sHU36AOVs7WXl/cVA7VYy5GVDZD3GTGmlrRSBHbYDlmOA0UMZoj5i6Oxo2obImetEOJUQzROBE9I6N3YNyEx81rnOOxzCmx3kRtsdeYWz1+N0C7iYryqLhuZnmXR/k1VMXrUI0FQx33aHJBrVK51igyUBxjfeV7/I4o+6Oiv7YId+0YYj2Hwe5/o5PDUKIRJiqHY59x7uM8R+VxNCbE+h/DKRPrRe/2qDSOrBI5KhpZonNAfaeK0Rz3SCyuzB5th4G8OhzE2izRqBRrpwwUa4MNtVZINATECKGB4u86ZqSIOp2f//znffsYiXgfxbomMaoirv3izlGsnxE5rtbBZKj6slj3JdariAahWIc0fq7WIBF/E/HzAxso4m8rOgPRuTRQwBCiZ0Z84NeLoW9xk14vKvajRbyR3gCDDQWNlvQIAPVTL9TE1BHx4T2cBopoaY9W7bi5jkWihgoM8f1oHIienbHAZE1978iaZrZkX3DBBdkwwViMLXpFRgEV5wAARiIqBaI8ibLyi1/8YnZDFL3mQgylX1L5HOV4LA64OOuuu242WjJu0utHUdSmQ4zv10SZGjdvMUVCNJxEBX9tocr633nvvfdmlQ0jKWOj52qMOoibwCW9vji2eH0De6ZFY04jIofEDXKMWhkoMsTVV1+dle3DuemPSpD//M//zKbi2G+//YZ8XvTkiwqsaMyoeeGFFxbJZ83MKZHzomEkGl3ipr1WmVV/jQHaQVQoh0anuGtEK8uv4RxTiLJuqH0OJxcMdY8d5dxg98qDiRwQMxrE4s233XZb1hBQO84oU4d7DNFwEA3n0dhRP6JksOmVhntdoqNkLMYcMypEdokGizjemtEc91irlc2RaWrXuFZvE9eqKMcbWSo60ERDwEDR4Bfvy8GmGIsOnQNHK0UOiinSYlH6mAZqqOmwhiMaJiInxjRTS8pz8fsXN4o1FiiP/UR+qr2G+gaU+P+BrzWml5o9e/ag54fOYQ0KGEIUxAPXj4hhqANHUESBHsMsr7322kX2ETfQg83lVxM39dFIEfMGRgPFwC1apaNnYa0XX6NOPfXUbPhn3GAPpdYTpb7nSRTksS7EQDG390jmtRwoQkJM7RTTX8TUU2eeeWYWsi6//PJR7xuAzhU98mNURUxTEDdOcRMdj8VIhoEdC2pTTNREmRSVLVEmD1QrI6MSPYbS168tEeX7ueeem91wxojEmmjAiDI8KhOiciieV98TsZYd4ubs4osvHvQmMbLB4kQZHscdGWGwxpX61xfHHjeH9cP2oxffUFNrDDyWaISIPDJYTjnmmGOym9Ba79BGxc9GTonMsbipFuJ1DuwhG+d8YBaLnBIGNlyMRIxAjYaomOYpzlF09Dj66KOH1VMXIG/ROB49l2NKnMF6bY9UK8uvRsX0NPE6IwMMLAdqn93DyQWDiQrkGLl55513NnxccS8eaz5Fz/RaQ1HMXhDrGsXUj8M5hsHu3eP+PEYZDhRl4nDKw8goUd/wla98Jc2aNWuRmR1Gc9xjLRogIkecc845/c5NlOFxfmIKpEbEeyI6nQz2+kYrzk80JMR6W4OtDRoNdpHVYiqn+nVAYyq1eCxm66iJ/BPXK+qfYj2YxY3wHOw1DTb9eLxX4u8xRuXUpoOLv+OB04iFeF6MdBhqDdFY6yXy3RlnnJHNzlEbGTLwdQ0cifPb3/42y+8x0oLOZQQFDCF69r373e/OAlQUClF5EY0QsTBQvahwjxvzuHmPefu222677AM9pgSIyoA//vGPi/xMfUt6DBcd6oM4WpAj/MXiTm9605savlZRUVJfWTKY+J0xSiR6JsZIjehpERUpg92Ax2uKSpkZM2akHXbYIauMiVb74Yj9HnXUUVmLfLSqhxg9EYVcDAGMcDGaoYkAdLYoj2Oxx1joMMrv6PEfIxiiZ1pUOkfPuscffzy7qYtpL6Jcr/1clNfxs1FORZkXN1hRtsfIgJiaKRZOjkqNKOfvuuuurHdh/ExMURQVIgPXUIibx6hIj5u0+P21tSpqYvHlmE4hjjN6P8bIx7jpjBu4eDzyxlA3fzVR4RE/G2tBxOuLHnRx3DFVY9wIx/+H+F6MLDn88MOzY49enVHeD3aTPFCcg2iAGKpHW/SwjJ59kWcGNsIsTkzVFOtRLUlkqzjWeH68vrh28doGzt8ccylH5U2s2xUVErH2R8yVPdx516OiJzJXvIdqC67HdYypSCK7vPe97x3W/gBaIaYUjPIjGsSjnIvGiRixHr3L43O8VlHYDK0svxoVHQPiMzruT6M8iKljoqyLY4o1F2sdCRvNBUM58MADsxGRMdKgkXUXoqyKY4nG+KiUjSwQxxnnMBpVYrrCKEMfe+yxrOyJcxnl9WBqo/riNcY9dMzgEPUEUc4NbHCJHBO/JzotxrRV8Zyh1o8IcSzxvHht0VAxsDyP1zrS464XUxFFJfRgU3qNdFrKOI6Y3jpGqrzuda/L8kqMpohzHvUWUX43IvYRDTTRoXJJC2VHJ9ZaR9ZofIi6nzjXtVG09bNThKhHib/NxTUURuNPrOkV1ynqZkI0usQi1fVrisbC0/E3He+D+Dv52te+1m8/9a93sNcU00JFvom/vXhfxDWM7BMdWeo74cS6I1E/E++FmFYs/saicS5+X+wr6m8GE+u7xN9XZOqaqE+LKcVjdo/4TIo8PXCKuPi8ilxa3xhDB6pCh5g+fXrUvPd7bPfdd69uvvnmgz6/p6en+pGPfKS68sorV5dZZpnqPvvsU3344Yer6667bnXatGn9nvvss89WTzzxxOpGG21UHTduXPYzu+yyS/XMM8+sLliwYND9P/7449Wlllqq+va3v33IY37++eez3/3GN75xyOc8+uij2es644wzFvv645iXXXbZfo/dcsst1Ve+8pXViRMnVtdcc83qhz/84eq1116b7e+GG27oe95zzz1Xfdvb3lZdfvnls+/FOQjxnPj629/+9iK/r/a92n6+8IUvZF9fddVV/Z732GOPVSdPnlzdb7/9Fnv8AHDppZdmZckdd9wxaLm94YYbZtvChQuzx/7whz9UDz/88Orqq69eXXrppatrrbVW9fWvf331O9/5Tr+f/fvf/1495phjsu9HOb722mtn5eZTTz3Vr9w+8sgjszI+nrPllltmxzOY3t7e6tSpU7NjPfXUUwd9TuSD008/Pcsh48ePr66wwgrV7bbbrvrJT36y+swzz/Q9L/YRGWYwcUzxvfhd8fride65557Viy66qN/z/vSnP1Xf8IY3ZJkijv+4446rzpo1a5HyfqADDjigOmHChOq8efOGfM4RRxyR/e76czXQ4vJWzWCZ4umnn+4758stt1yWxR544IFBs9jFF19c3WCDDard3d39Xlc8d//99x/0d9bvZ/bs2dUpU6Zkr3mgyGGRoR555JHFvgaAPMrE2hZlU5QDr33ta7N7r7lz5y7yMyeffHLD98RDfX62qvwa6l6zdv87sAy++eabs9c+adKk7DN7q622qp577rn9ntNoLljc/ftXv/rVJd5n1/++KJfqy6x4XVGeRZkTZWzklihL77zzzsVep+9///vZa4qfWW+99bJrcMkll2TPi3NSM2fOnOy6xXmI78X1rT+fg5X7H/3oR7PvRX3GUBo57qF+rv59OnCL17qk98zi8l/44he/WN1kk02ya7raaqtV3/Oe92QZotEsEtdn4HkcSu3aLOm11ER9y6qrrtqXTYdy1113Vffaa6/svRTX7sADD6w+9NBDi7yGxZ3LJb2mOE+vetWrslwV7+VVVlklyz033XRTv5998sknq+985zuzcxrHE58tG2+8cfX444/PvjeYX//619nzfvWrXy3yvcsuuyx7z6600krVGTNmLHIudtppp+phhx222PND+VXiP3k3kgAAAABAUcWUfzH3f4wGAEbvnnvuyUbmxAiqGAFF59JAAQAAAACLEVPivOxlL8um44mpjYDRiSnDYu2vmCKOzqaBAgAAAAAAaLmu1v9KAAAAAACg02mgAAAAAAAAWk4DBQAAAAAA0HIaKAAAAAAAgJZbKrWxWOn9r3/9a5o0aVKqVCp5Hw4AY6BaraZnn302rbnmmqmra2za1V944YW0YMGCpu1v3LhxacKECU3bH80lPwCUn/zAWJAhAMpvrDNEs+sfylAH0dYNFNE4MXXq1LwPA4AWmD17dlp77bXHJBysNHG59Hzqado+V1999fToo4+2dUAoM/kBoHPIDzSTDAHQOcYiQ4xF/UMZ6iDauoEiRk6Eh3//+77/L4pqKqbCjjPpXZiKqNrV1n8iLVUp6DVMlWLOZFct6HEV8TMiei5stPHGY/Y5Hz0XIhwcmtZK45ow8+GC1Ju+Pucv2X7bNRyUXV9+eOjBwuWHwn5m5X0AbaaIn6VFvYZFPFdFPl8MLz9sLD/QZLXc8PsC1kEUVaXamwqpoMelDqJx6iCG+d4q6H1Gp9VBNLv+oSx1EG1d+1qb1ineMJMnT05FUtSbmiL+4WcKWrktHDROOBjme0s4GLaxnspvYupK45pwXbqLWgDQFvlBA0U5FDFvFfWjqYjnqsjni+GTH+iYDFFQGiiGRx3EMN5bBa1HKmyeL+hxFTULjnWGaFb9Q1nqIIr57gQAAAAAAEqtrUdQAECzdFcq2Tbq/UQfkBL0YAAAlkx+AADyyg9lqYPQQAEAMaSwEiGhSUMT2zwcAACNkR8AgLzyQ1nqIEzxBAAAAAAAtJwRFADQ7CkaAICOID8AAHnlh7LUQWigAIAsIDRniGW3swkAHUN+AADyyg9lqYMwxRMAAAAAANByRlAAgCkaAIARMMUTAJBXfijLFE9GUAAAAAAAAC1nBAUAmEMaABgBa1AAAHnlh7KsQaGBAgBM0QAAjIApngCAvPJDMMUTAAAAAADACBhBAQApZctKNWNhpvZfngoAaJT8AADklR/KUgdRiEWyzzvvvLTeeuulCRMmpJ122indfvvteR8SAB06xLIZG60hPwCQN/mh/cgPAJQpP3SXoA4i9waKK6+8Ms2YMSOdfPLJ6e67705bb7112meffdITTzyR96EBAAUlPwAA8gMAtL/cGyjOOuus9I53vCMdeeSRabPNNksXXHBBWmaZZdIll1yS96EB0EG6K83bGHvyAwBFID+0F/kBgLLlh+4S1EHk2kCxYMGCdNddd6W99trr/x9QV1f29a233prnoQEABSU/AADyAwCUQ66LZD/11FOpp6cnrbbaav0ej68feOCBRZ4/f/78bKuZO3duS44TgPL7V8+D0Xc96G7K0bA48gMARSE/lDc/BHUQABQ5P5SlDiL3KZ6GY+bMmWnKlCl929SpU/M+JABKwvDK8pIfABgr8kO5yRAAjAVTPBWogWLllVdO3d3d6fHHH+/3eHy9+uqrL/L8E088MT3zzDN92+zZs1t4tABAEcgPAMBY54egDgIASt5AMW7cuLTddtul66+/vu+x3t7e7Oudd955keePHz8+TZ48ud8GAM0QwyubtTG25AcAikJ+KG9+COogACh6fuguQR1ErmtQhBkzZqRp06al7bffPu24447p7LPPTvPmzUtHHnlk3ocGQAfpyuaAbMJ+mnEwLJH8AEARyA/tRX4AoEz5oSx1ELk3ULz1rW9NTz75ZDrppJPSnDlz0jbbbJNmzZq1yMJVAADyAwCg/gEAyiP3BopwzDHHZBsA5KVZQyO7U/sPr2wX8gMAeZMf2o/8AEDemjk1U3cJ6iDKMAoEAAAAAABoM4UYQQEAeetu0hyQ3c04GACgLcgPAEBe+aEsdRAaKABABQMAMAIaKACAvPJDWRooTPEEAAAAAAC0nBEUAGCRSwBgBCySDQDklR+CRbIBgFGZOXNm2mGHHdKkSZPSqquumg466KD04IMP9nvOCy+8kKZPn55WWmmltNxyy6U3v/nN6fHHH3fmAaBDyQ8AQFkyhCmeAOCleRtr80COahvm2bzxxhuzgv+2225L1113XXrxxRfT3nvvnebNm9f3nPe///3pBz/4Qfr2t7+dPf+vf/1retOb3uS6AUDO5AcAILf8UClHHYQpngAgWuybNMQy9jMcs2bN6vf1ZZddlvViuOuuu9Juu+2WnnnmmfTlL385XXHFFek1r3lN9pxLL700bbrpplmgeOUrX+n6AUBO5AcAIK/8UJY6CCMoAKBAIgyEFVdcMfs3QkL0aNhrr736nrPJJpukddZZJ9166625HScAUBzyAwDQrhnCCAoAqBteOVq1fcydO7ff4+PHj8+2xent7U3HH3982nXXXdMWW2yRPTZnzpw0bty4tPzyy/d77mqrrZZ9DwDIj/wAAOSVH8pSB2EEBQBkhXqlaVuYOnVqmjJlSt8WC1EtScwDef/996dvfvObrgkAtAH5AQDIMz90l6AOwggKABgDs2fPTpMnT+77ekk9F4455pj0wx/+MN10001p7bXX7nt89dVXTwsWLEj//Oc/+/VgePzxx7PvAQDlIT8AAJ2WIYygAIC6IZbN2EIEg/ptqHBQrVazYHD11Venn/70p2n99dfv9/3tttsuLb300un666/ve+zBBx9Mjz32WNp5551dOwDIkfwAAOSZH7pLUAdhBAUA5CiGVF5xxRXpmmuuSZMmTeqb0zGGZE6cODH79+ijj04zZszIFq2KoHHsscdmweCVr3ylawcAHUh+AADKkiFK0UBRfWmjfS2sFPStWMA3VrMW0Wm2noJew6Ker94CvrdCEQ9rYYsOqn7uxtHuZzjOP//87N899tij3+OXXnppOuKII7L///znP5+6urrSm9/85jR//vy0zz77pC996UujPtZON7+3km1FMq47FVJRP7O6inX5+hTxdBX0VBXyXBWZ61g88kNnqvQsyLZC6R6X9xG0FXUQ7X9PrQ6iHHm+U+sgmpUfylIHUcwaRQBosa5KJduasZ/hiOGVSzJhwoR03nnnZRsAUBzyAwCQV34oSx2ENSgAAAAAAICWM4ICAGKofnclVZowX0ylSb0gAIDikx8AgLzyQ1nqIDRQAEAMKeyupK4mBIRmDdMEAIpPfgAA8soPZamDMMUTAAAAAADQckZQAEDo7kqVria021eWvOAUAFAS8gMAkFd+KEkdhBEUAAAAAABAyxlBAQDR6aCrki1UNVqV1P7zPwIAjZEfAIC88kNZ6iA0UABAbZGqJgSErhKEAwCgMfIDAJBXfihLHYQpngAAAAAAgJYzggIAsiGWzVmkqlJt/wWqAIDGyA8AQF75oSx1EBooAMAUDQDACJjiCQDIKz8EUzwBAAAAAACMgBEUABDDIrsr2TZalRIsUAUANEZ+AADyyg9lqYOwSDYAAAAAANByRlAAQF8PhiYskp16nU8A6BDyAwCQV34oSx2EBgoAsMglADACFskGAPLKD8Ei2QAAAAAAACNgBAUAxLDISiVVupqwSHZv+y9QBQA0Rn4AAPLKD2Wpg9BAAQDZEMuubButrmpz5pEEAIpPfgAA8soPZamDaP9XAAAAAAAAtB0jKAAghkV2V7JttCrV9h9eCQA0Rn4AAPLKD2WpgzCCAgAAAAAAaDkjKABAD0gAYASMoAAA8soPZRlBoYECACxyCQCMgEWyAYC88kOwSDYAAAAAAMAIGEEBAKFZQyxLMLwSAGiQ/AAADFcTp3hKJaiDsEg2AAAAAADQckZQAEC02Fcqqaur0pT9AACdQX4AAPLKD2Wpg9BAAQAppUp3V7aNVqXX4EQA6BTyAwCQV34oSx1E+78CAAAAAACg7RhBAQDRYt9dybbR6upt/+GVAEBj5AcAIK/8UJY6CA0UAJANsaxk22hVShAOAIDGyA8AQF75oSx1EKZ4AgAAAAAAWs4ICgCwyCUAMAIWyQYA8soPwSLZAAAAAAAAI2AEBQBki1T9a6Gq0erqdToBoFPIDwBAXvmhLHUQGigAIIZFdlWybbSasQ8AoD3IDwBAXvmhLHUQFskGAAAAAABazggKAIgW+66u1NWERaq6erT9A0CnkB8AgLzyQ1nqIErRQFHpXZhtRVLtKsWp7XhNmg6uqQp4SIxACUbgle7vsNJdybZm7If2MHH+02niC8XKDz3LrpSKqKhv62oqpiKerqKeK8qh0sHHJD90pud6l0qV3mLd80/qToVUrRS04qygBWMnf54yttRBFOvep1n5oSx1EAUtKQAAAAAAgDIrVpM/AOSk0t2Vbc3YDwDQGeQHACCv/FCWOoj2fwUAAAAAAEDbMYICAKLXQVdXto1WM/YBALQH+QEAyCs/lKUOQgMFAMSQwu6ubButZuwDAGgP8gMAkFd+KEsdRPu/AgAAAAAAoO0YQQEAoVmLVJWg9wIA0CD5AQAYriYukp1KUAehgQIAanNANqFgL8P8jwBAY+QHACCv/FCWOoj2fwUAAAAAAEDbMYICAGo9GJrQ86AMvRcAgMbIDwBAXvmhLHUQ7f8KAAAAAACAtmMEBQBEr4NskaruUZ+LSneP8wkAHUJ+AADyyg9lqYPQQAEAfQGhCVM8NWmhKwCg+OQHACCv/FCWOoj2fwUAAAAAAEDbMYICAKLFvqsr20arGfsAANqD/AAA5JUfylIHoYECAEzRAACMgCmeAIC88kMwxdMozZw5M+2www5p0qRJadVVV00HHXRQevDBB0e7WwCgxOQHAEB+AIByyHUMyI033pimT5+ebrvttnTdddelF198Me29995p3rx5eR4WAB3cg6EZG2NLfgCgKOSH9iE/AFDG/FApQR1ErlM8zZo1q9/Xl112WTaS4q677kq77bZbbscFABSX/AAAyA8AUA6FWoPimWeeyf5dccUVB/3+/Pnzs61m7ty5LTs2AMqtUulKlSYsLhX7obXkBwDyIj+UNz8EdRAAFDk/lKUOojCvoLe3Nx1//PFp1113TVtsscWQc05PmTKlb5s6dWrLjxOAcjK8sj3JDwDkSX4ob34I6iAAGAumeCpoA0WsRXH//fenb37zm0M+58QTT8x6OdS22bNnt/QYAYBikR8AgLHID0EdBAB0yBRPxxxzTPrhD3+YbrrpprT22msP+bzx48dnGwA0W7MWlyrDAlXtQn4AIG/yQ3nzQ1AHAcBYaObi1pUS1EHk2kBRrVbTsccem66++ur0s5/9LK2//vp5Hg4A0AbkBwBAfgCAclgq72GVV1xxRbrmmmvSpEmT0pw5c7LHY32JiRMn5nloAHSYru6ubGvGfhhb8gMARSE/tA/5AYCy5Yey1EHk2kBx/vnnZ//uscce/R6/9NJL0xFHHJHTUQHQiSpdlVTpasIUT12VphwPQ5MfACgK+aF9yA8AlC0/lKUOIvcpngAA5AcAQP0DAHSeQiySDQB5s8glACA/AADtUv8QLJINACWhgQIAkB8AgHapfyhLA0X7vwIAAAAAAKDtmOIJAKLXQaWrOYtkV7T9A0CnkB8AgLzyQ1nqINr/FQAAAAAAAG3HCAoAyOZt7E5d3d1N2Q8A0BnkBwAgr/xQljoIDRQAYJFsACDHRS7LsMAlANAYi2T3JwUBQI5uuummdMABB6Q111wzVSqV9L3vfa/f96vVajrppJPSGmuskSZOnJj22muv9Pvf/z634wUAikGGAADKkB80UABAXQ+GZmzDMW/evLT11lun8847b9Dvf/azn03nnHNOuuCCC9Ivf/nLtOyyy6Z99tknvfDCC64bAHRofggyBAC0p2bmh0oJ6iBM8QQAERC6urJttIa7j3333TfbBhM9F84+++z0sY99LB144IHZY5dffnlabbXVsl4OhxxyiGsHAB2YH4IMAQCdnR/KUgdhBAUAFNSjjz6a5syZkw2prJkyZUraaaed0q233prrsQEAxSVDAADtkh+MoACAMVjkcu7cuf0eHz9+fLYNRwSDEL0V6sXXte8BAPkpYn4IMgQAdNYi2XPbuA7CCAoAGANTp07NehrUtpkzZzrPAID8AACog6hjBAUAZPM2VprTA7Krkv07e/bsNHny5L7HR9L7cfXVV8/+ffzxx9Maa6zR93h8vc0227huAJCzIuaHIEMAQPnzQ1nqIErRQFHtWirbiqTSuzAVUdHOU82//pSKp1LtTUXTU9CBT90FvYgLincJMy+VH4WzVAGPq9Kmi1xGMKgPByOx/vrrZwHh+uuv7wsDMWzzl7/8ZXrPe94z6mPtdP9cavnUs/TorlGzrfTQz1MR/XP9XVMRTViqmGViET9Le6upkIqaH4qqoJexo89VEfNDkCHG1uSFz6XJC4v1AXbfMyNrzBprW0wqZt1IZfxyeR9C2yhq2VPUDKEOov1zc6VNF8me3MZ1EMWsrQaADvHcc8+lhx9+uN+iVPfcc09accUV0zrrrJOOP/74dOqpp6aNN944Cwsf//jH05prrpkOOuigXI8bAMiXDAEAlCE/aKAAgKzXQXe2jdZw93HnnXemV7/61X1fz5gxI/t32rRp6bLLLksf/vCH07x589I73/nO9M9//jO96lWvSrNmzUoTJkxw3QCgQ/NDkCEAoLPzQ1nqIDRQAECIQr0ZAWGY+9hjjz1StTr0wOlKpZI+9alPZRsAUDA55YcgQwBAh+eHktRBFHPiXgAAAAAAoNSMoACAEAtLNWORqiYtdAUAtAH5AQDIKz+UpA6i/V8BAAAAAADQdoygAICYZ7G7O9tGqxn7AADag/wAAOSVH8pSB6GBAgByXuQSAGhT8gMAkFd+KEkdhCmeAAAAAACAljOCAgD6FqlqxggKbf8A0DHkBwAgr/xQkjoIDRQAEPM2dnVl22g1Yx8AQHuQHwCAvPJDWeog2v8VAAAAAAAAbccICgAIlSYtUhX7AQA6g/wAAOSVH0pSB2EEBQAAAAAA0HJGUABAiN4LTVkku/17LwAADZIfAIC88kNJ6iA0UACARS4BgBGwSDYAkFd+CBbJBgAAAAAAGAEjKAAgmKIBABgu+QEAyCs/lGSKJ4tkAwAAAAAALWcEBQCEmP+xKYtka/sHgI4hPwAAeeWHktRBaKAAgFhYqrs720arGfsAANqD/AAA5JUfylIH0f5NLAAAAAAAQNsxggIA+oZYNqHdvgTDKwGABskPAEBe+aEkdRAaKAAgxPyPTVmDov2HVwIADZIfAIC88kNJ6iDav4kFAAAAAABoO0ZQAEAsLNXVnW2j1Yx9AADtQX4AAPLKD2WpgzCCAgAAAAAAaDkjKAAgVJq0SFXsBwDoDPIDAJBXfihJHYQGCgAwRQMAMAKmeAIA8soPwRRPAAAAAAAAI2AEBQCEGF7ZjB4MzRqmCQAUn/wAAOSVH0pSB6GBAgD6AkITCvYShAMAoEHyAwCQV34oSR1E+78CAAAAAACg7RhBAQCxsFR3d7aNVjP2AQC0B/kBAMgrP5SlDsIICgAAAAAAoOWMoACAEAtUNWWR7PbvvQAANEh+AADyyg8lqYPQQAEAQQUDADBc8gMAkFd+KEkDhSmeAAAAAACAljOCAgBiYamurmwbrWbsAwBoD/IDAJBXfihLHYQGCgAIlSYNsYz9AACdQX4AAPLKDyWpgyhFA0Wl2ptthdJVilPbMl2VVEgLq8VrhSzoqUrVVEzjKgX7bKipFO+9FRYW8EIW8Zgoh63fclqqLDU+Fck9V52ciuj55xamItpw+XF5H8Kgegr4uVXUrFXEcxW6C3q+CnpYheRcMZZO2ei1aXzB8vyn/3BNKqKup+alIlqw5papiKoFe18xfONcwra/3y/iMZWdWnQACJVKcxqOYj8AQGeQHwCAvPJDSeogtOsBAAAAAAAtZwQFAITovdCUERTa/gGgY8gPAEBe+aEkdRAaKADgpflemzHnq3ljAaBzyA8AQF75oSx1EO3/CgAAAAAAgLZjBAUABFM0AADDJT8AAHnlh1CCERQaKAAgVCr/2karGfsAANqD/AAA5JUfSlIH0f5NLAAAAAAAQNsxggIAQlfXv7bRasY+AID2ID8AAHnlh5LUQbT/KwAAAAAAANqOERQAkFKqVrqybbSasQ8AoD3IDwBAXvmhLHUQGigAIESh3oyCvQThAABokPwAAOSVH0pSB9H+rwAAAAAAAGg7RlAAQNADEgAYLvkBAMgrPwQjKAAAAAAAANp4iqfPfOYzqVKppOOPPz7vQwGgk3swNGOjpWQIAHIjP7Qt+QGAUuSHSvvXQRRiiqc77rgjXXjhhWmrrbbK+1AA6FDVSiVVm1Cwx35oHRkCgDzJD+1JfgCgDPmhLHUQuTexPPfcc+nQQw9NF198cVphhRXyPhwAoE3IEACA/AAA7S33Borp06en/fffP+211155HwoAnczwyrYjQwCQO/mh7cgPAOTOFE/FmeLpm9/8Zrr77ruz4ZWNmD9/frbVzJ07dwyPDoCOEsMimzE0sgTDK9vBcDKE/ADAmJEf2oo6CABKlR9KUgeR2wiK2bNnp+OOOy59/etfTxMmTGjoZ2bOnJmmTJnSt02dOnXMjxMAKJbhZgj5AQBQBwEAxZRbA8Vdd92VnnjiifSKV7wiLbXUUtl24403pnPOOSf7/56enkV+5sQTT0zPPPNM3xYBAwCawhQNbWO4GUJ+AGDMyA9tQx0EAIVhiqdiTPG05557pvvuu6/fY0ceeWTaZJNN0kc+8pHU3d29yM+MHz8+2wCAzjXcDCE/AADqIACgmHJroJg0aVLaYost+j227LLLppVWWmmRxwFgrFUrXdnWjP0wtmQIAIpCfmgf8gMAZcsPZamDyHWRbAAojCjUu5pQsJcgHAAADZIfAIC88kNJ6iAK1UDxs5/9LO9DAADakAwBAMgPANB+CtVAAQC5L1LVjP0AAJ1BfgAA8soPJamD0EABAEEFAwAwXPIDAJBXfihJA0X7vwIAAAAAAKAzGigeeeSR5h8JABShB0MzNoYkQwBQKvJDS8gPAJRKM/NDpUOneNpoo43S2muvnXbfffe0xx57ZP/GYwAAMgQA0EzqIACgvEbUxDJ79uw0c+bMNHHixPTZz342vexlL8saLA499ND03//9380/SgAYY9VKJVUrXU3YKq7VYsgQAJSJ/NAa8gMAZdK8/NBVijqIETVQrLXWWlljxEUXXZQefPDBbNtrr73St771rfSud72r+UcJAGPN8MqWkCEAKBX5oSXkBwBKxRRPo5/i6fnnn08333xz+tnPfpZtv/rVr9Imm2ySjjnmmGzKJwAAGQIAaAZ1EABQXiNqoFh++eXTCiuskI2iOOGEE9K//du/ZV8DQNuKYZHNGBpZguGVY0mGAKBU5IeWkB8AKJVm5YeS1EGMqIFiv/32y0ZQfPOb30xz5szJthg5EWtRAEBbD7Fsxn4YkgwBQKnIDy0hPwBQKs3KDyWpgxjRK/je976XnnrqqTRr1qy08847px//+MfZKIravJAAwPCcd955ab311ksTJkxIO+20U7r99ttLeQplCABoHvlBHQQAtHt+GFUTy5Zbbpl23XXXrJFihx12SE888US68sorm3d0ANAi1UpX07bhirJzxowZ6eSTT05333132nrrrdM+++yTlatlJUMAUAbyQ2vJDwCUQTPzQ3WYdRBFrH8YUQPFWWedld7whjeklVZaKWtl+cY3vpFN73TVVVelJ598svlHCQAlFuXqO97xjnTkkUemzTbbLF1wwQVpmWWWSZdcckkqGxkCAJpXpsoP6iAAoN3zw4jWoIgGid133z29853vzKZ2mjJlSvOPDADaeA7puXPn9nt4/Pjx2TbQggUL0l133ZVOPPHEvse6urrSXnvtlW699dZUNjIEAKUiP7SE/ABAqYzBGhRzG6iDKGr9w4gaKO64445U2ovaJNVUTL0FPbDugi44v1TqzfsQ2kZPtVh/gzVdBftsqCnoW76Q7/lWHVO1Usm2ZuwnTJ06td/jMXzyE5/4xCLPjzWdenp60mqrrdbv8fj6gQceSGVTpAyx6Z57paUmLJuKZFx3MT+zlhtXzE+tpXpeSEVU7R6XimZhQctpaHfyQ+flh3Dg7uuk5ZYaUXXKmKmOm5iKaOGyK6UiWlDQcnHpAkauSs+CVEgFzFuhR73bsHRqHUSz8sNw6yCKWv8w4hL1n//8Z/ryl7+cfve732Vfx5CQo48+2mgKAEgpzZ49O02ePLnvXAw2eqJTyRAAMDj5QX4AgE7LECNqMr7zzjvThhtumD7/+c+nf/zjH9kW/x+PxeIaANBuqtXmbSGCQf02VDhYeeWVU3d3d3r88cf7PR5fr7766qlsZAgAykR+aA35AYAyaWZ+qA6jDqKo9Q8jaqB4//vfny2S/cc//jF997vfzbZHH300vf71r0/HH398848SAMZYb7XatG04xo0bl7bbbrt0/fXX//9j6e3Nvt55551T2cgQAJSJ/NAa8gMAZdLM/NA7jDqIotY/LDXS3gsXX3xxWqpuzsX4/w9/+MNp++23b+bxAUDpzZgxI02bNi0rQ3fcccd09tlnp3nz5qUjjzwylY0MAQDNIT+ogwCAMuSHETVQxDCRxx57LG2yySaLzHU1adKkZh0bALRM9DloxnpmI9nHW9/61vTkk0+mk046Kc2ZMydts802adasWYssXFUGMgQAZSI/tIb8AECZNCs/pBHsp4j1DyNqoIgXEgtin3nmmWmXXXbJHrvlllvSBz/4wXTIIYc0+xgBoPSOOeaYbCs7GQIAmkd+UAcBAO2eH0bUQBENE5VKJR1++OFp4cKFqVqtZnNYvfe9702nnXZa848SAMZYb/VfWzP2w9BkCADKRH5oDfkBgDJpVn4oSx3EiBbJjsaIL3zhC+npp59O99xzT7r33nvTP/7xj7TWWmul9ddfv/lHCQBjLBrbm7UxNBkCgDKRH1pDfgCgTJqZH6olqIMYVgPF/Pnz04knnpgtorHrrrumH//4x2nLLbfMFrzceOONs0aL97///WN3tABAW5IhAAD5AQAY1RRPsXjGhRdemPbaa6/0i1/8Ih188MHZCt+33XZb+tznPpd93d3dPZxdAkAhmKJhbMkQAJSR/DC25AcAysgUT6NooPj2t7+dLr/88vSGN7wh3X///WmrrbbK1qCIKZ5iTQoAABkCAGgGdRAAUH7DaqD485//nLbbbrvs/7fYYos0fvz4bEonjRMAlEH7z9xYXDIEAGUlP4wd+QGAspIfRthA0dPTky1O1ffDSy2VlltuueHsAgAKyRQNY0uGAKCM5IexJT8AUEameBpFA0WsCn7EEUdkIyfCCy+8kN797nenZZddtt/zvvvd7w5ntwBAyckQAID8AACMqoFi2rRp/b4+7LDDhvPjAFDoCvTYmrEfFiVDAFBG8sPYkh8AKKNm5Yey1EEMq4Hi0ksvHbsjAYAc9b60NWM/LEqGAKCM5IexJT8AUEbNyg9lqYPoyvsAAAAAAACAzjOsERQAUFYxKrIZIyNLMLoSAGiQ/AAA5JUfylIHYQQFAAAAAADQckZQAEDM21j91zZazdgHANAe5AcAIK/8UJY6CA0UAJANi6xm22g1Yx8AQHuQHwCAvPJDWeogTPEEAAAAAAC0nBEUABDDIl/aRqsZ+wAA2oP8AADklR/KUgehgQIAYlhkNjRy9Kei/QdXAgCNkh8AgLzyQ1nqIEzxBAAAAAAAtJwRFAAQwyKr1WwbrWbsAwBoD/IDAJBXfihLHYQRFAAAAAAAQMsZQQEAtTkgm3Am2r/vAgDQKPkBAMgrP5SlDkIDBQBkwyL/tY1WM/YBALQH+QEAyCs/lKUOwhRPAAAAAABAyxlBAQChmlJT1pYqQe8FAKBB8gMAkFd+KEkdhAYKAIhhkamabaPVjH0AAO1BfgAA8soPZamDMMUTAAAAAADQckZQAECMimzSEMumDdMEAApPfgAA8soPZamDMIICAAAAAABoOSMoACDmbaz+axutZuwDAGgP8gMAkFd+KEsdhAYKADBFAwAwAqZ4AgDyyg/BFE8AAAAAAAAjYAQFAMSwyFTNttFqxj4AgPYgPwAAeeWHstRBWCQbAAAAAABouVKMoIh2ovZvK+psPQW9gN2pgKq9qYi6uorZ3lkp6PlKlWKer2oBj6tVx2QO6c5z7/e/kyrd41KRrDZ9q1REcy/9TCqi6rtOTYVUwLJnqVS8Y8p0leJ2hA4mP3Smr/30j2lcwfp7nrrMGqmIPn3DI6mIPvXaFVIRFXGx266C5eWi6y5q5irYZ1ZNTwGPqxXHZA2K/twRAEB2M1DNttFqxj4AgPYgPwAAeeWHstRBFK+ZCgAAAAAAKD0jKAAghnH2/msbrWbsAwBoD/IDAJBXfihLHYQGCgAwRQMAMAKmeAIA8soPwRRPAAAAAAAAI2AEBQC81OugxyLZAMAwyA8AQF75IRhBAQAAAAAAMAJGUABA1uugOT0PYj8AQGeQHwCAvPJDWeogNFAAQEqpp/df22g1Yx8AQHuQHwCAvPJDWeoguvI+AAAAAAAAoPMYQQEALy0s1ZwpnkowvhIAaIj8AADklR/KUgehgQIAYlhktZpto9WMfQAA7UF+AADyyg9lqYMwxRMAAAAAANByRlAAQAyLzIZGjv5UlGB9KgCgQfIDAJBXfihLHYQRFAAAAAAAQMsZQQEAMW9jbzXbRqsZ+wAA2oP8AADklR/KUgeR+wiKv/zlL+mwww5LK620Upo4cWLacsst05133pn3YQHQYarVauptwhb7YezJDwAUgfzQXuQHAMqUH3pLUgeR6wiKp59+Ou26667p1a9+dfrRj36UVllllfT73/8+rbDCCnkeFgBQYPIDACA/AEA55NpAcfrpp6epU6emSy+9tO+x9ddfP89DAqBD9VT/tTVjP4wt+QGAopAf2of8AEDZ8kNZ6iByneLp+9//ftp+++3TwQcfnFZdddW07bbbposvvnjI58+fPz/NnTu33wYAzdCs4ZWxMbbkBwCKQn4ob34I6iAAKHp+6C1BHUSuDRSPPPJIOv/889PGG2+crr322vSe97wnve9970tf+cpXBn3+zJkz05QpU/q2GH0BAHQW+QEAGOv8ENRBAEDJp3jq7e3NejB8+tOfzr6OHgz3339/uuCCC9K0adMWef6JJ56YZsyY0fd1jKDQSAFAM/T0VrOtGfthbMkPABSF/FDe/BDUQQBQ5PxQljqIXEdQrLHGGmmzzTbr99imm26aHnvssUGfP378+DR58uR+GwDQWeQHAGCs80NQBwEAJR9Bseuuu6YHH3yw32MPPfRQWnfddXM7JgA6U7PmbizD/I9FJz8AUBTyQ/uQHwAoimauHdFbgjqIXBso3v/+96dddtklG2L5lre8Jd1+++3poosuyjYAaKWe6r+2ZuyHsSU/AFAU8kP7kB8AKFt+KEsdRK5TPO2www7p6quvTt/4xjfSFltskU455ZR09tlnp0MPPTTPwwIACkx+AADkBwAoh1xHUITXv/712QYAeTJFQ3uRHwAoAvmhvcgPABSBKZ4K1kABAEXQ21vNtmbsBwDoDPIDAJBXfihLHUSuUzwBAAAAAACdyQgKAMiGWDZncakSdF4AABokPwAAeeWHstRBGEEBAAAAAAC0nBEUAGCRSwBgBCySDQDklR9Cs/aTJw0UAJBieGU120arGfsAANqD/AAA5JUfylIHYYonAAAAAACg5YygAIAYFtlbzbbRasY+AID2ID8AAHnlh7LUQRhBAQAAAAAAtJwRFAAQ8zZmczc2Zz8AQGeQHwCAvPJDWeogNFAAQAyLrFazbbSasQ8AoD3IDwBAXvmhLHUQpngCAAAAAABaTgMFAGTDK6tN28bKaaedlnbZZZe0zDLLpOWXX37Q5zz22GNp//33z56z6qqrpg996ENp4cKFrjEAdGh+CDIEAJQzP/SUoA6iFFM8VV7aCqW3mJVBXV3FvOSVgp6v+dXuVDTju4rZrli4v8GXVCvO13C82Js69ph6e6upp7cJUzw1YR9DWbBgQTr44IPTzjvvnL785S8v8v2enp4sGKy++urpF7/4Rfrb3/6WDj/88LT00kunT3/602N2XO3qof89I02aPDkVyRMLizk89y9v/Hgqom0K+hlfSEU9Vz0LUhH1dI1LRdRdLWZmTgW9x2iFdsgPQYZors8+en2aPHlSKpLKc39JRfTZDZ5IRbQwbZCK6P96i3dnPbG7eMcUChqb01IFzVxFPV9jXPyNSLPWhmhFfihLHUQx/2oAgEV88pOfTO9///vTlltuOejZ+fGPf5x++9vfpq997Wtpm222Sfvuu2865ZRT0nnnnZcFCwCgM8kQAEBR84MGCgCIlv+XejA0Ywtz587tt82fP3/Mz/Ott96aBYfVVlut77F99tkn+/2/+c1vXGcAaLIy5IcgQwBAe+aHnhLUQWigAIAxMHXq1DRlypS+bebMmWN+nufMmdMvGITa1/E9AKDY8sgPQYYAgPY2tY3rIDp3slAAqFPf82A0avuYPXt2mly3vsH48eMHff4JJ5yQTj/99MXu83e/+13aZJNNXC8AKJi88kOQIQCgs/NDWeogNFAAQFao//+CfbT7CREM6sPBUD7wgQ+kI444YrHP2WCDxhbxi4Wpbr/99n6PPf74433fAwDKkR+CDAEAnZ0fylIHoYECAHK0yiqrZFsz7Lzzzum0005LTzzxRFp11VWzx6677rospGy22WZN+R0AQDHIEABAGfKDBgoAGIMpGsbCY489lv7xj39k//b09KR77rkne3yjjTZKyy23XNp7772zEPD2t789ffazn83mfPzYxz6Wpk+fvtgpIgCA8uaHIEMAQLmneGrn/KCBAgDapILhpJNOSl/5ylf6vt52222zf2+44Ya0xx57pO7u7vTDH/4wvec978l6Miy77LJp2rRp6VOf+tSYHRMAdLJ2yA9BhgCA4miXBoqTWlQHoYECANrEZZddlm2Ls+6666b//d//bdkxAQDFJ0MAAEXNDxooACCl1NukHgyxHwCgM8gPAEBe+aEsdRBdeR8AAAAAAADQeYygAICYt7HapDmkq+3fewEAaIz8AADklR/KUgehgQIA2miRSwCgOOQHACCv/FCWOghTPAEAAAAAAC1nBAUA6AEJAIyAERQAQF75oSwjKDRQAEBKaWFvNXU3oWCP/QAAnUF+AADyyg9lqYMwxRMAAAAAANByRlAAgCkaAIARMMUTAJBXfijLFE9GUAAAAAAAAC1nBAUApJR6m9SDIfYDAHQG+QEAyCs/lKUOQgMFAMSwyGo120arGfsAANqD/AAA5JUfylIHYYonAAAAAACg5YygAACLXAIAI2CRbAAgr/xQlkWyNVAAgAoGAGAENFAAAHnlh7I0UJjiCQAAAAAAaDkjKABAD0gAYASMoAAA8soPwQgKAAAAAACAETCCAgCi10G1N/X09jZlPwBAZ5AfAIC88kNZ6iA0UABASqm3SUMsYz8AQGeQHwCAvPJDWeogLJINAAAAAAC0nBEUAPDSwlJdTeh5UIYFqgCAxsgPAEBe+aEsdRBGUAAAAAAAAC1nBAUApJQW9qZUaULPg9gPANAZ5AcAIK/8UJY6CA0UAGCKBgBgBEzxBADklR+CKZ4AAAAAAABGwAgKANADEgAYASMoAIC88kNZRlBooAAAFQwAwAhooAAA8soPZWmg6Mr7AAAAAAAAgM5jBAUApJR6e6tN6XkQ+wEAOoP8AADklR/KUgdhBAUAAAAAANByRlAAwEvzNlaa0POgDPM/AgCNkR8AgLzyQ1nqIErRQBGXoWiXotJVzFNb6V2Yiqha0PO1VLWA56pSSUVUqfamIqpUijlQrIBvrcy4rs49pmq1mqpNKNhjP7SHO/76XFpmbrE+U/e4+8JURNV9P5D3IbSV+b3Fel+FCdUXUhG92D0hFVHxruBLCpqZqx18TPJDZ6r+7qZUXXaZVCTnd++Uiui9662ViqinoBOKTKwUr85mfk93KqIJ1fmpiIpav1WpFPO4xlV6O/KYmpUfylIHUcxPZAAAAAAAoNSK2XwGAC0WC0s1Y3GpMixQBQA0Rn4AAPLKD2Wpg9BAAQC1IZZNGBpZhuGVAEBj5AcAIK/8UJY6CFM8AQAAAAAALWcEBQBEr4PeJi2SXYLhlQBAY+QHACCv/FCWOggjKAAAAAAAgJYzggIALHIJAIyARbIBgLzyQ7BINgCURLX3X1sz9gMAdAb5AQDIKz+UpQ7CFE8AAAAAAEDLmeIJAKLXQbWabaPVjH0AAO1BfgAA8soPZamD0EABAOaQBgBGwBoUAEBe+aEsa1CY4gkAAAAAAGg5IygAIFtYqppto9WMfQAA7UF+AADyyg9lqYMwggIAAAAAAGg5IygAIDSrB0MJei8AAA2SHwCA4WriCIpUgjqIXEdQ9PT0pI9//ONp/fXXTxMnTkwbbrhhOuWUU0qx+jgA7aW3Wm3axtiSHwAoCvmhfcgPAJQxP/SWoA4i1xEUp59+ejr//PPTV77ylbT55punO++8Mx155JFpypQp6X3ve1+ehwYAFJT8AADIDwBQDrk2UPziF79IBx54YNp///2zr9dbb730jW98I91+++15HhYAHShG7zVlkewS9F4oOvkBgKKQH9qH/ABA2fJDWeogcp3iaZdddknXX399euihh7Kv77333nTzzTenfffdd9Dnz58/P82dO7ffBgDNEOGgWRtjS34AoCjkh/Lmh6AOAoCi54dqCeogch1BccIJJ2SNDJtssknq7u7O5oQ87bTT0qGHHjro82fOnJk++clPtvw4AYDikB8AgLHOD0EdBACUfATFt771rfT1r389XXHFFenuu+/O1qI488wzs38Hc+KJJ6Znnnmmb5s9e3bLjxmAcurtja3ahC3vV1J+8gMARSE/lDc/BHUQABQ7P1RLUQeR6wiKD33oQ1kvhkMOOST7esstt0x/+tOfsl4K06ZNW+T548ePzzYAoHPJDwDAWOeHoA4CAEreQPH888+nrq7+gzhiqGVvGZp+AGi/RaqasLhUGRaoKjr5AYCikB/ah/wAQNnyQ1nqIHJtoDjggAOyOR/XWWedtPnmm6df/epX6ayzzkpHHXVUnocFQAeq9v5ra8Z+GFvyAwBFIT+0D/kBgLLlh7LUQeTaQHHuueemj3/84+m9731veuKJJ9Kaa66Z3vWud6WTTjopz8MCAApMfgAA5AcAKIdcGygmTZqUzj777GwDgDzF4lKV3mpT9sPYkh8AKAr5oX3IDwCULT+UpQ6i/wIQAAAAAAAAZR9BAQBFUe2tZlsz9gMAdAb5AQDIKz+UpQ5CAwUAqGAAAEZAAwUAkFd+KEsDhSmeAAAAAACAljOCAgBiYalqNVWqTVgkuwn7AADag/wAAOSVH8pSB6GBAgBM0QAAjIApngCAvPJDMMUTAAAAAADACBhBAQDR66DanB4MsR8AoDPIDwBAXvmhLHUQFskGAAAAAABazggKAHhp3sbeZoygaFIvCACg+OQHACCv/FCWOggNFABQG2LZhKGRZRheCQA0Rn4AAPLKD2WpgzDFEwAAAAAA0HJGUADAS8Mim7JIdgmGVwIAjZEfAIC88kNZ6iA0UABASv+a/7EJBXuz5pEEAIpPfgAA8soPZamDKEUDReWlrVCqvamIeirFvORFnWusq3BvrJR6Cvq5s1SlqFexmAr41soU8e1VxGPKwx//+Md0yimnpJ/+9Kdpzpw5ac0110yHHXZY+uhHP5rGjRvX97xf//rXafr06emOO+5Iq6yySjr22GPThz/84VyPvagmHPnWNLG7OxXJdVd8PxXRzt3F/NRaWNAPiAnV+aloFnZPyPsQ2koRM2Cmd2EqokoBc2CloPdjeZAhmm/3WZNS9/hlUpHcsddPUxFVJ74+FVF3KuZnxPxqsbJpGFfQHFjtLWb9VipgmRgKGptTTwFrBIt4TGXPDwX9awaA1qr29mRbM/YzFh544IHU29ubLrzwwrTRRhul+++/P73jHe9I8+bNS2eeeWb2nLlz56a999477bXXXumCCy5I9913XzrqqKPS8ssvn975zneOyXEBQCcren4IMgQAlDM/lKUOQgMFALSB173uddlWs8EGG6QHH3wwnX/++X3h4Otf/3pasGBBuuSSS7IeDZtvvnm655570llnnaWBAgA6lAwBABQ5PxizAgB1PRiasbXKM888k1ZcccW+r2+99da022679Rtuuc8++2Qh4umnn3adAaDJ2jE/BBkCAMqRH6olqIMwggIAsoDQ26QpGnr7hjrWGz9+fLY1y8MPP5zOPffcvp4LIeaFXH/99fs9b7XVVuv73gorrNC03w8AtF9+CDIEAJQjP5SlDsIICgAYA1OnTk1Tpkzp22bOnDno80444YRUqVQWu8Xcj/X+8pe/ZEMtDz744GwOSACgs/JDkCEAgDLUQRhBAQDR66CnJ9tGq7aP2bNnp8mTJ/c9PlTPhQ984APpiCOOWOw+Y67Hmr/+9a/p1a9+ddpll13SRRdd1O95q6++enr88cf7PVb7Or4HAJQjPwQZAgA6Oz+UpQ5CAwUARKFebc7cjbGfEMGgPhwMZZVVVsm2RkSvhQgG2223Xbr00ktTV1f/gZA777xz+uhHP5pefPHFtPTSS2ePXXfddenlL3+56Z0AoET5IcgQANDZ+aEsdRCmeAKANhDBYI899kjrrLNONufjk08+mc3pGFvN2972tmxxqqOPPjr95je/SVdeeWX6whe+kGbMmJHrsQMA+ZEhAIAi5wcjKAAgW1iqST0gm9QLYqDohRCLUsW29tpr9/+d1Wr2b8wz+eMf/zhNnz496+Gw8sorp5NOOim9853vHJNjAoBOV/T8EGQIAChnfihLHYQGCgBoAzFH5JLmiQxbbbVV+vnPf96SYwIAik+GAACKnB80UABAm/SABACKRX4AAPLKD2Wpg9BAAQAqGACAEdBAAQDklR/K0kBhkWwAAAAAAKDljKAAgKzXQW+TpnjqdT4BoEPIDwBAXvmhLHUQGigAIKXUG+GgCQEh2w8A0BHkBwAgr/xQljoIUzwBAAAAAAAtZwQFAFjkEgAYAYtkAwB55YdgkWwAAAAAAIARMIICAPSABABGwAgKACCv/FCWERQaKAAg9PSkalcTCvae9g8HAECD5AcAIK/8UJI6CItkAwAAAAAALWcEBQDEsMhqT0pNGBqZ7QcA6AjyAwCQV34oSx2EERQAAAAAAEDLGUEBANnCUr3NGUER+wEAOoL8AADklR/KUgehgQIAskK9SVM8NSlkAADFJz8AAHnlh7LUQZjiCQAAAAAAaDkjKACgb4jl6IdGlmF4JQDQGPkBAMgrP5SlDkIDBQCYogEAGAFTPAEAeeWHYIonAAAAAACAETCCAgD0gAQARsAICgAgr/wQjKAAAAAAAAAYASMoACDF+lQ9qdKEHgxl6L0AADRGfgAA8soPZamD0EABAFGo9/SmVOlpzn4AgI4gPwAAeeWHstRBdOV9AAAAAAAAQOcxggIAotdBtTmLVGX7AQA6gvwAAOSVH8pSB6GBAgBq8zY2Y4qnEsz/CAA0Rn4AAPLKD2WpgzDFEwAAAAAA0HJGUACAHpAAwAgYQQEA5JUfghEUAAAAAAAAnTaColqtZv8+++yzqXCqvamIego6q1dXJe8jaB89/3rbF85SrmEpFPHtVfuMr33mj5Xqiy80p+dBz4vNOBzGUO299HxP8ebqfP65Amaa+Ducmwqpd1wxc83SPS+kolnYvSAVURHLndBd0FxT6V2YCqlSvL9F+YGxzBA9858v3AmeO+//UhF1zS1mtuldUMwSaH5v8QqgcQUtFJWJw7OwoPWBRXx3tSJDNK3+oSR1EG3dQFF7w2y08cZ5HwoALfjMnzJlStP3O27cuLT66qunOb/9VtP2GfuL/VLs/PAfD/46Fc7OL8/7CABKRX6g2e+n8NCFRxbuxK52Tt5HAFAuY5EhxqL+oQx1EJXqWHdJHUO9vb3pr3/9a5o0aVKqVEbX5jZ37tw0derUNHv27DR58uSmHWNZOV/Ol/dWMXTC32IUUxEM1lxzzdTVNTa9Pl544YW0YEHzehdHMJgwYULT9kdzyQ/56YTPrGZyvpwv762Rkx8YCzJEfpSJzpX3VjF0wt/iWGeIZtc/lKEOoq1HUMSbZO21127qPuOPq6x/YGPB+XK+vLeKoex/i2MxcqJeFOTtXJgzPPJD/sr+mdVszpfz5b01MvIDzSZD5E+Z6Fx5bxVD2f8WxzJDqH9YVDEnIAMAAAAAAEpNAwUAAAAAANByGiheMn78+HTyySdn/7JkztfwOF/O1Vjx3oJ8+Rt0vry/isPfo3MF7cRnlvPlvVUM/hadL/LX1otkAwAAAAAA7ckICgAAAAAAoOU0UAAAAAAAAC2ngQIAAAAAAGg5DRQAAAAAAEDLaaB4yXnnnZfWW2+9NGHChLTTTjul22+/vfVXo+BmzpyZdthhhzRp0qS06qqrpoMOOig9+OCDeR9W2/jMZz6TKpVKOv744/M+lML6y1/+kg477LC00korpYkTJ6Ytt9wy3XnnnXkfViH19PSkj3/842n99dfPztWGG26YTjnllFStVvM+NOgo8kNjZIiRkx+WTH5onPwAxSA/NEZ+GB0ZYslkiMbID4w1DRQppSuvvDLNmDEjnXzyyenuu+9OW2+9ddpnn33SE088MeYXoJ3ceOONafr06em2225L1113XXrxxRfT3nvvnebNm5f3oRXeHXfckS688MK01VZb5X0ohfX000+nXXfdNS299NLpRz/6Ufrtb3+bPve5z6UVVlgh70MrpNNPPz2df/756Ytf/GL63e9+l3392c9+Np177rl5Hxp0DPmhcTLEyMgPSyY/DI/8APmTHxonP4ycDLFkMkTj5AfGWqWqu202YiJGBkRFX+jt7U1Tp05Nxx57bDrhhBPG/CK0qyeffDIbSRGhYbfddsv7cArrueeeS694xSvSl770pXTqqaembbbZJp199tl5H1bhxN/aLbfckn7+85/nfSht4fWvf31abbXV0pe//OW+x9785jdnoym+9rWv5Xps0Cnkh5GTIZZMfmiM/DA88gPkT34YOfmhMTJEY2SIxskPjLWOH0GxYMGCdNddd6W99trr/5+Urq7s61tvvXXML0A7e+aZZ7J/V1xxxbwPpdBi1Mn+++/f7z3Gor7//e+n7bffPh188MFZw9e2226bLr74YqdqCLvssku6/vrr00MPPZR9fe+996abb7457bvvvs4ZtID8MDoyxJLJD42RH4ZHfoB8yQ+jIz80RoZojAzROPmBsbZU6nBPPfVUNpda9ESuF18/8MADuR1X0cUok1hLIabk2WKLLfI+nML65je/mU0bFsMrWbxHHnkkm7Ioplv7r//6r+ycve9970vjxo1L06ZNc/oG6e0xd+7ctMkmm6Tu7u7sc+y0005Lhx56qHMFLSA/jJwMsWTyQ+Pkh+GRHyBf8sPIyQ+NkSEaJ0M0Tn5grHV8AwUjb5G///77sx7bDG727NnpuOOOy9briMXXWXLgjBEUn/70p7OvYwRFvMcuuOACDRSD+Na3vpW+/vWvpyuuuCJtvvnm6Z577skaDddcc03nCyg0GWLx5IfhkR+GR34A2pX8sGQyxPDIEI2THxhrHd9AsfLKK2e9jx9//PF+Jya+Xn311cf8ArSjY445Jv3whz9MN910U1p77bXzPpzCiqnDYqH1WH+iJnq5x3mL9U7mz5+fvff4lzXWWCNtttlm/U7Hpptumq666iqnaBAf+tCHsl4MhxxySPb1lltumf70pz+lmTNnaqCAFpAfRkaGWDL5YXjkh+GRHyBf8sPIyA+NkSGGR4ZonPzAWOv4NShi+pjtttsum8u9vhU1vt55553H/AK0k1hPPYLB1VdfnX7605+m9ddfP+9DKrQ999wz3XfffVnP9toWIwRiCp74f40T/cV0YQ8++GC/x2J9hXXXXbel161dPP/889l6OfXiPRWfX8DYkx+GR4ZonPwwPPLD8MgPkC/5YXjkh+GRIYZHhmic/MBY6/gRFCHmvI857qPyeMcdd0xnn312mjdvXjryyCPH/AK025DKmE7mmmuuSZMmTUpz5szJHp8yZUqaOHFi3odXOHGOBq7Pseyyy6aVVlrJuh2DeP/7358tvBRTPL3lLW9Jt99+e7rooouyjUUdcMAB2ZoT66yzTjbF069+9at01llnpaOOOsrpghaRHxonQzROfhge+WF45AfIn/zQOPlheGSI4ZEhGic/MOaqZM4999zqOuusUx03blx1xx13rN52223OzADxdhlsu/TSS52rBu2+++7V4447zvkawg9+8IPqFltsUR0/fnx1k002qV500UXO1RDmzp2bvZfic2vChAnVDTbYoPrRj360On/+fOcMWkh+aIwMMTryw+LJD42TH6AY5IfGyA+jJ0MsngzRGPmBsVaJ/4x9MwgAAAAAAMD/1/FrUAAAAAAAAK2ngQIAAAAAAGg5DRQAAAAAAEDLaaAAAAAAAABaTgMFAAAAAADQchooAAAAAACAltNAAQAAAAAAtJwGCiigT3ziE2mbbbbJ+zAAgDYiPwAA8gPQbjRQwBiYM2dOOvbYY9MGG2yQxo8fn6ZOnZoOOOCAdP311zvfAID8AACofwBIKS3lLEBz/fGPf0y77rprWn755dMZZ5yRttxyy/Tiiy+ma6+9Nk2fPj098MADTjkAID8AAOofgI5nBAU02Xvf+95UqVTS7bffnt785jenl73sZWnzzTdPM2bMSLfddlv2nMceeywdeOCBabnllkuTJ09Ob3nLW9Ljjz8+5D732GOPdPzxx/d77KCDDkpHHHFE39frrbdeOvXUU9Phhx+e7XfddddN3//+99OTTz7Z97u22mqrdOedd/b9zGWXXZY1pETjyaabbpo953Wve13629/+5n0BAC0kPwAA8gPQiTRQQBP94x//SLNmzcpGSiy77LKLfD8aA3p7e7MGg3jujTfemK677rr0yCOPpLe+9a2j/v2f//zns9Ebv/rVr9L++++f3v72t2cNFocddli6++6704Ybbph9Xa1W+37m+eefT2eeeWb66le/mm666aas8eSDH/zgqI8FAGiM/AAADJf8AJSFKZ6giR5++OGs8n+TTTYZ8jmxDsV9992XHn300WxtinD55ZdnoyzuuOOOtMMOO4z49++3337pXe96V/b/J510Ujr//POz/R188MHZYx/5yEfSzjvvnI3WWH311bPHYvqpCy64IGu8CMccc0z61Kc+NeJjAACGR34AAIZLfgDKwggKaKL6kQlD+d3vfpc1TNQaJ8Jmm22Wja6I741GTOFUs9pqq2X/xhoYAx974okn+h5bZpll+honwhprrNHv+wDA2JIfAAD5AehUGiigiTbeeONs/YlmL4Td1dW1SOVFjHwYaOmll+77/ziOoR6LaaYG+5nacxqpKAEAmkN+AADkB6BTaaCAJlpxxRXTPvvsk84777w0b968Rb7/z3/+M1uMevbs2dlW89vf/jb7XoykGMwqq6zSb+Hqnp6edP/997t2AFAC8gMAID8AnUoDBTRZNE5EA8KOO+6YrrrqqvT73/8+m7rpnHPOydZ/2GuvvbJplw499NBs4erbb789W7h69913T9tvv/2g+3zNa16T/ud//ifbYnTGe97znqxBAwAoB/kBAJAfgE6kgQKabIMNNsgaHl796lenD3zgA2mLLbZIr33ta7PFsWPR6phC6ZprrkkrrLBC2m233bIGi/iZK6+8csh9HnXUUWnatGl9DRnx/Ng/AFAO8gMAID8AnahSNdk8AAAAAADQYkZQAAAAAAAALaeBAgAAAAAAaDkNFAAAAAAAQMtpoAAAAAAAAFpOAwUAAAAAANByGigAAAAAAICW00ABAAAAAAC0nAYKAAAAAACg5TRQAAAAAAAALaeBAgAAAAAAaDkNFAAAAAAAQMtpoAAAAAAAAFpOAwUAAAAAANByGigAAAAAAICW00ABAAAAAAC0nAYKAAAAAACg5TRQAAAAAAAALaeBAhgTP/vZz1KlUsn+BQCKRTmd0nrrrZeOOOKIvC8FQNv4xCc+kd3j1Vu4cGH68Ic/nKZOnZq6urrSQQcdlD3+3HPPpf/8z/9Mq6++evYzxx9/fOp0s2fPThMmTEi33HJLy6/TaMkNDOaCCy5I66yzTpo/f74TxKhooKC0okBuZMu7An2PPfbodzzjxo1L66+/fnrnO9+ZBZgl+eMf/9j3s6eeeuqgzzn00EOz7y+33HIjOsYrrrginX322SP6WQBolssuu6xfmbnUUkultdZaK6tk/stf/uJEt+Ccx7bqqqumV7/61elHP/rRsLLOxhtvPOj3r7vuur59f+c73xn2Mf72t7/NKmMiEwEwss/3qDhfc8010z777JPOOeec9Oyzzza0n0suuSSdccYZ6d///d/TV77ylfT+978/e/zTn/509jve8573pK9+9avp7W9/e8dfmk996lNpp512SrvuumvfuYgMU38dxo8fn172spelk046Kb3wwgstP2df+tKXsutWFLWGkaG2b37zm6ndfP/730+veMUrsr+5qNw/+eSTs4a+Rpx22mnpDW94Q1pttdWy1x/5ZzBXX3119rccf9Pxnlp77bWzv9H777+/3/Oq1Wr65Cc/meXpyHfRkLhgwYJ+z4nGxvh+1AsNFO/feP6FF144rHMAAy21yCNQEhGC6l1++eXZDfDAxzfddNOUtygsZs6cmf1/fLjHjXa0RF977bXpd7/7XVpmmWWWuI8o3L7xjW+kj33sY/0enzdvXrrmmmuy749UFERRkA2n18tuu+2W/u///i9rcAGAZt/gR2N+3Ljfdttt2Y30zTffnJVVoynvWPI5jxvZxx9/PDvn++23X/rBD36QXv/61y/x1MV1efjhh9Ptt9+edtxxx37f+/rXv559f6QVMZGb4uY6GkJiVESjHnzwway3L0Anq32+v/jii2nOnDlZhXDc95111llZRepWW23V99y41zzhhBP6/fxPf/rTrPLy85///CKPv/KVr8wqX0npySefzBpwYhsoKpD/+7//O/v/Z555Jrt/P+WUU9If/vCHrIxsdQPFyiuvvMgIw7zv79/3vvelHXbYYZHHd95559ROonNHjDKKzHLuueem++67L+to+sQTT6Tzzz9/iT8ff4MxKmnbbbfN6ouGEvtdYYUV0nHHHZddz/jbjsbEyGC33npr2nrrrbPnxfsrGhM/8pGPpGWXXTZrAInGjxNPPLFvX/FY5Ku3ve1ti/yeyG/Tpk3LPi+OPfbYpo/coXNooKC0DjvssH5fRwVGNFAMfHyg559/vqEGgWaaMmXKIscVIfGYY47Jhn++9rWvXeI+opLgu9/9brr33nv7CpsQ4SYaPV73utdlIXGsReVChJa44VdJBMBY2HfffdP222+f/X9MHxE3XqeffnpWkfKWt7yl1Ce9t7c3K9dbXcbWn/Nw9NFHZzew0TmikQaKDTfcMOsdGM+vb6CI3BC9/Pbff/901VVXpbEWDSzxOydOnJhVCAF0uoGf71ExGfeN8dkePbWjw1x8ZoYYuRhbvahYXX755RfZbzy+2WabtX351yxf+9rXsnN3wAEHLPK9eLy+PuC9731v2mWXXbIyMyp+o7zNW9739//2b/+WjQBo1nsmOnJGhfxojKTu6IMf/GDW6PfjH/+4729p8uTJWSNBNCZssskmi/35Rx99NGsseOqpp9Iqq6wy5PNiBM5AkZmjc2w0hESH2PDDH/4wm3EjGipDNEJFnq41UEQj2Re+8IV00003Dfm7Int/9rOfTTfccEN6zWte0+CZgP50GaKjRav1Fltske66666sR0AULv/1X/+VfW+o4XKDzVf8z3/+M+tlEvNuxs3uRhttlFWURIE4UtEqHgYGwKFEz4Fo1Bg47C5axKNxYsUVV1zkZ6LxIioEasP+ovIgemr09PT0O0f/8z//k/70pz/1DaOs9U6sDbeMYZXRkh89Z+Iczp07d5E5KmvB9vDDD+93DNHjtbu7O2uxB4CR3rTWbqLqPfDAA9nNbJSBcXMaFTBx0zVQlOMxJUWUb7Vh8FFexc1ffUVLrVI+9hWdAep7QUbP0/g9Rx555CL7j3IxfiZuSmtirt7oVRqZIX5nZIiYw3vgHL5RlkaHhSjPN9988+y5s2bNyr4X01odddRR2THF4/H96B030J///Oest17ciMfw/Xito50rOCqjolxvNKeE//iP/0hXXnllv3wUIzDiBn+whqXIHlFJ8/KXvzz7XSuttFI6+OCD+03lFCM54rEQ004NnMIzrmlUskUvw7j+sZ/aNAT1mS4aLuLn42Y/rnVNVGxsueWWWUaKygyAThCVjB//+Mezz+GoWB9sbYPaVMNRKfmb3/ym3+dv/BsVqXEfWXu89tndqvKvdhzf+ta3sh7gUbZHWbznnntmI/oG+uUvf5l1+ote51FeRiVyVMyOJFcM5nvf+142vVMj0y7Hcb/qVa/KyqZHHnlkkR74kXviGCdNmpTdz8f5X5JLL700u66RA+KcRePRwB77US7Gvm688ca+6xb1AWHg/X1cm3gtUYYPVt5HfUZ9vcJIj3s4hnrP1KYzi9cVuSLOQbwf6keN1J4fdSPTp0/PsmGjdUd/+9vfsvdGZMEljfiMLabzrs9PcUxxrRuZ5nI4I0UHitcdx13/2qJBIt7zNfHerr+mH/jAB9IhhxzSrxFzoO222y77uahfgpEygoKO9/e//z3rNRIfutFrYbi9E+LDe/fdd89C0rve9a5sDsFf/OIXWYtzFFSNrN0QBXetEiQKtajMr4W2+vkplySCQATIz3zmM1kBHPuMlvmY1qoW5upFQR2hYsaMGdm/0VMmWtqjIiXmEQ0f/ehHs2GmUblRG7Y7MFRFo0aMmoiKlwiWgw37jKm04nkf+tCHslAXvXHiRj8qBqKXQK3FHgCGq1bpUX+DFTe9UYZG43lMRxE3xFFJERX10VP/jW98Y9+8unHDHGVvVHbEnMBRfkaFQ5R9MTojbt7ixjQqNOLGNzoEfPvb387KsLjJix5vSy+9dLbPGM0YFeD1ZWFUSkT5GFkjRAV9lIPRSB83qVFGxlD8KGcfeuih7Pn1onyOY4/fHccTN6cxzVJMnVG7GY+K9bj5j0aUKMdr0zLGsUdlzGOPPZZNjxA33pELhjuqMrJAnJe4gY4K/JiWIM7dkkam1oupAaJyKyo3aj3somNFHF/cNA90xx13ZJkqzltUJMR1jsqUuBZxgx832VFJEK8r5kuPioLa1J31U3jGVE6RkSKnveMd78gaPAaK8xiVW1Eh9e53vzu7jiHyWLyX4phH29MSoJ3EmhHxuRr3k/HZOVCUO1GeROV/lAe1KYvj8zcej8bw+OyOCs7a81tZ/tXEvXH0/o971SjLoqd39BiPBomamGkhGrPXWGONrEyPyvXIBdG7PL4eTq4YTNzjR5kW63GMJtvEeY3pdGJtgegQGXURUS5GY8avfvWrxVZex/OiEj7Of1SORweBqBiPaxIV8iHqLmKanrjfj3qAMFT9yFvf+tZ03nnnZY1QtY4CIY4p9h0ZKToijva4a2JNlPqOIzXReaF+WqHB3jP33HNP9r14vfF+iTqPWqeDyCUxTeRee+2VXZ/IDHFscb1iNovId0uqO4q6n+i0UhvdMJR4rWFgZX9ks/hbqX2/mSKn1qZvi+sbfyORu2pi2qxooIlrGO/pyLAxeqf2dxHnM/42lyTy81gv/k7JVaFDTJ8+vTrwLb/77rtnj11wwQWLPD8eP/nkkxd5fN11161Omzat7+tTTjmluuyyy1Yfeuihfs874YQTqt3d3dXHHntsscdVO4aB26abblp95JFHlvi6Hn300ez5Z5xxRvX+++/P/v/nP/959r3zzjuvutxyy1XnzZuXHXMcZ73nn39+kf29613vqi6zzDLVF154oe+x/fffP3vdA91www3Z79tggw0W2Vfte/FvTU9PT/VVr3pVdbXVVqs+9dRT2TVZaqmlqnfccccSXycAXHrppVnZ8pOf/KT65JNPVmfPnl39zne+U11llVWq48ePz76u2XPPPatbbrllv/Kst7e3ussuu1Q33njjvsdOOumkbJ/f/e53FznB8fxw9tlnZ8/52te+1ve9BQsWVHfeeeesnJ07d2722LXXXps97wc/+EG//ey3335ZWVnz1a9+tdrV1dVXXtdEHomfv+WWW/oei6/jub/5zW/6Pffoo4+urrHGGll5Wu+QQw6pTpkypa9crh37t771rb7nRC7YaKONFimnF3fOB25xvi+77LJqIyLrbL755tn/b7/99tmxh6effro6bty46le+8pW+3PDtb397sTnl1ltvzZ53+eWX9z0WPzPUa4n8Et+bNWvWEjNduPDCC/uu9W233ZZlueOPP76h1wnQTmqf74u7F4vyZNttt+37Ou6PB7unrn3GD/yMjfvIeq0s/2rlStxXz58/v+95X/jCF7LH77vvvuzrhQsXVtdff/3seKNcGiwHDCdXDObhhx/Ofue55567yPdq9+mRa2KL55555pnVSqVS3WKLLfqO4dlnn60uv/zy1Xe84x39fn7OnDnZ665/fLDrNFiZus8++/TLJyGuZVzTgQbe38dxrbXWWtU3v/nN/Z4XeSOed9NNNw37uAdT+71DbX/729+W+J6pvdejLiKud80TTzyR5ZC99947q6uo+eIXv5g9/5JLLmmo7iiuYXwv6mYWJ+ps4nmD1RHtsMMO1Ve+8pXVRsV7Zag6q3ovf/nL+85VZNaPfexj/V5rZNg4L7XnxPX/85//XH3xxRerm222WfUzn/lMQ8fzzne+szpx4sSGjx8GMsUTHS+G8Q02HUOjogdl9LyMng3Rol/bogU+RkYsbq6+mmhlj9bp2KL3R7RsR++OaJ2PxbQaFT0ioudfzFVZ65V44IEHDjkvYm0u0foeCfFaokdDDFFsVPSGqN/XUKLnSozaiB428dqipT56GyxuuCAADBRlbPSAi2khYlRe9PiKEQ+14fr/+Mc/sh5fMW1QrXyLLXq+Re+93//+99nIxxC9HmO6psF6PtZ65P3v//5v1psyeuHXRI+66LkfZVpMGRBiVED01otpjGqefvrprHyPnob12SF6jcYIwvrsUBtVENNl1IuRmvXzeMc9eBx3zGMd/1+/j3h9kSHuvvvuvmOPHqH18zZHLoieq8MRvSRrWSVGa8Z0SDGXcW2kwXBGUcTPxNRJMZVB9K4cqtdpfbaI3n9x/WJ0aUwvVXt9jYgRL3FeGhHnJZ4bPUij93BM7RTzQgN0ouhJH+Vos7Sy/KuJe/36UY21aSFrUydFr/Xo+R4jLwaupVHLAcPJFYOJ5w0cDVEvevNHroktyrkY7RGjNWLKnNoxRPkbveEji9S/7ihHY+qogeducWVqbVRknN84D/H1cMVxRa/7yBmRhWoiA8Uokxgd0YzjrolRD7UcUr8NnMp64HumXowEqo3qCD/5yU+yPBLXPuoq6p8X60LE6JBG6o6ijiPej0saCRKjWmv7GSimDKt9v5liaq+YTSPqXuJvL35H/dRbMd1W5NgYIRQjTWKL6xfPj9G/MRIqRq1G7ovHY+RIjMIYKN7bse/BpvyCRpjiiY4XH7KDTUnUqAgjv/71r4dcoKh+HuOhRMVKVLbUxJoRUaBHxX0MSf3c5z43rBv/eH4UJDEtQm1exMFEIRRrR0TYGljIDCekxI1/o+JGP4ZRxlRPMYdjzG0KAMOtLH/Zy16WlVUxLU90Bqi/2YupmOJGMcqYocqZKJ8jA8S6FW9+85sX+/tiDu6NN964381r/TRC8f0QUybEvqKDQNzUxTFFZXxUrtc3UER2iKkjGs0OA8vZ6LwQN/sXXXRRti1uH3FsUdlRP/1BGGyao8WJha3rOxRERcO2226bTaEQ02I0mqViWoSoeIkOGTFHdPxs3BwPJm50Y8qQuLmOip9/dY4c25wSvvzlL2d5Ja5TZKlGOmEAlFFUPA82Bd9ItbL8q4kpmOvVGgmiA0H9+lVxbzqU4eSKxakvxwZWTse0SCGml4xpqGJ/9eVPnLsw1CLEUaG+ODH9TkxbeOutty5SiRxl6pQpU9JwRbaJzpXRSSTqIeL9Eg0WMaViLXeM9rhrYj2o+jqTkZT5A79Xy28DM1Fkmg022KDv+82qO6pdz8HWAXvhhRfGJG/EWqX1GayWXc8888y+xyPf1jfqRANS1NlExo7rGFkttpgGPKYHj04c9euw1b+3B+ZNaJQGCjrecAuB+tbmEHM2vva1r80W9hpMVKCMRCw0FCGhkREY9aLCIEYlRKt/zMe49957D/q8CHbRuyACQaz/EDfiEYyix0ksWD2cBb6Hew5jHtPw17/+NetNUlsQHACGW1kecz9Ho37cGMe8wdHbs1aGRUX4UD3no9J+LMTNX8zfGxXwcWwxD3L0FI1RGjVxfHGjfdZZZw26jxgZsrhytvb6ohdbjGIcTIyoHEtxMxu96WIB0ah8iFGcjYjRHLGGRHSmiMqS6Ak7lLgBjsaJ6NkYN9iRi+LGN87xWOaUWG+iVnkQc6PX39wDdIqoKI+K62aWl3mUf/U95htpLBjquEeTK+K+vL5RZKA4xvrK9/gdkR2ior+2CHftGGI9h8Hun+sXXR4oGmFi3YHYZ5z7OM9R0R6NCbH+x3DK1HqxFkiMGoisEzksGlmic0F9p4zRHPdILK7MH20DwGh/PjJQiLVKB77X47HIt2MpGueioSg6iNQ3UAwUjXCxpkTk2J///OfZsUWjWdQXxXod0aE28ll9x514b8cIXZ06GCkNFLCYD++oxK8Xw//iw7leVOxHT4FGWvOHKxpD6odLNiJ6iMRw0Li5jkWehirw4/vROBA9O2OByZoY3jpQM1vBL7jggmwoZiymFr0iI3TF0FUAGIm4qY/yJCrLv/jFL2YLV0avt9o0TEsqn6Mcv//++xf7nHXXXTcbLRk32fU3Y7XpEOP7NVGmxg1oTHEQDScxSrG20GT977z33nuzyoKRlLHR8zRGHUROWNLri2OL1xcVMfW/KxpzRmvhwoXZv8PNKlGJEdNDxVQa++2335DPiymgogKqfiRp9DAcmM+amVMi50XDSHTwiMqbWmVU/TUG6ARRoRwanSKvEa0s/4ZzTCHKyqH2OZxcMdQ9elTcDnavPZjIETEjQlQG33bbbVlDQO04Y0TLcI8hGg6i4T0aO+pHlAw2vdJwr0tMexWdFWJGhsg+0WARx1szmuMea7WyPTJR7RrX6n3iWjX7eLfZZpvs3zvvvLNfY0R03IwGweFOvzkS0YC0uFGo8fcZIyfuuuuuvmOLurFonKgt6B3nJ0Yz1S+gHuerNjoDRsIaFDCEKEgHjl6IYaQDR1BEgRzDJK+99tpF9hE30LWb9+GKsBA3/PU9Lht16qmnZsM34wZ7KLWeJPU9R6KgibkGB5uCaiTzUg4UhVZM7RTTX8TUU9FqHyHp8ssvH/W+Aehc0SM/bvRimoGowI6b4HgsRjIM7FgQ6td3ijIpbsauvvrqRZ5XKyOjEn3OnDn91paI8v3cc8/NRmzEiMSaaMCI9R6iMiAqd+J59T0Ja9khpiy6+OKLB71xjLmoFyfK8DjuGH0wWONK/euLY4+by6jsr4mpHYaaGqNRMW1VjIiMSvzh3pDG+YmcEpljcVMlxOsc2MM1zvnALBY5JQxsuBiJGIEaDVExzVOco+jocfTRRw+rpy1Au4vG9VNOOSWbEufQQw9t2n5bWf41KnqKx+uMDDGwHKl99g8nVwwmGjZi5GdUTDcq7uWjR3pM+VxrKIrZD2JdpCiDh3MMg937x/199IIfKMrU4ZSnkXGi8SOm/Im1DuIa1xvNcY+1aICIHHLOOef0OzeRAeL87L///g3tJ94T0WllsNdXL0abxiiWgfVK559/ftYwVL9eWPz+2OdI62EGm2r8j3/8Y7r++usXuwbocccdl3UiqU15Fo0QcY1iHZYQU7RFNoo11+rFTBy77LLLiI4VghEUMIT4UH73u9+dBaCYwikqL6IRYuAHcVS4RyV7zMl3xBFHZFMzRbCKKQGiMiAKgYE/M1AUOrHgZIiKjGjBj0IqellET9DhioqS+sqSwUThES3h0TMxFvmMAjEqUga7AY/XFJUyMd/gDjvskFXGxMJkwxH7Peqoo7LXFK8txOiJCJdRCEY4iNZ4ABiJKI9jscZYqDDK71inIkYwxFQSUekcPeMef/zxrFNB9FKLcr32c1Fex89GORVlXtyERdkeo/6io0D0aItKiSjno0dZ9A6Mn4kpiqJCY+AaCnGzHhXpUQkfv39gBX4svhzTIcRxRoeEGPkYN6pxIxqPR95Y3M1jiAqL+NlYYDJeX8wdHMcdN4ix6GPtRjK+FyNLDj/88OzYo1dmlPdR6TEcMWVVbcRI3PTGOhsxtVPklEbnj66JqZpibuMliWwVxxrPj9cX1y5eW22qjPoeiVH5cvrpp2eZKtb+iCkMhjtvelTUxIKY8R6qLbge1zGmEons8t73vndY+wNoB7XP97gPjXIyGidixHv0Lo+ysNZzuhlaWf41KjoWxGd83N9GeRKLIEdZGccUazbWOiI2miuGcuCBB2YjKmOkQSPlZpR1cSzRmB+VwpEl4jjjHEajSkx3GCNKHnvssazsinMZ5f1gaqMC4zXGPXh0hIxGoignBza4RA6K3xOdHmPaqnjOUOtHhDiWeF68tmioGNgpI17rSI+7Xkw1FJ1QBpvSa6TTWsZxxPTYtWmL3vCGN2R1MXHOo94jyv9GxD6igSY6ZC5poexYxyF+T1yTOBfR0BavP+qf6vNidJyJ6x/ZJPJnTeSiWBujto5IdKqNaxXiHNdGhcT7NEYqxXs66n0is0XDSzSi1Bq9BlvEPkYM10+/GdNcRiNF5OQ3velNWSfT+Ld+6rTIl/F3F+9xGLEqdIjp06dHzXu/x3bffffq5ptvPujze3p6qh/5yEeqK6+8cnWZZZap7rPPPtWHH364uu6661anTZvW77nPPvts9cQTT6xutNFG1XHjxmU/s8suu1TPPPPM6oIFCxZ7XHEMcVy1rVKpVFdcccXqG97whupdd921xNf16KOPZj93xhlnLPZ5cczLLrtsv8duueWW6itf+crqxIkTq2uuuWb1wx/+cPXaa6/N9nfDDTf0Pe+5556rvu1tb6suv/zy2ffiHIR4Tnz97W9/e5HfV/tebT9f+MIXsq+vuuqqfs977LHHqpMnT67ut99+S3ytAHS2Sy+9NCtL7rjjjkHL7Q033DDbFi5cmD32hz/8oXr44YdXV1999erSSy9dXWuttaqvf/3rq9/5znf6/ezf//736jHHHJN9P8rxtddeOys3n3rqqb7nPP7449UjjzwyK+PjOVtuuWV2PIPp7e2tTp06NTvWU089ddDnRD44/fTTsxwyfvz46gorrFDdbrvtqp/85CerzzzzTN/zYh+RYQYTxxTfi98Vry9e55577lm96KKL+j3vT3/6U5YrIs/E8R933HHVWbNmLVLeL+6c128TJkyobrPNNtXzzz8/e61Lsri8VTNYpnj66af7zvlyyy2XZbEHHnhg0Cx28cUXVzfYYINqd3d3v9cVz91///0H/Z31+5k9e3Z1ypQp1QMOOGCR573xjW/MMtQjjzyyxNcK0C4Gfr5H2RblyGtf+9rs3m3u3LmL/MzJJ5/c8D31UJ+/rSr/hrpXrd0/DyzDb7755uy1T5o0KfvM32qrrarnnntuv+c0miuGOualllqq+tWvfnWJ9+n1vy/KtfoyL15XlIdRZkV5HLnniCOOqN55552LvU7f//73s9cUP7Peeutl1+CSSy7JnhfnpGbOnDnZdYvzEN+L61t/PgfLDR/96Eez70V9yFAaOe6hfm5gDqnf4rUu6T2zuPwYvvjFL1Y32WST7Jquttpq1fe85z1ZBmk0y8T1GXgeF+fqq6/OclS8/yNzfuxjH1uk3qh2zAPfpwPrj+q3+msT52X77bfP/r7ifRf1PYccckj117/+9aDH9Pzzz2d/s+ecc84i34vz9opXvCJ7T0ROeuKJJ/p9P+rN1llnnYYyIQylEv8ZefMGAAAAALA4MWXgQw89lI0GgDKIUTMxaiRG1MbMGDBS1qAAAAAAgDEUUz/ecccd2RSRUAYxBVWssRLTtsFoGEEBAAAAAAC0nBEUAAAAAABAy2mgAAAAAAAAWk4DBQAAAAAA0HIaKAAAAAAAgJbTQAEAAAAAALTcUqmN9fb2pr/+9a9p0qRJqVKp5H04AIyBarWann322bTmmmumrq6xaVd/4YUX0oIFC5q2v3HjxqUJEyY0bX80l/wAUH7yA2NBhgAov7HOEM2ufyhDHURbN1BE48TUqVPzPgwAWmD27Nlp7bXXHpNwsNLE5dLzqadp+1x99dXTo48+2tYBoczkB4DOIT/QTDIEQOcYiwwxFvUPZaiDaOsGihg5Efac+b201IRl8z4cWuiU/TdxvjvU0t1GS3Wa5559Nv3bNpv2feY3W/RciHBweForjWvCzIcLUm+6fM5fsv22azgoO/mhc8kPnUt+6DzyA2OZIR7+/e/HLJtSTNW8D4DcqIHoPDF6YqONNx6Tz/lm1z+UpQ6irRsoatM6RePE0hM1UHSS5SZNzvsQyMk4DRQda6yn8otwMK7ShIDg7qXw5IfOJT90Lvmhc8kPjMX7KSqtJk92T9pJRPzOpYGic41lhmha/UNJPqDauoECAJqlu1LJtlHvJyJsCQICALBk8gMAkFd+KEsdxNisNgoAAAAAALAYRlAAQLTYV6IXQ5Na/tu89wIA0Bj5AQDIKz+UpQ5CAwUANHuKBgCgI8gPAEBe+aEsdRCmeAIAAAAAAFrOCAoAyHowNGeIZbezCQAdQ34AAPLKD2Wpg9BAAQCmaAAARsAUTwBAXvkhmOIJAAAAAABgBIygAABTNAAAI2CKJwAgr/xQlimeLJINAAAAAAC0nBEUAGAOaQBgBKxBAQDklR/KsgaFBgoASCkr0psxrLD9owEA0Cj5AQDIKz+UpQ7CFE8AAAAAAEBnNlCcd955ab311ksTJkxIO+20U7r99tvzPiQAOnSIZTM2WkN+ACBv8kP7kR8AKFN+6C5BHUTuDRRXXnllmjFjRjr55JPT3Xffnbbeeuu0zz77pCeeeCLvQwMACkp+AADkBwBof7k3UJx11lnpHe94RzryyCPTZpttli644IK0zDLLpEsuuSTvQwOgg3RXmrcx9uQHAIpAfmgv8gMAZcsP3SWog8h1kewFCxaku+66K5144ol9j3V1daW99tor3XrrrYs8f/78+dlWM3fu3JYdKwDl9q+CffQle3dTjobFkR8AKAr5obz5IaiDAKDI+aEsdRC5jqB46qmnUk9PT1pttdX6PR5fz5kzZ5Hnz5w5M02ZMqVvmzp1aguPFgAoAvkBABjr/BDUQQBAB0zxNBzR0+GZZ57p22bPnp33IQFQEoZXlpf8AMBYkR/KTYYAYCyY4qlAUzytvPLKqbu7Oz3++OP9Ho+vV1999UWeP378+GwDgGaL4ZXNmeKpBBNAFpz8AEBRyA/lzQ9BHQQARc4PZamDyHUExbhx49J2222Xrr/++r7Hent7s6933nnnPA8NACgo+QEAkB8AoBxyHUERZsyYkaZNm5a23377tOOOO6azzz47zZs3Lx155JF5HxoAHaQrW6SqCftpxsGwRPIDAEUgP7QX+QGAMuWHstRB5N5A8da3vjU9+eST6aSTTsoWptpmm23SrFmzFlm4CgBAfgAA1D8AQHnk3kARjjnmmGwDgLyYQ7r9yA8A5E1+aD/yAwB5swZFARsoACBv3U0aYtndjIMBANqC/AAA5JUfylIHUYZpqgAAAAAAgDZjBAUA6AEJAIyAERQAQF75oSwjKDRQAIA5pAGAEbAGBQCQV34I3alJLR05MsUTAAAAAADQckZQAMBLwyKbskh21ekEgE4hPwAAeeWHstRBGEEBAAAAAAC0nAYKAIgC8aU5IEe7xX6GY+bMmWmHHXZIkyZNSquuumo66KCD0oMPPuiaAEAbkB8AgLzyQ3dJ6iA0UADAS8Mrm7UNx4033pimT5+ebrvttnTdddelF198Me29995p3rx5rgsAFJz8AADkmR+6S1AHYQ0KAMjRrFmz+n192WWXZb0Y7rrrrrTbbrvldlwAQHHJDwBAWTKEBgoAyHow/Gt45GiNdh/PPPNM9u+KK67ougBAwckPAEBe+aEsdRAaKACgbojlaNX2MXfu3H6Pjx8/PtsWp7e3Nx1//PFp1113TVtssYXrAgAFJz8AAHnlh7LUQViDAgDGwNSpU9OUKVP6tliIakliHsj7778/ffOb33RNAKADyQ8AQKdlCCMoAGAMpmiYPXt2mjx5ct/jS+q5cMwxx6Qf/vCH6aabbkprr722awIAbUB+AADyyg9lqYMoRQPFITusnZZZblLeh0ELrbxMt/PdoVZ4+uG8D4EWm/v8c215ziMY1IeDoVSr1XTsscemq6++Ov3sZz9L66+/fkuOD/mhE8kPnUt+6DzyA2Op+tIGlJ+/9c7Trtd8chvXQZSigQIARqurUsm2ZuxnOGJI5RVXXJGuueaaNGnSpDRnzpzs8RiSOXHixFEfDwAwduQHACCv/FCWOggNFACQUqp0V1Kla/QBoTLMcHD++edn/+6xxx79Hr/00kvTEUcc4doAQIHJDwBAXvmhLHUQGigAIEcxvBIAQH4AADqxDkIDBQDEsMjuSupqQg+GZg3TBACKT34AAPLKD2Wpg9BAAQChuytVurpGfy4qxeuNAACMEfkBAMgrP5SkDqJJZwIAAAAAAKBxRlAAQHQ66KpkC1WNViW1//BKAKAx8gMAkFd+KEsdhBEUAAAAAABAyxlBAQC1Raqa0IOhqwS9FwCAxsgPAEBe+aEsdRAaKAAgG2LZnEWqKtX2X6AKAGiM/AAA5JUfylIHYYonAAAAAACg5YygAABTNAAAI2CKJwAgr/xQlimejKAAAAAAAABazggKAIh5G7sr2TZalRL0XgAAGiM/AAB55Yey1EFooACAvoDQhEWyU6/zCQAdQn4AAPLKD2WpgzDFEwAAAAAA0HJGUACARS4BgBGwSDYAkFd+KMsi2RooACCGRVYqqdLVhDUoets/HAAAjZEfAIC88kNZ6iBM8QQAAAAAALScERQAkA2x7Mq20eqqavsHgE4hPwAAeeWHstRBtP8rAAAAAAAA2o4RFAAQ8zZ2V7JttCrV9p//EQBojPwAAOSVH8pSB6GBAgBUMAAAI6CBAgDIKz+UpYHCFE8AAAAAAEDLGUEBABa5BABGwCLZAEBe+aEsi2RroACA0KwhliUYXgkANEh+AACGq4lTPKUS1EG0fxMLAAAAAADQdoygAIBosa9UUldXpSn7AQA6g/wAAOSVH8pSB2EEBQAAAAAA0HJGUABASqnS3ZVto1Xp1fYPAJ1CfgAA8soPZamD0EABADGksLuSbaPV1dv+wysBgMbIDwBAXvmhLHUQ7d/EAgAAAAAAtB0jKAAgG2JZybbRqpSg9wIA0Bj5AQDIKz+UpQ5CAwUAmEMaABgBa1AAAHnlh7KsQdH+rwAAAAAAAGg7RlAAQLZI1b8Wqhqtrl6nEwA6hfwAAOSVH8pSB2EEBQAAAAAA0HJGUABAzNvYVcm20WrGPgCA9iA/AAB55Yey1EFooACAGFLY1ZW6mrBIVVePwYkA0CnkBwAgr/xQljqI9n8FAAAAAABA2ynFCIpJhx6clonVRegYU+7437wPgZxUJ0xy7jtM9cXW/J5KdyXbmrEf2sPkw9+alpUfOsqUX8oPnUp+6DzyA2Mp0p7EB52hmvcBUErNqn8oSx1EKRooAGC0Kt1d2daM/QAAnUF+AADyyg9lqYNo/1cAAAAAAAC0HSMoACB6HXR1ZdtoNWMfAEB7kB8AgLzyQ1nqINr/FQAAAAAAAG3HCAoAiBb77q5sG61m7AMAaA/yAwCQV34oSx2EBgoACM1apKoE4QAAaJD8AAAMVxMXyU4lqINo/1cAAAAAAAC0HSMoAKC2SFUTeh6UYYEqAKAx8gMAkFd+KEsdRPu/AgAAAAAAoO0YQQEAtR4MTeh5UIbeCwBAY+QHACCv/FCWOggNFAAQhXq2SFX3qM9FpbvH+QSADiE/AAB55Yey1EG0fxMLAAAAAADQdoygAIC+HgxNmOKpSQtdAQDFJz8AAHnlh7LUQWigAIAYUtjVlW2j1Yx9AADtQX4AAPLKD2Wpg2j/VwAAAAAAALSdXBsoZs6cmXbYYYc0adKktOqqq6aDDjooPfjgg3keEgAdPsSyGRtjS34AoCjkh/YhPwBQxvxQKUEdRK6v4MYbb0zTp09Pt912W7ruuuvSiy++mPbee+80b968PA8LACgw+QEAkB8AoBxyXYNi1qxZ/b6+7LLLspEUd911V9ptt91yOy4AOo9FLtuH/ABAUcgP7UN+AKAoLJJd4EWyn3nmmezfFVdcMe9DAaDDVCpdqdKExaViP7SW/ABAXuSH9iU/ANDu+aEsdRCFaaDo7e1Nxx9/fNp1113TFltsMehz5s+fn201c+fObeERAgBFIz8AAGORH4I6CADooAaKWIvi/vvvTzfffPNiF7X65Cc/2dLjAqAzmKKhPckPAORJfihvfgjqIAAYC6Z46q8QY0COOeaY9MMf/jDdcMMNae211x7yeSeeeGI2DLO2zZ49u6XHCUD5A0IzNlpDfgAgb/JDefNDUAcBQNHzQ6UEdRC5jqCoVqvp2GOPTVdffXX62c9+ltZff/3FPn/8+PHZBgB0LvkBABjr/BDUQQBAyRsoYljlFVdcka655po0adKkNGfOnOzxKVOmpIkTJ+Z5aAB0mK7urmxrxn4YW/IDAEUhP7QP+QGAsuWHstRB5PoKzj///Gyqpj322COtscYafduVV16Z52EBAAUmPwAA8gMAlEPuUzwBQBFUuiqp0tXVlP0wtuQHAIpCfmgf8gMAZcsPZamDyLWBAgCKolmLS5VhgSoAoDHyAwAwXM1c3LpSgjqI9n8FAAAAAABA2zGCAgD0gAQARsAICgAgr/xQlhEUGigAIAr1Sldz1qCotH84AAAaIz8AAHnlh7LUQbT/KwAAAAAAANqOERQAkA2L7E5d3d1N2Q8A0BnkBwAgr/xQljoIIygAAAAAAICWM4ICACxyCQCMgEWyAYC88kOwSDYAlIQKBgBAfgAA2qX+oSwNFO3/CgCgjd10003pgAMOSGuuuWaqVCrpe9/7Xt6HBAC0ARkCAChDftBAAQDR66Crq2nbcMybNy9tvfXW6bzzznMdAKDN5JUfggwBAO2pmfmhUoI6CGtQAECO9t1332wDAJAhAIBOq4PQQAEAY7AGxdy5c/s9Pn78+GwDAMpDfgAA8soPZamDMMUTAGRDLCt9IWFUW1clO59Tp05NU6ZM6dtmzpzpPANAycgPAEBu+aG7HHUQRlAAwBiYPXt2mjx5ct/X7dJzAQDIj/wAAHRahihFA8VOt/6k3wWg/Db/8Ky8D4Gc3HPG65z7DrOgumxLfs9IF6gcbD8hyiVlU7HtePOPXaMOIz90Lvmh88gPjKXqSxsA5Fn/UJY6iFI0UADAaFW6urOtGfsBADqD/AAA5JUfylIHoYECAHL03HPPpYcffrjv60cffTTdc889acUVV0zrrLOOawMAyBAAQGnrIDRQAECIXgfN6HkwzH3ceeed6dWvfnXf1zNmzMj+nTZtWrrssstcGwAospzyQ5AhAKDD80NJ6iA0UABAjvbYY49UrZrFGACQIQCAzquD0EABACEWlmrGIlVNWugKAGgD8gMAkFd+KEkdhAYKAIiFpbq7s220mrEPAKA9yA8AQF75oSx1EO3fxAIAAAAAALQdIygAIOdFLgGANiU/AAB55YeS1EFooACAvjkgm9FAYXAiAHQM+QEAyCs/lKQOov1fAQD8v/buPMiusswf+NsdoBOWJIDIImEJAcMSZKdIaiSMURgQsWoKQYMGZABZRiCIJn8IIoMZHARmGH5sjoAOslgIWC4sgywFiCwJFsgiyJLAEIICCQQl0Pf86j0hPTRJsPv2uffc857Pp+o19M3tk3P6dvf9+rzneV8AAAAAKkcHBQDEjaW6u/MxVEUcAwCoBvkBACgrP6RSg6j+FQAAAAAAAJWjgwIAoq6CNqmKxwEA6kF+AADKyg+J1CBMUABAFMNBIZtkVz8cAAADJD8AAGXlh0RqEJZ4AgAAAAAA2k4HBQDY5BIAaIJNsgGAsvJDKptkm6AAgMgSDQDAYMkPAEBZ+SGyxBMAAAAAAMDg6aAAgCi2RRaySXb12ysBgAGSHwCAsvJDIjWI6l8BAAAAAABQOTooACBuLDVsWD6GqohjAADVID8AAGXlh1RqECYoAKCvxbKAxsIE2isBgAGSHwCAsvJDIjWI6l8BAAAAAABQOTooACCKG1QVskl29dsrAYABkh8AgLLyQyI1CBMUABDXbewelo+hKuIYAEA1yA8AQFn5IZUahCWeAAAAAACAttNBAQBRV0GbVMXjAAD1ID8AAGXlh0RqENW/AgAAAAAAoHJ0UACANaQBgCbYgwIAKCs/pLIHhQkKAIhie2URb+xFtWkCAJ1PfgAAysoPidQgqn8FAAAAAABA5eigAIC+OxgKmLdP4O4FAGCA5AcAoKz8kEgNovpXAAAAAAAAVI4OCgCIG0sNG5aPoSriGABANcgPAEBZ+SGVGoQJCgCI4gZVhWySXf1wAAAMkPwAAJSVHxKpQVjiCQAAAAAAaDsdFAAQuQMSABgs+QEAKCs/JNJBYYICAOK6jd3d+RiqIo4BAFSD/AAAlJUfUqlBVP8KAAAAAACAytFBAQBRV0EtlvE4AEA9yA8AQFn5IZEaRBITFKtlS/JBfXzi/51Y9ilQkje+8ylf+5pZ/Haj7FMgUfJD/cgP9SU/1I/8QCt1vTuA9GVlnwDUQBITFAAwZF1dcfHGYo4DANSD/AAAlJUfEqlBmKAAgCiGg0ImKGzvBAC1IT8AAGXlh0RqENW/AgAAAAAAoHJ0UABAXFu0qzsfQ1XEMQCAapAfAICy8kMqNQgTFAAQWaIBABgs+QEAKCs/RAlMUFT/CgAAAAAAgMrRQQEAUVfX0jFURRwDAKgG+QEAKCs/JFKD0EEBAAAAAAC0nQ4KAIi6u5eOoSriGABANcgPAEBZ+SGRGoQJCgAIIWRd3fkYqiKOAQBUg/wAAJSVH1KpQVT/CgAAAAAAgMrRQQEAUbzroIg7DxK4ewEAGCD5AQAoKz8kUoMwQQEAkQIDADBY8gMAUFZ+SGSCovpXAAAAAAAAVI4OCgCI3AEJAAyW/AAAlJUfIh0UxfnXf/3X0NXVFU444YQCjwoApE6GAADkBwCopo7ooLj//vvDRRddFLbffvuyTwWAmsq6ukJWwJ0H8Ti0jwwBQJnkh2qSHwBIIT+kUoMofQ+KN954I0ydOjVccsklYe211y77dACoe4tlEYO2kCEAKJ38UDnyAwBJ5Yeu6tcgSr+CY489Nuy3335hypQpf/O5b731Vli0aFG/AQDU00AzhPwAAAw2P8gQAFCDJZ6uuuqqMHv27Ly9ciBmzZoVTjvttJafFwA1FNsii2iNTKC9sgoGkyHkBwBaRn6oFDUIAJLKD4nUIErroJg3b144/vjjwxVXXBGGDx8+oM+ZOXNmWLhwYd+IxwCAQmivrIzBZgj5AYCWkR8qQw0CgI5hiafO6KB48MEHw4IFC8JOO+3U91hvb2+48847w3/+53/myzEMGzas3+f09PTkAwCor8FmCPkBAFCDAIDOVNoExSc+8Ynw8MMP93vssMMOC+PHjw/f+MY3lpucAIBWyrq681HEcWgtGQKATiE/VIf8AEBq+SGVGkRpExRrrbVW2G677fo9tsYaa4R11113uccBAGQIAEANAgDSUuom2QDQMeJdB90F3HmQwN0LAMAAyQ8AQFn5IZEaREdNUNx+++1lnwIAdd+kqojj0HYyBAClkB8qTX4AoNL5IZEaRPWvAAAAAAAAqJyO6qAAgNK4AxIAkB8AgKrUH+rcQfH0008XfyYAQPJkCABAfgAAhtRBMW7cuLDxxhuHPffcM0yePDn/Mz4GAJWlg6ItZAgAkiI/tIX8AEBSdFAMvYNi3rx5YdasWWHEiBHhu9/9bthqq63yCYupU6eG73//+80cEgBKlXV1hayru4DR5ZX8ADIEACmRH9pDfgAgJcXlh+4kahBNTVB85CMfyScjLr744vDEE0/kY8qUKeGaa64JRx11VPFnCQAkQYYAAOQHAGBISzy9+eab4a677gq33357PubMmRPGjx8fjjvuuHzJJwCoHEs0tIUMAUBS5Ie2kB8ASIolnoY+QTF69Oiw9tpr510UM2bMCH/3d3+XfwwAlRXbIotojUygvbKVZAgAkiI/tIX8AEBSisoPidQgmpqg2HffffMOiquuuirMnz8/H7FzIu5FAQAgQwAARVGDAIB0NbUHxfXXXx/+9Kc/hRtvvDHsscce4eabb867KJatKw0AlW2xLGI04fzzzw+bbbZZGD58eNh9993DfffdF1IkQwCQFPmhLeQHAJJSZH7o6q58/aG5Ksq7JkyYECZNmpRPUuy6665hwYIF4eqrry7u7ACgBuJ75/Tp08Opp54aZs+eHT72sY+FvffeO39fTZUMAQBDIz+oQQBACvmhqQmKs88+O3zmM58J6667bj7LcuWVV+bLO1177bXh5ZdfLv4sAaDFsq7uwkYz76tHHHFEOOyww8I222wTLrzwwrD66quHH/zgByE1MgQAKZEf2kN+ACAlReaHbJA1iE6sPzS1B0WckNhzzz3DkUcemS/tNGrUqOLPDADaaQjLMy13nEFYsmRJePDBB8PMmTP7Huvu7g5TpkwJv/nNb0JqZAgAkiI/tIX8AEBSisoP0SCO06n1h6YmKO6///7izwQAErJo0aJ+H/f09OTj/eKeTr29vWH99dfv93j8+PHHHw+pkSEAYOXkB/kBAFqVITq1/tDUBEX02muvhf/6r/8Kjz32WP5xbAk5/PDDS+mmGPb6y2FY+Evb/13K873FS7/vqJ9v3frHsk+BNnvrzTfa8u9kXV35KOI40ZgxY/o9Htd3/Na3vjXk46egUzKE/FA/8kN9yQ/1Iz+kp1PyA/WUlX0CQFKKqj+kUoNoaoLigQceyDfPGDFiRNhtt93yx84555zwne98J9x8881hp512Kvo8AaClsmzpKOI40bx588LIkSP7Hl9R90T0oQ99KAwbNiy89NJL/R6PH2+wwQYhNTIEACmRH9pDfgAgJUXlh8HWIDq1/tDUYlcnnnhivkn2s88+G37605/m45lnngmf/vSnwwknnFD8WQJAxcRg8N6xsgmK1VZbLey8887h1ltv7Xus0WjkH++xxx4hNTIEAKyc/CA/AECrMkSn1h+a7qC45JJLwiqr/N+nx//++te/HnbZZZcizw8A2qKRZfko4jiDNX369DBt2rT8PTR2Jp577rlh8eLF4bDDDgupkSEASIn80B7yAwApKSo/RIM9TifWH5qaoIizMHPnzg3jx4/v93hsJVlrrbWKOjcAqIWDDjoovPzyy+GUU04J8+fPDzvssEO48cYbl9u4KgUyBAAUQ35QgwCAFPLDKs1eSNyM6qyzzgoTJ07MH7v77rvD1772tXDwwQcXfY4A0HLxnoMi7l9o9hjHHXdcPlInQwCQEvmhPeQHAFJSVH4ITR6n0+oPTU1QxImJrq6u8KUvfSm88847IcuyfA2rY445JpxxxhnFnyUAtFgjWzqKOA4rJ0MAkBL5oT3kBwBSUlR+SKUG0dQm2XEy4t///d/Dq6++Gh566KHwu9/9LrzyyivhIx/5SNh8882LP0sAIAkyBAAgPwAATU1QvPXWW2HmzJn5JhqTJk0KN998c5gwYUK+YdWWW26ZT1qceOKJgzkkAHSE2A1Y1GB5MgQAKZIfWkt+ACBFReaHLIEaxKCWeIqbZ1x00UVhypQp4Z577gkHHnhgvsP3vffeG773ve/lHw8bNqx1ZwsALWKJhtaSIQBIkfzQWvIDACmyxNMQJih+8pOfhB/+8IfhM5/5THjkkUfC9ttvn+9BEZd4intSAADIEABAEdQgACB9g5qgeP7558POO++c//d2220Xenp68iWdTE4AkILqN0Z2LhkCgFTJD60jPwCQKvmhyT0oent7880tl1lllVXCmmuuOZhDAAA1JEMAAPIDADCkDoq46cahhx6ad05Ef/3rX8NXvvKVsMYaa/R73k9/+tPBHBYASmcN6daSIQBIkfzQWvIDACmyB8UQJiimTZvW7+NDDjlkMJ8OAB39f4DjKOI4LE+GACBF8kNryQ8ApKio/JBKDWJQExSXXnpp684EAEiWDAEAyA8AwJAmKAAgVY13RxHHAQDqQX4AAMrKD6nUIExQAEDeFrl0DFUC3ZUAwADJDwBAWfkhlRpEd9knAAAAAAAA1I8OCgCIbZHZ0jFURRwDAKgG+QEAKCs/pFKD0EEBAAAAAAC0nQ4KAMjXbczyMVRFHAMAqAb5AQAoKz+kUoMwQQEAsS3y3TFURRwDAKgG+QEAKCs/pFKDsMQTAAAAAADQdjooACC2ReatkUP/UlS/uRIAGCj5AQAoKz+kUoPQQQEAAAAAALSdDgoAiOs2Zlk+hqqIYwAA1SA/AABl5YdUahAmKABgWYtlAV+J6kcDAGCg5AcAoKz8kEoNwhJPAAAAAABA2+mgAIC8LXLpGKoijgEAVIP8AACUlR9SqUGYoACAKAuhkKUbEwgHAMAAyQ8AQFn5IZEahCWeAAAAAACAttNBAQCxLTJk+RiqIo4BAFSD/AAAlJUfUqlB6KAAAAAAAADaTgcFAMRlGwtaA7KwdSQBgI4nPwAAZeWHVGoQJigAILZFZkvHUBVxDACgGuQHAKCs/JBKDcISTwAAAAAAQNvpoAAASzQAAE2wxBMAUFZ+iCzxBACJaIQsH0UcBwCoB/kBACgrP6RSg7DEEwAAAAAA0HaWeAIASzQAAE2wxBMAUFZ+iCzx1CEW/vT7oTG8p+zToI1GfmxHX++aOr1nSdmnQJsteucv4TxfdVpAfqgf+aG+5If6kR+AInX5ctZW9RfPgc6ngwIA4rqNWZaPoSriGABANcgPAEBZ+SGVGoQJCgAIIfQ2lo6hKuIYAEA1yA8AQFn5IZUahE2yAQAAAACAttNBAQCWaAAAmmCJJwCgrPwQWeIJABIR39R77UEBAMgPAEAF6g+pTFBY4gkAAAAAAGg7SzwBQH7XQTF3HsTjAAD1ID8AAGXlh1RqEDooAAAAAACAttNBAQAhhN7G0jFURRwDAKgG+QEAKCs/pFKDMEEBAO9uLFXMEk8J9FcCAAMiPwAAZeWHVGoQlngCAAAAAADaTgcFAMS2yCzLx1AVcQwAoBrkBwCgrPyQSg3CBAUAxLbIvDVy6F+KBJZ/BAAGSH4AAMrKD6nUICzxBAAAAAAAtJ0OCgCIbZGNLB9DVcQxAIBqkB8AgLLyQyo1iNI7KF544YVwyCGHhHXXXTeMGDEiTJgwITzwwANlnxYA0MHkBwBAfgCA6iu1g+LVV18NkyZNCnvttVf41a9+FdZbb73w5JNPhrXXXrvM0wKghrIsC40CNpeKx6G15AcAOoX8UB3yAwCp5YdUahClTlCceeaZYcyYMeHSSy/te2zzzTcv85QAqKnebOko4ji0lvwAQKeQH6pDfgAgtfyQSg2i1CWefvazn4VddtklHHjggeHDH/5w2HHHHcMll1xS5ikBAB1OfgAA5AcASEOpExRPP/10uOCCC8KWW24ZbrrppnD00UeHr371q+Hyyy9f4fPfeuutsGjRon4DAIoQ2yuLGrSW/ABAp5Af0s0PkRoEAJ2eHxoJ1CBKXeKp0WjkHRTf+c538o9jB8UjjzwSLrzwwjBt2rTlnj9r1qxw2mmnlXCmAECnkB8AgFbnh0gNAgAS76DYcMMNwzbbbNPvsa233jrMnTt3hc+fOXNmWLhwYd+YN29em84UgNT1NrLCBq0lPwDQKeSHdPNDpAYBQKfnh94EahCldlBMmjQpPPHEE/0e+8Mf/hA23XTTFT6/p6cnHwBQtKJaI1Nor+x08gMAnUJ+SDc/RGoQALRCkUszNRKoQZTaQXHiiSeGe++9N2+xfOqpp8KPf/zjcPHFF4djjz22zNMCADqY/AAAyA8AkIZSJyh23XXXcN1114Urr7wybLfdduH0008P5557bpg6dWqZpwVADfVmxQ1aS34AoFPID9UhPwCQYn7oTaAGUeoST9GnP/3pfABAmSzRUC3yAwCdQH6oFvkBgE5giacO6qAAAAAAAADqqfQOCgDoBI1Glo8ijgMA1IP8AACUlR9SqUHooAAAAAAAANpOBwUA5GtAFrO5VAI3LwAAAyQ/AABl5YdUahAmKADAJpcAQBNskg0AlJUfoqKOUyZLPAEAAAAAAG2ngwIAQmyvzPIxVEUcAwCoBvkBACgrP6RSgzBBAQCxLbKR5WOoijgGAFAN8gMAUFZ+SKUGYYknAAAAAACg7XRQAEBsi8xbI4s5DgBQD/IDAFBWfkilBqGDAgAAAAAAaDsTFAAQ123MssJGq5xxxhlh4sSJYfXVVw+jR4/2ugFAyaqQHyIZAgDSzA+NBGoQJigAIG+vzAobrbJkyZJw4IEHhqOPPtprBgAdoAr5IZIhACDN/NCbQA3CHhQAUBGnnXZa/udll11W9qkAABUiQwAAnZofkpig+Pnux4QRa65V9mnQRpMvP9nXu6ZO3mF62adAm739l8Vt+XcajSz0NrJCjhMtWrSo3+M9PT35oHPID/UjP9SX/FA/8gMA0KmKqj+kUoOwxBMAxBbLdwNCESMaM2ZMGDVqVN+YNWuWrzMAJEZ+AADKzA+9CdQgTFAAQAvMmzcvLFy4sG/MnDlzhc+bMWNG6Orq+sDx+OOPe40AoAYGmh8iGQIASKEGkcQSTwAwVO+982Cox4lGjhyZj7/lpJNOCoceeugHPmfs2LFDPi8AIJ38EMkQAFDv/JBKDcIEBQCUaL311ssHAIAMAQDUrQZhggIA8rsO/u/Og6Eep1Xmzp0bXnnllfzP3t7e8NBDD+WPjxs3Lqy55pqt+4cBgMrmh0iGAID08kMqNQgTFADQgiUaWuGUU04Jl19+ed/HO+64Y/7nbbfdFiZPntyyfxcAqG5+iGQIAEh7iacq5webZANARVx22WUhy7LlhskJAECGAACqWIPQQQEAFboDEgDoHPIDAFBWfkilBmGCAgBCCI2CAkI8DgBQD/IDAFBWfkilBmGJJwAAAAAAoO10UABAbIvMClriKav+3QsAwMDIDwBAWfkhlRqEDgoAAAAAAKDtdFAAgE0uAYAm2CQbACgrP0Q2yQaARCgwAADyAwBQlfpDKhMUlngCAAAAAADazhJPABBCeKeRhWEF3HkQjwMA1IP8AACUlR9SqUHooAAAAAAAANpOBwUA2IMCAGiCPawAgLLyQyp7UJigAIAQQqOggBCPAwDUg/wAAJSVH1KpQVjiCQAAAAAAaDsdFAAQ2yKzLB9DVcQxAIBqkB8AgLLyQyo1CBMUAGANaQCgCfagAADKyg+p7EFhiScAAAAAAKDtdFAAgDsgAYAm6KAAAMrKD5EOCgAAAAAAgCbooAAAd0ACAE3QQQEAlJUfUumgMEEBAPFNPWuE3kajkOMAAPUgPwAAZeWHVGoQNskGAAAAAADaTgcFAIQQGgW1WMbjAAD1ID8AAGXlh1RqECYoAODddRu7C3hjT2H9RwBgYOQHAKCs/JBKDcISTwAAAAAAQNvpoACAEMI7jRC6CrjzIB4HAKgH+QEAKCs/pFKD0EEBAAAAAAC0nQ4KALCGNADQBHtQAABl5YdU9qAwQQEACgwAQBNMUAAAZeWHVCYoLPEEAAAAAAC0nQ4KAHAHJADQBB0UAEBZ+SGVDgoTFAAQQmg0skLe2ONxAIB6kB8AgLLyQyo1CEs8AQAAAAAAbaeDAgDebYvsKuDOgxTaKwGAgZEfAICy8kMqNQgdFAAAAAAAQNsl0UFxSM+TYWTPGmWfBm10/o8e8vWuqb2+8OGyT4E2++vi18Mv2/DvZFkWsgLuPIjHoRrkh/qRH+pLfqgf+QGAInT5MtZOV4XqD6nUIJKYoACAIjaWKmJzqRQ2qAIABkZ+AADKyg+p1CAs8QQAAAAAALSdDgoAWNZiWUBrZArtlQDAwMgPAEBZ+SGVGoQJCgCIb+qNgvagSKC9EgAYGPkBACgrP6RSg7DEEwAAAAAA0HY6KADAJpcAQBNskg0AlJUfIptkAwAAAAAANEEHBQDk6zYuHUNVxDEAgGqQHwCAsvJDKjUIExQAEN/UsywfQ1XEMQCAapAfAICy8kMqNQibZAMAAAAAAG2ngwIAbHIJADTBJtkAQFn5IbJJNgAAAAAAQBN0UABAvrFUlo+hKuIYAEA1yA8AQFn5IZUahAkKAIiKCggJhAMAYIDkBwBgsAqcoAgJ1CBK3SS7t7c3fPOb3wybb755GDFiRNhiiy3C6aefnsTu4wBAa8gPAID8AABpKLWD4swzzwwXXHBBuPzyy8O2224bHnjggXDYYYeFUaNGha9+9atlnhoANdPIstBVwAR5PA6tJT8A0Cnkh+qQHwBILT+kUoModYLinnvuCQcccEDYb7/98o8322yzcOWVV4b77ruvzNMCoIZi914he1AkEA46nfwAQKeQH6pDfgAgtfyQSg2i1CWeJk6cGG699dbwhz/8If/4d7/7XbjrrrvCP/zDP5R5WgBAB5MfAAD5AQDSUGoHxYwZM8KiRYvC+PHjw7Bhw/I1pc8444wwderUFT7/rbfeyscy8XMBoAjx7oVCOigS2KCq08kPAHQK+SHd/BCpQQDQyfkhlRpEqR0U11xzTbjiiivCj3/84zB79ux8L4qzzjor/3NFZs2ale9PsWyMGTOm7ecMAJRLfgAAWp0fIjUIAEi8g+Lkk0/O72I4+OCD848nTJgQnnvuuTwETJs2bbnnz5w5M0yfPr3v43j3g0kKAIrQaITQVcCdB/E4tJb8AECnkB/SzQ+RGgQAnZwfUqlBlDpB8eabb4bu7v5NHLHVsrGSr2xPT08+AKAlm1QVsLlUChtUdTr5AYBOIT+kmx8iNQgAOjk/pFKDKHWCYv/998/XfNxkk03CtttuG+bMmRPOPvvs8OUvf7nM0wIAOpj8AADIDwCQhlInKM4777zwzW9+MxxzzDFhwYIFYaONNgpHHXVUOOWUU8o8LQBqKGssHUUch9aSHwDoFPJDdcgPAKSWH1KpQZQ6QbHWWmuFc889Nx8AUKZGIytoD4rqt1d2OvkBgE4hP1SH/ABAavkhlRpE/wUYAQAAAAAAUu+gAIBOkTWyfBRxHACgHuQHAKCs/JBKDUIHBQAAAAAA0HY6KADAHZAAQBN0UAAAZeWHVDooTFAAQNxYKstCV1bAJtkFHAMAqAb5AQAoKz+kUoOwxBMAAAAAANB2OigAwBINAEATLPEEAJSVHyJLPAFAIrKsmIAQjwMA1IP8AACUlR9SqUFY4gkAAAAAAGg7SzwBwLttkY0iOigKugsCAOh88gMAUFZ+SKUGoYMCAAAAAABoOx0UALBsDcgC1m5MYf1HAGBg5AcAoKz8kEoNQgcFALzbFlnUaIVnn302HH744WHzzTcPI0aMCFtssUU49dRTw5IlS7x+AFCSTs8PkQwBAOnmhyyBGoQOCgCogMcffzw0Go1w0UUXhXHjxoVHHnkkHHHEEWHx4sXhrLPOKvv0AIAOJUMAAJ2cH0xQAEAISzeoKuDOg6I2unq/ffbZJx/LjB07NjzxxBPhggsuMEEBACXp9PwQyRAAkGZ+SKUGkcQExZyRO4Y11hpZ9mnQRl+Z9xtf75p69PVhZZ8CbfbG6+15q8oavfko4jjtsnDhwrDOOuu07d9LjfxQP/JDfckP9SM/fDAZAgan+iu8A530815U/SGVGkQSExQA0GkWLVrU7+Oenp58FOWpp54K5513nu4JAEhIq/NDJEMAQHoWVbgGYZNsAHjPHQxFjGjMmDFh1KhRfWPWrFkr/DrPmDEjdHV1feCIaz++1wsvvJC3Wh544IH5GpAAQL3yQyRDAEA1FZkfsgRqEDooAKAF5s2bF0aO/L/lB1d258JJJ50UDj300A88VlzrcZn//d//DXvttVeYOHFiuPjiiws8YwCgKvkhkiEAgBRqECYoACC/g6FR0B4UjfzPGAzeGw5WZr311svHQMS7FmIw2HnnncOll14aurs1QgJAHfNDJEMAQL3zQyo1CBMUABDf1Ht78zFURRxjZcFg8uTJYdNNN83XfHz55Zf7/m6DDTZoyb8JAFQ7P0QyBACkmR9SqUGYoACACrjlllvyTani2Hjjjfv9XZZlpZ0XANDZZAgAoJPzg7UhACB/gy1og6qsNXcvxDUiYwhY0QAAytHp+SGSIQAg0fzQSKMGYYICAAAAAABoO0s8AUC+sdTSuw+GqqiNrgCAzic/AABl5YdUahAmKABAgQEAaIIJCgCgrPyQygSFJZ4AAAAAAIC200EBAO6ABACaoIMCACgrP6TSQWGCAgDyN/VGQXtQNHw9AaAm5AcAoKz8kEoNwhJPAAAAAABA2+mgAIAQQiPevVDAHQz5cQCAWpAfAICy8kMqNQgdFAAAAAAAQNvpoAAAm1wCAE2wSTYAUFZ+iGySDQCJUGAAAOQHAKAq9YdUJigs8QQAAAAAALSdJZ4AIOrtDVl3AXce9Fb/7gUAYIDkBwCgrPyQSA3CBAUAxLbIrDeEAloj8+MAALUgPwAAZeWHVGoQlngCAAAAAADaTgcFAOQbSzWK6aCIxwEAakF+AADKyg+p1CB0UAAAAAAAAG2ngwIA8rsOCtqDoqC7IACAzic/AABl5YdUahAmKACgr8Vy6K2RKbRXAgADIz8AAGXlh1RqEJZ4AgAAAAAA2k4HBQBYogEAaIIlngCAsvJDZIknAEiEAgMAID8AAFWpP6QyQWGJJwAAAAAAoO0s8QQAIe5P1Ru6CrjzIIW7FwCAgZEfAICy8kMqNQgdFAAAAAAAQNvpoACAeNdBbyOErt5ijgMA1IL8AACUlR9SqUGYoACA+KaeFbNJVX4cAKAW5AcAoKz8kEoNwhJPAAAAAABA2+mgAIBlG0sVscRTAhtUAQADIz8AAGXlh1RqEDooAAAAAACAttNBAQDugAQAmqCDAgAoKz+k0kFhggIAFBgAgCaYoAAAysoPkQmKkmVZlv+5+I3Xyz4V2mzRMF/yunrjDSvT1c2y3/HLfue3TO/boZB/offtIo5CC8kP9SU/1Jf8UD/yA63MEK+/rgZRNy3+fyJAB1n2O76lNYii6g+J1CAq3UHx5z//Of/zgInbl30qALThd/6oUaMKP+5qq60WNthggzD/0WsKO2Y8XjwunUl+AKgP+YGiv5+icVtu6QsLkLhWZIhW1B9SqEF0ZS2/JbV1XnvttbD22muHuXPntqRo1ckWLVoUxowZE+bNmxdGjhwZ6qTO117363ft9XzdFy5cGDbZZJPw6quvhtGjR7fk3/jrX/8alixZUtjxYjAYPnx4YcejWHXOD5HfpfX8Xep197rX7XtefqAV6pwhvI94H6nb+4jv+Xp+z7cjQxRdf0ihBlHpDoru7qVLvcRgUMcfmChet2uvJ6+9n/m6WfY7vxXiG3mV38wZHPlhKe8j3kfqxvd8Pb/n5Qda8f2kBlHP3yfeR7zudVPn7/lWZgj1h+VZzB0AAAAAAGg7ExQAAAAAAEDbVXqCoqenJ5x66qn5n3Xj2uv5ukde+3q+9l73er7utEadf57qfv2u3eteN77n6/k9T+v4marnz5TX3eteN3X+no/qfv1lqPQm2QAAAAAAQDVVuoMCAAAAAACoJhMUAAAAAABA25mgAAAAAAAA2q5yExSvvPJKmDp1ahg5cmQYPXp0OPzww8Mbb7zxgZ8zefLk0NXV1W985StfCZ3u/PPPD5tttlkYPnx42H333cN99933gc//yU9+EsaPH58/f8KECeGXv/xlqKrBXPtll1223OsbP6+K7rzzzrD//vuHjTbaKL+O66+//m9+zu233x522mmnfPOecePG5V+POlx7vO73v+5xzJ8/P1TNrFmzwq677hrWWmut8OEPfzh89rOfDU888cTf/LwUfuabufaUfuZpnzrlh0iGqFeGqHN+qHOGkB/kB9qjThlCfqhXfqh7hpAf6ld/iNQgOlPlJihiMPj9738fbrnllvDzn/88/4Vy5JFH/s3PO+KII8KLL77YN7773e+GTnb11VeH6dOn57vGz549O3zsYx8Le++9d1iwYMEKn3/PPfeEz3/+83lYmjNnTv4LJo5HHnkkVM1grz2KYfG9r+9zzz0Xqmjx4sX59cZgOBDPPPNM2G+//cJee+0VHnrooXDCCSeEf/qnfwo33XRTSP3al4lvpO997eMbbNXccccd4dhjjw333ntv/rvt7bffDp/61Kfyr8nKpPIz38y1p/QzT/vUJT9EMkT9MkSd80OdM4T8ID/QHnXJEPJD/fJD3TOE/FC/+kOkBtGhsgp59NFHs3jK999/f99jv/rVr7Kurq7shRdeWOnn7bnnntnxxx+fVcluu+2WHXvssX0f9/b2ZhtttFE2a9asFT7/c5/7XLbffvv1e2z33XfPjjrqqKxqBnvtl156aTZq1KgsNfF7/brrrvvA53z961/Ptt12236PHXTQQdnee++dpX7tt912W/68V199NUvNggUL8mu74447VvqclH7mB3vtqf7M0zp1yg+RDFHvDFHn/FD3DCE/yA8Ur04ZQn6od36oe4aQH+pZf4jUIDpDpToofvOb3+QtlbvsskvfY1OmTAnd3d3ht7/97Qd+7hVXXBE+9KEPhe222y7MnDkzvPnmm6FTLVmyJDz44IP5tS0TrzF+HL8GKxIff+/zozjjv7Lnp3TtUWyx3XTTTcOYMWPCAQcckN/hUgepvO5DscMOO4QNN9wwfPKTnwx33313SMHChQvzP9dZZ53avfYDufY6/8zTnLrkh0iGkCEGItX3kLpnCPlBfqB4dckQ8oP8MFAyhPyQWnZUg+gMlZqgiOvCvr/1epVVVskLWR+0ZuwXvvCF8N///d/htttuy4PBj370o3DIIYeETvWnP/0p9Pb2hvXXX7/f4/HjlV1nfHwwz0/p2j/60Y+GH/zgB+GGG27IX+dGoxEmTpwYnn/++ZC6lb3uixYtCn/5y19CymJB4cILLwzXXnttPmKhOq71Gltyqyx+/8Y22UmTJuX/Z2ZlUvmZb+ba6/wzT3Pqkh8iGUKGGIg654dUM4T8ID/QGnXJEPKD/DBQdc4Q8kNa9YdIDaJzrBI6wIwZM8KZZ575gc957LHHmj7+e9eHjBu5xF8qn/jEJ8If//jHsMUWWzR9XDrDHnvskY9lYqFy6623DhdddFE4/fTTSz03WicWqeN47+sef6bPOeec/P8AVFXcjyGu43jXXXeFuhnotfuZZxn5gaHy+6SeUswQ8oP8wODIEAyF/FBP8kN61CA6R0dMUJx00knh0EMP/cDnjB07NmywwQbLbVL0zjvvhFdeeSX/u4Hafffd8z+feuqpjpygiG2gw4YNCy+99FK/x+PHK7vO+Phgnt+pmrn291t11VXDjjvumL++qVvZ6x437BoxYkSom912263Shf3jjjuub+O9jTfe+AOfm8rPfDPXXuefefqTH5YnQ8gQAyE/pJUh5Af5gcGTIfqTH+SHgZIh+pMfqll/iNQgOktHLPG03nrrhfHjx3/gWG211fJZ6tdeey3fo2CZX//613lLzrJJh4F46KGH8j9jJ0Unite68847h1tvvbXvsXiN8eP3dgq8V3z8vc+PbrnllpU+v1M1c+3vF5eIevjhhzv29S1SKq97UeLPdhVf97gnV3xzvO666/LfaZtvvnltXvtmrr3OP/P0Jz8sT4aQIQYilfeQumcI+UF+oHkyRH/yg/wwUDJEf/JD9bKjGkSHyipmn332yXbcccfst7/9bXbXXXdlW265Zfb5z3++7++ff/757KMf/Wj+99FTTz2Vffvb384eeOCB7JlnnsluuOGGbOzYsdnHP/7xrJNdddVVWU9PT3bZZZdljz76aHbkkUdmo0ePzubPn5///Re/+MVsxowZfc+/++67s1VWWSU766yzssceeyw79dRTs1VXXTV7+OGHs6oZ7LWfdtpp2U033ZT98Y9/zB588MHs4IMPzoYPH579/ve/z6rm9ddfz+bMmZOP+ON59tln5//93HPP5X8frzte/zJPP/10tvrqq2cnn3xy/rqff/752bBhw7Ibb7wxS/3azznnnOz666/Pnnzyyfz7/Pjjj8+6u7uz//mf/8mq5uijj85GjRqV3X777dmLL77YN958882+56T6M9/Mtaf0M0/71CU/RDJE/TJEnfNDnTOE/CA/0B51yRDyQ/3yQ90zhPxQv/pDpAbRmSo3QfHnP/85DwNrrrlmNnLkyOywww7Lf6ksEwNA/KV622235R/PnTs3DwLrrLNOXvQeN25c/ot04cKFWac777zzsk022SRbbbXVst122y279957+/5uzz33zKZNm9bv+ddcc0221VZb5c/fdttts1/84hdZVQ3m2k844YS+566//vrZvvvum82ePTurovh9G79/3z+WXW/8M17/+z9nhx12yK8/Bt9LL700q8O1n3nmmdkWW2yRB8H48z158uTs17/+dVZFK7ruON77Wqb6M9/Mtaf0M0/71Ck/RDJEvTJEnfNDnTOE/CA/0B51yhDyQ73yQ90zhPxQv/pDpAbRmbri/5TdxQEAAAAAANRLR+xBAQAAAAAA1IsJCgAAAAAAoO1MUAAAAAAAAG1nggIAAAAAAGg7ExQAAAAAAEDbmaAAAAAAAADazgQFAAAAAADQdiYoAAAAAACAtjNBAR3oW9/6Vthhhx3KPg0AoELkBwBAfgCqxgQFtMD8+fPDP//zP4exY8eGnp6eMGbMmLD//vuHW2+91dcbAJAfAAD1B4AQwiq+ClCsZ599NkyaNCmMHj06/Nu//VuYMGFCePvtt8NNN90Ujj322PD444/7kgMA8gMAoP4A1J4OCijYMcccE7q6usJ9990X/vEf/zFstdVWYdtttw3Tp08P9957b/6cuXPnhgMOOCCsueaaYeTIkeFzn/tceOmll1Z6zMmTJ4cTTjih32Of/exnw6GHHtr38WabbRb+5V/+JXzpS1/Kj7vpppuGn/3sZ+Hll1/u+7e233778MADD/R9zmWXXZZPpMTJk6233jp/zj777BNefPFF3xcA0EbyAwAgPwB1ZIICCvTKK6+EG2+8Me+UWGONNZb7+zgZ0Gg08gmD+Nw77rgj3HLLLeHpp58OBx100JD//XPOOSfv3pgzZ07Yb7/9whe/+MV8wuKQQw4Js2fPDltssUX+cZZlfZ/z5ptvhrPOOiv86Ec/CnfeeWc+efK1r31tyOcCAAyM/AAADJb8AKTCEk9QoKeeeiov/o8fP36lz4n7UDz88MPhmWeeyfemiH74wx/mXRb3339/2HXXXZv+9/fdd99w1FFH5f99yimnhAsuuCA/3oEHHpg/9o1vfCPsscceebfGBhtskD8Wl5+68MIL88mL6Ljjjgvf/va3mz4HAGBw5AcAYLDkByAVOiigQO/tTFiZxx57LJ+YWDY5EW2zzTZ5d0X8u6GISzgts/766+d/xj0w3v/YggUL+h5bffXV+yYnog033LDf3wMArSU/AADyA1BXJiigQFtuuWW+/0TRG2F3d3cvV7yInQ/vt+qqq/b9dzyPlT0Wl5la0ecse85ACiUAQDHkBwBAfgDqygQFFGidddYJe++9dzj//PPD4sWLl/v71157Ld+Met68eflY5tFHH83/LnZSrMh6663Xb+Pq3t7e8Mgjj3jtACAB8gMAID8AdWWCAgoWJyfiBMJuu+0Wrr322vDkk0/mSzf9x3/8R77/w5QpU/Jll6ZOnZpvXH3fffflG1fvueeeYZdddlnhMf/+7/8+/OIXv8hH7M44+uij8wkNACAN8gMAID8AdWSCAgo2duzYfOJhr732CieddFLYbrvtwic/+cl8c+y4aXVcQumGG24Ia6+9dvj4xz+eT1jEz7n66qtXeswvf/nLYdq0aX0TGfH58fgAQBrkBwBAfgDqqCuz2DwAAAAAANBmOigAAAAAAIC2M0EBAAAAAAC0nQkKAAAAAACg7UxQAAAAAAAAbWeCAgAAAAAAaDsTFAAAAAAAQNuZoAAAAAAAANrOBAUAAAAAANB2JigAAAAAAIC2M0EBAAAAAAC0nQkKAAAAAACg7UxQAAAAAAAAod3+P1z+ZmPfipV4AAAAAElFTkSuQmCC", + "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" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DSA (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/dsa_fig3_tutorial.ipynb b/examples/dsa_fig3_tutorial.ipynb new file mode 100644 index 0000000..5da6125 --- /dev/null +++ b/examples/dsa_fig3_tutorial.ipynb @@ -0,0 +1,674 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the first tutorial on DSA! We'll recreate the third figure from the paper (except the Procrustes analysis). In doing so, we'll learn about how to structure our data matrices to fit into DSA, how to apply the DSA to data, and how to select various paramters for DSA." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from DSA import DSA\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.manifold import MDS\n", + "\n", + "rng = np.random.default_rng(2023)\n", + "np.random.seed(2023)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we need to define our models, which we construct as ordinary differential equations. There are 3 types of models:\n", + "* Bistable switch (nonlinear system)\n", + "* Line attractor (linear system)\n", + "* Point attractor (linear system)\n", + "\n", + "The goal of this demonstration is to show that even the condition averaged trajectories sampled from these systems are the same, DSA can distinguish between the systems. \n", + "\n", + "How do we do this? Thanks to Galgali et al., (Nat. Neuro, 2023), we can construct three systems with different intrinsic dynamics that can be controlled to have the same condition averages. The process is a very simple feedback linearization scheme. We'll sample from the first system first and then use those condition averages to drive the latter two systems. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#defining our models\n", + "def run_model1(cohs,params,time=100,cond_avgs=None,seeded=False):\n", + " '''\n", + " simple saddle model\n", + "\n", + " Parameters\n", + " __________\n", + "\n", + " cohs : list or np.array\n", + " list of the constant input drives (using -.1 and 0.1 as default)\n", + " params : dict\n", + " dictionary of the parameters in the model (a,b,c) and system evolution\n", + " (dt, euler timesep size), (ntrials, number of sample trials),\n", + " (sigma, noise variance)\n", + " time : int \n", + " number of 'units to run', time / dt is the number of steps\n", + " cond_avgs : np.ndarray or None\n", + " condition average drive to control model\n", + " seeded : bool\n", + " if True, samples noise from a random generator with fixed seed\n", + " ''' \n", + " a = params.get('a',-.6)\n", + " b = params.get('b',2)\n", + " c = params.get('c',-1)\n", + " dt = params.get('dt',1)\n", + " ntrials = params.get('ntrials',10)\n", + " sigma = params.get('sigma',0)\n", + " steps = int(time / dt)\n", + " x = np.zeros((len(cohs),ntrials,steps,2))\n", + " cohs = np.array(cohs)\n", + " cohs = np.repeat(cohs[:,np.newaxis],ntrials,axis=1)\n", + " input_optimized = np.zeros((len(cohs),ntrials,steps,2))\n", + " for i in range(1,steps):\n", + " dx = a*x[:,:,i-1,0]**3 + b*x[:,:,i-1,0] + cohs\n", + " dy = c*x[:,:,i-1,1] + cohs\n", + " dx = np.concatenate([dx[:,:,np.newaxis],dy[:,:,np.newaxis]],axis=2)\n", + " if cond_avgs is not None:\n", + " xavg = x[:,:,i-1].mean(axis=1)\n", + " \n", + " dx_avg = a*xavg[:,-1]**3 + b*xavg[:,-1] + cohs.mean(axis=1)\n", + " dy_avg = c*xavg[:,-1] + cohs.mean(axis=1)\n", + " dx_avg = np.concatenate([dx_avg[:,np.newaxis],dy_avg[:,np.newaxis]],axis=1)\n", + " inp = (1/dt) * (cond_avgs[:,i] - xavg - dx_avg * dt)\n", + " input_optimized[:,:,i] = np.repeat(inp[:,np.newaxis],ntrials,axis=1)\n", + " else:\n", + " input_optimized[:,:,i] = 0\n", + " \n", + " if seeded:\n", + " rand = rng.normal(0,sigma,size=(len(cohs),ntrials,2))\n", + " else:\n", + " rand = np.random.normal(0,sigma,size=(len(cohs),ntrials,2))\n", + " x[:,:,i] = x[:,:,i-1] + dt * (dx + input_optimized[:,:,i] + rand)\n", + " \n", + " #xdot = [ax^3 + bx, cy]\n", + " cond_avg = np.mean(x,axis=1)\n", + " return x,cond_avg\n", + "\n", + "def run_model2(cond_avgs,params,time=100):\n", + " '''\n", + " line attractor model - similar arguments as run_model\n", + " '''\n", + " l0 = params.get('l0',[1,1])\n", + " l0 /= np.linalg.norm(l0)\n", + " r0 = params.get('r0',[1,0])\n", + " sigma = params.get('sigma',0)\n", + " dt = params.get('dt',1)\n", + " ntrials = params.get('ntrials',10)\n", + " eval1 = params.get('eval1',-1)\n", + " evals = np.diag([0,eval1])\n", + " # Mrot = np.array([[0,-1],[1,0]])\n", + " # r1 = Mrot @ l0\n", + " r1 = l0\n", + " R = np.array([r0,r1])\n", + " L = np.linalg.inv(R)\n", + " A = R @ evals @ L\n", + " theta = np.radians(45)\n", + " c, s = np.cos(theta), np.sin(theta)\n", + " Mrot = np.array(((c, -s), (s, c)))\n", + " A = Mrot @ A\n", + "\n", + " steps = int(time / dt)\n", + " x = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", + " input_optimized = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", + " for i in range(1,steps):\n", + " dx = np.einsum('ij,mkj->mki',A,x[:,:,i-1])\n", + " #dx = A @ x[:,:,i-1] \n", + " # dx_avg = np.einsum('ij,mkj->mki',A,cond_avgs[:,i-1])\n", + " xavg = x[:,:,i-1].mean(axis=1)\n", + " dx_avg = A @ xavg #cond_avgs[:,i-1]\n", + " inp = (1/dt) * (cond_avgs[:,i] - xavg - dx_avg * dt)\n", + " input_optimized[:,:,i] = np.repeat(inp[:,np.newaxis],ntrials,axis=1)\n", + " # diff = cond_avgs[:,i] - x[:,:,i-1].mean(axis=1)\n", + " # opt_input = (diff - dx.mean(axis=1)) \n", + " # input_optimized[:,:,i-1] = np.repeat(opt_input[:,np.newaxis],ntrials,axis=1)\n", + " x[:,:,i] = x[:,:,i-1] + dt*(dx + input_optimized[:,:,i] + \n", + " np.random.normal(0,sigma,size=(cond_avgs.shape[0],ntrials,2)))\n", + " return x, input_optimized\n", + "\n", + "def run_model3(cond_avgs,params,time=100):\n", + " '''\n", + " Point attractor model -- same argument structure as run_model2\n", + " '''\n", + " a1 = params.get('a1',-0.5) #eigenvalue 1\n", + " a2 = params.get('a2',-1) #eigenvalue 2\n", + " A = np.diag([-np.abs(a1),-np.abs(a2)]) #make sure they're negative\n", + " sigma = params.get('sigma',0)\n", + " dt = params.get('dt',1)\n", + " steps = int(time / dt)\n", + " ntrials = params.get('ntrials',10)\n", + " x = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", + " input_optimized = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", + " for i in range(1,steps):\n", + " dx = np.einsum('ij,mkj->mki',A,x[:,:,i-1])\n", + " #dx = A @ x[:,:,i-1] -- is the basic computation\n", + " xavg = x[:,:,i-1].mean(axis=1)\n", + " dx_avg = A @ xavg #cond_avgs[:,i-1]\n", + " # dx_avg = np.einsum('ij,mj->mi',A,cond_avgs[:,i-1])\n", + " inp = (1/dt) * (cond_avgs[:,i] - xavg - dx_avg * dt)\n", + " input_optimized[:,:,i] = np.repeat(inp[:,np.newaxis],ntrials,axis=1) \n", + " # diff = cond_avgs[:,i] - x[:,:,i-1].mean(axis=1)\n", + " # opt_input = (diff - dx.mean(axis=1)) \n", + " # input_optimized[:,:,i-1] = np.repeat(opt_input[:,np.newaxis],ntrials,axis=1)\n", + " x[:,:,i] = x[:,:,i-1] + dt*(dx + input_optimized[:,:,i] + \n", + " np.random.normal(0,sigma,size=(cond_avgs.shape[0],ntrials,2)))\n", + " return x, input_optimized" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 20, 10000, 2) (2, 10000, 2)\n", + "(2, 20, 10000, 2) (2, 10000, 2)\n", + "(2, 20, 10000, 2) (2, 10000, 2)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#let's visualize a sample from each \n", + "x1,cond_avg = run_model1([-.1,.1],dict(dt=0.01,sigma=0.1,ntrials=20))\n", + "print(x1.shape,cond_avg.shape)\n", + "\n", + "x2,input_optimized2 = run_model2(cond_avg,dict(dt=0.01,sigma=0.1,ntrials=20))\n", + "cond_avg2 = x2.mean(axis=1)\n", + "print(x2.shape,cond_avg2.shape)\n", + "\n", + "x3,input_optimized3 = run_model3(cond_avg,dict(dt=0.01,sigma=0.1,ntrials=20))\n", + "cond_avg3 = x3.mean(axis=1)\n", + "print(x3.shape,cond_avg3.shape)\n", + "\n", + "fig,ax = plt.subplots(1,3,figsize=(8,3),sharex=True,sharey=True)\n", + "for i in range(x1.shape[0]):\n", + " for k, cavg in enumerate([cond_avg,cond_avg2,cond_avg3]):\n", + " ax[k].plot(cavg[i,:,0],cavg[i,:,1])\n", + " for j in range(x1.shape[1]):\n", + " if j == 10:\n", + " break\n", + " for k, x in enumerate([x1,x2,x3]):\n", + " ax[k].plot(x[i,j,:,0],x[i,j,:,1],c=\"orange\" if i else \"blue\", alpha = 0.2)\n", + "\n", + "for i in range(3):\n", + " ax[i].set_ylim(-0.15,0.15)\n", + " ax[i].set_xlabel(r\"$h_1$\")\n", + "ax[0].set_ylabel(r\"$h_2$\")\n", + "\n", + "ax[0].set_title(\"Saddle Point\")\n", + "ax[1].set_title(\"Line Attractor\")\n", + "ax[2].set_title(\"Point Attractor\")\n", + "plt.tight_layout()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#define the parameters for our samples and our dmd\n", + "nmodels = 4 #3 x nmodels total\n", + "sigma = 0.05 #trajectory noise\n", + "ntrials = 100 #number of trajectories per model\n", + "dt = 0.01 #timestep simulated in the odes --don't make this too small\n", + "\n", + "\n", + "#if you want to make the task harder, you can change these paramters around!\n", + "#vary params for model 1\n", + "a = np.random.uniform(-5,-4,size=nmodels) \n", + "b = np.random.uniform(4,5,size=nmodels)\n", + "c = np.random.uniform(-4,-3,size=nmodels)\n", + "\n", + "#vary params for model 2\n", + "eval1 = np.random.uniform(-2,-3,size=nmodels)\n", + "\n", + "#vary params for model 3\n", + "a1 = np.random.uniform(-4,-5,size=nmodels)\n", + "a2 = np.random.uniform(-8,-9,size=nmodels)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next let's sample the data. Depending on how you set your parameters, such as the number of models, this may take awhile. We'll run them alternating model type, so the models 2 and 3 aren't fitted only only a single condition-averaged trajectory from model 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#some code that's relevant for processing our data\n", + "def flatten_x(x1):\n", + " #this will flatten the first 2 dimensions (conditions, trials) to 1 dimension\n", + " return x1.reshape(x1.shape[0]*x1.shape[1],x1.shape[2],x1.shape[3])\n", + "\n", + "models = [[],[],[]]\n", + "model_names = ['bistable'] * nmodels + ['line attractor'] * nmodels + ['point attractor'] * nmodels\n", + "\n", + "for i in range(nmodels): \n", + " x1,cond_avg = run_model1([-.1,.1],dict(dt=dt,sigma=sigma,ntrials=ntrials,a=a[i],b=b[i],c=c[i])) \n", + " #x has shape conditions x trials x time x dimension\n", + " models[0].append(flatten_x(x1))\n", + "\n", + " x2,input_optimized = run_model2(cond_avg,dict(dt=dt,sigma=sigma,ntrials=ntrials,eval1=eval1[i]))\n", + " models[1].append(flatten_x(x2))\n", + "\n", + " x3,input_optimized = run_model3(cond_avg,dict(dt=dt,sigma=sigma,ntrials=ntrials,a1=a1[i],a2=a2[i]))\n", + " models[2].append(flatten_x(x3))\n", + "\n", + "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, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 12/12 [00:03<00:00, 3.32it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 12/12 [00:00<00:00, 5717.56it/s]\n", + "Computing DMD similarities: 100%|██████████| 66/66 [00:00<00:00, 1368.35it/s]\n" + ] + } + ], + "source": [ + "#dmd parameters, all others are default for now.\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,score_method='wasserstein')\n", + "similarities = dsa.fit_score()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first visualize this as a heatmap. We should see a block structure corresponding to the different types of models." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(similarities)\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Excellent! We should see a block structure here. Let's reduce the dimensionality with MDS and make sure the clusters appear. Note that they might not be as evident with a small number of models--in the original paper, we used 100 models for each type, which really allowed for some strong separation between each network. It's possible that the clustering will be weaker in the smaller dataset setting." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/.venv/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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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reduced = MDS(dissimilarity='precomputed').fit_transform(similarities)\n", + "\n", + "# Create a colormap for the different model types\n", + "unique_types = list(set(model_names))\n", + "colors = plt.cm.plasma(np.linspace(0, 0.7, len(unique_types)))\n", + "color_map = {model_type: colors[i] for i, model_type in enumerate(unique_types)}\n", + "\n", + "# Plot each model type with its corresponding color\n", + "for model_type in unique_types:\n", + " mask = [name == model_type for name in model_names]\n", + " plt.scatter(reduced[mask, 0], reduced[mask, 1], \n", + " label=model_type, color=color_map[model_type], alpha=0.7)\n", + "\n", + "plt.xlabel(f\"MDS 1\")\n", + "plt.ylabel(f\"MDS 2\")\n", + "plt.legend()\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dealing with Memory Issues involved in Many Comparisons\n", + "\n", + "The current DSA object might not be very good at is performing comparisons on many many models (think hundreds to thousands). This is because the current object would require saving all of the data simultaneously, fitting each DMD in series, and then comparing each DMD pairwise. That would take a lot of memory! Fortunately, we can design a different approach in which we utilize the two main objects in the DSA class iteratively: \n", + "* DMD: fits the DMD matrix to the data\n", + "* SimilarityTransformDist: compares two DMD matrices, returning a similarity score\n", + "\n", + "With these in series, we can iteratively compute the DMD matrices, and save only the relevant feature: DMD.A_v.numpy(), the DMD matrix. This will allow us to throw away our data for each model (or stream them in one at a time), thereby allowing us to fit many more models without having to put it all into one class. Then, we can compute our DSA's pairwise to achieve the final result. \n", + "\n", + "For the sake of readability here, we'll only display the standard looped version, but for added computational boost we can add in parallel processing for each DMD computation" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from DSA.dmd import DMD\n", + "from DSA.simdist import SimilarityTransformDist\n", + "\n", + "nmodels = 5 #3*nmodels total, turn this up as high as you want\n", + "sigma = 0.05\n", + "\n", + "ntrials = 100\n", + "dt = 0.01\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", + "b = np.random.uniform(4,7,size=nmodels)\n", + "c = np.random.uniform(-4,-2,size=nmodels)\n", + "\n", + "#vary params for model 2\n", + "eval1 = np.random.uniform(-1,-3,size=nmodels)\n", + "\n", + "#vary params for model 3\n", + "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=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()\n", + " return dmd.A_v.numpy()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/sh/r0d61tjn42s4mc3nxqb0hhq00000gn/T/ipykernel_79107/1281545838.py:28: RuntimeWarning: CUDA device 'cuda' requested but CUDA is not available. Falling back to CPU. 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", + "4\n" + ] + } + ], + "source": [ + "model_types = []\n", + "models = []\n", + "for i in range(nmodels): \n", + " print(i)\n", + " 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)\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)\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)\n", + " models.append(dmd3)\n", + " model_types.append('point attractor')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "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='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", + " smtype = int(model_types[i] == model_types[j])\n", + " sims_mtype[i,j] = sims_mtype[j,i] = smtype\n", + " if i == j:\n", + " sims_mtype[i,i] = 2\n", + " if j < i:\n", + " continue\n", + " sdmd = comparison_dmd.fit_score(mi,mj)\n", + " # print(i,j,sdmd)\n", + "\n", + " sims_dmd[i,j] = sims_dmd[j,i] = sdmd\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/.venv/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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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reduced = MDS(dissimilarity='precomputed').fit_transform(sims_dmd)\n", + "\n", + "# Create a colormap for the different model types\n", + "unique_types = list(set(model_types))\n", + "colors = plt.cm.plasma(np.linspace(0, 0.7, len(unique_types)))\n", + "color_map = {model_type: colors[i] for i, model_type in enumerate(unique_types)}\n", + "\n", + "# Plot each model type with its corresponding color\n", + "for model_type in unique_types:\n", + " mask = [name == model_type for name in model_types]\n", + " plt.scatter(reduced[mask, 0], reduced[mask, 1], \n", + " label=model_type, color=color_map[model_type], alpha=0.7)\n", + "\n", + "plt.xlabel(f\"MDS 1\")\n", + "plt.ylabel(f\"MDS 2\")\n", + "plt.legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DSA (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/dsa_koopstd_fix.ipynb b/examples/dsa_koopstd_fix.ipynb new file mode 100644 index 0000000..89973b2 --- /dev/null +++ b/examples/dsa_koopstd_fix.ipynb @@ -0,0 +1,514 @@ +{ + "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": 2, + "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": 3, + "id": "e75af356", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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": 4, + "id": "90e66ece", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((2000, 3), 100)" + ] + }, + "execution_count": 4, + "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": 5, + "id": "0eb18f19", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 100/100 [00:01<00:00, 57.16it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 100/100 [00:00<00:00, 25628.16it/s]\n", + "Computing DMD similarities: 100%|██████████| 4950/4950 [00:01<00:00, 3277.61it/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": 7, + "id": "e7a0aecd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/.venv/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 [0. 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 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", + "im = axes[0].imshow(sims, cmap='gist_gray', aspect='auto')\n", + "cbar = plt.colorbar(im, ax=axes[0])\n", + "cbar.set_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 data for scatter plot\n", + "x = embedding[:, 0]\n", + "y = embedding[:, 1]\n", + "silhouette_score_ = round(silhouette_score(sims, rho_labels),3)\n", + "\n", + "# Plot scatter with improved styling\n", + "# Create a color map for each unique rho value\n", + "unique_labels = []\n", + "for label in rho_labels:\n", + " if label not in unique_labels:\n", + " unique_labels.append(label)\n", + "\n", + "colors = plt.cm.tab10(np.linspace(0, 1, len(unique_labels)))\n", + "label_to_color = {label: colors[i] for i, label in enumerate(unique_labels)}\n", + "\n", + "for label in unique_labels:\n", + " mask = [rho_labels[i] == label for i in range(len(rho_labels))]\n", + " axes[1].scatter(x[mask], y[mask], label=label, s=60, alpha=0.8, color=label_to_color[label])\n", + "\n", + "axes[1].set_xlabel('MDS Component 1')\n", + "axes[1].set_ylabel('MDS Component 2')\n", + "axes[1].set_xticks([round(min(x),2), round(max(x),2)])\n", + "axes[1].set_yticks([round(min(y),2), round(max(y),2)])\n", + "axes[1].legend(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 (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/fig3_tutorial.ipynb b/examples/fig3_tutorial.ipynb deleted file mode 100644 index 6071546..0000000 --- a/examples/fig3_tutorial.ipynb +++ /dev/null @@ -1,889 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is the first tutorial on DSA! We'll recreate the third figure from the paper (except the Procrustes analysis). In doing so, we'll learn about how to structure our data matrices to fit into DSA, how to apply the DSA to data, and how to select various paramters for DSA." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "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" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from DSA import DSA\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.manifold import MDS\n", - "import seaborn as sns\n", - "import pandas as pd\n", - "\n", - "rng = np.random.default_rng(2023)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we need to define our models, which we construct as ordinary differential equations. There are 3 types of models:\n", - "* Bistable switch (nonlinear system)\n", - "* Line attractor (linear system)\n", - "* Point attractor (linear system)\n", - "\n", - "The goal of this demonstration is to show that even the condition averaged trajectories sampled from these systems are the same, DSA can distinguish between the systems. \n", - "\n", - "How do we do this? Thanks to Galgali et al., (Nat. Neuro, 2023), we can construct three systems with different intrinsic dynamics that can be controlled to have the same condition averages. The process is a very simple feedback linearization scheme. We'll sample from the first system first and then use those condition averages to drive the latter two systems. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "#defining our models\n", - "def run_model1(cohs,params,time=100,cond_avgs=None,seeded=False):\n", - " '''\n", - " simple saddle model\n", - "\n", - " Parameters\n", - " __________\n", - "\n", - " cohs : list or np.array\n", - " list of the constant input drives (using -.1 and 0.1 as default)\n", - " params : dict\n", - " dictionary of the parameters in the model (a,b,c) and system evolution\n", - " (dt, euler timesep size), (ntrials, number of sample trials),\n", - " (sigma, noise variance)\n", - " time : int \n", - " number of 'units to run', time / dt is the number of steps\n", - " cond_avgs : np.ndarray or None\n", - " condition average drive to control model\n", - " seeded : bool\n", - " if True, samples noise from a random generator with fixed seed\n", - " ''' \n", - " a = params.get('a',-.6)\n", - " b = params.get('b',2)\n", - " c = params.get('c',-1)\n", - " dt = params.get('dt',1)\n", - " ntrials = params.get('ntrials',10)\n", - " sigma = params.get('sigma',0)\n", - " steps = int(time / dt)\n", - " x = np.zeros((len(cohs),ntrials,steps,2))\n", - " cohs = np.array(cohs)\n", - " cohs = np.repeat(cohs[:,np.newaxis],ntrials,axis=1)\n", - " input_optimized = np.zeros((len(cohs),ntrials,steps,2))\n", - " for i in range(1,steps):\n", - " dx = a*x[:,:,i-1,0]**3 + b*x[:,:,i-1,0] + cohs\n", - " dy = c*x[:,:,i-1,1] + cohs\n", - " dx = np.concatenate([dx[:,:,np.newaxis],dy[:,:,np.newaxis]],axis=2)\n", - " if cond_avgs is not None:\n", - " xavg = x[:,:,i-1].mean(axis=1)\n", - " \n", - " dx_avg = a*xavg[:,-1]**3 + b*xavg[:,-1] + cohs.mean(axis=1)\n", - " dy_avg = c*xavg[:,-1] + cohs.mean(axis=1)\n", - " dx_avg = np.concatenate([dx_avg[:,np.newaxis],dy_avg[:,np.newaxis]],axis=1)\n", - " inp = (1/dt) * (cond_avgs[:,i] - xavg - dx_avg * dt)\n", - " input_optimized[:,:,i] = np.repeat(inp[:,np.newaxis],ntrials,axis=1)\n", - " else:\n", - " input_optimized[:,:,i] = 0\n", - " \n", - " if seeded:\n", - " rand = rng.normal(0,sigma,size=(len(cohs),ntrials,2))\n", - " else:\n", - " rand = np.random.normal(0,sigma,size=(len(cohs),ntrials,2))\n", - " x[:,:,i] = x[:,:,i-1] + dt * (dx + input_optimized[:,:,i] + rand)\n", - " \n", - " #xdot = [ax^3 + bx, cy]\n", - " cond_avg = np.mean(x,axis=1)\n", - " return x,cond_avg\n", - "\n", - "def run_model2(cond_avgs,params,time=100):\n", - " '''\n", - " line attractor model - similar arguments as run_model\n", - " '''\n", - " l0 = params.get('l0',[1,1])\n", - " l0 /= np.linalg.norm(l0)\n", - " r0 = params.get('r0',[1,0])\n", - " sigma = params.get('sigma',0)\n", - " dt = params.get('dt',1)\n", - " ntrials = params.get('ntrials',10)\n", - " eval1 = params.get('eval1',-1)\n", - " evals = np.diag([0,eval1])\n", - " # Mrot = np.array([[0,-1],[1,0]])\n", - " # r1 = Mrot @ l0\n", - " r1 = l0\n", - " R = np.array([r0,r1])\n", - " L = np.linalg.inv(R)\n", - " A = R @ evals @ L\n", - " theta = np.radians(45)\n", - " c, s = np.cos(theta), np.sin(theta)\n", - " Mrot = np.array(((c, -s), (s, c)))\n", - " A = Mrot @ A\n", - "\n", - " steps = int(time / dt)\n", - " x = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", - " input_optimized = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", - " for i in range(1,steps):\n", - " dx = np.einsum('ij,mkj->mki',A,x[:,:,i-1])\n", - " #dx = A @ x[:,:,i-1] \n", - " # dx_avg = np.einsum('ij,mkj->mki',A,cond_avgs[:,i-1])\n", - " xavg = x[:,:,i-1].mean(axis=1)\n", - " dx_avg = A @ xavg #cond_avgs[:,i-1]\n", - " inp = (1/dt) * (cond_avgs[:,i] - xavg - dx_avg * dt)\n", - " input_optimized[:,:,i] = np.repeat(inp[:,np.newaxis],ntrials,axis=1)\n", - " # diff = cond_avgs[:,i] - x[:,:,i-1].mean(axis=1)\n", - " # opt_input = (diff - dx.mean(axis=1)) \n", - " # input_optimized[:,:,i-1] = np.repeat(opt_input[:,np.newaxis],ntrials,axis=1)\n", - " x[:,:,i] = x[:,:,i-1] + dt*(dx + input_optimized[:,:,i] + \n", - " np.random.normal(0,sigma,size=(cond_avgs.shape[0],ntrials,2)))\n", - " return x, input_optimized\n", - "\n", - "def run_model3(cond_avgs,params,time=100):\n", - " '''\n", - " Point attractor model -- same argument structure as run_model2\n", - " '''\n", - " a1 = params.get('a1',-0.5) #eigenvalue 1\n", - " a2 = params.get('a2',-1) #eigenvalue 2\n", - " A = np.diag([-np.abs(a1),-np.abs(a2)]) #make sure they're negative\n", - " sigma = params.get('sigma',0)\n", - " dt = params.get('dt',1)\n", - " steps = int(time / dt)\n", - " ntrials = params.get('ntrials',10)\n", - " x = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", - " input_optimized = np.zeros((cond_avgs.shape[0],ntrials,steps,2))\n", - " for i in range(1,steps):\n", - " dx = np.einsum('ij,mkj->mki',A,x[:,:,i-1])\n", - " #dx = A @ x[:,:,i-1] -- is the basic computation\n", - " xavg = x[:,:,i-1].mean(axis=1)\n", - " dx_avg = A @ xavg #cond_avgs[:,i-1]\n", - " # dx_avg = np.einsum('ij,mj->mi',A,cond_avgs[:,i-1])\n", - " inp = (1/dt) * (cond_avgs[:,i] - xavg - dx_avg * dt)\n", - " input_optimized[:,:,i] = np.repeat(inp[:,np.newaxis],ntrials,axis=1) \n", - " # diff = cond_avgs[:,i] - x[:,:,i-1].mean(axis=1)\n", - " # opt_input = (diff - dx.mean(axis=1)) \n", - " # input_optimized[:,:,i-1] = np.repeat(opt_input[:,np.newaxis],ntrials,axis=1)\n", - " x[:,:,i] = x[:,:,i-1] + dt*(dx + input_optimized[:,:,i] + \n", - " np.random.normal(0,sigma,size=(cond_avgs.shape[0],ntrials,2)))\n", - " return x, input_optimized" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(2, 20, 10000, 2) (2, 10000, 2)\n", - "(2, 20, 10000, 2) (2, 10000, 2)\n", - "(2, 20, 10000, 2) (2, 10000, 2)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#let's visualize a sample from each \n", - "x1,cond_avg = run_model1([-.1,.1],dict(dt=0.01,sigma=0.1,ntrials=20))\n", - "print(x1.shape,cond_avg.shape)\n", - "\n", - "x2,input_optimized2 = run_model2(cond_avg,dict(dt=0.01,sigma=0.1,ntrials=20))\n", - "cond_avg2 = x2.mean(axis=1)\n", - "print(x2.shape,cond_avg2.shape)\n", - "\n", - "x3,input_optimized3 = run_model3(cond_avg,dict(dt=0.01,sigma=0.1,ntrials=20))\n", - "cond_avg3 = x3.mean(axis=1)\n", - "print(x3.shape,cond_avg3.shape)\n", - "\n", - "fig,ax = plt.subplots(1,3,figsize=(8,3),sharex=True,sharey=True)\n", - "for i in range(x1.shape[0]):\n", - " for k, cavg in enumerate([cond_avg,cond_avg2,cond_avg3]):\n", - " ax[k].plot(cavg[i,:,0],cavg[i,:,1])\n", - " for j in range(x1.shape[1]):\n", - " if j == 10:\n", - " break\n", - " for k, x in enumerate([x1,x2,x3]):\n", - " ax[k].plot(x[i,j,:,0],x[i,j,:,1],c=\"orange\" if i else \"blue\", alpha = 0.2)\n", - "\n", - "for i in range(3):\n", - " ax[i].set_ylim(-0.15,0.15)\n", - " ax[i].set_xlabel(r\"$h_1$\")\n", - "ax[0].set_ylabel(r\"$h_2$\")\n", - "\n", - "ax[0].set_title(\"Saddle Point\")\n", - "ax[1].set_title(\"Line Attractor\")\n", - "ax[2].set_title(\"Point Attractor\")\n", - "plt.tight_layout()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "#define the parameters for our samples and our dmd\n", - "nmodels = 4 #3 x nmodels total\n", - "sigma = 0.05 #trajectory noise\n", - "ntrials = 100 #number of trajectories per model\n", - "dt = 0.01 #timestep simulated in the odes --don't make this too small\n", - "\n", - "\n", - "#if you want to make the task harder, you can change these paramters around!\n", - "#vary params for model 1\n", - "a = np.random.uniform(-5,-4,size=nmodels) \n", - "b = np.random.uniform(4,5,size=nmodels)\n", - "c = np.random.uniform(-4,-3,size=nmodels)\n", - "\n", - "#vary params for model 2\n", - "eval1 = np.random.uniform(-2,-3,size=nmodels)\n", - "\n", - "#vary params for model 3\n", - "a1 = np.random.uniform(-4,-5,size=nmodels)\n", - "a2 = np.random.uniform(-8,-9,size=nmodels)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next let's sample the data. Depending on how you set your parameters, such as the number of models, this may take awhile. We'll run them alternating model type, so the models 2 and 3 aren't fitted only only a single condition-averaged trajectory from model 1" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "#some code that's relevant for processing our data\n", - "def flatten_x(x1):\n", - " #this will flatten the first 2 dimensions (conditions, trials) to 1 dimension\n", - " return x1.reshape(x1.shape[0]*x1.shape[1],x1.shape[2],x1.shape[3])\n", - "\n", - "models = [[],[],[]]\n", - "model_names = ['bistable'] * nmodels + ['line attractor'] * nmodels + ['point attractor'] * nmodels\n", - "\n", - "for i in range(nmodels): \n", - " x1,cond_avg = run_model1([-.1,.1],dict(dt=dt,sigma=sigma,ntrials=ntrials,a=a[i],b=b[i],c=c[i])) \n", - " #x has shape conditions x trials x time x dimension\n", - " models[0].append(flatten_x(x1))\n", - "\n", - " x2,input_optimized = run_model2(cond_avg,dict(dt=dt,sigma=sigma,ntrials=ntrials,eval1=eval1[i]))\n", - " models[1].append(flatten_x(x2))\n", - "\n", - " x3,input_optimized = run_model3(cond_avg,dict(dt=dt,sigma=sigma,ntrials=ntrials,a1=a1[i],a2=a2[i]))\n", - " models[2].append(flatten_x(x3))\n", - "\n", - "models = [x for mtype in models for x in mtype] #list the models by type (bistable,...,line,...,point,...)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "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" - ] - } - ], - "source": [ - "#dmd parameters, all others are default for now.\n", - "n_delays = 50\n", - "delay_interval = 20\n", - "rank = 30\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", - "similarities = dsa.fit_score()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's first visualize this as a heatmap. We should see a block structure corresponding to the different types of models." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sns.heatmap(similarities)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Excellent! We should see a block structure here. Let's reduce the dimensionality with MDS and make sure the clusters appear. Note that they might not be as evident with a small number of models--in the original paper, we used 100 models for each type, which really allowed for some strong separation between each network. It's possible that the clustering will be weaker in the smaller dataset setting." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "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", - " warnings.warn(\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df = pd.DataFrame()\n", - "df['Model Type'] = model_names\n", - "reduced = MDS(dissimilarity='precomputed').fit_transform(similarities)\n", - "df[\"0\"] = reduced[:,0] \n", - "df[\"1\"] = reduced[:,1]\n", - "\n", - "palette = 'plasma'\n", - "sns.scatterplot(data=df,x=\"0\",y=\"1\",hue=\"Model Type\",palette=palette)\n", - "plt.xlabel(f\"MDS 1\")\n", - "plt.ylabel(f\"MDS 2\")\n", - "plt.tight_layout()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Dealing with Memory Issues involved in Many Comparisons\n", - "\n", - "The current DSA object might not be very good at is performing comparisons on many many models (think hundreds to thousands). This is because the current object would require saving all of the data simultaneously, fitting each DMD in series, and then comparing each DMD pairwise. That would take a lot of memory! Fortunately, we can design a different approach in which we utilize the two main objects in the DSA class iteratively: \n", - "* DMD: fits the DMD matrix to the data\n", - "* SimilarityTransformDist: compares two DMD matrices, returning a similarity score\n", - "\n", - "With these in series, we can iteratively compute the DMD matrices, and save only the relevant feature: DMD.A_v.numpy(), the DMD matrix. This will allow us to throw away our data for each model (or stream them in one at a time), thereby allowing us to fit many more models without having to put it all into one class. Then, we can compute our DSA's pairwise to achieve the final result. \n", - "\n", - "For the sake of readability here, we'll only display the standard looped version, but for added computational boost we can add in parallel processing for each DMD computation" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "from DSA.dmd import DMD\n", - "from DSA.simdist import SimilarityTransformDist\n", - "\n", - "nmodels = 5 #3*nmodels total, turn this up as high as you want\n", - "sigma = 0.05\n", - "\n", - "ntrials = 300\n", - "dt = 0.01\n", - "downsample = 20\n", - "n_delays = 50\n", - "rank = 30\n", - "\n", - "#vary params for model 1\n", - "a = np.random.uniform(-5,-3,size=nmodels) \n", - "b = np.random.uniform(4,7,size=nmodels)\n", - "c = np.random.uniform(-4,-2,size=nmodels)\n", - "\n", - "#vary params for model 2\n", - "eval1 = np.random.uniform(-1,-3,size=nmodels)\n", - "\n", - "#vary params for model 3\n", - "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", - " 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", - " return dmd.A_v.numpy()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "1\n", - "2\n", - "3\n", - "4\n" - ] - } - ], - "source": [ - "model_types = []\n", - "models = []\n", - "for i in range(nmodels): \n", - " print(i)\n", - " 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", - " 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", - " 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", - " models.append(dmd3)\n", - " model_types.append('point attractor')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "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" - ] - } - ], - "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", - "\n", - "for i,mi in enumerate(models):\n", - " for j,mj in enumerate(models):\n", - " smtype = int(model_types[i] == model_types[j])\n", - " sims_mtype[i,j] = sims_mtype[j,i] = smtype\n", - " if i == j:\n", - " sims_mtype[i,i] = 2\n", - " if j < i:\n", - " continue\n", - " sdmd = comparison_dmd.fit_score(mi,mj)\n", - " print(i,j,sdmd)\n", - "\n", - " sims_dmd[i,j] = sims_dmd[j,i] = sdmd\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "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", - " warnings.warn(\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df = pd.DataFrame()\n", - "df['Model Type'] = model_types\n", - "lowd_embedding = MDS(dissimilarity='precomputed').fit_transform(sims_dmd)\n", - "df[f\"DMD:0\"] = lowd_embedding[:,0] \n", - "df[f\"DMD:1\"] = lowd_embedding[:,1]\n", - " \n", - "\n", - "fig,ax = plt.subplots(1,1,sharex=True,sharey=True)\n", - "sns.scatterplot(data=df,x=f\"DMD:0\",y=f\"DMD:1\",hue=\"Model Type\",ax=ax,palette=palette)\n", - "ax.set_xlabel(f\"MDS 1\")\n", - "ax.set_ylabel(f\"MDS 2\")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/how_to_use_dsa_tutorial.ipynb b/examples/how_to_use_dsa_tutorial.ipynb new file mode 100644 index 0000000..653bafe --- /dev/null +++ b/examples/how_to_use_dsa_tutorial.ipynb @@ -0,0 +1,1179 @@ +{ + "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": 1, + "metadata": {}, + "outputs": [], + "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 DefaultSweeper\n", + "from DSA.stats import compute_all_stats\n", + "\n", + "np.random.seed(22)\n", + "torch.manual_seed(22)\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\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, nonlinearity=False):\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", + " if nonlinearity:\n", + " x = np.tanh(x) \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, 1053.18it/s]\n", + "Caching compare objects X: 100%|██████████| 2/2 [00:00<00:00, 27060.03it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:02<00:00, 2.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Similarity matrix shape: (2, 2)\n", + "Similarity between systems: 0.8746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAGwCAYAAABmTltaAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAJyxJREFUeJzt3QmYFdWdN/5fNyCgAoqiiOJCMCpxAUUI/mM0kQjqZNMkoiYu46MmcRs1iWCiaJwJblEnyqjxdcn7xASXiRlfY3B3HAkBBY2CS6LigAsSQgQEQaDv/znldE83NNAHu+m+tz8fn7K7qs691LlV99a3T506t6pUKpUCAIAmq256UQAABCgAgA2gBQoAIJMABQCQSYACAMgkQAEAZBKgAAAydcx9QHtTU1MTb7/9dnTr1i2qqqpae3MAgCZIw1wuXrw4+vTpE9XVzd9eJECtRwpPffv2bfYXHgBoeXPmzIkddtih2Z9XgFqP1PJUuwO6d+/e7DsAAGh+ixYtKhpAas/jzU2AWo/ay3YpPAlQAFBeWqr7jU7kAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZjEQOAO3IqppSTJ21IOYtXhbbdOsSQ3bpGR2qW2a07komQAFAOzFxxjtxyf97Md5ZuKxu2XY9usTYLw6IkXtu16rbVm5cwgOAdhKevvPL6Q3CUzJ34bJieVpP0wlQANAOLtullqdSI+tql6X1qRxNI0ABQIVLfZ5Wb3mqL8WmtD6Vo2kEKACocKnDeHOWQ4ACgIqX7rZrznIIUABQ8dJQBeluu7UNVpCWp/WpHE3jEh4AVLg0zlMaqiBZPUTVzqf1xoNqOgEKANqBNM7TDd/cN3r3aHiZLs2n5caBymMgTQBoJ1JI+sKA3kYibwYCFAC0I+ky3bBPbNXam1H2XMIDAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACASg9Q48ePj5133jm6dOkSQ4cOjalTp6617M033xwHHnhgbLnllsU0fPjwdZYHAKi4AHXnnXfGueeeG2PHjo3p06fHPvvsEyNGjIh58+Y1Wv6JJ56IY445Jh5//PGYPHly9O3bNw499NB46623Nvq2AwCVo6pUKpWiTKQWp/333z+uv/76Yr6mpqYIRWeeeWaMHj16vY9ftWpV0RKVHn/88cc3Wmb58uXFVGvRokXFv7Fw4cLo3r17M9YGAGgp6fzdo0ePFjt/l00L1IcffhjTpk0rLsPVqq6uLuZT61JTLF26NFasWBE9e/Zca5lx48YVL3jtlMITAEBZBqj58+cXLUjbbrttg+Vpfu7cuU16jvPPPz/69OnTIIStbsyYMUVarZ3mzJnzsbcdAKgsHaOduOyyy2LChAlFv6jUAX1tOnfuXEwAAGUfoLbeeuvo0KFDvPvuuw2Wp/nevXuv87FXXXVVEaAeeeSR2HvvvVt4SwGASlc2l/A22WST2G+//eLRRx+tW5Y6kaf5YcOGrfVxV1xxRVx66aUxceLEGDx48EbaWgCgkpVNC1SShjA44YQTiiA0ZMiQuPbaa2PJkiVx0kknFevTnXXbb7990RE8ufzyy+Oiiy6KX/3qV8XYUbV9pTbffPNiAgCo+AB19NFHx1//+tciFKUwNHDgwKJlqbZj+ezZs4s782rdcMMNxd17X/va1xo8TxpH6uKLL97o2w8AVIayGgeqEseRAACan3GgAADamLLpRA4A0FYIUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAyCRAAQBkEqAAAAQoAICWpQUKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAUOkBavz48bHzzjtHly5dYujQoTF16tS1lp05c2YcddRRRfmqqqq49tprN+q2AgCVqawC1J133hnnnntujB07NqZPnx777LNPjBgxIubNm9do+aVLl0a/fv3isssui969e2/07QUAKlNZBairr746TjnllDjppJNiwIABceONN8amm24at956a6Pl999//7jyyitj1KhR0blz542+vQBAZSqbAPXhhx/GtGnTYvjw4XXLqquri/nJkyc327+zfPnyWLRoUYMJAKAsA9T8+fNj1apVse222zZYnubnzp3bbP/OuHHjokePHnVT3759m+25AYDKUDYBamMZM2ZMLFy4sG6aM2dOa28SANDGdIwysfXWW0eHDh3i3XffbbA8zTdnB/HUV0p/KQCgIlqgNtlkk9hvv/3i0UcfrVtWU1NTzA8bNqxVtw0AaF/KpgUqSUMYnHDCCTF48OAYMmRIMa7TkiVLirvykuOPPz623377oh9TbcfzF198se73t956K5577rnYfPPNo3///q1aFwCgfJVVgDr66KPjr3/9a1x00UVFx/GBAwfGxIkT6zqWz549u7gzr9bbb78dgwYNqpu/6qqriumggw6KJ554olXqAACUv6pSqVRq7Y1oy9IwBuluvNShvHv37q29OQBAGzh/l00fKACAtkKAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAAACFABAy9ICBQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATB1jA3z1q1+NqqqqNZanZV26dIn+/fvHscceG7vtttuGPD0AQOW1QPXo0SMee+yxmD59ehGa0vTss88Wy1auXBl33nln7LPPPjFp0qTm32IAgHJsgerdu3fRwnT99ddHdfVHGaympibOPvvs6NatW0yYMCG+/e1vx/nnnx9PPfVUc28zAECrqiqVSqXcB/Xq1atoXfrkJz/ZYPmf//znOOCAA2L+/PnxwgsvxIEHHhjvvfdelLNFixYVLW4LFy6M7t27t/bmAABt4Py9QZfw0mW6l19+eY3ladmqVauK31NfqMb6SQEAtMtLeN/61rfi5JNPjgsuuCD233//YtnTTz8dP/nJT+L4448v5v/zP/8zPvWpTzXv1gIAlGuAuuaaa2LbbbeNK664It59991iWZo/55xzin5PyaGHHhojR45s3q0FACjXPlCrX2NMKrV/kD5QAFB+FrVwH6gNaoGqr1KDU4uqWRXx33+IeP/diE23TgNoRSz5a8Tm20bsdECsiuqYOmtBzFu8LLbp1iWG7NIzOlTrTwZAGz2Xbf7R+SuqO6x3/aqaUvzx9b/FH1+dFzssejYGbrk8+n+if3TY+f9r+Pg2boMD1D333BN33XVXzJ49Oz788MMG69L4UC1l/PjxceWVV8bcuXOLsaauu+66GDJkyFrL33333XHhhRfGG2+8Ebvuumtcfvnlcfjhh0erefG+iInnRyx6u9HVH3TtHZesOD4mvD+wbtl2PbrE2C8OiJF7brcRNxQAMs5l3ftEjLw8YsCX1rr+2U+NjpOmbBdDl02KsZ3+b/SpWvDRukkfnf+6fvHKjx5fBjboLryf/exncdJJJxX9ntIAminAbLXVVvH666/HYYcdFi0lDdB57rnnxtixY4uQlgLUiBEjYt68eY2W/8Mf/hDHHHNM0eE9bedXvvKVYpoxY0a0inRA3XX8WsNT0nnp3PjJiitiRPXUumVzFy6L7/xyekyc8c5G2lAAyDyXLXrno+UPXdjo+tKid2KfP5wV317+i7ih07XRO/4nPNU7/5XS49LzV2ofqN13370IMSmcpIEz//SnP0W/fv3ioosuigULFhQDbLaEoUOHFnf91T5/Gryzb9++ceaZZ8bo0aPXKH/00UfHkiVL4v77769b9ulPfzoGDhwYN95448a9hpqaMq/dc53hqa5oKWJubBWfWf6vUfM/GTddwOvdo0s8df7nXc4DoHWs91xW9VG3lFJN4w8vRdREVVRHKRrrmZIeVdV9+6j6pxc+9uW8NjkOVLpslwbMTLp27RqLFy+uG97g17/+dbSEdJlw2rRpMXz48LplaRT0ND958uRGH5OW1y+fpBartZVPli9fXrzo9admka4DNyE8Jemg6lP1txhS/b9jbaWU+87CZUXfKABoFes9l5XWGp5qz28dqxoPT8X6FKAWvfXRv9PGVW/oV7mklqZkxx13jD/+8Y/F77NmzYqPeVPfWqXRzdMgnemyYX1pPvWHakxanlM+GTduXJFYa6fUwtUsUie6TNvEmqO4p47lANAqNuBc1qb/nY0doD7/+c/Hffd9dI0y9YVK4z994QtfKC6ZffWrX41yNmbMmKK5r3aaM2dO8zxxugMh07zYYo1l6a48AGgVG3Aua9P/zsa+C+/nP/950f8oOf3004sO5KnD9pe+9KU47bTToiVsvfXW0aFDh7qBO2ul+dQi1pi0PKd80rlz52Jqdun2zXSHQupkV1yQW38fqKk1u9ctq+0DlYY0AIBWsd5zWVXz9IFK/04ltkClvkcdO/5v9ho1alRxZ17qzL3JJptES0jPu99++8Wjjz5atyyFuDQ/bNiwRh+Tltcvnzz88MNrLd+iUme4dHtnYe1jOqWDK7lkxbcadCBP0lAGxoMCoNWs81xW9dGPYWf8z+8N15f+Z/7/rDyiwfmuVpqvSv+NvKwsxoPa4HGgli1bFs8//3wxhEBta1St1BLVEtIQBieccEIMHjy4GDrh2muvLe6yS5cRk/Q9fNtvv33Rjyk5++yz46CDDoqf/vSnccQRR8SECRPimWeeKVrQWkUa2+Ib/3ed40At3/SjcaAeXP6/40CllifjQAHQJqztXNY9jQN12Ufrd9h/jfVV3fvEc586P26csl08u6z/R+NA1RvKIJ3/ymkcqA0axmDixIlFWEkdu9d4wqqqorN3S0lDGNQOpJmGI0gtX2l4g+Tggw+OnXfeOW6//fYGA2n+6Ec/qhtIM31/X85Ami1yG6SRyAEodzVteyTylh7GYIMCVAoi6cuC07hPq9/lVml8Fx4AlJ9FbXEcqNQRO11Oq/TwBADQbAHqa1/7WjzxxBMb8lAAgLK3QZfwli5dGl//+tejV69esddee0WnTp0arD/rrLOiUriEBwDlZ1ELX8LboLvw0te1PPTQQ9GlS5eiJSp1HK+Vfq+kAAUA0CwB6oc//GFccsklxRf4pjGhAADak+oN/WLf9LUtwhMA0B5tUIBKg1neeeedzb81AACVegkvDZSZBqR88MEHY++9916jE/nVV1/dXNsHAFAZAeqFF16IQYMGFb/PmDGjubcJAKDyAtTjjz/e/FsCAFCJAerII49cb5k0jMG///u/f5xtAgConACVBqQCAGjvsgLUbbfd1nJbAgBQJoyCCQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQBQqQFqwYIFcdxxx0X37t1jiy22iJNPPjnef//9dT7m5z//eRx88MHFY6qqquK9997baNsLAFSusglQKTzNnDkzHn744bj//vvjySefjFNPPXWdj1m6dGmMHDkyLrjggo22nQBA5asqlUqlaONeeumlGDBgQDz99NMxePDgYtnEiRPj8MMPjzfffDP69Omzzsc/8cQT8bnPfS7+/ve/F61X67J8+fJiqrVo0aLo27dvLFy4sGjJAgDavnT+7tGjR4udv8uiBWry5MlF8KkNT8nw4cOjuro6pkyZ0qz/1rhx44oXvHZK4QkAoOwC1Ny5c2ObbbZpsKxjx47Rs2fPYl1zGjNmTJFWa6c5c+Y06/MDAOWvVQPU6NGji87d65pefvnljbpNnTt3Lpr66k8AAPV1jFZ03nnnxYknnrjOMv369YvevXvHvHnzGixfuXJlcWdeWgcA0G4CVK9evYppfYYNG1YMQTBt2rTYb7/9imWPPfZY1NTUxNChQzfClgIAlFkfqD322KMYjuCUU06JqVOnxqRJk+KMM86IUaNG1d2B99Zbb8Xuu+9erK+V+kc999xz8eqrrxbzL7zwQjGfWq4AACo6QCV33HFHEZAOOeSQYviCz3zmM8VAmbVWrFgRr7zySjH2U60bb7wxBg0aVASv5LOf/Wwxf99997VKHQCAylAW40BV8jgSAEDzMw4UAEAbUzaX8AAA2goBCgAgkwAFAJBJgAIAyCRAAQBkEqAAADIJUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAyCRAAQBkEqAAADIJUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAyCRAAQBkEqAAADIJUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAyCRAAQBkEqAAADIJUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAyCRAAQBkEqAAADIJUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAyCRAAQBkEqAAADIJUAAAmQQoAIBMAhQAQCYBCgAgkwAFAJBJgAIAqNQAtWDBgjjuuOOie/fuscUWW8TJJ58c77///jrLn3nmmbHbbrtF165dY8cdd4yzzjorFi5cuFG3GwCoPGUToFJ4mjlzZjz88MNx//33x5NPPhmnnnrqWsu//fbbxXTVVVfFjBkz4vbbb4+JEycWwQsA4OOoKpVKpWjjXnrppRgwYEA8/fTTMXjw4GJZCkOHH354vPnmm9GnT58mPc/dd98d3/zmN2PJkiXRsWPHRsssX768mGotWrQo+vbtW7RcpdYvAKDtS+fvHj16tNj5uyxaoCZPnlxctqsNT8nw4cOjuro6pkyZ0uTnqX0R1xaeknHjxhUveO2UwhMAQNkFqLlz58Y222zTYFkKQT179izWNcX8+fPj0ksvXedlv2TMmDFF0Kqd5syZ87G2HQCoPK0aoEaPHh1VVVXrnF5++eVmacY74ogjisuAF1988TrLdu7cuWilqj8BANS39mtZG8F5550XJ5544jrL9OvXL3r37h3z5s1rsHzlypXFnXZp3bosXrw4Ro4cGd26dYt77703OnXq1CzbDgC0X60aoHr16lVM6zNs2LB47733Ytq0abHffvsVyx577LGoqamJoUOHrrPlacSIEUWr0n333RddunRp1u0HANqnsugDtcceexStSKecckpMnTo1Jk2aFGeccUaMGjWq7g68t956K3bfffdifW14OvTQQ4s77m655ZZiPvWXStOqVatauUYAQDlr1RaoHHfccUcRmg455JDi7rujjjoqfvazn9WtX7FiRbzyyiuxdOnSYn769Ol1d+j179+/wXPNmjUrdt55541cAwCgUpTFOFCVPI4EAND8jAMFANDGlEUfKACAtkSAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKACCTAAUAkEmAAgDI1DH3AQBA+VpVU4qpsxbEvMXLYptuXWLILj2jQ3VVa29W2RGgAKCdmDjjnbjk/70Y7yxcVrdsux5dYuwXB8TIPbdr1W0rNy7hAUA7CU/f+eX0BuEpmbtwWbE8rafpBCgAaAeX7VLLU6mRdbXL0vpUjqYRoACgwqU+T6u3PNWXYlNan8rRNAIUAFS41GG8OcshQAFAxUt32zVnOQQoAKh4aaiCdLfd2gYrSMvT+lSOpnEJDwAqXBrnKQ1VkKweomrn03rjQTWdAAUA7UAa5+mGb+4bvXs0vEyX5tNy40DlMZAmALQTKSR9YUBvI5E3AwEKANqRdJlu2Ce2au3NKHsu4QEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEAZDIS+XqUSqXi56JFi3JfWwCgldSet2vP481NgFqPxYsXFz/79u3bIjsAAGjZ83iPHj2a/XmrSi0VzSpETU1NvP3229GtW7diJ6QgNWfOnOjevXu0lwTf3urcXuvdHuvcXuvdHuvcXuvdnus8e/bsqKqqij59+kR1dfP3WNICtR7pRd9hhx2K39OOSNJB2F4OxFrtsc7ttd7tsc7ttd7tsc7ttd7tsc49evRo0TrrRA4AkEmAAgDIJEBl6Ny5c4wdO7b42V60xzq313q3xzq313q3xzq313qrc8vRiRwAIJMWKACATAIUAEAmAQoAIJMABQCQSYCq51/+5V/igAMOiE033TS22GKLJr2AaSD3iy66KLbbbrvo2rVrDB8+PP7yl780KLNgwYI47rjjigG90vOefPLJ8f7770dbkbt9b7zxRjGoaGPT3XffXVeusfUTJkyItmBD9snBBx+8Rn2+/e1vNyiTRr494ogjimNom222ie9///uxcuXKaCty653Kn3nmmbHbbrsVx/eOO+4YZ511VixcuLBBuba0r8ePHx8777xzdOnSJYYOHRpTp05dZ/l0zO6+++5F+b322iseeOCB7Pd4W5BT75tvvjkOPPDA2HLLLYsp1Wn18ieeeOIa+3TkyJFRrnW+/fbb16hPelyl7+vGPrfSlD6nymVfP/nkk/HFL36xGFE8bdtvf/vb9T7miSeeiH333be4C7F///7F/v+4nxVrSF/lwkcuuuii0tVXX10699xzSz169GjSy3LZZZcVZX/729+W/vSnP5W+9KUvlXbZZZfSBx98UFdm5MiRpX322af0xz/+sfRf//Vfpf79+5eOOeaYNvOy527fypUrS++8806D6ZJLLiltvvnmpcWLF9eVS4fXbbfd1qBc/delNW3IPjnooINKp5xySoP6LFy4sMHrsueee5aGDx9eevbZZ0sPPPBAaeutty6NGTOm1Fbk1vuFF14oHXnkkaX77ruv9Oqrr5YeffTR0q677lo66qijGpRrK/t6woQJpU022aR06623lmbOnFnsry222KL07rvvNlp+0qRJpQ4dOpSuuOKK0osvvlj60Y9+VOrUqVNR75z3eGvLrfexxx5bGj9+fHGcvvTSS6UTTzyxqOObb75ZV+aEE04ojpf6+3TBggWlcq1zOj67d+/eoD5z585tUKYS9/Xf/va3BnWeMWNGccyn16Nc9vUDDzxQ+uEPf1j6zW9+U3zW3Hvvvess//rrr5c23XTT4lye3tfXXXddUeeJEydu8OvYGAGqEenAakqAqqmpKfXu3bt05ZVX1i177733Sp07dy79+te/LubTzks7/Omnn64r8/vf/75UVVVVeuutt0qtrbm2b+DAgaV//Md/bLCsKQd6OdU5Baizzz57nW/y6urqBh/KN9xwQ/GhvXz58lKl7Ou77rqr+OBZsWJFm9vXQ4YMKZ1++ul186tWrSr16dOnNG7cuEbLf+Mb3ygdccQRDZYNHTq0dNpppzX5Pd4W5NZ7dSn8d+vWrfSLX/yiwUn1y1/+cqmtyq3z+j7X28u+vuaaa4p9/f7775fNvq6vKZ81P/jBD0qf+tSnGiw7+uijSyNGjGi21zFxCe9jmDVrVsydO7do5q3/3TupKXDy5MnFfPqZLpUMHjy4rkwqn75jb8qUKdHammP7pk2bFs8991xxOWh1p59+emy99dYxZMiQuPXWW4sm8nKu8x133FHUZ88994wxY8bE0qVLGzxvugS07bbb1i0bMWJE8cWWM2fOjNbWXMdiunyXLgF27NixTe3rDz/8sDgW678fU93SfO37cXVpef3ytfustnxT3uOtbUPqvbp0HK9YsSJ69uy5xmWQdCk6XcL9zne+E3/729+inOucLlfvtNNOxRfNfvnLX27wvmwv+/qWW26JUaNGxWabbVYW+3pDrO993RyvY+LLhD+G9GZL6p8wa+dr16Wf6aBs8KJ37Fh8UNWWaU3NsX3pDbnHHnsU/cfq+/GPfxyf//zni/5ADz30UHz3u98tPsBSH5pyrPOxxx5bfPim6/DPP/98nH/++fHKK6/Eb37zm7rnbexYqF1XCft6/vz5cemll8app57a5vZ12rZVq1Y1ug9efvnlRh+ztn1W//1bu2xtZVrbhtR7delYTsd1/RNK6gNz5JFHxi677BKvvfZaXHDBBXHYYYcVJ5gOHTpEudU5BYMU7Pfee+/ij4Crrrqq+MxKISp9YXx72Nepj8+MGTOKz+z62vK+3hBre1+nP2Y/+OCD+Pvf//6x3zPtIkCNHj06Lr/88nWWeemll4pOpO2x3h9XOhh/9atfxYUXXrjGuvrLBg0aFEuWLIkrr7yyxU6qLV3n+qEhtTSljqaHHHJI8YHziU98Iip9X6cPn9TxdMCAAXHxxRe36r6m+Vx22WVFh//UAlG/U3Vqpah/vKfgkY7zVC4d9+Vm2LBhxVQrhaf0h99NN91U/FHQHqTglPZlaiWur9L29cZS8QHqvPPOK+4wWJd+/fpt0HP37t27+Pnuu+8WJ9NaaX7gwIF1ZebNm9fgcemurHR3U+3jW7PeH3f77rnnnqL5//jjj19v2dQUnj6oli9f3iLfRbWx6ly/Psmrr75afNikx65+F0c6FpJy39eLFy8u/krt1q1b3HvvvdGpU6dW3deNSZcP01/Lta95rTS/tvql5esq35T3eGvbkHrXSq0wKUA98sgjxUlzfcdQ+rfS8d7aJ9WPU+da6RhOYT/Vpz3s6/RHTQrKqbV4fdrSvt4Qa3tfp64H6e7K9Bp+3OOn0OTeUu1Ibifyq666qm5ZuiursU7kzzzzTF2ZBx98sM11It/Q7Usdq1e/I2tt/vmf/7m05ZZbllpbc+2Tp556qniedLdO/U7k9e/iuOmmm4pO5MuWLSuVa73TMf3pT3+62NdLlixp0/s6dQw944wzGnQM3X777dfZifwf/uEfGiwbNmzYGp3I1/Uebwty651cfvnlxbE5efLkJv0bc+bMKY6V//iP/yiVa51X7zi/2267lc4555yK39e157VUl/nz55fdvt6QTuTpjuj60t3Gq3ci/zjHT7EtTS7ZDvz3f/93cVtv7S356fc01b81P73h0q2U9W97Tbc+pgPt+eefL+5kaGwYg0GDBpWmTJlSnHTTbeBtbRiDdW1furU51Tutr+8vf/lL8SZLd3KtLt32fvPNNxe3g6dy//Zv/1bcVpqGiijHOqdb+H/84x8X4WPWrFnF/u7Xr1/ps5/97BrDGBx66KGl5557rrhltlevXm1uGIOceqcTSLorba+99ipeg/q3Oaf6trV9nW5NTieJ22+/vQiMp556avH+rL0z8lvf+lZp9OjRDYYx6NixY3HSTLfzjx07ttFhDNb3Hm9tufVOdUp3Ut5zzz0N9mntZ136+b3vfa8IV+l4f+SRR0r77rtvcby0hT8GNqTO6XM9/cHw2muvlaZNm1YaNWpUqUuXLsUt7JW8r2t95jOfKe5EW1057OvFixfXnY9TgErDDaXf0zk7SfVN9V59GIPvf//7xfs6DdnR2DAG63odm0KAqifdypl2zurT448/vsZ4N7XSXy0XXnhhadttty12xiGHHFJ65ZVX1hiHI52kUihLf/GddNJJDUJZa1vf9qU31eqvQ5KCQd++fYvkvroUqtLQBuk5N9tss2LsoRtvvLHRsuVQ59mzZxdhqWfPnsV+TuMnpTdn/XGgkjfeeKN02GGHlbp27VqMAXXeeec1uN2/3Oqdfjb2nkhTKtsW93Ua82XHHXcsAkL6KzONeVUrtaKl9/nqwzJ88pOfLMqnW59/97vfNVjflPd4W5BT75122qnRfZoCZLJ06dLiD4H0B0AKlKl8Gicn5+TS1ur8T//0T3Vl0748/PDDS9OnT6/4fZ28/PLLxf596KGH1niuctjXj6/lc6i2nulnqvfqj0mfS+k1Sn/s1j9vN+V1bIqq9L8NusgIANBOGQcKACCTAAUAkEmAAgDIJEABAGQSoAAAMglQAACZBCgAgEwCFABAJgEKoInSlzZ/5Stf8XoBAhRQOeGmqqqqmDp16hS77LJL/OAHP4hly5a19qYBFahja28AQHMZOXJk3HbbbbFixYqYNm1anHDCCUWguvzyy73IQLNyCQ+oGJ07d47evXtH3759i0ttw4cPj4cffrhYV1NTE+PGjStaprp27Rr77LNP3HPPPXWPXbVqVZx88sl163fbbbf413/911asDdCWaYECKtKMGTPiD3/4Q+y0007FfApPv/zlL+PGG2+MXXfdNZ588sn45je/Gb169YqDDjqoCFg77LBD3H333bHVVlsVjz311FNju+22i2984xutXR2gjRGggIpx//33x+abbx4rV66M5cuXR3V1dVx//fXF7z/5yU/ikUceiWHDhhVl+/XrF0899VTcdNNNRYBK/aYuueSSuudKLVGTJ0+Ou+66S4AC1iBAARXjc5/7XNxwww2xZMmSuOaaa6Jjx45x1FFHxcyZM2Pp0qXxhS98oUH5Dz/8MAYNGlQ3P378+Lj11ltj9uzZ8cEHHxTrBw4c2Ao1Ado6AQqoGJtttln079+/+D0FodTP6ZZbbok999yzWPa73/0utt9++zX6TSUTJkyI733ve/HTn/60aKXq1q1bXHnllTFlypRWqAnQ1glQQEVKl+8uuOCCOPfcc+PPf/5zEZRSy1K6XNeYSZMmxQEHHBDf/e5365a99tprG3GLgXLiLjygYn3961+PDh06FP2cUuvSOeecE7/4xS+KYDR9+vS47rrrivkkdSx/5pln4sEHHywC14UXXhhPP/10a1cBaKO0QAEVK/WBOuOMM+KKK66IWbNmFXfcpbvxXn/99dhiiy1i3333LVqpktNOOy2effbZOProo4uxo4455piiNer3v/99a1cDaIOqSqVSqbU3AgCgnLiEBwCQSYACAMgkQAEAZBKgAAAyCVAAAJkEKACATAIUAEAmAQoAIJMABQCQSYACAMgkQAEARJ7/H1jKpNzSXQZXAAAAAElFTkSuQmCC", + "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, 886.93it/s]\n", + "Caching compare objects X: 100%|██████████| 2/2 [00:00<00:00, 36314.32it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 1.04it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity with custom config: 0.8777\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.4925\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, 1.14it/s]\n", + "Fitting DMDs: 1it [00:00, 1.44it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 2444.23it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 1003.18it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 51.11it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity with PyKoopman: 0.6496\n", + "(8, 100, 5)\n", + "(10, 10)\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=10)\n", + "\n", + "# Create configuration\n", + "from dataclasses import dataclass\n", + "\n", + "@dataclass\n", + "class CustomPyKoopmanConfig:\n", + " observables: object = observables\n", + " regressor: object = 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, 1315.86it/s]\n", + "Caching compare objects X: 100%|██████████| 2/2 [00:00<00:00, 43464.29it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 708.38it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "InputDSA similarity: 2.6830\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, 192.02it/s]\n", + "Caching compare objects X: 100%|██████████| 2/2 [00:00<00:00, 58661.59it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 3258.98it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SubspaceDMDc similarity: 0.5317\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", + " ),\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": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/DSA/dsa.py:412: 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.0131\n", + "state similarity: 0.3778\n", + "joint similarity: 1.8671\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAF2CAYAAAB9KhCBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN11JREFUeJzt3Qm8jPX////XsRxLOOiESJSPSLYQqdAiREWrtJDEt120UXHa0SKFIkWbokWplJYTpWiztapUJ/Kxlp3Osczv9nz//9d8ZubMYeasczmP++02zpnrXHPNNddcl3nN63q9X1dSIBAIGAAAAOBDJYp6BQAAAIDcIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBYAi9Oyzz1pSUpJlZGT4+n3Ytm2bXXnllVajRg33em688cZ8Xb6Wedddd4VN+/rrr+2EE06wgw46yP19yZIlbvrs2bOtefPmVrZsWTd906ZN+bouxVG07Q8kCoJZYD9BxjfffJMQ22jHjh3uw2Tu3LnZ/qbpWlfvVr58eTv88MPtrLPOsilTplhmZmbUZb799tvWoUMHq1atmnvMkUceaRdeeKELBqLZs2eP1axZ0z3He++9l2+v7Y033rAzzjjDUlNTLTk52T2H1uPjjz/Ot+dAwXrggQfcMXP11VfbCy+8YJdddlmO89atWze4r5YoUcIqV65sTZo0sQEDBtiXX34Z0/Pt2rXLLrjgAvvnn3/s0Ucfdc9Zp04d+/vvv92+U65cORs/frybrmA3Ef33v/91x64XhMf6f5Jun332Wba/6+r0tWvXdn8/88wzC2CNgcRUqqhXAEDswezdd9/tfj/55JOjzvPkk09ahQoVXPC6atUqe//99+2KK66wMWPG2DvvvOM+6DwPP/yw3XLLLS6YHTp0qAtmly9fbh999JFNmzbNunTpkm35Ci5Xr17tgpGpU6e6ADQv9OGr9dOH9LHHHmuDBw92mT09hwLc0047zT7//HOXfTtQKei76KKLrEyZMuZn2jeOP/54S0tLi2l+ZU5vuukm9/vWrVvtp59+sldffdUmTZpkgwYNstGjR4fNv3PnTitV6n8fWb/99pv9+eefbn5lhD36Iqbl3XvvvdaxY0dLZApmdUzreNL2iJUyzi+99JKddNJJYdM/+eQT++uvv3y/LwHxIpgFDiDnn3++y256hg8f7oLO3r17uyzWF1984abv3r3bfdiffvrp9sEHH2Rbzrp166Iu/8UXX7QWLVpYnz597Pbbb7ft27fnKev1yCOPuEBWp6QVvCij5LnjjjtcVi00gDmQeNuuZMmS7uZ32mcaNWoU8/y1atWySy+9NGzaqFGj7OKLL3aZ1vr167ssb2gAF/l8oqxuLNPzIq/7eX7r2rWrC/wff/zxsONDAW7Lli1tw4YNRbp+QKELAIhqypQpAR0iX3/9dXBanz59AgcddFDgr7/+CnTv3t39npqaGrjpppsCu3fvDs73xx9/uMc+9NBDgdGjRwcOP/zwQNmyZQPt27cPfPfdd2HP06FDB3eLpOeqU6dO2PIib2lpae7v+qn769evj/paBgwY4P7+wQcfuPurV6929++6666Y3/0dO3YEKlasGHjwwQfd40uUKBGYOnVqtvk2bdoU+Omnn9zP/S2vatWqgYYNG4Ztu3357bffAueff36gSpUqgXLlygXatGkTeOedd8LmmTNnjntt06dPd6+vZs2agQoVKgTOO+88t07//vtvYODAgYFDDjnEvX+XX365mxZKj7/22msDL774YuCoo44KlClTJtCiRYvAJ598EjZfRkZG4Oqrr3bz6P3V69H66f2Kti/NnTvXza/nrly5ctjfQh+jfa5Tp06Bgw8+2C23bt26gb59+4Ytc9u2bYHBgwcHDjvssEBycrJbB+1ve/fujfpa3njjjcAxxxzj5m3UqFHgvffei2mbr127NnDFFVcEqlWr5rZD06ZNA88++2y27R15i9wGobRfd+vWLerftm7d6rZjrVq1wl5L6P6uYyPy+bzjKHK65vV88cUXgc6dOwcqVark9h8dj5999lnY83vH0g8//BDo1auXe5+aN28e/PsLL7zg9gW9L9oPe/bsGVixYkXYMrQe2tZaxsknn+yeS/vhqFGj9rvdtD/kxNtXXn311UBSUlLg3XffDf4tMzPTrc8jjzwSdfvGur/oWLjxxhvd/2s6bs4666zAypUrw7a/R/8Par/UvuHtV88880y29X788cfd37QdtD1btmwZ9f8OILcOzJQHUIBUN9q5c2dr06aNO1Wv0/LKMNarVy8skyTPP/+8O+V57bXX2r///muPPfaYnXrqqfbdd99Z9erVY37OQw45xJUQaPnnnHOOnXvuuW5606ZNYz6V/dRTT7ksrLKxqpFVTaFqZq+//nqrWrXqfpfx1ltvuUE+OiWuUgCVOijrq0xaKJUH9O3b19XqXn755TkuTzV/qndUVjaWzOTatWtduYHKLW644QY7+OCD7bnnnrOzzz7bXnvtNbddQo0YMcK9xiFDhrjyibFjx1rp0qVdjebGjRtdraIy1coMH3HEES6LHXnKdvr06e65dNr2iSeecKUXX331lTVu3Dg4AGn+/Plumxx22GFuEJfeJ22bH3/80ZVuhLrmmmvce6nnUrYvGmUWO3Xq5ObTuivDqOXOmDEjOI9iO73uOXPmWL9+/dwpapWUqGxE5SXKbEZuaz1ez1+xYkWX0TvvvPNsxYoVbjvmRKf29Vq0/a677jq3nZQR1PuqQVUDBw60o48+2mXQVRqgbeCVDmj9c0NlMnovn3nmGbcNjznmmGzz/N///Z/L7KpOV+/PcccdFzyeGjRo4Pb1e+65x62vjkuvDEJlMcpcqhRC+4H2UR2P8+bNs9atW4c9h85kKDus5/j/Ymmz+++/34YNG+ZqclXasH79erdftW/f3hYvXhyWDdY+pv1Fx6rm1z562223udpgrYe2m9ZR+4Jqhdu1a+ceF0tJjcoS2rZtay+//HKw1Ec17Js3b3b7ot7fUPHsL3pdOgOj41rrou3WrVu3qMejykp0NkX7ht5vrYOWv2XLluAAQJWB6D3SWSPtL/p/8Ntvv3W10ZH/dwC5luswGCimmVlNu+eee8LmPfbYY122weNlUpWJUPbC8+WXX7rpgwYNiiszK8q6RsuOxJKZ3bhxo/v7OeecE5w2fPhwN03ZyTPOOCNw//33BxYuXJjj9jjzzDMDJ554YvD+U089FShVqlRg3bp1UbfbvjJM8thjj7n5lDGMhbJFmn/evHlhWbwjjjjCZS737NkTlvFq3LhxICsrKzivsmzKZum1hmrbtm3YdhYvS/bNN98Ep/35558uGxe6DZVdjrRgwQL32Oeffz7bNjnppJOyZaEjM7PaHpH7XaQ333zTzXPfffeFTVdWWK9x+fLlYa9FWbPQaUuXLnXTx44dG9iXMWPGuPmUofZom2qbKWu3ZcuWmLKtkfY376OPPuqed+bMmWGvI3Tf995nZSn3d9wq+1i/fn2XlQ3NROr90/5z+umnZzuWtL9EZuFLlizpjpNQOtOi4yB0upchDt0HlDmtUaOGO0Pg0TrGcqxEe23jxo1zZ0q8ffCCCy4InHLKKVG3b6z7y5IlS9x811xzTdh8F198cbbt369fv8Chhx4a2LBhQ9i8F110USAlJSW4XjqDpSw1UJDoZgDkwlVXXRV2X1mV33//Pdt8PXr0cBkkj7I/yui+++67hbrdle0SZYk9GniiGjsNvFKWRjWqylqpJlaDcUJphLjm6dWrV3CaMnvKyrzyyith8yprp9hjX1lZUfZGlCmMhbaZtl/ooBe9LmW1lLlUFi+U6oSVifVou3sDzkJp+sqVK10dcShlvrQ9POoO0b17d7cdlJ0XZX5DR9drO/3nP/9xGbpFixZlew39+/ffbxbay+5pwJ6WmdO20HKU8QqlrKheY2SnCQ2E8jKUXka/UqVKUffZyOdRFj70fdc21fMqS6/sdWHtr3mhbgG//vqrywTqPVJNqW7KjmuQ4aeffmp79+7d5zGuzLbmUZbVe7xu2j7K4CrrGfkaQmuC1aVD++/+tnmstB7KnGs/0XbSz5wynbHuL97/S5HzRbZZ02Nef/111y1Fv4duD521UobY2/+1P2tQms5iAAWFYBaIkwaiRJ5CrVKlijutGEkfcpGOOuqoQu8pqsAjWuCoIEWnWLXuKkHQh6FOl+pDSqcDPTrdrsBKga9OOeumEgEFgio1yA0FU/EELBq5rlPIkXS61vt7KAWfoVJSUtzP0I4O3nQFKfoAjuW9U5mDTi+LggmdJtYyVYqgwXfaN3QKPnJ5otPe+6PuEvqioC8bWp4C6Mj2anqtal8W+X7Gui32tc+G0nK0HXRKPpbnKej9NbcUyIoGLur9Cb09/fTTbttGvl+R75WWocBN2yNyGfryFzloUiUXoQMaY93msdLz6kuKvpAq0NYXLJ3KjybW/UU/9V6HfvGRyONO+7/2cZVzRG4LlRiJtz1UWqHAXoG8tp1KrtShBMhP1MwCccrvkef6wPNq8kJ52b/88P3337ufyhrmFFiqllY3Zd5Ui6qaNgVW4gWsJ554YtTHK9ukHrXxaNiwofup+mFlsAvrfcpperT3YH9Ub6xAU5krZXIVGOv9VN1iZKYvMpObEz1e9ZWq51VNs9deTXXZmuZlLeORn6+5MOxvf42X91489NBDObbAityuke+VluH1V462PSMfXxjbXF8+le1fs2aNq53Nzw4OsWxPZZ71BSEar55fAfPPP//sMsdqm6aMrurP9SXQazUI5BXBLFCAvIxQqF9++cUN4AjN1kQ79RiZ9YrM8sRDA3REpwD3p1WrVi6YVa9X+eOPP9wgJw3y8ILb0A81DS5TdujOO++Ma51ULqDXrkEsavO1vy8JaoivD8VIy5YtC/69MN47DeryMvMKOvVhrkDTo4x2flxxSoNrdNOgI23fSy65xPX/1QAdvVYNPFRWOzTblt/bQsvRYB29z6HZ2YLa5l5WVoMIle32Mod55WUa9aUtt71ntQwFosrYKkOfH/JyTIsGymkwnL7k6OxJTmLdX/RT77V6+IZmYyOPO+3/Wo6+cMeyPdXWrGfPnu6WlZXlBsVpv1Z/68iWa0BuUGYAFKA333zTjRb2aCS8Mp6hFxvQh6Q+VLxT17J06dJsp+K8kfHxBkoKhHQqVZlD1QeKTpUvWLAg6vxe/Zz3YeZlZW+99VZ3GjP0pro9BbihpQY6XavXE+00e+Tr0SlInaLVz2gZK42q1jbzemvq99D1Vs2jTnXqy0E8PU5joecJrXtVXe3MmTNdpwEv8NbPyPXW6Pa8ZNV1GjpymV420Ss10LbQc4wbNy5sPo1KV4CU14tZePQ8yvqFBkqqLdZrVCYy8stNXqlsQ1+OVMKiGu68Bnse1T7rOFP3Ea+EIVTosZcTBWB6v5VNjHx/dF+1uPHyetfm9suP3gN1z1BnDpUG5STW/cX7GdkNQRddCaXtoFIYZVm9LHpO2zNyu6h2WMeqtllONeFAvMjMAgVIp0mVgVRLLQUi+lBQKyQFhh6dQtYFA5Q1VVsb1ZpNmDDBtSTyBkl5pz31IaDAQpkhtdNSiyivTZSXKdQHnLIf3hXAFBQ3a9bMtVTyKJhV2x1l/tQ+SFkwfaAq+FYNrU77qz5WFKgqmIqsNfWo5Y9Otyvw0+CxWFtziVoD/fDDDy6zqQE0CpA1oEYBlNZFwauywqI2VV4rIg1Q0etXBlmZY32oRtZ15pW2q96T0NZcEnpqVJcMVdZb5QV6bxQAKwO2r3ZX+6PXpOdS1k0BmLJpam+krKKCElHgcsopp7iAT/XXen9V86xgWyUPkTWPuaXBdRMnTnTv48KFC92XBu1j2qe0L+elplX7p76siAJMDeDTPqr3XgOTlHHML9o39IVO+46OK+2fGpipddB+p22rko590Ta97777XDZR21zHiF6/9j/t89pWN998c1zrpWWqNEDHu5al4FZ16LHUVntyOs0fKtb9Rce56ui1/+nLqP6PSE9PdzXykUaOHOm2ndZXpQ7a//UlRP8P6BjQ76IvfzqmVaKk9mn68qqgWu2+8qsmGqA1F5CLiyZE8tr5RLtogpqY165d2zWcb9eunWuLFEmtj4488kjXQkkN2t9///1srblk/vz5rgWY5ot20QTvphZSao6udlqTJ0/OdlGAXbt2BSZNmhTo0aOHew6tW/ny5V2LMa2z2giJWnVpecOGDctxP1HLotB2Y7G25gr12muvuYsEqFm+2hyp5Y+a0esiA9EumqDG63qNrVu3zvGiCbG0bMqprVnoRRPU0knbR9tGy45seaam8V6DebV+WrZsmdumoc36c3ruaK25Fi1a5NpC6UIbel41pNf7GNomzGtLpm2uZvylS5d267mviyZEilzHfV00wXuN2u+aNGkS9b2NtzWXt6+qNZQuYqD2Tf3793ft66LJS2suz+LFiwPnnnuuuxiFtq3W48ILLwykp6fH3Obu9ddfdy3W9P+Abrroh7bvzz//nO2iCZGiHdNqP6YLCmi/j/WiCftq25bTexHr/rJz587ADTfc4LaRXt++LpqgfUOvXf+/aZlqPXbaaae5tn2eiRMnuotTeNu8Xr16gVtuuSWwefPmfb4GIB5J+oeYHshfyn4ou6IBJ/Fma1D0dOpVo64jT8sCABIPNbMAAADwLYJZAAAA+BbBLAAAAHyrSINZXUJQoyx1ZRLVqGn08v7MnTvXjZjW6GKNFH/22WcLZV2BeGjUt8rRqZf1J7131MsCgD8UaTCrHpFqETJ+/PiY5lcLFLXzUIsRXWtbLUXUQFzthwAAAFD8JEw3A2Vm1atvX5e1VGP1WbNmhTVp1mUj1R9Tl8kDAABA8eKriyaoIXnkpfPU1FwZ2pyoUb131RzRpfrUzFlNzfPr6jIAAADIP8q16qIxKkXd30VxfBXM6sowuoJIKN3XVZJ0GURdISnSiBEjwq7YAwAAAH/QpcQPO+ywAyeYzQ1denDw4MHB+7pE3+GHH+42ji5hCACAHzROY3wIitb3d3cutOdSolKXUY/lsse+CmZ1fee1a9eGTdN9BaXRsrKirge6RdJjCGYBAH5Rokz5ol4FFHOViiAJGEtJqK/6zLZt29bS09PDpn344YduOgAAAIqfIg1mt23b5lps6ea13tLvK1asCJYI9O7dOzj/VVddZb///rvdeuuttmzZMnviiSfslVdesUGDBhXZawAAAEAxDWa/+eYbO/bYY91NVNuq34cPH+7ur169OhjYyhFHHOFacykbq/60jzzyiD399NOuowEAAACKn4TpM1uYBcUpKSluIBg1swAAv6g7ZFZRrwKKuYyR3RIyXvNVzSwAAAAQimAWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBQAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBQAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvlXkwez48eOtbt26VrZsWWvTpo199dVX+5x/zJgx1qBBAytXrpzVrl3bBg0aZP/++2+hrS8AAAASR5EGs9OnT7fBgwdbWlqaLVq0yJo1a2adO3e2devWRZ3/pZdesiFDhrj5f/rpJ3vmmWfcMm6//fZCX3cAAAAU82B29OjR1r9/f+vbt681atTIJkyYYOXLl7fJkydHnX/+/Pl24okn2sUXX+yyuZ06dbJevXrtN5sLAACAA1ORBbNZWVm2cOFC69ix4/9WpkQJd3/BggVRH3PCCSe4x3jB6++//27vvvuude3atdDWGwAAAImjVFE98YYNG2zPnj1WvXr1sOm6v2zZsqiPUUZWjzvppJMsEAjY7t277aqrrtpnmUFmZqa7ebZs2ZKPrwIAAADFegBYPObOnWsPPPCAPfHEE67GdsaMGTZr1iy79957c3zMiBEjLCUlJXjToDEAAAAcGIosM5uammolS5a0tWvXhk3X/Ro1akR9zLBhw+yyyy6zK6+80t1v0qSJbd++3QYMGGB33HGHK1OINHToUDfILDQzS0ALAABwYCiyzGxycrK1bNnS0tPTg9P27t3r7rdt2zbqY3bs2JEtYFVALCo7iKZMmTJWqVKlsBsAAAAODEWWmRVlTPv06WOtWrWy1q1bux6yyrSqu4H07t3batWq5UoF5KyzznIdEI499ljXk3b58uUuW6vpXlALAACA4qNIg9mePXva+vXrbfjw4bZmzRpr3ry5zZ49OzgobMWKFWGZ2DvvvNOSkpLcz1WrVtkhhxziAtn777+/CF8FAAAAikpSIKfz8wco1cxqINjmzZspOQAA+EbdIbOKehVQzGWM7JaQ8ZqvuhkAAAAAoQhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBQAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAbxHMAgAAoHgFs7t377aPPvrIJk6caFu3bnXT/vvf/9q2bdvye/0AAACAHJWyOP3555/WpUsXW7FihWVmZtrpp59uFStWtFGjRrn7EyZMiHeRAAAAQOFkZgcOHGitWrWyjRs3Wrly5YLTzznnHEtPT8/dWgAAAACFkZmdN2+ezZ8/35KTk8Om161b11atWpWbdQAAAAAKJzO7d+9e27NnT7bpf/31lys3AAAAABI2mO3UqZONGTMmeD8pKckN/EpLS7OuXbvm9/oBAAAA+Vdm8PDDD7sBYI0aNbJ///3XLr74Yvv1118tNTXVXn755XgXBwAAABReMFu7dm1bunSpTZ8+3f1UVrZfv352ySWXhA0IAwAAABIqmN21a5c1bNjQ3nnnHRe86gYAAAD4oma2dOnSrrQAAAAA8OUAsGuvvdZdIEFXAQMAAAB8VTP79ddfu4sjfPDBB9akSRM76KCDwv4+Y8aM/Fw/AAAAIP+C2cqVK9t5550X78MAAACAog9mp0yZkv9rAQAAABRGMOtZv369/fzzz+73Bg0a2CGHHJLbRQEAAACFMwBs+/btdsUVV9ihhx5q7du3d7eaNWu6XrM7duzI3VoAAAAAhRHMDh482D755BN7++23bdOmTe42c+ZMN+2mm27KzToAAAAAhVNm8Prrr9trr71mJ598cnBa165d3dW/LrzwQnvyySdztyYAAABAQWdmVUpQvXr1bNOrVauWqzKD8ePHW926da1s2bLWpk0b++qrr/Y5vzLB6nWrMocyZcrYUUcdZe+++27czwsAAIBiGMy2bdvW0tLSwq4EtnPnTrv77rvd3+Ixffp0V7ag5S1atMiaNWtmnTt3tnXr1kWdPysry04//XTLyMhw2WENQJs0aZLVqlUr3pcBAACA4lhm8Nhjj7mA87DDDnPBpyxdutRlVt9///24ljV69Gjr37+/9e3b192fMGGCzZo1yyZPnmxDhgzJNr+m//PPPzZ//nx3aV1RVhcAAADFU9yZ2caNG9uvv/5qI0aMsObNm7vbyJEj3bRjjjkm5uUoy7pw4ULr2LHj/1amRAl3f8GCBVEf89Zbb7nsr8oMVOqgdXnggQdsz549OT5PZmambdmyJewGAACAYtxntnz58i6jmhcbNmxwQWhk/a3uL1u2LOpjfv/9d/v444/tkksucXWyy5cvt2uuucZ27drlShWiUdCtEggAAAAceOLOzCo41On+SJo2atQoK0h79+51A82eeuopa9mypfXs2dPuuOMOV56Qk6FDh9rmzZuDt5UrVxboOgIAACCBg9mJEydaw4YNs01XicG+gspIqampVrJkSVu7dm3YdN2vUaNG1Meog4G6F+hxnqOPPtrWrFnjyhaiUceDSpUqhd0AAABQTINZBY4KKiPpcrarV6+OeTnJyckuu5qenh6WedX9nLoinHjiia60QPN5fvnlF7c+Wh4AAACKl7iD2dq1a9vnn3+ebbqm6bK28VBbLrXWeu655+ynn36yq6++2l0u1+tu0Lt3b1cm4NHf1c1g4MCBLohV5wMNANOAMAAAABQ/cQ8A08CvG2+80Q26OvXUU900ZVNvvfXWuC9nq5rX9evX2/Dhw13GV50RZs+eHRwUtmLFCtfhIDSQVvuvQYMGWdOmTV1/WQW2t912W7wvAwAAAAeApEAgEIjnAZpdPWAff/zxYJ2qeswqoFRQmujUmislJcUNBqN+FgDgF3WHzCrqVUAxlzGyW0LGa3FnZpOSklzXgmHDhrnSgHLlyln9+vXdQCsAAAAgoWtmPRUqVLDjjjvOKlasaL/99lvYoCwAAAAgoYJZ9ZHV5WdDDRgwwI488khr0qSJuxoXPVwBAACQkMGsLlRQpUqV4H0N1JoyZYo9//zz9vXXX1vlypW50hYAAAAKVcw1s7/++qu1atUqeH/mzJnWvXt3d2lZUYssr6UWAAAAkFCZ2Z07d4aNJps/f761b98+eF/lBmqvBQAAACRcMFunTh1buHCh+33Dhg32ww8/uCtyeRTIqoUCAAAAkHBlBn369HFX2lIQ+/HHH1vDhg3d5WhDM7UaBAYAAAAkXDCrK3zt2LHDZsyYYTVq1LBXX3012+Vse/XqVRDrCAAAAOTPFcD8jiuAAQD8iCuAoahlJOgVwHJ90QQAAACgqBHMAgAAwLcIZgEAAOBbBLMAAAAoPsHsnDlzCmZNAAAAgIIOZrt06WL16tWz++67z1auXBnvwwEAAICiC2ZXrVpl1113nb322mvuEradO3e2V155xbKysvJvrQAAAICCCGZTU1Nt0KBBtmTJEvvyyy/tqKOOsmuuucZq1qxpN9xwgy1dujTeRQIAAACFPwCsRYsWNnToUJep3bZtm02ePNld4rZdu3busrcAAABAwgWzu3btcmUGXbt2tTp16tj7779v48aNs7Vr19ry5cvdtAsuuCD/1xYAAAAIUcridP3119vLL79sugruZZddZg8++KA1btw4+PeDDjrIHn74YVd2AAAAACRUMPvjjz/a2LFj7dxzz7UyZcrkWFdLCy8AAAAkXJlBWlqaKyGIDGR3795tn376qfu9VKlS1qFDh/xbSwAAACA/gtlTTjnF/vnnn2zTN2/e7P4GAAAAJGwwq1rZpKSkbNP//vtvVy8LAAAAJFzNrGpkRYHs5ZdfHlZmsGfPHvv222/thBNOKJi1BAAAAPISzKakpAQzsxUrVrRy5coF/5acnGzHH3+89e/fP9bFAQAAAIUXzE6ZMsX9rFu3rt18882UFAAAAMB/rbnUzQAAAADwTTCry9amp6dblSpV7Nhjj406AMyzaNGi/Fw/AAAAIG/BbPfu3YMDvnr06BHLQwAAAIDECGa90gJ1LVAv2aZNm1rlypULet0AAACA/OszW7JkSevUqZNt3LgxnocBAAAAiXHRhMaNG9vvv/9eMGsDAAAAFGQwe99997nWXO+8846tXr3atmzZEnYDAAAAErY1V9euXd3Ps88+O6yrgXeZW9XVAgAAAAkZzM6ZM6dg1gQAAAAo6GC2Q4cO8T4EAAAASIxg1rNjxw5bsWKFZWVlhU1X2y4AAAAgIYPZ9evXW9++fe29996L+ndqZgEAAJCw3QxuvPFG27Rpk3355ZdWrlw5mz17tj333HNWv359e+uttwpmLQEAAID8yMx+/PHHNnPmTGvVqpWVKFHC6tSpY6effrpVqlTJRowYYd26dYt3kQAAAEDhZGa3b99u1apVc79XqVLFlR1IkyZNbNGiRblbCwAAAKAwgtkGDRrYzz//7H5v1qyZTZw40VatWmUTJkywQw89NDfrAAAAABROmcHAgQPdlb8kLS3NunTpYlOnTrXk5GR79tlnc7cWAAAAQGEEs5deemnw95YtW9qff/5py5Yts8MPP9xSU1Nzsw4AAABA4faZ9ZQvX95atGiR18UAAAAABRPMDh48OOYFjh49Ov61AAAAAAoqmF28eHFMC0tKSsrNOgAAAAAFF8zOmTMnd0sHAAAAEqk1FwAAAOCrzOy5557r2m7pKl/6fV9mzJgR90qMHz/eHnroIVuzZo3rXTt27Fhr3br1fh83bdo069Wrl3Xv3t3efPPNuJ8XAAAAxSCYTUlJCdbD6vf8NH36dDfATBddaNOmjY0ZM8Y6d+7sLszgXWksmoyMDLv55putXbt2+bo+AAAA8I+kQCAQKMoVUAB73HHH2bhx49z9vXv3Wu3ate3666+3IUOGRH3Mnj17rH379nbFFVfYvHnzbNOmTTFnZrds2eIC8s2bN7tMMwAAflB3yKyiXgUUcxkjuxXac8UTrxVpzWxWVpYtXLjQOnbs+L8VKlHC3V+wYEGOj7vnnntc1rZfv377fY7MzEy3QUJvAAAAODDEHcz+/fffdu2111qjRo3cFb+qVq0adovHhg0bXJa1evXqYdN1X/Wz0Xz22Wf2zDPP2KRJk2J6jhEjRrjI3rsp6wsAAIBiegWwyy67zJYvX+6yogo6C7O37NatW93zK5CN9dK5Q4cODbvogzKzBLQAAADFNJhVjaqyo+o6kFcKSEuWLGlr164Nm677NWrUyDb/b7/95gZ+nXXWWcFpqrGVUqVKuUFj9erVC3tMmTJl3A0AAAAHnrjLDBo2bGg7d+7MlydPTk62li1bWnp6elhwqvtt27aN+tzfffedLVmyJHg7++yz7ZRTTnG/k3EFAAAoXuLOzD7xxBOuy8Dw4cOtcePGVrp06bC/x9shQCUAffr0sVatWrnesmrNtX37duvbt6/7e+/eva1WrVqu9rVs2bLuOUNVrlzZ/YycDgAAgANf3MGsgkfVnZ566qlh09XhS/WzGtAVj549e9r69etdcKxBX82bN7fZs2cHB4WtWLHCdTgAAAAA8txnVtlT1acOHDgw6gCwDh06WCKjzywAwI/oM4uilpGgfWbjzsx+//33tnjxYmvQoEFe1hEAwvBBjeL0QQ0g/8R9/l61rStXrszHVQAAAAByJ+7MrC4zqxKDW265xZo0aZJtAFjTpk1zuSoAAABAAQezGrAlV1xxRXCa6mZzOwAMAAAAKLRg9o8//sj1kwEAAABFGszWqVMnX1cAAAAAKNBg9q233rIzzjjD1cfq933RFbkAAACAhAlme/To4S5oUK1aNfd7TqiZBQAAQMIFs3v37o36OwAAAFCUuE4sAAAADvxgdsGCBfbOO++ETXv++eftiCOOcOUHAwYMsMzMzIJYRwAAACBvwew999xjP/zwQ/D+d999Z/369bOOHTvakCFD7O2337YRI0bEujgAAACg8ILZJUuW2GmnnRa8P23aNGvTpo1NmjTJBg8ebI8//ri98soreV8jAAAAIL+D2Y0bN1r16tWD9z/55BPXrstz3HHH2cqVK9nwAAAASLxgVoGsd/WvrKwsW7RokR1//PHBv2/dutX1oQUAAAASLpjt2rWrq42dN2+eDR061MqXL2/t2rUL/v3bb7+1evXqFdR6AgAAALm/nO29995r5557rnXo0MEqVKhgzz33nCUnJwf/PnnyZOvUqVOsiwMAAAAKL5hNTU21Tz/91DZv3uyC2ZIlS4b9/dVXX3XTAQAAgIQLZj0pKSlRp1etWjU/1gcAAACIGVcAAwAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBQAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvpUQwez48eOtbt26VrZsWWvTpo199dVXOc47adIka9eunVWpUsXdOnbsuM/5AQAAcOAq8mB2+vTpNnjwYEtLS7NFixZZs2bNrHPnzrZu3bqo88+dO9d69eplc+bMsQULFljt2rWtU6dOtmrVqkJfdwAAABTzYHb06NHWv39/69u3rzVq1MgmTJhg5cuXt8mTJ0edf+rUqXbNNddY8+bNrWHDhvb000/b3r17LT09vdDXHQAAAMU4mM3KyrKFCxe6UoHgCpUo4e4r6xqLHTt22K5du6xq1aoFuKYAAABIRKWK8sk3bNhge/bsserVq4dN1/1ly5bFtIzbbrvNatasGRYQh8rMzHQ3z5YtW/K41gAAAEgURV5mkBcjR460adOm2RtvvOEGj0UzYsQIS0lJCd5UYwsAAIADQ5EGs6mpqVayZElbu3Zt2HTdr1Gjxj4f+/DDD7tg9oMPPrCmTZvmON/QoUNt8+bNwdvKlSvzbf0BAABQjIPZ5ORka9myZdjgLW8wV9u2bXN83IMPPmj33nuvzZ4921q1arXP5yhTpoxVqlQp7AYAAIADQ5HWzIracvXp08cFpa1bt7YxY8bY9u3bXXcD6d27t9WqVcuVC8ioUaNs+PDh9tJLL7netGvWrHHTK1So4G4AAAAoPoo8mO3Zs6etX7/eBagKTNVySxlXb1DYihUrXIcDz5NPPum6IJx//vlhy1Gf2rvuuqvQ1x8AAADFOJiV6667zt1yukhCqIyMjEJaKwAAACQ6X3czAAAAQPFGMAsAAADfIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBQAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAbxHMAgAAwLcIZgEAAOBbBLMAAADwLYJZAAAA+BbBLAAAAHyLYBYAAAC+RTALAAAA3yKYBQAAgG8RzAIAAMC3CGYBAADgWwSzAAAA8C2CWQAAAPgWwSwAAAB8i2AWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAAD4FsEsAAAAfItgFgAAAL5FMAsAAADfIpgFAACAb5WyBDB+/Hh76KGHbM2aNdasWTMbO3astW7dOsf5X331VRs2bJhlZGRY/fr1bdSoUda1a1dLVHWHzCrqVUAxlzGyW1GvAgAAB2Zmdvr06TZ48GBLS0uzRYsWuWC2c+fOtm7duqjzz58/33r16mX9+vWzxYsXW48ePdzt+++/L/R1BwAAQDEPZkePHm39+/e3vn37WqNGjWzChAlWvnx5mzx5ctT5H3vsMevSpYvdcsstdvTRR9u9995rLVq0sHHjxhX6ugMAAKAYlxlkZWXZwoULbejQocFpJUqUsI4dO9qCBQuiPkbTlckNpUzum2++GXX+zMxMd/Ns3rzZ/dyyZYsVlr2ZOwrtuYBoCnN/zy2OExS1RD9OOEZQnI6RLf//cwUCgcQOZjds2GB79uyx6tWrh03X/WXLlkV9jOpqo82v6dGMGDHC7r777mzTa9eunad1B/wkZUxRrwGQ+DhOgMQ7RrZu3WopKSmJPwCsICnrG5rJ3bt3r/3zzz928MEHW1JSUpGuG2L/dqYvHytXrrRKlSqx2QCOESBufJb4izKyCmRr1qy533mLNJhNTU21kiVL2tq1a8Om636NGjWiPkbT45m/TJky7haqcuXKeV53FD4FsgSzAMcIwGdJ8ZCyn4xsQgwAS05OtpYtW1p6enpY5lT327ZtG/Uxmh46v3z44Yc5zg8AAIADV5GXGagEoE+fPtaqVSvXW3bMmDG2fft2191AevfubbVq1XK1rzJw4EDr0KGDPfLII9atWzebNm2affPNN/bUU08V8SsBAABAsQtme/bsaevXr7fhw4e7QVzNmze32bNnBwd5rVixwnU48Jxwwgn20ksv2Z133mm33367u2iCOhk0bty4CF8FCpLKRNSHOLJcBADHCMBnCZICsfQ8AAAAABJQkV80AQAAAMgtglkAAAD4FsEsAAAAfItgFsXWs88+S89hAPChyy+/3Hr06BHTvHPnznUXSdq0aVOBrxeKBsEsfKVu3bqufRtQXMTzoR3qrrvuct1hgAPRY4895hISsVAXpNWrV8fcgD8vxx2KaWsuIL/t2bPHfQsPbekGADhwxBOY6gJNOV0lFAcGPu2Rr3QFtwcffND+85//uL6whx9+uN1///3ub999952deuqpVq5cOTv44INtwIABtm3btmzfhB9++GE79NBD3TzXXnut7dq1y/395JNPtj///NMGDRrkglXdQssF3nrrLWvUqJF7XvUn3rhxo7voRpUqVax8+fJ2xhln2K+//so7joT02muvWZMmTYLHR8eOHe2WW26x5557zmbOnBnc53XKVG677TY76qij3L595JFH2rBhw4LHio6Ju+++25YuXRp8nJfF0qnWK6+80g455BB3eWgdk5oP8JPQzGlmZqbdcMMNVq1aNStbtqyddNJJ9vXXX+dYZuB9Zrz//vt29NFHW4UKFaxLly4ue+ud1cjpuENiIjOLfDV06FCbNGmSPfroo+4/FP3nsGzZMndVt86dO7vLDus/mXXr1rkP1Ouuuy7sVNGcOXNcIKufy5cvdxfV0KnS/v3724wZM6xZs2YuCNb9UDt27LBRo0bZ008/7QIB/afWq1cvF7wqyNWHtj78u3btaj/++KOVLl2adx4JQ8eJ9ld9ETznnHNs69atNm/ePPdlTF/MtmzZYlOmTHHzVq1a1f2sWLGiO3Zq1qzpvijqmNC0W2+91R0333//vbsAzUcffRSWybrgggtcwPzee++5aRMnTrTTTjvNfvnll+CyAT/RPv/666+7ALROnTruONLnjT5Dctqn9ZmhxMkLL7zgzuJdeumldvPNN9vUqVPdz59++inqcYcEpYsmAPlhy5YtgTJlygQmTZqU7W9PPfVUoEqVKoFt27YFp82aNStQokSJwJo1a9z9Pn36BOrUqRPYvXt3cJ4LLrgg0LNnz+B9/f3RRx8NW/aUKVN04Y/AkiVLgtN++eUXN+3zzz8PTtuwYUOgXLlygVdeeSX4uJSUFN58FLmFCxe6/TUjIyPb33RcdO/efb/LeOihhwItW7YM3k9LSws0a9YsbJ558+YFKlWqFPj333/DpterVy8wceLEPL0GoDB5x4U+U0qXLh2YOnVq8G9ZWVmBmjVrBh588EF3f86cOe742rhxY9hnxvLly4OPGT9+fKB69erZlg9/IDOLfKNvsjrdoyxPtL8pq3rQQQcFp5144omuLOHnn38OXr74mGOOsZIlSwbnUZZWWadYaqKaNm0a9nylSpWyNm3aBKcpY9ugQQP3NyCR6NjQcaMyA2WUOnXqZOeff74rkcnJ9OnT7fHHH7fffvvNlevs3r3bnYHYF5UTaF4dC6F27tzplgP4jfZbldfo88SjM2+tW7fe5//1Ks+pV69e2GeNzhjCnwhmkW906jKvIk//q1ZJAW8sz+3V0AJ+oy9wH374oc2fP98++OADGzt2rN1xxx325ZdfRp1/wYIFdskll7i6WAW/KheYNm2aPfLII/t8HgWy+tCOVv+nGkKguIj2WRMIKGELP2IAGPJN/fr1XVCZnp6e7W8qsldWSLWzns8//9zVKilbGitlYNWtYH/0fMpUhQYDf//9t8sCa5AYkGj0YarskgLUxYsXu339jTfeiLrPK+hVbaAC3latWrljT4MjQ0V7XIsWLWzNmjXurIUGaYbeUlNTC+V1AvlJ2VXt6/o88ShTq7EZefm/PtbPGiQGglnkG40i1SArFeM///zz7vTPF198Yc8884zLIunvffr0cQNTNMDr+uuvt8suuyxYYhBrn9lPP/3UVq1aZRs2bMhxPn24d+/e3Q2K+eyzz1wgrQL/WrVquelAItGXrgceeMC++eYbN+BLgx3Xr1/vvpRpn//222/dFzHt8/qg1v6t+ZSN1XGmcgMFvqH0uD/++MOWLFniHqcSIHVI0CBMjQJXBjgjI8MFxgqK9dyA36h07eqrr3adPzTgUQN89f++Bnj169cv18uNdtwhcRHMIl+pPdBNN91kw4cPdx/EGlWtOiTVJ6kNyj///GPHHXecqwdUjeC4cePiWv4999zjPoD1bVythfZFo1BbtmxpZ555pvsA1ymkd999l04GSDiqddWXNHXbULutO++805UMqJ2cPph19kIZWO3zykCdffbZrkWduoGo24cCUh17oc477zzXbuiUU05xj3v55Zdd9lfHQPv27a1v377uuS666CKX1Y3nSyWQSEaOHOn2dyVHdPZBXQz0ebOvmvP9iXbcIXElaRRYUa8EAABArNTKTrXmL774IhsNZGYBAIA/aCyESgk0CFLdbwChzAAAAPiCxlzo1L8C2auuuqqoVwcJgjIDAAAA+BaZWQAAAPgWwSwAAAB8i2AWAAAAvkUwCwAAAN8imAUAAIBvEcwCAADAtwhmAQAA4FsEswAAAPAtglkAAACYX/0/ci2bUrF8YB8AAAAASUVORK5CYII=", + "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": 11, + "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.0558\n", + " State similarity: 0.9661\n", + " Control similarity: 0.0629\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": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 0%| | 0/2 [00:00\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": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test data shape: (12, 150, 5)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 100%|██████████| 5/5 [00:00<00:00, 63.80it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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", + "\n", + "\n", + "sweeper = DefaultSweeper(\n", + " test_data,\n", + " param1_name = \"n_delays\",\n", + " param1_values=n_delays_range,\n", + " param2_name='rank',\n", + " param2_values=ranks_range,\n", + " compute_residuals=True\n", + ")\n", + "sweeper.sweep()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.2 Visualizing Sweep Results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sweeper.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.3 Basic Hyperparameter Sweep and Visualization for DMDc / Subspace DMDc" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 100%|██████████| 5/5 [00:15<00:00, 3.15s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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", + "\n", + "sweeper = DefaultSweeper(\n", + " data1,\n", + " param1_name = \"n_delays\",\n", + " param1_values=n_delays_range,\n", + " param2_name='rank',\n", + " param2_values=ranks_range,\n", + " control_data=control1,\n", + " compute_residuals=True,\n", + " model_class='SubspaceDMDc'\n", + ")\n", + "sweeper.sweep()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sweeper.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.4 Using Statistics for DMD Quality Assessment\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DMD Matrix Statistics:\n", + "==================================================\n", + "MAE : 0.0079\n", + "MASE : 0.1737\n", + "NMSE : 0.0400\n", + "MSE : 0.0001\n", + "R2 : 0.9479\n", + "Correl : 0.9736\n", + "AIC : -9.1654\n", + "logMSE : -9.2058\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", + "## 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", + "\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 (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/inputdsa_fig2_tutorial.ipynb b/examples/inputdsa_fig2_tutorial.ipynb new file mode 100644 index 0000000..fce56c4 --- /dev/null +++ b/examples/inputdsa_fig2_tutorial.ipynb @@ -0,0 +1,2803 @@ +{ + "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_79424/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": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAJOCAYAAADhz3V3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QV4nFXWB/B/3N29aVN3F6hBlQJFi0uB4l3sQwosvkiRRQqLU6RYcW1poUbdXdOkjbu7fc85kxmibdJOkkny/+3zbiaTyWQyNPd9z73nnmNVVVVVBSIiIiIiIuowrNv6BRAREREREZF5MdAjIiIiIiLqYBjoERERERERdTAM9IiIiIiIiDoYBnpEREREREQdDAM9IiIiIiKiDoaBHhERERERUQfDQI+IiIiIiKiDYaBHRERERETUwTDQIyIiIiIi6mAY6BFV2717Ny655BJERETA0dERISEhmDx5Mt54440WeY/27duHJ554ArGxsRb33+Crr77C1Vdfje7du8PKygoTJkxo65dERO0Ax1GDjIwMvPjiixg3bhz8/Pzg6emJUaNG6dhKRNRaGOgRAVi3bh2GDRuGnTt3Ys6cOViwYAFuuukmWFtb47XXXmuxQO/JJ5+0yEDvf//7H3788UeEhYXBy8urrV8OEbUDHEf/sX79ejzyyCPw9vbGo48+iv/85z9wdnbG5Zdfjscff7wN/ysRUWdi29YvgMgSyEnYw8MDmzdv1pnXmlJTU9HZfPrpp7qiKYFuv3792vrlEFE7wHH0H3379sXhw4c1Q8To9ttvx6RJk/DCCy/ggQcegIuLS5v8dyKizoMrekQAoqOj9cRcN8gT/v7+ptvjx4/HwIEDG3zPevbsialTp5o+//LLLzF06FC4ubnB3d0d/fv3N60OLly4EJdeeqnenjhxoqZHyrFy5UrT9//+++8YO3asXgzIc8yYMQN79+6t9TOvv/56uLq64vjx4zj33HP1tgRob775pimN6qyzztLnkAuOzz//vEn/vWUlT4I8IqKm4jj6j8jIyFpBnpAx/oILLkBJSQmOHj3Kf1hE1OJ4JUcE6Al569at2LNnzwnfj2uuuQa7du2q9zhZCTx06JDuaxPLli3DFVdcoWmPMnv7/PPP6z63tWvX6tdl38a//vUvvf3www/rCpocvXv31vvktgR2ErjJ9//73//WVM8zzzyzXqpnRUUFpk+frsHZ/Pnz0aVLF9x5550aTE6bNk1TUuU5JFi89tprERMTw//mRGR2HEdPLjk5WT/6+vryXyARtbwqIqr6448/qmxsbPQYPXp01QMPPFC1dOnSqtLS0lrvTnZ2dpWjo2PVgw8+WOv+f/3rX1UuLi5V+fn5+vldd91V5e7uXlVeXt7ou7t48eIq+RNcsWJFrfvz8vKqPD09q+bMmVPr/uTk5CoPD49a91933XX6HM8++6zpvqysrConJ6cqKyurqi+//NJ0/4EDB/Sxjz/+eLP+i/ft27dq/Pjx/FdCRCfEcfTEMjIyqvz9/avGjh3Lf0lE1Cq4okcEaHVN2Tx//vnna0EWWRmTNExJg/zpp59M75Hs45s5cya++OILmSQxrahJJTVJyTHuuZAU0IKCAl3Zay75nuzsbF0RTE9PNx02NjYYOXIkVqxYUe97pHCMkfxsSSOV1zJr1izT/XKffI0pQ0TUEjiONq6yshJXXXWVju0tVcmZiKguBnpE1YYPH47vvvsOWVlZ2LRpE+bNm4e8vDxtuSBpk0aS/ih74tasWaOfL1++HCkpKZrWWXPTfY8ePTSlMjQ0FDfccAOWLFnSpPdaNvAL2VsnZblrHn/88Ue94jDSCkK+VpMEpPJzZU9I3fvl9yMiagkcRxs2d+5cPQe8//77je7zJiIyN1bdJKrD3t5eL1bkkGBt9uzZWLx4sakktqz0BQQE4LPPPtO9dvIxMDBQq6nVLOCyY8cOLF26VIuqyPHRRx9pkPjxxx+fdObXuE9PnrfeH61t7T9bWelrSGP3G1ciiYhaCsfRf0gbnbfeekv3atecECQiamkM9IhOQAqZiKSkpFoB1JVXXqnFTqTIyQ8//KC99+oGVnKhc9555+khwZus8r3zzjtaWCUqKqreaptRt27dTMFizeCRiKg96szjqFRAfuKJJ3D33XfjwQcfbLPXQUSdE1M3iQDd99bQStdvv/1m2t9Wk8zKSgrkLbfcgvz8fFO1TaOMjIzaf2jW1hgwYIDeltLawrifT/Zs1CQrhtKO4dlnn0VZWVm915SWlsb/ZkRkcTiO1iZ7t6W6suzNe+WVV9rovwoRdWZc0SOq3j9RWFiICy+8EL169UJpaSnWrVunJ2ppVyDpmzUNHjxYG4lLSqe0RBgyZEi94iiZmZm6z072yh07dkw34A8aNMjUQkFuy+y1zGbn5OTAwcFBHy8z0P/73/80mJTnvfzyy3UPnuwL/PXXX3HGGWdgwYIFLfrfbfXq1XoYA0spLPPMM8/o55KuKgcRUU0cR/8h+7wlVd/Hxwdnn302Fi1aVOu9GjNmDLp27cp/QETUslqnuCeRZfv999+rbrjhhqpevXpVubq6Vtnb21dFRUVVzZ07tyolJaXB75k/f3691gZG33zzTdWUKVO0lLY8V3h4eNUtt9xSlZSUVOtx7733XlXXrl21rUPdVgtye+rUqdpSQVo6dOvWrer666+v2rJlS632CtLWoS5phyBtEeqKiIiomjFjxknfD2nBIK+noaO57RmIqHPgOPqPjz76qNExVA75OhFRS7OS/2vhWJKoQ3rttddwzz33aAPz8PDwtn45RETtDsdRIqKWw0CP6BTI/IiUyJa0nIb62hEREcdRIqK2xD16RM0ge9WkgboEd7t378aPP/7I94+IiOMoEZHF4YoeUTNImmZkZCQ8PT21zPd//vMfvn9ERBxHiYgsDgM9IiIiIiKiDoZ99IiIiIiIiDoYBnpEREREREQdDIuxnERlZSUSExPh5uYGKyur1vmvQkTUxlVl8/LyEBwcDGvr058P5DhKRJ2RucdSouZioHcSEuSFhYU1+40lImrv4uLiEBoaetrPw3GUiDozc42lRM3FQO8kZCXP+Efq7u6OlpaZmYk5c+bo7ffeew/e3t4t/jOJiGrKzc3VCS7j+He6OI4SUWdk7rGUqLkY6J2EMV1TgrzWCPTkZyxbtqzFfw4R0cmYK12d4ygRdWbc+kNthQnDREREREREHQwDPQsjqZsjRozQQ24TERHHUSIiouZi6qaFiY6OxubNm023uUePiIjjKBERUXN1+BW97OxsDBs2DIMGDUK/fv20wIklc3R01BK8cshtIiLiOEpERNRcHX5FTyodrV69Gs7OzigoKNBg76KLLoKPjw8sUf/+/VFRUdHWL4OIqN3iOEpERNQJAj0bGxsN8kRJSYk2r5SDiIgs2zu/7MKnfx3E4G6+eOOOiW39coiIqAlkwaKsrIzvVQuwtbXV2KaplVwtPtCT1bgXX3wRW7duRVJSEr7//ntccMEFtR7z5ptv6mOSk5MxcOBAvPHGG1rMpGb65vjx43H48GF9nK+vbxv8JkRE1BwfbkqAQ3AgNmaW8I0jIrJwspAi1+Jy3U0tRwI9f39/eHh4nDTgs/hAT9ItJXi74YYbNOWyrq+++gr33nsv3n77bYwcORKvvvoqpk6dioMHD+qbIDw9PbFz506kpKToc1xyySUICAiAJdq9e7f+vkJes6QgERF1Rt0j/RDs54r8oubNDHMcJSJqfcYgT66/JZuO/QPNH0iXl5cjNzdXF7+KiooQFBTUvgO96dOn69GYV155BXPmzMHs2bP1cwn4fv31V3z44Yd46KGHaj1WgjsJotasWaPBXkMkvVMOI3kzW1NxcbEptVRuExG1N+YaRyP9nBHu54TMguadqjiOEhG1frqmMciz1DoYHan+iIODA9LT0/X9lhW+Dll1s7S0VFM6J02aZLpPqlXK5+vXr9fPZRUvLy9Pb+fk5GgqaM+ePRt9zueee06XQo1HWFgYWlO3bt0wevRoPeQ2EVF7Y65x1KY6I8XB1holpU1f1eM4SkTUuox78ox1Mahlubi46MLQyfZCtutATyJZmUGom4Ypn8vysTh27BjGjh2rK3nyce7cuSdMh5w3b54GhMYjLi4OrUn65q1bt04P9tAjovbIXONoVx8X/WhrY4W/th9v8vdxHCUiahtM17Ss99niUzdPlxRl2bFjR5MfL0uhchAR0akx1zg6sqs3VsdkwtbaCj9ujcf0kcxyICIiaqp2vaIn1TMlL1XSM2uSzwMDA9EeZWZmYuLEiXrIbSKizirCy5ACZGNthaSiyiZ/H8dRIqL2szJV87Czs9Pre8m+u/766/Htt99qARJziY2N1Z8zYcIEdAbtekXP3t4eQ4cOxZ9//mlquVBZWamf33nnnWiPoqOjsXLlStNtpm8SUWcle/Mqq6pgbWUFZ1enJn8fx1EiovbluuuuM13HS8r/oUOH8Mknn+Djjz9GVFQUFi1aVKt1GnWQQC8/Px9HjhwxfR4TE6OpmBIAhYeHa2sF+ccxbNgw/Qcg7RWkJYOxCmd74+joaMq7ldtERJ2VjIVlFVVwsLWCu1vTU0E5jhIRtS8LFy5scNLu4Ycfxtdff62ZbmvXrsWgQYPa5PW1VxYf6G3ZskX/4xpJYCckuJN/FJdddhnS0tLw2GOPaQEW+QewZMkSi+2TdzKyVC2zGUREBJSVV+rKnotj009XHEeJiNo/qaAs/bKlncAHH3ygPbW3bdvW1i+rXbH4PXqSQyvlQ+seNSN/SdOU6prSt2njxo3aOJ2IiNo/WdETDvaN9wkiIqKO6+WXX9Z2Atu3b8fff/9d7+tS2VliAQkMJaNDsv7OPfdcrWDfnP6rEkzOnDkTXbt2hZOTEzw9PTFu3Dh8+eWX9R4vzy9ZJ3/88UeDz1dYWKjfL0Gqsc2bkNck280iIiK0aJnUFJGMROn9LVmMnS7QIyKizquswpDhYG/LQI+IqDOSfqzTp0/X2ytWrKj1NembLS3U3nzzTS3kMmPGDPTr1w9Lly7VIE1WBJtapOWmm27STMIuXbpowCdZghs2bMAVV1yBJ554otbjb7nlFv343nvvNfh8ixcv1r2Gl19+uQZ74ueff9ZWbz/99BOCgoJw0UUXYfDgwVpA7IUXXtC2cebGQM/C7N69WyuJyiG3iYg6s9JyY6DX9NMVx1Eioo7FuDdv//79pvtyc3Nx8cUX68fPPvsMBw4c0Cqdq1ev1gDQ3d1dgzfZ4nUyfn5+WLZsGeLj4/HXX3/pKp4URzx48KAGfk8//bQGg0bnnHMOwsLC8OOPPyI1NbXe8xkDwDlz5pjue+mll3R7lgSBEkB+8cUX+P3337UWyaZNm+Dj4wNzY6BnYWTpWP4RyCG3iYg6M+OKnp1N05rDCo6jREQdi7RcEFlZWab7PvzwQyQlJeHuu+/GVVddVevxUqTx3//+t6ZDShB4MhJkTZo0qV4j8sjISDzyyCN6XS4rckayICNBXFlZmVYGrUkCTikcM2DAgFqVQo0Bp/ycuoYPH25a+etUxVg6G8kvliVo420ios6stMwQ6EnT9KbiOEpE1LFIfQ5RMxAz7o+TFMiGjB07Vj/KallTyR5AWclLSEjQSUP5uRJMisOHD9d6rKwWPvXUU3j//fdx//3311vNu/nmm2s9XlrCyYrkNddco0GofG5t3bJrbgz0LIxsIJX2EUREBJRXr+jZNmNFj+MoEVHHYty/VrO/tDGV8owzzmjS956I7KeTgFHSNhtTs6iKkH12559/Pr777jusWrUK48ePR2lpqfb/k2IudVcZn332Wd1aICuDcnh5eeHMM8/U57j66qtbpK0aAz0iIrJYleUV+tGmGSt6RETUsUjFTdGnTx/TfcZ2ZJdccolW5WxMr169Tvr8Dz74oAZ5Eqw9+eSTWtBFqmZKiqasHE6dOtW0qljTrbfeqoGerOLJ9/7www8aWF577bX6/TXJnj4p9iI/55dfftHg0Bj0zZ8/X/cVmnufHgM9CyOVd2QpWMhScM2ZCyKizsZ4krKps2/iRDiOEhF1HLLaJlU0Rc3e2qGhoVosRVoTSBrk6fj+++81qJOKmFLEpaajR482+n2y3y4qKkqLwLzxxhuNpm0a2draYsqUKXoIaQ8n/QEl+JPKmxLwmROLsViY6Oho/ccmh9wmIurMXKsbpcuKXln16t7JcBwlIuo47rvvPhQUFGjBktGjR5vunzx5sn6Ua+bTlZWVpQFe3SBPfP31141+n+wZlKBO9vPJfr0///wTvXv3Pmk6qZH005PVRLFnzx6YGwO9FlBUUoZet36J8Bs/R0Ja7Xzek6mZn9sSubpERO1JmJeTKV0mNjW3Sd/DcZSIqP2TlbTLLrtMG5lLaqZ8rNvLzt/fX1fB3n33XVMqp1F5ebmuBDYlgOrRo4cGe3X77v33v/+t17uvrtmzZ2vz81dffVXPVzVbKtR9ruTk5Hr3//bbb6bUTnNj6mYLKK+qgl9UCGxtrbF6XzKuGN/0cqn9+/dvMAeYiKgzGhTmic3JedpeYXN0OroHe530eziOEhG1L9dff71+lGBN+uIdOnRI2xTINXH37t3x+eef69hek+yBkz525513ngZ9zzzzjO6tkyInElBt27YN2dnZuuIn95/IvHnztCCKNDiX5uuSFrpz5059Dffcc48GaSdq/SD9/OQ1SsAn+/MaInv//u///k+r68vvJL+b/Az5XWWrlnzN3BjotYSqSpw3NBg21sDWuAxc0SI/hIio44sKcMPa+FzY2QDHstlblIioIzL2opM9bJI+GRwcrAHTzJkztSql7J9ryKhRo7SSpQRiv/76qxY4MVbEHD9+PC688MIG+9bVJRUyJUCUxuhS/V6eU3rxvfXWWxqQnSjQE2eddZYGelK5s7GCKrKHb8mSJdi6das2Sjeu4t177716hISEwNwY6LUAV0cHeDrZaN7unqKm7SkhIqL6PJztUVJRBamnViGzZ0RE1GGYI4stMDBQC5nIcTJdunRp9Geec845epzK6zTu42usCIuQ/nlytCaeNVuABHjVrZ9Q2cxGiEeOHNHZDDnkNhFRZ2ZtZYWiUsOEmbeHM0rKa+/BaAjHUSIiai3SkH3ZsmXo27cvJkyYAEvCFb0WUlFVBVtYwd6+eW+xbAStqKgw3SYi6uzySipQWl4Je1trHEzLx4Cg+lXRauI4SkRELU3aOhw/flxTRmXF7z//+Q8sDQO9FlJRaVjidXKwa9b3SU6yVP4x3iYi6uzKyiuRX1oJb1trZBSUnvTxHEeJiKilffnll4iLi9MWCc8995zuJ7Q0DPRaSJnmbtrAwaF5qZuyEVOaPxIRkUFpWSXKKwyTZ3kl5RxHiYiozcXGxsLScY9eCzFelDhKqTgiIjplpWXlKK/OkshvQqBHREREDPRajOwnEfa2zQv0MjMztReIHHKbiKizq6ioNAV6BWUVptT4xnAcJSIiYupmi+4pEfa2Vs36vujoaLz77rt6+6abbtIGikREnVmgmwMktqusqtIqnPml5fBwbHz/M8dRIiIirui16Ay0sG1m3ydHR8cGbxMRdVYXDg5GYWmFKSU+JqPwhI/nOEpERMRAr8UY9+bZWlvheErT2yT0799fS7TKIbeJiDq7YeGe2ktP2iyIrQnZ1QWvGsZxlIiIiIFei+nu76ofbayt8NVKVtEkIjpVkhlRUFKOvJJKDfAkjTMt/+RtFoiIiDozVt1sIcPDPPSjnY0VVkaz8TkR0enIKyjRTIfSckP6Zkp+Cd9QIiKiE2Cg10IifVz0okQKB9i4uDT5+44cOQJ7e3s95DYREQF5+SUoq6hCcXWgF5dTxHGUiIjoBBjotRAbG2u9KBEBPm5N/r6srCyUlZXpIbeJiAgoLy5DeUUlCssM+/RS8kqQlFvMcZSIiKgRDPRaUHGZoViAt4dDk78nODgYoaGheshtIiICHG2BssoqSA2Wquo2egmNBHocR4mIyJzy8/Px+OOPY9q0adr6zMrKCgsXLmzwsfv379fHubq66mOvueYapKWloS3YtslP7STyS8rh7mQLd6fG+z3VFRISgri4uBZ9XURE7Y30zZMVPVFSXglHO2sUlJY3+FiOo0REZE7p6el46qmnEB4ejoEDB2LlypUNPi4+Ph7jxo2Dh4cHnn32WQ0QX3rpJezevRubNm3SrVmtiYFeC8orLAU8HeFib2i1QEREp8bf3QFF1fvzik2BniGNk4iIqCUFBQUhKSkJgYGB2LJlC4YPH97g4yS4KygowNatWzUoFCNGjMDkyZN1BfDmm29u1f9QTN1sQUUS6AGwt7XSGegmfU9RER577DE95DYREQHdA1xQalzRq06LbyzQ4zhKRETm5ODgoEHeyXz77bc499xzTUGemDRpEnr06IGvv/4arY2BXgtysbU2NU2PzSho0vfs2bMHTz/9tB5ym4iIgMGRfiitnjArqQ74Gkvd5DhKREStLSEhAampqRg2bFi9r8mq3vbt21v9NTF1swUN6eKN7MoqbZq+41gmegY0vfomERH9Y1AXL5SuPa63q+M8rWwswZ999aQaERFZFmk1VlhsyHCzBM6O9lpIpSVIaqcxzbMuuS8zMxMlJSW6OtguAr3i4mI4Ojqa79V0MON6+mHx7mQ429sgNquwSd8jOb/yR0FERP9wd7JHcXWqppykra2AyiograAEIR5OHEeJiCyQBHm+Y+6DpUhf9zJcnFom0DJuuWookDPGS/KY1gz0mj0NWllZqWmFUtVMyoYePXpU7//3v/+NDz74oCVeY7sV6OGEouoLkworzjgTEZ0OWb3LLSrT24WlhmW99cfYb5SIiNqek5Nh0lFW7RpaHKv5GItd0XvmmWfw8ccfY/78+ZgzZ47p/n79+uHVV1/FjTfeaO7X2G5ZW1khv6QCPq6Aoz2zZImITkdlVRXScku0ZU1qfhkivByQVVSmrWxcHTjGEhFZGkmVlFU0S3o9LcWYsmlM4axJ7pOeeq25mieafWb85JNP8O677+Lss8/GrbfearpfekocOHDA3K+v3cstNhQLcLC3xrb4HAwJ9Tjh448cOaJBs7GgQFRUVKu8TiIiS1daUoHC0gqUV1ZpkSvZ/yy3pXF6Tz9X0+M4jhIRWQZJtW+pVElLExISAj8/P22/UJf00Bs0aFCrvybrU6ko01DwISmdZWWGlBr6R3y6odqmnbUVVh/NPOlbk5WVpUu+cshtIiIyyM7IR35RGQpLDBNo6QWGc86amAxd2eM4SkREbeniiy/GL7/8gri4ONN9f/75Jw4dOoRLL7201V9Ps1f0+vTpgzVr1iAiIqLW/d988w0GDx5sztfWIaRkFKC4zNDcN7+0DGUVlbCzaTy+Dg4Ohr+/v+k2EREZ2FtVoaioDDGpBegX5oG8kgp4OtlC6letP5aJc3oFcBwlIqIWsWDBAmRnZyMxMVE///nnnxEfH6+3586dCw8PDzz88MNYvHgxJk6ciLvuugv5+fl48cUX0b9/f8yePdvyAz1p5H3dddfpyp6s4n333Xc4ePCgpnRKBEu12aEKGQWlCPF01GAvNb8UIR6OJ1z2TUlJ4dtIRFSHr6sd0ksqUFxWgZTcYgR7OiExpwQhng5IyClGdlEZPJ3sOI4SEZHZvfTSSzh27Jjpc4mB5BBXX321BnphYWFYtWoV7r33Xjz00EOwt7fHjBkz8PLLL7f6/rxTCvRmzpypEexTTz0FFxcXDfyGDBmi902ePLllXmU7FuBih9RcQ6DnZGuNxNziEwZ6RETUsGGRXlhyJA9FxWVIzSlGgLsjSmGl/6tCFeJzijTQIyIiMrfY2NgmPa5v375YunQpLMEplSkbO3Ysli1bZv5X0wGNivLF6sQCDKpy06a++1PyMTzMs9HHS3+NhQsX6u3rr7++1cuwEhFZqktHR2LJkV0oLi5HmbM90vJKEODuoHv1vJ1tcSgtH738XFFWWsJxlIiIOr1O0dztwgsvhJeXFy655JJW/9lXndEF+cXlKCgx9NPLKylDYamhkEBDpNLm7bffrofcJiIig8GRPigvr0BlJWBXVYmsglJkF5VrJU5pvZBRWIZvdidi8659HEeJiKjTa3agZ21tDRsbm0YPSySbIWUPYVvw93BGZmYRjqYX6eeyqrfkYFqbvBYiovZeprukurpmgUygSfuaqiotypKSV6atFuT2oTJXWFvo+YiIiMhiUze///77Wp9LS4Xt27drE/Unn3wSlmjChAlYuXJlm/38jLQcxGa4ws3JFl28HZFRWIqEnCKEeNRPyxw+fDiqpIQcERHVU1RQBGdXBxSVVcHeCSgsLoetjTUSs0tQVlGFEA972Ng54lBKDrr5uPAdJCKiTsv6VIqx1DwkHfI///kP5s+fj59++snsL3D16tU477zztNWAzOb+8MMP9R7z5ptvokuXLnB0dMTIkSO1KaElqSotR1FxOdILypFfUqn3/Xk4va1fFhFRu1NVVoaiwlKUlVXopFhiTjEivZxQXF4JextrXdET+1Ly2vqlEhERdYw9eqNGjdKGgOZWUFCAgQMHajDXkK+++kpLmD7++OPYtm2bPnbq1KlITU2FpXC0qUJ+YRmKSyW9qFTvKy6vQGxWYVu/NCKidsXB2tBLr6y0XIuyiPjqsTQ1r0QDPQkAk/NKEJ1R0MavloiIqJ0HelIp8vXXX9feReY2ffp0PPPMM1pQpSGvvPIK5syZo00IpZn722+/DWdnZ3z44Yen9PNKSkqQm5tb6zhd/q52KCwsNfR+ypOPlbo6+fuBVKyPzar12CNHjujrl0NuExG1Ny0xjhr5OFppIJeXV6KBntzenZiHKB/Dql5FJZBVUIxda//Cqx9/je+2HEFWoWGCjYiIqDNpdqAn1Su9vb1Nh3zu5uamgZV0fm9NpaWl2Lp1KyZNmlSrWIx8vn79+lN6zueee04bHhoPaXx4urr6OqG0tAJ5hYYiAodSC7VogK21FTYcz9KG6kZZWVkaOMsht4mI2puWGEeNuvs7oyivCJWVVSguLtO0eLEpNgsVlVXILylHVk4hNv/1O2L37URKcRV+3p+Cw2n5ZnsNREREHbIYy3//+19djaoZWPn5+eneOAn6WlN6ejoqKioQEBBQ6375/MCBA6bPJfDbuXOnpoGGhoZi8eLFGD16dIPPOW/ePE0FNZKZ6NO9SBkY4Yl1KZnIziuBq7Ohme+RtEL0CnCBq4MNvt+ThAndfBDl66p7EY3vo9wmImpvWmIcNeoX7olf9uagvKxcUzht7Wzh7GirmRJBbg5IyC1BuJcdbF18YOXqg4pKK5SUV2Ll0QxkFpVhRJhnrXMYERFRR9XsQE+aeLc3y5cvb/JjHRwc9DCnvhE+KP07BSUl5cjOL0FJWQVc7G0Qm1GMYE97LSCwIjoDlVVAj5AQZGZmmvXnExG1ppYYR40GdvNDVVWMBnqlpbawtgLyCsrg5mqPtNwSfcze7Cr896XnsPF4DpJzS+BRWQ5PJ1vsSspFdlEZxnfzgaMt2y8QEVHH1qRAb9euXU1+wgEDBqC1+Pr6au++lJSUWvfL54GBgbAUvbv4orS0TNo9oaiwTGeTk7MLYWfjgpiMEgS528Hd0RarjmZo499BIR5t/ZKJiCxSVIgPqsrLUV5aDjhLCn85pCGNh5s9YjMLcWZ3HxzNKMKbfx/HjSND0dPPBRuPZyMtvwy+LrY4nl2Eb3YlYnSENyK9nWHN1T0iIurMgd6gQYM0ODlZfzd5jKRSthZ7e3sMHTpUq31ecMEFel9lZaV+fuedd8JShPi5o7zYsA+voKgcfcM8EJNZhIqyCng42iI51xD8uTnYYFNcFtbsOYwe1jkYd+YYODnV77VHRNRZ+Xm7oqq8FBXl9qiqqEBhYRnc7WxRXlYJa1treDnYwsUWSE9Lw6K/0vDKlaMxvqs3NhzPxt9HM+HpbFjJ++tIumZWGAM+IiKiThnoxcTEoK3k5+fXqj4pr2XHjh1aCCY8PFz3gVx33XUYNmwYRowYgVdffVX34kkVTkshq46SZlRRUQkbG2skpBfC1dEWB1MLMNLZHmn5pSgpr0DfIFdUlpdh6def4r3ow3jgMQ9cfdawtn75REQWw8PVERV5WbBxckVxUSmsbGw0fTO/qAzubg6ITi/AFWElmHrb1bCCFXr4foN7LxiDcV290T/QDYu2JyKrsBzujjYoKK3A8sNp6ObjrHukwz05sUZERPVt3rwZH3/8MVasWIHY2Fj4+PhoaznpDNCjR49aW9zkcXX17NmzVv0Qiwr0IiIi0Fa2bNmCiRMnmj43bvCX4G7hwoW47LLLkJaWhsceewzJycm6+rhkyZJ6BVraWlVFOfLziuHu4YSEzCL8a3IUvtqRiI2xWRga4YWkvBKUlQOuVaW6uhcR1QOJFc6IySzkbDMRUY0CYLaoQGVJMSrtbE3lo8vKKvX24dQC2IRaozQ/Bw6unticXoHcYgnsbOHlbIdbRoVh0/EcbE/M1VR5N0cbRGcU6jEgyA2R3i7wc7FnwRYiIjJ54YUXsHbtWlx66aW6TU1ijgULFmDIkCHYsGED+vXrZ3qs7FF///33a09Seni0j2IsRvv27cPx48e1xUFN559/PsxpwoQJJ00ZlTRNS0rVbIhVeRnKyyu1Spyzsz12Hc/GlF5+WLI/DU62hgpw2+Jz8PTkLgi/5x4czi7Xmeo/DqUiyscF47r6wM7GbP3tiYjaLSc7axRWlpu2ChQWlcHe0Q521lYok9Y1fhGIjT6M19enILHYCt/sTMJlg4M1VVPG0TMivTAg2A0fbY5Hcm6pVj+WY1dSnh4+znYYEOSOCC9njrtERARZaPr8889125iRLDb1798fzz//PD777DPT/ba2trj66qst4l1rdqB39OhRbV6+e/fuWvv2jOWqW3OPXntiD0NjXykcIIHeltgsXDUmTAO9/cl56BPsoTPK721JwdVDgxHsW4kVRzO01150RgEOpBZgWJgnRoR5cKaZiDo1dydbFJRXoKqyCnLmKS4p10CvtKwCVjbW2JlchOFjInDeECe8vzEeq49mYUtcLqb28sX0Xn6wt7WGm4Mt5p4Rge0JuVh/LBsZ+eVwsreGo50VMgrLtBKyrXWmBnz9At3gwCqdRESd1pgxY+rd1717d/Tt2xf79++v9zWJh2Qrmbu7O9pSs5eI7rrrLkRGRiI1NRXOzs7Yu3cvVq9erXvkVq5c2TKvsgNwsoVhn165pBdJU98KbD2aDXsbK2QUlGFMF0842lojNrMI8/86Chtra1w+MFgvRiSItre1wq6kHHywKQ77U/JQeZJVTiKijsrf3RFVlYZG6TZWkrZpaFmTW1Cm9329PQmbjmXpyt0dZ4Qj2N0BhWUV+H53Chb8fUwbqwsZW4eEeuCOMyLwfxO7YnxXQ9+97KJylFdUobyyCtsSDOPuO+uPYUNslrZnICIiqqqq0kr/0gWgpsLCQg3wJF1TaorccccdWnOkXazorV+/Hn/99Zf+UrJXQo4zzzwTzz33HP71r39h+/btLfNK27lANzscyCuCrZctiovK4ehkh7dXxWDSgADsTMzD4m2JeGpGT7zw+178+NZT+Ost4M55T+OiEd1gbW2FVdEZeqFShSqsicnA0kNp6B/oju6+LgjzdOQqHxF1GqG+Ltiekq23i0vKYGtvB3cHGyTnl2oWRHFhHqZPnYLyjDjs27EVz0zvoS0WPtoUr6mZ/1l+RHvpRXo7IdzLUIBFvm9QiDsGBrshPqcYB1IKEJtdoJNqdhJNSquh5BysP54FF3tb3c8nqZ1B7i3TL5CIqKMEQ4XFljNB5uxoZ7Zr5kWLFiEhIQFPPfWU6b6goCA88MADundPOgFI3ZC33noLO3fu1AUxSetsTc3+abIU6ebmprcl2EtMTNRKMlKw5eDBgy3xGjuEXmGe2LevEGWlZSgosIKPuwMKyipRWFgOB1trHM0o1Apw54SW463ta2Bj54D1x7OxOzsaYyO9cPngIE3hlIsVSY6V2evojHzsS8mDrbU1evi5aNAX4uEIGylBR0TUQQV6uwKlKagsLUFxoQ1c7e1wIC4bHp7OyM4uQpRHBVYfM6TSvLrsIF68PgSju3hp1sTrfx/TPntHM+L161Jxs0+gKwJc7XUc9XdzQJinkx6AL8rKK7ArOQ97kvNQWlGpe/kkK0MyLLYmZMPGyhpdvZ0xIcob9jZswk5EVJMEeb7n/9di3pT0n+6Bi9M/++xOlVTQlJW60aNHa4FII1n4qunyyy/XqpyPPPIIvvnmG/3cogM9qSojUamkb44cORLz58/XjYnvvvsuunbt2jKvsgMYEBWAb3ceRElRCZydHRCfmgcvLxesP5KBCf0DsCcpD9vicjAqIgR2VWVwcPZCD19XxBVXYWV0ps4wy96SWQODEJdTjC1x2Sgur9T9JOJIRr6mGJVVAH0CXLVJsFy0MOgjoo7G3dUJqChDZUkhKuwdNAW+tLwS/m72SM0rxbjIAPzkFwwbZy9szajEr3tTtPjV4FAPPD4lClvjc7EvOR+xWUWmiptGEV6OGB7mieHhHghwc4CdrQ2GhnrqEZddhIOp+TiWXQRJwpefK45lF+LDTQWacu/v4qATboHuDho8sogWEVHHkpycjBkzZmhqpgRv0kbtRO655x78+9//xvLlyy0/0Hv00Ud1c6GQpcpzzz0XY8eO1X4SX331VUu8xg5hRO8wVJbtQmWFE7wcrZFWWAEPBxvklFQgMdNwkbF0fyrO698fubm5puVuSTP639rjOJJeiDf+PqYz0pN6+OLsKD+4ONjgSHqBrupJ0OfpZKv7Sg6m5WNrfA5c7W0xJNRdUztlxlkKEBARtXcebk6y6Vnb1oiK8grAyhpRfi4a6K2ML0PSkf34cMNx/Lg7Ba+tjMGXWxNw0+gInNHVC128nXHxAOh+O2m1kJhTjKTcEhxOL8CxrGIcy0rGN7uSEe7piGHhHtpfTybQjCt9MjYXlVXoBNzupDykFZRUT6pVIbWgGAm5RSgpr0RZRRV8Xey1crIEoV5OdvB2tmPwR0SdhqRKyiqaJb2e05GTk4Pp06cjOzsba9asQXBw8Em/x8nJSeOkzMxMtLYmB3pSbOWmm27ClVdeaaogExUVpUuX8sK9vLy4T+wEenf1R2VxIeDqiWNJOXD2cEVaViE8PJxwODEPAX4uWohl5rubce3wUFw+NFjfz4HB7nhsShS+252iPfWkcMsv+1L16Bfoisk9fXHl4BDEZRdjXWwmClABb2dbeDnZoKS8CtsTcjTdU/afDA11h7+rg160SFBorhxlIqLW5Fkn0JPUIAcnB7jYWmvz9L2JeRg/fzVentUfTnY2Wt04Ja8U//njMHoFuOLaEaG6uufpZIcpPf/ZRJ9XUo6tcTnYHJeD/Sn5OJ5drIeQSbahYR5aOKunvyuc7W3Rw89Vj+KyCs2oiM0ypODLnj676hneiqpK7E3NxY6kKk39lMLUUmQrytdZA05fFzsNADkeE1FHJGObOVIlLUFxcTHOO+88HDp0SFfn+vTp06Tvy8vLQ3p6Ovz8/GCxgd7AgQN1c+F9992Hiy++GDfccIP2uBNSUYZOzNvDBbalBagsK0UZ7GGFKuQVlqFPqCeOZBYhM7sYPp6OKCotw3ur9mPL4TjcNK4Heod4I9jDEXeeGYHyikosOZCOA6n52Jucjz3Vh1woTO7hi/P7BiIxt1j3kmQUlmpap6PdP6t4RzOlTUO+XojYW1ujZ4Arung5IcLLCa4Orbs5lIjotFb0Ksok7QGoqjSs6AH4bXsCnrpsIB77fg/KCguxYOkOLLzpDFwyOBgfrj+Ovw6l40BKPh7++QB6+LtoOufQME+EeDrq90sANiHKRw8J+qS36e6kfMRkFGrLhbUxWXrIFFk3X2f0DXTVNM1gd0dtfzOmi7emkKbml+hYLJNzuSXlOtEmh/T/M5J0zyMZBSirqERVlZU2bvd2ssegYHctEMO0eyIiy1FRUaF986Qo5Y8//qh78xoKBMvKyky1TIyefvppzQSZNm0aWptV1cm6kdcpF/r1119j4cKFulwp+/Qk4JNNiCEhIeiIJI1ScnBlqfZ0e2F0P/cpJFS6wc7DF7Z2tnDxcNH7R/TyR3R6oV4ITIuswnNzDE3nxzz6JaYM7YFZQ4LRzbf2fju5kPjzUAbWHM3SapxCvj46whPjunlrOfG4nCJNScosKkNOURnq/oeWEuN5JRUoLa9CpI8zxnbxQlh1BToi6rzMOe61xPMt/XsvLvjX24BPKGw9fGHn5ARXT1f9WlSAK+4YYYdLzjlLP796/re4++KxGBrhhdS8Eny5LRHLD6RpuruQYVXG1xERnugb5IaBIe71Uiul8ubhtEKsP5aFzcdzdLKsLhm/ZZUuytcF3Xyc0NXHGR5OdrqKJymimYWlyCosQ0p+CbKKyrR1Q0PklFxRBW3+7u5opxkYoR6OmgLqaMdiL0TtibnHPksmQU5MTIzGBo6OhsmzjuTuu+/Ga6+9pit6s2bNqvd1aZAeGxuLwYMH44orrkCvXr30/qVLl+K3337TIO/XX3/VbgWt+X43K9CrKTo6Gh999BE+/fRTrbw5ZcoU3HjjjbjooovQkZjzj3T0lfOxI60KNi7usHFyxbBegTicXoRgLycM7+WPvw9noI9rPj6//wJY29rjjMe/gaOnIa1IqmwOCfPArMHBOhNtTPOR2eO/Y7Lww+4UnTk2kmIsM/r4o3+Qqz5WLlRyi8u1mMDRzEKk5Zc0GPjJvwYXe1v08ndBL39XUx8/Iuo8LD3Q27DzKCZe/wqsfENh7eoFG0dnXDmxO7Ycz0VKTjG6OeZg5cvXA9bW6DX3Yzh6BmJkVy9cPSpcP8o+vt/3pWhBFimEVZOHoy0mdPfFjL7+6OLjXO9nV1ZW6eTZ9vhcHM8uwvGsYqTll5om3GqSbAsJ+KQFg6TN+7vaw8/VXn+G7OGTgC+9oBTxOUV6u6EA0kjGZgkmZa+1q72NriK6OdoiyM1RU1CJyPIw0Os4JkyYgFWrVjX6dQmnZN/e3LlzsWHDBo2NZBVQtrldddVV+L//+z/Y2ZlvrG7xQM9Ivv3bb7/FLbfcor+g/FIdiTn/SM+/400sO5ALKwcn2Hn4oFugO4psbFFQUoEFs4fhyV8OoKS0DF1tM9HD3wETxwzH5sRC3TMiFwVGPf1dcO2IMC0SYAzC5L/D4fRCrDmaiXWx2aaGwFKIRdKLJBVocIi77lcxXqwcSs9Hcl6JHpKm1BB5dm9ne32eCE9nLSRgW2e2m4g6FksP9A4cTcbgi5+BtU8w4OwOWxcPXDgqAjdN640rF6xHaWkp/KpScdnIYOS7dcGfB7NMK2i6gufvimtGh+GsXn662ibB3s6EXK18nFn4T7+nADd79PB3xYBgd/QJctOAraE0d22am1eqqfFSwVPa5STm1J9MM5KWOjIuS+p8dz9DWxx3R1t9Hgn2jmUV6X4/Wf0rLK2AjZUVbKsrfDZEVv9kxS/QzVHHak8ne60Iykk6orbFQI9aSqsEetL4T1b1JNCTBoBSMvTtt99GR2LOP9Lr5n2ErzckAHYOsPcJ1Puumtwbv2xPxJAuXjh/ZBgW/Hm01sWBnNpHdfXCgAhPJOSWYOMxQ5NgMTzcE3eO64Igj9r/gSVFaOmBdG3LUDNAlFVBSS2K9HbWpsBycWGsxCn7/6Rtg+wpic8uQn5pBeRLNS8UZFVQ0jwl8JPeU/0C3bi3j6gDsvRALyktB12nPAJ4+MPK2V0nzroHu2PLyzPxw5Z4PLZ4N7ILyzC4ixeevWwAXBxt8eWmeCzfl4aMglLT88ge5qtGhmH6gEBE+jrrqtmW49n4fV8q1sdkNRioSZq7rNINDffQ25Lubt/A5JdU5ZS9fVJkKyW/VNNGU/NLdTWw7llXRtku3k662icBm+lwtYO/i70Gf4fSCnSMlsBUfgdJ1ZeiLw62jQd0EiDK7yh7/zycbOGnz+ugQaU1MzWIWhwDPWp3gV58fLzu0ZPj6NGj2lpBUjYvvfRSLR/a0Zjzj/Tu57/GO7/vA+yd0KV7VyRmFeP+iwfi3VWx+nVJ4bx2fCQc7W2x7XgO9iXm6p4Oo77Bbnh8Zm/8sjcVyw+maeluVBcFkH0lw8INe0yMq3b5UkFO0ouyirAzMRfpBf88V82LCx8Xe52plhU/+VwuACSokwuUnUmGGW4JBK3rNGKXVUO52JA2DqEeToj0cdI0IhYRIGrfLD3QKyouhffoewE3H8DR1TRxNmNYKJ69ZhhkfuuCV/5GblGZaQVthBRZ6eWHQZFe2BaXi2+2JCA9v7TWRFiwpyP83R3RJ9gNPQJc4e1mj4OpBdgel4NjmYb0yrqc7WwwJNwD3X1dNNWzi4+T9t9rLJCSsVT69+1PKaieWCvWALAxspAX5O6IUE9H3asnbRq8pUqnNZBdWI6E3GItviV7DuW5Jfhryhgsr8+hOg1Uqn4GuDroeUD2BXIlkMg8GOhRuwn0pAjLhx9+iD///BP+/v5agEUKsUjuaUdmzj/SJ9/8Bc9/uVEvTM4e0xdrDmXBzckOl07ojlUH0pCeV4rS/Byk//gI7FCOv1auQmhoCL7dmoiP1x03Pc+ISC+M7+WLHYl52JWYi5p7+uX83tXXBYNC3DE+ykcrawqp7HY4rQBJeSXYk5Svs8MN7QeRqnDG/SSyv0SCQNkLEuXrpBc52xNykZRbjKLyinoXMhIcSh8/md2W9KZANwfd5ycfeeFA1H5YeqAnpy2PEXejzMENcHJDZFQkErJL9GueLva4cawvXr7nMpTAASGz5qPM7p8KaDJsXXtmFzx6YV+si87E5xvjsCchF8Vl/2Q/GMkq3y3jIzGhly8cbG104m1/cp62Xtgen4OknGItaNXQOCrp8p7OdvB0tIO7k60GazIR11BFTdnjJxNysl9PjrSCUm2lI/cbi8Y0RFo+yMqfrATKIW1z7K2lgqetjvkZheXIKirVsV6KwhjaPlidcDVP3lsZr3U/oI21rgi62dvC19Ue7g52Gtg62xuOhlYyiegfDPSo3QR69vb22gVeVu/OOeccs1WN6Ux/pK9/9hce/N9ywNkDl0/qhxVH8pGVX4phUb74+dFJeOfPo1j4+zrsWnCjPj7wqrdw5yVj8cgFfbEhOhPzlxxCTLqhuboI83bCrGEhcHG209W3Tcey9OKgppFdPDEm0hujunjBy/mfTaDyn10Ct0OpBciTtKDUAm3829hFhRQRkBU/mVWWQi9y0j+Ulq97SWQ2WvpI6RJhHbLqV1RWqRdJkjYkz+PjbK/lzGUWmYgsj6UHeiL8rIeQVmwFuHjionE98dC143DHO+uxMyYTJTnxKPn9YX3cpk2b4BXWCyv3pWL53hSsO5Su93f1d8H5Q0Nw+egI+Lnb43hGkaZXyse9iblYfSgdOUX/7F2W4CnK3wWT+/iju7Sm8XWGt4s9Dqbk64RbTEYRYjMKEZdVhLJGKmoKWUULdJfVM0fdA+jn6qArgAHuDpqdUbPip4zTklEhfVKlOXtCTrGuQkogmF3jtTVEYjkppiWFX4xFYNwdbDVwq6pOLZUCXgWl5VrUS+47WRBY73exsdaVUKkuKj9Lnl8+ujjY6kph3eqlRJ0NAz1qN4FeamqqruR1Nub8I/3spw2Y8+x3mm50Rv9QvHP/eTjjoV9QVFqBd24/A5eP7YqDhw5j4OAhqLCyg8+lr8De1Rt3T++B68dFwtvVAbHpBfhsfRz+OpBmSuuUC5CFNwxFVz8Xraa5OzEPfx5Mx+bj2bXTNH2cdUZZqslJOfG6JO1HVvyS80qRlleifaMkJUhSlyRYq2lUhCdGhnuYSogbLkhKNfCT55DXJqt+dcnjJJaU55NiAbLfL9TDAf0C3bXQC1f+iNpeewj0Rl72HHYdTQc8/eHr4YRjX89FeWUlXv9lHx59bxlKlj8Ba6sqLFv5N84aNdD0fX/tTcE9n25HVo29emE+zpjYxx9XjolAn1APU+r75xvi8PXmhFr7+mqS7IpBYR7o5u+CCB9nhHtLoGalhVhkr3NOcbnuqZNDgsD9yfknXKGTMXB6H39NxZem7E72jbdTkBU6eV1p+YbKndJyR4I/+ShpptWZ/SdMCZXJP8na8HW2h5ezra7WSWwmcWpxRSXyist1v3ZxeYWeQ2QlUr5ua2VVL5W/4Z9hpauOLg428JCVTUdb3S8oQacEifJ8HPOpI2OgRy2l1apudnTm/CP9ddVuXHLfh4BXINyc7ZH8/d145ac9ePqrHXB3ssPn/zcBY/sY9pqIV38/iFd+O2j6fHR3H8yd2gNjuvvqbKykdH67NQHHM4t0VvXeKVGY1Mdfn0v+s24+lq0pmlJUQNI2jeTkemZXL5zTNwD9g9xOWkVTCrpI4+Aj6YU6syzPWZOPsx36Bbmhh58Lwj0d9SQu/Z6ksmdMlhQjKNQLkfzS8lpppg31jpJLB1n9k3QnSR0NcHVEsEfDle6IqPMGepfe8y5+WbkLjkFdNKNg1evXYETvYP3ai9/twjOLd+ptWVW6akI33DylJ/qEeWpgkVdUhl93JOLdv6IRnZJvKo6iY2NPX5zZ008n1xzsbAzZD4VlyCwoxbojmdhwNBPxmUW6ctdQYHNGdx8t0OLjaq9ZF7LyF+rlpGOiZDgk5xYjKbcEybklSJECLdVFWuT5pAVO3cBPJugMhVmMBVrsEeHlBH83h0b34kmFUQlU5fkkyJRiMPLzpMKypINKgHiyQFACVlkJlNR7+SivRX4H+ZGlFYYWEzIhWFBWoT9PincZG8PL0ZRAUKqFSmsIWQXUfYJuDhoQSpEw+RqDQGrvGOhRS2GgZ4F/pGu3R2PSDf/V3k9VsMKehTcjPMADM/+zDGsPpOpjBnf1wQdzz9TWC3KBsXhjHN75MxqHk//p9XTh8FC8du0QvR2dVoDL/rcJFdVXKnJylguDEV29MVJmm8M94OZopyd22Vfyx/40bIjNMj2XnIt7Bbjq7HGfQDft0ScpRCdK35FAb010pvbja6yEuOwVkaqechKX9CQJ3KTqW6S3k64SJubKqp8h/Uj6T50oW8jYKkIu2GTGWZ5TLjrkkDRQSRdiyweizhXo/d+L3+DNz1eie/8+OJyUh/suG4lnbppg+vr+uGw8+MlmrNqTbLrvotER+ODOsbWCkIKSck3n/Gr9cfyx+5/HRvq5YOrAIPQP88BZfQM0HbGm45mFWH8kE/uScnEsowjH0gs1qGqI/LReQW4Y080bs0aEapBWl+ypWy2BZGwW9ibn1SoU05hgD0dttyOTa7Iy51cdlMnzS8pmY4GSTMJlF0v1TkMFz/RCw6qgcV+gpIYax93GyBgvAWegm732XpWUVHlf5bwlhcJyiss0CCwpq0RxRYUG0xKYOtnKSl7tis6NkcfriqC9jRaJkd9Jin9JYCiTf3I/q4eSJWOgRy2FgZ4F/pHuj07CkEv+AxvvIFRY2+KGcwbizXumIb+4DPM+2YJFq6L15Cqzpp/cPQ5Th4SavjcxqwivLTmEL9Yd0883PjUZQV6GKqe74nOw8Wgmlu1NxeHU2qttMrN6/7TumDXc8FxyEpb9eEsPpGHZgbRa7ReM5IQtKZnDJT2zixcivBsuHy5kZVFW+jbH5ehMdUJOyQmb/sqJO8jNQVfpJBCUKnIB7vZwtrVBakGJ7kGRPSmy+mfse9VU8rtKsQCdhZYqdR6OpgqkRNSxAr0Fn6/A/S9+ixHD+mBTbB66BHpg3ye31Asg1u5PwZu/7cOvW+L186vHd8PLN4yEYwNpkXvicrBqfyo+XHlUV6uMvF3tMalfACb0CcDYnn7wqLHfuSbZ27clJktXAOX7JdsiNr1QV9dqjlM9A10R5u2sq3ODwz0xJMJTJ8Jqvnb5HmnPIKt/GdXBl+7Pq07NPNn4KKnxsv9PqoBKqr4ERRKsyj5rKQhzoiwJOQ/JhFxybqn28tOVx/zqn19Qaqr43BiJo2VCTlYDdUXQzdAkXoI9+RXld8suLtfUUEkLLa2s1GBYJvPqtvU5GZncdLGz1Z8n+8Al4NWA0IEtJKjtMdCjdhXoSTP0tWvXYsCAAfD09ERnYM4/0ozsfIROfAhwcDaUBQew5MXLMX5QhN6OzyjA5Ls/xIHP7tLPN23aiOHDh9d6jov++ze2HM3UVb3bJ0ehZ1Dt1xSTXoDDKfmaYrTtWLYpvejOs7rigsHBmk5U82Qu+zl2xOfiaHohdifmNlhIQE7aMkMss8fG1CFZBZS0z7qz3EIa/MpePQnYZLZY0oakIXtcVnGD5cmFnNZlv4hU/JRDKn128XLUGWqZJU+UIgS6AlhmqiBnvGhqLH1Jfj8rWGl1OJkFltXEMA8n3dNo7B9IRO0z0Pt5xS7MuvddDOwdhoM5tiguLceOD25Cz3AfbN68GSNGjDAVY5Fx9Ju1MZjz5lqtDtw/wgtf3T8RIT719yqLnMIyLNmZhO3HsrB6f6qmahrJcCP7+EZ288HIKB+M6Oat+6cbI6dYWSX7c1+qpttLFkZDpEhKgLujBoF9pUF7sJumfMoYWHeMk7Ett7gMB1LykZBdbFqFk+BSbtds+t4YyYiQSbxwL2fDR73tpAHTicjvI/v2JPiTImCyEig/T9NbCw37EU+WFiqrgVLZOcDVXtM1QzwMlZ7lPZD0UjlPyIqgVDQtkEMKxlS3+DGkhhrG/pMFhDJBKat/bg6Gc4AUz5EiMS72htVAFouhlsZAj9rdip482f79+/WJOwNz/pFWVlbCY+TdKC+vxJWXTcXnf+7Dmf3DsOyVK02P+WX5Gpw3eZzh9rLVmDFpbK3nkJnmJ77dY/pc0opunNgVFw4LrXfSk/+0L/9xBIs2xOnn8tX+oe4Y39MXo7v5aKP1urPIcgEhQdWepDxNIdqZkKuBW0Pk2kOCvy7eUoTASS8WZJXOuMG/ofYLciEgz68V5LJL9KOc2BtaWTQypGvaatGXYHfDSqCrg43h5O1gq7PCcpEje0ayi0q1xUNDFUCN74n8KPk95UJBVi9lBVXSPyUNVGafJQ1KLgK4P4Q6q/YQ6O06GI+Rlz8PH08X9Bw0AOv2xOO9+8/B1VP6NxjoieU7E3HLW38jPbdEL/IHdfXG/13QH9NqZE80lFK5/nC6Vu2U40hKfr3H9AhywygN+gzBX4BHwydd7U+aXqjBXpJU0swqwpbYrFrVlOuScUoCvqERnhge6aVFX2SFUcbZxgIVLdQi+/LySjTLQzIlJPsip6hMJ9wkOGuMjKsysSfjbK9AN1PFzhBPJy2mcjKSFirVPNOqf75xNVAOuV23sFdNMmzLxJwEoZqC6mpYDZSAUPbw2dpY6f5AKXKTaRrzDZN/eg6xqtK9ffK4pqR0yjlMisJI5oecS+T3k0BQ9onruaH6/CAfJWjkOYGai4EetbtAb9iwYXjhhRdw9tlnozMw9x9p1ymPICktBz+8eScuevInPSkaZ6FFUVERel34CFJySuAUMQz7/3cZAr2ca1XG/GV7In7amqAXHcb0nbP6+GPezD7oGVz7Ncp/3i82xeOXncnYn/TPPj8jCWjCfZz14kF6RkkKkVxUyD49OanJ98uJVJr6Ss8o2cORmFuMPYl5evFworQhuTCQGWIJACUYlBQiKSled3ZafobM3MpFgKQpyfPLHj5JMT1RhTojuSgwBoASeBpmh+01NehIWoGpEExZZeVJT/7GQFAuyOSxUlxBA1dne005ldln+Zz7Qqgjaw+BXl5BMfzP/D+9ffuNM/HWj9tM6fAyji5cuFC/dv3118PJyZDmLqKTc3Hzm2ux5YihzYL8Lb80ewRumNS9SRfyydlF2BSdiY1HMrDhSEat/dM19/dJwCdH31APhHo7w/UEQZJUXpaUzMSsYk3/3JeYh0MpeUjOKWk0RVMCD9mD3d3fVVtFdPNz0eqfTSlcJfsSpW+f6cgs0iyMlNyG91wbyX5r+XldZG+eu6ElRKCbo2Z5NKVJu4yvEpRp4CdBYH6pnkekUIx8PNlKoJBgTAqARfo4Y0iIu2HFztGwdzu/pELHe1ntTC8o099JUkNlYk8aSOiYXr0a2NwxXB4tK45+Lg7aJ1HeZy8nw6SgvAYJBhkIUl0M9KjdBXpLlizBvHnz8PTTT2Po0KFwcamd+mKuk3hH/SMdfcXz2HEgHt+/fhve+2M/ftsQjXtnjcR/5vxTROCnTcdx4xtrtLeRs4MNFj9wNs7sE1DvuTLySvDhqqN4Y+lh/Vyqbb5703CM6eHb4M9OyS3G6kMZWHUwHXsScmr1iKpLTl5y8SAndbl46B8iqUTutU7mMqMak1lo2IciFwqZhUjNK9W0m8Y28ssJUXpFyeqcXCjIbK2kg8oekroFCuSfphRqkYItMhOdVVSuFTxlVVACQ2M58aYFgJImJGmh9siRi4H8El0FlIsO+RnyXutrbsK5X4JzU6EAOxttJiyBoI+LnQaasjrIEz61Z+0h0DP10svKx7MPXomHP1ij+79+ef4ynDWkywm/T8aWY2n5eP6bXfhizVFTIax/XzYIE/oFwqYZfWJlHN4UnYGN0ZnYdCQDexNyTFU8a5Lm6YMivNA90BUDI7wwvKu3rvydqDqltItIyyvFvsRc7Dieg82xWbpSl1Ug6ZENj7EyrsrYHeVnGLul958UgmlKYCPVS2WyTVJApeiWjOmyMifj+olWAWUslMk1Cb5kMkxWAGU8l6OLt6Hi6MlIQCsBqKSFaruIPEPLCMNKYKnuGTzR3kCZXDSuAEogKCuAMiknr0UyNWSlUH4XOT9JQJhWUKLnQDkHSCsgWbmVoV3+c8gEn/wTMAaGTV0dlOwTQ+9CO1M1UePB7QKdEwM9aneBXs1G6TUvZuVp5HPZx9eRmPuPdOYdb+GPdfvwzhNXwcPHB5c/+T0CvV1x+PPbalWO3H0sExMe+U3TEId288GfT09vNHiQtKInvtmD/Ym5eqEzrpcf5kzspiXCT3QRUVJegYSsYhzLKMTxjELsSczFwaR8XblraBZZTprjevhq+XC5eJDS4bYNXBBJwCSrc7LfT4oGHMsqNHzMLDphiqbM1BpW5By1PHmUrzOi/Fx0X0VjZO+GVP6U2WApBCOrgXK7sQDQqvrnyO8i6aB6MVB9QeBTfVEgq4hSEVSCSWM6qNxn/Dd+MoY/KSstEmBIOzWkHUm7CAk+3RzsmjT7TdRW2kugN+7al7B5dyw+eX42Plh+CKt2HIePuxO+ffpijOwT0qRJmwW/7cML3+5CfnVrg66Bbrh1ai+M6OGH3qGeDRZtORHZ3yf7qDdGZ2BzdAaOphbU6tlXkxR1kf59Z/cNwPg+/vB0bnysq/W6q6oQk1aA3Qm5iE4t0FRQ+SirZA2RFbcega666icTduN7+J6wR19DpIBKdHqBZlrIvkBNy8w1tIc4UYN4LT4T4IowT0dEeDujd6Aronxdmh34GPcGZhaUaQC48XiObgOQiTppI3Gy2l2SiilFWmScl2BYgj8JSg2Bob0GinLukp8hwW589XPLaqtkhBSVVek5U4JvCfzk8TbVaaLyO56MBI9yTpCgTwJSeR3GRvNynuDkYMfEQK/jWLlyJSZOnNjg19avX49Ro0aZPl+3bh0eeOABbNu2Tc95s2bNwrPPPgtXV1fLD/RWrVp1wq+PHz8eHYm5/0jnPPYpPvt5I56aez7uuuZsdL38TWTkFuHJ2ePwwJWjkZCQgCFDDK0TvluyGjNe3KSzwzdO6oFHZw2CdwNluYXMhD79/V58vtZQlVPIiVxSiCKrU3u6yG0/V/QL9TjhxYvMbMoqXXRqPo6kFuBQSj62xmbpLGjd1KFIP0Pap1xI9Atx10OqyTVETqL7k/N0hlZW5TR1R4oH5JXgaEZhoydqKc4yONQDfm72CPN00mbCcoI8kZoBoKSBygWBpPFI8NYUEpjJyqOcjI1FC/xd7PVELTPCWvggv1QLBuiKYEWVXojI+f5EJ2y5sJSLImOpcUn3cbYz7A2RnxXg5qi35WjKxQNRZw70rpv3Eb5eshX/ufsC3H7FBJx192fYfjgFxcXZsN/+DlwcbbB75w6EhJw46EvJLsJz3+zE9xuOIbtGUCYX9D2C3TGmdwCmDwlFjxB3BHk5a3+95pAg8mhqPrZL64T4HOyRIy6n1mNkPJDCLlJoS8bpAeEecLJvXv/QvOIyU+AnY/fRtAJdDaw7dkvQoat+/oZMiq5+LpjWL+CUVp0k6JSiWxL8SZVQWY0zrAKWICnHUFilLvldZeLL19Ww+idZHfLRWCU01POfVNumkIlJyTCRVFA5p2hxmCJDcZimFqeRsT3c08nQqsL5n8k/YwEyYwVn2f8oP0POL7IXUQJgKTYme9m1gmiF4TxgWyMIbMrEnlaNlv6xzoaehXIOklVBCQKb0pOQLBMDvY4X6P3rX/+qVyhx2rRp8PU1ZNPt2LEDo0ePRu/evXHzzTcjPj4eL730kn7v77//brbXw/YKFvpH+uhrP+Llhctw51UT8eL/XYz3f9mBua8thZ2tNVJ+uBt7du2oVUTgj1g7zP9ut37ePdgdv/17CvxPcBLcdTwbC1fF4Ict8Y3u7ZAUIlntmzu1O3qHeDTpdUvwJ6lDf+xNxf6kXL2QKG5gU72cjsZE+Wi/KLmQkH1/ciFxstlKKRQgwZhcLEhwJqt/8jPisosaDADlJNjd30VnZiXts1v16t+JUmzkgkQueLJqXATIx+zqj7Ii2FhV0Jq/nxSCMV6YGD/KiVlmi6VHlOwNlBlneX65EJCTvyEr9MQrgto0vtJw0SKH/C6GHlKG0uE+1UVu5HeXIjqNtbwg6iyB3pNv/oLn31+Cmy4+A288egWy8opx///+xMJv/0DFptf1MTc+8i7ef2ZOk55PWt18vioaP2w4hgMJOZqWWZebkx3uPr8vZgwNQ2SAW7NX/GqmScp4/eeeFPy5NwWH6uyhlnTH8b39MGVAIMZ090Wwl9MprfrIzzmQlGcK/lYfSkdidv391cGejpjSxx9RAa7oHmBY/TvdzAMZ02T/nVR0lvRL2TMt/Vwb6zdoJOPbyAgvHVu7+jqju5+M9Y3PWJ+MZJLIz5RMDwlEtWG9caIx35CxcTKynUHGe5l4lP6BEgiGezrqmCyrhTV/Z3k+Y9Vp6VEo5xUpGibBYEmF4XwggaUUjmlKT0FjWwo7aykOY1iZlFVBqU4tk55y3uGKoGVioNfxAr3FixfjkksuafRx55xzjgZ7Bw4cMJ3v3n//fcyZMwdLly7FlClT2kegV1hYiOPHj6O0tHZKirRe6EjM/Uf6xqIVeOClb3HxlCH47IUb9KQQcvHreoGy8e3ZcK7KRb9+/fSxe/bsQbdu3fC/3w9g3qdb9D5PF3td2RvbJwDhfq5wbmTjvQRm8RmFmjYUk5qvq3OS6nMoKRfpeYb/ZnIOH9XdF31C3NE72B29QtzRvYkXLhI0ycXCkdR8LT0ut3fE5TRY8EVmQrv4Omuqp5wUpcVDuLezrgbKxxPNIkvazMZjWVowQE7IB1PydT9gQ2SPnFwMyIlYfo6kCkmQKSdkmSmVVM2TnQwlwJKTsfw8WQnMLDTMTh/NKNIGw035a5GTvnGPSM8AFy3iIq9BTs5CLjTkkAsPSQmSi4Km9gyUFUFjICi/iwR7MuNrTEeVPlLeztKg3rZJ+2KI2nOg99F363D7059j2pl98f0bt5nu/3nZOlxwzkT9e7EedTcSfn5MU+SbQ8ZmWenbGp2h1TpX7E5CfHqBjq1GUmDl4jFdMHNkBM7qH3RaF9vH0wuweGOcpuJLKn1ynWBM9vMNifTSPn6zRoWf1p6v1NwS7EnI1aqfsnd72b5U3QtYkwQihmqfXuge4KJjuKz8ydh6Or+nvK+GxuyGIMvQn6/6dl4JotMLGxwPpbert4udpn3KBJ+8Nknzl9dzOoyBmYzHcdmGgmOyH1AmBDOkkXy+FPM6cSaIjMGB7oZWETLea6Ga6h6CNYNAI/k3JJVD5WfKz9EqooWlyCkx7G837hU8WYZITZJK6mIv+wMNewRlT6JMEMredLaRaDsM9DpmoDd16lQt8mVra1vvv7ePjw/uuecezJ8/33S/xEpy/2WXXaZBn0UHemlpaZg9e3ajy4/co3di3y/fjivv/wAj+nfBqk8MFePOvmeRlgZfOO88XHZWnwa/b1t0Bm7931ocTPgn3UeKr9w8tSdun94bPk2c7ZSqnVIp7tO/Y/H7jqQGH+Pn7qDpl3Jh4eVqj27+ruge6IZewW4IPElKjaQKrTyYhp1xubr3T4LAxooGGNNVpFDA4HAPvaAY3c37pBcwkpYpff9kD6Cs/kn5cNk3IimUJyIrcZL6KW0levi7oHeAq1YGlXLiTTmZykWjnPDlxGwM1owpnHLCNhaJORH5MXIiNqbm6Ec5HG21J6HhosBQnlx+jnw0Fotpyh9qzVVBebzMADvbywyw4YQvF0byM+UigJVDqb0Hekv/3osL5v4P/buHYNPX8+p9fdzcT7D5QJIGeX+/eS1CfN1O6+fJGLB4bQzeW3YQB+JzkFdjZWpi/yA8dPEAjOrpj9Mlf8f7EnK1l9+Kfama7lmzwJWXiz0m9PHXJu7je/vrueB0SEbFkt0puvJ3ODUfh5LztUhJQ2RSSQI+OSRjw3jbWKn5dMkK5O7EPOxJytUVuEOp+TreNzb+SUAqY6m0+JGVv8m9/HScM+cKl7w/xuD0eHXWiXwuGSeSqnkiMt5283HG4FB3nYiTVUFZsTzZ+Cv/vfNK5LwiAaEUkTGkiBoKiJXrOUFSOm2aEAxKwCgTrp5yHpBiOS72GgSyqXzLY6DX8QI9V1dX5Ofnw8bGBmPHjsWLL76oHQmE9Bo/88wz8dVXX+m+vJrksbJItnXrVssO9K666iocO3YMr776KiZMmIDvv/8eKSkpeOaZZ/Dyyy9jxowZ6EjM/Ue6bd9xnHHVfAT6uiNm2bN6352vLsEHv+7Eg1eOxhOzDT30GksrevzzbTrDfCA+W1e7hIOdtRYNiApyx9g+gTijtz+6B588JfNAYi52HsvWIi4HEnL1Y2NFA4zCfZ018BvcxUtnl6WK3IkuMnRlMatIe0fJx6zqk+Wx9EJt7l5374gEfiHSksFHDlkFdNZ9JIPCPE54MpP34lBaPrILZW9esc7ISiCoK2eFhiprjf1Dl+DKuD9EKsfJBYucDGX2WDbpS0pTU9MkS40pO4WG9CCpXGdsJtyURsI1Lw5CPRx1FTKoepVSeknJf2vZj5lVLGlBhplgCXwlNelEAXXNiwc9pLAMrPTkL8UApFKonPhl34yPi4P+XAaCnVd7CfT2HE7A8FnPaS+9+BUv1Pv6Z3/sxpwXf9Pbw3oF4bNHZyIioGnp6icjp85Ve5M1zfOzldGmlb4zevnj2WuHYVCkoWWOORSVlmPX8Ryt7rlwdQzScktq9zP1ckK3AFfcNLGbBn6nS8aI5Jxi3Z8tKfuxGQWISStEQiOp9EImj2TMlkIv/ULdtem7bBMwB0mBlLRPmVQ7rB9LDAVhGmkHIa+lf7AbIr2d0TfITauB1q3qbA7G1UAZi5Oqi9Pox+pWQY0Fy5ISK2N8pLeTBoESmMrRlKyTmj9btglI0Cntj1LyDVsP5Bwkzy+nLOkRKPsET0TObZKWKquPXbykaqrsRWc2iLkw0KuuoF7SeIX01uZ8ipXRpcDKK6+8oqmZsh9v3759uveuoKBAvzZ48GB88803uPTSS7F69WoN7GqSwG/NmjVISmp4kcViAr2goCD8+OOPuo9MTthbtmxBjx498NNPP+ky5d9//42OxNx/pOlZ+Qg76yG9nbXhv3B0sMOC77bovpKpw7vih2cvbfLM8q9b43T/3q7YzHpfnzIoBP+7bQx8m7GvQf4pSMW4uMxCxMmm+uoy29IgWHpFHUnOq3eSlxOKpBJJr6jzhwY3ec+f8edJhc/tx3Ow/Xg21hzKaLRqXKiXIwaGeaB/iAcGhHmgZ6BrswIR2UAvgaacFKVh8IGUfJ0pbsomfbmQkpTQUE9H08Z8SRcylhCXIKwpqTHGRsIS9Ek1T/1YHQTW/PxEaZySniMnZKlOKq0jJEVIXpMEhTKzLTPPxlVHwz5BQ/VQ2SfY1D90TQ2tqNL/trKHRFZYtaGwvY0GvlIR1UMqxbGpfIfVXgK9zJwChEx4sNZ4WneMkRY21z77EwqLy3RFfWC3ALzzf+dgQLfTD4iMDifm4JUf9+Dz1YZWDWLGsFCM6O6PcX0DMbirt9lWmCQrY2tMFpbvSdb9fXUbuPcNdcfwbobm7cYWDuYiq22SqSGZG0fTCnE0XQLAAhzPqJ+5IePm6G4+mNbPXyt9yqqfuUmavex9kwk9KQSzLiYT2+Nz67X3kXdeMjn6BLqiT6AbhoR56Bja0qRQi5xzNh7L0Y/p1SmhjQ3x0p9P9t3JtoPh4R6armosAtNUsq1C3heZ3JR+gsY94/Kz5T6pGnqypvLyn1LOJxIAGlcBJRtGMkNYMbp5GOgBBcVlCJ79JSxF4keXw8XRPJNQR44c0S1r48aN0/Zzn376Ka699lps3LjRVG/DSO6XWCk7O9uyAz05Se/atQtdunRBREQEPv/8c5xxxhn6w/r27avLkh2Juf9I5e32HXMfCotLsfuHxxAV4Y99sWkYOudDvQh5+ZreuP3amaZiLHUr+zT0fIcTc3EkKRfbYzKw/kAq1h9M1Qv1AE8nTB0cgvsu6Icu/qeXsiRScooRnZKPg0m52BaThW2xWRoQ1iQzy7LaNzjCE4MjvdC/GeXJ5QQle0fkQuKfowhbYrPqtWWQE5C/uwP85ATk5aRN38N9nNAr0A2BzTiBy+ynzBL/s1+kRGeJpYeTrMBJ4NnYrGxNxpVAWRU0luyWvSQyk9ycvTTGhsKyV0Rej3FlUCq8SfGAxoJAOV1LOpDMEssePVmZk+BPglMJDGW/nvyusvon6T+mqnRFZSgsLdf0I3n/m0Nea1V1BT8HW9kPYugnKGlUsvro5Xx6e3mo7bSXQE/+DXqPvhfFJWXY+9Pj6Brmp/dv3ry5VlErR58IPPj2X1ix3VCVWFLe7rl0hGZQ1Gxrc7qOp+Xjqa+2Y/Ha2Fr39w3zxBNXDMGUwSdv+dBcqbnFOJ5eqBWXv9kUV+/rkoExqrsPhnX1xuT+gaed5tkQWc2MyyzSfdoyXkvDdxm/a+of6o7BYZ6630+qM3fxNX/gJ+RcIQHowdQCHE7Lx8GUAt1zXZOMStLmQYK90ZFeGBbu2eyA6lRJEKrnFtlznlqgbRxkRU7OPXWHd3mdEuyFeTnq3j9jdodsQzjV1yv/rWTyT/ZFxuUUI7OoVIPlkgppG3HynoESADrZGjJBZNtBhKeznne4J7xhDPQ6dqAnrrjiCnz33Xca/0iWY7tf0ZPAQ9I0ZSPi+eefD09PTzz33HN4/fXXdckyOjoaHUlL/JEOufgZ7D+ajF/+dwfOHtVb75v1xHf4ee1hFGcnAFveaHKg15D9cdmYNf8v3dwvZACeNiQUF42OwPh+QVrQxVwk6Ft/KAPrDqXhj93J9U5UugcvxB1n9QnAmT19MSDcs9ECMo2Rk9Du+Bzsis/RvlE7j+ecMPiSE6D0jDozykcLwEjqpwSCp7IhXf48JCiSCwVZfZSZY0nTkQ36Wr0tp/iEFdtk9lMqtEnlOLmwkEpysiJ4KmmRcoGQVv0zEyRFKEeavhtShE62N1D2IcoqpK5ISllzKYpT47apdLikIRUafjfpTSXFYmQWWFYK5UJAZoNFU16/cVZd3gMXOxvdgyhFYiQQlYsV+cj0UMvUXgI90e/8JxEdl4Zl79+NM4dGNRjoGcfRI/GZmj2xZJNh5S3Q2wVP3TAe10ztb9bXJH1Qf9p0HPukquauRFOa/XkjwjFzRDguGdOlRSZBkrOLsPlopuGIztB9fjXP8L5u9pg+MBjnDgnW1T5zBrl1SaD3y84krD2SiYMNZIP0DnLDyEgvbQFkbOwuE0YtITnXEEztlC0KyXnYlZhX/zwV4IpBEoyGeujt1i5gIgGYVCaVXrB7kvKwJ/nEGScSXEkzejm/yCG3Jf3+dJSWVyA5rxQJOUVIrS4YJquD0hLIwbbxFUAhQaIEf4YiNI5aFVTG+84+2cdAr+OkbjZG+uXJPj05v+3evbv979H77LPPUF5ejuuvv15frPSOyMzMhL29PRYuXKgVZTqSlvgjvfiut/Hb6j14+YFLtPeTSM8pxN1vLMOipTuAxHVwtLXB5+/Ox4XjDRU4T2VPx9LtCXjqy+2ITv7npCZB3/ShoZgxLExTimTVz1xk75js+ZOVvh2xWdozSlI/6wr0dNRefmE+zhgV5YOJfQKaVaLcOHssM5LJOSV6+3imYQVQighUNTILGenrYiobLqt/IyK94HaaszqGDfPlGgjKPhKpXGfosVSse0kkWKr3WqytdPVPZpNlhjbYw0ELCYR7OWnQ1dwBSP6E5efIRYHxSKnewyKzxU3pHSiBoPx8Wf2TdFA5QUvZblmprHvxIL+zBH6SEiQroTIznSPlw0vL9WvaT/AkZdnlMXLxIPsEZUVQSoa7Oxj2CMp7IvtVWmuGndp3oDd1zmtYveUw5s2ZhsduP1fvKyoq0glIMW/ePK2OVtOnS3fjgbf/RHZ+iba2OfjZbQjyMV8j25qkL9/873bhrd/3m4IuGXsnDQzGDZN6aLuGlpJdWIpN0ZnYcDgdP29L1KyMmnuTZQzuH+aBqEA39A5x17Y7LbEyk5gtmRnZ2BWXoymWMllXN9VT+qTeOqErxnb30UyNlhSfXaTp+/JaVh3O0DGsJmlrIwGfjMv9gtx0n58ULmltck6RVT/Z92fI7JC9eKX1UlONpNCXjN9DQz0wIcrbbC145BwnwbKkn8pkY071JKD8J5T3qrF9gBJAyzlNgj4pBiZbHaRCaWfCQK/ju+SSS/Drr7/qXr28vDzdv9dY1U0J/j744IP21UdPolPpFREeHm5qFtiRtMQf6QvvL8ETb/6CS6YMwacv3FDra5v2J2L28z/jaGK2XoBI8YDzz+hxyj+rpKwCGw+lYdmOBJ1hjk3Nr9VQ/b6Z/XDpmZFmSe2sS/5pJWQVYeORDPy2Iwk7jmXVKiJQ84Kjf7gnBkXI4YURUT7NSr+suyciPa9EZ5EPJOdpmXJpIHyiCnKyhyWiOu1T9gH2CHA1S3qT/P6SfinlwqPTC7AhNktvN3aSNu7R0FRULyf9KEcvf1ddBTxVMiNr7Oek1UKrVyObUjpcTt/hXo7oIlVYq4M+uZCQQKyhsuFGkiJqaFRsqEwqwafsEyyraFogKO+RpKnKhYpcYEkT4TAPaaTscNrBOXWsQO+TH9fjlicWwdbWGsf/fB5e7s5N+r7SsgqMuX0h9sam49wx3bHo0Zmwb8GLUFnl+3D5YXz812HTGCATbQ9c1B83Te6JliYVQqVf37pD6fh9Z5Lux65LUu8vGBaCqQOCdDxuqdUYaW7+1/407e0nq30Hk/N1nDLq4uOMYV28MCbKG2dE+ZxWK4km7RXPLcH2+Bzs0CNXA5ma5F2I8HZC70A3jOriiZFdvNo0G0Em2mRyUVoNxWYVad9ZCQZrXs3J5N2IcE+MivDUPrMt8Xplcvd4ddqpbDeQCUZ5P+XcYN/ICqCu+lVvcZCPkv7ZkTM7GOh1HGlpafDzM2wPMNq5c6dmjEyfPl3rlwi5LfcfPHgQbm6Ga2sJ7m666SbtWCALZObAhukW/Ee6ZsthTJnzGoL8PBC99Jl6J9Oy8gpc/9zP+G71QTg52GLla9eYpXCADMAS9C3ZFo9ft8ThUGKu3i+D7JXjumLa0FCEeLugT1jT99U19+fnFpVrtc+Dibna2++PXckaDNYlBQUm9JbS4X4Y2tX7tNJojEVfpILcYenDl16I3fG5WpWzMb0CXbWQgFxoSCU5CbTMcdEjF3i6DzCnRFN05HVJSpH27cspbnCTvsREEviFejrpnj+ZXZY0UHOteMlFg8zUysWOnKwlKJMVOiltLkFaQ+SdkGI0sgdQgr6w6o9y8pZZ3JNWiyuSoFP2CRqCQG0jUVquq3wnYuwxZawUJ4UL5JCLBQlCT/azqeMFevLvKWrav5GYmq0ta6R1TVOt2BaL8+Z9rf+u5l48DPNvPRstTSomf7/hGN5dehCZ+YaJrzG9/HHb9N6YPCgYTvYtv3Ikv29CZqHuuZbWDVLQ5e+DabpH2kh6q0qz9mvHdoHfaTQrb2qRl682xWPJnhQN+mqOAm6OthjXwxdnRHljQk8/naBsSbJXWVb7pGfr0YxC7EnM0/GxJl0N9XTEgBB3TceXVM+Wfl1N2Zso7R6k5+uSA2m10j6lr+uZXb0wMcrntNM7T5Ztszc5H/tT83Esq0i3NTjYyB5ua039lMyauudRzXCRKtfOhqJiktHRkQI/Bnodx1lnnaXZIWPGjIG/v79W3Xz33XdhZ2eH9evXo3dvw1asbdu26WP69OmDm2++GfHx8dqVQAq2SMN0czFroHfvvfc2+QdL6dGOpCX+SIuKS+E/9v9QXl6Jg789hfAgb9PXEhISMGrUKL3d+9xHseZINroFe2HJS5cj1M+8RQy+XHMUby85gB0xtat2+rg5YHRPf+0HdcOk7mbdtNrQ64hNK8CWmEzsqk773BOfU2tmUmZzu/q74M4pPXDekGCzzTLLbKQ0epeS2FJFThoI707I0SCsLgkqpGGwrPgNDvdEkKcjuvu7mnWmWU6Ssu9Ogj7jcUwuxtLrFzjSKnLuDrrHZUpPP90D2CJ7fjT4K0JMZpGpV6AUhpHArCESaMnrkn5Ww8M8dN9IcwNSw14V6VdlSIfNKSnXC0G5AGvod5R/Q4Ym8oYAUFb/5MIhxMMBEV7OrBLXwQM9MemG/2Lt9mh8/Nz1mDVtWK1xdMOGDQgJabwIyo9/H8LlT36vt3d9NAfdQ/8Zj1tSTmEpXvh2F978bb/pvhBvZ0wdEoqRPfwwc2R4qwR9tdL9dyXr5NvyPSn6N2fUL8wDt54dpat84S1URMVIJpm2HcvGxqNZ+OtA7UbukuYd4euM688Ix3kDg9BasgpLsS85X/f4Ld2fiqKy2vuypRDWg5OitKKnVCNuazIe7kvO02qfW+NzTPvIpWrzuX38MbG7j66stcrKY3axpsjKKqlMJBaVl2u6pwR/ksFSlyGIdkKUj4t+bO8Y6HUcr7/+OhYtWqSVNuW/q6zunX322Xj88ccRFWXYH24kHQgefPBBDfpkVU9SNmU7gXGFz+ICPWkQ2BRyEfbXX3+hI2mpP9Lhs57FnsOJ+ObVWzBj/D+FAGoWEVi2Yg1uf2834lJzdf/I6jeuMWuwZ7RidxJ+3nQcmw6nIS69QPeUGMks5fkjwrUx+7Co2kvWLSUjrwQr96di9f5UrJKZyRr7J6Rx+40TumLawEB4u7bMPg6ptLklJgtL96acsHeUzE72DHTTCnLGQ/Z0mDvgktcTm1mI41nFmuokFxuSelmTnMCj/KQJvBu6+7vo6pp83lKlsGVPoKxEasU4KQ5T3US4ocI0su9PGtQPDnbDoBD3U35/pBCMpINKACgpp1It7kSFcKSdhVzwaKNgJ0PTYtkrIiXC5QKjsxcJ6EiB3k3//gSLftmEJ+88Dw/cOLXRYiyNuejRb/D7xmhcMLYH3rx7GrzdW+8C82hKHj744yAWr4tFSvY/WQYSUF07MQq3n9O7RSfbGiI99JbtTsZX649j1/HapcAn9vHH/ef21uCvNVYepfXOuiOZWL4vtVYWxpS+/rhyZJiOu61Z8l8momQCTIKXNdHSziHHtBdbXoVkXcghY14/aSvh07aTTVJga5sEqAfSdMLOuGVhUg8fTOvp16JpsXXJZJ1MXG5NyMXe6gI9cu6SVkHd/Zx1bK9ZYbuLlxPGdPGGSytOeJgbAz1qKUzdtPA/0hse/Rhf/LoZT9xxLh686Z98XZkpkOVeIcvC1s4+uPjf3+LA8QwM6OqPZa9cCXeXltuoXlZeidX7krE7Ngsf/Xmo1p6+sX0C8OisQRje3Rc21q1zcpCL9fjMQny4KgafronRPV5CTk7nDArC6O6+6BXsjoHhnifd93U6J0q5wJBU05UH0zXVVPpGyQpXXZJmJJU+ZwwIxIWDJQ2rZVJgJa3yQEoelh9Mx/qYrAbbLsjMsqyoSdrn5F5+6B9s/gvsuidxqUgqJ+vNx3O0GI3sA6zJx8VOU56C3AxlwiX1Uz6eahqqvBcyaywrjbFZhYbCMMUn7kUoJNCT/SGy/0+KA8gKoLSGaO1Ke5aqvQV6/3nnNzzz9m+YfeEYvPXYlfXG0bqzrQ2lcJ7z4Fd629XJHj8+eynG9AtFa5IS5L9vjceuY1n4+u+jSKoOamS/8I2Te+Bf5/aFdwsXKWls4u2jVTH4bWeipnoap4avG9sFc87q1uIrfDX/1mXS64uN8fh43XHT/TKxdd6gIMwaHtJiVTtPRPYj/2/NMaw9mtngXnDZKzc60hs3jQlv0bTJpgTNyw+l44+D6aZxWV7bzaPD0T/I/Hv0T0b6Ce5IzMWao1la0blfoCvO6+OvhV+OZhZif2qeqZ/fiDAv9PB1adEqsS2FgR61FAZ6Fv5H+t9PluPh//6AiyYPxqL5N57wsceSczBu7idIzS7UYG/5f6+Em7NDq5xYt0an44Nlh/D12hjtzSci/F3x4nXDNcWoNeUWlekM81cbjuNQUu3y2CFeTrj3nJ64eERYiwV8dd8bacAu6Z57E/I05fNAUr42ZjeSXkdT+wZg1ohQLfDSUmQGVC6ADqbmY3+yoZKcpHzWrbYpAd/ILp7aLFiKq0h7hZYmM926zyU5DyuPZDYagPm52GNid2+MjvDS/XbmuKiRQjDRGYVIzitGYm6JzsRLICcT2I2t5sl+v5DqPX8SjLbmbLclaW+B3qKfN+Kmxz7FhBE98Ps7/zql5/h82R7c99ZyrcQZ7OuKbe/fBI8WnFQ7WeGU7zfE4pUf9yImxTDWBXk54cdHJqNnSMuvpDUmNi0fL/96ED9uTdDP5SL8X9N64MYJ3eDq2HqrLlLA5cO/j2H1oXQUV6dRRmpKZwTOGRAA21aaiGyoyMy+lHwdf2Uslv19hdUpsJIqeXZPX8wZE96mE0oyMbY+Nhs/7EnR8Vkmuu48M0KbybeF7Qm5+GZXst6WXqzju3pr1dDs4jKsOZph2icuI7ZxT7acu2Q/X3vIymCgR+0u0JM0zhP9cVli6uaFF16IlStXai6t9PqzhD/SPzfsx7m3vYmQAE8c+u0pWJ/kxLTjSApmzvtag72RfYK199O4geFoLfEZBXjk061Yuj3e1BPq3OFh+L8L+mNQpHerDrjyT3btoXSsP5yOrTFZ2HksCwXVQY2Pqz0m9PHH9eMiMTDCC61JAgnZ67fjeA4WbYzTtg/GfWvXjQnH0C7SLFgqaLb8xaMEOnKxIRviN8RkYcXhjHqPkVUs2atxxdCQVikkIBVRZY+GlgnXQjQl+vrqVv3s7uuMKT19MSTUw2wpT7oakF+KQ2kFekivQFmBlP82Uhpc9ow09LO0Ab2TNH+Xj3baBN7V3qZdXGB0pkBvy95jGHv1i/B0c0LcX8/D9hRXdvKLSjH6toU4kpCFiEAP/PDMJegV0XbVpCWjQYpn3b9wE+KrG5A/ecUQ3H1+X7Sln7cl4J0/o01pnS4ONrhjSg/cNLFrqzbOlvY9v+xMxucb4zSd29iY/bLhoZjUx69NVvjqjsN7knLx5upYrZApHpnSHeO7+6CtSabKM8uO6B46Gfuemd5dC6G0BUnn/H5PMrKKDCmwI8I9MLNvgI7RkuK5PSFHV/1qkhZAEvQFaM8+GZdtW2WSt7kY6FG7C/SkN0RNZWVl2LFjB/bs2YPrrrsOr732GiyNBHnS2+Ljjz+2mEBPCrKEnz0P+YUlWPnxfRg5IPKk37Ny+zGc8+CXptSZ2dMH4M17prXqRac0vZTefO/+cdBUInxAF2+8PmcUBndtm5NXcWkF3l95FP9bdlibqxvJpv0hkd546LzeOhvemuQEtTU2Gx/8HatFBWo6s7sP7p/WHeHeTSsDbw6SZrorIRd/HUrX4iqyp864uCYn+dGRXjivbwD6BLmdsG1CS80wb4nL0ZQi2fdXVaNS3Nk9fDAy3FMDLnP+O5dhT4oDSNC5OS4HB9MKdKVPiu7IKoWhQlzD74NddW8o6YPo5+KgK4CWeIHRmQK9iopKhJ/9EDJzCrH8w3twxuBup/xc6/fG47yHvtZUyp5h3lj+36vg69F6f6sN2R+XjWtfXWWqlHzHOb3x7DXD2vQ1yd/Q91vi8ervh7SglpAU+hevGqTp9K2d7SEpnZ+sP25q0yAN2Z+7uK9WTW5rkulx1zd7NKCZ0dcfd03oCksgk2+vro7FkfRCDAh2w73jT34d0pKZKZuOZ2PJwXRdvbtxRKjudTRV7C4px7GsQt2fLhOEdbNDpJVf30B3DA/ztKiqnQz0qMOkbj7xxBPIz8/HSy+9BEskwd6CBQssJtAT1837CF8v2YrzzxqIL1+6SS9kd+/ejQEDBujXd+3ahf79/ynUIjYfSMTC33dh4ZJdOts7a2JvvDp3CrzcWncmbldsJh7+dAs2H5bUmQp4uthj2ysz4dNGM4LGgG/n8Wx8se4YftmeqDOWQipkPn1pf0wZ0HpV2moWEFm8OQHbZc+apPRkFJoCGWnZILPP90yOQlgrBn1CLoa2HM/GO2uPaYETI2mZcMOocJzZzbvVAz5jQPrX4QysOJJRK/VU0nSm9/bDGZEts0qr/RcLypCUJ0VlDCuOGfml2stSigVI8CepuA1xsrXWVFgvJzttgSHFXtq79hboiWsf+giLl27F/TdMwaUTIk84jp6MFMAa/69PkZSRrxkUK1692iJWcV/7eS8e+3yb3pbJNSnW0tavS85DP2yNxxPf7EF2YRkc7Kzx+wPjtQl7a0vJLcaXm+Lx3dZEU4EUGV+vHdN62S+Nkb3Uj/92UG//96K+2ibHEkhhmUd/P4TREZ64bnhIm++D+2J7IvYk52u2xU0jQxusvCnXHDJGS98+qdAswZ/xvCqTgmd28dGMFUvAQI86TKAnm9+lyllmZu1S/SezevVqvPjii9i6dSuSkpLw/fff44ILLqj1mDfffFMfk5ycjIEDB+KNN94wVVRrz4He9v1xGH/tS9o379vXbsE54/o3uVrcfxdvxMPvrtTb/bv64d37Z2BQVABaW0ZuMaY/9QcOJuQg3M8FV43rhpun9mqTogE1ZReWYnN0Jh5bvNvUp2/6oCA8eUn/U27Gbg6x6QV44fdD2FBjlU8qoL18WX9tENzaZFVWmrn/vDsFa2MykV8dXEkhF9mgf/3IMHTza51iC3VnwDfEZuPPwxmIzy5C9fZQnBXlg2m9fOHfCv++ZKVxZXSmznbLxYRxoJSgz8XOunovYVWtnl9CAj4p9NLNx0ULzbT1hXhnCfS+/H0zZj/8MXpGBuC9edOaVXWzIQeOpeOMOz9BYXEZvn/mEkwbeeqrhOZ0zwcb8eHyQ3r7lqk9Mf/65p0LW0pcRiFu+3CLpnOO6e6LL+aObrN/+4nZRXjwm726h1parvwwdxSC2nDcNxZtuWrhdt2zJ0HM3RO7Ykqv1qlk3ZTCKObYG22usf/L7Un68bphIU3az6jVPDMKsOpohqmAy7BQT3T1dmnzdhcM9KitAz2zTd1Is8AT/aDGFBQUaPAmwVxDvvrqK+3jJ30qpB+FPHbq1KlITU01PWbQoEHo169fvSMxMRGWbHDvMNxx5QS9/caiFfqxW7du2mBRDrndmLsuHoE375mqZbd3H03DxLs+w84jKWhtsoL3xs2j4OZkh+NpBXju213oO/dbXPTcn/htSxzSchpvSt6SPJ3tMbl/IP6YNwEzhxp6aP2+Iwnnv7Qaq/b/82+ntXXxdcH/rhmMtfPG4aPZQ9A/xF1nnu/+YpeWD5cVwNYkaZs9/F1x39nd8Om1g3H18BCdCZUVv43HsnHPd3vxxdYE3X/YmuTibFw3bzw5rTtev6gPJkYZepv9dSQDD/xyEA/9cgDrY2unxJqbVAKd3ssPc8+MwN3jumBGbz8MDHKDk60NsosrEJNZjJjMEq00KoGdlAgXWUVlOJCWj18PpOCbXUn4OyZDU45q9iUj8ztnbD/Y29niYEwKiqucmjSOnojszbtpxiC9/dYPW2Epnr1mqKZuineWHsTuY82bXG0pYT7OeGv2UN2jJxfeudX7rdpCsKcTPrlxKAaHe2jAcOeinbpC35Zc7G3x9uX9cWZXb007tKTxwFKCPOPYf9WQYFwztGlBnpBUze6+rpg1IFj360l17vXHsvDFjngczTCkFRN1Vs1e0bvoootqfS7fLitxW7Zswb///W8NyE75xVhZ1VvRGzlypM7GymqcqKysRFhYGObOnYuHHnrI7Ct6JSUletScjZGf11Iz0ceTMtFrxuP6Ph749SlEBHs3e9Z5zku/YcuBJK0Qd/sFQ3HPrBGtUpWzpsz8Eg3s/vf7Aew5XvsCfFzfQDx40QCM6eXfJnuZ5L39c28Knvl+L46mGgb9u6b1wD3Te7b53qqS8grc+NE27E00VNaTdMnzBwXhipGhiGylsuV1yUWaVIt7deVR3TNnTOm8clgIzunj3yaz9HJh9Pv+NN2Yf6D6v6Hsp3tlZu9WTzE1FnaRwjLSjFiKGYjBIe6Y1tNX04jicoq0vURFneFVVm+lwqjMNrtbcIrn6c5Ct/Y4ajTr3nfx84pduOWycXj1oVmn/XxHE7PQ97p39faSFy/H+EERsBRXvrwCv26Jxz3n98UTVwyBpTiYlIsegW4WsZIdl1mIOR9v15TSBVcNbJOsiYbG183HsjHSAl5LRyRZKntT8nA4PV/b7sjevT4B7hgc4tEm2xG4okftbkVPTv41D29vb0yYMAG//fbbaQV5DSktLdWUzkmTJv3zgq2t9XNZQWwJ0rm+5u8nFyctKTzIG2cOMcw4f798+ynNOv/4n0sxsJs/cgpK8NyidZh87+coKqnf460lSfPyqydEYc1zM7D8qWmaUtRNT/bA6r3JmPH0HzjnqT+w/Wj96o8tTS44JvULxG8PjNdqnOK1JYdw+0db9KK9LUlVuP9ePgAXDw3WHkuyIX3xlgRc9vYmHM80VNlrbTI7OiDEHW/N6o+7J0TqngfZx/fayhisPNL6//2EpDqd19cfD53dDW9c1EdLgkvPqg3HWnZVr7F/T7LqOSzMA7OHh2J8N2/IfIGUCf9qZ5I2ZR8b6YMrB4dgUnc/9PF3hUd16XlZvZWWD9/sTsL6Y5na+qG1V3FbQ2uPo0a3Xz7e1G6hvPz0V0y6Bnth8jDDmHHho9/o3j1LcckYw+t674+D2BfX+n8HjekZ5G4RQZ6Qvc/vXTcYr10xwCKCPOP4yiCvZbNUBgS548J+QYjwctK0/93JuVh+OK3Nz/dEbcFse/TMoe6KnqRehoSEYN26dRg9erTpcQ888ABWrVqFjRs3Nul5JTDcuXOnpolKYLp48eJaz9fWM9Fvf7UK9zy/GKMHdcWnz1yGs846y9SqQn7/pigoKsXilfvx6PurkJFbpBU537p3Otqa9IB65LMtWLo9Qfvwyflfmq5LW4a2Ir34Hvpyp878zZvZG7ee3fYFDYRc8K84kI4HFu/Rz8/q7YfnL+7b5k28pajNB+uP4/tdyRqMvn/lQF2Zaks/703Ft7uSMTDYDfe0YaU4I+lh+OUO2VdShV7+Lpp2VFdxeYUGzDuTcrTap5GDjTV6+ruib4CbNnC3BO11RU8yPgLG3o/0jCSEF2+Ao4Nds8bRhsh4OuOBL7EzOhU3zhiIBXdPgyUor6jEBc8ux5p9KZg0MBjfPnR2W78kIosil7dSZXr5kXQ930u1ZAkCI72dW60yJ1f0qMPs0bNky5cvR1paGgoLCxEfH99okCccHBz0QqTm0dKmnWnoibRpdywOH4nBoUOH9GjOHkMXJ3tcP30gPn74PA2mPvp9Fz78bQfaWmSAGz6/byI2vzwTF4/uohuln/5qB5btMDTcbQuXjQ7H7ZOj9PZzP+7H3IXbkJH3z0VpW5Emv5P7+OsMtPhrf5ruLWlr0jT8xjHh6OrjjKm9pTdV2w8bg4INFev2p+Sbqqu2JQnUbh0djhAPB5zTSIEFR1sbrSA3o1cApvb014sNJztr7Q+1K0maBiciJrPQ1LakPWuLcdSY8dG/RwhQUYzjxwxj6enu1fZxd8LLd07W2x8v2a3pnJZAqiN+cvd4XHdWFD6YO7atXw6RxZEJ3HAvZ5zZxVtX+iSt/q8j6Vi8MxE5xa2b9UTUVpp9xebl5aWrYnUPHx8fnTUdP348PvroI7O8OF9fX9jY2CAlpXaREfk8MDAQHUWXEF9EhftpL6j9cRn6O8sh73VznT00Ek/OHqe371mwHH/vioMl6Brghg//NRY3Tuqhn3+68kibvp67p/fUPXoy+P+0LQE3vrsJlkJSjJ6c2RueznY4d2CgxWyQX3BpP9w4OtwiAr1QT0dNKZUVtP2p+bAEks552+hw+LjYn/ziw9NJ0zqvHByKKT38dKa5rLJK04sWbY/XCnJ0agZIoGfjCCsr61MeR+s6o18opgyP1FU0SyrMItWNX58zWtvbEFHDevi54opBIRgS4qHnMunJ9/XOROxLMeyNJ+rImn3F9thjj+ms6YwZM/Dkk0/qIbflvjvuuAM9evTAbbfdhvfee++0X5y9vT2GDh2KP//8s1Zqjnx+olW59mj8cEMAlJRlhfLycj2iogyrTs31f5ePwgVje6C0rEL3lXyzaj8sxRXjDI1iZd9eRRvuTZJ0yHvO6YlPbx+ln2+LzcK++BxYCinI8tPc0ZgxwDICPdHW/ZXqBksz+/njxpGh6GYBDZGNmpsCLOlDEV7OOL9PIPoHuuteRNmnKbPOK46kIyGnfmNgOjFZ0XN08sb5t79xWuNoXTefZyh48t3qg9o7jojaD6miPDTUExf3D9JCXmJtbKYe/HumjqzZV25///03nnnmGXz66ada+VIOuS33SeEUCfCk593rr7/epOeTJus7duzQQ0i+qdw+fvy4fi6tFeQ5P/74Y+zfv1+DSNlrN3v2bHQkfaOC9eP+o8lmudj84IFzMWFQBPKLSnHNMz/hg1/bPo1TDO7qA3cnO2Tll7ZJYZa6zuzpp/31xLebLGP108jN0bbV9hG0R+O7+WBsV2+L2dd2OmRleVSEF64bGqbV4eS/+pGMAvx2IBWLdyZo0RZqeoErkZhq3ombSUO7aGVjaaK+fl/bpZ4T0amT88WsgcHo6m2YIJRVvUPplpEVQpbt+uuv1+vrxo6EBMN5QQpUNvT1adPaZn93s6+Qli5dihdeeKHe/WeffTbuu+8+vX3OOec0ufWBtGWYOHGi6XMJ7MR1112HhQsX4rLLLtP9dbKSKA3TpWfekiVLEBDQ+s3BW1LvroaVmwNHk8zyfM6OdvjhP5fgkfdX4s3vt+LBt//CVZP7wdHets1XhSYPCsG362Px+aqjGBbV9g1jLx4Rpj32ftiagHkz+1jUyhV1LtLuQ1ovhHk4aonwhJxi5JdW4Nf9KZjROwCBbm3b9Lk9CPT10I9JaeYN9BzsbXH5WX2QkVek/UuJqH2S/fBnRfnCMTYT+1LzsVNagvi5cmKVTuiWW26p1QXAWPDn1ltvRZcuXWoV/QoNDdXq0zUFBxsWdFpbs6/6ZT/ezz//jHvuuafW/XKffE3Iipubm6FYwslI5Huywp933nmnHh1Zr66GVaW9hw+Y0r927dqF/v37n9aFyYu3nY1vVx1EcmY+1u+Jx8QhXdDWrj0rSgO9xWtj8PRVQ9r8omlCb394udgjLbcEaw+lY3xv/zZ9PUQBbo56SKN6SeM8nl2E3/anINjDCcNDPU+6D7AzC/LzQHFROuJ3vAkrqxdOexyt6dV/TTHL8xBR25LrrBHhXojOLNS2N1IIq5tP2/SupfZh9OjR9baNSZajFHq86qqrat0vVauvvvpqWIJmB3rSFF3SJ1esWIERI0bofZs3b9Y+em+//bZ+vmzZMi3KQk0X4OMGL3dnJNWoECelU80xmJ09tAsWLduDP7fFWkSgN65PIPqEeaJ/hBfyisraPNCTqpIzh4Zgb3yO7pEishSyl3RilC9+3ZeC9EJp0l6ElLwSTO/lr/36qD4fTxfYVpWj3IzjKBF1zPFV2tpsS8jB/tQ8BnrUbJ9//rleZ1955ZX1viZ7xOX84+rqinYV6M2ZMwd9+vTBggUL8N133+l9PXv21L52Y8aM0c+NKZzUdPIPJSLYG0kpXhhz5lkI8PNAt26GRuqnyxTobY3FMzdZRnra38/PgI215aRIPn5xP90nRWRppErcBf0CkZxXgo3Hs5BWUKqre9KiIcidqZwNNrQP6oKEpC4YN7y72cZRIup4JGVTAr3k3BIUllXA2c5QqIXoZMrKyvD1119r7COpmzVJax8XFxeUlpbqVjOJnWQLmp1d6y9snNKGrTPOOEMPMq8Qf084Ojlh9l1P4qZLzjTb804eFqn99SYObvvVPCNLCvIEgzyy9OBFgjrZp7fsUBoScovx64EUDAxyx9AQT508oX9EhgUgI2cG7nt0jmlLARFRXW4OtvCTrRsFpTiSXqAN1cm8ZHtWUWmFxbytTvY2za6Q3VjNkoyMjHppmzK5KLVHZMuAbGX75ptvtGClBH9fffUV2kWgJy0Ojhw5gtTUVL1d07hxhh5u1HyhgYZ+T/Ep5m3I6+vhjFkT+/A/CVEHSDWa0tNfi7Ok5pdgR2KuzkKP7+rb1i/NIguyJKfltvVLISIL18vfFWkxmdibnIt+gW4symJmEuT1+r/fYCkOvHQOnM1QrVvSNmWFbtasWbXu/+CDD2p9fs011+Dmm2/WDgJS32TUKENbr9bS7GWVDRs2aF+i3r17a1AnxVSMR83qmXRqK3rFRUV4/ck7tLpoZmYm30YiqkX2kcrK3ugIL23DcCitQPvt0T+8nCpQvP9LPH7vdRxHieiEonxd4GhrrRWOYzML+W5Rk1rD/fjjj5g6dSp8fHxO+njjlrbly5ejtTU7pJUyosOGDcOvv/6KoKAgsyx/Uo0VvYosZKXF6REdHc20IyJqMNjrF+iOnOJy7QMllTkv7BfUIXoKmsNV0wfivecykJyQwXGUiE7abqFPdVEWyZLo4u3MVT0zp0rKKpolvZ7T9cMPPzRYbbMxYWFh+rEtFnCafVVw+PBhzTeVVT0yr5AAT8DGUDbd2toajo4stEBEjRsR5qlVODMKS7EyOh3TewVwv6m0AfJ00zFUcBwlopORQG93cq6OpYfS8tHLv2ktwujkZEHIHKmSlmTRokVaTfP8889v0uOPHj2qH/38Wr93dLNTN0eOHKn788j8QgO84OjkC69Rd2tZVnP1fiKijrtn7+zuvrrCl5RXglVH00/al7QzkLGzoqJCD46jRHQyTnY2GBRs2NsbncH0TWpcWlqapmBeeOGFcHZ2rvW13NxclJSU1LpPzslSjEVIqmdra3aIPXfuXM01TU5O1hNo3VKhAwYMMOfr61TCAr2x4cuHdK8eEVFTeDjaYVJ3Pyw9lKoXKEFu+egdwNloIqLm6OrtjM1x2UjKK0ZpeaX22CWqSypnymJMQ2mb27ZtwxVXXKGHZD4WFRXh+++/x9q1a7Ugy5AhQ2Dxgd7FF1+sH2+44YZay7ISscpHmUGlU2NnZ4OBPUP59hFRs4R5OmFYqKdepBxKZ6BHRNRc7o528HS0RXZxOaIzCjhhRo2mbfr7+2PSpEn1vhYREYGxY8dqcCcLYrKFQIpXvv322xrotYVmB3oxMTEt80pI7d69GwMHDtTbO3fuZNoRETVJD19XbInLRmp+KfJLyjt1YRaOo0R0KiQbYv2xLOxKytW2Cyw4SHWtX78ejYmMjNQm6pak2VcCEq1SyykuLjbtsZHbRERN4WxvA29ney0mkF5Q2qkDPY6jRHQqevoZJsxyS8q1ibq/qwPfSGrXmnQl8NNPP2H69Om6H09un0hTK9BQw7p166Y9CY23iYiaytPJVgO97OKyTv2mcRwlolMtcCWp8EczC7EnORcTu/lyVY86fqB3wQUXaK6p5KTK7cZwj97p8/b2xooVK8zwTETU2Xg6GYpjZRd17kCP4ygRnapuPi4a6ElxqzCPAnT3c+WbSe1Wk0oKVVZWapBnvN3YwUIsRERtx6s60Mvq5IEeEdGpivByQpSvi96WgI+oPWPtWAuTmZmJMWPG6CG3iYiaSvbo6ThSWIrC0s5bAZnjKBGdKslO6x/orreTcotRUcnepNQJAj2pMvPLL7/Uuu+TTz7RCjOy2idlQ+s2CaTmi46O1vdaDrlNRNScnnpSPECuS2R/SWfFcZSIToePsx0cba1RVlml+56JOnyg99RTT2Hv3r21ylffeOON2kfioYcews8//4znnnuupV5np+Ho6KizSXLIbSKi5hgYZJiJlkAvr6S8U755HEeJ6HTINZgxQ6Kz73mm9q3J9bd37NiBp59+2vT5l19+iZEjR+K9997Tz8PCwvD444/jiSeeaJlX2kn0799f9zsSEZ3q/hI/F3stDZ6YU4ye/p2vkADHUSIyR3GrxNxi7nmmzrGil5WVhYCAANPnq1at0pYLRsOHD0dcXJz5XyERETVrJtqtuodeGSeNiIhOiacjqxhTJwr0JMiLiYnR26Wlpdi2bRtGjRpl+npeXp722SMiorbvBSXKKlhEgIjodKoYM3WTOkWgd8455+hevDVr1mDevHlwdnbG2LFjTV/ftWsXG3ybgex9tLGx0UNuExE1l52NlX4sq+icaeAcR4nIXH1JZa9zOStvUkffoyf78y666CKMHz8erq6u+Pjjj2Fvb9ioKj788ENMmTKlpV5np1FcXGzaoye3iYiay866ekWvk16ccBwlotPlZGcNextrlFZUIqe4DD7VxVmIOuSKnq+vL1avXq179eS48MILa3198eLFWoyFTk+3bt10v6MccpuIqLk6+4oex1EiMsd+Z+OqHtM3KT8/X+OcadOmwdvbW/99LFy4sME3Zv/+/fo4WRiTx15zzTVIS0ur9zhZ2Jk/f762qpNq0QMGDMAXX3zRNit6Rh4eHg3eL78InT55Hzdt2sS3kohOWWffo8dxlIjMtU8vNb+EgR4hPT1dW82Fh4dj4MCBWLlyZYPvSnx8PMaNG6fx0rPPPqsB4ksvvaRbCuT6vmY25COPPILnn38ec+bM0QWeH3/8EVdeeaUGkZdffnnbBHpERGTZbK2rV/RYdZOI6JRxRY+MgoKCkJSUhMDAQGzZskUDs4ZIcFdQUICtW7dqUChGjBiByZMn6wrgzTffrPclJCTg5Zdfxh133IEFCxbofTfddJNukbv//vtx6aWXar2OVkvdpNaRmZmphW/kkNtERKe6olfeSVf0OI4SkTm4V7eqkYIs1Lk5ODhokHcy3377Lc4991xTkCcmTZqEHj164OuvvzbdJ6t3ZWVluP322033yUrebbfdpquC69evN8vr5oqehYmOjsbvv/9uus2UWCI65T16nXRFj+MoEZmDm6PhMjmXgR41gazSpaamYtiwYfW+Jqt6v/32m+nz7du3w8XFBb179673OOPXzzzzTJwuBnoWRjZjSkRvvE1EdMpVNzvpih7HUSIyB7fqFb2S8kqUllfC3paJcM1VVVWF4jLLmXR0tLM2XWebm6R2GtM865L7JNukpKREVwflsdKjvO5rMX5vYmKiWV4TAz0L079/f1N7BSKiU9HZq25yHCUic5D2Co621igur9RVPV9btlhoLgnyxjy3ymL+Qa6bNx5O9qe/960hRUVF+lECubqMizfyGPm68eOJHmcOnJogIuqoVTc7aR89IiLz79Mr45tKJ+Tk5KQfZdWuLmNvbONj5GNTHne6uKJHRNTB2FVX3ayorEJlVRWsWyhNhYioM+zTk2IsnbW4lTlSJWUVzZJeT0sxpl0aUzhrkvuk7oZxFU8eu2LFCk1trZm+afze4OBgs7wmruhZGOmzYWtrq4fcJiI61RU90RkvTjiOEpG5TOjmi6uHhqG7nyvf1FMgQYykSlrKYdWCE58hISHw8/PT9gt1SQ+9QYMGmT6X24WFhdpcvaaNGzeavm4ODPQsjCzZVlRU6GFcviUiag5Z0DOeyzpj5U2Oo0RkLsyIoOa4+OKL8csvvyAuLs50359//olDhw5pbzyjmTNnws7ODm+99ZbpPlnde/vttzVgHDNmDMyBqZsWplu3bujVq5fpNhFRc8mMpVTeLK2o7JSVNzmOEhGRuUlj8+zsbFNFzJ9//ll73om5c+fCw8MDDz/8MBYvXoyJEyfirrvuQn5+Pl588UUtEjZ79mzTc4WGhuLuu+/Wr0k/PWnA/sMPP2DNmjVYtGiRWZqlC6sqCR+pUbm5ufofLicnB+7u7nyniKhd+Hx7PApKK3BB30D4udav7NWa4x7HUSLqjDrT2CeZFDExMYiMjOyw7cG6dOmCY8eONfg1+d3l62Lv3r2499578ffff8Pe3h4zZszAyy+/rO0UapIq+y+88ALeeecd3ZvXvXt3zJs3D1dddZXZ3m+u6BERddheehWsvElERGQGsbGxTXpc3759sXTp0pM+ztraWgM7OVoK9+hZGGmmKJG8HHKbiOhUdOZeehxHiYiIGOhZnOjoaHz++ed6yG0iotPqpdcJ9+hxHCUiImKgZ3Fq5tl21BxnImq9XnrlnbDqJsdRIiKiTrBHT6rjTJo0CeXl5XpIBZw5c+bAUklVHtbHISJzreiVdsIVPY6jREREnSDQc3Nzw+rVq+Hs7IyCggL069cPF110EXx8fNr6pRERtRjb6j165Z1wjx4RERF1gtRN6UMhQZ4oKSnR1TKumBFR56i6KQ3TO9+KHhEREVlAoCerbeeddx6Cg4O1ya80C6zrzTff1N4Usu9i5MiR2LRpU7PTNwcOHKjNCe+//374+vrCUh05cgR2dnZ6yG0iolPRmatuchwlIiKygEBP0iklCJNgriFfffWVNh18/PHHsW3bNn3s1KlTkZqaanrMoEGDNCWz7mHsXO/p6YmdO3dqY0GpZpmSkgJLlZWVZdpPKLeJiE5FZ666yXGUiIjIAvboTZ8+XY/GvPLKK1o8Zfbs2fr522+/jV9//RUffvghHnroIb1vx44dTfpZ0pFeAsU1a9bgkksuafAxkt4ph1Fubi5ak6xsyuql8TYR0elU3Sxrg6qbHEeJiIjaXpuv6J1IaWkptm7dqlUza3aRl8/Xr1/fpOeQ1bu8vDy9nZOTo6miPXv2bPTxzz33HDw8PExHWFgYWlNISIiuPMoht4mITmdFr7wNVvQ4jhIREbU9iw700tPTUVFRoStxNcnnycnJTXqOY8eOYezYsbqSJx/nzp2rpbcbM2/ePA0IjUdcXNxp/x5ERJ1pjx7HUSIiorbX5qmbLW3EiBFNTu0UDg4OerSVoqIiU0rq888/DycnpzZ7LUTUftmaUjdbf0WP4ygREVHbs+gVPamOKe0R6hZPkc8DAwPREe3Zswevv/66HnKbiOhUeDrZYXSEF4aEeHS6N5DjKBERmVN+fr4Whpw2bRq8vb21U8DChQtrPaayslLvO//883Xrl4uLixaHfOaZZ1BcXFzvOeU5GjpkoadTrOjZ29tj6NCh+PPPP3HBBReY3kT5/M4772zrl0dEZLFc7G3RL9C9rV8GERFRu5eeno6nnnoK4eHhuh1s5cqV9R5TWFioxSNHjRqFW2+9Ff7+/lpTRAJEiV3++usvDeRqmjx5Mq699tpa9w0ePLjjBHoSIdfsFydFSCTVUqJleTOltcJ1112HYcOGaRrmq6++qi0ZjFU4O5rhw4ezoTsREcdRIiKyEEFBQUhKStKMwi1btuj1ekMLVGvXrsWYMWNM90nnAKmmbwz2ahaYFD169MDVV1/dcVM35c2SyNUYvUpgJ7cfe+wx/fyyyy7DSy+9pJ9LvzwJApcsWVKvQAsREREREVFL7D0PPMm2MQn0agZ5RhdeeKF+3L9/f6P1ORpK7ewQgd6ECRN0BavuUTPvVdI0pXqm9GbauHEjRo4c2aavmYiIiIiI6GSMnQKk9khdEu/IXj4pvtinTx98/vnnMKc2T92k2iSNtW/fvnp77969iIqK4ltERNQMHEeJiCyDLN4Ul7d+m5/GONpa19sn19Lmz58Pd3d3TJ8+vdb9svo3a9YsREZGIjExEW+++Sauuuoqbe922223meVnM9CzMFlZWdoo3nibiIg4jhIRtUcS5M18dzMsxY83D4eTnU2r/bxnn30Wy5cvx1tvvQVPT89aX5P9fDXdcMMNWoTy4YcfxvXXX2+WFmttnrpJtQUHB+uGTznkNhERNQ/HUSIiamtfffUVHn30Udx4441NWqGTPX6yXS07Oxtbt241y2vgip6FCQkJ0eVbIiLiOEpE1J5JqqSsolnS62kNy5Yt07YJM2bMwNtvv93k75P+eyIzM9Msr4OBHhERERERmZ3sh2vNVElLsHHjRq20Ka3hvv76a9jaNj3cOnr0qH708/Mzy2thoGdhpMSqbMYUd9xxh1nyc4mIOhOOo0RE1BakhYKs4knvvF9++aXR6/i0tLR6wVxeXp72C5fqnLJXzxwY6FmYPXv24P7779fb48ePb7AhIxERcRwlIqLWs2DBAt0/Z9xi9fPPPyM+Pl5vz507F9bW1pg6daoWU5Rr+V9//bXW93fr1g2jR4/W27Ko88MPP+C8885DeHi4NmP/8MMPcfz4cXz66ae6X88cGOgRERERERGdwEsvvaR9vY2+++47PcTVV1+tH+Pi4vTjQw89VO/7r7vuOlOgd8YZZ2DdunV4//33kZGRob30RowYocHeWWedBXNhoGdhZAVPeo4QERHHUSIisgyxsbEnfUxTr+EnT56sR0tjewUiIiIiIqIOhoEeERERERFRB8NAz8IcOXJEK/TIIbeJiIjjKBERUXNxj56FkUo9xcXFpttERMRxlIiIqLkY6FmY4OBgeHt7m24TERHHUSIiouZioGdhQkJCtMwqERFxHCUiIjpV3KNHRERERETUwXBFz8IUFRXhp59+0tvnn3++FmUhIiKOo0RERM3BQM/C7NmzB5dffrne3rRpkzZQJyIijqNERETNwUCviR3uc3Nz0Rry8/Nr3W6tn0tEZGQcd4zj3+niOEpEnZG5x1Ki5mKgdxJ5eXn6MSwsDK3trLPOavWfSURUc/zz8PA47TeE4ygRdWbmGkuJmouB3klIi4O4uDi4ubnBysqqWbM4EhzK97q7uzf7P0xnwPeI7w//DVnm35nMPsuFiblavJzqOCo4TvD9OV38N8T3p63+DZl7LCVqLgZ6J2FtbY3Q0FCcKhkQGOjxPTod/DfE96gt/h2Zc/b5dMdRwb8Dvj+ni/+G+P60xb8hruRRW2J7BSIiIiIiokZI3YzHH38c06ZNg7e3t2anLFy4sN7jrr/+ev1a3aNXr171HltZWYn58+cjMjISjo6OGDBgAL744guYE1f0iIiIiIiIGpGeno6nnnoK4eHhGDhwIFauXNnYQ+Hg4ID333//pCu7jzzyCJ5//nnMmTNHq+z/+OOPuPLKKzUwNFbgP10M9FqI/EeWyF8+Et8j/hvi31lbae9jUXt//S2N7w/fI/4b4t8ZtbygoCAkJSUhMDAQW7ZsOWH7M1tbW1x99dUnfL6EhAS8/PLLuOOOO7BgwQK976abbsL48eNx//3349JLL4WNjc1pv26rKtZ8JSIiIiKiU1RcXIyYmBhTGmJHtqU60Pvoo480VbMm+fybb75BTk4OCgoKGt3T+dZbb2mQt3fvXvTp08d0v6RuyqremjVrcOaZZ572+809ekRERERERGZQWFioAZ6ka8p+PgnoavbJFtu3b4eLiwt69+5d6/4RI0aYvm4OTN0kIiIiIiKzk8TB0grLaRhvb2MojtKSKZ4PPPAAhgwZosVWlixZoqt3O3fu1H19ktYpJA00ICCg3muR7xeJiYlmeT0M9IiIiIiIyOwkyLtl8R6LeWffubQfHGxbLtB77rnnan0uRVV69OihhVckpdNYZKWoqKjBvefGNEz5ujkwdZPoNMkMjczIZGdnt+v3skuXLnj11Vfb+mUQUSfEcZSIOqp77rlH+8kuX77cdJ+TkxNKSkoa3Htn/Lo5cEWPOjTZFPvxxx/jlltuwdtvv13ra5IzLcvp1113XYO9UFqT/PzZs2dj6tSpusxvJMGjl5cXVqxYgQkTJrTpaySizonjKBGdTqqkrKJZ0utpbRK0+fj4IDMzs1aKplzbSWprzfRNSekUwcHBZvnZXNGjDi8sLAxffvllrWVwmTH5/PPPtR+KpZC8bZntkT/8jqK0tLStXwIRmQHH0bbDcZTaMwliHGytLeawasH9eY3Jy8vTPnx+fn6m+wYNGqRFW/bv31/rsRs3bjR93RwY6FGHJxti5SLlu+++M90ntyXIGzx4cK3HyjL6v/71L/j7+2uetJS23bx5c63H/Pbbb5pvLTM0EydORGxsbL2f+ffff2Ps2LH6GPnZ8pxSZvdEpPrSDTfcgIceeqhZ6U07duzQ+4yvQ1YHPT098csvv6Bnz55wdnbGJZdcogOKrG5KiqasEsprqqioqDcYXXHFFfpaQkJC8Oabb9b6uvxc6fMig5VUlDrrrLN0g7HRE088oYOTNArtDCWWiToLjqMcR4noxGQRQa6j6nr66ad15W7atGmm+2bOnAk7OzvNLDOSx0j2mVx/jRkzBubAQI86BQmgpN+J0YcffqipknVJpaRvv/1WA6Jt27YhKipK0ymNy+1xcXG46KKLcN5552mAJUFP3cAsOjpa/5gvvvhi7Nq1C1999ZUGfnfeeedJX6cESrt379YNu6dDgrrXX39dVzIlFVQCxAsvvFCDVDk+/fRTvPPOO/V+zosvvoiBAwdqWV/5ve666y4sW7bM9HVp4Jmamorff/8dW7du1Yu/s88+u1Y6wpEjR/Q9lGBa3iMi6hg4jnIcJerMFixYgGeeeUavIcXPP/+sn8shffOSk5N1EeH222/XazA5ZsyYoddWcl0owZ1RaGgo7r77bp1Ql+1FMkEu15bSP2/+/PlmaZaupGE6UUd13XXXVc2cObMqNTW1ysHBoSo2NlYPR0fHqrS0NP2aPEbk5+dX2dnZVS1atMj0/aWlpVXBwcFV8+fP18/nzZtX1adPn1o/48EHH5S6wVVZWVn6+Y033lh1880313rMmjVrqqytrauKiooafJ0fffRRlYeHh95+6KGHqnr06FFVVlamzynPvWLFCv2afKz5s8T27dv1vpiYGNNzyedHjhwxPeaWW26pcnZ2rsrLyzPdN3XqVL3fKCIiomratGm1Xtdll11WNX36dNPv4O7uXlVcXFzrMd26dat655139Pbjjz+u76G830TUMXAcNeA4StQ4ub7Zt29fo9c5HUFERIReXzV0yDWYXJtdffXVVVFRUXrNJdedffv2rXr22Wf1erKuiooK/Zo8r729vT72s88+M+v7zWIs1ClIqqHMqkhaoyyNy21fX996K3FlZWU444wzTPfJsro0rzTmUMvHkSNH1vq+0aNH1/pcUhllJW/RokWm++RnSj+VmJiYes0x63rwwQd1tU1mjGbNmnVKv6+ka3br1s30ufRqkZRNV1fXWvfJ6tyJfhf53FiJU34vafgpG4prkr2P8t4ZRURE1MpDJ6KOgeMox1Giziy2ga06dUnGVFNJJc558+bp0VIY6FGnSjsypk/W3XtmThIMyTK87IGrqynFX2R/nfzRP/nkkzj33HPrDQrGwNFIgtO6JECtSfbwNXSfBJ/N+b2kSpSkgTb0mo1kfx8RdUwcRzmOElH7wUCPOg3Jj5bqZRLgyL67umQFzN7eHmvXrtVVKWMQJcVYJI9ayGrcTz/9VOv7NmzYUOtz2be2b98+3d93qubOnau53a+99lqt+40rZVJ+VwqqCHPug6v7u8jnxhVI+b0k/1yqg8rqIBF1PhxHT47jKBFZChZjoU5DNrZK6qUEYQ1tcpWVqNtuuw3333+/FjCRx82ZM0cLm9x44436mFtvvRWHDx/Wxxw8eFBbNNTtwSepl+vWrdPVQwnC5PE//vhjk4qxGEm1SlnRk2CvJgkepYqnFG2R5/3111/x8ssvw1wkyJVNwIcOHdJVz8WLF2tBFjFp0iRN5bzgggvwxx9/aAqD/J6PPPIItmzZYrbXQESWi+PoyXEcJSJLwUCPOhVpCSBHY55//nmtlnnNNdfoCpZUkFy6dKlp9UxSL6Wi5A8//KDVKaUM7rPPPlvrOQYMGIBVq1ZpsCQtFqSFw2OPPdbs5pfSyL1r16617pP0yy+++AIHDhzQn/PCCy9otSdzue+++zRok9csz/vKK6+YVj9lJVQqdo4bN04rlkqLicsvvxzHjh3T/X5E1DlwHD0xjqNEZCmspCJLW78IIiIiIiJqvz3kpOAce+ha1vvNFT0iIiIiIqIOhoEeERERERFRB8NAj4iIiIiIqINhoEdERERERNTBMNAjIiIiIiLqYBjoERERERERdTAM9IiIiIiIiDoYBnpERERERESNyM/Px+OPP45p06bB29sbVlZWWLhwYb3Hyf2NHZMnTzY9LjY2ttHHffnllzAXW7M9ExERERERUQeTnp6Op556CuHh4Rg4cCBWrlzZ4OM+/fTTevdt2bIFr732GqZMmVLva1dccQXOOeecWveNHj3abK+bgR4REREREVEjgoKCkJSUhMDAQA3chg8f3uDjrr766nr3SVAoK3US1NU1ZMiQBr/HXJi6SURERERE1AgHBwcN8pqrpKQE3377LcaPH4/Q0NAGH1NQUIDS0lK0BAZ6REREREREZvbbb78hOzsbV111VYNff/LJJ+Hq6gpHR0ddJfzjjz/M+vOZuklERERERGZXVVWFsooqi3ln7WwMBU9ay6JFi3Q18JJLLql1v7W1te7Zu/DCCxESEoKjR4/ilVdewfTp0/HTTz9hxowZZvn5DPSIiIiIiMjsJMh7ctkRi3lnH58cBXvb1gn0cnNz8euvv2qxFU9Pz1pfk6IuS5curXXfNddcgz59+uC+++4zW6DH1E0iIiIiIiIzkr15xcXFjaZt1iVtG2bPno2DBw8iPj7eLK+BK3pERERERNQiqZKyimZJr6c10zY9PDxw7rnnNvl7wsLC9GNmZmajxVuag4EeERERERGZneyHa61USUuSlJSEFStW4Prrr9c9ek0le/WEn5+fWV4HUzeJiIiIiIjM5Msvv0RlZWWjaZtpaWn17ktISMCHH36IAQMGaN8+c+CKHhERERER0QksWLBAWyUkJibq5z///LNpL93cuXM1TbNm2mZwcDAmTJjQ4HM98MADiI6Oxtlnn62Pi42NxTvvvKM99V577TWYi1WV1D0lIiIiIiI6BVJ0JCYmBpGRkdoTriPq0qULjh071uDX5HeXrwspptKrVy/ce++9ePnllxt8/BdffIG3334b+/fvR1ZWllblHDt2LB599FEMGTLEbO83Az0iIiIiIjplnSHQa4/vN/foERERERERdTAM9IiIiIiIiDoYBnpEREREREQdDAM9IiIiIiKiDoaBHhERERERUQfDQI+IiIiIiKiDYaBHRERERETUwTDQIyIiIiIi6mAY6BEREREREXUwDPSIiIiIiIg6GAZ6REREREREHQwDPSIiIiIiog6GgR4REREREVEjNm/ejDvvvBN9+/aFi4sLwsPDMWvWLBw6dKjeY/fv349p06bB1dUV3t7euOaaa5CWllbvcZWVlZg/fz4iIyPh6OiIAQMG4IsvvoA52Zr12YiIiIiIiDqQF154AWvXrsWll16qAVlycjIWLFiAIUOGYMOGDejXr58+Lj4+HuPGjYOHhweeffZZ5Ofn46WXXsLu3buxadMm2Nvbm57zkUcewfPPP485c+Zg+PDh+PHHH3HllVfCysoKl19+uVlet1VVVVWVWZ6JiIiIiIg6neLiYsTExJhWpzqadevWYdiwYbUCtcOHD6N///645JJL8Nlnn+l9t99+OxYuXIgDBw7oqp9Yvnw5Jk+ejHfeeQc333yz3peQkKDvlXwuAaOQkGz8+PH6PsbGxsLGxua032+mbhIRERERETVizJgxtYI80b17d03llFRNo2+//RbnnnuuKcgTkyZNQo8ePfD111+b7pPVu7KyMg0MjWQl77bbbtNVwfXr18McGOgRERERERE1g6zApaSkwNfX17RKl5qaqit/dY0YMQLbt283fS63Za9f79696z3O+HVz4B49IiIiIiJqkWCovNJydonZWlvpypk5LFq0SIO7p556Sj9PSkrSj0FBQfUeK/dlZmaipKQEDg4O+tiAgIB6r8X4vYmJiWZ5jQz0iIiIiIjI7CTIW7glzmLe2euHhcHO5vQDPdmDd8cdd2D06NG47rrr9L6ioiL9KIFcXcZ9dPIY+brx44keZw5M3SQiIiIiImoCqbg5Y8YMraz5zTffmIqmODk56UdZtWuoeErNx8jHpjzudHFFj4iIiIiIWiRVUlbRLOn1nI6cnBxMnz4d2dnZWLNmDYKDg+ulXRpTOGuS+6SnnnEVTx67YsUKTW2tmb5p/N6az3s6uKJHRERERERmJ0GMnY21xRxWp7E/T1bbzjvvPG2S/ssvv6BPnz61vh4SEgI/Pz9s2bKl3vdKD71BgwaZPpfbhYWFtSp2io0bN5q+bg4M9IiIiIiIiBpRUVGByy67TNseLF68WPfmNeTiiy/WIDAu7p99iX/++acGh9Js3WjmzJmws7PDW2+9ZbpPVvfefvttDRilnYM5MHWTiIiIiIioEffddx9++uknXdGT6pnGBulGV199tX58+OGHNRCcOHEi7rrrLuTn5+PFF1/UxuqzZ882PT40NBR33323fk366Q0fPhw//PCDpoNKNc8TNUtvDqsqCR+JiIiIiIhOMa0xJiYGkZGRpsqRHcmECROwatWqRr9eM5zau3cv7r33Xvz999/aZF0Kt7z88svaTqGmyspKvPDCC3jnnXd0b540YJ83bx6uuuoqs73fDPSIiIiIiOiUdfRAr72+39yjR0RERERE1MEw0CMiIiIiIupgGOgRERERERF1MAz0iIiIiIiIOhgGekRERERERB0MAz0iIiIiIqIOhoEeERERERFRB8NAj4iIiIiITlvNxuHU9u8zAz0iIiIiIjpldnZ2+rGwsJDvYisoKCiAlZWV6X1vjG1rvBgiIiIiIuqYbGxs4OnpidTUVP3c2dlZAxEy7ypeeXk5cnNz9ZD3W973E7Gq4horERERERGdZiCSnJyM7Oxsvo8tSII7f39/eHh4nDSYZqBHRERERERmUVFRgbKyMr6bLcDW1lYDvaauljLQIyIiIiIi6mBYjIWIiIiIiKiDYaBHRERERETUwTDQI6q2e/duXHLJJYiIiICjoyNCQkIwefJkvPHGGy3yHu3btw9PPPEEYmNjLe6/wT333IMhQ4bA29tbK2f17t1bX2t+/v+3dx7gUdVZG3/TJr33npDQey+KgCCIiAV0bbsi9q6ra2F31XV1xbauuvpZV3F17QWxgApSld47JAQIpPfe53vOmcyYhCQkkDDJzPvzuc6dyWTm5jJz7v89tcTah0YI6eLQljZPcnKyXluktmbTpk1n+F+FEGKPsEaPEAC//vorJk2ahJiYGMyZMwdhYWFITU3FunXr9OKclJTU4efp888/x+WXX47ly5dj4sSJXerf4eyzz8bw4cORmJioC5OtW7finXfewYgRI7Bq1So4OtJHRAg5EdrSlrnooovw888/6/yrjRs3qj0lhJDOhHP0CAHwj3/8Q9vUysVX5pI0xDwTxp5Ys2bNCY8lJCTgT3/6EzZs2IAxY8ZY5bgIIV0b2tLm+eGHH3R78MEH8eSTT57hfxVCiL1Ctzwh9Sk1/fv3P0HkCTKrxMyECRMwePDgZs9Z7969MW3aNMv9jz/+WKNi3t7e8PHxwcCBA/HSSy/pzxYsWKDRPEEiiZLKI9uKFSssv7948WKMHz8enp6e+hozZszA7t27G73nddddBy8vLxw9ehQXXnih7kvK6auvvmpJoTr33HP1NSQl9cMPPzzlf++4uDi95XwcQkhL0JaeiLSZv+eee3QThxkhhJwpKPQIAVQEbd68Gbt27Wr1fPzhD3/Ajh07TnieRAIPHDiA3//+93r/p59+wlVXXQV/f38888wzePrppzU985dfftGfn3POObj77rt1/89//jPef/993aQWTpB9EXYi3OT3H3nkEa3pk5TKpjV9Mq9m+vTpiI6OxrPPPquC7M4771Qxef7552t6kLyGiMVrr70WKSkpbfo3r6mpQU5ODtLS0vDjjz/ir3/9q77GqFGj+JkhhDQLbemJvPjii8jPz1cbSgghZxQjIcT4448/Gp2cnHQbO3as8cEHHzT+8MMPxqqqqkZnp6CgwOjm5mZ86KGHGj1+9913Gz09PY0lJSV6/5577jH6+PgYa2pqWjy7n332mVG+gsuXL2/0eHFxsdHPz8940003NXo8IyPD6Ovr2+jxOXPm6Gs89dRTlsfy8/ON7u7uRgcHB+PHH39seXzfvn363Mcee6xN/+Jr167V55u33r17n3CshBDSENrSxqSnpxu9vb2Nb7zxht5/99131Z5u3LiRHxxCSKfDiB4hgHbXXLt2rRbLb9++XSNjkoYpaZCLFi2ynCOp47v44ovx0UcfiZPEElH75JNPcMkll2iKpCApoFJwL5G99iK/I+mREhGUiJp5c3JywujRo7V5S1NuvPFGy768t6SRyrH87ne/szwuj8nPDh061Kbj6Nevnx7LwoULta5EXo9dNwkhrUFb2piHHnoIPXr0aGSjCSHkTEGhR0g9I0eOxJdffqkpNtJwZN68eSguLtaRC5I2aUbSH6UmbvXq1Xp/6dKlyMzM1LROM7fffjt69eqlKZVRUVG4/vrrsWTJkjad64MHD+qt1NYFBwc32iSFsmlzGOmKKT9riAhSeV+p+2v6uPx9bUHqCqdMmaLCVlI/77//ft0XIUwIIS1BW2pCujZLGv6//vUvdiomhFgFdt0kpAkGg0EXKrKJWJs7dy4+++wzPPbYY/pzifSFhobigw8+0Fo7uZVxDCKKGjZw2bZtm3ZZk6Yqsr377rsqEt97771Wz3ldXZ3eygJBXveEL61z46+tRPqao6XHzZHI9jJr1iwVs9JkpqWGNIQQYsbebalkQkhDrfj4eEtttWRnCOnp6eowlJE+hBDSWVDoEdIK5jlHclFueNG/+uqrtdmJRLoktfGmm246YTEgi5yZM2fqJgsOifK98cYb2lhF5tM1jbaZMXdlkwVOwwWPtamsrNS/o7Cw0NqHQgjpZtijLRUhd+TIERV6TZEyAcmwYBdjQkhnwtRNQgCte2vOO/v9999b6tsaIpEtSYG85ZZbtG7N3G3TTG5ubuMvmqMjBg0aZBFMgrmer+mFXrzckjb51FNPaVvupmRnZ3fqv5kcT3Pv+/bbb+sth/wSQlqCtvQ33nzzTXz11VeNtrvuukt/9vzzz+N///sfP0iEkE6FET1CAL34lpWV4dJLL0WfPn1QVVWFX3/9VZusyLgCSTlqyNChQzFgwABNQ5KRCMOGDWv0cym8z8vL0zo7qZUTr+6///1vDBkyxDJCQfbFcy2ebImSubq66vPF+/zaa6+pmJTXvfLKK7UGT7zD3333Hc466yy88sornfbvJrP8ZPSD1Cb27NlTz4XUI0r9ooi8pqKWEELM0Jb+xtSpU0/4YJgdezKTlU4zQkin0/mNPQnp+ixevNh4/fXXG/v06WP08vIyGgwGY2JiovGuu+4yZmZmNvs7zz777AmjDcx8/vnnxqlTpxpDQkL0tWJiYoy33HKLttpuyFtvvWXs0aOHjnVoOmpB9qdNm6YjFWSkQ0JCgvG6664zbtq0qdF4BRnr0JQJEyYY+/fvf8LjsbGxxhkzZrR6LpKSkozXXnutHpeMaZD3lteSsQzm8RGEENIctKWtw/EKhJAziYP8r/PlJCG2x0svvYQ//vGPWmTPgnpCCKEtJYSQrgSFHiGngPhHpPNkYGBgs3PtCCGE0JYSQog1YY0eIe1AhqDLAHURdzt37sTXX3/N80cIIe2EtpQQQjofRvQIaQeSpimtsv38/LTF9z/+8Q+eP0IIaSe0pYQQ0vlQ6BFCCCGEEEKIjcE5eoQQQgghhBBiY1DoEUIIIYQQQoiNQaFHCCGEEEIIITYGu26ehLq6OqSlpcHb2xsODg5n5l+FEEKsPD6kuLgYERERcHQ8fX8g7SghxB7paFtKSHuh0DsJIvKio6PbfWIJIaS7k5qaiqioqNN+HdpRQog901G2lJD2QqF3EiSSZ/6S+vj4tPsEE0JId6OoqEgdXGb7d7rQjhJC7JGOtqWEtBcKvZNgTtcUkUehRwixJzoqXZ12lBBiz7D0h1gLJgx3MfLy8jBq1CjdZJ8QQgjtKCGEENJeGNHrYiQnJ2Pjxo2W/YCAAGsfEiGEdCtoRwkhhBA7iOgVFBRgxIgRGDJkCAYMGIC33noLXRk3NzftzCSb7BNCCKEdJYQQQtqLzUf0pAB21apV8PDwQGlpqYq9WbNmITAwEF2RgQMHora21tqHQQgh3RbaUUIIIcQOInpOTk4q8oTKykqdaSIbIYQQQgghhNgqXV7oSTRu5syZOmxSuhYtXLjwhOe8+uqriIuL01TH0aNHY8OGDSekbw4ePFhnmDzwwAMICgo6g38BIYQQQgghhJxZurzQk3RLEWki5prjk08+wX333YfHHnsMW7Zs0edOmzYNWVlZluf4+flh+/btSElJwYcffojMzEx0VXbu3Gmp0ZN9QgghtKOEEEKIzQm96dOn48knn8Sll17a7M9feOEF3HTTTZg7dy769euH119/XVM133nnnROeGxoaqkJw9erV6KpUVFRY0ktlnxBCCO0oIYQQYlfNWKqqqrB582bMmzfP8phEwqZMmYK1a9fqfYneifCTpiyFhYWaCnrbbbe1+JpSxyebmaKiIpxJEhISMHbsWMs+IYR0N2hHCSGEEOvTrYVeTk6OdqiUSF1D5P6+fft0/8iRI7j55pstUbK77rpLO7K1xPz58/H444/DWsjcvF9//dVq708IIacL7SghhBBifbq10GsLo0aNwrZt29r8fIkOSs1fw4hedHR0Jx0dIYTYHrSjhBBCiPXp1kJPumfK+ISmzVXkflhY2Cm9pqurq27WIi8vD7Nnz9b9L774QiN8hBDSnaAdJYQQQqxPl2/G0hoGgwHDhw/HsmXLLI/V1dXpfXOdW3cjOTkZK1as0E32CSGE0I4SQgghNhfRKykpQVJSkuW+jEiQVEyJdMXExGia5Zw5czBixAhN03zxxRd1JIN04eyOyCxAmRdo3ieEEEI7SgghhNic0Nu0aRMmTZpkuW+unxNxt2DBAlxxxRXIzs7Go48+ioyMDAwZMgRLliw5oUFLd0EaxUhUkhBCCO0oIYQQcqo4GKUVJWkRacbi6+uroxl8fHx4pgghNk9H273Teb2Ssgp4eTC7gRDS/eAaklibbl2jRwghxHZZvikJ0XP+i0fe+NHah0IIIYR0Oyj0uhg7d+7UTqKyyT4hhNgr1722DtF94/HuthK8tWhTm3+PdpQQQgih0OtyVFRUaI2ebLJPCCH2ypChCTh7UDiGDI7EK8uPtPn3aEcJIYSQbtCMxd5ISEjA4MGDLfuEEGKvDOsZiDAfA8J8DSgrbbvji3aUEEIIodDrcsjYCBkfQQgh9s6oWF8cK6xAmLcBvSL92vx7tKOEEEIIUzcJIYR0Uc7vHYLiihqdLRri62rtwyGEEEK6FWzG0sXIy8vDrFmzdJN9QgixV0TglZZX6767wanNv0c7SgghhFDodTmSk5Px1Vdf6Sb7hBBiz7g6m/yRrs5OSDqW26bfoR0lhBBCKPS6HG5ubs3uE0KIPdIrxFtvDc4O+Hj1wTb9Du0oIYQQwmYsXY6BAwfCaDRa+zAIIaRLMCDCB8uTc+Di6ID1KUVt+h3aUUIIIYQRPUIIIV2YaD9TZoOjowNqDC7WPhxCCCGk28BmLIQQQrosUptXW2fKcgjw97T24RBCCCHdBgq9LkZSUhKcnZ11k31CCLF3qmrr9DbAx71Nz6cdJYQQQlij1+XIz89HbW2tZZ8QQuydyuo6uLs4wdvDuU3Ppx0lhBBCKPS6HBEREejVq5dlnxBC7J3KanF+ucDTtW1Cj3aUEEIIodDrFLILyjDn+R+xN60YSW9dAyentmfIRkZGYv/+/fxsEkJIPU5w0Fs3F0ccTs9HXLg/7SghhBByElij1wnsTc3DcUdPBCdE4/PVBzrjLQghxG6ICfDQW4OTIz5ZSUcYIYQQ0hYo9DqBuKgADOsbgjF9g/F/S9s24NdMXl4ebrnlFt1knxBC7J2BEaah6c5ODlh58OR2kXaUEEIIYepmp+Dp6oSRsT5wdnTArmTTAqWtJCcn480339T9G2+8EQEBAfycEkLsmh5BnlifWqA2tdLZcNLn044SQgghjOh1CgHuBjjIfw4O6BvbPqHm5ubW7D4hhNgrni5OqDOaZukFBZ7ceUY7SgghhDCi1ymIwCupqIafpwFh/m4wGo36WFsYOHCgPp8QQshvNrWqxgg3FwcE+p7cAUY7SgghhDCi12k41+s6HzdnHEzN4WeNEEJOg8oa09B0H8+Tp24SQgghhEKv0xgW7W/pEvfh6kP8rBFCyGlQpbP0AE+DE88jIYQQ0gbYdbOTGBRuqiOREXo7M4rb/HtJSUkwGAy6yT4hhBAA9Sntbi5OKCgqox0lhBBCTgKFXifh52H4rTavHU1V8vPzUV1drZvsE0IIAUK8TXbU4OyAHzam0I4SQgghJ4FCr5MQgVdTZ/JAe3m5obbWlHZ0MiIiIhAVFaWb7BNCCAH6hpmyJFycHPHDrnTaUUIIIeQkUOh1ItIlTpAucQ+/sbJNvxMZGYnU1FTdZJ8QQgjQN8RLT4OzI5BVSTtKCCGEnAwKvU7EPPcpwMsVq9PKO/OtCCHEpvH3cLGkw3t6uVv7cAghhJAuj7O1D8CW6RHoiezSSgR5uiAiqm2D08vLyzF//nzdnzdvHtzduaAhhBAReNW1Rq3R86mv16MdJYQQQlqGQq8TmdIzCP/begxOjg6Ir68vORm7du3CE088ofszZ87EyJEjO/MQCSGk2yB1zzJFz9219UsX7SghhBDC1M1OxcvVGfml1aZ9Nxd+3ggh5DSorW9wZXDhLD1CCCGkUyN6FRUVcGvH6AB7pKLK1G3To41DfiWCJ3UohBBCGlNT2zahRztKCCGEnEJEr66uTlMLpSOkl5cXDh06pI8/8sgj+M9//sNz2gQvF9MpdnVxxP4j2Tw/hBByilTX1umtQVpvEkIIIaRV2n21fPLJJ7FgwQI8++yzMBikWsLEgAED8Pbbb7f35WyeYTF+emtwcsAbP+639uEQQki3j+i5ODlY+1AIIYQQ2xN6//3vf/Hmm2/immuugZPTb+kzgwcPxr59+zr6+Lo9QyJ99dbZ0QH78itO+vykpCRNh5VN9gkhhJioqjGlwjs7tX7poh0lhBBCTqFG7/jx40hMTGw2pbO62tR4hPyGn4dBGwhI583AQJ+Tnpr8/HxUVlZa9gkhhJioqqmzOM5oRwkhhJAOFnr9+vXD6tWrERsb2+jxzz//HEOHDm3vy9k8jg4OKKuqhbebM8KCPE/6/IiICISEhFj2CSGEmKiqb27leBKhRztKCCGEnILQe/TRRzFnzhyN7EkU78svv8T+/fs1pfPbb7/lOW2G4vIaFXrhfm6oMxpV/LWENLnJzMzkeSSEkCZU16duSuamdCeWIeq0o4QQQkgH1ehdfPHF+Oabb7B06VJ4enqq8Nu7d68+dt5557X35eyCnMIKXZSI2NubWWztwyGEkG5Jbb3QE2dZYUWNtQ+HEEIIsb05euPHj8dPP/3U8Udjo+Tnl6Iw1At+7s7YmVGM/mEt1+qVl5drV1Phuuuug7u7+xk8UkII6bqY43eSuZleVAk/d5dmn0c7SgghhJxCRK87cumll8Lf3x+XXXaZVd4/yOCArOIq3S8sr0ZN/Syo5ti1axduv/123WSfEEKICbf6Rs8S0UsvNjWtoh0lhBBCOkjoOTo66liFlrauyD333KM1hNZiYJQ3soorNX1Tmggs2Z9ltWMhhJDuip+7qyWidzC7VG0qIYQQQjoodfOrr75qdF9GKmzduhXvvfceHn/8cXRFJk6ciBUrVljt/YcnhOCn9GPILa1BkJeLphxJVK+5WVAjR47k4oUQQpqhT5g3iuqbsOSUVmH1oTyckxBIO0oIIYR0VDOWhpukQ/7jH//As88+i0WLFqGjWbVqFWbOnKntsuXivnDhwhOe8+qrryIuLk6HjI8ePRobNmxAV6JvdAAqq+uQlF2mXTel0GTD0QJrHxYhhHQrzu4TioNZZbof7OWC9akFeGd9Kp1jhBBCSGfW6I0ZMwbLli1DR1NaWorBgwermGuOTz75BPfddx8ee+wxbNmyRZ87bdo0ZGV1nfRIV4MzSsqrUGsESitNXeM2pBaiupVaPUIIIY2J8HfH1iOFyKmveZYGV1V1tXhrfSqySlqu2SOEEELskQ4RetLh7OWXX9YZcB3N9OnT8eSTT2pDleZ44YUXcNNNN2Hu3Lk6zP3111+Hh4cH3nnnnVN6v8rKShQVFTXaOoKSsmrU1hlRVGESehLZ+2RbOkrrBwCbSUpK0uOXTfYJIaS70Vl2VJqwVFXVYNXBXKzZk4mqmjo46fD0Ory1LhW/Hs7X59GOEkIIIacg9KR7ZUBAgGWT+97e3iqsnnvuuTN6TquqqrB582ZMmTKlUbMYub927dpTes358+fD19fXskVHR3fIsVZX1aKqphYF5abZT56ujtifXYp3NhxTAWgmPz9fhbNssk8IId2NzrKjSnUNJBkiKbsC1bVAdnGVpvUHeDpj1aFc7MssoR0lhBBCTqUZy7/+9S+9qDYUVsHBwVobJ6LvTJKTk4Pa2lqEhoY2elzu79u3z3JfhN/27ds1DTQqKgqfffYZxo4d2+xrzps3T1NBzYgnuiMWKRUV1aiuqVOhJ2V64pn2dXdGRnGl1uuNjTOdO6lFNJ9H2SeEkO5GZ9lRId7XBel1gKenAa6ODtiZUw5fD2cYnBwR6OmCFYdyYDD6o0ffQcjPSKUdJYQQYre0W+jJEO/uxtKlS9v8XFdXV906mvLSCk0zEjKLKxHm44pIH1fkl9Vg6cFchPu4IdbfTdNf8/LyOvz9CSHkTNFZdlR44IJ+uPWz3fBwd8GKfVmICPLGltRiTOkViDIJ8TkCtXDBQ+98rSPWdxa7wK20CoGehk45HkIIIaRbC70dO3a0+QUHDRqEM0VQUJDO7svMzGz0uNwPCwtDV6KyogpV1bWapplWWKVCr6y6BhE+rkgrqtRmArI/MMwb/cK8EMRFCSGEnMCA2AAUF1fC3c0Z+ZV1uDTGF0v25+DXlALMHRWlTa62pRXpzFIhtbBcNzdnJ4yI8kXPYC841/+MEEIIgb0LvSFDhmi65smG08pzJJXyTGEwGDB8+HDt9nnJJZfoY3V1dXr/zjvvRFeiR4AbKiprUVRWBSdHV5RU1sLL1Qnebo7o6+aBpJxyFXzHCsqxaEsyYt2qcPnZgxDm723tQyeEkC5FdVUNKitr4ebmjOziCoT7uOp80pdXH8Hlg8Nw7ZAQLFmzEZnwRp2HH1ycHVFRU4s1h/N0C/FyxdgYf4R4d07UkRBCCOk2Qi8lJQXWoqSkpFH3STmWbdu2aSOYmJgYrQOZM2cORowYgVGjRuHFF1/UWjzpwtmV+PmJGej9wHdwcgrQGr3DuU4YEOGFyvp0ztmDQlFYUYtfdx/CK3+/Qx87/vjruHR4D4yK8W1UF0kIIXZNdTUqK2tU6P1yKB//uXowvt6dhR/35+CrnZkoz0zB5VMn6FNlrqpjeE+N8lXV1mk0T0YxLNydDhcnR8T5e6BXsKemz0vtNCGEEGJXQi82NhbWYtOmTZg0aZLlvrnAX8TdggULcMUVVyA7OxuPPvooMjIyNPq4ZMmSExq0WBtnJ0dUFJcjO7sUjqEO2JtWDHcXR/i4OyPYy4BNxwowKtof54TU4dGU/fANiUCt0QGL9mRhd2YJhkR4IyHIA75uLtb+UwghxKp4ORlRVV2nWSZ5ZdW6XTU0HGmFFdiVUYLPkqpg8PRBValprMPwKD/djuaXYWNqoQo9ZycH1NQZkZRbqptkc0b6uFtEn7uLE/+VCSGEdGscjCfLx2yBPXv24OjRozrioCEXXXQRbAnpFiftwQsLC+Hj43NarxV/yydw8fWBv587fH3d9LHRPQLg7yEpnCbN7QAjItyBXr5OSK1wwYrDxboYMRPmbcDwKF+MiPbVLnOEENKV7V5nvN71Ly7D1kIH+Pq4wmBwwqSegXjovERU1xrxv83HsfygdGSugoezI0bGBuKyoVEnNGPZm1mM1Sl5OstUnG6meXy/4WlwQoyfu0b8RPg1/TkhhJxp20dIpwu9Q4cO6fDynTt3NqrbM6cWnskave72JR1272fIM7rBP8ATnp4u2jXOx80ZvcK8UQcjYvxdNZXIjNTw9Qjw1M6ch/LKkFZYCfM/VpSvGy4ZEKq1KYQQYk9Cb+X2I7jnyyS1ozJmQUgM8sCdE+LRL8wbu9KLsWDjMeSUVltE2/ge/hgc4aPPa2hniypqsCujCMk5ZcgurYSrsyMMzo2daJLuKTY30tcdvm7OCPV2Y0MXQsgZt32EdLrQmzlzpna6fPvttxEfH6/1D7m5ubj//vvx/PPPY/z48bAlOvJLOvsfi7ExoxrePm5wdXVGeLAnquuM2mWz0giUV9ch0NMZcQHucHNxbLTISAzyxNAIX+zMKMbSA7moqK/tC/RwQXygB2L93PQ5IhwJIcSWhZ5ctno9uBje3m4q9LzcnVFrBFycHPCnyQmYkBioHY4PZpfio63pSC2osPyuPCcx0AOhPq7oE+KFgeFe8DSY7GZ+eTUO55XjQHYJDueVqeBrLton9yS1M8LHDVF+bppSH+hhYNSPENKpto+QThd6MtLg559/1jEK8uEVode7d299TMTe1q1bYUt05Jf0xS8245/Lj8HZ2Qn+/h5wcHRAUIC7RununRiPoqparDuQjm9fewLOTk743R//hr6R/iipMkVJvV2dEeDhAoOjI44VVqgHusqk9xRZiwyJ8EHPIA9E+7nDz92ZTVwIIVa1e53xekLsDf+Dwd8fnl6uOkphYJwf0otNpQTBrtX45sFLgJpq7Ni1B1nwwvbjxdiZXoyiypoTRFuApwt6BnkiwtcV4+L8dbyNXBrF+bYnswQ704uQV1al3TtFKLY0nkHE37BIX/TiCAdCCIUe6QK0O/wjqZne3t4W0ZeWlqZCTxq27N+/vzOO0WY4b2gU/v71fnj5eqGkpEK90aXl1ZrC+dqaI3jrqkFIqDmOV35dAldvP+xPL0BxjTPO6x2A9OIKFFfW6GYmws8V7s6OcHR0RFF5DVILK7HleJFuQpCnC/qGeKFnsCfiA9zZUY4QYjO8esNI3PrBHnVmidjbkVKAhHAvlNTUITWzEKVlFairLEd2ZjpGjRyJUTF+Kt5kDMPBnDKkF1VgR1qxjrXJLa1GbmmBvu6XOzIR7GnQzIqze/ir7Rwe5aPZF/K8zOIKbZCVX1aN6jpTF08RfxL1K6+uxS+H8/BLSp5mZYhgNL2Wh0b82D2ZEEJIlxZ6AwYMwPbt2zVtc/To0Xj22Wd1nt2bb76JHj16dM5R2gjx4X6oLq9AjYcbJJEo2AcoLa1GoLcrymvq8N76Y/h9vwh4uBng5OQATw9XTSX6dFumirapvYO0Q2duWRXSiip0NIP8HlAHJydgQJgnpFQyr6xGFzNSn7I6JV83qVHpH/qb6GNHOUJId2bS0FhUvLYBjk6OMLg4wsXVBcnpJfByc4aPlzv84gZIkic+OFCDgLhSJASLfXRAhK+bbsKVQ001ejK/VMSf1PbJbXZplW7SoVMQsTYg3EtTNSXV/uoIH30tGc5+KLcM2SVVyCipVPEo3TxF/El6vWReyLY1zeR8k8dF8Em9X7CXK7xcnbXmj2MdCCGEdInUzR9++EHn1M2aNUvn21144YU4cOAAAgMD8cknn+Dcc8+FLdGRKUdyqr0vfQMuXt7w8ffWBYqfvwc83Zzg4eUKb1cnfHbDCMtFv6SyBt/szsLK5DxLTZ40Chgb54fJiYEI8TbgcH45juaX43B+WaP38jI46etU1RqRVVKlA9plX5BXlyYuPQI9VPTJLTt4EkI6w+51xuuZ8brwRfjFxKktndQ/FAXVdTiaV66pnOGBHqiqv7yJmLp6RCTO6xOs4qo1xO5KTd/mY4XYdrxII3f1ptNCiJdBxzBI1E8avIgDzmzjM4srsTfTNLJBhrTLr7o6O7Qo5pwcHODn7oLewV5acy3HJ445Rv8I6f6wRo90G6EnA8lvvPFGXH311SdcqPPy8uDv72+TF6aO/pJ6z3wZjl7+CA3xQUWdAyLDfVBRXYewYA9dTLxy+QD0CvFq9DsV1bX4fm821h8pQGbJb+MsRKz1DvZU4Sce4qOF0kSgFDmllWgwkcGCi6MDSirr1FNdrxsVKTcRj3WYt6tuIvykVoVeZkLsk+4i9EKmP4WaoDh4+pqidb4eLrjyrDh8sTVdBVb/KB+4e7jgSF65Pj/Iy4BrRkRiXLyMtWnbTFLJnJDaPmnOIo1a9mWVNhp5I1c9SdGULski/AaFe6NvqBfc6ufw1RmNKCivRlJOGQ7mlCK3tApGGDW6J9G/luysh4uTCkgZ8SDjHUT8OTtypA4h3QkKPdJthN4NN9yAzz77TGv0Zs+ejeuvvx4TJ06ErdPRX1K/Gc/D6BMKT09XOLu7YVC8P44XV8PHxxWuBie4ONThnEg3XDwwELHhIXB3d7f8rvxTySJj2cFcbD1epF3lzMT6u+PcngHoEeChkT4Rc5KSVFhRjcLyahwrqkDDf2lp7CLCMrOoEvnlNScIQ4OTg3qsZZEhzV1kwWGLQp4Q0n2FXr/LnkWqMQAGT0/ER/kjq74ZS58ID2QXl+hcvbAgf5w/JAqbjhXqYHWzc0vq5nqGeGo6e5/6tPa22DhxvO3NKkVKbhn2ZpZoqmdTRMSJEy4x2EM7cooQjPJzhb+7i76H1PKZMjHKkV1SiYKKGrXv8nsy+aG545Cfy+PisJPUe0kBjfR1U9vvUd81lBDStaDQI90qdbOsrAyffvopFixYgNWrV2udngi+OXPmIDIyErZIR39Jwy58BmVe4XBydoK3v6mpzZi+oTonLy7MC1mZmfj1ySthrKvDF0uW4eKJY5q96JdV1WJ3RjF2ZZRg7eF8S1qmEOplQI8gD0T6uMHX3RkJQR66gNifXaI1f1kllY1EnyA/d3N20tc5Xmiq/2sY9ZMawfgA6ebphmhfN/WMM+JHiG3SXYTelJtfwbpMRzh5eOO6SYkoNjpi6a5MVOWlIfOjOwAHR/S5+z24+YXh5gnxcHJxxI60IhzIKj3htTwMTjqeRjob9wgyCUDZYgPcG83da4rU54lDTRxm+zJLtMGLONqaQzohix2VaKLsiwAUmyoRO7kUF1bUaHdPc7OYqloxwiYB2JoIFXsu4tXV2Un/jjAv1/o6QANFICFWhEKPdLsaPTPJycl499138f7772vnzalTp2rUT2r3bImO/pImzH4eWQ7+cHQx4IKxPfDLwVxLVE8u/lf1AW67/Hxx6WLcXz9GREQ4xsX746yEAPQO8Wq2vkRqSpYn5Wk9ydGCcvViN0Vq+8K8DQjxclXRZnCWhQNQVl2L0vrxDU0xLyukvq+yxqiLDnlteXlXJ0dE+rpqbYnU+cmCRRZIrC0hpPvTXYTeDY/8Fx9vyYezTwCGxgdg+T8uQFJmCS75+2fY89qN+pybXvoaG/M9df+uyT1w/oBQTZk8kF2GpOxSHMwqxc60IksddFNEZMUFeqjoE1E2KNJHI2meLdT6ySU1o7hSBZ80xRLxJs412W8upV6Qjp0RPqbUeRFn2q3Ty7T5uzujuKIGmSWVmrovmRqyie3WKKBT61FIyfwQp5ybs6NePySqKK8v7yU224npoIR0GhR6pNsKPTPy61988QVuueUWFBQUaGqnLdHRX9LB17yE5BIDnDy8cOm4OPx8IF9bcw9MDMKR3HJM7RuA/oZMrEytQrpjIGrQ2JMs3eIGhnvj0sFh6nVuNq0oswTHCys1MpdbVo2UvLJmxZ85RVMXGD6u8HZz0sYAdTBq3WBtCx+NujoRfUZ9TdPtbwJQmsCEertaFi0yTFgaDDDtk5DuQ3cRen9+cSFe/G4/XIIi9P7Oly9FTLAXvt10GLe+8DVqagHvsFhcOCYeKw7kWn5P5uYNjPLFyDh/nNMrEIFeBuSUVKOkqkbT2ZNyTAJQbsXR1Rye9bZOtpgAd0zqGYgYf3c4txD9kywJscVilwvKa1BQVq3iTRq/yLy+lhAZJw41iQCab6WmWmq0RQhKDaA03JJuzEWVtSirMolA+b2mg96bu34bYeoSKqN6JKVfuoHK64d6G3SQPG03IacOhR7p1kJvxYoVGtUToefs7Iwrr7wSr7/+OmyJjv6Snnvr61iXWgEXn0D0jvSFl78XkjJKMGdCD3y7O0uf0z/CG3+e0RuJoV7YfqwIaw7lYcORfJ3h1JDeIZ4YEeOHkbF+6BdmSgNtyaMrCwqpX5GOcLIokFtpDtCSF1uEWp9QT11IiCe4sqYWhTLHT2pJWnifxgKwzrIv0cRQL1f1hls81Z6SUmRqVkAI6Vp0F6H3wntL8Zf/rIFLRDwcHBzh72XAsiemIyHMB/vTizDv4x3YdChPsxdmj41Vm5deUNGomYogNi4uyAMj4/0RE+ABT1cn9Aj2RK9QL43OSeQvKbsMh3JK1ZEmEbXmEMEkTjMVS/UROUlzN+27arfOppFAuQTLKBwZ8SC2WUc7lFQhp/62YVp+c+jAdw+XetFpitSJrZWoo/ymCEuJKEp9oghZEZwiDkUDnkzEmesC5e8SO+5pcIaXwRQVFKej/D1M4SekZSj0SLcTeseOHdMaPdkOHTqE8ePHa8rm5Zdf3qhxiK3Q0V/SuY/+Dx+vS4MhMEzvP3bNCLz4w0H4uDvjDxMT8MWWNEv0bWCUD4ZG+2F4nB/O7hmoiwvxMv+wN0vFX8O1yswBoRgd64eQeg+zextElAhAWVSkF1bgeFEl0gorNL0otZmFkHkxJN04pauct5szHGDUIcJSnyLH1tIHST5i8ifViPCrM+r7VtUY1dssCxQRfZZ0JU+DprBy8UCI9eguQu/NT1fjnpd/gINPILwCgzXFXPi/W8fhmgkJqKqpw8MfbcfnG1L18bhgT8waFY1RiYFIyirF0r1Z2J9eUl8LdyKj4v3RN9wbY3oEoGeol0YCtZlKVa2KJ3GYZRRVYt3hfOxKK27RcdZcN00RgJF+pjo6idQNi/ZVMdjUdhZX1qrok6ZaUgeoddbyvsXy/lWtvqe7i6M2bZGmMD2DPFUEihiUFM6qmlr9/fTiCr0OiBOvpErG8NTVRwNbF4JybBKJFFsttYEBHs6I9nXX8gD5m5jGTwiFHulGQk+asLzzzjtYtmwZQkJCtAGLNGJJTEyELdPRC5S/vfINnvlqF5x9A+Ho6o4RiYHw8vPG1sP5GB7vj4fPC8eUadNQ5+yG+KuehIuHr/7e4GhfPDWrHyL8TGJaLvTbjhViRVIuNh01DfVtiKTgqHfXx01rS0QA9grx1FTKk3lxS6tqsCtdusmV6jBgWQy0VMcn4s/cwEBSieRi7+riqOmcskAprmze890Q8S6LsJS1lkQFRWOa60lkASReY/EeS1RQvMqEkM6luwi99xetw83zFwJe/pg0IhFZVc44mFaEyvIiOC1/FK5ORmzdth2v/5qHhZuOobRBGmakvzvO7h2MGyb2gLOzo0btfk3KVcEjomrb0cITnFfS7TLK3w1RAe6IlTmkQZ4a+YsP8lDnWk5JlUbQ5FY26agpUTnzdjJ7KDa7R6BEEj21JlsaaYkNbMlmm4WgCE4VnSLciipwrECieDLGoXkkxV4ij+IUNI3VkVRN032xsTW1dZr2LwJQmsMUlosIrNG5gGKrTRHBlq8j8nOx49Ih1DwUPshTuo46w8fNRcWubDLvkBBbhhE90m2EnsFgwIwZMzR6d8EFF8DRTgq4O/pL+q//LsWf/7MGcPWER0i4RrleuHEMnl98QBchvT0KsfTZa/W5//xwGcq8IrBkV6ZFaEla54TeQVpb0jfCWz2pa1Py8NP+HKTpxb2yxZoSQbzIQyJ9EOXnrl5XEVDSWvxktRxS+yeeZBkELDOl5OIvC4nWaktEAEqjFlm8yL6IN2kcIIsAeS2JAjYXOWwO+ZhKNNABDjrcXV5PPNUyAkJSlBgBJMT+hN5nP2zGtY9+BPgEY1ivMKx55Vr8+f1N+NfHS1G5+M/6nPXrN2DUqJEorazBos3H8X8/HcSRZkYiiKPtqSsGoXe4jwqQ3WlFWJechyO5Zdh4OB+ZhZUtCich1MdVBZ9Z/PWP9EHPUM9Gs+9krIJJAJpEoMz3EzsoaZt7M0qafX0RXjIyR0TYoAgfjfzJyAZ5rDWnnaRoysw+EYB7Mks0U0OcdmJ7W0NqqqXWMMbfTUWgiDQRZ9LEyzwbUFBBWViu9YYiYCWzQ65nli5ebUCEoLymRP/EpktaqKT0e9Q/5uHiDDcXR9p30m2h0CPdRuhlZWVpJM/e6Ogv6dufr8Fd/1oMePhgQP8EHMgs14vYXRcPxPu/HkV5US6yP38QTsZqrF7zC0YP6YdD2aV44pt92JbaOHInF0SpIQn1FU+sGyL93TCxdzA83Zws9XhH88p13pPs788sUbHUFBFgwd4GFU4S8ZMOc3LRlcVEuK+rRgObE1ISfUsvrlQRKhHGY4UmT7LcysW/NSQCKAIt3NugaaCymJE0I9kXj7osRqSbqKQltdQURpCPr6RraTMBFydN/5TX9XNz0TpD1wYLE0KIbQm9b1fswOV/ehfwD0OgjzuOfXG32oRJD3yIlf++TZ8z7tZ/4/v5V8HXw6D35ee5JVXYebQALy45gD3HClUUNbSrPcO80Svcu9FtsLer2tHUvHIckxl4kvGQXYqUnDIVb80hryWRQ7HT0rBF0kDldfw8XODv6aKOOjNi96RZS3J2qY5p2J9Vqmn1LVk/GfuQGCTZGgb0D/dGtJ+72uq2OO2ke6cpAliJzKIqvZWtpcwNM5JdIRkiQyK81VEoaZoNa63VIVdrRHFVDVILyrUcQN5LbLmk7IujTxp+nSwttCHyfHlfEbrBnq46mN7TYHIcslEM6epQ6JFu33XT1unoL+lH32/E9X//DPAOxNj+UQiLjsB3m44hwMsVnz48GQtWpeCbLWn6XEkFGp0QiAn9QjBnfBzyy6qx+mCujmTYerRA7zdFLp0S6QuSOglvAxJkDpS0Bg/1UhG1J6MEu9OLVZhJ9C85p6zFxgJmRIDFBnjowkKGDMcFmm5FrLV0oZULu0T85PWlvsS0Vetta4sJeTkZ0i6NZkSoxenoBhftDCcecHnNjGIRktXNitaGyEdbFj3uLs7qIdYUU2kt7mVAgLtB/y4uFAjpvkJv2bq9uPD2/wMCo/R+5sJ74ePpioLSKjz+8Va8vzxJ08jD/d1x70X9ce7ACPSKNKXDN7QTe44X4ZHPdmL7kfwWOxSbBaBZ/A2L98eQWH8YnB1RVF6NQzllSFHhV6r1fzuPFakdbAmxnOHSNMXPDeMSAzUSKPfFZpvFmhy7RP9UYOaX49eUfBWWEj1rzvyJw0uicfKaIsJknmpisKc+djIBKMjxSurp0fwKHMkv14igjIeQrSW7rY1ZfFy1flsyRCJ8pBGMCLITm85IOqj8LfK6aUWVKghlJqw49OTozAPj5Vh1a6VhjPw5ntIcxtVJI4FSriBpr3I8hHQVKPSItaHQO8Nf0oYeaCF70R8x+ZEl2He8EHfO6IcnrxmG5Xuy8K/v92P70QLL7w2J9cNfL+2PUQmBlovm/owS9S5nFFVoS/A9aUXY2ky9nhkZ4yBtxCP93NW7PLFPMIbG+qKgrEYvvCLCpE5FBwBr4X810gsrW0yvlMjZiBhfBHoadJMaPVlgtFZTIsiCQTy9EvnTOVP1aZxyX+pNmkNEWcOmLVJfEuPnpn+TLB5ySiu1UYEIQPEcy9u3tLCRcyd/kkQKJRXUXA8ojQTk9WUgPCOBxJ7pLkLvl63JmHL9v+AUHIVaowN+euFqnD0w2vLzHYfz8Pt/rcSRrBLLYxMHhGHCgHCcNyQCA2MDGr2eCKvD2aU4kF6MgxnFensgoxgpWSXNCsAQH1f88YLeWusXE+jRyO5JirqIstS8MiRlmgSgNNPKL63S0Qot2VWxn2MSAjAoyge9RVjWO+kaInZuS2qhRhKP5Jdhf2applK2JFLFFkpUTOym1G1LSqbY6oERPtr8qi2IjT6aX44NRwtwrLBS37uoFSHr4+rcQPzJyB03TeNvzkEo50q6SovITCuq0PIDiTCKY0+igK5O4rAzpf6bxGDL1xfJDvF1NaWbavqnwckiCAPdDawLJGcUCj1ibSj0zvCXdMWG/Zh+y7+BIPFAO+Dis3vhhotH4bJnftaL1+u3jcPscXGaKrk5JR/rk3Lx4uL9ltQiqSNJDBWvsheGxQeod9m3wYVaUn1E8BWWVWvNnqQBSY3J4ZyyZlOA5KIpLcWlq1xiiKeOdJCIlzlVU4ry0worcTivDIfldfLKdV+EWksBNVlQyFBhc7F/XH00sGF9R3No7V6Z1AGW4GhBhb5PRlHriwnBVK/nYqo99HVT73Wgp4s2kxHhKr8v4yEkAijx65NlDDVsKe7mbKoVES9xrL+7LsLEe8wmAsSW6S5Cb8ueozjrmmfhFhSGCrjgmVvPxd2zRzZ6TkVVLd5ddgDfbUrFr/uy1BFkpl+0H8b3C8Xo3iEYnhCIuJDmx9Q0FYB7jxfh14M5amfNhIlwivZT2xwb5IlBMX7oE+HTrCgx1ts6scv70oux6Ui+OuuO5pY1W2MtokxE38whYTinV1DzqfQyT6+4UiOLEjUTJ5rYP7kvc/VawtvVCd5uLmpHxU6PivXTGm4RaCdrfiXROBFmco0w3x4vqjhhFFBDxJ5KloZkWci1RppsyXtL2YA48TxU0JneV/6tCuqdjuLQk3MmYyLyyqvVQSjOOrHTpvEPJjHYmpNR0kDFKSmzCCUCKLZcnHzSnMbT4NymqCch7YFCj3QroSfD0H/55RcMGjQIfn5+sAc6+ku6afcRjP/9c/AODkWx0QBfT1ekf3WPep2/3ZiKysJjqFz8F1kK4LufVuOCKWfjaE4pHv18F37enXnC68k1TYSfCMDh8QG4aHgE3A2Nvb/mJgDiSZbavbT8cuw8XoTl+7J1cdEUX3dnbSYg86T6RXjj/AGh8GmSDiOdOVcl5ang02hgianbm7x+cx8ouXyK8DOngJrTQOMDPU56cRWRa54pZb6VxgKysGipFlAWDhJhFOEniwfZl9lS0vWttLoO5dU1uigRr3FhZbW2SzfNqzKJvJMhCwZZBOkAYzdpIOCsiwwRhhIVlEUM00JJd6W7CL29yekYdtk/4O4fiHInD/xuUl+89+eLsHHjRowaNUqfs2HDBowcaRJ/SelF+OLXw9iWkosftx03NQ9pgET5bpveF5MGhJ/UmSMC8rWlSVi5Nws7jhY0G6GTWrzLRkfjunPiERPkedK/p6auTlM+1x/Kw970Eo0myviGpkKpd7g3+oR5abqnzP8Tex3gaapBbIopWlalr2PZisUJWKZdlVtC/nxp1CWCb0C4N8YnBJ4QWWzx3FSbInLHRQBqlM4kBCV9v6HQbgmxoYmSdhrkobWHoV6mhl4Nbap5vIMMipfacBGCIgplk6wRU1bHb2mg0vjlZNcag5OD2nKJRkoTGhGBIgjFrot9l/ts/EXaA4Ue6XYRPTc3N+zduxfx8fGwBzr6S7rvUAaGzn4Sfj4eKHEP1ojZwQ9vg5+3O15ctBuvfLQUmQsf0Of6zXwGH/3tapw/LMpSR5KcWYJDWSXYdjhfPcEi2hoS4GXArJFROG9gGPpF+jaK9jWHRPuW7c3CvvQSfT1pMtD0AyHeUmkc0CvUG2MTAjA0xlfTlJrWYJgFpcyTOpBdguz6Vt+ymJD23M0hkbeEIE9dTGjqp6/UrIg32bVNQklEoKT7yHvszihRz6/UsrQ0Y1i8131CvNA31EsHwod4GizeY6Gurg5HCyv0NUwNYWpRXlOrCxdRq3Iu2nKhl2dISqhn/UJB0pWkvbg8FuBh0NchpKvSXYTe4eM56Hvh3+Dq6YVKd3+EBXgh6cPbsGXL5maFXkPyiiuxfFc61u3LwsakHGxPkdmkJsMR5OOKMb1CMKRHIM7pH4pRPYNbtUflVTXYfqQAe9Ma2OgjBShpUP88IMoXZ/cJxgjJoOgZdILzrCUkcnUgowQ/78vGwi1pLc7Nk6jfzCHhOLdPMOKDPRp1+2wJaQAjHZTNDbB2HC/SOm6x281FFiVbQ9L+Zd6f1E+L8OsX5q22uy32WiKj4mCTGkOZ2SdRR4nSyXtLtkhr9dtaeuDhYikVkH1x4sk1RBqJSQqq2a7Kv6Okmor4M5UlmNP7q/UaJTbcnAYqQUundth1afolEUGx47IvUUER3+bIIB18pCEUeqTbCb0RI0bgmWeeweTJk2EPdPSX9FhmPnqe/4jObeo5eBD2HsnF109djqkje+jPs/KKcO/jL2PDoXwcc+kLb093PDR7EOae2xOBPm4nvF5OcSW2HM7HlpQ8fL3pOI43EX4xQR4YER+AS0ZEqRdY0otauxDJhVgWFSJ0krNKsXJ/ttaVNBfRkvq+niFeGBLjq+JMun+KV7m5C6ZczI/klWk7cbmVi7qIM0n9aY5ofzf0CPRAhK+pMcvoOP82p9WYvclH8iXCWKmzoEQMiie7OQEo9SrT+wbj7PiW30MWDhJJlAY28tqyeJBoYml1rYpwx/rGAbJwkOYMrSHvIV1BdW6Vl6tGUH1dXU76e4ScKbqL0MvIKUL8eX/W1IaAuETkFVfgiydmY9LgSCxYsECfc91118Hd3TR/tDWSM4rwf9/vxSdrUlDcZATBtKGRePSKoRgQ69/mYxMn3qp92Xjz52SsO5jTKNVdRN7FwyNx3YR4Tb9vK5pCmlOGvVI7mFlSn5ZfimP5FY2eJ5kGEukTe9xb0vxj/XT8g3T8PFkKvRnJ9tiZXqR12iuTcrU+ryWkDs5c9yfzWkWImVP2XRo40k6GRPtE7Ml7Seq9NPMSMSjpmidbqMhlR6JwIrpE+Ek9oAhBSQ+V+m5NCzU4WdJBZSSE1DSWS8aIzDvUmYGmaKA8x8nJZM/Nzj0xzycTcXL5cHVyRJi3m54D88gIRgPtFwo90u2E3pIlSzBv3jw88cQTGD58ODw9G6ejdORF3Ba/pAXFZQg/50Hdv/TSyfhq9QE8ccME/OnKMY2eV11Th7n/Xo1vNhzV+xEBHlg9fwaCmhF7lt+prcPqfdn4ZN1RbR1+LO/EC3OQtwG9wn3Uu3zpyCj0j2rcga4p8vGQC362DGhPLcTqAzla95fXQg2GjGa4e0oCzu4ZeNILfFVNnXYAFREmHmRJ8ZFFhYjMph01JU1Son1Do3xx5fAI+J5CZzU5Pyl55VoDKFtSTlmjdCvxUI+N9VNhKfV4bfHMyvkRz7SkrmaVVuFgdimSc8t0oeBYv0hwqW8mILfmNKLmcHd21MWBb70IlMWKLFzoISZnmu4i9AqLyxF2jikD4qbrLsRb326Hm8EZc84fhH/cOAGe7s2nM7aGROekicv6A9nYeDAH32w8qrW9wsOzB2HeZYPb/Zp5JZVYtjsTmw7l45cD2ThaP8dPTEy/SB+t6RvXMwgzhkYg0Nu13a8vEbmf92Zh4dZ0HMwsaTEyJvZoXGIAhsf6qwAcEOmjWQdtfQ9zfbZE5WT2nzi8Wpr/J0gGg0QAZeyD2G+pw5P6P0njb61rc3OiWerypPZP0vflVlI29Vbut9LcpmlGh3R1Fueapt3r5qw12CIE5XERdXKtkIigbDlaFyiOvWqNRBZVyND4OktTmN9uWxeCYvZ9XF3075b3FTtvHhXhyeHxNguFHul2Qq/hoPSm+fJyX+r4bImO/pLW1NTCe+Q9uv+3P12Fvy1Yg1B/T6x46feIC/c7Qex9vPoQ/v7JVmQVmjy2I3sGYXhCEC4/Kw5D4gMbpR02RVqM7zpWiIWbjmGLtOXOLj2hPkLahMtCY1C0H0YmBmJQtG+bLr6S4vlrUq5G/cS7LGJQomdm5AIW5e+OEB83TOkXjLMSA1usIWlKUUW1SQAWVGgt3prk3BO6cYq3dtbgcK0bEY/tqSBROklP+vVwPr7eldlo+LssCOIDPDAw3FvTk3rUL1bagnwXZKEliw8djCy1kfUDkqUzqEb9nGRQsGn4u4jYlk65pH2aFgWmuYZy3zzAmBB7F3pV1TXwHXWv7u/+7nFc/8z3WL/HNJ7G28OAT/82CxOHxp7WeyzdnoaXvtmNVbsz9H7fKF+8fef4dkX3GiI2WOqtP113FD/sML2mGYm4zTknHuP7BGun5VNx8ogI2XW8WJ1z2UWV2HykAAcyi5FTXHVC2qdkZsQEmub7TeoTjD7h3hqVa8/76lw+mcNXZGoEI9E4sXWSsdFc+qcZsXtSi2cWXLIv7y1blHRA9m4+O6Q5zKma5vo8sbuSeZFTLwTlvjjkTobYZmkU0zQSKJscn0ToBBGVkp0iolNS+yUzRSKPch5qjEYVuOLYM0cE2zI3UJ5nHgMkdYnyniIMOQaoe0OhR7qd0Fu5cmWrP58wYQJsic74kgaM/SPKK6qx5cu/4oKHv0BGXgnCAjyxc8HNKMzLxrBhw/R5W7ZsQWRkJLYeysWVzy1HRkHjCJ14fu+Z2R+3TOsDtwZDa1uLoG06lIfjeWVYsTdLFxnyWHMRP5nfNzIhAAkhXjqDqi1kFVXimSUHsOVIgbYPb4jUMoyI89OZfvFBHpjSL6TNNSrizZULqIi/9zce1/2GjI710zbhMi8qMdjjlESQLAbWyYIou1QHFTdXByMtwsUjLW3CRciaFwBSIyJ/X1sXRTJG4kj9nCoZkCzaW5YAsjBwd3HQ45d9+Wq29OUMqx8eLJ5o80LpZB3yCLE1oSffEa8Rd6OuzohDP/4DIQHeWLjmAH7/9/+hYs3Lurj+/JufMOu8E2v02sszX+zAU59vt8w4veqcBPz5skEI9m2bfWwO6eQpNX3SzOWDNYdVnDUc3TCiRwAm9QvF0Dh/dcqd7rnal1GCjSn52HjY5PgTZ1pTxLbJSAdpxjVKZgXG+CLct33izyy+juaVa7aGiMC0+vl8citC8GQBOLGBUrvdMBIY7W/azIKrPUhtnmSPZBabonOSem+O0olTTtNDT3JM0hRGGuyIsy0h0EOPTfalRlGcrtpNVTuC1mi3Z3FQSoqozFksqqpR+68NgOrT/NsSCRREOIqNl/mvEhGUekBJURXnHzuFdm0o9Ii14XgFK3xJY859GNn5Jdj46TzUObpg0r0foKyiGv++ZxoGh1Y320RAFzKZxdiclINFG4/i+03HLI0DxNCP6xOCv1w+BGN6t940oGk60a8Hc7E/rUjbha/en63dJ5sijV3G9w7GhcMiENSGqJa5jiSjsAI7jhVi2d5snSfVEDcXRwyJ9tUUImlOMDCy+TbkzVFaWYPlB3OxaGeG1vo137HN0yL8pNmLPNbW8yLiV8SYNCWQNEy5UMtta4sAKcIXD7BJ/NV7hC2bS4t1MeKF3nq8SDvSyQJEon9m5GilZbg0DTClfzrC4Nxy0wBJ/5EmCbJQExEoYrC5hjmE2IrQE4LG3YfS8irs+eZviI8K0sdW/bIWE84ep/uuY+/Fk3dfoWMXDG10yLREcnoR7ntnPVbsMkXipNnVeUMi8ceLBpxyhM9MbnElPl57FDtTC7B0V+YJTrjBMX4YlRCAPpE+6B3uo2n3p7vIF+fcwawSrD6Qi+2pBZqW39wsPklplPEOIvzO7Rus3T5PB7lGSIdmSb8Up6AILhGDIjyPFZa3Or9VkMhXoJeL1sLFBbpr92ZTIy+3U852kPeTWvJGHZ41TdTUzEV+ZjyJGJPsD3PDmHBvV234JWUATcsYRPBJKmppZa0Oqc+ob1wm4lDOjauLY32X0LbUBZpmwYoAlPMR6eOm+61l+5AzB4Ue6bZCr6ysDEePHkVV1W8LU0FGL9gSnfEl7Tfzb0g5loPlC+7DmME98PIXG/HQ6z9rx7iPHzoHE8aZxN2uXbuQmJjY7GuY0zqf+XIHUnN+a5bSJ9IXl4yJxeyxcYgL9YLBue0LG2kXvj+9CDtTC7Fmfzb2pRXhUINGLHIRmzooDHec1xOJ7WggIIJUonyHskvVw7suOU8XFA0Roff4JX21xq89nuNDOaVYf8S0QJGZUdLGuzkk/cU8KDjM1ySCxEtt9hifbMEkCxGp75MalcKKGq1XMXVyq2q1U1zDVFBT9K+xEBQBKgsDsxDMrU/zFO+y1qBo1zjTQsj8RRUPsAhlSf+UBYQ5Rag5ZAFgbghg9gJ7yr7cujprXSBrAEl3FnrRkx5GTkEJNn/+F/RLCNfHkpKS0L//ABUtxlH3wM0zEJdP7Iv/PDQDLu2wic1RW1eHr9Yewbz3N1lS6qWR0gXDo3FW3xAdxt47svXa57bUCZrt8C/7c7ThVtO0e39Pg849lcyLkT0CMbyHP/w8Ti2NvamTLilLRjuUYN2hPCRllZ4guiQrY2Scv47fkQ7MMt7hVOqmW0L+VikFkAicjE44XlCuafxSvy0i7GS2Vuy6dAMdEOGt+yJ8RACejjAWQSZpqUWVtWr3pR5b7LSmbzZI+2+KvKeIPh1W720wXYN8WnbEyd+u15hKU8RRBKC8h6SeVtTUqgPQPC6iuREgsqSTfy+j0VQiIA1opPmXXG9Mw+tPfr0jHQeFHul2Qi87Oxtz587F4sWLm/05a/ROzqjfzcfOg8fxzf/dgSlj+2o0b9ztC7A/NU8HqH/4yCVtHsgtkb79xwvx6uK9+GxNimkMQD0iHu69qP8pNQ8wI97lJdvTsWR7hg4KNi9qJMp3+3mJ2tSlvUJBPnIizDYfLtBBwSv351i8yJKeclbPAMwaFqljHNr72qX10TcRfbJJ1zbp8tlampB6Qz2lS5srYvzddNafNBAQT2xbFi+SEiQXYrPwk8Yspvumx9oiBEWAyQJF3k9amId4udbfGhDibYCrs5Ne9M2NByxCUDzNIgKNpuifizn652wSgm3pEidpp/J8d5kVZXBSb7mkI0kzGGkhzkWB/dGdhF7P6Y/gWEY+1nzwAIb3b1yPJ7b1X5+tx/wPftUF9MQhsXj/rxchyNfjtN+3sKxKRzP8+7s9WL2n8YzTKYMj8I/fD0efqI6ZNytp+78cyNGxOjJbb/exQhQ1M7JG0jtH9giwiL+ogLY1lWoNiSyKvd55rFBt9YaU/BOEn9T69QiWuas+GBTlg3N6B6lTqzOcSGJvc80zYWW0Tk6pCjBpECM2tyXEGTYixg+TegXqeB2x9x1xfOLIlBo9EWLavKW+WYw4BaUMoLXaQNOYBhdNwbeMGBKHpI9rs6n45lpEqX0srhTb/1v6qcy2lZ+f7G+S74HMBRQ7LyMptA7Ry6DOQKkBp73vWCj0SLcTetdccw2OHDmCF198ERMnTsRXX32FzMxMPPnkk/jnP/+JGTNmwJbojC/puXNfwNpth/DR8zfikslD9LGtBzNwzl3vaz1aoI87rps+CDfMGIL4Jg1aWiO3qAJLth7Hez8fxM4jeSirL4SPC/HCO3eNx/BEU1rTqSDHtSE5D//300FtGW4m0t8dN0zsgZnDIxHq23JH0NaQZi7zv9+PvWnFjRYQ4okcGOWjnuOEEE9NF5IGL+29EFVJjV/9oGBzvYhpM3mLW5pLZRae0iJch617GNSTnRDkod7Yti4SZBFgSv9pIAbbKQRFtIn3VxYGIsCkLlBEmNyXzcXREdV1dcgrk9lRpoWG1oZU1qgzQNI/JZPnt+YApnEQbfkbRAiLN1gWI7KZIoMSIXRq06wu0v3oTkJv0CV/x8EjWfjpP/fi7GHNZ0B8tzYJc55ahNKKam1+9ddrz8YNMwZ3yEJfLqGbk3OwbHs61h3IwoqdGbrgFofY9OFRmlY/eVAEEsN9Okz4VFbX6tzTA2lF2HgoDxslSyKr5ITnyTgdFX49TDXXfSLaniLfEpLNIJG+7UcLkZRdgqO5kmrZfK2fNHcZEeuvWRRjEwPb3NDqVBFHpzRFEZElNd170os1/VJEcdOFjjjWJMtDxN+gSG+NALa11ro9nw1xyul4n+L6ofXSuKbYNDKiJRzqrz3i5OtRP6ZCrkESGWzNCSzvJ9cbKQWQUUDyHsVaG1in19a2fPxEtMu1NyHQE1G+bloOwLmvpw6FHul2Qi88PBxff/211pHJBXvTpk3o1asXFi1ahGeffRZr1qyBLdEZX9KL7/g//PjrHrz26NW47lJTHYnw0bLduO2fi/UiLri7OmPpC9dgWK+wdr+H/LO+8PUuPPnpdl10eLg64YXrR2PGiGj4nEZ6j7zuppQ8vL38EH7elakDy81pnQ9f3A9Xj4s95YVEZU0t9qQVY9G2dPywK0s9t02RaFVckCdGxPrhrJ6B2jTgdBYP4t2Ui7B4RdO0y2e5ppdK7V/Tpi8NkQuhzPmTtE/pDhdanwoq99vTNlyQC7NckEuqanRshaRuykXadFulHty2IOc9QAr2JTXUwxQJlFQh08gGZ50hKO8lAjNTu9JVaPSxqtaoIlBqPUzjH0yzoMzjIFpDfizeYRF//u6mbqDiFdYBwgZnPU9t7ZxHug7dSeiNvmI+dhz4LUOiJXalZOMPT36NfUdz9f7UkfF464EZCPE/vXqzpkgt9T1vrbN06TQj3TqfnjMSE/qHdUqkS2aqbhbRV7/JiJ2mkTepKbxlciIuHx19yo655kjNk3RPifoVYfXBHE3Tby6LQrp7ntMrEIkhXurEC21lXFBHInZe0j5/2p+NbceKtCNo01RYdSyGe6N/uDfGJwRohK0z09pFlB6vHx4vDj8RZxKVlChlS1FAifLJGCARfz0C3fUa1J7rjaSfbj1eqNcAaRRTWl2jzWHEX2eeF9gUc0d1bQjjZtAZtz2DPNXZR04OhR7pdkJPLtI7duxAXFwcYmNj8eGHH+Kss85CSkoK+vfvr7V7tkRnfEnve+YzvPbxStzzh3Px9H2zGv1s6fI1OO/c8aY7I+6CX0gszh/dA8/fPgWRQe3vupaRX4ZbX/sVy3emWx4bFBeAWWNjceN5veF9GnUVUkfywZoj2i1OOrgJksp5zdmxOKtXEPx0LlH7RE/Di2BqXrmmCe06XoSUnFKtHTELy4bocN4gDx0KLNvgKF9NQTxdRGjK4kBEnzQJyCutQrIcR155q40CpB7Q1BjAHQPCvRHl74YYSQN1O7Wh6PI3i9iTCJ25WYCkb4o4lft59betpafKv4Ck50jn0HDLJjWLphbmsrCQyKK5G5387bIoUG9wVR1qjHWaHtowMthWASfPlUWCRiTdGkQFXU1iUH7GOsGuRXcSehOufR4bdh7Gpy/cjJmTTDXiGzdubLapVWVVDd74Zise/c9KdajFhfnipbunYurIHh16TBJFlyjf95uPYVNSDlbvybA0c4oO8sTFo2Mx77JB8OrEMSlin7cdKdBo38ZDudicko+SeqeROOZmj45WwXXugFBEBZx+KmtTp51E+rYeLcBuqfXOLlM73hTJkBjTI0CddtLopT3D1U8HbbhVUK6Cb/3hfG281bT2T7IYpvYNRs9gT/RoZxbH6WJOARUnpByj1Ce2lH0iTrwBYd7afdrfw1mjcO05TnEES5fQnFIZDyENaExOxqq6uvqGMC2/lvx7iVNRxh31CvbSaxw5c7aPkE4RenLBlDTNadOm4aKLLoKfnx/mz5+Pl19+GZ9//jmSk5NhS3TGl/TdL3/F7U98iMlj+uDb1+5s9LOGC5RhVzyBPbkmw9krOgBb3roBTqdwIZQmKzIH6sNVyTjcIL0nyMcVl4+Lx01TeyMh3Oe0Cvj/u/ownv1m7wldOyV1aER8gM7qmz0qus2jGlq6IKUXVGiqp8zw23S4QKNwtU0+wiIsxHM8vF749Y/00VqEjrpIy98rAlAuwBL1k1oRuRVPrDQQaE1wiUdWUnKkXbiIP2k+MyLGV9NjTndhKbV6WrtXnxIqx5Sux1WJsmaio2Yk+iZNYeR4YurHR0T4up4wrF3ErQwONr9HWXWdpokW1s+ukn+HhqmhbWkbLsg6QupFZPHpbTDNCzSPjJBGMowInnm6k9A7/+aXsXLjAfzzwctw+1UTWxV6ZvYeycHFf/4MqVlFcHF2xLJ/XYORfSLQWeQUVeDJT7fhs19SfhNb7i44p38o7rigH8b2DmlzXfbppN9/tPYo/rsqBfvTTfXWZiTCd8XYGE3z7Cwxk1tShTUHc/Brcp468fZnFDeylWI3pLFLr1Avtdtiv0UInglxJdeW/Zkl2JdZos29th0rPMGOm7M4hkX74oJ+IW2eC9thx1hnVHsu1x3zJgKw6XFKs68R0b7oH+atdeanMopCkKWhOFylwdnRggoVgOJQFKefzH9t/ndM1zjT+AlP7Xgttt2eodAj3U7offDBB6ipqcF1112HzZs34/zzz0deXh4MBgMWLFiAK664ArZEZ3xJxfssXujQQG8cXjq/0c/Ky8tVOAsPP/wwtiTn4qJ5n6K8skYXI+MGRJ3We2cVlGPxlmMq/JLrm6uIV27u5J64ZmKCDmE/VVJzy3Q4+xcbUpFRUKFpgg3xcXfGBUMiNNon3TvdOyD1Qzuh5Zap+JPOnjIcWOrxmiLF7dIZLlzqHHzdtN6vT7iX1t11RPSvYT2guU24RP/2Z5XgcK5psG7TVKGGCxyJ/MlxSbqlCK1eIZ5aP9IRhfHyFRcPsSwSpH5FhJ/UKsp9qeVrCblAi+ATASiRQFPDAFO3uOYWXyKARfDJJv8u8p655TKzytSlVKKEUkfo1EgMtv73yU8l+mfyGrtqmpIIQRGnjAJ2Ht1J6N07/xO88elqBPt7Yc+3j8PLw7WRHZ03bx7c3U90MBWUVOD6p7/F4vXJ2qRl8XNXorMpqajGj1uP4++fbENK5m9iS+qoJa3+yvE9NOOiM5Hv6fdb0zTaJ/P7JM3TTHSAB/pG+mBsryBcPDyyTeN0ThWZLScZG9KF+ed92SoimiJp6FLnJ/Y6IdgTE/sEqc3ubETgrDiYi13pxdrsRYajVzftPBrooeN7eod4YUrvYBWCZxqJTB7KK8PKpDwcLTB1JJVU/Ib0CvbEkEhvTEgIVLt5umhn1rwy07WkqEIbwhhRp7a8qU2Wa4/UPWqnUW9XBHm6agZOS0LRFqHQI91+jp6kau7btw8xMTEICjr1Zh/29CUtLa9E8Fl/UiMoQ37Dg1tvxT336W/w8bI9uGxiH/z3zxd1yAJXxjN8uykV7y9PwrIdaZbHJaXz4dmDT7s9uFBWWWNZSHy18RiSMn+LJkr9lywi4iQtJsQLIT5umkIks6JOBzmn0hhAon0i/LYcLVDvcWvIAF5ZTIjwk1QmaTAjj51KmmVrxyXCV8VPaZV6YqUWcHdGsXqRm0OEkET+xCsqwk8WFDIbsCMHo0taqCwORPQdzi3D8fo6EWlg0JJlkNRUSWuSpjTasU3advu4ItTH9aQXcFPrcIk2Vqmn+HhhuUYIRRzKx1oWC+bOobK1Fs2T0RBSE2juHKdRQLeWZxYS2xR6RSXlGDr7H0jLKsD/nr0Bs84b2ubfPZJZiL5/eF0/68/fPhlzzh8EL/fOFxISXdt6KBf/+ekAvt+cisJ6kSNOtznnJuKJa4bD4wzNwPxlfzY+XXcUS3ZkNMrI8HF3wb3Te+GqcbE6iqWzI2rioDtU391THHZS79c0VV9s34g4f4xLDMCEXkFqq88E8u8lNlts9fe7M7WbZkMkxVHSOy/oH4pBEd4d5qRrL3K+dqQXY/vxIj3GhnNZZYzPzP4hGN8joMOPTa5vch1Jyi3VukPJ9Kgz1rWYiivppVI6EOrVsuPQVqDQI9aGA9Ot9CUdc+XT2L7/GN6bfx1+d/6IVp/7w4ZkXPKXz3X/8bnn4MGrx6Ijkfq9d5YewLcbU/WCK3VYktJ549ReGNYjqENSisQLuHpfNtYezMH329I1+tccvaVYv08wLhkZpUOBO0JsyeJF6kOO5Zu6w0m65560IhzPr9AIXHPInLqzewZqGpF0+pS24TJyoaMvSHKBlHlM2vylSNJATR3jUnLLTvDMmhcUkmYZ5utW34nNHVP7BHeoKG3YqfR4UaUei0QkRZDJYqel+kQRab2DPU3NYGRgsI8r4gM8dIFxss+QuW24pJ9KBFDeK7+sCvnSNlyGCNcZ6+cGmqKArf07iNgM9TKgR6CnLiakOQyxXaEnzPvXV3jxv8tw4YSB+PRfN7fre3rNEwvx5ar9ut8vLkgzJ/y8zkyTELND7Ov1R/DhqkONGrhcNb4H7r9kAHpGnL7Tra0Rti0p+eqc+25rGvammWrqgn1ccd8FvTF1YBiCz1DzFHO0SrpmHsoq0Rq/jTJaooFTTEzK+F5B6BPmhXN6BamNPlOIbdqbUYKknFIsP5CrtXRNO44Oj/bDqFg/7eopzihrIOJry7FC/LA/x9LlU7p3iuAbEeXbqenCUiO69kgBdmeWaITU4Cxz/Rx1fdEQGSUk1wnpghrle+Jw+e4OhR7pFkLvvvvua/MLvvDCC7AlOutL+tA/v8TLH/yM62eNw6uPXG15/Pjx4xgzZozur1u3DpGRkbr/4mcbMO/N5bp/9+yReObWc9HRSJroQ+9txIaDv41PGJEYhBum9MI5A8IQFdgx3ekkqnMsrwx5JVU6m09En0T7ftqZoRd3M34eLlrXJ8JvXK8guHZC62tpPrI/o0RblUv655HcMhzLK2925IE0M5ncNxiDo31VBHp3YuG5CB/piCkiS4TgwSxTGmhzLbnFyy0d4sxjH3qGeGkEUFJkOsOzLR07JRon8wnleKRwv7U6QGm2Ig0NegZ56K2kErXXo2weImyeJSj1hxJ9lOYE8jNZPJgaB5xYFyiLC6kZ0TpEPw/1Ine0MLY1upvQ27z7CM7+/XO6/86T1+KcIZHN2tHmKC2vwitfbsILn65HUVmVpscveupyeJ6ByF5Te/TTtjTc8cavlkHsEtG+fXofPHbVUBhOc9B7e5Dv1Ee/HsHry5JwNOc3p9ygGD/cPa0nzu0fCuczvCCX8yOdPaU+e/XBXI36mRFz8uacoRge648zjdaOF1ZgVVIefj6Yo6n7DSOR4pz6y9SeGNejc1NyW0Ps5rKDuVh6IMcy3F1G9AyP8sX0PsGdLkRF6O3JLMG2tGKdeehucFtFVhkAADSeSURBVNS5r01TScVyqyPT29TBWtL0u7ujjkKPdAuhN2nSpLa9mIMDfv75Z9gSnfUlXbx6F2bd/Tqiw/yx//u/WxanLTURkH+me17+EW99u03vL/zHZZg2KgEdjXSi+25TKhZtOIrFm49ZBrDLwlhmQV02Lg4TBoQh2LfjU2byS6s06vfVpmN621D0yemZ0CcEQ+P8dVj7gOjO83LLuRZP8pqDudr8RWo09qeXNIr+SVRJZvvFBHhou/CJfYK1lqwzkeMSgSMCUCKA0jVu2YEc7ZjWHDqI18MFiUGeGBnrhyFRPprq2FnHJjUb+7NLtTuoCD+ZFSVNa5oGJiXCJ2JP2oTHyYwof7fTSreUhZYMEJbRGNIwQLzrkrIkYtK1haHx8u8nnmRZTIgXWSKQpPsKPeGOJz7EO1/+it/PHI2bZ/ZptRlLc+xIzsLU+z9EYWklBvUIwb/vnYZRfTuvQUtLVNXUaqdOqaNesuW4ZTTDG7efjcHxZ1YsyPVgwaoUrb3efey3rpnSXOvZq4eo8LMWkuK59Wghvt2RgYOZJfqdlpEN0weGYVr/EE09tQYikiXFc8ORAqw7nK/OOslGeHBKIs5JPPUa+I5AbLOIvaUHci3OTJnDeuWQcO3aeSZSKCV1f92RAo32ie32Mjip6JR/v+YybCQtP8rPNFJC6sS7W5onhR6xNkzdtNKXtKy8ClHnPoRyMXofP4zBvU1NVpKSktCvXz/d37NnDxITGw8AvuX57/HfH3bqIvbdeTNx+cSW50adLkezS/DGkn1YvTcT21N+K9gXO5sQ5oNzB4bjusk90T/Gv1Muliv2ZGHx9jT8uCMDBU0iWYmhXji7dzCiAz0wZUAo4kO80JmI6Pxhd6YOdZdhwSkNvNzmqNH4XoG4anQU+oX7dGiDl5Mdlwgbaf4inlLp/Hkgq0T3m2ZYymdGLuaSTiTCRlKeOkv4NewUl6rHVIqDOaXYnVFyQrTUob5ZTpx0IZUZUYGmofSn021T52bVt09PzivT+kh5TDzJzTWAkcYz0qGub4gX/NwNVqmv6Up0R6H36ZJNmDNvAcYNTcAbf57Zqh1tiQ1707T5lYg9ySBY8vxVGNOv5WhgZ/P9plTc9dZa5BRV6mdyyuAIzP/DiNPqknw6c/re/DkZH/5yWAeQC5eOiMQLfxhm1e+LpJze/sE27E77rblNhJ8b3r1+eKcPaD8ZYnP+vvgA1h7O1/tzx0TjquHW+zyZkYijNJr5bHu6DnIXxsb6Ye7oqDPWKEVmxS5PysPO9GLLMHu5bErWh8xkFVEqWRwN0bFFPjKr1qCRP5nh2tWh0CPWhkLPil/S3933Jr5ZvgN/uWU6/nrrjDb9jixAbnzmW3y7NgkGFyetJxnROxydiURrth7Kwzcbj+Knbcex84jpomVmVM9gPDR7ECYPCu8Ub5tcLJMyi1X4SQ3JjzszTuhgmRDihXP6BmtXT2kR3tmtymVAsMz1k9q/n/ZkNRJ+8s7RAaa6vqExvjreoUeQ5xkTf4J0uJRmLxLZWp2Uq4JHOsc1RNJmJvUMxOg4fwyN9j0jF3hZYOyTTqT1Q+mP5JuasTRFPLzj4vx1MK/UlIjX+XQ/WyL25HzI+0sTHBkHIZ52aS7T8LVNLcId0DPIS8WfdEHtbl5kexR6G3cdxjl/eF6bW0mTq1MlI68ENz37HZZuPowJQ2Kw5LmrYE1yiypwz3/W45sNR/V+fKg3Vj11AXzOQPfJ5sgorMD8r/fg603H1Jl0y+QEPHxRP6uKPXNa56oDOfhwfSrySqtx6dBwPHpR5zlC25Pu/s66VHy+LV2vDX+7oDfGxp/5FNOWrhNL9mXjm91Z2kTmnvFxZ9zWSZaKNJARJ2DD5jHRvm44v0+QOgZT8kq1YVhD5OPWI8BTbbTU+HVVG02hR7qd0JM0zta+UF0xdfPSSy/FihUrMHnyZJ3111W+pO8vWoebH/sAQ/tG49cPH2rz79XW1uHKvy/Et78ehL+3GxbN/12ni72GZBeWa2rRByuT8cOW49poRRgY649rJyViwoBw9Irw6TTDW1BWhbUHcrA+OU9r/KRrXEPd1yPEU6N9CaFeKvxCfTu3gYB8haRJwIJfjmLT4XxNrWyKnInEEE/cfm4PjIzz7/Quds0hXTWX7M1Can6FpcFKwzqSs3sE4Lw+wdo84Ewic/hE8KXUiz8RYuY6EjOSsvPHCXE66qEj/92k+cvG1EJtUS5d4pobBO/kIGmeBgwK99F0T3vo6tkdhV5Ofgmiz31Y9/PWvgB3t1MXQjJfr/+cN7Q78cY3r8eA+GBYE/ms/rI3Cze9ugZpeWW4eWpvPDfXlJpqLT5bdxT3/89UStA/ygf/u2MsAk5zHmhHIDb4pve26v5Ts/ppKmdX4OUVh/Dt7iy9FsweEo4bxsZ0mcwBqQOX5lmdXX7QluNYlmRqbiO2+KFJPSz2VmqzjxSU6RgOnd/aINontem9g710dl9XOadmKPRItxN6f/zjHxvdr66uxrZt27Br1y7MmTMHL730EroaIvKKi4vx3nvvdSmhl5lbhPjz/mLyRv7wJCJD2r7AlsjezIc/wcZ96fD2MOD52ybjD9MGnnlvXEE5/vX1Lvx3eZJ2R2wY5btmQoKOa+hsz3NucSU2H87H4m1p2tDFnFYkeLo64fdnx+GGSQnaqfJMkFdahQMZJdihNSQF2uyl6Ywo6cr2u5FRuGtyx9dZtgWJiG44ko/NqYVYmZTbqM5v7uhoXDXCeulFko665XiRdouTLp9S6ydWanCEN24bF9NpQsvcnOdgThm2Hi9Ub7dE+5pGh6X5TbjOhXJTASizobra4sIehZ78+4WOfwDFpRX4+d37MHZIj9N6vcsf+1KdaQ9fMxaPXXcOugI/70jDpfOX6f7nD52L84ZYNw1QGrb8/ctdKK2sxbieQXj6qkGIC+7cNPq2fA4uf20DkrNNIxCuGxeDOyb3gLOjdRswiUP0mZ+SsCrZVAZxYf8Q3D3x9D6jtorMYZWOz9LFubXUTykH2J9dYsnwkRE7/UK8dBSRtf+9zVDoEZtJ3fzb3/6GkpISPP/88+iKiNh75ZVXupTQEyZd9wLWbT+Ex++ciQdvmIadO3di0KBB+rMdO3Zg4MCBLR9baSXG3LYAKemm7mO3XTIcz916Lpys0J44r7gS/1uZjCVbjmnXTnMjFYlczZ3SSweyJ56BuhKZRyViT1I9V+7NatRA4MKhEbhhUg8Mi/M/44I4u7gSH6xNxaJt6SomzEhq58BIX8w9O1a7jFoDMQHSPGDJ3mws3pOlj53bKwgzB4Sif7g3rI14d//y/QHdl3826d5505gYrdHo7MWGRBdlyy2rrh/tcGJXTxGDMuYizl9GSRis7hW3V6EnnDv3BazddggJQcDupa+2yY62xMc/78Hc+d/A080FD141FnfNHgF3V+t8RxvywLsb8OaP+xHk44pVT81AZAd1Qz5VdqYW4NIX1qjNl6ZdX/zx7NOeh9oR6aWvr0jB19vS9f4fz0vEteNi0BVYfjAHr646jKcv6qtzUcnp2+m9WcXYk1lsGUkkNlmie4mBngi2cpSZQo/YjNCTJiLS5Swv77emHW1h1apVeO6557B582akp6fjq6++wiWXXNLoOa+++qo+JyMjA4MHD8a///1vS0e17i70/vfNetz46PuIDPXDwcVPYNOmTe3qFpdbVI4XPlmvrcGFC8cm4h83TUSvaOt190rPK8PHaw7hw5XJOFA/i0kE35t3nIUZI6LPmMiSRiDLdmfi6UV7NcXTTGyQB567egjG9AyCNSirqsFry1PwwbpUy2M9Q73wwY0jrN72/z9rj+KTLWm6L0GqiT2DMK1vMIZGnZlZXi3x0/4cLNmfjdxSk0iWmUvXjYrS9uBnAh0JUliBzccKdXaWIHV8MjqiacTPx9VZmwb0C/XWpgHdke4q9LbuTcW4q59BRUkakPRVu7puNqW8shpT/vghthw0zbYb3S8CPzx3FVwN1hXyFVW1mPzIYuw6mo/ekb5Y8/SMMzp6oTn2Hi/EvI93YMvhfFw5NkY7clobWdq8sTIFb6w8jCh/N3x919jTavDUkUi9sMcZrNm2B2S8z6HcUuxML0JJg4Zf8f4emJAQaLX5fBR6xNp02Cd/7dq1cHNrf2pcaWmpijcRc83xySef6By/xx57DFu2bNHnTps2DVlZpsiDMGTIEAwYMOCELS3NtGDtysyeOkwjcMczC5CeXYiEhATcfPPNusn+yQj0cVdhJx04ZcEpTVoufPhTreOzFuEBHvjjRQOw4fmL8MbtZyEq0EPTOq95YSXufGOtDlI9E8j5kFEMy/4yCd89eA5mjYzSi+uRnDL84f/W4aUl+3XRdKbxMDjj/mk98cFNI/DYRX3g6+6s7cFfW3EI1kbqRp65uK/W60k2zM8HcjBv0V4saqYBzpnkvN5B+OdFffH0jN7aRKa4shafbjV5688EkpopRf+zBobhtnGx6BnshdIqI44WyEy/ahRV1Or5kmVkkXqYS/DlznR8tSsduzKKdNFJOh+pd/bzdgec/HH5Fb9vsx1tDone/fTC1Xj+9snw83LF+j1peObDtbA2bgYnfPSnifD1NGD/8UKs2p1p7UNC30hf/OnCProvzbKkAYm1EYfinLNi4e3mjGP5FVhXnzLZFaDI64Rz6uKEAWE++N3gSEzpGYSEQA+1xyn5ZViWlKMOVtphYo+0O6I3a9asE+dnpadrJOqRRx5RQXbKB+PgcEJEb/To0eqNlWicUFdXh+joaNx11114+GFT4X1HRvQqKyt1a+iNkffrTE/0wIsfR9LRbHz/+l2YNLr3Kb/O4vXJmPVX09/30aOX4JLxp/5aHYkMIX7ik214+6cDOjdndK9gfPbQufC1QrSjuLwa932wFT/sMHnpZREwtmcQHpnVH7FB1kmjWb4vG/d9slP3b58Uj5vOiUdXYHd6MV5bc1hHIwh3T4jHhQNCrX1Ymvp678K9uv/czD6dnsLZWs2NDI9PzinDjwdy9LEbR0VBSkMkjUgigGYk8idRPhnYLl1EXbt4W/DT9UJbw46aGTb7Sew9lIHvXrsT544xiY/T5dPlezDnqW8QFuCJ5I/u6PSuvm3hj/9Zj3eWHsAFw6Pwv/smWv2Y5Psw6q8/IrekSjMmrhjbNVIlP914TNPiJ/UJtlpUh1iH9KIKLN6XaZnl6ufmjDGxAYjyPXOdlBnRI9am3VZPLv4Nt4CAAEycOBHff//9aYm85qiqqtKUzilTpvx2wI6Oel8iiJ3B/PnzG/19sjjpbHrHmRbP+w+bxMepMn10Am6cYUqZufqJhVi4ej+6AtKMRTrEffXnyeqFXn8gG4Pu/gqf/5Jyxo/F290Fb944Eq9cNxxRAe4orqhRD/Ql/1yNlKwSWANZgFwz2vQ5+7/lKXhjRYoKYmsj9XnPXdwPUX6mSP36JmM1rIUU3MvAdeHdDcdQ1GTW0plCFo2yYJiQEIA+IabjSSuqRKy/B6b3CcUVgyMwMtpPu8dV1NQhObcMy5Nz8P7mY/h2T4amGJk71toa1rCjZmS8gpCR81t97uly8Vm9tFYvI68U25OtH0ETLj8rTm+/33wMN//fGmsfjn4fbptimlf4r8X7UVF95rMlmkOaXk3tH0qRZ4eE+7hhRt9QBNbXvxdU1GDJ/ixsOmbqa0CIPdBuoffuu+822v7zn//g6aefxtSpUzv84HJyclBbW4vQ0MZRBLkv9XptRYTh5ZdfrmI0KiqqVZE4b9489Tqbt9TU3+qoOovePUztn/enZOL48ePo3bu3brLfXv5y7VlaSyI64aq/L8QNz3yLnMLGw72txcQB4fj0gUk6B6qgtAo3vLIGu4+eefEgnryLhkdi1aOT8cUfz0K/SB/1Qj/19R5Yiz+d3xO3TTRF8l5fmYIXfkjqEmkmMvvvz1N76v6mo4WNOqtakym9AjUtZ0+mqVmKtYn1M4192Hr8N/Emw+iHRPji2uHRuLBvKAaH++iYCPlXlZlQ647m44ud6difVdIlUt06EmvY0YZCr6I8D3dff+kp29GmSF3epKGxuv/Vqq7hQBvXJxT/umG0fkcvHWMSfdbm2vHxGBDlixsn9tDvJyHWJtTbDbMGRuCaYVE6l1XYllaEzccKusQ1lpDOxi7yGJYuXYrs7GyUlZXh2LFjGDt2bIvPdXV11dSihtuZiujtS8nQusIDBw7odio1hmEBXlj6wjW4eeZQTeX5cOluDL3hbRxK6xrRmDG9Q7Dx+Yvw8OxBuOvCfugfY73Bsc5OjhjZIxAvXTtM70u3zvT8xkPFzyQ3nROHh6b30v3/rU/F44v2oSvQI8gDAR4uWqN3y8c7dJ6RtRkV44e/npeIab2DMDLauo1iBInoSeacCLhPt2ecUN8nnuVRMf64bFCERvrGxvrDS2sNa7AqJRefbE/DqkO5yCuz/rntCKxhRxtF9GorkJttsqUdVat9zXkD9Pb1RVu0CVZX4PopvbD9pUu1yVVXQOoHpR76xnMT4GoH8yZJ96rhm5gQhD714z+2HC/E2iP52rWTEFum3ULP399f0zWbboGBgYiMjMSECRM00tcRBAUFwcnJCZmZjVNl5H5YWNcYgtoR9E0wDTvfm5yu51f+Ztlk/1QFzEt3T8Wipy6HwcUJOYXl+PeXm9BVcHF2xLzLBuPJa4ajK9A7wgdjEgO1mcZ326zXwEcijVeOisJ9U03pT99sT9eZfNZGOtX9eVpPnRkX6eemoq8rkBDkgauGRZzxURnNEeLtiutGRmkNyKSEgFafK5E+aRowe1AEhkX66gJEOsbJPKgvd6Xju72ZWH80X+tL6HFuP2FBvoCTm87iOB072pSLzuqFwQkhKC6rwg/rk9FVCK2PJncVusL3kZCWODs+wNKteXdmMT7edhwrD+WgxorNxgjpUkLv0Ucf1Tq5GTNm4PHHH9dN9uWxO+64A7169cJtt92Gt95667QPzmAwYPjw4Vi2zDQg1tyMRe63FpXrbvTtYRJ6mbnF8A0IRU1NjW6JiaYF/6kyeXg8Fj55me6/t2QHDh7rOl3HuhoPXdQXn997Fm7oAgNs/zA2Bn3CvFR4rq5v8mFtBkX44K2rBuPBKYlcyLWAdHn744R4RPi2rfuwwckRw6P88LvBEZjaK1jr/SSTKK2oAjvSi/Dt3kx8vTvDZuv4Oos+PULh5h6AiHP+hJLS8tO2o2YkQ0IcaGtfuw5X10f3CCHdC3FEDI3wxZSewQj3cdVU+gPZpVh7hOsjYpu0eyDQmjVr8OSTT+LWW29t9Pgbb7yBH3/8EV988YUO/H755Zdx0003nfT1ZMi6zOAzk5KSgm3btmmUMCYmRkcrzJkzByNGjND5ci+++KKOZJg7dy5sBS8PV8RHBSHlWA72HkpHcEDHDameODRWa0uWbz2CuU9/i5Uv/d4qA9W7OsPjW4/CnGkm9gnGvowSrNifg4uHRqArILVAspGWkcYrp9LEQhq4xPi5I7esCjmlMrKhEofyypBdWoVtaYUYGW29FOfuxsSRvREd5o/UjHx8tXQrrprRvpmrrTG6X2SHvRYhxHpiLz7AQ7fDeWX46WA2DmSXaIaFp5XnZBLS0bR7xf/DDz806oJpZvLkyfoz4YILLsChQ22bCSZjGYYOHaqbIMJO9iVyKFxxxRV4/vnn9b7MyxMRuGTJkhMatHR3+tenb/74i6ltfEcatDcfuABxYb64e/YIirxuwtT+Ibh1Qjxum2T9CCM5M8h3NcjTFX1CvDEhIQjn9Ai0NA5YnpSDyhpG9tqCOLKun3UW3N1ckN6BnTcJIbZHXIAHQr1cNYNmd0axtQ+HEOsLPYm0ffPNNyc8Lo/JzwSJuHl7ty0qJaMZpA6l6bZgwQLLc+68804cOXJE5zKtX79eZ+vZGldcMFJv57/5sS74ZNu50zRb7XSJCvbBzgU343eT+nXI65HOJz7IE7dMjEevUFPhOLE/egR4YHikr3YvTMotxcJd6V2mZX1XZ/yAAOSvexH3X3deh9lRQohtMjjC1CxqV0aRps4TYku0O0YtQ9GlBm/58uWaSils3LhRRxe8/vrrev+nn37Spiyk7cw+byj++W4U1m36rRlIRUXHGRxp0EII6T6Is2dYlB8ifd2xLCkbRZU1WrcnIxtEBFp7QHZXxuDs0Cl2lBBie0jafIiXK7JKKrEiOQdXDYlkLTqxX6EndXf9+vXDK6+8gi+//FIfk1lFK1euxLhx4/T+/fff3/FHageLuuH9Y7Fu60H0HjgK/RIjkZCQYO3DIoRYmVBvV5zfOwTf781Efnm1Dl3fmOqESYlBCPNuW+MXe0Ns56WXXmrZJ4SQ1tZf03uH4H9bj6G0qlYFn8zfI8QWOKWq07POOks30rEM7h0FN3d39Bp3Lb589Q6eXkKIEuBhwKyB4doOXMYwlFTV6ty9ywd1jfESXQ0pIzA7Igkh5GQYnB0R5++hafIbUwswvU+ozkAlxC6Fnow4kE6ZWVlZut+Qc845p6OOze4Y0tc09Hb7vmNap8gFHCHEjIfBWbtvDg73xUfbjqGwokbFnjRtoa0ghJDTr9U7kl+G9OJK7M0q1nmnhNid0Fu3bh2uvvpqbY7SdJivLDZqa9ks4FQZkBiBc4aFYeuS/2Dw4O+wYsUKS4MbQggxe55l/t7aI/k4kFMKP3cXDI4wDQAmJvLy8nDuuefq/s8//0w7SghpU+bEqBh//HI4T7sd9w3xZlSPdHva3aFD5ufJTLtdu3bpxTQ/P9+yyX1y6ri7GfDkrdOQnXZYO8UlJyfzdBJCTkA8zWfFmZxAG1ILcCi3lGepAWI7t2/frhvtKCGkrfQO9oK7ixPKq2txtKCMJ47YX0Tv4MGD+Pzzz5GYmNg5R2TnuLm5wdHR0bJPCCHN0TfEC3llVdibVaINWiTSF+XrzpNFO0oIOUWkLq9XkCe2pxfhYE4p4gM8eS6JfUX0ZIad1OeRzmHgwIGa/iqb7BNCSHNIqvy4uAAdtSDDfpcezOacPdpRQkgHDFEXMoorTyhRIsTmI3p33XWXjk/IyMhQIeLi4tLo54MGDerI4yOEENICjg4OmJgQhMKKdOSWVasXenSMP88XIYScIkEeBo3sVdbUoaCiBv7ujde5hNi00Js9e7beXn/99Y08y+YukWzGQgghZw5ZkAyN9NOInnSMo9AjhJBTx9HRASGeBu2+mVlcQaFH7EvopaSkdM6REEWasAwePFj3pZEA0zcJIScj3NtVb2XkQmVNLVydnez6pNGOEkJOh3AfNxV6RwvK0SfEmyeT2I/Qi42N7ZwjIUpFRYUlJ1z2CSHkZLi5OMHH1RlFlTXIKqlCtJ99N2WhHSWEnA4yPH3L8UIcK6xATW0dnJ3a3dKCkO4j9BYtWoTp06drPZ7st8ZFF13UUcdmlyQkJGDixImWfUIIaQshXq4q9I4Vltu90KMdJYScDgEeLpYxC1L/HFqfNUGITQq9Sy65RJuvhISE6H5LsEbv9JEB6cuXL++AVyKE2BM9Aj2QlFuqLcFHRvnZtQeadpQQcjrIetbb1ST0yqprAFDoke5Jm1YCdXV1KvLM+y1tbMRCCCHWQdI1vVydtFOcpBwRQgg5dTxdTLGQ0qpankbSbbFfl28XJS8vD+PGjdNN9gkhpK2jFsbEBOj+vuwSuz5ptKOEkNPFw2BqalVGoUfsQeitXbsW3377baPH/vvf/yI+Pl6jfTfffDMqKys74xjtiuTkZD3Xssk+IYS0lXAfU3qRRPVqZYq6nUI7Sgg5XTzrhR4jesQuhN7f//537N69u1H76htuuAFTpkzBww8/jG+++Qbz58/vrOO0G9zc3DQ3XDbZJ4SQtuLq5AhHB9O+1JbYK7SjhJCOiuiVao0eITY+XmHbtm144oknLPc//vhjjB49Gm+99Zbej46OxmOPPYa//e1vnXOkdoLMzZN6R0IIaS/iIJJOceKBLquuhZdruyfo2AS0o4SQjqrRY+omsYuIXn5+PkJDQy33V65cqSMXzIwcORKpqakdf4SEEELajIeLyQttzxE9Qgg5XaS5lVBcWYM6O06FJ3Yi9ETkpaSk6H5VVRW2bNmCMWPGWH5eXFysc/YIIYRYD4noCRLRI4QQcmp4uzrDxdEBovEKKqp5GoltC70LLrhAa/FWr16NefPmwcPDA+PHj7f8fMeOHRzw3QFI7aOTk5Nusk8IIacU0bPjTnG0o4SQjkiFD/Aw6H5eGYUesXGhJ/V5zs7OmDBhgtblyWYwmL4AwjvvvIOpU6d21nHaDRUVFZa5hLJPCCHtwd3cEtyOI3q0o4SQjiDAw5SplltWxRNKuiVtrtQPCgrCqlWrUFhYCC8vL404NeSzzz7Tx8npkZCQoPWO5n1CCGkPPvUNWLJL7XdhQjtKCOkIfN1MQq+kkp03Sfek3S3ZfH19m308IMA0qJecHnIeN2zYwNNICDklonzd9TantAplVTXwMNhf503aUUJIR2BwMiW+VbMZC7H11E1CCCHdY/ZTkKcprT6tqNLah0MIId0WZyfTYNKaWo69It0TCr0uRl5enja+kU32CSGkvXjXR/Eqa+xzcUI7SgjpCFwY0SPdHPvL6eniJCcnY/HixZZ9psQSQtqLS70XurrOPoUe7SghpCOQ8QpCNSN6pJtCodfFcHNz05a+5n1CCDllL7SdLk5oRwkhHeo0q+XAdNI9odDrYgwcOFBHKxBCyKli74sT2lFCSMembnJdRronrNEjhBAbw8WRixNCCDl9W2puxmKE0WifjjPSvaHQI4QQG8PeI3qEENIRONdH9MSS1lLokW4IhV4XY+fOnXB2dtZN9gkhpL3Ye40e7SghpCNwro/oCXScke4IhV4Xo6KiArW1tbrJPiGEtBd7j+jRjhJCOgJHBweL2LNXxxnp3rAZSxcjISEBffr0sewTQkh7sfcaPdpRQkhH1unV1Bl1I6S7QaHXxZC5eXv37rX2YRBCbCJ10z4XJrSjhJAOrdOrqbNbe0q6N0zdJIQQm03dtM+IHiGEdLg9tdMMCdK9odDrYuTl5eGaa67RTfYJIaS92HtEj3aUENLhqfB2ak9J94ZCr4uRnJyMDz/8UDfZJ4SQU539JO3A6+ywJTjtKCGko3BmhgTpxrBGr4vh5ubW7D4hhLQ3omf2Qrs6/9Yi3B6gHSWEdBQ9AjwQ7GmAv4cLTyrpdti80CsoKMCUKVNQU1Oj2z333IObbroJXZWBAwfCaIceeEJIx+Hk6AAHB0BMidTpuTrbV/IG7SghpKPoE+LNk0m6LTYv9Ly9vbFq1Sp4eHigtLQUAwYMwKxZsxAYGGjtQyOEkE7D2cEB1XaaukkIIYQQO6jRc3JyUpEnVFZWarSMETNCiD1E9QTOfiKEEELsE6sLPYm2zZw5ExEREXBwcMDChQtPeM6rr76KuLg4rbsYPXo0NmzY0O70zcGDByMqKgoPPPAAgoKC0FVJSkqCi4uLbrJPCCGnI/SkIYu9QTtKCCGEdAGhJ+mUIsJEzDXHJ598gvvuuw+PPfYYtmzZos+dNm0asrKyLM8ZMmSIpmQ23dLS0vTnfn5+2L59O1JSUrSbZWZmJroq+fn5lnpC2SeEkFPByaFe6NXZn9CjHSWEEEK6QI3e9OnTdWuJF154QZunzJ07V++//vrr+O677/DOO+/g4Ycf1se2bdvWpvcKDQ1Vobh69WpcdtllzT5H0jtlM1NUVIQziUQ2JXpp3ieEkNOK6FlB6NGOEkIIIdbH6hG91qiqqsLmzZu1a6YZR0dHvb927do2vYZE74qLi3W/sLBQU0V79+7d4vPnz58PX19fyxYdHY0zSWRkpEYeZZN9QgjpbkKPdpQQQgixPl1a6OXk5KC2tlYjcQ2R+xkZGW16jSNHjmD8+PEayZPbu+66S1tvt8S8efNUEJq31NTU0/47CCHEejV6Z/7c044SQggh1sfqqZudzahRo9qc2im4urrqZi3Ky8stKalPP/003N3drXYshJDuPV7BWhE92lFCCCHE+nRpoSfdMWU8QtPmKXI/LCwMtsiuXbvw8ssv6/7vf/97jBw50tqHRAjphlgzddPa0I4SQgghXTx102AwYPjw4Vi2bJnlsbq6Or0/duxYqx4bIYR0Zex5vAIhhBBCukBEr6SkpNG8OGlCIqmWAQEBiImJ0dEKc+bMwYgRIzQN88UXX9SRDOYunLaGRPA40J0Q0lHjFexxYDrtKCGEENIFhN6mTZswadIky30RdoKIuwULFuCKK65AdnY2Hn30UW3AIjPzlixZckKDFkIIIb9hz6mbhBBCCOkCQm/ixIknjWDdeeeduhFCCGkbTN0khBBC7JsuXaNnj0gaq7ljXcOUVkIIOZXUTXuM6NGOEkIIIV0gokcak5+fr4PizfuEEHIqONW78exR6NGOEkIIIRR6XY6IiAiEh4db9gkh5FSw5xo92lFCCCGEQq/LERkZibS0NGsfBiGkm+NcL/Rq7HC8Au0oIYQQwho9QgixSey5Ro8QQgghjOh1OcrLy/Hqq6/q/h133AF3d3drHxIhpBtiz6mbtKOEEEIIhV6XY9euXXjggQd0f8KECTr4lxBC2os9j1egHSWEEEKYukkIITYJUzcJIYQQ+4bjFboYEsE72QB5Qgg5Gfacukk7SgghhDCiRwghNt110x5TNwkhhBDCiB4hhNgkbi5OiPJ1g48rEzcIIYQQe8TR2gdAGpOUlKSdNmWTfUIIORUCPQyY3icUZ8UH2t0JpB0lhBBCGNHrcuTn56OiosKyTwghhHaUEEIIaS/M6eliREREICAgwLJPCCGEdpQQQghpLxR6XYzIyEjk5uZa+zAIIaTbQjtKCCGEsEaPEEIIIYQQQmwORvS6GOXl5Vi0aJHuX3TRRdqUhRBCCO0oIYQQ0h4o9LoYu3btwpVXXqn7GzZs0MG/hBBCaEcJIYSQ9kChdxKM9cOGi4qKcCYoKSlptH+m3pcQQsyY7Y7Z/p0utKOEEHuko20pIe3FwchPX6scO3YM0dHR7T6xhBDS3UlNTUVUVNRpvw7tKCHEnukoW0pIe6HQOwl1dXVIS0uDt7c3HBwc2uXFEYEoX24fH592/8PYAzxHPD/8DHXN75n4/4qLi3XEi6Ojo9XsqEA7wfNzuvAzxPNjrc9QR9tSQtoLUzdPgnwxT8cLIwaBQo/n6HTgZ4jnyBqfI19fX3QVOyrwe8Dzc7rwM8TzY43PUEfaUkLaC90LhBBCCCGEEGJjUOgRQgghhBBCiI1BoddJuLq64rHHHtNbwnPEzxC/Z9aiu9ui7n78nQ3PD88RP0P8nhHSEmzGQgghhBBCCCE2BiN6hBBCCCGEEGJjUOgRQgghhBBCiI1BoUcIIYQQQgghNgaFXifx6quvIi4uDm5ubhg9ejQ2bNgAe2DVqlWYOXOmDgeVwcgLFy48YXjoo48+ivDwcLi7u2PKlCk4ePBgo+fk5eXhmmuu0Vk1fn5+uOGGG1BSUgJbYP78+Rg5cqQOjg4JCcEll1yC/fv3N3pORUUF7rjjDgQGBsLLywuzZ89GZmZmo+ccPXoUM2bMgIeHh77OAw88gJqaGtgCr732GgYNGmSZVzR27FgsXrzY8nN7Pz9Nefrpp/W7du+999rcObJXOyrQlrYObWnr0I62H1u2pcSOMZIO5+OPPzYaDAbjO++8Y9y9e7fxpptuMvr5+RkzMzNt/mx///33xr/85S/GL7/80igfr6+++qrRz59++mmjr6+vceHChcbt27cbL7roImN8fLyxvLzc8pzzzz/fOHjwYOO6deuMq1evNiYmJhqvuuoqoy0wbdo047vvvmvctWuXcdu2bcYLLrjAGBMTYywpKbE859ZbbzVGR0cbly1bZty0aZNxzJgxxnHjxll+XlNTYxwwYIBxypQpxq1bt+o5DwoKMs6bN89oCyxatMj43XffGQ8cOGDcv3+/8c9//rPRxcVFz5lg7+enIRs2bDDGxcUZBw0aZLznnnssj9vCObJnOyrQlrYObWnr0I62D1u2pcS+odDrBEaNGmW84447LPdra2uNERERxvnz5xvtiaZCr66uzhgWFmZ87rnnLI8VFBQYXV1djR999JHe37Nnj/7exo0bLc9ZvHix0cHBwXj8+HGjrZGVlaV/78qVKy3nQ0TNZ599ZnnO3r179Tlr167V+3IhcXR0NGZkZFie89prrxl9fHyMlZWVRlvE39/f+Pbbb/P8NKC4uNjYs2dP408//WScMGGCZXFiK58h2tHfoC09ObSlJ4d21D5tKbFvmLrZwVRVVWHz5s2akmjG0dFR769duxb2TEpKCjIyMhqdG19fX03JMp8buZV0zREjRlieI8+Xc7h+/XrYGoWFhXobEBCgt/LZqa6ubnSO+vTpg5iYmEbnaODAgQgNDbU8Z9q0aSgqKsLu3bthS9TW1uLjjz9GaWmppnDy/PyGpBNJulDDz4pgC+eIdrR1aEtPhLa0ZWhH7deWEuLMU9Cx5OTkqFFt+KUX5P6+ffvs+nSLyBOaOzfmn8mt5Lg3xNnZWYWQ+Tm2Ql1dndYCnHXWWRgwYIA+Jn+jwWBQsdvaOWruHJp/Zgvs3LlThZ3UR0hdxFdffYV+/fph27ZtPD+Ait8tW7Zg48aNJ5w7W/gM0Y62Dm1pY2hLm4d29OTYui0lhEKPECt6EXft2oU1a9bw36AJvXv3VlEnXvrPP/8cc+bMwcqVK3meAKSmpuKee+7BTz/9pE1KCLF3aEubh3a0dWhLiT3A1M0OJigoCE5OTid0ZZL7YWFhsGfMf39r50Zus7KyGv1culdJJ05bOn933nknvv32WyxfvhxRUVGWx+VvlLS1goKCVs9Rc+fQ/DNbQLyoiYmJGD58uHbXGzx4MF566SWen/p0IvmODBs2TKPdsokIfvnll3VfvMnd/TNEO9o6tKW/QVvaMrSjrWMPtpQQCr1OMKyyOF22bFmjtBK5L6lo9kx8fLwavobnRvLYpfbOfG7kVoyqGGAzP//8s55DqeXr7khfBVmYSCqi/F1yThoinx0XF5dG50jGL0j75obnSFJyGgpiie7IKAJJb7RF5N+/srKS5wfA5MmT9d9fIp7mTWpaZSSJeb+7f4ZoR1uHtpS29FSgHbU/W0oIu252Ultw6SS5YMEC7SJ58803a1vwhl2ZbBXpXiUthmWTa/ELL7yg+0eOHLGMV5Bz8fXXXxt37NhhvPjii5sdrzB06FDj+vXrjWvWrNFuWLYyXuG2227T8RIrVqwwpqenW7aysrJG7Zxl5MLPP/+s7ZzHjh2rW9N2zlOnTtURDUuWLDEGBwfbTDvnhx9+WLuQpqSk6GdE7kvX1R9//FF/bu/npzkadoqzlXNkz3ZUoC1tHdrS1qEdPTVs0ZYS+4ZCr5P497//rcZB5kBJm3CZCWcPLF++XAVe023OnDmWEQuPPPKIMTQ0VBdxkydP1llpDcnNzVVh5+XlpS2K586dq4seW6C5cyObzNYzI6L39ttv11bYHh4exksvvVTFYEMOHz5snD59utHd3V1n9tx///3G6upqoy1w/fXXG2NjY/W7IxdM+YyYRZ5g7+enLYsTWzlH9mpHBdrS1qEtbR3a0VPDVm0psV8c5H8MbBJCCCGEEEKI7cAaPUIIIYQQQgixMSj0CCGEEEIIIcTGoNAjhBBCCCGEEBuDQo8QQgghhBBCbAwKPUIIIYQQQgixMSj0CCGEEEIIIcTGoNAjhBBCCCGEEBuDQo8QQgghhBBCbAwKPUJOkxUrVsDBwQEFBQXd+lzGxcXhxRdftPZhEELsENpRQgjpeCj0iE1z3XXXqQi79dZbT/jZHXfcoT+T51ibBQsW6LGcf/75jR4X8SiPyyKIEEKsAe0oIYR0Tyj0iM0THR2Njz/+GOXl5ZbHKioq8OGHHyImJgZdBWdnZyxduhTLly+HrVBVVWXtQyCEdAC0o9aDdpQQcqpQ6BGbZ9iwYbpI+fLLLy2Pyb6IvKFDhzZ6bmVlJe6++26EhITAzc0NZ599NjZu3NjoOd9//z169eoFd3d3TJo0CYcPHz7hPdesWYPx48frc+S95TVLS0tbPU5PT09cf/31ePjhh9uV3rRt2zZ9zHwcEh308/PDt99+i969e8PDwwOXXXYZysrK8N5772mKpr+/vx5TbW1to9cvLi7GVVddpccSGRmJV199tdHP5X1vvPFGBAcHw8fHB+eeey62b99u+fnf/vY3DBkyBG+//Tbi4+P1HBJCuj+0o7SjhJDuB4UesQtEQL377ruW+++88w7mzp17wvMefPBBfPHFFyqItmzZgsTEREybNg15eXn689TUVMyaNQszZ85UgSWip6kwS05O1hTM2bNnY8eOHfjkk09U+N15550nPU4RSjt37sTnn39+Wn+viLqXX35ZI5lLlixRgXjppZeqSJXt/fffxxtvvHHC+zz33HMYPHgwtm7dqn/XPffcg59++sny88svvxxZWVlYvHgxNm/erIu/yZMnW86PkJSUpOdQxLScI0KIbUA7SjtKCOlmGAmxYebMmWO8+OKLjVlZWUZXV1fj4cOHdXNzczNmZ2frz+Q5QklJidHFxcX4v//9z/L7VVVVxoiICOOzzz6r9+fNm2fs169fo/d46KGHjPJVys/P1/s33HCD8eabb270nNWrVxsdHR2N5eXlzR7nu+++a/T19dX9hx9+2NirVy9jdXW1vqa89vLly/VnctvwvYStW7fqYykpKZbXkvtJSUmW59xyyy1GDw8PY3FxseWxadOm6eNmYmNjjeeff36j47riiiuM06dPt/wNPj4+xoqKikbPSUhIML7xxhu6/9hjj+k5lPNNCLENaEdN0I4SQrobjOgRu0BSDWfMmKFpjRLZk/2goKATInHV1dU466yzLI+5uLhg1KhR2Lt3r96X29GjRzf6vbFjxza6L6mM8j5eXl6WTaKCdXV1SElJOemxPvTQQ8jOztao46ki6ZoJCQmW+6GhoZqyKcfS8DGJzrX2t8h9898uf1dJSQkCAwMb/W3yN8m5MxMbG6vnmxBiW9CO0o4SQroXztY+AELOZNqROX2yae1ZRyJi6JZbbtEauKa0pfmL1NfNmzcPjz/+OC688MJGP3N0NPlmjEYJ2pkQcdoUEagNkRq+5h4T8dmevys8PLzZDqByzGakvo8QYpvQjtKOEkK6DxR6xG6QujnpXiYCRyJsTZEImMFgwC+//KJRKbOIkmYs9957r97v27cvFi1a1Oj31q1b1+i+1K3t2bNH6/tOlbvuuktr7F566aVGj5sjZenp6dpQRejIOrimf4vcl7/Z/HdlZGRod1CJDhJC7A/a0ZNDO0oI6SowdZPYDU5OTpqGKCJM9psikajbbrsNDzzwgDYwkefddNNN2tjkhhtu0OfIPL6DBw/qc/bv368jGiRNs2nq5a+//qrRQxFh8vyvv/66Tc1YzEi3SonoidhriIhH6eIpTVvkdb/77jv885//REchIvfZZ5/FgQMHNOr52WefaUMWYcqUKZrKeckll+DHH3/ULp/yd/7lL3/Bpk2bOuwYCCFdF9rRk0M7SgjpKlDoEbtCRgLI1hJPP/20dsv8wx/+oBEs6SD5ww8/WKJnknopHSUXLlyo3Slff/11PPXUU41eY9CgQVi5cqWKJRmxICMcHn30UURERLTrWOfMmYMePXo0ekzSLz/66CPs27dP3+eZZ57Bk08+iY7i/vvvV9Emxyyv+8ILL1iinxIJlY6d55xzjnYslRETV155JY4cOaL1foQQ+4B2tHVoRwkhXQUH6chi7YMghBBCCCGEENJxMKJHCCGEEEIIITYGhR4hhBBCCCGE2BgUeoQQQgghhBBiY1DoEUIIIYQQQoiNQaFHCCGEEEIIITYGhR4hhBBCCCGE2BgUeoQQQgghhBBiY1DoEUIIIYQQQoiNQaFHCCGEEEIIITYGhR4hhBBCCCGE2BgUeoQQQgghhBBiY1DoEUIIIYQQQghsi/8HiY9kNwiAfzcAAAAASUVORK5CYII=", + "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, 615.48it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 164.51it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 626.13it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 220.96it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Custom backend silhouette score: 0.980\n", + "N4SID backend silhouette score: 0.963\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, 52.64it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 177.45it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 44.00it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 202.00it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 435.29it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 217.24it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 651.23it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 227.44it/s]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABTEAAAFPCAYAAACVlIpbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXhBJREFUeJzt3QeYFEXawPGamZ3dZTM5ZxAEMYERERQEBHM60x0oYjjM52c6FZVT1DOgmD1FDIeKAe84FRMcKpwKSDAgIEjOcWHZNNPf85bOTFdvzrW7/9/zDNs93dPdM7P7UvNO1Vs+x3EcBQAAAAAAAACW8tf0BQAAAAAAAABAcUhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAANRiAwYM0Lfy8Pl86u67746uv/zyy/q+X3/9VdUUeS4HHXSQqm9mzZqlX3v5CQAAgIJIYgIAgGoVSZRFbomJiapVq1ZqyJAh6oknnlCZmZkFHiOJNtnX7/ertWvXFti+Z88e1aBBA73P1VdfHb1fknHucwWDQdWkSRN17LHHqttvv12tWbOmQs9l5MiRxvHT0tLUIYccoh555BGVk5OjKsuPP/6oX4OaTC5WxPTp09XQoUNV48aN9ft9wAEHqJtuuklt3769pi8NAAAAtQRJTAAAUCPuvfde9eqrr6pnnnlGXXPNNfq+66+/XvXq1UstXry40MckJCSoKVOmFLj/3XffLfZcF1xwgT7Xiy++qO68807VqVMnNWHCBHXggQeqN954o0LPQ65Jji23+++/XzVq1Egn6EaMGKEqM4l5zz33FJrE/Pjjj/XNVvJanHrqqWrTpk3qlltuUU8++aQaNGiQ/ikJ359//rmmLxEAAAC1QFxNXwAAAKifTj75ZNWnT5/o+m233aY+//xzdcopp6jTTjtN/fTTT7p3pduwYcN0EvPmm2827v/nP/+phg8frt55551Cz3X44Yeriy++2Lhv9erVavDgwTrZKMlMSaiVR1xcnHHsP//5z+qoo45Sb775pnr00Ud1L9Pyys7OVvHx8cXuU9L2miTvlfRK/cMf/qBef/11FQgEjF6sJ5xwgjr33HPVggUL9Otok8hrL71/AQAAUPNolQEAAGuceOKJuqekJBhfe+21AtsvvPBCtXDhQrV06dLofdLDT5Kfsq0s2rdvr4e25+bmqoceekhVFkl6RWpUSs/JHTt26N6I0sM0JSVFDzmXBO6iRYsKrYkoPUPvuOMO1bp1a5WUlKSH2EuiT0jSLzJ0PVI70VsTU57PXXfdpXr37q3S09NVcnKy6tevn5o5c2aZn4skeGX4fV5eXoFtkgDu1q1bsY+X3qMNGzZUzz//vJHAFEceeaTumblkyRL19ttvF3js/Pnz9bB/SWR37NhRPfvsswX2mThxourZs6d+neQ8khSXhLbb+vXr1aWXXqqaN2+ue83K/i+99FKpXntJrsr9kydPLnDuGTNm6G0yVL4s5xLr1q1TZ5xxhn5vmjVrpm644YZKLT8AAABQF5HEBAAAVvnjH/+ofxY2RPr4449Xbdq0MRJV0uNRkoPSE7OsjjnmGNW5c2f1ySefqMr0yy+/6J9SA3LlypVq2rRpuoep9Mz8v//7P52469+/v9qwYUOBx44bN0795z//0YlPGZ4uycJrr71Wb5M6npGh69J7tDBSH/Qf//iHTmw++OCDupbm1q1bdc1RSQCX9b2QupWSsHOLJI69vVvdli9froeKn3766TpxW5g//elP+qc7ESh27type91KIlYSzPKeX3XVVUZC8IUXXtCvS48ePXRpAEmYHnrooerrr7+O7rN582Z19NFHq08//VTXSn388cdVly5d1KhRo/RjSnrt5dhSeuCtt94qsK/83kniVF7Xspxr//79auDAgfo1lf3++te/qi+++KJA72IAAACY7Bq3AwAA6j1JWEkPwkgi0E16vp1//vl6mLLU1BQyTPmss87SPd/KQ2bCfv/993Xyr6hkW0m2bdumf+7evVsnvCRpefDBB+ueitLDbtmyZcawZEkOdu/ePVqj0zuMed68ecZQeulJKT0yTzrppBJnIpfEmvQAdQ8zHz16tD6f9FyUc5alZ6y8H9IrVpKwEfL6h8PhYpOYUsdTFDdMv0OHDvo1l9IBbpLclWHoN954o16/4oor9BB9KTkgr51M0CTJRunpOHXq1CKPLwnCUCikk8aSUBZXXnmlrpEqyV05rvt1Luy1l6HwDz/8sE6symsb6e363nvv6d87uZaynEt6pcrvg/yeRHrYyvtT3nIGAAAA9QU9MQEAgHWkZ2Vhs5QLGTa+YsUK9e2330Z/lnUoufdcoqjzlWTfvn2qadOm+iY976S3pPTwlCSXkORqJIEpSS7p2SjnlASnDFcubAi3txZoWciw7UgCUxKNMpw9Pz9fD7Uu7HzFkeu+6KKL1L/+9S/j9ZHEsQz1lmHeRYnsn5qaWuw5ZLskkN2kPqYk/SLk+cj6li1b9DBzkZGRoYdly/tfGMdxdI1UmVRIliXRHLlJ70lJOHtfj8Jee0liynB69+RR0kt4165deltZz/XBBx+oli1bqnPOOSd6PBm6fvnllxf7OgEAANR3JDEBAIB19u7dW2Ty67DDDtO9CmVIuSTTWrRooXsMVuRcpUm2FSUxMVEPR5fb7Nmz1dq1a9VXX32lhyFHEomPPfaY6tq1q05oSo1JSXjKDOyS3PIqLjFYWlLDUXqCyrVJr0A5n/RcLOx8JZEh3zIEOpKUlSHikkiMDPsvSuT1LCk5LNu9r71MhiT1It0OOOAA/TMyQ7vU05RksNTWlNd2zJgx+nWPkCH0kmiUno+RJHPkdskll+h9JCla0msvPSTl902Gj0fIsryPkd+7spxL6r1Kslt6FbuVVF8UAACgvmM4OQAAsIr0rpNkmyR6iiI9L5955hmd/JLecBWZQfr777/Xk6uUdyi59HwcNGhQkdultqIMGZcJX6TmYqNGjfT1Xn/99TrB6VWRXphChn7LzN8ycYzU35TnJtc4fvz4Qofol0TqQkptSjmuJDTlp/SMPO+884p9XKRmpyRriyIJPemFKecoKzm+JFSlnuZHH32ke0I+/fTTelIjqY8ZeW1lyLv0sCyMJHpL89rL79h9992ne1bK75z0TJVh4pEZ1ctzLgAAAJQNSUwAAGAVmbRGRCZMKSqJKcmqjRs3Rvcvj7lz5+rEXnG1HStKZt6WWcW9tSil55705isNb6+9ks4nvUBl+LP7cWPHjlXlJclLqU8pr7f0gJVJlCL1IYsiPSflJvVBZZKbwnq6vvLKK/qnu95mpCamDNN398aUOpKROpoRsl0SjHKTOpVSo1KSjVI7U3pByjllCH9xSebSkONLYlQSpTLzuCRepTZrRFnO1b59e504l2Hn7vdHErIAAAAoGsPJAQCANWTGa+mtKMN6pRZjUWRGcZnxWXoXynDi8pBegNJjUXoVSo/FqiK9ICVh5SaT0axfv77Ux4gk8yTxWZrzCfc5ZcZuSdiWl/Q6lITbddddp2dbL23SVxLNMiGOTHAjCT43GZIus6fLxEpnn322sU1qeD733HPRdUlQyrokC6VXqJDaom7yPkqPTnneUsNSXgc5riQeJWnoJUPAy9Lrs1evXnoYudykpuXxxx8f3V6Wc8ms65KklWRzRFZWlh6KDgAAgKLRExMAANSIDz/8UC1dulQnrDZv3qwTmFJXUnqqyXBdqedYHEmolZZMqiLDoGXYryQCZTIYSThJYk56cnqH+kZ6+0XqL1aE9DKUmdSlNqJMhiOzV0stz0jNzNI49NBDdaJMkn4y1F5qa0o9RhkqXtj5pBfmmWeeqXtMrlq1Sj377LM6wRep/1lWkjwcOnSoTr7KhDpy3NKQRLS81tITU2Yrl3XpwSnvx0svvaTrdUoyLzLDt7smpjxXef2lN6ckDhcuXKgTfZF9Bw8erOuh9u3bV/eOlBnOn3zySX1tkV6fDzzwgJo5c6ae2VxmAJfXQCY6kvN/+umnerksvTElKSu/l6NGjSpQwqC055Jtcp3Su1USuZIQld9BmdwHAAAARSOJCQAAaoQkhCI96KROpPR0k96Vkuwr7yQ7RZkyZYq+SQ1DqX0pE8FITUrpIdiuXbsC+8tQ5uJqcpaFzFYux5Nh2JKMO/zww/UkO7feemupjyHJOklESs9TSaBJr0ZJmBWWxJTepZs2bdI9F2fMmKGTaZLAlQTkrFmzyv08JOkm9SelFqYkUUtL3lMZTv/UU0/p+qDS67Bt27Z6Ih55DQobUi+JTpmc6JprrlEvvPCCTlJK4k8SgBEyW7kkgx999FGdnG3Tpo269tpr1R133BHdRx73zTff6CSyJHalZqYkTnv27KmTpGUhSUw5tlx/ZFZyt9KeS5KVn332mX5uEydO1OuS3D355JN1ohgAAACF8zne8U0AAAD1mPQYlMSTJOxK2+OwPnj//ff1ZEEyA3u/fv1q+nIAAABQz1ATEwAAwEV6OB5zzDEkMD2kR6QMgT/uuOP4fQEAAEC1oycmAAAAivTGG2+oxYsX66HsUttShmwDAAAA1Y0kJgAAAIpuLPp8KiUlRdeBlLqcUlcUAAAAqG60QgEAAFAkyqcDAADABtTEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAFDD3nrrLdWoUSO1d+/eSjlehw4d1MiRI1Vl+uijj1RKSoraunVrpR4XgF1+/fVX5fP51Msvv1yq/YlfAEqrsuNFfXP00Uerm2++uaYvA6j1arqtU98cXcmxiyQmgFpryZIl6pxzzlHt27dXiYmJqnXr1uqkk05SEydONPa7//771bRp08p9nh9//FHdfffd+j+8yhYKhdTYsWPVNddco5OE7kTkKaecoqrb008/Xeh/6EOHDlVdunRR48ePr/ZrAmz1yy+/qCuuuEJ16tRJx6C0tDTVt29f9fjjj6v9+/dX2XmrMiaVBfELqB51ub2Tm5urY+Zhhx2mY2hGRobq2bOnuvzyy9XSpUtVXfHBBx/o17YibrnlFvXUU0+pTZs2Vdp1ASWhrUPsutu22OUAQC301VdfOfHx8U6XLl2ccePGOS+88IJz1113OYMHD3Y6d+5s7JucnOyMGDGi3OeaOnWqI+Fy5syZTmV77733HJ/P56xbt864v3379s7w4cPLdczs7GwnNze3XI/t2bOn079//0K3Pf30005SUpKzZ8+ech0bqEumT5/uNGjQwMnIyHCuvfZa5/nnn3eefPJJ5/zzz3eCwaAzevToKjt3VcakVatW6WNPmjSpxH2JX0DVq+vtnVNOOcUJBALOxRdf7Dz11FPOhAkTnCuvvNJp06ZNqeJQbTFmzBj92lZEKBRyWrRo4dx5552Vdl1AcWjrELvGWBi74ionFQoA1eu+++5T6enp6ttvv9Xf2rtt2bKl1rwdkyZN0j23pFdFZUlISFBV4eyzz9Y9KKZOnaouvfTSKjkHUBusWrVKnX/++bpX1Oeff65atmwZ3TZmzBi1YsUK9Z///EfZwHEclZ2drRo0aFDpxyZ+AVWvLrd35DlNnz5dP8fbb7/d2P/JJ59Uu3btUrbat2+fSk5OrtZz+v1+3SP3lVdeUffcc48eDgtUFdo6vyF22Re7GE4OoNYObZDhRt4GvWjWrFl0WYKkNDQnT56sl+UWqRe5evVq9ec//1l169ZNf8Bv3LixOvfcc41hVDK0Wu4TJ5xwQvQYs2bNiu7z4Ycfqn79+unGbGpqqho+fLj64YcfSnwOkliQWpODBg0q1XOW5/GXv/xFtW3bVicq5boffvhhnaQoriamPAe55q+++krdeOONqmnTpvpazzzzTKPGpTxOrvu///1v9HkOGDDAeF0PPvhg9f7775fqeoG66qGHHtJ1kV588UUjgRkhpReuu+666Hp+fr4aN26c6ty5s/7blb81+cCek5NjPC5SRuLLL79URx55pB42KkPVpdFX2pgUOcaMGTNUnz59dGx77rnn9LaVK1fqx0pdp6SkJF2jqLzJVuIXUD3qcntHnpuQ5KZXIBDQ1+m2fv16/SVq8+bNdSyV1+Wll14y9pHrlet+8803dZxt0aKFvt7TTjtNrV271tj3iy++0M+5Xbt2+njSvrrhhhsKlAOR11GGwMv1Dhs2TD/3iy66qNTHkMfLUMrI+xS5RYTDYTVhwgT9fCTuy/OTUiU7d+4s8LpIGQF5PxcuXFji6w5UBG0dYtdIS2MXPTEB1ErSA2ru3Lnq+++/VwcddFCR+7366qvqsssu0wkBqa8kJJEQ6QEwZ84c3aOqTZs2ujH/zDPP6MSd1IWSD/nHH3+8uvbaa9UTTzyhG8MHHnigfmzkpxx/xIgRasiQIerBBx9UWVlZ+hjHHXec+u6773RCoSjz58/XtaAOP/zwEp+vJCqlAT5z5kw1atQodeihh+okxf/93//pRv1jjz1W4jGkF2XDhg11TSp5rvKfztVXX60b+kLWI7Wq/vrXv+r75D8jt969e1eo3hZQF/z73//WycVjjz22VPtLDJLEgnwLLV9EfP3117q+7E8//aTee+89Y1/pxSn7yd+5xBb5gC6NSPnbk0ZiSTFJ/Pzzz+qCCy7QDcnRo0frxMXmzZv19UqMksdLckCuSeLK22+/rb/UKAviF1A96nJ7R56beP3113UiMy6u6I+mEsPkixf5AC1tF/lCVpKqEiv37Nmjrr/+emN/6d0p+0otNumxKm0cSaLKB+hIz3QZWSLP46qrrtIx8ZtvvtF1RtetW6e3ucmXUfLc5fnKF8jympX2GBKLN2zYoD755BP9OnrJdkkiX3LJJfo9kB5w0hNVXlf5AjoYDEb3lf8LhNwvdUSBqkJbh9h1ha2xq1IGpQNANfv44491DSW5HXPMMc7NN9/szJgxo9BakEXViMrKyipw39y5c3Xdj1deeaXEGlGZmZm6Hp639t2mTZuc9PT0Emvi/eMf/9DHXbJkSYFt3pqY06ZN0/v+7W9/M/Y755xzdI2pFStWGI91P1+pKSWPHTRokBMOh6P333DDDfr127VrV6lqYor7779fH2vz5s3FPjegrtq9e7f+Gzj99NNLtf/ChQv1/pdddplx/0033aTv//zzz42/Xblv9uzZ0fu2bNniJCQkOH/5y19KVbcucoyPPvrIuP/666/X93/xxRdGDOvYsaPToUMHXa+oLDUxiV9A9ajL7R1pk0ibQ7Y1b97cueCCC3RdzNWrVxc4xqhRo5yWLVs627ZtM+6XOsRyDZHnKNcux2vdurVRw/utt97S9z/++OPFvi7jx4/X7Sr3NchrKo+99dZbC+xf2mMUVVdOYrLc//rrrxv3Swwv7H4hNVKvuuqqAvcDlYW2zm+IXY6VsYvh5ABqJemSLj0TpBfRokWL9JAH+YZcai3961//KtUx3DXi8vLy1Pbt2/UwUBmytWDBghIfL99KSb0m6fG0bdu26E2GQB111FG612Rx5HxCekeWZlZLOa58y+Umvbqkl6b0RiiJ9MxwDwGQIWEyW6h07S+tyLXK8wTqI+nxI2Q4YWnI366QUg7ev13hHc7do0cP/bcZIb2NpCelDAUvrY4dO+p46L0O6aElvYgipNe1xAXplSW9scqC+AVUj7rc3pE2iYwq+dvf/qa3TZkyRdcVlh6af/jDH6I1MaWd884776hTTz1VL7uvQV6L3bt3F3gef/rTn4w4LT3cpfxHJCZ7XxcZii/Hkx7rcg7pSeQlvS29ynoML+mtKTVP5X12Py/ptSQxurDXVl4r2mGoSrR1fkPssjN2MZwcQK11xBFHqHfffVcPUZKGvQzLlGHV0lCV4UKSDCiO1CuSIZ1SsFmGZLtrS0qDuCTLly/XP0888cRCt6elpZXqeXhrWhZGEo2tWrUqkDiJDPMqTSJS6jW5RT5MFFa3pKRrpZg86qvI33VmZmap9pe/TSloLgkDN6nTJgkE79+u9+808rdalr9TSWIWdh2SbPByx5DihqoWhfgFVL263N6ROpJSwkZuGzdu1HW5H3/8cfXWW2/poYivvfaart8tCc3nn39e3wrjneSoa9euxrq0WyQOu+uArlmzRt111106GeyNsd7XRYa6y1B8r7Ico6jXVvZz1zct7nlFXkfaYahKtHUK/s15EbuW11jsIokJoNaLj4/XDXy5HXDAAbouh3w7JLUfiyP1H6VBL3WUjjnmGP1tkgRWqRklhYpLEtlHaoRIQsKruNpOIlKwXhq9hTWMK5v0mChvEiIi0kBv0qRJpV0XUNsa9vKFgtSnK4vSNtoq4++0KmYi9yJ+AdWvrrd3pKekXNPZZ5+tawBLIlPqrUXOf/HFF+u6nIWRiQfLQkaiSA+iHTt26LqZ3bt31xMASZJX6hB7XxdJWMgXUhU5RmFkH0kCSF3QwkhvfC9J6NIOQ1WirfMbYpedsYskJoA6RWbjFfJtfknJA5nMQhrDjzzyiDGDZmT4UkmPjxTMlwBe2hnG3aSxK6QIcq9evYrdV4ZWffrpp7r3l7s35tKlS6PbK0NJiRa5VvnPp7D/mID6Qmb/lt5AMsRTEgLFkb9NaehJbxv35DsySYXEmvL87ZbnW2w5j0z441XeGEL8AmpWXW3vCOmBKUlJiZsy9FDaHNL2kaRhac8f6T3q/iJIJk6LJDuXLFmili1bpic4k6Hn7qHzpVWWYxT32kr7TiY2Ks0XUJIglR657v9PgKpAW4fYZWvsoiYmgFpJ6mwU1jMpUutIashFyLfi3oZ6pMeT9xgyo6Q0kt3k8cJ7DKnDJN9U3n///brGlJcMfyqO1AyRXhXz5s1TJRk2bJi+LpnxzU2Gk8l/LieffLKqDEW9Vu4ZRktK2gB13c0336z/VmQmYElGev3yyy96OGTkb1fIzLhujz76qP45fPjwMp+/qJhUHLkOmTVXEq/u+m2SjJVZhUsajupF/AKqR11u70iiUYZje8n5JVZJKQ1JYMr1S+9MqYtZWC/4ws7/yiuvGGU/JJErCd9IeynS6939ushyJHaXRlmOUdRre9555+n3Ydy4cQUeIzOie/eXdpiQuptAVaKtQ+yyNXbRExNArSRDo7KystSZZ56pv+GXb3bmzJmj3nzzTf2BXIZYuRvP8k2RJA1kGKjUi5PacPINowyNkmFV8gFeGsyyX2ToQMShhx6qG6oPPvigrv0hQ4qkLpT0SHjmmWfUH//4R3X44YfrIVDS2JYGuUzWId9MeZOObomJiWrw4MH6nPfee2+xz1eK2Z9wwgm6ZpTUczrkkEPUxx9/rN5//309PCzSS6Ki5LWS5yRF9qV2lDzHSA0sqW2yePFiXXQfqM/k7+2f//ynnnhCvlGWHjhSTzISh2R4pwwlFPK3Kj2gJFkoDbr+/fvrZKL03DnjjDP033VZFReTinLrrbfqSTPkA7xMENaoUSN9DdIzShID3mGSJSF+AdWjLrd3pL7nhRdeqOOSTGgmcUl660hs2rBhg/7yJ5IofOCBB3RCV57P6NGj9fOQYdwyoY8cV5bd5FgykZm8PvJlkxxL2jXyWCGvpcTym266SZ9TkrQSC8tSf7gsx5D3Rkj8laSwPC95HeX/hCuuuELXLJX6pvI6SU9USfDK/yWSEJXap+5enlI7+bDDDiv1dQLlQVuH2GVt7Krw/OYAUAM+/PBD59JLL3W6d+/upKSkOPHx8U6XLl2ca665xtm8ebOx79KlS53jjz/eadCggXxV7owYMULfv3PnTueSSy5xmjRpoo8xZMgQvW/79u2j+0S88MILTqdOnZxAIKCPMXPmzOg2WZbHpqenO4mJiU7nzp2dkSNHOvPmzSvxebz77ruOz+dz1qxZY9zfrl0757TTTjPuy8zMdG644QanVatWTjAYdLp27er8/e9/d8LhsLGf9/onTZqkr/nbb7819pPr9j6XTZs2OcOHD3dSU1P1tv79+0e3PfPMM05SUpKzZ8+eEp8XUB8sW7bMGT16tNOhQwcdg+Tvpm/fvs7EiROd7Ozs6H55eXnOPffc43Ts2FH/7bZt29a57bbbjH0if7vy9+clf4fuv8XiYlJRxxC//PKLc8455zgZGRk6Vh155JHO9OnTjX1WrVqljydxoyTEL6Dq1eX2jlz/Aw88oONby5Ytnbi4OKdhw4bOiSee6Lz99tsFjiH7jxkzRsdQiaUtWrRwBg4c6Dz//PPGNcp1T5kyRcfZZs2a6ddD4uLq1auN4/3444/OoEGD9Gsir43E80WLFhWIgfIaJScnF/q8SnuM/Px8/Z41bdpUvw7ej+HyHHr37q2vVf4v6dWrl3PzzTc7GzZsiO4TCoX063THHXeU+HoDlYW2DrHrGstil0/+qXgqFABQHtINX3oTSJd8d3d86UEgw0yl54Qt5JuzAQMG6CHsAED8AlDReFHZZs2apXu4S08gdy+gumDatGm656qULJFJkABUPWKXfbGLmpgAUIOkS74MrXrqqafU3r179X0S4GUoUllr1FWljz76SA8PuO2222r6UgBYgvgFoCLxAmUjw/yvvvpqEphANSJ22Re76IkJAJZYuXKlLtQvdadkBk2ZNVjqWQGA7YhfAGxQl3tiAqi7iF2lR09MALDE7Nmz1Y033qhn8JQJe0hgAqgtiF8AAACoavTEBAAAAAAAAGA1emICAAAAAAAAsFqdTmK+/PLLyufzqV9//bWmLwUAAAAAAABAXU5iRpKR8+bNq7Zz/vjjj+ruu+8mAQqgTF588UV14IEHqsTERNW1a1c1ceLEUhdzljhX2O1///tfgf1zc3PV/fffr7p3767P1bx5czV8+HC1bt063jEAZRYOh9VDDz2ka/FKTDn44IPVlClTSv34Xbt2qcsvv1w1bdpUJScn64k1FixYwDsBoFrbU2L+/Plq6NChKi0tTaWmpqrBgwerhQsX8k4AqJY4tHfvXjV27Fgdhxo1aqQ/z0lOqzAvvPCC6t+/v/4sl5CQoNthl1xyCXmoYsSpOuyPf/yjOv/88/UvQ3mSmPfcc48aMGCA6tChQ5VcH4C65bnnnlNXXnmlOvvss/UEPV988YW69tprVVZWlrrllltKdQzZ/4gjjjDu69Kli7Gel5enE5Zz5sxRo0eP1smGnTt3qq+//lrt3r1btWnTplKfF4C6769//at64IEHdEyRGCSTi1144YW64S1tqZISoBKTFi1apP7v//5PNWnSRD399NO6DSXJBGn4A0B1tKfky5PjjjtOtW3bVicRJD5JPJIkwTfffKO6devGGwGgSuPQtm3b1L333qvatWunDjnkEN1ZpSjfffedTlyedtppqmHDhmrVqlU6sTl9+nTdrmrVqhXvlpdTC0yaNMmRS/3222+r7ZxTp07V55w5c2a1nRNA7ZWVleU0btzYGT58uHH/RRdd5CQnJzs7duwo9vESayTmSOwpyYMPPugEg0Hn66+/rvB1A8C6det0TBkzZkz0xQiHw06/fv2cNm3aOPn5+cW+SG+++WaB+LVlyxYnIyPDueCCC3iBAVRbe2rYsGFOw4YNnW3btkXv27Bhg5OSkuKcddZZvBMAqjwOZWdnOxs3btTLksOSNpLktEpr3rx5+jHjx4/n3SpErRhOXpjPP/9c9evXTw9ZysjIUKeffrr66aefSqyJKb0qTznlFPXll1+qI488UncN7tSpk3rllVeMx5177rl6WYZDRYZ0FpdBB1C/zZw5U23fvl39+c9/Nu4fM2aM2rdvn/rPf/5T6mNlZmaq/Pz8QrdJj4LHH39cnXnmmTqGyX7yjSAAlJf0upQe3u74Je2eq666SpeomDt3brGPf/vtt/UwqLPOOit6nwwrP++88/Sxc3JyeHMAVEt7SnpLDRo0SDVu3Dh6X8uWLXVPTOnZJMM8AaAq45CMBG7RokW5X+TISGAp1YOCamUS89NPP1VDhgxRW7Zs0XUrpXuvDKvs27dvqWoHrFixQp1zzjnqpJNOUo888ojutjty5Ej1ww8/6O3HH3+87iosbr/9dvXqq6/qm9RDAICihgKIPn36GPf37t1b+f3+6PaSSA0UqeEkX7DIlyjeWsBS6mLDhg16CLnUn5MvcuQm6/IfLgCUlcQniSPedo58UeKOb8U9/vDDD9exzvt4+ZJl2bJlvCkASh2PKtKeki9NGjRoUOD+pKQkXU/8+++/550AUKVxqDwkaSr5LfnsJ58HxcCBA3mn6kpNTKm3JAVSpWeA/BRnnHGGOuyww3Ttk8mTJxf7+J9//lnNnj1b9+QU0lNA6qZMmjRJPfzww7pnpmx74okndKJTajoBQHE2btyoAoGAatasmXF/fHy87g0gicfiyH5Sc2XYsGG6npwkKyUeSSySL2kkvonly5frn4899piOf1KvRcgkP1I8+ttvv9UJTQAoS/ySnpTS+9JNei+JkuKXPF6+APZyP75Xr168IQCqvD0lNS9lQsRQKKSPIyR5KXXDxfr163kXAFRpHCqP1q1bR0euyDkiuSjUgSSm/ELJ7HI333xzNIEp5EO7vMkffPBBicfo0aNHNIEZGfIk/+GtXLmyyq4bQN22f/9+/R9bYaRXpWwvzrHHHqtvEVLcWXqMS2y77bbb1EcffaTvjwyDkiHn8i2gfAEjTjzxRD0BkMwu/Nprr1XiMwNQ10l8KmwSRIldke1V+XgAqKz2lAz/lFIYo0aN0p8XpQzP3/72N/0ZkngEoDriUHl8+OGHKjs7W5dIlM9yMmwddSSJuXr1av2zsJnlZBjUjBkz9Bsuw6KKIrNEecmQcpndFwDKQ4YuyTf9hZH/kAob2lQSSUpKvd9333032qMgchwpnxFJYEbimszGKb02AaAwmzZtMtbT09N1TJFbYXUrJXZF4ltxKvp4AKis9pTMJrx27Vr197//PTo6T4aESkLzvvvuUykpKbzYAKr9c11JpIyYOPnkk/Xnv4MOOkjHq6uvvpp3qy7UxKyoyNACL8eRSaAAoOxk2KQkGqWWiZv8Byg1Tlq1alWul1USlXKMyLdxkePI0E8vGfLAlzEAiotT7tubb74ZvV8SnN52UKTnUknxSx4f2bc8jweAymxPSbJy8+bNepKfxYsX61I70iNTHHDAAbzYAGrkc11pde7cWZcSe/3113mn6kISs3379tG6ll5Lly7VteSK64VZWt66UABQnEMPPVT/9E7EI+vScI5sLyspcyHDFiI9B6SuXDAYLLSmk9RnkfIYAFCYTz75xLjJJImR+CUT8MgQJrdIDbmS4pdsX7BgQTRJ4H68TKZB0gBAdbenZJSdjFCJ1OOViWHbtGmjunfvzpsBoFriUEXIkPXdu3dX+XlqI39tzIrLL40MD3BPOS8zzX388cd6UozKEEmEMq09gNKQmpRSp/eZZ54x7pd1+RA/fPjw6H3btm3TX7pI0iBi69atBY65aNEi9a9//UsNHjw4OutvamqqjnMybFyOESHJB7mPAtAAijJo0CDjFpl4R4YtyZcjTz/9dHRf6ZX57LPP6kLz7nq90rtSYk9eXl70PqnfK72epPSFO85NnTpVnXrqqYXWywSAqmhPFUZ6nUtvzOuvvz7angKA6oxDhcnPzy90FN0333yjlixZUmB2dNTSmphCapxIrYBjjjlGF22WLPXEiRN1bae77767Us4hiVIZdv7ggw/qDLg0wOWX2TtDFQAIqY0ybtw4NWbMGHXuuefqHk4yjEkKM8uwJvdEZE8++aS655571MyZM9WAAQP0fX/4wx/0MSRZIHFGZid//vnn9X+UDzzwgPEiy0zkn332mY5J1157rb5PZrCTc9x+++28IQDKRHonyYd7aV9JcvKII45Q06ZN0zFMhjK5y/DIRGPyRfKqVatUhw4doknMo48+Wl1yySU6dsmoGEmIylAsiXUAUF3tqdmzZ6t7771XfwEsM/zKTOWTJk1SQ4cOVddddx1vBIAqj0OR+6VDXGQm83//+99q3bp1evmaa67RuSuZsFVKh8nnwJ49e+qOdJK8lJgl2++8807ercI4tcBLL70kRZqcBQsWRO/79NNPnb59+zoNGjRw0tLSnFNPPdX58ccfjcdNmjRJP27VqlXR+9q3b+8MHz68wDn69++vb24vvPCC06lTJycQCOjjzJw5s0qeH4C64/nnn3e6devmxMfHO507d3Yee+wxJxwOG/uMHTu2QEx5/PHHnSOPPNJp1KiRExcX57Rs2dK5+OKLneXLlxd6nvnz5zuDBg1ykpOTndTUVOf00093li1bVuXPD0DdFAqFnPvvv1+3kyR+9ezZ03nttdcK7DdixIgCbSuxY8cOZ9SoUU7jxo2dpKQk3ab69ttvq/EZAKhLytueWrFihTN48GCnSZMmTkJCgtO9e3dn/PjxTk5OTg08CwD1MQ4JaU/J/YXdIm0oiUvXXXedc/DBB+ucVjAY1I+T9pS3nYUYn/yjLCc9jOSbsxUrVugipwAAAAAAAADqj1pRFERqmEjX2sikPgAAAAAAAADqD6trYr7zzjtq1qxZuh7TZZddpuLirL5cAAAAAAAAAFXA6uHkHTt2VJmZmerMM89UEyZMiM4YDgAAAAAAAKD+sDqJCQAAAAAAAAC1oiYmAAAAAAAAgPqLJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAArEYSEwAAAAAAAIDVSGICAAAAAAAAsBpJTAAAAAAAAABWI4kJAAAAAAAAwGokMQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACrkcQEAAAAAAAAYDWSmAAAAAAAAACsRhITAAAAAAAAgNVqJIn51FNPqQ4dOqjExER11FFHqW+++aZazjt+/Hh1xBFHqNTUVNWsWTN1xhlnqJ9//tnYZ8CAAcrn8xm3K6+8slquD0DNq6n4VBZ33313gTjVvXv3mr4sAPUsNhGLANREfJo9e7Y69dRTVatWrXQbaNq0abwRQD1W1hg0depU/dlJ9u/Vq5f64IMPquXcL7/8coHPcPI4WJ7EfPPNN9WNN96oxo4dqxYsWKAOOeQQNWTIELVly5YqP/d///tfNWbMGPW///1PffLJJyovL08NHjxY7du3z9hv9OjRauPGjdHbQw89VOXXBqDm1WR8KquePXsacerLL7+s6UsCUA9jE7EIqN9qIj7JZzc5jyQPANRvZY1Bc+bMURdccIEaNWqU+u6773THNrl9//33VX5ukZaWZnyGW716dZnPW9/5HMdxqvOEkp2W3pBPPvmkXg+Hw6pt27bqmmuuUbfeemt1XoraunWr7pEpyc3jjz8+2hPz0EMPVRMmTKjWawFQ82yKTyX1fpJeBwsXLqzpSwFQj2MTsQhATccn6cn03nvv6SQEgPqnrDHoD3/4g/4iZPr06dH7jj76aJ0DevbZZ6v03NIT8/rrr1e7du0qxzNFjfTEzM3NVfPnz1eDBg2KXYDfr9fnzp2rqtvu3bv1z0aNGhn3v/7666pJkybqoIMOUrfddpvKysqq9msDUL1si08lWb58uR5G1alTJ3XRRRepNWvW1PQlAaiHsYlYBNRftscnAHVbeWKQ3O/eX0jvybLGrPLGv71796r27dvrZOfpp5+ufvjhhzKdF9WcxNy2bZsKhUKqefPmxv2yvmnTpmp9PyRLLlnwvn376mRlxIUXXqhee+01NXPmTJ3AfPXVV9XFF19crdcGoPrZFJ9K862ffJP30UcfqWeeeUatWrVK9evXT2VmZtb0pQGoR7GJWATUbzbHJwB1X3likNxfGTGrPOfu1q2beumll9T777+vc06Skzr22GPVunXrynTu+i5O1VNSG1PqHnjryF1++eXRZSny2rJlSzVw4ED1yy+/qM6dO9fAlQKA6eSTT44uH3zwwTqRIN/ovfXWW7q+CwBUB2IRAABA6RxzzDH6FiEJzAMPPFA999xzaty4cbyMNvbElCHagUBAbd682bhf1lu0aFFt13H11VfrGgjS27JNmzbF7ivJAbFixYpqujoANcGW+FQeGRkZ6oADDiBOAXVQbYpNxCKgfqlN8QlA3VOeGCT3V0bMqoz4FwwG1WGHHcZnOJuTmPHx8ap3797qs88+i94nXWhl3Z2Rrioyh5EkMKX48+eff646duxY4mMiE2dIj0wAdVdNx6eKkNoq0lucOAXUPbUpNhGLgPqlNsUnAHVPeWKQ3O/eX3zyySdljlmVEf9kOPqSJUv4DGf7cHKZgn7EiBGqT58+6sgjj9SzgMvsUJdcckm1DCH/5z//qWsQpKamRmsVpKenqwYNGugkgGwfNmyYaty4sVq8eLG64YYb9MzlMmQTQN1Wk/GpLG666SZ16qmn6iHkGzZsUGPHjtXfBF5wwQU1fWkA6lFsIhYBqIn4JF+YuEfJSW1w6Xgik7W2a9eONwWoR0qKQX/6059U69at1fjx4/X6ddddp/r3768eeeQRNXz4cPXGG2+oefPmqeeff77Kz33vvffqmdC7dOmiZyj/+9//rlavXq0uu+yySn1N6rpqT2LKlPZbt25Vd911l04iylT2MjmFtyBqVZAJMMSAAQOM+ydNmqRGjhyps+mffvpp9JdPZow6++yz1R133FHl1wag5tVkfCoLKf4sCcvt27erpk2bquOOO07973//08sA6h5bYxOxCEBNxCdJOJxwwglGIkFIMkEmPgRQf5QUg9asWaNnDXfXoZSOa5Ljuf3221XXrl3VtGnTjMmeq+rcO3fuVKNHj9b7NmzYUPfknDNnjurRo0elvBb1hc+RMdYAAAAAAAAAYKlqrYkJAAAAAAAAAGVFEhMAAAAAAACA1UhiAgAAAAAAALAaSUwAAAAAAAAAViOJCQAAAAAAAMBqJDEBAAAAAAAAWI0kJgAAAAAAAACr1VgSMycnR9199936pw1sux4ANaM2xYLadK0A6u7fvK3XBaBuxwBiDwCb4wQxqmr4HMdxVA3Ys2ePSk9PV7t371ZpaWk1cQlWXw+AmlGbYkFtulYAdfdv3tbrAlC3YwCxB4DNcYIYVTUYTg4AAAAAAADAaiQxAQAAAAAAAFgtrqYvQLrY2iByHZV1PfHx8SoxMbFSjgWg/samqohbxCegdrMtPlVWG4rYBNRu1R2bKvvzW3GIT0DtVhNtp+qIUfH1MO9UYzUxpSZB44wmKqTyVV3UokULtWrVqnr3CwXUdr/FpsYqpEKqriI+AbUTbScANqrrsUnQdgJqp7oen1rUw7xTjfXE9Pl8+hfp+AZnq2BCsvLFxysVjFMqIV45waBSwYAKxweUIz+DfhWO96twwKd/hoI+FQ4q5cT59LITp1QoqFQ4IPcpvS0cp5Qj63rZ+e1nwFFKL4eVL85R/kBIBYJh5Q+EVXwwpBLi8lUwEFKJcXkqIRBSSXF5qkEgV9+S4/JUSiBbNfDnqeRAtkr171dJvlyV4s9WyX75matSfCGV7Per0N44dUCfdSo3N7de/TIBdcFvsSmkjk84UwXjk5QvIUEpiUnxv90kJjnxcSosPyOxKc6vwsHf4pH8/C02Sez5PVYFfotJkdik49Pvt3DQUU7AUY6OTY7yxUl8Civ/77dgXFglBPNV0P97bIrLVw3i8lVSXK5K9OeppECuSgnk6DglP5P8OSrFl6NSA5EYlaNS/fkqyadUsi9OhfcFVfvevxKfgFrIaDslpiifxKYEaTNJ2ylOxyYn3q+cOGlDSVz67aZjk8SjePkZi016WeKTblP9HqMCv7UOdWwKOioshYeCYR2jIrEpoG8h3XaKD4RUfFy+SghEYlOeSpC2UlyuSpaYJG0oiVH+XN12SvXnqAa+HJUmscqfqxr4wirVH1B5ewO0nYDaHpuk7RSJTdJuSohXKi4SmwIq/HtskvZTSNpO8e7Y9Ht80vHKbC+Zn+2c35d/i1E6Nslnu8Dv8Unikm4/SXz6PTYF83R8SgzkqSR/rm5Dyc/kuGyV5M/Tn+d++0z3exvKL+2pkErxKdWAthNQJ+JT/+RzVVzks118nFJxQeUk/B6fdDwK6J+hSPtJt5V+vxUSm3QccrWlZDnyeS6Sd1JB+flbvkliUyCSdwqEVFB/povEpnzVIJCjUgJ5KvH3dpP+jKdjU85vscm/X7ebkn0Ss8IqyRfQeacufdbWu8911MQEAAAAAAAAYLUa64kpY/el6+vsTe8otV/VOfLc5DkCqF1isek9pXKUUpmqziE+AbUTbScAtaLtVAfRdgJqd3z676apSu1TdU6Leph3qrGamCI7O1t3fa2L6mOBVaCuqMuxSRCfgNqrLscnYhNQe9Xl2CSIT0DtVZfjU3w9zDvVaBITAAAAAAAAAKwdTn6S/1xj/fJlK6PLTePMKejzpIqzy75wQnR5Q15DY9sRDVYZ67vCDaLLXYO7jW2tA0nG+n7HzM7nOeEirz/BZ750u8Oxx2Z50sJd224s8jgA7OKNTYEDOkeXfTlmjHCSY/FFZLVPjy4n/7TZ2JbToYmxHrcvL7r8yNTnjW2ZYXNIwK955mPdGgX2Gutp/mxj/cD42DVP2N7b2HZPr/eLPC4Au2PTund6Rpd7Nt9kbFu4rrWx7vPFllOSzBjRNs1sG63eFWtXndZhibGtSZwZb2QCMbcV2c2jy4t3m9dwYpOlxvreUGKR7bxxvaYZ6wBqV3wygk5l9pdxHffmFYuNTdtDKcb6wn3tizzM1txUY93vMz/zPdDys+jysf+7wtj289l3lfGiAdgSm+Jatyo8Tol8c/ZyJ+SKC+GQuW+cmQvSk1RH+L3H9TzWX/S0NE6DWJ5L/HRDY2O96yuxeh0PT3nO2HZou7WqvmBiHwAAAAAAAABWI4kJAAAAAAAAwGo1NpzcPXxcPH9Ap+jyxNVfGdtmZXU11vs2+CW6vDU/zdiWGTaLmmb4Y0Odsh2za2++Mrv2ZobNLsTp/li34ICnu7F7+Lh+rOvYST7KjAK1lXv4uAgti8Wb/BPN4dh+9zADKay8KxYX9h/QzNjmC5lxYX+L2FD0PMf8PinbCRrrQZ8Zq0IqFm9ae8pvbA0lm4/1xDkAtZN7+Lhoc/YP0eUu35mxaLHfNVxKKdW9+Zbo8ortRZenEG0zdkWXd+ebJTNOTl1cZCwSu0KxMj29M9YY215fdaSxfma7RdHlzglm+Q0AtYx3WKZ7CLnfLBdRgLt8l6/4/jU+1zDNTfkZxrYd+SnFDhkPuz6rrdlnliPzWtk09hE5e2/9mvUXqEuM4ePyWW79huhyoGlTc2fPkHFfUqxN4+w2P2+psPm5zsmNlQnzJZgxw/GUIysw3Nx9rATzM6A/JXZcry5x9bc/Yv195gAAAAAAAABqBZKYAAAAAAAAAOrmcPINGzaoL7/8Um3ZskWFw+YwpmuvvbbEx3tnIHcPIb+mfV9j2wVLY91+hV/Futy2DW4v9jxJvtgQ8YDrcSLTMyTcO2R8m2t7umcoRNAzhCrJNatdvHdIBYBqU9HY5J2B3D2EPO7z+ca2QI8DzMfuiM3yG+edjbNRbOZyER8fC79+TwmKpoF9xvqWkDkkyh3LvDOZB10x77f1WOxKDZizEgOoPfHJOwO5ewj5/MPM76S7/zc2fFz8tKl5kbOTe6XExWa+TPCb8eSXvGbFDt/skbA+uvzyruOMbU2TzZnNN+TEhoIe1KD+zKgJ1MW2U4EZyN2fm7yz+hZ7nFCpR553j99obNseMMvpZIbMEmNh12e3jGCWebmedtihrjZaWkNzXwC1KD558jLuIeShrVvNbWlmmULlPlfQkzbzlslwzWxuzGpeGq7h5T7PMPUCXE8nrMp4nvqexHz55ZfVFVdcoeLj41Xjxo2Vz/XLIcul+s8OACoZsQmArYhPAGxEbAJgK+ITKi2Jeeedd6q77rpL3XbbbcrvZ0Q6ADsQmwDYivgEwEbEJgC2Ij6hMOXKQGZlZanzzz+fBCYAqxCbANiK+ATARsQmALYiPqHSemKOGjVKTZ06Vd16662qvPIcs47ArKyuRdbAnNK9lbHe4Zdt0eVf82J1DUTn+M3Gepbjfopmbac8d2EVpVTLOLO207ZQrC5dwFMDM6ce1yAAbFUZsclJbmCs+111Tbw1MEM/LjPW41rHYpUvwaxVGQ6YMc9x1Vtq5Kk7tzvsqbPiEXLFo2wnaF6vqz6vPq/KK/RxAGpXfFq4rrWxvtjfqsgamPv7m22h3OfaRZcT083alF578mJ15NID+4utgemtwTsvq1N0uW/DFca2nLAZq1buj7Xf5md1NLadUewVArCt7VQTvJ8l81Sg2O3umpj7PfXEvfY7sfro+SFGHQK1Nj65alV6a/R6a2CG9phztsQluT4T5nmOEyihdqVxYG+t30Cp6ws74aI/u+V5cln1SbmSmOPHj1ennHKK+uijj1SvXr1UMGg2TB999NHKuj4AIDYBqPVoOwGwEbEJgK2IT6jUJOaMGTNUt27d9Lp3Yh8AqAnEJgC2Ij4BsBGxCYCtiE+otCTmI488ol566SU1cuTI8jwcAKoEsQmArYhPAGxEbAJgK+ITKi2JmZCQoPr27asqYl84wVjv2+CX6LJfOUXWwBTjOx8cXX5xzZfGtm0hc2h7gi9WgyDeUysu1W8+/RwnVjtOJPoCRdYcSPCZ9VG2ukodpPq9dQ8AVIfKiE1Z7dON9fhdsbpIvh27i6yBKfLXx+r5xnVsb2zzZ8Zq7IpwIKXIuOX3mTEw4ImJZRHnqrsSdMVDALUrPnkHunRvHquD+dOm5kXWwBQHXPFtdHn3B12MbVv3J5vHzYgdN9FvtouaB3cZ6/P3mbUs28TvjC6PyVhrbHtnr1l76pAGq6PLy3NaGNsA1K62UwHVUKvNW+c7z5gHwayBqfd3Yp/d8kqoPe7+3BcOUxMTqK3xyXHNbSB8SUmxlXC46BqY8rluU6y+eKB5M/M43kaZey6E4rbpgxUTUzyPdbK9sSr2WW5DyNy3sao/yhWVr7vuOjVx4sTKvxoAqABiEwBbEZ8A2IjYBMBWxCdUWk/Mb775Rn3++edq+vTpqmfPngUm9nn33XfLc1gAqBBiEwBbEZ8A2IjYBMBWxCdUWhIzIyNDnXXWWaoiNuQ1NNa35seGGbUNbje2/ZrX1Fh3DyEf1e44Y9v9q74x1jeHYkM2uwX3GNv8no6om0M5xnrLQKxLsd/VdbcwTQOxIVeh8o/8BFABlRGbkn+KDR0Q+w+IDR+Ic8w/bp9neIB7CHn+qthQSeE/qLv52LxQoWUvSjNkqrjh5QFlDo0IuEpf5DnFD58CYG98SknKNtZXbG9S5LbE9L3GunsIefqwFeaBP2tjrK7ZF2ufNYo3y2Ak+T3tpHhzeHlqYH90+bTlQ41tB6ZtMtabu9pkP2eZw+EB1K62UwHusltO1ZSySfTlG+tJPjM+JXi2h13DNNPiYrGqMCn+WNmzYNA8DoBaFJ/CZvxxdrvyQUFPKizP/Ft3DyEPbd5ibkszS+SonFj5MRVvdvBTOWZsUgHP57Gw63Nd4wxzW7Doz3xNA1VftqNOJTEnTZpU+VcCABVEbAJgK+ITABsRmwDYiviEwpS7UnF+fr769NNP1XPPPacyMzP1fRs2bFB795rf/gNAdSI2AbAV8QmAjYhNAGxFfEKl9MRcvXq1Gjp0qFqzZo3KyclRJ510kkpNTVUPPvigXn/22WfLc1gAqBBiEwBbEZ8A2IjYBMBWxCdUWhJTZonq06ePWrRokWrcODaZ+5lnnqlGjx5dqmMc0WCVsZ4ZTixy387xZo26baFgkTUwb+94pLH+sqt+ptdeJ1bH0lsDU28Px+oXJPnN2gbZjlkzYbtrivsWAbN+HYDqURmxKadDrM6c8LmL3DZKN7aFPTVN/Jn7iqyBGf5+qbEeOLBrdDnLMUOxt3Zl2DE7zcf7Y7Er17Ovt35mjhOrlZfkd9VrAVCr4lPbtN3lPvfW/clF1sBUA9cZq8GZraLLJ6V9X2yN8lSfWYvz4+09o8tXt/7M2PbOjj7Gen44FtcS/NScA2pz26kmeNtKeSpQfFvK1T7aG4rVvBQBn1l3Lsf1GTEUKvfARQA1HZ/i4oquP+n31KYMeOY+cNXR9dbADO0x51oJNDXbR+bGQPHXFHLV7XSdE5WcxPziiy/UnDlzVHy8OalFhw4d1Pr168tzSACoMGITAFsRnwDYiNgEwFbEJxSmXF8thcNhFXJnjH+3bt06PawcAGoCsQmArYhPAGxEbAJgK+ITKi2JOXjwYDVhwgSjq61M6DN27Fg1bNiw8hwSACqM2ATAVsQnADYiNgGwFfEJlTac/JFHHlFDhgxRPXr0UNnZ2erCCy9Uy5cvV02aNFFTpkwp1TF2hc36kxn+/dHlJJ9ZG8lbLy7BF+sFujmUUmwNzJHtjosuv+jZluipHRf0mfUK0vyxOp1hZdZICHge2zQQLvI4AKpHZcSmuH1mrdz9LWKxKj7ejEWOZz0ciMUjX16oyBqYIvTT8uhyqqvGpchzzMcGXTFPP9ZVIzMjLsvYtiuUZKwn+Mx6vgBqZ3xavauhsd42Y1d0OSUuVsNb7Mkz64x3z9gSXV6zr2GRNTBF6IQN0eXxn5hfTHdJ22asp8XF2m5icOMfosvxnri1bHczY71P4zXR5aNSVhrbANSutpO3jpvPH1t3Yh+RKlWqp853tmO2dxI9bSu3tDiznq/fUxMzxfUZMD6u4OhDALUjPvk85Q+dXFdcyC+hHneC67E5ucXWwAxt3Rrb1rxZ0ecU3nX39XrWgw3MfZ1A7DNgs4Cr3nk9U64kZps2bXRx1TfffFP/lF6Yo0aNUhdddJFq0MBMTgJAdSE2AbAV8QmAjYhNAGxFfEKlJTFnz56tjj32WJ20lFtEfn6+3nb88ceX57AAUCHEJgC2Ij4BsBGxCYCtiE8ojM9xHLP/fCkEAgG1ceNG1ayZ2VV2+/bt+r7CJv3x+nVdS2M923FNYe8Zup3rGjop4n2xcQlJJcxC776SUa6h5WLM8mXGeqLP7K67PLdFdPniNHPfPM/YiGzXy+gdTN66zcbiLxJApaiM2LRkTRtjPc8Vf7zDjRr5zWEI20LBQsteFFYWwz2E/Jr2fY1ta+461lj3nFa5Q2TrE9aaxw2aQ6SOaRQbpjl3Rydj27TjnvYcGICt8enOJWcY67vzYyNfEjyxKD2wv8hhlRtz041tJ6V9b6yPXxUbQh5/0mpjW3CW2Xbbl2cO03J7susbxvrbu3sb60NSl0SXZ2T2Mrbd0+v9Io8LwL620yeruhvrm/Izosvd483PQXmO+Ukp5BpAmegpKebd1z2E/MYOxxQ7pD3QpaO5PT7WRstql2bum2t+rktYGyvXkdW1kbFt9r9vNo8LwNr4dHLHG807XMPCnVDxtS58ybF2lrPf/HxVnNDmWAmfwoae+1xDwgtcRyOzjfbzHeak2Z2ei30IfO+NZ41taa3Mz4R1Wbkm9pG8p0zm4yW/TMnJ9XdsPoCaRWwCYCviEwAbEZsA2Ir4hAoPJz/rrLP0T0lgjhw5UiUkJES3SRZ88eLFepg5AFQnYhMAWxGfANiI2ATAVsQnVFoSMz09PZoRT01NNSbxiY+PV0cffbQaPXp0WQ4JABVGbAJgK+ITABsRmwDYiviESktiTpo0Sf/s0KGDuummmyo0dLx1IMlYz3dVr8wM5xZbfzLVH7tsv2dE/F7HrGuZ6Kqz4q2B+VTXA4z1v65caKxnBLKiy0k+s+5TljKvcXc4dv2N/OUapQ+gnCozNmWGzb/1bCdWQ6lpYJ+xbXfYrNXkrZlZXF2nPCdUZA3MdvfOMdZXPmjWfUrcGotrF7X+2tg2ea2579c7YzWhtmSZdVUA1J741CRur7F+curi6PIveWatqB35KcZ682CsvluSP8fY9mueWaupS9q26PJGTw3MvAGeGt+ftDdWd+9PjC638bQwl+xpVWRNzICr1jmA2td22h5KKTIGbQ+Yx83zzB6Q56oZnuTLKXZfd5vMWwNTeaZ58GV5ati56s4F95q1N33hottvcVkl1wQFYGl8yjf/fh1XTcwCvPU1E1yfCXPM2KQCZmxycvOKrIEZ2rrVfGhaWqmvwVdMWino887EUn+UK9t28803GzUxV69erSZMmKA+/vjjyrw2ACgTYhMAWxGfANiI2ATAVsQnVFoS8/TTT1evvPKKXt61a5c68sgj1SOPPKLvf+aZZ8pzSACoMGITAFsRnwDYiNgEwFbEJ1RaEnPBggWqX79+evntt99WLVq00L0xJbH5xBNPlOeQAFBhxCYAtiI+AbARsQmArYhPqHBNzIisrCw9sY+QIeQye5Tf79cT+0gyszT2O2Y9gsxwrDZJwFPjpGWcWWclx1X3cnPIrE/QMhCbbMhbKyDRl1dsDcz7Oh1qrI9b9W10Oc9TZyXoqdES9FEvBahplRGbfs1rUuTf9pZQ8TUlAyoWJ0Kuerwi7PiLPK63lKa3BmanW+Ya6/5De0SXd4w042OfxmuM9fX7M6LLaQme+lAAqk1F41NqYL+x7o4x3hqYQZ9Z723+vlht3Jbxu8zj+sy4kBYXO88KTzz01sCMP8m87oaftosuL8o122P9Gy031j/fG4tjO/PMOukAalfbaeE+MzZszY21lzJDsVq5hdUID7tiWYIndnn3TfS76s51icW1wmpg5q/fUOT1hjo1NtcbmOfJaRTbHrePz3hArY1P3rlK/J5augZPjcmAv8gamCrOk0Zz1cT0uR9XSA3M0J495vaM9CLr8/o8HxLdqwk+V43geqZcPTG7dOmipk2bptauXatmzJihBg8erO/fsmWLSiuuUCkAVCFiEwBbEZ8A2IjYBMBWxCdUWhLzrrvu0rNEyWxRRx11lDrmmGOi2fHDDjusPIcEgAojNgGwFfEJgI2ITQBsRXxCpQ0nP+ecc9Rxxx2nNm7cqA455JDo/QMHDlRnnnlmeQ4JABVGbAJgK+ITABsRmwDYiviESktiTpo0SZ1//vl6Qh83maW8tPKcsLGe7o+PLm8Lm/Uyt4X2GeuJrjqX3hqYe8Nmjcw0f6wOy/Jc83ozAllF1sAUd3Y8Irr8wfoFxrZ8ZdZHcVckCLnq4gGoPpURm7zcdefcNS+927y8+8a76jjpx7prZHpCRuJWX5E1MEV44Y/R5d0hMwYOT19krC9MiNWo+3JHlyKvF4Dd8WlFdnNjfVcoVkeyR8J6Y9u8rE7Gepv4nUXW1vx4e09jfXDjH6LLC3a0Nbbt3p9YZA1METcoVpP3kHXmeeZlmfWkDkmK1bL6NbepsQ1A7W47hR1foTUvC1t3t4fCvuL3NcR76sGFwqW/vgRzMGJ+ouc8ruvw5fO5Dqgz8cldc7LY+pjFPE6Eiq6V65QQi9w1MPWhdu2ObWtq1uv1Rh/Hdc0hTz6tXEOsa6lyPddbb71VNW/eXI0aNUrNmTOn8q8KAMqB2ATAVsQnADYiNgGwFfEJlZbEXL9+vZo8ebLatm2bGjBggOrevbt68MEH1aZNm8pzOACoFMQmALYiPgGwEbEJgK2ITyiMz3GcCvWR37x5s3rttdd0UnPp0qVq6NChuofmqaeeqvzeKe1dtq9vbawn+WNDArKdfGNbwDOUwD0UPcFnjogPeIYh+F152izHHKae5Iv3HNfsFuw+9rDWhxvbXl7zpflY1/LyPLOL8EkdlxrrAKpeeWPTRyvNodut4/ZElzPDZszIdjxDmYqR6wSKLGfx15VnGdsuav21sb4jP8VYdw8h/98h5jXs/sAcMr4nKzb8M39ZqrFtxa03lvr6AdRsfDrli2uM9d4ZsaHbP+81h5r3bbjCWB+TsTa6fNryoca2q1t/ZqzH+2JtoaYBs5xPG08RokW5ZjmLQ+JjQ8jPa/PbpI8Rh35nPjboOk+S32yf3XHQdHNnAFa3nUZ9O9JY/3Vvo+jywRlmuYv9nrZUXjjWPkqLM8tQ7A0lGOtpcdnR5W//2sfYFtxrfn4MeYaMu4eQJ/zHLCEWaNjQfEKNM6KLvmwzPn24ZoK5LwBr49PQ7read4RjeSSfd4i4Ny3myiu5h3F7txXgvRbP0HPveZ1AbP/Q8pXGtl9eNyfN7vR07LHvvvmssS2tVaytV9dVeOi8DCuXSX5khnL55VmyZIkaMWKE6ty5s5o1a1blXCUAEJsA1BG0nQDYiNgEwFbEJ1Q4iSmZ8Icfflj17NlTDynfs2ePmj59ulq1apXu9nveeefpZCYAVCdiEwBbEZ8A2IjYBMBWxCdUShJTuuy2bdtWvfzyy2r06NE6aTllyhQ1aNAgvT05OVn95S9/UWvX1p8urQBqHrEJgK2ITwBsRGwCYCviEwrjqW5UOs2aNVP//e9/9RDyojRt2lT3yiyKt5bl7nCs3kjQUwMzR5nTxyf4is69FldP011LU2Qps8ZJUJk16/JVqMgamCPbHWesP7s6tr1VILPI6wNQdSojNqX5Y/WWxNZQcnQ56DPji99nxhS3gCduhTxxbVcoKbqcGjTPOXmtef19Gsdq34nh6YuiyzM+MOtppg8za+H1nR+Ll7MTzXqZAGpPfDqxiVlf+/VVR8Yel7zX2JYTNmvlvrM3Lbp8YJo5CeM7O8y6cst2N4suD2i23Ni2ZE8rY71/I3P7vKxAkTUwF5plndTTq+dGl7e66vwCqH1tp+LaQ35f+adfCHge6z5WIDdcbJ25UAPP57rEWDssyVMDM7Rzp7Eel+6qIR5nHgdA7YlPP93Q2Fj3p7hnMjE5YfOzmpPt+tsPFh/Hgg1ixw3lm7kqb+rK54lrxppjNpY6X2Q2ppa9GGuz9Z58g7Ft+W2q3ihTT8y5c+fqIeMvvvhi9BfplVdeUR07dtS/YJdffrnKycnR9/t8PtW+ffuquWoAIDYBqAVoOwGwEbEJgK2IT6i0JOa9996rfvjhh+i6TOIjM0LJMPJbb71V/fvf/1bjx48vyyEBoMKITQBsRXwCYCNiEwBbEZ9QaUnMhQsXqoEDB0bX33jjDXXUUUepF154Qd14443qiSeeUG+99VZZDgkAFUZsAmAr4hMAGxGbANiK+IRKq4m5c+dOPbV9hNQnOPnkk6PrRxxxRKkn83HXwBSZjqtOSTF1VcTWWKlK1TRg1jXYHjJrGTQNxI6V7Zj1B3aHXQfS9e48665lb/UEdw1McWX7WI3MR3+N1XkCUPUqMzYdGO+tlRuLC0GfWRcp7IkMca66ugFPAZQcx6x7meCLRZhFjVYa277e2dFYX78/w1hfmNAuurwnK7HIGpji+96ueDrd2ASgFsWnvSHzb/3MdrHauBtyzBixcn9TY/2QBqujy82De4xt+WF/kTV4h6QuMbZ51z/f28M8T1LsPDvyY/WEvTUwxZ9d7abcT8zyQ//tYKwCsLzt9EDLz4z1lU1jHzEPjTc/bu53zHaWe86CFH+CsS3HMdtZKf5YHBy2tnOx15TTyKyFp3yuz4iNM4qugSlx8VdXLfIjexV7HgD2xqeur/xW6rBQZtqoEGZuqDhOwNWW8uScCpzWs9nx+4qs7euugSkOGDUvujxx9VeeI9+o6osy9cSUX6RI0dTc3Fy1YMECdfTRR0e3Z2ZmqmDQLCYPAFWN2ATAVsQnADYiNgGwFfEJlZbEHDZsmK59+cUXX6jbbrtNJSUlqX79+kW3L168WHXuXPy3YgBQ2YhNAGxFfAJgI2ITAFsRn1Bpw8nHjRunzjrrLNW/f3+VkpKiJk+erOLj46PbX3rpJTV48OBSHSvL0402ydWvNt7d3b8Qqf5Y196Q5zgtAuZj3cM/85x8Y1sjf/E53JBrwvsfc9OMba0Cmca6ewj5jR1+m7k94pPiR8cDqKDKjE0TtvcucltqwBwSHvKMQ3CXpMhzzKHnSX5z+JTb3B2djPUtWeawprQE87xf7ugSXc5fZu47OzG2zTuEvNEpy8xtxCag1sQnb0zpnLA5unxQA3NI1fwssyTF8pwW0eWfs2LDs0SC32wbHZUSK28xI9McRhnwlPvZmZdkrP+a27TImLc11MBYdw8hjz8pNgxdIzYBtartdOz/rjDWs/fGjpPWMMvYlh8yP3+FXSUtgkEzHoU8+8bHxdpZ6V3N9k9cljn0M26fue7Lj32u82V72mRxZnw1hpB/Y5bRAFB74tPDU54z1rvExWJK2NPYcJe2EBtcZQrdJQoL0ywQK6GzN2x+bvOWI3OXFBMh13m95TZ6T77BWHcPIb+mfd96m3MqUxKzSZMmavbs2Wr37t36lykQMN+QqVOn6vsBoDoRmwDYivgEwEbEJgC2Ij6h0pKYEenp6YXe36hRo/IcDgAqBbEJgK2ITwBsRGwCYCviEypcExMAAAAAAAAAqpvPcUqYAx4AAAAAAAAAahA9MQEAAAAAAABYjSQmAAAAAAAAAKuRxAQAAAAAAABgNZKYAAAAAAAAAKxGEhMAAAAAAACA1UhiAgAAAAAAALCaVUnMrVu3qquuukq1a9dOJSQkqBYtWqghQ4aor776qsLHHjlypDrjjDMq5ToB1C/EJgC2Ij4BsBGxCYCNiE21X5yyyNlnn61yc3PV5MmTVadOndTmzZvVZ599prZv317TlwagHiM2AbAV8QmAjYhNAGxEbKoDHEvs3LnTkcuZNWtWodsvueQSZ/jw4cZ9ubm5TtOmTZ1//OMfen3q1KnOQQcd5CQmJjqNGjVyBg4c6Ozdu9cZO3asPrb7NnPmTP2YNWvWOOeee66Tnp7uNGzY0DnttNOcVatWRc8xYsQI5/TTT3fuu+8+p1mzZnq/e+65x8nLy3Nuuukm/ZjWrVs7L730UpW+PgBqBrEJgK2ITwBsRGwCYCNiU91gTRJTkoIpKSnO9ddf72RnZxfY/tVXXzmBQMDZsGFD9L53333XSU5OdjIzM/X9cXFxzqOPPqqTkIsXL3aeeuopvU1u5513njN06FBn48aN+paTk6OToAceeKBz6aWX6v1//PFH58ILL3S6deumt0eSmKmpqc6YMWOcpUuXOi+++KJOgg4ZMkQnNpctW+aMGzfOCQaDztq1a6v1NQNQ9YhNAGxFfAJgI2ITABsRm+oGa5KY4u2339Y9G6Un5bHHHuvcdtttzqJFi6Lbe/To4Tz44IPR9VNPPdUZOXKkXp4/f75OLv7666+FHjvSo9Lt1Vdf1QnLcDgcvU+Slw0aNHBmzJgRfVz79u2dUCgU3Uce069fv+h6fn6+TqZOmTKlUl4HAHYhNgGwFfEJgI2ITQBsRGyq/fy21SfYsGGD+te//qWGDh2qZs2apQ4//HD18ssv6+2XXXaZmjRpkl6WepkffvihuvTSS/X6IYccogYOHKh69eqlzj33XPXCCy+onTt3Fnu+RYsWqRUrVqjU1FSVkpKib40aNVLZ2dnql19+ie7Xs2dP5ffHXqrmzZvr80QEAgHVuHFjtWXLlkp/TQDUPGITAFsRnwDYiNgEwEbEptrPqiSmSExMVCeddJK688471Zw5c/Ss4mPHjtXb/vSnP6mVK1equXPnqtdee0117NhR9evXL5pI/OSTT3Ris0ePHmrixImqW7duatWqVUWea+/evap3795q4cKFxm3ZsmXqwgsvjO4XDAaNx/l8vkLvC4fDlfxqALAFsQmArYhPAGxEbAJgI2JT7WZdEtNLEpL79u3Ty9Lb8YwzztC9MaV35iWXXFIgkdi3b191zz33qO+++07Fx8er9957T2+T5VAoZOwvvTyXL1+umjVrprp06WLc0tPTq/FZAqhtiE0AbEV8AmAjYhMAGxGbahdrkpjbt29XJ554ou5huXjxYt2DcurUqeqhhx5Sp59+enQ/GVI+efJk9dNPP6kRI0ZE7//666/V/fffr+bNm6fWrFmj3n33XbV161Z14IEH6u0dOnTQx/3555/Vtm3bVF5enrroootUkyZN9PG/+OILfU4Zwn7ttdeqdevW1cjrAMAuxCYAtiI+AbARsQmAjYhNdUOcsoTUozzqqKPUY489putRSpKxbdu2avTo0er222+P7jdo0CDVsmVLXaeyVatW0fvT0tLU7Nmz1YQJE9SePXtU+/bt1SOPPKJOPvlkvV2OIwnKPn366GHkM2fOVAMGDNCPueWWW9RZZ52lMjMzVevWrXVtTTkeABCbANiK+ATARsQmADYiNtUNPpndR9UikoCURKMMKZfEIwDYgNgEwFbEJwA2IjYBsBGxyW7W9MQsiUyaI8PApXdlRkaGOu2002r6kgCA2ATAWrSdANiI2ATARsSm2qHWJDGlzqXMRt6mTRs9qU9cXK25dAB1GLEJgK2ITwBsRGwCYCNiU+1Q64aTAwAAAAAAAKhfrJmdHAAAAAAAAAAKQxITAAAAAAAAgNVIYgIAAAAAAACwGklMAAAAAAAAAFYjiQkAAAAAAADAaiQxAQAAAAAAAFiNJCYAAAAAAAAAq5HEBAAAAAAAAGA1kpgAAAAAAAAAlM3+H8iOv1YfbDQzAAAAAElFTkSuQmCC", + "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, 47.98it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 74.16it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 42.14it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 202.52it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 418.82it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 132.72it/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.963\n", + "SubspaceDMDc Control: 0.746\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, 39.69it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 134.52it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 619.13it/s]\n", + "100%|██████████| 16/16 [00:00<00:00, 197.54it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Silhouette Scores:\n", + "DMDc Full (state): 0.037\n", + "SubspaceDMDc Full (state): 0.293\n", + "DMDc Full (control): 0.051\n", + "SubspaceDMDc Full (control): 0.251\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfEAAAEICAYAAABPr82sAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANe1JREFUeJzt3Qd8FHXaB/Bnd9MgCSGUAKEZikBAEKQJIiVUqQcCHqgBlbtXQYN3KIJKBE4pYjmRQ16UIlJ8RQLiCYhICL0kdJAmSieAgbRL25338/x193Y3O7Mlu5ud3d/38xnCzszOzLb/M/+ukSRJIgAAAFAdbXlfAAAAALgGQRwAAEClEMQBAABUCkEcAABApRDEAQAAVApBHAAAQKUQxAEAAFQKQRwAAEClEMQBAABUCkHcDo1GY7FotVoKDQ2lypUrU4MGDah79+708ssv0759+xSPM2bMmFLHiomJocLCQpv7X79+nUJCQko956233rLYjx9b7xMUFEQVK1akmjVrUqtWrWjEiBG0cOFCys7Odvb7AeAzcnNzad68efToo49StWrVKDg4mKKioui+++6j9u3b09ixY+n999+nS5cuue2cqampFr8t/h2De3Xr1q1UGsafbWRkJNWtW5c6duxIzz77LK1bt45KSkpkj7Ns2bJSx+ElIyND9jkPPPBAqf35epS+A7zodDoKCwsT38OmTZtS//79aebMmfTLL7+Q1/GwqyCP3yJHl44dO0rnzp2zeZzExESbz1myZInN/d944w2b+ycnJ1vsx48dvb7w8HBpzpw5ksFgwEcOqnL27Fmpfv36Dn3PV6xY4bbzbt++3eLY/DsG9+ratavDaVidOnWkTZs22TzO0qVLbT7n6aeftrn/Dz/8YHN/vh6l74DSotVqxflycnK89jVBTtxJ/fr1o6FDh1JCQgJVr17dYhvnxtu0aWM3V25u/vz5pdZx7nzRokXkivr169OwYcNowIAB9OCDD4o7RqO8vDyaPHky/fnPf+abN5eOD+Bt/F194okn6NdffzWt4xwQ/wYHDx5MjzzyCFWpUgUfjJ9o27atSMP69OlDDRs2tNh25coVeuyxx2jBggUOH+/LL7+kzMzMUuv/+c9/unR9XMrJ1zdkyBDq3LmzeGxkMBjo888/FyVDd+7cIa/w2u2CSlnfaV28eNG0jXO0KSkpUs2aNS32iYmJkW7fvu1QTpyXtLQ0i305dy63r72cuHVO4dq1a9KYMWNKHWfmzJkeeb8A3C0jI8Piuzt48GCpuLi41H6HDx+WpkyZIptTcwVy4t7PiXOO2vpz7dChQ6kcb2pqqkM5cV5mzJhhse/58+fFMVzJiXOJkLn8/Hxp7ty5UnBwsMV+CQkJkjcgJ14GXDfCd2Pbt2+n8PBw03q+63v33XcVn1u7dm3T/z/66CPZO0Tz/VxRq1YtWrp0KT3zzDMW6+fMmUO3b98utT/n1rn+nEscYmNjRf1/pUqVqFGjRjRq1Cj6/vvvy3Q9AM46e/asxeOuXbuKdh/WuOTpnXfeob59+zpVp8116ub72MO/kddff50aN24s6kW57UliYiJdvHjR5v5btmwR7VK4DQ3n2ritCz+nZcuW9NRTT4nfe05Ojml/rle1rqMtKCgQr6158+ZUoUIFqlq1qsgNHj161GZJHv++ucSNz8G/Y75OXvj/vXv3Fr/xoqIixdfobDrA9dWrVq2iQYMGUZ06dcT5uF6b651feeUVkYt2BX+unMa2aNHCIsfLpYpKzNPOTz75hIqLiy1KQPkY1vu5gj8Pfn2fffaZxfpt27bR5s2bS+3PecNvvvlGlC5xSUNERIQ4Rr169cT7ze+7U7xyq+CnOXFzSUlJFvvVrVtXMSf+1ltvSTqdTvyf/166dKnUXV/lypWlSZMmlSknbnTz5k0pJCTEYt9PP/3UYp8DBw7YrXdEnSB427p16yy+g9WrV5fmz58v2/7E2Zy09Xde6fmPPfaY1Lx5c5u/jejoaCk9Pd3i+e+++65DdanHjx83PYfTGPNtDz74oNS2bVubzwsNDS1V8nDr1i2Hztm6dWvp7t27pd4PV9IBLvFr37694nMiIyOlDRs2OJ0TN+JST+tjXrhwQTYnznXT999/v+nxypUrxX737t0T12Jc//bbb5cpJ26OPyvzfZ988kmL7ZmZmXbbACgd3xbkxN2E62nMXb58WbGVLNddcy6e6fV6Ux2PeS78ueees8jhlwW3hH/ooYcs1u3evdvi7p/roMzrHTm307p1axo4cKCo6+eW+QDexq2TzXPet27dohdffFHkhKOjo0XdOPfSOH78uMev5bvvvqOTJ0+KXh89evQQuSijrKwsGj58uKnHCef8pk+fbtrOOfAuXbqInCq/Js6tOuLIkSN06NAhuv/++6lXr14W9f98Ls4Z26rz5dx6u3btRM6b2w5wCQbnpo0OHz5MycnJFs9xJR3g18np34EDB0zr+LXxOq4zNu7PpQ0jR460WXrgCH4d5m182K5du2T351IM/p5Yl3hyyaSx5IPr3zt16kTuwjlpuTSW03l+T3bs2GGxD3+uvJ6/G5wjd5pTIT8AOZoTP336dKl9+Y5WLifOd41cF258XLVqVenkyZOmehrOnf/yyy+lctqu5sTZyJEjS+UqjPiu1XxbkyZNxPWYu3z5svTNN9+U4d0EcM20adMcyl0OHDhQ5HY8lRPn5eOPPzZt//nnn6VatWpZbF++fLnYdvXqVYv1n3/+ealz82/8f//3f6Xr16/L5sR5eeWVVyxy2i1atLDYPn36dNP2wsJC6dixYzZ7oWRnZ0txcXGm53F7HnOupANcomf+nBdeeEHS6/Wm7bt375Y0Go1p+4ABA1zKibMaNWpY7Dt37lzZnDh/1txKPCoqyrRu7969UsOGDS16Mlh/xmXJiS9cuNBi34oVK8q2dapQoYK0ceNGi+fz9dr6nihB1spNjPUr5uzVr/GdF9/hMm7JyHfoxuPwnTPn1j15jcbr4/UbNmyw2Mat4+Pj4y3W8d01340DeBvnaJcsWWL3N7Fx40bx2/FU7wuuE37hhRdMj+Pi4mj8+PEW+2zdutXUgt68JO3jjz8WdbM//PCDyOnyNfLrGTdunKgjl8P1yubjQ/BxX3vtNZvnNOb4uf/8lClTqEOHDmJ/45gTnBM3r7u/ceMG3b17t0zpQEpKisX2c+fOiTYAjz/+uFi47z6f3/xa5cbHcDUNk8MlJebtgZ588km6cOGC+D+/53yd7qR0fdzP3RzX6XMvIuvr5XYSzijdOgRcYl78ZFSjRg27z0tKSjI1tjF+uYzrPX2NxuvjG4h79+5ZFJ+5s4gJwB14MBf+rezfv18USe7du5d27txJv/32m8V+vJ4XT3yHjYODmDNvcGX+O+PA9eabb5oCLhc3mxc5c0DlgWv+8pe/KN4c842DeTcmpXMyfk+4WJcbpzmCf/s8eJWr6YB1gz7zGwpbOIBfu3ZN3AA5O9iP9Wddw4E0dsKECaKakgOseRr7/PPPW9xceDKNZT///LPFNq7ecAfkxN1YV2aORxrixR5uocj11datMfnH7U58x811YOa4vgpATTiAcn0y52LWr18v6se5pa953TQ7ffq0zefbGvHLVn2yu/B1civl0aNHi1y3+Q0Aj6D47bffihI46x4qZcHByTyA881Cz549RWt2Xjhnbq48xoxw9AbDupU/1ys7m4Y1aNCgVI6Xg/df//pXcrdNmzY5fX1lhSDuBqdOnRJFfea4sYkjuOuG9ZfppZdeInfj3IB5FwtO9DjxMDaAMW/wwgndnj173H4NAK7g3GF+fr7NbdxoinOx3ODLHA/byaxzWtYDcHCDsf/85z8OX8uJEydKreOGbuasi/y5AdwXX3whGo1x8Dpz5oxoXGV+48FFznI492h9jXLn5MZ15tu4iynnDjl3vHbtWrHIDYzjajpgnaPmwa74xkBpsS5JsIfft2nTplms46qCBg0aOPR865JNzjw5kot3Bg/7at240jwOWF+rdQM3VyGIlwF/Gbk+iMdPN09k+MvB/QaduXPm5/CPiIvOuH+nu/AY7NyHdfny5aWCuvGOnBNCY0A34hsL69wM5+a5zhHAmzhh5D60U6dOtRlEuReI9SiJ3J+acR9n69bMxmPw99m8ftsRXN/L9dpGHCCtRw/jXK8R9+3mInRjbpdbH3NrZP6Nm5fA8bXI4Rz7jBkzLG5EZs+ebfOc5jfqxiJxzigYcY7fut+9kavpgPVzeC4JW6Ub58+fF/3XzV+LI7gEkdNYziwZcSv1uXPnOnwMvpF6+OGHRRrLizurK/kGi6+Fq0WsPxPzMQuMvZGM+L3gkhjrY61cudK5C3CqGVwAsm4l2q9fP2no0KFSz549RX9V6+3cEnL//v2ljmOrdbojnG2dzi0nhw0bJlrpcj9QY19082XUqFGlWq5yf0vzVpy8BAUFSW3atBHHateunXiMfuLgbTt37rT4XlarVk20IB40aJD0yCOPlBopi7/35t/vRo0aWWznHiD16tWz+dtwpHU6L9wfmEfkMu9vzAu3/C4oKDA93/ib4t4nnTt3FtfMvUKsW7Tz8ZRapxtbivfu3Vscy3w9jydx48YN0/PNW5/zUrt2bdEiPD4+Xjw2bylu3ePGlXSAW8Nb953n/uudOnUSo+t1795dio2NtWg1rtQ6nfvEcxrGaa31Z2f8/P71r3+V+p4stdE63RHOtk7nFud8fUOGDBHfP35sfY38fty5c8fiODzKIH83rfflvuz9+/cX542IiHC6nziCuL03yIFuLcaFv7Tmgw+URxC3NwHKvHnzZCdA4e4XPEiN0jEQxMHbdu3a5fB3nIPzmTNnLJ7/9ddflwpcxoUTY/MAYy+I9+jRo1SQNC4c/A4ePGjxfOuAaGvhrkbbtm2TDeIcOLt162bzuTyA07fffltqUBS5IUU5qHbp0kU2iLuaDnC3M7kBaayXZ5991uUJUPi6vv/+e5vfk6VeCuJKC7/vPMx1bm6uzXPxzRYHfqVjOBvE0TrdBcapPrluiYv5uCEa17FwcY0v4GIxrgvk+i3uRsGDYnBxFHev4K4ncrjBEBdZcdE7NxY6duyYaA3Kx+Lifh44wtG6fgB34cZBPOAJD/XJLdN/+uknunr1qmitzN91HvCFi8+58RJ317Ju5MYTFv373/8WRdvGaSl5///5n/8RLd6daSXNjVW5Xvkf//iHqErj6+CW3TwQCXeDs673XLFihWgtzsX9PAAUF4Vz1RtfI5+Xh1Tl1tPWE32Y47SGX/sHH3wgJtfgOnIulufWzVxPbOymal5sy43p+Br5/eLGYFxNxy37uRiZB8dR4ko6wN3O+DXye8MTjqSnp4sidT43pzn8vvDzeCAZ8yJmOVxcztUA/NlylYjx8+Xug7aG3PU245TP3P2PqyX59fH7xlWXPIyvHH7/uC6cu/KtXr2aDh48SDdv3hQt53lCLX6d1tUTdq+FI7kbXhMAALgBN4Azv7HgYM1jwAPYgoZtAAAAKoUgDgAAoFII4gAAACqFOnEAAACVQk4cAABApRDEAQAAVApBHAAAQKUQxAEAAFQKQRwAAEClEMQBAABUCkEcAABApRDEAQAAVApBHAAAQKUQxAEAAFQKQRwAAEClEMQBAABUCkEcAABApRDEAQAAVApBHAAAQKUQxD0oNTWVNBoN3b1715OnAQBAmhOgEMSdNGbMGBoyZIhD+3bq1ImuX79OUVFRbj8+78c3CLwEBwdTjRo1qFevXrRkyRIyGAwW+x49epQGDRpEMTExFBYWRvfddx+NHDmSMjMzSx131qxZpNPp6N1333X4mgHAc5DmgBIEcQ8KCQmhmjVrikDrCX379hU3Cb/88gtt2rSJunfvTklJSTRgwAAqKSkR+9y6dYsSEhKoSpUqtGXLFjp9+jQtXbqUYmNjKS8vr9Qx+Sbg1VdfFX8BQF2Q5gQgCZySmJgoDR48WPy/oKBAevHFF6Xq1atLoaGhUufOnaUDBw6Y9t2+fbvEb3FWVpZ4vHTpUikqKkravHmz1LRpUyk8PFzq06ePdO3aNbE9OTlZ7G++8DHsXYe5bdu2iectXrxYPE5JSZGCgoKk4uJiu68tNTVVql27tlRUVCTFxsZKu3fvxrcDoJwhzQElyImXAedYv/76a1q+fDllZGRQo0aNqE+fPvTbb7/JPic/P5/mzZtHK1asoLS0NLp06RJNmjRJbOO/I0aMMOWweeEieWf06NGDWrVqRevWrROPuSSAc+UpKSl8w6b43M8++4z+/Oc/i+J5/suPAcB3IM0BawjiLuKi6IULF4q64379+lF8fDwtXryYKlSooBj8iouL6ZNPPqG2bdtSmzZtaMKECbRt2zaxLSIiQjw/NDRUBF9euHjMWU2bNhVF7Kxjx440depUGjVqFFWrVk1cK1/zzZs3LZ6TnZ1Na9eupSeffFI85r//93//R7m5uU6fHwDcD2kO2IIg7qILFy6IgNy5c2fTOs7Btm/fXtQ7y6lYsSI1bNjQ9LhWrVo2G5iVBee4zevh3377bbpx44a4eWjevLn4y4H++PHjpn1Wr14trotz8ezBBx+k+vXr05dffunWawMA1yDNAVsQxL2MA705Drb2irmdxTcRcXFxFuuqVq1Kw4cPF0X5vJ0btvH/jbj04OTJkxQUFGRaTp06hQZuACqHNMe/IYi7iHOtXNS9e/du0zrOmR88eFAUrbuKj6nX611+/o8//ihy2MOGDVM8B1+/sXU673/o0CHRr/3IkSOmhR/v3buXfvrpJ5evBwDcA2kO2BJkcy3YFR4eTs8//zy98sorovtWvXr1aO7cuaLh2rPPPuvyO8h9uLkr2JkzZ0TumfuYW99JGxUWFopicg76XMe9efNm0c+bu5g9/fTTYp9vv/2W1qxZQ0888QTdf//9Ite/ceNG+u6770RXM2MunKsBHn300VLnaNeundiOfuMA5QtpDtiCIO4kHkiFi5rZ7NmzxeOnnnqKcnJyRGM1DsDR0dHkqnHjxokcMB+LG5Vt376dunXrZnNfDtpcp87Xw+fk+uyPPvqIEhMTSav9vZCFSwW4Hv7vf/87Xb58WTSaa9y4MX366afiuouKiuiLL76gyZMn2zwH5+jfe+89euedd2RvJgDAc5DmgBIN9zNT3AMscPcv7kr28ccf450BAI9DmgNKUCfuoKysLFE0zbnknj17Ovo0AACXIM0BR6A43UHPPPOMaLTGxdKDBw929GkAAC5BmgOOQHE6AACASqE4HQAAQKUQxAEAAFTKL4P4ggULRH9rnju7Q4cOdODAgfK+JNXh7nM8mtzEiRNl9+FJVrgrXOXKlUUfVh6qlSd28ZXPlzte8Fjx/DrWr1/v8euCwIU0p3zNmjVLjGkRGRlJMTExNGTIEDHWhpJly5aJtMF84TRFbfwuiPNY33/7298oOTlZzCzGfad5ZjF3j0/uz7gB36JFi6hly5aK+/EgN6+//roY1e3YsWM0duxYsXBfeVfxD0uuX7yzn++HH37osbncAVz5ToJn7Nixg8aPH0/79u2jrVu3itEze/fubRqVUk6lSpVMM0by8uuvv6rvI5L8TPv27aXx48ebHuv1ejE39qxZs8r1utQiJydHaty4sbR161apa9euUlJSklPPb926tfTGG2+YHvOc63//+9/FZ1CxYkXx+cjNkW6cc53PW9bP9/Dhw2Ju9OvXr4v51XledQBPQJrjezIzM8XvfseOHYppTVRUlKR2fpUT59HH0tPTLfpx88hl/Jhzi2Af383279/f6b7wXHTNU6pyEZb58K081Sq/9zz0K+fWeRIWHrzi3LlzHvt8eehbnnqVizh5OlcAT0Ga45vu3btnKi1UwqNi8myNdevWFV2HeRIotfGrfuK3b98W44jXqFHDYj0/xiQe9nGg5eJALk535sdSu3ZtMY67Tqejf/3rX9SrVy+x7dKlS2J8dv7Ls6axSZMmieFieT0P5eqJz/fll1+mTp06oT8/eBzSHN8cpnbixIlimugWLVrI7tekSRMxSyNXG3I6xrM6crrBgbxOnTqkFn4VxMF1PK56UlKSqE9ypnEHNyThGc/4jpZz4lw32KBBA1GvzbOjcdDliVfMccDnyV0YB3jzWd9KSkpEfVZERIRp3dSpU8XiiG+++UbM5Hb48GGHXwMA+Fdp4okTJ2jXrl2K+z388MNiMeIA3qxZM9EeaObMmaQWfhXEq1WrJnKDPKOXOX6MYlVlXEzNDXHatGljWscBOC0tTYwTb8xpW+PibB5LnnHrdJ6rnFuKchDnwM7P4WNbP9cYpDmHzjcB5i3ev/76a1q5cqVpnbFIzJHPlwP4hQsXRIt564lcunTpIobNBXAXpDm+ZcKECWJ4bE63nM1N8wRPrVu3pvPnz5Oa+FWdOM+T/dBDD4kcoXnRCj82v+OC0hISEkTO2Xw+ce4+Nnr0aPF/WwHcFn6/OeAz/kHwjQDfHHCgN1+MQZdnYDNfz91DKlSoYLHOGMQd+Xxfe+01Ufdu/jrYBx98YJp6FcBdkOb4BkmSRABPSUkRN/JxcXFOH4PTKk4DeWZINfGrnDjj4lyeipMDEM+Rzd2MuJsBd30C5WJx6/oj7vvNxd7G9TxHOdd/c06b8V9+nxs2bCgCN89Rzv3EFy5cKLZzMTrfBPDzeDpTDuq3bt0SQZfrobgBnbs/X745sFXqwvO9u/LDBijrdxK8U4S+atUq2rBhg0jLbty4IdZHRUWJTIGt9GvGjBnUsWNHkVG4e/cuvfvuu6KL2XPPPaeqj8zvgvjIkSNFoJg2bZr4ILmIlxtSWTeGAudx/bVxnnLGCdULL7xAV65cET+Upk2birnJ+TMw4tzvP/7xDzFxzNWrV0XxI/9wBgwYgM8X/ALSnPK38I+Mg/UYE5z+jBkzxmb6xbPEjRs3TsSJ6OhoUcq3Z88eizY6aoAJUAAAAFTKr+rEAQAAAgmCOAAAgEohiAMAAKgUgjgAAIBKIYgDAACoFII4AACASiGIAwAAqJRfBnEePeytt94yDf8JvgefEfgTfJ99X6GfxgW/HOwlOztbDLfH08tVqlSpvC8HbMBnBP4E32ffl+2nccEvc+IAAACBAEEcAABApRDEAQAAVMrvZjFjoaGhFEfNaGjVcaQLCiFNcBCRTkeaIP6rFf//fdHyhNZEWi1JQfxYQ5JYryFJrNMSaTVkCNL88VdLkpZIEvv9sfBjsY3+u01LZND9vl4Sf43bzP5v/viPv2Rzm/T7Nv6r+WM/nUSklcQ2jfGxRiKtziAea7QG0uok0mok0ukMpNMaKIj/av74y481BgrW6SlIa6AQrfFviVgfquO/ego2+3+YtpiCNXoK/eNvmOaPv+JxCYWIdUVm2wwUxuvJQKEaiUI0GgrWaCiUdBSs0VFwkY6Sk5PFZwXgr2kOpzG/pzvyac7v/9cqpzmclgRpzNKY0mnO7+mOcR+ZNOePdfRHGmUzzRFpi3GbZDvN0f7+WKPldEdSTHN0WomCOK1RSHOCtJy2lCimOf9NW0rENltpTgjx/3lficICJM3x2yDeUNOcNBr+JoIvCg3VipaiAP4AaY7vC/XTNAfF6QAAACqFIA4AAKBSCOIAAAAq5ZeDvQAAAAQC5MQBAABUCkEcAABApVTfxayXdrj8Ro3G5eNqK1aU3WbIz3f5uJqgYNltUkkxqYroMCpDMig+dcvVw7LbtDXPleWqAMotzdF3b6P43MJo+d9/+KU82W0/T1LOb+mL5bvThoSVkCu0GZHKOyglr2WopI3skim7jfufyzHwQBoK8gtDZLcdHzSD1Ao5cQAAAJVCEAcAAFApBHEAAACVQhAHAABQKQRxAAAAlUIQBwAAUCnVdzFT7EbmqcHo7B3X1a5tqhs8z+BHrwXAMUrdyHTbMxSfq+vfTnZbSaR8FyiS9IrHNRTIJ+VFCskRTyUqJ1jhcuxSSgKVe59SWJB8l7gSg3y+s2KwchfdgiL57n1qhpw4AACASiGIAwAAqFS5BvG0tDQaOHAgxcbGkkajofXr15fn5QCAn0OaA/6mXIN4Xl4etWrVihYsWFCelwEAAQJpDvibcm3Y1q9fP7EAACDNAXAe6sQBAABUSlVdzAoLC8ViziDpSauRn8EHAMCtaY6hhLRaVSWd4MdU9U2cNWsWTZ8+3WJdHMVTQ01z715IGaY49dg5PdUvuzxeK4APpzl1mvWievG9ne4HzkL/fVB2W1GftrLbKlfKUTzubYWpSCtULJLdptfLF8ZqlLumk6RQjqstdu157E6e/DTQIQp9yG/8VknxuIYS/yx4VtWrmjJlCt27d89iidM0Le/LAgA/ZSvNqdOkR3lfFoA6c+KhoaFiMYeidADwapqjU1WyCX6uXL+Nubm5dP78edPjixcv0pEjR6hKlSpUr1698rw0APBDSHPA35RrED906BB1797d9Phvf/ub+JuYmEjLli0rxysDAH+ENAf8TbkG8W7dupGEiTIAAGkOgP83bAMAAID/Un0LDW1F+e4IZWHIy5M/Z3i46wfWKnTpCFHZVHkKr4UMduYbBFCp8Et5rk0naqcbWciWQ7LbMv+i3I1Wo5HvYlpUKJ/MBwXL9yOT7A2/odD71KAQWRQuVSgp0bn0OnU6O2mO5J/dZZETBwAAUCkEcQAAAJVCEAcAAFApBHEAAACVQhAHAABQKQRxAAAAlVJ9FzNDfr78RnsDySjM0KXUjUyp+5m942qC5LuRScVF/jOLGQbxAT/18ySFvI+kPPWX0mxkSt3I6gw7qXjcvMc7yG7Th2hcmlFs4purFc+pdzEPqLfT1Wtg+CXZbRFay3HszWUZCkhJjkEpjZxKaoWcOAAAgEohiAMAAKgUgjgAAIBKIYgDAACoFII4AABAoLVOv3btGu3atYsyMzPJYDXZxUsvveSOawMAQJoD4O4gvmzZMvrrX/9KISEhVLVqVdKYdUPi/yOIA4A7Ic0BcGMQf/PNN2natGk0ZcoU0ipNR1neXO3jXNbjutpHuizX66nXqnhOpc8eU5GC+/hSmqMvlp8q01CgnKTeLnZtmk2lfuAsfO1+2W13xj0suy0oX/6cZwpqkScYlOYwJaLi8F9lt10p+Y/stozCWMXjVg/Klt3WmNTLpV9Dfn4+PfHEE+X+YwKAwIA0B8A2l6Lws88+S1999RWV1axZs6hdu3YUGRlJMTExNGTIEDpz5kyZjwsA/gVpDoAbi9M5+A4YMIA2b95MDzzwAAUHWw4l+v777zt0nB07dtD48eNFIC8pKaGpU6dS79696dSpUxSuMOwpAAQWpDkAbg7iW7ZsoSZNmojH1g3bHMU3AdaNVzhHnp6eTo8++qgrlwYAfghpDoAbg/h7771HS5YsoTFjxpA73bt3T/ytUqWKW48LAOqGNAfAjUE8NDSUOnfuTO7Efc0nTpwojtuiRQub+xQWForF4nmSnrQa+RafAKB+vpTmSMUlpAlW/QSQ4Cdc+iYmJSXR/Pnz6aOPPnLbhXDd+IkTJ8QAMkpFatOnT7dY10DbghoGtSS3U2h5rzSdqD1K041qgkPIf+DGCtzHl9KcKsO7UbWR3W3uX2SnNrFCRfnff1FhkEvTidrrRlZ18V7ZbVlj5J/XrMJVxXMWS67dyOjsdD+N0cm3hyrWyk/1Gqy5pnjckPLohusFGklyvlPzn/70J/rxxx/FQC/Nmzcv1bBt3bp1Th1vwoQJtGHDBkpLS6O4uDjZ/WzdFQ+t9heP5MQ1YfLz1koFltfgjMAJ4so2/3pAdpu25jmvXgv4Pl9Kcx76bh5pZXLiSoG4LEG86sYKisctDte4PYhPmrqqXIL4E5FZCueUD+I39fJ9yO0F8Zq1lW8AfJlLn0LlypVp6NChZT453z+8+OKLlJKSQqmpqYo/JmORGi/mUJQO4P98Ks1BUTqoPYgvXbrUbcVZq1atEnfE3Ff8xo0bYn1UVBRVqKB85wkAgQNpDoBtLg+5xv26f/jhB1q0aBHl5OSYJkXJzc11+BgLFy4ULdK7detGtWrVMi1ffvmlq5cFAH4KaQ6Am3Liv/76K/Xt25cuXbok6ot69eolctJz5swRjz/55BOHjuNCdTwABCCkOQBuzIlzS9G2bdtSVlaWRbE3Nz7Ztm2bK4cEAECaA+CNnPjOnTtpz549YipSc/fddx9dvarcLcHdpJJihY2u5/Q1IcEutTD//ckal1qg2z2ur1HqsoFSFnAjX0pzlGi0ymmOXi+fbwoKlm95LdnJbinNRqbUAj16mXzL9eIpyuFBL8n//g0K+cNiO91P8w2upYM39cq9eypr5Y9bkwIsJ86DJOj1pb9wV65cEcXqAADuhDQHwI1BnCcp+fDDDy3GS+cGbcnJyfTYY4+5ckgAAKQ5AN4aO71Pnz4UHx9PBQUFNGrUKDp37hxVq1aNVq9e7cohAQCQ5gB4I4jXqVOHjh49KrqC8V/OhfN8v6NHj0b/bgBwO6Q5AG4M4jxUYadOnUTQ5sW8HydvwzSiAOBOSHMA3Fgn3r17d/rtt99KreeBW3gbAIA7Ic0BcGNOnAdp4cZs1u7cuUPh4fIz0PgcV2e18dPZcCjQXyv4LF9Kc7QZ8j1w7M1hpJHvRUaSQs+riW8qtzU6U1DLpdnIlLqRfd6kruI5tS2aKmyU3yQFK3cxW//+bdlt0aH5stvSb9RxuXvfaeWX6j9B3DgBAf+YxowZYzExAHc5O3bsmChmBwBwB6Q5AG4M4jwxifGumPuDm4/WxoMwdOzYkcaNG+fMIQEAkOYAeCOIG2cS4lGSJk2apK6icwBQHaQ5AB5o2Pbqq69a1E/x5AQ8+Mv333/vyuEAAJDmAHgriA8ePJg+//xz8f+7d+9S+/btxQAwvJ6nFwUAcCekOQBuDOIZGRnUpUsX8f+1a9dSzZo1RW6cA/tHH33kyiEBAJDmAHgjiOfn55smOuEidG5BqtVqRcM2DuYAAO6ENAfAjf3EGzVqROvXrxfzh2/ZsoVefvllsT4zM5MqVapEquHqdJn2nudPfauVXqs/vU7waT6V5pTha684pajCcfWu5beEYinIpelEFfuB88xyJ36Sf25L+edqC0oUj6vVGGS3BSls01BgcumbMW3aNNE6nVupd+jQgR5++GFTrrx169buvkYACHBIcwDcmBN//PHH6ZFHHqHr169Tq1atTOsTEhLEnTIAgDshzQFwY06c+27ywC+c6+a6cCNupd60qXIRjDluyd6yZUtRHMYL5+g3bdrkyiUBgB9DmgPgxiD+2muvUY0aNcT0o3v27KGyTC84e/ZsSk9Pp0OHDlGPHj1EV5KTJ0+6fEwA8D9IcwDcGMSvXr1Ky5cvp9u3b1O3bt1E7nvOnDl048YNp44zcOBAeuyxx6hx48Z0//3309tvv00RERG0b98+Vy4LAPwU0hwANwbxoKAgUfe9YcMGunz5shgvfeXKlVSvXj0aNGiQWG8wyLcitIUnUFmzZg3l5eWZGspZKywspOzsbIvFIClMCwQAfsGn0pwS5dbVAD7fsM0cF6tzI7ezZ8+K5fjx45SYmEjR0dGiHotz6kp4f/4BFRQUiFx4SkoKxcfH29x31qxZNH36dIt1cRRPDTXNy/oyAEAlyjvNqfpIb6r+aF+X+jlpi+W3GcqcGjvPoJSPs5PFU+pGZjj2k+td1xT64RkUusQZFLYxyc52tXK58+HNmzdp3rx51Lx5c/Gj4TvUb7/9li5evCiKvkaMGCF+WPY0adKEjhw5Qvv376fnn39ePOfUqVM2950yZQrdu3fPYonTON6QDgDUy1fSnKqdenrg1QG4RiPxvKJO4rpsHnCB67Gfe+45evrpp6lKlSoW+/AgDDwcq7NFXD179qSGDRvSokWLHNq/l26E+wdz4bsbhRnaDHl5yk9WGARFExQsu00qLiJVURrsxc57v+XaEdlt2prnynJV4Id8Kc1p9voHstsMocrP1Ra5lhN/Y/SXisc9X1BDdlujsJuy24olney2L0f0IFeVJSceuiBLdlvVUPm098D1eorH1evl86w/DU0mtXKpACcmJoZ27NghW4/EqlevLu6QncU/QK6HAgBAmgPgxiC+d+9eunPnDn322WemdTzpSXJysmgcMmTIEJo/fz6FhoaKqUrr16+veDwuqurXr59onJKTk0OrVq2i1NRUcccNAIA0B8CNdeIzZsyw6MPNDUS4rzgXR3E/zo0bN4qGII7i4i8uFuM6Kh7t7eDBgyKA9+rVy5nLAgA/hTQHwI05cW4MMnPmTNNj7p7BY6cvXrxYPK5bt67Ilb/11lsOHc88Rw8AgDQHwINBPCsrS3TvMOJ6cS4ON2rXrp3owwkA4A6qS3MMrs9iplFoC6o029jvp5XfrlO4qGKSb9gmBctvszcbmVLjNaXZz1iQtprCNvlxQUKClPvvF2uUX09AFKfzj8nYWK2oqIgyMjLEHOJGXK8dHCzf+hoAAGkOQDkFcR4ileu+d+7cKRqlVaxYkbp06WLafuzYMdFVAwDAHZDmALixOJ3rw4cOHUpdu3YVIx3x+OkhISGm7UuWLKHevXs7c0gAAKQ5AN4I4tWqVaO0tDQxahEHcZ3Oso7hq6++EusBANwBaQ6ABwZ74bnEbbEeQQkAwB2Q5gC4eex0AAAAKF8I4gAAACpVDpPfqWQCD088ryzsnbMMk70AgOMiu2TKbguz01f5Tl5F2W0lJfL9mAeGX1I8bnH4r7LbYnTykznlG+RnZFn//m3Fc2o1BpemE1XqB85yusif9/JT8vN1RD51XfG4VzNqyW8cRKqFnDgAAIBKIYgDAACoFII4AACASiGIAwAAqBSCOAAAgEohiAMAAKiU+ruYabSuzwuoRKv10DV5qOtaeXR7U+rWVh7XA+AFOq18ulJiUP7tK02XqVGYizRCG6p43Csl/5HdVqwwfaeS6NB8xe1Bil3MNC5NJ2qvG1nlFXtlt/V4NU/xuGuahZE/Qk4cAABApRDEAQAAVMpngvjs2bNJo9HQxIkTy/tSACAAIM0Bf+ATQfzgwYO0aNEiatmyZXlfCgAEAKQ54C/KPYjn5ubS6NGjafHixRQdHV3elwMAfg5pDviTcg/i48ePp/79+1PPnj3t7ltYWEjZ2dkWi0FyreUlAASmMqc5RcqTnAAETBezNWvWUEZGhijacsSsWbNo+vTpFuviKJ4aapu7f2Yvg0L3NLvHVerapvOfmciUupGp7bVAQHBHmhM7ujPVeeoRm/tXDC5WPN6N3yrJbtPp5NONLEOB4nEzCmNltwVrrsluu6kPkd2WfqOO4jmVOpEqdTFT6mZnbzYypW5kPz4gP1sbC32ysvzGgaRa5ZYTv3z5MiUlJdHKlSspLMyx/ntTpkyhe/fuWSxxmqYev1YAUD93pTmxIzt6/FoBfD4nnp6eTpmZmdSmTRvTOr1eT2lpafTxxx+LYiydzjLXGhoaKhZzWo1CzhYAwN1pToj6x8gC/1Fu38aEhAQ6fvy4xbqxY8dS06ZNafLkyaV+TAAASHMAfCSIR0ZGUosWLSzWhYeHU9WqVUutBwBAmgPgg63TAQAAwDU+VbmTmppa3pcAAAEEaQ6oHXLiAAAAKuVTOXFXbLl6uLwvAVzQJ/ZB2W1byzCDLICn5RfK960uKApWfK6hRCHfpNC3OsegPO5C9aBs2W0hCuM5VNYWyW7T613P40kKr6XYTo+iqxm1XJpONFSpHzgRRX2xT37j56RayIkDAACoFII4AACASiGIAwAAqBSCOAAAgEohiAMAAKgUgjgAAIBaSQGqoKBASk5OFn9xTvW/twC+DmmOf723vkLD/1AAys7OpqioKDG1YKVK8nP84pzqeG8BfB3SHP96b30FitMBAABUCkEcAABApRDEAQAAVCpgg3hoaCglJyeLvzin+t9bAF+HNMe/3ltfEbAN2wAAANQuYHPiAAAAaocgDgAAoFII4gAAACqFIA4AAKBSARfE09LSaODAgRQbG0sajYbWr1/v8XPOmjWL2rVrR5GRkRQTE0NDhgyhM2fOePScCxcupJYtW4rRi3h5+OGHadOmTeRNs2fPFu/xxIkTvXpeAF+CNMd7ZgdgmhNwQTwvL49atWpFCxYs8No5d+zYQePHj6d9+/bR1q1bqbi4mHr37i2uxVPq1KkjvtDp6el06NAh6tGjBw0ePJhOnjxJ3nDw4EFatGiRuJEACGRIc5DmeJQUwPjlp6SkeP28mZmZ4tw7duzw6nmjo6OlTz/91OPnycnJkRo3bixt3bpV6tq1q5SUlOTxcwKoAdIcz8gJ4DQn4HLivoAH6WdVqlTxyvn0ej2tWbNG5Ai4WN3TuNShf//+1LNnT4+fCwDsQ5rjv4LK+wICjcFgEPU1nTt3phYtWnj0XMePHxdBu6CggCIiIiglJYXi4+M9ek6+WcjIyBDF6QBQ/pDm+DcEcS/jXOqJEydo165dHj9XkyZN6MiRI+IufO3atZSYmCjq5z0VyC9fvkxJSUmi3j8sLMwj5wAA5yDN8W8BPewqt2Lk3Cm3FveGCRMm0IYNG0Rr1bi4OPI2Lt5u2LChaHDmCdzS/09/+hPpdDqLonx+n7VaLRUWFlpsAwg0SHPcaz3SHOTEvYHvk1588UVxw5CamlouAdxYrMaB1FMSEhJEEb65sWPHUtOmTWny5MkI4ABegjSnacCkOQFXnJ6bm0vnz583Pb548aIocuZGZvXq1fNYcdaqVatELpz7it+4cUOsj4qKogoVKnjknFOmTKF+/fqJ15STkyPOzzcQW7ZsIU/h12Zdzx8eHk5Vq1b1eP0/gK9CmoM0x6OkALN9+3bRzcN6SUxM9Ng5bZ2Pl6VLl3rsnM8884xUv359KSQkRKpevbqUkJAgff/995K3BVp3DwBrSHO8q2uApTkBXScOAACgZugnDgAAoFII4gAAACqFIA4AAKBSCOIAAAAqhSAOAACgUgjiAAAAKoUgDgAAoFII4gAAACqFIO5Gt27doueff14MdRoaGko1a9akPn360O7du8t87DFjxnhtohYAUAekORBwY6d70rBhw6ioqIiWL19ODRo0oJs3b9K2bdvozp075X1pAOCHkOZAwI2d7ilZWVliPPTU1FSb28eOHSv179/fYl1RUZEY1/zTTz8Vj7/66iupRYsWUlhYmFSlShUx3nlubq6UnJxcatx1Ho+ZXbp0SRo+fLgUFRUlRUdHS4MGDZIuXrxoOgePCT948GDp7bfflmJiYsR+06dPl4qLi6VJkyaJ59SuXVtasmSJR98fAHAvpDnAEMTdhINiRESENHHiRKmgoKDU9t27d0s6nU66du2aad26deuk8PBwKScnR6wPCgqS3n//fRGEjx07Ji1YsEBs42XEiBFS3759pevXr4ulsLBQ3AQ0a9ZMTHbC+586dUoaNWqU1KRJE7HdGMQjIyOl8ePHSz/99JP02WefiZuAPn36iMB+9uxZaebMmVJwcLB0+fJl/CoAVAJpDjAEcTdau3atyNlyTrpTp07SlClTpKNHj5q2x8fHS3PmzDE9HjhwoDRmzBjx//T0dBFcf/nlF5vHNuaoza1YsUIEbIPBYFrHwbtChQrSli1bTM/j2cz0er1pH35Oly5dTI9LSkrEzcTq1avd8j4AgHcgzQE0bHNz/dS1a9fom2++ob59+4r5u9u0aUPLli0T25977jlaunSp+D/Xl2/atImeeeYZ8bhVq1aUkJBADzzwAA0fPpwWL15MWVlZiuc7evSomBud5/GOiIgQC8+LXlBQQBcuXDDt17x5c9Jq//tR16hRQ5zHSKfTiTm/MzMzUcEEoCJIcwBB3M3CwsKoV69e9Oabb9KePXtEq/Lk5GSx7emnn6aff/6Z9u7dS1988QXFxcVRly5dTIF069atIrDHx8fT/PnzqUmTJnTx4kXZc+Xm5tJDDz1ER44csVjOnj1Lo0aNMu0XHBxs8TyNRmNzncFgcPO7AQCehjQnsCGIexgH5Ly8PPF/zu1yNzHOjXPufOzYsaUCaefOnWn69Ol0+PBhCgkJoZSUFLGN/6/X6y3251z+uXPnKCYmhho1amSxREVFefqlAYAPQpoTWBDE3YS7kfXo0UPksI8dOyZy0F999RXNnTuXBg8ebNqPi9S5C9rp06cpMTHRtH7//v30zjvv0KFDh+jSpUu0bt060Qe0WbNmYvt9990njnvmzBm6ffs2FRcX0+jRo6latWri+Dt37hTn5CL8l156ia5cueKulwYAPghpDjD0E3cTro/u0KEDffDBB6I+moNs3bp1ady4cTR16lTTfj179qRatWqJeurY2FjT+kqVKlFaWhp9+OGHlJ2dTfXr16f33nuP+vXrJ7bzcThAt23bVhSjb9++nbp16yaeM3nyZBo6dCjl5ORQ7dq1Rd06Hw8A/BfSHGAabtuHt8J7OABzoOUidQ68AABIc8BVyIl7CTca42Jwzl1XrlyZBg0a5K1TA0AAQpoTGBDEvYTrubk1ep06dUSjtqAgvPUAgDQHygbF6QAAACqF1ukAAAAqhSAOAACgUgjiAAAAKoUgDgAAoFII4gAAACqFIA4AAKBSCOIAAAAqhSAOAACgUgjiAAAApE7/D3oIHOb7NxDWAAAAAElFTkSuQmCC", + "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": 18, + "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 (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ring_attractors.ipynb b/examples/ring_attractors.ipynb index 45e927a..8b1ddf4 100644 --- a/examples/ring_attractors.ipynb +++ b/examples/ring_attractors.ipynb @@ -9,21 +9,28 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fatal: destination path 'netrep' already exists and is not an empty directory.\n", + "\u001b[2mUsing Python 3.10.19 environment at: /Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/.venv\u001b[0m\n", + "\u001b[2K\u001b[2mResolved \u001b[1m7 packages\u001b[0m \u001b[2min 623ms\u001b[0m\u001b[0m \u001b[0m\u001b[37m⠋\u001b[0m \u001b[2mResolving dependencies... \u001b[0m\n", + "\u001b[2K \u001b[36m\u001b[1mBuilding\u001b[0m\u001b[39m netrep\u001b[2m @ file:///Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/\u001b[0m\n", + "\u001b[2K\u001b[1A \u001b[32m\u001b[1mBuilt\u001b[0m\u001b[39m netrep\u001b[2m @ file:///Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/\u001b[0m\n", + "\u001b[2K\u001b[2mPrepared \u001b[1m1 package\u001b[0m \u001b[2min 187ms\u001b[0m\u001b[0m \n", + "\u001b[2K\u001b[2mInstalled \u001b[1m1 package\u001b[0m \u001b[2min 1ms\u001b[0m\u001b[0m file:///Users/mitchellostrow/Desk\u001b[0m\n", + " \u001b[32m+\u001b[39m \u001b[1mnetrep\u001b[0m\u001b[2m==0.0.2 (from file:///Users/mitchellostrow/Desktop/Projects/dsa_test/DSA/examples/netrep)\u001b[0m\n" + ] + } + ], "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\n", - "\n", - "# #install netrep\n", - "# ! git clone https://github.com/ahwillia/netrep\n", - "# ! cd netrep/\n", - "# ! pip install -e .\n", - "# ! cd .." + "# Clone and install netrep\n", + "!git clone https://github.com/ahwillia/netrep.git\n", + "!uv pip install -e netrep\n" ] }, { @@ -36,8 +43,6 @@ "import matplotlib.pyplot as plt\n", "import torch\n", "from DSA import DSA\n", - "import seaborn as sns\n", - "import pandas as pd \n", "from netrep.metrics import LinearMetric" ] }, @@ -494,31 +499,44 @@ "metadata": {}, "outputs": [], "source": [ - "def plot_results(ts,nruns,diffs_dmrsa,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", - " palette = None \n", - " errorbar = 'se'\n", - " hue = None\n", - " g = sns.lineplot(data=df, x=\"ts\", y=\"diffs_dmrsa\", 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", - "\n", + "def plot_results(ts,nruns,diffs_dsa,diffs_proc,parameter): \n", + " # Reshape data for plotting\n", + " diffs_dsa_flat = diffs_dsa.flatten()\n", + " diffs_proc_flat = diffs_proc.flatten()\n", + " ts_repeated = np.tile(ts, nruns)\n", + " \n", + " # Compute mean and standard error for each time point\n", + " diffs_dsa_mean = np.array([diffs_dsa[:, i].mean() for i in range(len(ts))])\n", + " diffs_dsa_se = np.array([diffs_dsa[:, i].std() / np.sqrt(nruns) for i in range(len(ts))])\n", + " \n", + " diffs_proc_mean = np.array([diffs_proc[:, i].mean() for i in range(len(ts))])\n", + " diffs_proc_se = np.array([diffs_proc[:, i].std() / np.sqrt(nruns) for i in range(len(ts))])\n", + " \n", + " # Plot DSA\n", + " plt.plot(ts, diffs_dsa_mean, c=\"blue\", marker='o', label=\"DSA\")\n", + " plt.fill_between(ts, diffs_dsa_mean - diffs_dsa_se, diffs_dsa_mean + diffs_dsa_se, \n", + " color=\"blue\", alpha=0.2)\n", + " \n", + " # Plot Procrustes\n", + " plt.plot(ts, diffs_proc_mean, c=\"orange\", marker='o', label=\"Procrustes\")\n", + " plt.fill_between(ts, diffs_proc_mean - diffs_proc_se, diffs_proc_mean + diffs_proc_se, \n", + " color=\"orange\", alpha=0.2)\n", + " \n", " plt.xlabel(parameter)\n", - " plt.ylabel(rf\"$D({parameter}={ts[0]},\\cdot)$\")\n" + " plt.ylabel(rf\"$D({parameter}={ts[0]},\\cdot)$\")\n", + " plt.legend()\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "cuda\n" + "cpu\n" ] } ], @@ -537,8 +555,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 +574,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "scrolled": true }, @@ -566,79 +584,37 @@ "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, 72.98it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 73.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 123.29it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 132.43it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 43.98it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "on run 1\n" ] }, @@ -646,7 +622,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_79963/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", " centers = np.sum(\n" ] }, @@ -654,529 +631,311 @@ "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, 59.80it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 45.35it/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", - "\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": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 133.92it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 122.02it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 121.85it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 2\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, 53.82it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 47.38it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 123.26it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 100.87it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 233.97it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 3\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, 41.10it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 65.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 126.42it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 117.30it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 140.00it/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_79963/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, 10.86it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 43.30it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 102.10it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 118.44it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 282.31it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 5\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, 36.12it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 38.00it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 100.94it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 103.39it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 312.87it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 6\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_79963/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, 46.91it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 38.93it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 100.67it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 101.61it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 282.33it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "on run 7\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, 41.24it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 50.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 113.74it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 98.86it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 227.80it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "on run 8\n" ] }, @@ -1184,87 +943,44 @@ "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" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 52.09it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 48.73it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 126.49it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 101.04it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 147.08it/s]" ] }, { "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 9\n" ] }, @@ -1272,92 +988,45 @@ "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" + "DSA\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 46.63it/s]\n", + "Fitting DMDs: 100%|██████████| 1/1 [00:00<00:00, 21.53it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 130.92it/s]\n", + "Caching compare objects Y: 100%|██████████| 1/1 [00:00<00:00, 112.87it/s]\n", + "Computing DMD similarities: 100%|██████████| 1/1 [00:00<00:00, 158.80it/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 +1037,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": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1399,7 +1073,7 @@ } ], "source": [ - "plot_results(ts,nruns,diffs_dmrsa,diffs_proc,parameter)" + "plot_results(ts,nruns,diffs_dsa,diffs_proc,parameter)" ] }, { @@ -1411,7 +1085,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -1434,7 +1108,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -1443,15 +1117,45 @@ "text": [ "on run 0\n", "0.0\n", + "[0.34813535 0.51610552 0.66213145 0.76551707 0.8384662 0.89794759\n", + " 0.93656195 0.96131608 0.97581514 0.98310719 0.98793454 0.99123529\n", + " 0.99268905 0.99382806 0.9948947 ]\n", "0.1\n", + "[0.54582073 0.76558439 0.87481118 0.94078347 0.96911968 0.98067321\n", + " 0.98936751 0.9924271 0.99426955 0.99589332 0.9967694 0.99739081\n", + " 0.99786609 0.99818268 0.99847013]\n", "0.2\n", + "[0.21830951 0.38287959 0.51502781 0.61739591 0.70785376 0.78032985\n", + " 0.83866465 0.88552491 0.92136682 0.94655041 0.96349438 0.97514645\n", + " 0.98190376 0.9858382 0.98927634]\n", "0.30000000000000004\n", + "[0.67282294 0.87458353 0.95275757 0.97585083 0.98853111 0.99323142\n", + " 0.99521829 0.99677828 0.99758222 0.99803759 0.99846682 0.99872347\n", + " 0.99897825 0.9992007 0.99934618]\n", "0.4\n", + "[0.36890001 0.53236022 0.6814589 0.78470399 0.85580787 0.91136665\n", + " 0.9461438 0.96700512 0.97920082 0.98491131 0.9898081 0.99209045\n", + " 0.99328691 0.99443158 0.99542766]\n", "0.5\n", + "[0.15959428 0.28908879 0.41094848 0.49578087 0.57750645 0.65379548\n", + " 0.71925711 0.77567115 0.8238677 0.8647262 0.89808503 0.92386401\n", + " 0.94375256 0.95847659 0.96958638]\n", "0.6000000000000001\n", + "[0.26300956 0.41647857 0.53726641 0.62719734 0.71537568 0.77416938\n", + " 0.83227965 0.87786799 0.912936 0.93812491 0.9575343 0.97066461\n", + " 0.97891474 0.98405959 0.98744505]\n", "0.7000000000000001\n", + "[0.45429789 0.5207928 0.5836935 0.63666869 0.68222928 0.72322328\n", + " 0.76024541 0.79099829 0.82038663 0.84525522 0.86677413 0.88663519\n", + " 0.90411281 0.91922178 0.9324377 ]\n", "0.8\n", + "[0.6645814 0.71164052 0.75469257 0.78664353 0.81688598 0.84232286\n", + " 0.86199444 0.87971805 0.8962877 0.91122159 0.9258577 0.93918892\n", + " 0.9506958 0.96057451 0.96898793]\n", "0.9\n", + "[0.69288973 0.73119948 0.7672158 0.79889557 0.82703214 0.84951018\n", + " 0.86916308 0.88746149 0.904444 0.92053566 0.93514135 0.94770815\n", + " 0.95866581 0.96777368 0.97521807]\n", "1.0\n" ] }, @@ -1459,7 +1163,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_79963/1197694459.py:120: RuntimeWarning: invalid value encountered in divide\n", " centers = np.sum(\n" ] }, @@ -1467,109 +1171,54 @@ "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.10351104 0.19950946 0.2815726 0.36148873 0.4332065 0.49886852\n", + " 0.55804923 0.61560174 0.66799287 0.7172119 0.76383889 0.80236109\n", + " 0.83913826 0.8672754 0.89480113]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting DMDs: 100%|██████████| 1/1 [00:01<00:00, 1.49s/it]\n", + "Fitting DMDs: 100%|██████████| 11/11 [00:00<00:00, 12.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pre-computing eigenvalues for Wasserstein distance...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Caching compare objects X: 100%|██████████| 1/1 [00:00<00:00, 1663.75it/s]\n", + "Caching compare objects Y: 100%|██████████| 11/11 [00:00<00:00, 5432.40it/s]\n", + "Computing DMD similarities: 100%|██████████| 11/11 [00:00<00:00, 1344.05it/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 +1234,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 +1253,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": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1631,7 +1283,7 @@ } ], "source": [ - "plot_results(alphas,nruns,diffs_dmrsa,diffs_proc,r\"$\\alpha$\")" + "plot_results(alphas,nruns,diffs_dsa,diffs_proc,r\"$\\alpha$\")\n" ] }, { @@ -1644,9 +1296,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "DSA (uv)", "language": "python", - "name": "python3" + "name": "dsa-uv" }, "language_info": { "codemirror_mode": { @@ -1658,7 +1310,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.19" } }, "nbformat": 4, diff --git a/examples/sweep_resdmd_tutorial.ipynb b/examples/sweep_resdmd_tutorial.ipynb new file mode 100644 index 0000000..e18f818 --- /dev/null +++ b/examples/sweep_resdmd_tutorial.ipynb @@ -0,0 +1,1132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fa008edd", + "metadata": {}, + "source": [ + "## Tutorial On Sweeping and ResDMD\n", + "This tutorial will demonstrate the basic interfaces of hyperparameter sweeping and residual dmd, which can be utilized on any dmd model, for a wide range of hyperparameters. These have been fully reimplemented due to the increasing generalization of the DSA package, so like other tutorials in this folder, the goal of this notebook is to demonstrate how the interfaces are designed to be intuitive across many different DSA / DMD instances. \n", + "\n", + "There are 2 high level settings: using a Pykoopman / Pydmd model, or a local model. Then, there can be models that take in control versus not. Finally, the default setting is to sweep ranks and delays (the rank of the principal components regression and the number of delays in the delay embedding, respectively.). But there are other hyperparameters that you can sweep as well. \n", + "\n", + "Let's start with the sweeper class!\n", + "\n", + "### Sweeper class\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c0c1d638", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "sys.path.append('../')\n", + "\n", + "np.random.seed(42)\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e8d66584", + "metadata": {}, + "outputs": [], + "source": [ + "# System dimensions\n", + "n_state = 15 # state dimension\n", + "n_control = 3 # control dimension\n", + "n_timesteps = 100 # 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.999\n", + "\n", + "# Sample random matrix for B\n", + "B_true = np.random.randn(n_state, n_control)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e1552288", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated data shape:\n", + " State data X: (5, 100, 1)\n", + " Control data U: (5, 100, 3)\n" + ] + } + ], + "source": [ + "def generate_trajectory(A, B, n_timesteps, n_trials, noise_std=0.01,use_control=False,partial_observ_frac=1.0):\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", + " use_control : bool \n", + " Whether or not the control input has any effect\n", + " partial_observ_frac : float\n", + " if < 1, does a partial observation legend on the states with % partial_observ_frac still observed\n", + " will bottom out at 1\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", + " drive = A @ X[trial, t] + np.random.randn(n_state) * noise_std\n", + " if use_control:\n", + " drive += B @ U[trial, t]\n", + " X[trial, t + 1] = drive\n", + " if partial_observ_frac < 1:\n", + " n_dims = max(1,int(X.shape[-1]*partial_observ_frac))\n", + " X = X[:,:,:n_dims]\n", + " return X, U\n", + "\n", + "# Generate training data\n", + "X_train, U_train = generate_trajectory(A_true, B_true, n_timesteps, n_trials,noise_std=0.0,partial_observ_frac=0.1)\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": "code", + "execution_count": 4, + "id": "a0b65b61", + "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, X_train.shape[-1])):\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": "code", + "execution_count": 6, + "id": "3a4db4a7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 0%| | 0/9 [00:00,\n", + " array([,\n", + " ,\n", + " ],\n", + " dtype=object))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from DSA.sweeps import PyKoopmanSweeper\n", + "import DSA.pykoopman as pk\n", + "from pydmd import SubspaceDMD,DMD\n", + "sweeper = PyKoopmanSweeper(\n", + " data=X_train[0],\n", + " control_data=None,\n", + " param1_name=\"observables.n_delays\",\n", + " param1_values=np.arange(1,10),\n", + " param2_name=\"reg.svd_rank\",\n", + " param2_values=np.arange(1,25),\n", + " reseed=1,\n", + " base_regressor_class=SubspaceDMD,\n", + " compute_residuals=False\n", + " # base_regressor_class=pk.regression.DMDc, # Must use DMDc or EDMDc\n", + ")\n", + "sweeper.sweep()\n", + "sweeper.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d83efaf6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 0%| | 0/7 [00:00,\n", + " array([,\n", + " ,\n", + " ,\n", + " ],\n", + " dtype=object))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from DSA.sweeps import PyKoopmanSweeper\n", + "from pydmd import SubspaceDMD,DMD\n", + "#we can also sweep other parameters here! here we sweep the dimension of random fourier features\n", + "sweeper = PyKoopmanSweeper(\n", + " data=X_train[0],\n", + " control_data=None,\n", + " param1_name=\"observables.D\",\n", + " param1_values=np.arange(3,10),\n", + " param2_name=\"reg.svd_rank\",\n", + " param2_values=np.arange(1,15),\n", + " reseed=1,\n", + " base_regressor_class=SubspaceDMD,\n", + " base_observable_class = pk.observables.RandomFourierFeatures,\n", + " base_observable_kwargs = {'gamma':0.1,'include_state':False},\n", + " extra_observables = pk.observables.TimeDelay(n_delays=5),\n", + " compute_residuals=True\n", + " # base_regressor_class=pk.regression.DMDc, # Must use DMDc or EDMDc\n", + ")\n", + "sweeper.sweep()\n", + "sweeper.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2920979a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 0%| | 0/7 [00:00,\n", + " array([,\n", + " ,\n", + " ,\n", + " ],\n", + " dtype=object))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sweep TimeDelay n_delays AND RandomFourierFeatures D\n", + "sweeper = PyKoopmanSweeper(\n", + " data=X_train[0],\n", + " control_data=None,\n", + " param1_name=\"obs.n_delays\", # Sweep TimeDelay.n_delays\n", + " param1_values=np.arange(3, 10),\n", + " param2_name=\"extra_obs.0.gamma\", # Sweep RFF.D (first extra observable)\n", + " param2_values=[1,0.1],\n", + " base_observable_class=pk.observables.TimeDelay,\n", + " extra_observables=[pk.observables.RandomFourierFeatures], # Pass CLASS, not instance\n", + " extra_observable_kwargs=[{\"include_state\": False,'D':10}], # Optional default kwargs for RFF\n", + " base_regressor_class=SubspaceDMD,\n", + " base_regressor_kwargs={'svd_rank':10},\n", + " compute_residuals=True\n", + "\n", + ")\n", + "sweeper.sweep()\n", + "sweeper.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "57fb8535", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 100%|██████████| 9/9 [00:00<00:00, 107.62it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from DSA.sweeps import DefaultSweeper\n", + "# With control data\n", + "sweeper = DefaultSweeper(\n", + " data=X_train,\n", + " control_data=None, #NOte that we can still pass this in, even if it's none\n", + " param1_name=\"n_delays\",\n", + " param1_values=np.arange(1,10),\n", + " param2_name=\"rank\",\n", + " param2_values=np.arange(1,25),\n", + " compute_residuals=True #\n", + ")\n", + "sweeper.sweep()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9a225798", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sweeper.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "afc7a96a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated data shape:\n", + " State data X: (5, 100, 7)\n", + " Control data U: (5, 100, 3)\n" + ] + } + ], + "source": [ + "#now, let's generate data with input\n", + "# Generate training data\n", + "X_train_control, U_train_control = generate_trajectory(A_true, B_true, n_timesteps, n_trials,use_control=True,noise_std=0,partial_observ_frac=0.5)\n", + "\n", + "print(f\"Generated data shape:\")\n", + "print(f\" State data X: {X_train_control.shape}\")\n", + "print(f\" Control data U: {U_train_control.shape}\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fb5f1e37", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 0%| | 0/4 [00:00,\n", + " array([,\n", + " ,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from DSA.sweeps import DefaultSweeper\n", + "# Without control data\n", + "sweeper = DefaultSweeper(\n", + " data=X_train_control,\n", + " control_data=None,\n", + " param1_name=\"n_delays\",\n", + " param1_values=np.arange(1,5),\n", + " param2_name=\"rank\",\n", + " param2_values=np.arange(1,15),\n", + " model_class=\"DMD\",\n", + " compute_residuals=True\n", + ")\n", + "sweeper.sweep()\n", + "sweeper.plot()#not so clear, if we just use regular dmd now" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "094fe74c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sweeping: 100%|██████████| 9/9 [00:03<00:00, 2.87it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from DSA.sweeps import DefaultSweeper\n", + "# Without control data\n", + "sweeper = DefaultSweeper(\n", + " data=X_train_control,\n", + " control_data=U_train_control,\n", + " param1_name=\"n_delays\",\n", + " param1_values=np.arange(1,10),\n", + " param2_name=\"rank\",\n", + " param2_values=np.arange(1,25),\n", + " model_class=\"SubspaceDMDc\",\n", + " compute_residuals=False\n", + ")\n", + "sweeper.sweep()\n", + "sweeper.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2e72767d", + "metadata": {}, + "source": [ + "We've seen the flexibility of the sweeper algorithms to different settings of DSA. In the previous code, you might have seen a parameter called ```compute_residuals``` that added a 4th plot. This is our impementation of ResidualDMD (ResDMD, Colbrook et al., 2021,2022, and more) that develops a method for precise error control on \\textit{individual} dmd eigenvalues. This is an alternatve method of error that has been helpful for understanding which modes are worth keeping, and is more in line with Koopman Operator theory than the prediction error metrics. We've found that studying these residuals can afford more accurate comparisons\n", + "\n", + "\n", + "In this next section, we'll go over the interface of ResDMD for different methods, and demonstrate its efficacy on this above problem" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0cfe5a52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 100, 15) (15, 15)\n" + ] + }, + { + "data": { + "text/plain": [ + "1.1975627478369772e-16" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from DSA import DMD, DMDc, SubspaceDMDc\n", + "import DSA.pykoopman as pk\n", + "from pydmd import DMD as pyDMD\n", + "from pydmd import SubspaceDMD\n", + "\n", + "from DSA.pykoopman import Koopman\n", + "\n", + "from DSA.resdmd import ResidualComputer\n", + "\n", + "X_train, U_train = generate_trajectory(A_true, B_true, n_timesteps, 100,\n", + " noise_std=0.0,partial_observ_frac=1,use_control=False)\n", + "X_test, U_test = generate_trajectory(A_true, B_true, n_timesteps, 10,\n", + " noise_std=0.0,partial_observ_frac=1,use_control=False)\n", + "print(X_train.shape, A_true.shape)\n", + "\n", + "true_evals = np.linalg.eigvals(A_true)\n", + "\n", + "model = DMD(n_delays=1,rank=15)\n", + "model = Koopman(regressor=pyDMD(svd_rank=15),observables=pk.observables.TimeDelay(n_delays=2))\n", + "model.fit(X_train)\n", + "\n", + "rescomput = ResidualComputer(model,X_test)\n", + "residuals, normalized_res, num, denom = rescomput.compute();\n", + "\n", + "\n", + "\n", + "fig, ax = rescomput.plot()\n", + "ax.scatter(true_evals.real,true_evals.imag, c = 'r', marker='x')\n", + "rescomput.get_average_residual()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b7e7784b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 200, 1) (10, 200, 1) (15, 15)\n" + ] + }, + { + "data": { + "text/plain": [ + "3.489429412696055e-13" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "X_train, U_train = generate_trajectory(A_true, B_true, 200, 10,\n", + " noise_std=0.0,partial_observ_frac=.1,use_control=True)\n", + "X_test, U_test = generate_trajectory(A_true, B_true, 200, 10,\n", + " noise_std=0.0,partial_observ_frac=.1,use_control=True)\n", + "print(X_train.shape,X_test.shape, A_true.shape)\n", + "\n", + "true_evals = np.linalg.eigvals(A_true)\n", + "\n", + "U_zeros = np.zeros_like(U_train)\n", + "model = SubspaceDMDc(X_train,U_train, n_delays=20,rank=15)\n", + "# model = DMDc(X_train,U_train, n_delays=1,rank_input=15,rank_output=15)\n", + "# model = Koopman(regressor=pk.regression.DMDc(svd_rank=15),observables=pk.observables.Identity())\n", + "# model.fit(X_train, u = U_train) # use this for Koopman\n", + "model.fit(X_train,U_train) # use this for DMDc or SubspaceDMDc\n", + "\n", + "rescomput = ResidualComputer(model,X_test, U_test)\n", + "residuals, normalized_res, num, denqom = rescomput.compute()\n", + "\n", + "\n", + "fig, ax = rescomput.plot()\n", + "ax.scatter(true_evals.real,true_evals.imag, c = 'r', marker='x')\n", + "rescomput.get_average_residual()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72f8c75c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13f71085", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DSA (uv)", + "language": "python", + "name": "dsa-uv" + }, + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 6a7186b..7624d17 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,10 @@ +[build-system] +requires = ["setuptools>=61.0", "wheel"] +build-backend = "setuptools.build_meta" + [project] name = "dsa-metric" -version = "1.0.2" +version = "2.0.0" authors = [ { name="Mitchell Ostrow", email="ostrow@mit.edu" }, ] @@ -17,15 +21,30 @@ license-files = ["LICENSE*"] dependencies = [ "numpy>=1.24.0,<2", "torch>=1.3.0", - "kooplearn>=1.1.0", "pot", "omegaconf", + "pydmd", + "tqdm", + "optht", + "derivative", + "prettytable", + "scipy", + "scikit-learn", + "matplotlib", + "joblib", ] [project.optional-dependencies] dev = [ "pytest>=3.7" ] +umap = [ + "umap-learn" +] + +[tool.uv] +# PyTorch ships CPU-only wheels on PyPI for macOS, which is what we want. +# No special index needed — uv resolves from PyPI by default. [project.urls] Homepage = "https://github.com/mitchellostrow/DSA" diff --git a/setup.py b/setup.py index 0e1eff1..2b05d52 100644 --- a/setup.py +++ b/setup.py @@ -2,24 +2,28 @@ 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", + "tqdm", + "optht", #for havok in pykoopman + "derivative", #for pykoopman + "prettytable", + "scipy", + "scikit-learn", + "matplotlib", ], extras_require={ - 'dev': [ - 'pytest>=3.7' - ] + "dev": ["pytest>=3.7"], + "umap": ["umap-learn"], }, ) diff --git a/tests/dmd_test.py b/tests/dmd_test.py index 0c38a41..faae52a 100644 --- a/tests/dmd_test.py +++ b/tests/dmd_test.py @@ -3,99 +3,106 @@ 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 + assert np.linalg.norm(dmd.A_havok_dmd.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) - dmd.fit(send_to_cpu=True) - assert dmd.A_v.device.type == 'cpu' - assert dmd.H.device.type == 'cpu' +@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() + dmd.all_to_device() + 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..c7f4122 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, ) + + +@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 == (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/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"]) + diff --git a/tests/simdist_test.py b/tests/simdist_test.py index 9647c01..1371684 100644 --- a/tests/simdist_test.py +++ b/tests/simdist_test.py @@ -1,98 +1,76 @@ import pytest import numpy as np -from DSA.simdist import SimilarityTransformDist,pad_zeros +from DSA.simdist import SimilarityTransformDist 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): - 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() - 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) - #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': +@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_simdist_convergent(seed, n, score_method, dtype, device): + rng = np.random.default_rng(seed) + X = rng.random(size=(n, n)) + + 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 = 10000 + + # excessive but we just want to see that it converges + sim = SimilarityTransformDist( + lr=5e-3, iters=iters, score_method=score_method, device=device + ) + 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("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) diff --git a/tests/test_sweeps.py b/tests/test_sweeps.py new file mode 100644 index 0000000..cbe33c2 --- /dev/null +++ b/tests/test_sweeps.py @@ -0,0 +1,435 @@ +""" +Tests for sweeps module: LocalDMDSweeper, PyKoopmanSweeper, and convenience functions. +""" + +import pytest +import numpy as np +from DSA.sweeps import ( + LocalDMDSweeper, + PyKoopmanSweeper, + sweep_local_dmd, + sweep_pykoopman, + sweep_ranks_delays, + split_train_test, +) + + +# ============================================================================= +# Test Data Fixtures +# ============================================================================= + +@pytest.fixture +def data_2d(): + """2D data: (time, dim)""" + np.random.seed(42) + return np.random.randn(200, 5) + + +@pytest.fixture +def data_3d(): + """3D data: (trials, time, dim)""" + np.random.seed(42) + return np.random.randn(10, 100, 5) + + +@pytest.fixture +def data_list_2d(): + """List of 2D arrays""" + np.random.seed(42) + return [np.random.randn(100, 5) for _ in range(5)] + + +@pytest.fixture +def data_list_3d(): + """List of 3D arrays""" + np.random.seed(42) + return [np.random.randn(3, 80, 5) for _ in range(4)] + + +# ============================================================================= +# Test split_train_test +# ============================================================================= + +class TestSplitTrainTest: + + def test_split_2d(self, data_2d): + train, test, dim = split_train_test(data_2d, train_frac=0.8) + assert train.shape[0] == 160 + assert test.shape[0] == 40 + assert dim == 5 + + def test_split_3d(self, data_3d): + train, test, dim = split_train_test(data_3d, train_frac=0.8) + # For 3D with shape[0] > 1, splits along first dimension + assert dim == 5 + + def test_split_list(self, data_list_2d): + train, test, dim = split_train_test(data_list_2d, train_frac=0.8) + assert isinstance(train, list) + assert isinstance(test, list) + assert len(train) == 4 # 80% of 5 + assert len(test) == 1 + assert dim == 5 + + +# ============================================================================= +# Test LocalDMDSweeper +# ============================================================================= + +class TestLocalDMDSweeper: + + def test_sweeper_creation_2d(self, data_2d): + """Test sweeper can be created with 2D data.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2, 3], + param2_values=[5, 10], + ) + assert sweeper.param1_name == "n_delays" + assert sweeper.param2_name == "rank" + assert len(sweeper.param1_values) == 2 + assert len(sweeper.param2_values) == 2 + + def test_sweeper_creation_3d(self, data_3d): + """Test sweeper can be created with 3D data.""" + sweeper = LocalDMDSweeper( + data=data_3d, + param1_values=[2, 3], + param2_values=[5, 10], + ) + assert sweeper.dim == 5 + + def test_sweep_runs_2d(self, data_2d): + """Test sweep completes on 2D data.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2, 3], + param2_values=[5, 8], + train_frac=0.8, + ) + sweeper.sweep() + + assert sweeper._swept + assert sweeper.aics.shape == (2, 2) + assert sweeper.mases.shape == (2, 2) + assert sweeper.mses.shape == (2, 2) + assert sweeper.nnormals.shape == (2, 2) + + def test_sweep_runs_3d(self, data_3d): + """Test sweep completes on 3D data.""" + sweeper = LocalDMDSweeper( + data=data_3d, + param1_values=[2, 3], + param2_values=[5, 8], + ) + sweeper.sweep() + + assert sweeper._swept + assert sweeper.aics.shape == (2, 2) + + def test_sweep_with_residuals(self, data_2d): + """Test sweep with residual computation.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2], + param2_values=[5], + compute_residuals_flag=True, + ) + sweeper.sweep() + + assert sweeper.residuals is not None + assert sweeper.residuals.shape == (1, 1) + assert not np.isnan(sweeper.residuals[0, 0]) + + def test_invalid_rank_skipped(self, data_2d): + """Test that invalid rank combinations are skipped.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2], # n_delays=2, dim=5 -> max_rank=10 + param2_values=[5, 15], # 15 > 10, should be skipped + ) + sweeper.sweep() + + assert not np.isnan(sweeper.aics[0, 0]) # rank=5 valid + assert np.isnan(sweeper.aics[0, 1]) # rank=15 invalid + + def test_get_results(self, data_2d): + """Test get_results returns correct structure.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2, 3], + param2_values=[5, 8], + ) + sweeper.sweep() + + results = sweeper.get_results() + assert "param1_name" in results + assert "param1_values" in results + assert "aics" in results + assert "mases" in results + assert "mses" in results + assert "nnormals" in results + assert results["param1_name"] == "n_delays" + assert results["param2_name"] == "rank" + + def test_fitted_models_stored(self, data_2d): + """Test that fitted models are stored.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2], + param2_values=[5], + ) + sweeper.sweep() + + model = sweeper.fitted_models[0][0] + assert model is not None + assert hasattr(model, 'A_v') + + def test_plot_runs(self, data_2d): + """Test that plot method runs without error.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2, 3], + param2_values=[5, 8], + ) + sweeper.sweep() + + fig, axes = sweeper.plot() + assert fig is not None + assert len(axes) >= 1 + import matplotlib.pyplot as plt + plt.close(fig) + + def test_error_before_sweep(self, data_2d): + """Test that accessing results before sweep raises error.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2], + param2_values=[5], + ) + + with pytest.raises(RuntimeError): + _ = sweeper.aics + + +# ============================================================================= +# Test PyKoopmanSweeper +# ============================================================================= + +class TestPyKoopmanSweeper: + + def test_sweeper_creation(self, data_2d): + """Test PyKoopman sweeper can be created.""" + sweeper = PyKoopmanSweeper( + data=data_2d, + param1_name="observables.n_delays", + param1_values=[2, 3], + param2_name="regressor.svd_rank", + param2_values=[5, 10], + ) + assert sweeper._param1_component == "observables" + assert sweeper._param1_attr == "n_delays" + assert sweeper._param2_component == "regressor" + assert sweeper._param2_attr == "svd_rank" + + def test_sweep_runs_2d(self, data_2d): + """Test PyKoopman sweep completes on 2D data.""" + sweeper = PyKoopmanSweeper( + data=data_2d, + param1_name="observables.n_delays", + param1_values=[2, 3], + param2_name="regressor.svd_rank", + param2_values=[5, 8], + ) + sweeper.sweep() + + assert sweeper._swept + assert sweeper.aics.shape == (2, 2) + assert sweeper.mases.shape == (2, 2) + + def test_sweep_runs_3d(self, data_3d): + """Test PyKoopman sweep on 3D data (flattened internally).""" + sweeper = PyKoopmanSweeper( + data=data_3d, + param1_name="observables.n_delays", + param1_values=[2], + param2_name="regressor.svd_rank", + param2_values=[5], + ) + sweeper.sweep() + + assert sweeper._swept + assert sweeper.aics.shape == (1, 1) + + def test_with_extra_observables(self, data_2d): + """Test PyKoopman sweeper with extra observables.""" + from DSA.pykoopman.observables import RandomFourierFeatures + + sweeper = PyKoopmanSweeper( + data=data_2d, + param1_name="observables.n_delays", + param1_values=[2], + param2_name="regressor.svd_rank", + param2_values=[10], + extra_observables=[RandomFourierFeatures(D=20, gamma=1.0)], + ) + sweeper.sweep() + + assert sweeper._swept + assert not np.isnan(sweeper.aics[0, 0]) + + def test_get_results(self, data_2d): + """Test get_results for PyKoopman sweeper.""" + sweeper = PyKoopmanSweeper( + data=data_2d, + param1_name="observables.n_delays", + param1_values=[2], + param2_name="regressor.svd_rank", + param2_values=[5], + ) + sweeper.sweep() + + results = sweeper.get_results() + assert results["param1_name"] == "observables.n_delays" + assert results["param2_name"] == "regressor.svd_rank" + + def test_plot_runs(self, data_2d): + """Test that plot method runs without error.""" + sweeper = PyKoopmanSweeper( + data=data_2d, + param1_name="observables.n_delays", + param1_values=[2, 3], + param2_name="regressor.svd_rank", + param2_values=[5, 8], + ) + sweeper.sweep() + + fig, axes = sweeper.plot() + assert fig is not None + import matplotlib.pyplot as plt + plt.close(fig) + + +# ============================================================================= +# Test Convenience Functions +# ============================================================================= + +class TestConvenienceFunctions: + + def test_sweep_local_dmd(self, data_2d): + """Test sweep_local_dmd convenience function.""" + sweeper = sweep_local_dmd( + data_2d, + n_delays_values=[2, 3], + rank_values=[5, 8], + ) + + assert sweeper._swept + assert sweeper.aics.shape == (2, 2) + + def test_sweep_pykoopman(self, data_2d): + """Test sweep_pykoopman convenience function.""" + sweeper = sweep_pykoopman( + data_2d, + param1_name="observables.n_delays", + param1_values=[2, 3], + param2_name="regressor.svd_rank", + param2_values=[5, 8], + ) + + assert sweeper._swept + assert sweeper.aics.shape == (2, 2) + + def test_sweep_ranks_delays_backward_compat(self, data_2d): + """Test backward-compatible sweep_ranks_delays function.""" + result = sweep_ranks_delays( + data_2d, + n_delays=[2, 3], + ranks=[5, 8], + return_residuals=False, + ) + + aics, mases, nnormals = result + assert aics.shape == (2, 2) + assert mases.shape == (2, 2) + assert nnormals.shape == (2, 2) + + def test_sweep_ranks_delays_with_residuals(self, data_2d): + """Test sweep_ranks_delays with residuals.""" + result = sweep_ranks_delays( + data_2d, + n_delays=[2], + ranks=[5], + return_residuals=True, + ) + + aics, mases, nnormals, residuals = result + assert aics.shape == (1, 1) + assert residuals.shape == (1, 1) + + +# ============================================================================= +# Test with List Data +# ============================================================================= + +class TestListData: + + def test_local_dmd_sweeper_list_2d(self, data_list_2d): + """Test LocalDMDSweeper with list of 2D arrays.""" + sweeper = LocalDMDSweeper( + data=data_list_2d, + param1_values=[2], + param2_values=[5], + ) + sweeper.sweep() + + assert sweeper._swept + assert sweeper.aics.shape == (1, 1) + + +# ============================================================================= +# Test Edge Cases +# ============================================================================= + +class TestEdgeCases: + + def test_single_param_value(self, data_2d): + """Test with single parameter values.""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[3], + param2_values=[10], + ) + sweeper.sweep() + + assert sweeper.aics.shape == (1, 1) + assert not np.isnan(sweeper.aics[0, 0]) + + def test_large_n_delays(self, data_2d): + """Test with larger n_delays (more delay embedding).""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[5, 10], + param2_values=[20, 30], + ) + sweeper.sweep() + + # Should complete without error + assert sweeper._swept + + def test_train_frac_1(self, data_2d): + """Test with train_frac=1.0 (test on train data).""" + sweeper = LocalDMDSweeper( + data=data_2d, + param1_values=[2], + param2_values=[5], + train_frac=1.0, + ) + sweeper.sweep() + + assert sweeper._swept + assert not np.isnan(sweeper.aics[0, 0]) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) 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)