From caa7de018341a53cf09a8b8ceb36be105ca64708 Mon Sep 17 00:00:00 2001 From: Elad Hazan Date: Mon, 2 Jun 2025 15:54:39 -0400 Subject: [PATCH 01/27] Update core.py just changed comments to reflect that now we have env returning observations and not states. States are hidden. --- deluca/core.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/deluca/core.py b/deluca/core.py index a93467b..2c345bc 100644 --- a/deluca/core.py +++ b/deluca/core.py @@ -112,11 +112,11 @@ class Env(Obj): @abstractmethod def init(self): - """Return an initialized state""" + """Return an initial observation""" @abstractmethod def __call__(self, state, action, *args, **kwargs): - """Return an updated state""" + """Return an updated observation after taking input action""" class AgentState(Obj): From 60007ea3ea7b4eaa8eca944d7de18f0b47071503 Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 15:31:21 -0400 Subject: [PATCH 02/27] Fixed bugs in SFC, DSC; Changed LDS class; Added disturbance class --- deluca/agents/_dsc.py | 2 +- deluca/agents/_sfc.py | 2 +- deluca/core.py | 12 +++++ deluca/envs/_lds.py | 107 ++++++++++++++++++++++-------------------- 4 files changed, 70 insertions(+), 53 deletions(-) diff --git a/deluca/agents/_dsc.py b/deluca/agents/_dsc.py index 0517bac..fb44d8c 100644 --- a/deluca/agents/_dsc.py +++ b/deluca/agents/_dsc.py @@ -85,7 +85,7 @@ def __init__( self.h = h self.t = 0 - subkey_1, subkey2, subkey3, subkey4 = jax.random.split(key, 4) + subkey1, subkey2, subkey3, subkey4 = jax.random.split(key, 4) self.M_0 = init_scale*jax.random.normal(subkey1, shape=(self.n, self.p)) self.M_1 = init_scale*jax.random.normal(subkey2, shape=(self.h, self.n, self.p)) self.M_2 = init_scale*jax.random.normal(subkey3, shape=(self.h, self.n, self.p)) diff --git a/deluca/agents/_sfc.py b/deluca/agents/_sfc.py index a228b4b..3121c06 100644 --- a/deluca/agents/_sfc.py +++ b/deluca/agents/_sfc.py @@ -85,7 +85,7 @@ def __init__( self.h = h self.t = 0 - subkey_1, subkey2 = jax.random.split(key) + subkey1, subkey2 = jax.random.split(key) self.M = init_scale*jax.random.normal(subkey1, shape=(self.h, self.n, self.p)) self.M_0 = init_scale*jax.random.normal(subkey2, shape=(self.n, self.p)) diff --git a/deluca/core.py b/deluca/core.py index 2c345bc..6e1a3af 100644 --- a/deluca/core.py +++ b/deluca/core.py @@ -134,9 +134,21 @@ def init(self): return AgentState() +class Disturbance(Obj): + + @abstractmethod + def init(self): + """Initializes disturbance class""" + + @abstractmethod + def __call__(self, *args, **kwargs): + """Returns the next disturbance""" + + deluca.field = field deluca.Obj = Obj deluca.Env = Env deluca.Agent = Agent deluca.save = save deluca.load = load +deluca.Disturbance = Disturbance diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index af185ee..1fc974f 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -14,62 +14,62 @@ """Linear dynamical system.""" from deluca.core import Env -from deluca.core import field +from deluca.core import Disturbance import jax import jax.numpy as jnp import matplotlib.pyplot as plt import numpy as np -class LDS(Env): - """LDS.""" - key: int = field(default_factory=lambda: jax.random.key(0), jaxed=False) - A: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) - B: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) - C: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) - state: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) - d_hidden: int = field(1, jaxed=False) - d_in: int = field(1, jaxed=False) - d_out: int = field(1, jaxed=False) - - - def init(self,d_in = 1,d_hidden = 1, d_out = 1): - """init. - initialize internal state to be random - - Returns: - obs: - """ - self.d_in = d_in - self.d_hidden = d_hidden - self.d_out = d_out - A = jnp.diag( jnp.sign( jax.random.normal(self.key, shape=(self.d_hidden))) * 0.9 + jax.random.uniform(self.key, self.d_hidden ) * 0.04 ) - print("the eigenvalues of our system:",jnp.diag(A)) - B = jax.random.normal(self.key, shape=(self.d_hidden, self.d_in)) - C = jax.random.normal(self.key, shape=(d_out, d_hidden)) # jax.numpy.identity(self.d_hidden) # - self.A = A - self.B = B - self.C = C - self.state = jax.random.normal(self.key, shape=(self.d_hidden, 1)) - return self.C @ self.state +class ZeroDisturbance(Disturbance): + def init(self, d): + self.d = d + def __call__(self, t, key): + del t + del key + return jnp.zeros((self.d, 1)) - def __call__(self, action): - """__call__. - Args: - action: +class GaussianDisturbance(Disturbance): + def init(self, d, std=0.5): + self.d = d + self.std = std - Returns: - observation signal: + def __call__(self, t, key): + del t + return jax.random.normal(key, (self.d, 1)) * self.std - """ - assert action.shape[0] == self.d_in , "dimension of action is wrong" - self.state = self.A @ self.state + self.B @ action - return self.C @ self.state +class LDS(Env): + """LDS.""" - def generate_random_trajectory(self, trajectory_length = 1000): + def init(self, A, B, C, x0=None, disturbance=None): + self.A = jnp.array(A) + self.B = jnp.array(B) + self.C = jnp.array(C) + self.d = A.shape[0] + self.n = B.shape[1] + self.p = C.shape[0] + self.x = jnp.zeros((self.d, 1)) if x0 is None else jnp.array(x0) + self.t = 0 + self.disturbance = disturbance or ZeroDisturbance(self.d) + self.history = {"x": [self.x], "u": [], "w": [], "y": []} + + def __call__(self, u_t, key): + w_t = self.disturbance(self.t, key) + x_next = self.A @ self.x + self.B @ u_t + w_t + y_t = self.C @ self.x + self.history["x"].append(x_next) + self.history["u"].append(u_t) + self.history["w"].append(w_t) + self.history["y"].append(y_t) + self.x = x_next + self.t += 1 + return y_t + + + def generate_random_trajectory(self, trajectory_length = 1000, key=None): """generate_random_trajectory. generates a trajectory of the environment with random actions @@ -79,23 +79,28 @@ def generate_random_trajectory(self, trajectory_length = 1000): """ print("trajectory length =" , trajectory_length) - results = np.zeros(trajectory_length) + + if key is None: + key = jax.random.PRNGKey(0) + + results = jnp.zeros((trajectory_length,)) for i in range(trajectory_length): - # rand_action = jax.random.normal(self.key, shape = (self.d_in,1)) - rand_action = np.random.normal(0,1,size=(self.d_in,1)) - obs = self( rand_action ) - results[i] = obs[0,0] # first coordinate of the observation + key, subkey1, subkey2 = jax.random.split(key, 3) + rand_action = jax.random.normal(subkey1, (self.n, 1)) + obs = self(rand_action, subkey2) + results = results.at[i].set(obs[0, 0]) # first coordinate of the observation + return results def show_me_the_signal(self,length = 1000): results = self.generate_random_trajectory(length) - plt.plot(results) + plt.plot(np.array(results)) plt.show() def diagnostics(self): print("my parameters are") - print("d_in, d_hidden, d_out are:") - print(self.d_in, self.d_hidden, self.d_out) + print("d_in (n), d_hidden (d), d_out (p) are:") + print(self.n, self.d, self.p) print("A, B, C are: ") print(self.A, self.B, self.C) print("state is:") From 4442ea8d94539a5285e84c390d3ecd654c66acba Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 15:56:45 -0400 Subject: [PATCH 03/27] Fixed bugs in core.py --- deluca/core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deluca/core.py b/deluca/core.py index 6e1a3af..70b36ee 100644 --- a/deluca/core.py +++ b/deluca/core.py @@ -137,7 +137,7 @@ def init(self): class Disturbance(Obj): @abstractmethod - def init(self): + def init(self, *args): """Initializes disturbance class""" @abstractmethod From 790edc38659fa7ba77b35faa50c721ff16b7c896 Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 16:03:06 -0400 Subject: [PATCH 04/27] Fixed bugs in LDS --- deluca/envs/_lds.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index 1fc974f..91fe881 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -92,8 +92,8 @@ def generate_random_trajectory(self, trajectory_length = 1000, key=None): return results - def show_me_the_signal(self,length = 1000): - results = self.generate_random_trajectory(length) + def show_me_the_signal(self,length = 1000, key=None): + results = self.generate_random_trajectory(length, key) plt.plot(np.array(results)) plt.show() From 144241162b5bf08d413963c65dc10a7bcfb6d278 Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 16:09:33 -0400 Subject: [PATCH 05/27] Fixed SimpleRandom Agent --- deluca/agents/_random.py | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/deluca/agents/_random.py b/deluca/agents/_random.py index 07a5ceb..9a2f18e 100644 --- a/deluca/agents/_random.py +++ b/deluca/agents/_random.py @@ -41,15 +41,8 @@ class SimpleRandom(Agent): # agent_state: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) # key: int = field(default_factory=lambda: jax.random.key(0), jaxed=False) - def __init__(self,d_action): - self.d_action = d_action - self.agent_state = None - self.key = jax.random.key(0) - return None - - def __call__(self, obs): - self.key = jax.random.split(self.key)[0] - return jax.random.normal( self.key, shape = (self.d_action,1)) - - def update(self, state: jnp.ndarray, u: jnp.ndarray) -> None: - return None + def __init__(self, n: int): + self.n = n + + def __call__(self, obs: jnp.array, key: jax.random.key): + return jax.random.normal(key, shape = (self.n, 1)) \ No newline at end of file From 9088e414edda091a1f2c7d0a8b1f4ee913b5c3c9 Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 16:33:41 -0400 Subject: [PATCH 06/27] Fixed LDS class --- deluca/envs/_lds.py | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index 91fe881..6694c60 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -54,17 +54,11 @@ def init(self, A, B, C, x0=None, disturbance=None): self.x = jnp.zeros((self.d, 1)) if x0 is None else jnp.array(x0) self.t = 0 self.disturbance = disturbance or ZeroDisturbance(self.d) - self.history = {"x": [self.x], "u": [], "w": [], "y": []} def __call__(self, u_t, key): w_t = self.disturbance(self.t, key) - x_next = self.A @ self.x + self.B @ u_t + w_t + self.x = self.A @ self.x + self.B @ u_t + w_t y_t = self.C @ self.x - self.history["x"].append(x_next) - self.history["u"].append(u_t) - self.history["w"].append(w_t) - self.history["y"].append(y_t) - self.x = x_next self.t += 1 return y_t @@ -104,4 +98,4 @@ def diagnostics(self): print("A, B, C are: ") print(self.A, self.B, self.C) print("state is:") - print(self.state) + print(self.x) From a2dd0f47468b59b92dd81c86bb85ec8b349ab589 Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 16:34:32 -0400 Subject: [PATCH 07/27] Fixed LDS class --- deluca/envs/_lds.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index 6694c60..a43ca4b 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -55,12 +55,12 @@ def init(self, A, B, C, x0=None, disturbance=None): self.t = 0 self.disturbance = disturbance or ZeroDisturbance(self.d) - def __call__(self, u_t, key): + def __call__(self, u, key): w_t = self.disturbance(self.t, key) - self.x = self.A @ self.x + self.B @ u_t + w_t - y_t = self.C @ self.x + self.x = self.A @ self.x + self.B @ u + w_t + y = self.C @ self.x self.t += 1 - return y_t + return y def generate_random_trajectory(self, trajectory_length = 1000, key=None): From 2373e3c5f5b9808ea727105d3c6aae1a1f6390dc Mon Sep 17 00:00:00 2001 From: Anand Date: Tue, 3 Jun 2025 17:27:27 -0400 Subject: [PATCH 08/27] Fixed a bud in DSC --- deluca/agents/_dsc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deluca/agents/_dsc.py b/deluca/agents/_dsc.py index fb44d8c..598e99f 100644 --- a/deluca/agents/_dsc.py +++ b/deluca/agents/_dsc.py @@ -116,7 +116,7 @@ def last_ynat(): self.last_ynat = last_ynat def slice_window(start): - return jax.lax.dynamic_slice(self.ynat_history, (start, 0, 0), (self.m, p, 1)) + return jax.lax.dynamic_slice(self.ynat_history, (start, 0, 0), (self.m, self.p, 1)) self.slice_window = slice_window From b107bd61ebed8ee2748a3856164640814368010b Mon Sep 17 00:00:00 2001 From: eladhazan Date: Wed, 4 Jun 2025 16:40:51 +0000 Subject: [PATCH 09/27] remove depreciated stuff --- plugin/README.md | 16 ---------- plugin/setup.cfg | 17 ---------- plugin/setup.py | 17 ---------- scripts/make_plugin.py | 71 ------------------------------------------ 4 files changed, 121 deletions(-) delete mode 100644 plugin/README.md delete mode 100644 plugin/setup.cfg delete mode 100644 plugin/setup.py delete mode 100755 scripts/make_plugin.py diff --git a/plugin/README.md b/plugin/README.md deleted file mode 100644 index eaa05f0..0000000 --- a/plugin/README.md +++ /dev/null @@ -1,16 +0,0 @@ -# deluca-plugin - -Welcome to your new `Deluca Plugin (TM)`! - -## IMPORTANT! -`deluca` uses [Python namespace -packages](https://packaging.python.org/guides/packaging-namespace-packages/) to -handle its plugins. In order to maintain this, we recommend you do not create -the file `[PLUGIN_ROOT]/deluca/__init__.py` or write code outside of -`[PLUGIN_ROOT]/deluca/plugin`. - -## Getting started -1. Optional, but good to fill out `[PLUGIN_ROOT]/setup.cfg` as appropriate. -2. Start writing your code in `[PLUGIN_ROOT]/deluca/plugin`. -3. Create a pull request [here](https://github.com/google/deluca/pulls) if you'd - like us to review your plugin and add it to the official list. \ No newline at end of file diff --git a/plugin/setup.cfg b/plugin/setup.cfg deleted file mode 100644 index 13be7c8..0000000 --- a/plugin/setup.cfg +++ /dev/null @@ -1,17 +0,0 @@ -[metadata] -name = deluca-plugin -version = attr: deluca.plugin._version.__version__ -author = [AUTHOR] -author_email = [AUTHOR_EMAIL] -url = [URL] -description = [DESCRIPTION] -long_description = file: README.md -long_description_content_type = text/markdown -keywords = [KEYWORDS] -license = [LICENSE] -classifiers = [CLASSIFIERS] - -[options] -packages = find_namespace: -install_requires = - deluca \ No newline at end of file diff --git a/plugin/setup.py b/plugin/setup.py deleted file mode 100644 index da45894..0000000 --- a/plugin/setup.py +++ /dev/null @@ -1,17 +0,0 @@ -# Copyright 2022 The Deluca Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import setuptools - -setuptools.setup() diff --git a/scripts/make_plugin.py b/scripts/make_plugin.py deleted file mode 100755 index 8b0f5c1..0000000 --- a/scripts/make_plugin.py +++ /dev/null @@ -1,71 +0,0 @@ -# Copyright 2022 The Deluca Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -#!/usr/bin/env python3 -import argparse -import fileinput -import pathlib -import shutil -import sys - -parser = argparse.ArgumentParser( - description="A script that generates the template for a new plugin" -) -parser.add_argument("name", type=str, help="Name of the package, formatted as deluca-name") -parser.add_argument( - "-d", - "--dst", - type=pathlib.Path, - help="Parent directory to place new plugin (default: 'PATH/deluca/..')", - default=pathlib.Path(__file__).absolute().parent.parent.parent, -) - -args = parser.parse_args() - - -def err_and_die(message): - print(f"{message}\n") - parser.print_help() - sys.exit(1) - - -if not args.dst.exists() or not args.dst.is_dir(): - err_and_die(f"ERROR: '{args.dst}' either does not exist or is not a directory!") - -path = args.dst.absolute() / f"deluca-{args.name}" - -if path.exists(): - err_and_die(f"ERROR: '{path}' already exists!") - -src = pathlib.Path(__file__).absolute().parent.parent / "plugin" - -shutil.copytree(src, path) - -for file_path in path.glob("**/*"): - if file_path.is_file(): - with fileinput.FileInput(file_path.absolute(), inplace=True) as file: - for line in file: - line = line.replace("deluca.plugin", f"deluca.{args.name}") - line = line.replace("deluca-plugin", f"deluca-{args.name}") - line = line.replace("deluca/plugin", f"deluca/{args.name}") - print(line, end="") - -lib_path = path / "deluca" / args.name -lib_path.mkdir() - -with open(lib_path / "__init__.py", "w") as init_file: - pass - -with open(lib_path / "_version.py", "w") as version_file: - version_file.write("__version__ = 0.0.1") From 0cd3c4f9cef98c5867c714d2e64cc50033753610 Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:06:39 -0400 Subject: [PATCH 10/27] Added default arguments to LDS class --- deluca/envs/_lds.py | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index a43ca4b..d63d59f 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -44,19 +44,29 @@ def __call__(self, t, key): class LDS(Env): """LDS.""" - def init(self, A, B, C, x0=None, disturbance=None): - self.A = jnp.array(A) - self.B = jnp.array(B) - self.C = jnp.array(C) + def init(self, A = None, B = None, C = None, d_in = 1, d_hidden = 25, d_out = 1, key = jax.random.PRNGKey(0), x0=None, disturbance=None): + key, subkey1, subkey2, subkey3 = jax.random.split(key, 4) + self.A = jnp.array(A) if A is not None else jnp.random.normal(subkey1, (d_hidden, d_hidden)) + self.B = jnp.array(B) if B is not None else jnp.random.normal(subkey2, (d_hidden, d_in)) + self.C = jnp.array(C) if C is not None else jnp.random.normal(subkey3, (d_out, d_hidden)) self.d = A.shape[0] self.n = B.shape[1] self.p = C.shape[0] self.x = jnp.zeros((self.d, 1)) if x0 is None else jnp.array(x0) self.t = 0 - self.disturbance = disturbance or ZeroDisturbance(self.d) - - def __call__(self, u, key): - w_t = self.disturbance(self.t, key) + if disturbance is None + self.disturbance = GaussianDisturbance() + self.disturbance.init(self.d) + else: + self.disturbance = disturbance + self.key = key + + def __call__(self, u, key = None): + if key is None: + self.key, subkey = jax.random.split(self.key, 2) + w_t = self.disturbance(self.t, subkey) + else: + w_t = self.disturbance(self.t, key) self.x = self.A @ self.x + self.B @ u + w_t y = self.C @ self.x self.t += 1 From 7250042a27bdec44af86d5050675149637b85442 Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:11:01 -0400 Subject: [PATCH 11/27] Added default arguments to LDS class --- deluca/envs/_lds.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index d63d59f..ad2ad1f 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -54,7 +54,7 @@ def init(self, A = None, B = None, C = None, d_in = 1, d_hidden = 25, d_out = 1, self.p = C.shape[0] self.x = jnp.zeros((self.d, 1)) if x0 is None else jnp.array(x0) self.t = 0 - if disturbance is None + if disturbance is None: self.disturbance = GaussianDisturbance() self.disturbance.init(self.d) else: From e0ba985a38eb8bdccc6ee6e44b4e24e86a610479 Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:14:19 -0400 Subject: [PATCH 12/27] Fixed Simplerandom agent --- deluca/agents/_random.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/deluca/agents/_random.py b/deluca/agents/_random.py index 9a2f18e..44c7bdf 100644 --- a/deluca/agents/_random.py +++ b/deluca/agents/_random.py @@ -41,8 +41,13 @@ class SimpleRandom(Agent): # agent_state: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) # key: int = field(default_factory=lambda: jax.random.key(0), jaxed=False) - def __init__(self, n: int): + def __init__(self, n: int, key: jax.random.key = jax.random.PRNGKey(0)): self.n = n - - def __call__(self, obs: jnp.array, key: jax.random.key): - return jax.random.normal(key, shape = (self.n, 1)) \ No newline at end of file + self.key = key + + def __call__(self, obs: jnp.array, key: jax.random.key = None): + if key is None: + self.key, subkey = jax.random.split(self.key, 2) + return jax.random.normal(subkey, shape = (self.n, 1)) + else: + return jax.random.normal(key, shape = (self.n, 1)) \ No newline at end of file From 48165ccaf81fb14500660b08fc053f5a9c1974eb Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:16:46 -0400 Subject: [PATCH 13/27] Added default arguments to LDS class --- deluca/envs/_lds.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index ad2ad1f..fd257e1 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -44,7 +44,7 @@ def __call__(self, t, key): class LDS(Env): """LDS.""" - def init(self, A = None, B = None, C = None, d_in = 1, d_hidden = 25, d_out = 1, key = jax.random.PRNGKey(0), x0=None, disturbance=None): + def init(self, d_in = 1, d_hidden = 25, d_out = 1, A = None, B = None, C = None, key = jax.random.PRNGKey(0), x0=None, disturbance=None): key, subkey1, subkey2, subkey3 = jax.random.split(key, 4) self.A = jnp.array(A) if A is not None else jnp.random.normal(subkey1, (d_hidden, d_hidden)) self.B = jnp.array(B) if B is not None else jnp.random.normal(subkey2, (d_hidden, d_in)) From 57cdcdd2b3a6131344182eb0f673fc3fd7a52c46 Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:19:30 -0400 Subject: [PATCH 14/27] Added default arguments to LDS class --- deluca/envs/_lds.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index fd257e1..052ca36 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -46,9 +46,9 @@ class LDS(Env): def init(self, d_in = 1, d_hidden = 25, d_out = 1, A = None, B = None, C = None, key = jax.random.PRNGKey(0), x0=None, disturbance=None): key, subkey1, subkey2, subkey3 = jax.random.split(key, 4) - self.A = jnp.array(A) if A is not None else jnp.random.normal(subkey1, (d_hidden, d_hidden)) - self.B = jnp.array(B) if B is not None else jnp.random.normal(subkey2, (d_hidden, d_in)) - self.C = jnp.array(C) if C is not None else jnp.random.normal(subkey3, (d_out, d_hidden)) + self.A = jnp.array(A) if A is not None else jax.random.normal(subkey1, (d_hidden, d_hidden)) + self.B = jnp.array(B) if B is not None else jax.random.normal(subkey2, (d_hidden, d_in)) + self.C = jnp.array(C) if C is not None else jax.random.normal(subkey3, (d_out, d_hidden)) self.d = A.shape[0] self.n = B.shape[1] self.p = C.shape[0] From 20beb70bab9bdf0bbbfb5ec070ea7133b073f090 Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:22:38 -0400 Subject: [PATCH 15/27] Added default arguments to LDS class --- deluca/envs/_lds.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index 052ca36..9f9cba0 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -49,9 +49,9 @@ def init(self, d_in = 1, d_hidden = 25, d_out = 1, A = None, B = None, C = None, self.A = jnp.array(A) if A is not None else jax.random.normal(subkey1, (d_hidden, d_hidden)) self.B = jnp.array(B) if B is not None else jax.random.normal(subkey2, (d_hidden, d_in)) self.C = jnp.array(C) if C is not None else jax.random.normal(subkey3, (d_out, d_hidden)) - self.d = A.shape[0] - self.n = B.shape[1] - self.p = C.shape[0] + self.d = self.A.shape[0] + self.n = self.B.shape[1] + self.p = self.C.shape[0] self.x = jnp.zeros((self.d, 1)) if x0 is None else jnp.array(x0) self.t = 0 if disturbance is None: From b25ddce99c956529e62c35fc5a0f3c82a1156050 Mon Sep 17 00:00:00 2001 From: Anand Date: Wed, 4 Jun 2025 13:34:25 -0400 Subject: [PATCH 16/27] Added default arguments to LDS class --- deluca/envs/_lds.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index 9f9cba0..152fa11 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -46,7 +46,7 @@ class LDS(Env): def init(self, d_in = 1, d_hidden = 25, d_out = 1, A = None, B = None, C = None, key = jax.random.PRNGKey(0), x0=None, disturbance=None): key, subkey1, subkey2, subkey3 = jax.random.split(key, 4) - self.A = jnp.array(A) if A is not None else jax.random.normal(subkey1, (d_hidden, d_hidden)) + self.A = jnp.array(A) if A is not None else jnp.diag(jax.random.uniform(subkey1, (d_hidden,), minval=0.9, maxval=0.95)) self.B = jnp.array(B) if B is not None else jax.random.normal(subkey2, (d_hidden, d_in)) self.C = jnp.array(C) if C is not None else jax.random.normal(subkey3, (d_out, d_hidden)) self.d = self.A.shape[0] From 969c59183a7ca0d49fb0c8ded139821472f67795 Mon Sep 17 00:00:00 2001 From: Elad Hazan Date: Wed, 4 Jun 2025 14:05:42 -0400 Subject: [PATCH 17/27] Update _random.py added update function to SimpleRandom --- deluca/agents/_random.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/deluca/agents/_random.py b/deluca/agents/_random.py index 44c7bdf..d1d329e 100644 --- a/deluca/agents/_random.py +++ b/deluca/agents/_random.py @@ -50,4 +50,7 @@ def __call__(self, obs: jnp.array, key: jax.random.key = None): self.key, subkey = jax.random.split(self.key, 2) return jax.random.normal(subkey, shape = (self.n, 1)) else: - return jax.random.normal(key, shape = (self.n, 1)) \ No newline at end of file + return jax.random.normal(key, shape = (self.n, 1)) + + def update(self, obs: jnp.ndarray, action: jnp.ndarray) -> None: + return None From d5be431c90a9bba446aed1c462c60fb8f8ae2ead Mon Sep 17 00:00:00 2001 From: Elad Hazan Date: Wed, 4 Jun 2025 14:39:55 -0400 Subject: [PATCH 18/27] Update _zero.py --- deluca/agents/_zero.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/deluca/agents/_zero.py b/deluca/agents/_zero.py index e64b155..ec120f3 100644 --- a/deluca/agents/_zero.py +++ b/deluca/agents/_zero.py @@ -28,7 +28,7 @@ def init(self,d_action): return None def __call__(self, obs): - return jnp.zeros(self.d_action) + return jnp.zeros((self.d_action,1)) def update(self, state: jnp.ndarray, u: jnp.ndarray) -> None: return None From 987c0bcb970bf326fa047a97d34122732146e63c Mon Sep 17 00:00:00 2001 From: eladhazan Date: Wed, 4 Jun 2025 20:05:11 +0000 Subject: [PATCH 19/27] added sinus noise --- colabs/test_agents_on_lds.ipynb | 1 + deluca/colabs/test_agents_on_lds.ipynb | 1 - deluca/envs/_lds.py | 12 +++++++++++- 3 files changed, 12 insertions(+), 2 deletions(-) create mode 100644 colabs/test_agents_on_lds.ipynb delete mode 100644 deluca/colabs/test_agents_on_lds.ipynb diff --git a/colabs/test_agents_on_lds.ipynb b/colabs/test_agents_on_lds.ipynb new file mode 100644 index 0000000..96db5f0 --- /dev/null +++ b/colabs/test_agents_on_lds.ipynb @@ -0,0 +1 @@ +{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1ZArDMR7PAiWBecPgHCikbKXN_V7j7SJ2","timestamp":1748725042432}]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XOcLsTo1vS5A","executionInfo":{"status":"ok","timestamp":1749067051752,"user_tz":240,"elapsed":1574,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"169dbb7c-5ae6-4115-c8a0-83c6bb7d216c"},"outputs":[{"output_type":"stream","name":"stdout","text":["Cloning into 'deluca'...\n","remote: Enumerating objects: 2604, done.\u001b[K\n","remote: Counting objects: 100% (307/307), done.\u001b[K\n","remote: Compressing objects: 100% (138/138), done.\u001b[K\n","remote: Total 2604 (delta 249), reused 187 (delta 169), pack-reused 2297 (from 2)\u001b[K\n","Receiving objects: 100% (2604/2604), 3.23 MiB | 5.83 MiB/s, done.\n","Resolving deltas: 100% (1590/1590), done.\n"]}],"source":["!git clone https://github.com/google/deluca.git"]},{"cell_type":"code","source":["%cd deluca\n","\n","!pip install -e ."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"eBKI9_uzKNAY","executionInfo":{"status":"ok","timestamp":1749067077217,"user_tz":240,"elapsed":24342,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"1fcca168-7763-4c86-d4e0-9048e86c7554"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["/content/deluca\n","Obtaining file:///content/deluca\n"," Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (2.0.2)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (1.15.3)\n","Requirement already satisfied: jax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.5.2)\n","Requirement already satisfied: optax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.2.4)\n","Requirement already satisfied: flax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.10.6)\n","Collecting brax (from deluca==0.0.17)\n"," Downloading brax-0.12.3-py3-none-any.whl.metadata (20 kB)\n","Requirement already satisfied: absl-py in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.4.0)\n","Collecting dm-env (from brax->deluca==0.0.17)\n"," Downloading dm_env-1.6-py3-none-any.whl.metadata (966 bytes)\n","Requirement already satisfied: etils in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.12.2)\n","Requirement already satisfied: flask in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.1)\n","Collecting flask-cors (from brax->deluca==0.0.17)\n"," Downloading flask_cors-6.0.0-py3-none-any.whl.metadata (961 bytes)\n","Requirement already satisfied: grpcio in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.71.0)\n","Requirement already satisfied: gym in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.25.2)\n","Requirement already satisfied: jaxlib>=0.4.6 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.5.1)\n","Collecting jaxopt (from brax->deluca==0.0.17)\n"," Downloading jaxopt-0.8.5-py3-none-any.whl.metadata (3.3 kB)\n","Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.6)\n","Collecting ml-collections (from brax->deluca==0.0.17)\n"," Downloading ml_collections-1.1.0-py3-none-any.whl.metadata (22 kB)\n","Collecting mujoco (from brax->deluca==0.0.17)\n"," Downloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (44 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.4/44.4 kB\u001b[0m \u001b[31m476.9 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting mujoco-mjx (from brax->deluca==0.0.17)\n"," Downloading mujoco_mjx-3.3.2-py3-none-any.whl.metadata (3.4 kB)\n","Requirement already satisfied: orbax-checkpoint in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.11.13)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (11.2.1)\n","Collecting pytinyrenderer (from brax->deluca==0.0.17)\n"," Downloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (1.2 kB)\n","Collecting tensorboardx (from brax->deluca==0.0.17)\n"," Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl.metadata (5.8 kB)\n","Collecting trimesh (from brax->deluca==0.0.17)\n"," Downloading trimesh-4.6.10-py3-none-any.whl.metadata (18 kB)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (4.13.2)\n","Requirement already satisfied: ml_dtypes>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (0.4.1)\n","Requirement already satisfied: opt_einsum in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (3.4.0)\n","Requirement already satisfied: msgpack in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (1.1.0)\n","Requirement already satisfied: tensorstore in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.74)\n","Requirement already satisfied: rich>=11.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (13.9.4)\n","Requirement already satisfied: PyYAML>=5.4.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (6.0.2)\n","Requirement already satisfied: treescope>=0.1.7 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: chex>=0.1.87 in /usr/local/lib/python3.11/dist-packages (from optax->deluca==0.0.17) (0.1.89)\n","Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from chex>=0.1.87->optax->deluca==0.0.17) (0.12.1)\n","Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (3.0.0)\n","Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (2.19.1)\n","Requirement already satisfied: dm-tree in /usr/local/lib/python3.11/dist-packages (from dm-env->brax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: blinker>=1.9.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (1.9.0)\n","Requirement already satisfied: click>=8.1.3 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (8.2.1)\n","Requirement already satisfied: itsdangerous>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (2.2.0)\n","Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.0.2)\n","Requirement already satisfied: werkzeug>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.1.3)\n","Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (3.1.1)\n","Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (0.0.8)\n","Collecting glfw (from mujoco->brax->deluca==0.0.17)\n"," Downloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl.metadata (5.4 kB)\n","Requirement already satisfied: pyopengl in /usr/local/lib/python3.11/dist-packages (from mujoco->brax->deluca==0.0.17) (3.1.9)\n","Requirement already satisfied: nest_asyncio in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (1.6.0)\n","Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (5.29.5)\n","Requirement already satisfied: humanize in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (4.12.3)\n","Requirement already satisfied: simplejson>=3.16.0 in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (3.20.1)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorboardx->brax->deluca==0.0.17) (24.2)\n","Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich>=11.1->flax->deluca==0.0.17) (0.1.2)\n","Requirement already satisfied: attrs>=18.2.0 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (25.3.0)\n","Requirement already satisfied: wrapt>=1.11.2 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (1.17.2)\n","Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (2025.3.2)\n","Requirement already satisfied: importlib_resources in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (6.5.2)\n","Requirement already satisfied: zipp in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (3.22.0)\n","Downloading brax-0.12.3-py3-none-any.whl (14.2 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.2/14.2 MB\u001b[0m \u001b[31m57.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading dm_env-1.6-py3-none-any.whl (26 kB)\n","Downloading flask_cors-6.0.0-py3-none-any.whl (11 kB)\n","Downloading jaxopt-0.8.5-py3-none-any.whl (172 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m172.4/172.4 kB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading ml_collections-1.1.0-py3-none-any.whl (76 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.7/76.7 kB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.6 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.6/6.6 MB\u001b[0m \u001b[31m68.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco_mjx-3.3.2-py3-none-any.whl (6.7 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.7/6.7 MB\u001b[0m \u001b[31m70.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m46.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading tensorboardX-2.6.2.2-py2.py3-none-any.whl (101 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading trimesh-4.6.10-py3-none-any.whl (711 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m711.2/711.2 kB\u001b[0m \u001b[31m27.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl (243 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m243.5/243.5 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hInstalling collected packages: pytinyrenderer, glfw, trimesh, tensorboardx, ml-collections, dm-env, mujoco, flask-cors, mujoco-mjx, jaxopt, brax, deluca\n"," Running setup.py develop for deluca\n","Successfully installed brax-0.12.3 deluca-0.0.17 dm-env-1.6 flask-cors-6.0.0 glfw-2.9.0 jaxopt-0.8.5 ml-collections-1.1.0 mujoco-3.3.2 mujoco-mjx-3.3.2 pytinyrenderer-0.0.14 tensorboardx-2.6.2.2 trimesh-4.6.10\n"]}]},{"cell_type":"markdown","source":["#This cell creates an LDS environment and plots the signal with random activations."],"metadata":{"id":"SJ_Hx9Q28jle"}},{"cell_type":"code","source":["%load_ext autoreload\n","%autoreload 2\n","import jax\n","import numpy as np\n","import jax.numpy as jnp\n","import matplotlib.pyplot as plt\n","\n","from deluca.core import Env\n","from deluca.core import field\n","from deluca.envs import _lds as lds\n","from deluca.envs._lds import SinusDisturbance\n","\n","\n","\n","env = lds.LDS() #LDS with random initiations and dimensions as specified\n","#env = lds.LDS(2,10,3) #LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","disturbance = SinusDisturbance()\n","disturbance.init(d_hidden, 0.5)\n","obs = env.init(d_action,d_hidden,d_obs, disturbance = disturbance)\n","env.show_me_the_signal(1000)"],"metadata":{"id":"NZgnFh7KJoCh","executionInfo":{"status":"ok","timestamp":1749067109519,"user_tz":240,"elapsed":11210,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"6b8316bf-f2dc-42de-e402-795e536b693f","colab":{"base_uri":"https://localhost:8080/","height":448}},"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["trajectory length = 1000\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Now I'd like to plot the signal with different activations, but instead of a build in function, i want to use agents."],"metadata":{"id":"1ryBUW4q8r9Y"}},{"cell_type":"code","source":["# prompt: I want the same cell as above, but plot the figures side by side\n","%load_ext autoreload\n","%autoreload 2\n","from deluca.core import Agent\n","from deluca.agents._grc import GRC\n","from deluca.agents._random import SimpleRandom\n","from deluca.agents._lqg import LQG\n","from deluca.agents._zero import Zero\n","from deluca.agents._sfc import SFC\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","def plot_lds_with_a_given_agent(env, agent, name_of_agent, traj_length=1000, window_size=50, ax=None):\n"," obs = np.zeros(shape=(d_obs, 1))\n"," action = agent(obs)\n"," losses = np.zeros(traj_length)\n"," window_losses = np.zeros(traj_length - window_size)\n","\n"," for i in range(traj_length):\n"," obs = env(action)\n"," action = agent(obs)\n"," losses[i] = np.linalg.norm(obs) + np.linalg.norm(action) # simple quadratic loss\n"," agent.update(obs, action)\n"," if i >= window_size - 1:\n"," window_losses[i - window_size] = np.mean(losses[i - window_size + 1: i + 1])\n","\n"," ax.plot(window_losses)\n"," ax.set_xlabel('Time step (sliding window)')\n"," ax.set_ylabel('Loss')\n"," ax.set_title(f\"Loss of {name_of_agent} on LDS\")\n","\n","\n","env = lds.LDS() # LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","disturbance = SinusDisturbance()\n","disturbance.init(d_hidden, 0.5)\n","obs = env.init(d_action,d_hidden,d_obs, disturbance = disturbance)\n","\n","fig, axes = plt.subplots(2, 2, figsize=(12, 8))\n","axes = axes.flatten()\n","\n","agent = GRC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"GRC\", ax=axes[0])\n","\n","agent = SimpleRandom(d_action)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"Random agent\", ax=axes[1])\n","\n","agent = Zero(d_action)\n","agent.init(d_action)\n","plot_lds_with_a_given_agent(env, agent, \"Zero agent\", ax=axes[2])\n","\n","agent = SFC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"SFC\", ax=axes[3])\n","\n","plt.tight_layout()\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"3VhZKqj6nOaN","outputId":"0bdf0bd2-cb8f-4cd3-de9a-db8df3c9d8cb"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["The autoreload extension is already loaded. To reload it, use:\n"," %reload_ext autoreload\n"]}]},{"cell_type":"code","source":[],"metadata":{"id":"xQIAC7kzuDsk"},"execution_count":null,"outputs":[]}]} \ No newline at end of file diff --git a/deluca/colabs/test_agents_on_lds.ipynb b/deluca/colabs/test_agents_on_lds.ipynb deleted file mode 100644 index fcce40b..0000000 --- a/deluca/colabs/test_agents_on_lds.ipynb +++ /dev/null @@ -1 +0,0 @@ -{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1ZArDMR7PAiWBecPgHCikbKXN_V7j7SJ2","timestamp":1748725042432}]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XOcLsTo1vS5A","executionInfo":{"status":"ok","timestamp":1748782658506,"user_tz":240,"elapsed":1731,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"b09818da-de59-471e-ac03-d8339aa3f5f4"},"outputs":[{"output_type":"stream","name":"stdout","text":["Cloning into 'deluca'...\n","remote: Enumerating objects: 2487, done.\u001b[K\n","remote: Counting objects: 100% (299/299), done.\u001b[K\n","remote: Compressing objects: 100% (154/154), done.\u001b[K\n","remote: Total 2487 (delta 217), reused 172 (delta 145), pack-reused 2188 (from 1)\u001b[K\n","Receiving objects: 100% (2487/2487), 3.03 MiB | 6.61 MiB/s, done.\n","Resolving deltas: 100% (1509/1509), done.\n"]}],"source":["!git clone -b fix-jax-compatability https://github.com/google/deluca.git"]},{"cell_type":"code","source":["%cd deluca\n","\n","!pip install -e ."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"eBKI9_uzKNAY","executionInfo":{"status":"ok","timestamp":1748782677022,"user_tz":240,"elapsed":17659,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"2b4e075f-36d1-49de-d682-65100536fb5c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["/content/deluca\n","Obtaining file:///content/deluca\n"," Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (2.0.2)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (1.15.3)\n","Requirement already satisfied: jax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.5.2)\n","Requirement already satisfied: optax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.2.4)\n","Requirement already satisfied: flax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.10.6)\n","Collecting brax (from deluca==0.0.17)\n"," Downloading brax-0.12.3-py3-none-any.whl.metadata (20 kB)\n","Requirement already satisfied: absl-py in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.4.0)\n","Collecting dm-env (from brax->deluca==0.0.17)\n"," Downloading dm_env-1.6-py3-none-any.whl.metadata (966 bytes)\n","Requirement already satisfied: etils in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.12.2)\n","Requirement already satisfied: flask in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.1)\n","Collecting flask-cors (from brax->deluca==0.0.17)\n"," Downloading flask_cors-6.0.0-py3-none-any.whl.metadata (961 bytes)\n","Requirement already satisfied: grpcio in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.71.0)\n","Requirement already satisfied: gym in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.25.2)\n","Requirement already satisfied: jaxlib>=0.4.6 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.5.1)\n","Collecting jaxopt (from brax->deluca==0.0.17)\n"," Downloading jaxopt-0.8.5-py3-none-any.whl.metadata (3.3 kB)\n","Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.6)\n","Collecting ml-collections (from brax->deluca==0.0.17)\n"," Downloading ml_collections-1.1.0-py3-none-any.whl.metadata (22 kB)\n","Collecting mujoco (from brax->deluca==0.0.17)\n"," Downloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (44 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.4/44.4 kB\u001b[0m \u001b[31m2.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting mujoco-mjx (from brax->deluca==0.0.17)\n"," Downloading mujoco_mjx-3.3.2-py3-none-any.whl.metadata (3.4 kB)\n","Requirement already satisfied: orbax-checkpoint in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.11.13)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (11.2.1)\n","Collecting pytinyrenderer (from brax->deluca==0.0.17)\n"," Downloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (1.2 kB)\n","Collecting tensorboardx (from brax->deluca==0.0.17)\n"," Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl.metadata (5.8 kB)\n","Collecting trimesh (from brax->deluca==0.0.17)\n"," Downloading trimesh-4.6.10-py3-none-any.whl.metadata (18 kB)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (4.13.2)\n","Requirement already satisfied: ml_dtypes>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (0.4.1)\n","Requirement already satisfied: opt_einsum in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (3.4.0)\n","Requirement already satisfied: msgpack in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (1.1.0)\n","Requirement already satisfied: tensorstore in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.74)\n","Requirement already satisfied: rich>=11.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (13.9.4)\n","Requirement already satisfied: PyYAML>=5.4.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (6.0.2)\n","Requirement already satisfied: treescope>=0.1.7 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: chex>=0.1.87 in /usr/local/lib/python3.11/dist-packages (from optax->deluca==0.0.17) (0.1.89)\n","Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from chex>=0.1.87->optax->deluca==0.0.17) (0.12.1)\n","Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (3.0.0)\n","Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (2.19.1)\n","Requirement already satisfied: dm-tree in /usr/local/lib/python3.11/dist-packages (from dm-env->brax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: blinker>=1.9.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (1.9.0)\n","Requirement already satisfied: click>=8.1.3 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (8.2.1)\n","Requirement already satisfied: itsdangerous>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (2.2.0)\n","Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.0.2)\n","Requirement already satisfied: werkzeug>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.1.3)\n","Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (3.1.1)\n","Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (0.0.8)\n","Collecting glfw (from mujoco->brax->deluca==0.0.17)\n"," Downloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl.metadata (5.4 kB)\n","Requirement already satisfied: pyopengl in /usr/local/lib/python3.11/dist-packages (from mujoco->brax->deluca==0.0.17) (3.1.9)\n","Requirement already satisfied: nest_asyncio in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (1.6.0)\n","Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (5.29.4)\n","Requirement already satisfied: humanize in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (4.12.3)\n","Requirement already satisfied: simplejson>=3.16.0 in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (3.20.1)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorboardx->brax->deluca==0.0.17) (24.2)\n","Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich>=11.1->flax->deluca==0.0.17) (0.1.2)\n","Requirement already satisfied: attrs>=18.2.0 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (25.3.0)\n","Requirement already satisfied: wrapt>=1.11.2 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (1.17.2)\n","Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (2025.3.2)\n","Requirement already satisfied: importlib_resources in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (6.5.2)\n","Requirement already satisfied: zipp in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (3.21.0)\n","Downloading brax-0.12.3-py3-none-any.whl (14.2 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.2/14.2 MB\u001b[0m \u001b[31m61.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading dm_env-1.6-py3-none-any.whl (26 kB)\n","Downloading flask_cors-6.0.0-py3-none-any.whl (11 kB)\n","Downloading jaxopt-0.8.5-py3-none-any.whl (172 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m172.4/172.4 kB\u001b[0m \u001b[31m11.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading ml_collections-1.1.0-py3-none-any.whl (76 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.7/76.7 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.6 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.6/6.6 MB\u001b[0m \u001b[31m57.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco_mjx-3.3.2-py3-none-any.whl (6.7 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.7/6.7 MB\u001b[0m \u001b[31m67.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m44.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading tensorboardX-2.6.2.2-py2.py3-none-any.whl (101 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m8.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading trimesh-4.6.10-py3-none-any.whl (711 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m711.2/711.2 kB\u001b[0m \u001b[31m29.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl (243 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m243.5/243.5 kB\u001b[0m \u001b[31m16.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hInstalling collected packages: pytinyrenderer, glfw, trimesh, tensorboardx, ml-collections, dm-env, mujoco, flask-cors, mujoco-mjx, jaxopt, brax, deluca\n"," Running setup.py develop for deluca\n","Successfully installed brax-0.12.3 deluca-0.0.17 dm-env-1.6 flask-cors-6.0.0 glfw-2.9.0 jaxopt-0.8.5 ml-collections-1.1.0 mujoco-3.3.2 mujoco-mjx-3.3.2 pytinyrenderer-0.0.14 tensorboardx-2.6.2.2 trimesh-4.6.10\n"]}]},{"cell_type":"markdown","source":["This cell creates an LDS environment and plots the signal with random activations."],"metadata":{"id":"SJ_Hx9Q28jle"}},{"cell_type":"code","source":["#%load_ext autoreload\n","#%autoreload 2\n","import jax\n","import numpy as np\n","import jax.numpy as jnp\n","import matplotlib.pyplot as plt\n","\n","from deluca.core import Env\n","from deluca.core import field\n","from deluca.envs import _lds as lds\n","\n","\n","\n","env = lds.LDS() #LDS with random initiations and dimensions as specified\n","#env = lds.LDS(2,10,3) #LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","obs = env.init(d_action,d_hidden,d_obs)\n","env.show_me_the_signal(1000)\n"],"metadata":{"id":"NZgnFh7KJoCh","executionInfo":{"status":"ok","timestamp":1748782690699,"user_tz":240,"elapsed":13675,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"f78d9786-1e7e-49a9-a361-b03c76ecdb6c","colab":{"base_uri":"https://localhost:8080/","height":484}},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["the eigenvalues of our system: [ 0.9379067 0.9391432 -0.8867083 -0.88125324 0.92279553 -0.89337987\n"," -0.8875922 0.9275792 0.92987067 -0.8931594 ]\n","trajectory length = 1000\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Now I'd like to plot the signal with different activations, but instead of a build in function, i want to use agents."],"metadata":{"id":"1ryBUW4q8r9Y"}},{"cell_type":"code","source":["%load_ext autoreload\n","%autoreload 2\n","from deluca.core import Agent\n","from deluca.agents._grc import GRC\n","from deluca.agents._random import SimpleRandom\n","from deluca.agents._lqg import LQG\n","from deluca.agents._zero import Zero\n","from deluca.agents._sfc import SFC\n","\n","\n","\n","def plot_lds_with_a_given_agent(env, agent, name_of_agent, traj_length = 1000, window_size=50):\n"," obs = np.zeros(shape = (d_obs,1))\n"," action = agent(obs)\n"," losses = np.zeros(traj_length)\n"," window_losses = np.zeros(traj_length - window_size)\n","\n"," for i in range(traj_length):\n"," obs = env(action)\n"," action = agent(obs)\n"," losses[i] = obs[0,0] # first coordinate of the observation\n"," agent.update(obs,action)\n"," if i >= window_size - 1:\n"," window_losses[i-window_size] = np.mean(losses[i - window_size + 1 : i + 1])\n","\n"," plt.plot(window_losses)\n"," plt.xlabel('Time step (sliding window)')\n"," plt.ylabel('Loss')\n"," plt.title(f\"Loss of {name_of_agent} on LDS\")\n"," plt.show()\n","\n","\n","\n","env = lds.LDS() #LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","obs = env.init(d_action,d_hidden,d_obs)\n","\n","fig, axes = plt.subplots(2, 2, figsize=(12, 8))\n","axes = axes.flatten()\n","\n","agent = GRC(env.A,env.B,env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env,agent, \"GRC\")\n","\n","agent = SimpleRandom(d_action)\n","agent.init()\n","plot_lds_with_a_given_agent(env,agent, \"Random agent\")\n","\n","agent = Zero(d_action)\n","agent.init(d_action)\n","plot_lds_with_a_given_agent(env,agent, \"Zero agent\")\n","\n","agent = SFC(env.A,env.B,env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env,agent, \"SFC\")\n","\n"],"metadata":{"id":"c5XvfPmAq7Li","colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"status":"error","timestamp":1748785108362,"user_tz":240,"elapsed":7315,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"7c1c9ad8-04fa-4fe5-9283-b5d6cfd49e8c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stderr","text":["[autoreload of deluca.agents._random failed: Traceback (most recent call last):\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 245, in check\n"," superreload(m, reload, self.old_objects)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 410, in superreload\n"," update_generic(old_obj, new_obj)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 347, in update_generic\n"," update(a, b)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 302, in update_class\n"," if update_generic(old_obj, new_obj): continue\n"," ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 347, in update_generic\n"," update(a, b)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 266, in update_function\n"," setattr(old, name, getattr(new, name))\n","ValueError: __setattr__() requires a code object with 0 free vars, not 2\n","]\n","[autoreload of deluca.agents._zero failed: Traceback (most recent call last):\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 245, in check\n"," superreload(m, reload, self.old_objects)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 410, in superreload\n"," update_generic(old_obj, new_obj)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 347, in update_generic\n"," update(a, b)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 302, in update_class\n"," if update_generic(old_obj, new_obj): continue\n"," ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 347, in update_generic\n"," update(a, b)\n"," File \"/usr/local/lib/python3.11/dist-packages/IPython/extensions/autoreload.py\", line 266, in update_function\n"," setattr(old, name, getattr(new, name))\n","ValueError: __setattr__() requires a code object with 0 free vars, not 2\n","]\n"]},{"output_type":"stream","name":"stdout","text":["The autoreload extension is already loaded. To reload it, use:\n"," %reload_ext autoreload\n","the eigenvalues of our system: [ 0.9379067 0.9391432 -0.8867083 -0.88125324 0.92279553 -0.89337987\n"," -0.8875922 0.9275792 0.92987067 -0.8931594 ]\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}},{"output_type":"error","ename":"NameError","evalue":"name 'subkey1' is not defined","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)","\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[0mplot_lds_with_a_given_agent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0magent\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Zero agent\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 52\u001b[0;31m \u001b[0magent\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSFC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mC\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 53\u001b[0m \u001b[0magent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0mplot_lds_with_a_given_agent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0magent\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"SFC\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/content/deluca/deluca/agents/_sfc.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, A, B, C, cost_fn, R_M, gamma, key, init_scale, h, m, lr, decay)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[0msubkey_1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubkey2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 89\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mM\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minit_scale\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubkey1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 90\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mM_0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minit_scale\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mjax\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubkey2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mNameError\u001b[0m: name 'subkey1' is not defined"]}]},{"cell_type":"code","source":["# prompt: I want the same cell as above, but plot the figures side by side\n","%load_ext autoreload\n","%autoreload 2\n","from deluca.core import Agent\n","from deluca.agents._grc import GRC\n","from deluca.agents._random import SimpleRandom\n","from deluca.agents._lqg import LQG\n","from deluca.agents._zero import Zero\n","from deluca.agents._sfc import SFC\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","def plot_lds_with_a_given_agent(env, agent, name_of_agent, traj_length=1000, window_size=50, ax=None):\n"," obs = np.zeros(shape=(d_obs, 1))\n"," action = agent(obs)\n"," losses = np.zeros(traj_length)\n"," window_losses = np.zeros(traj_length - window_size)\n","\n"," for i in range(traj_length):\n"," obs = env(action)\n"," action = agent(obs)\n"," losses[i] = obs[0, 0] # first coordinate of the observation\n"," agent.update(obs, action)\n"," if i >= window_size - 1:\n"," window_losses[i - window_size] = np.mean(losses[i - window_size + 1: i + 1])\n","\n"," ax.plot(window_losses)\n"," ax.set_xlabel('Time step (sliding window)')\n"," ax.set_ylabel('Loss')\n"," ax.set_title(f\"Loss of {name_of_agent} on LDS\")\n","\n","\n","env = lds.LDS() # LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","obs = env.init(d_action, d_hidden, d_obs)\n","\n","fig, axes = plt.subplots(2, 2, figsize=(12, 8))\n","axes = axes.flatten()\n","\n","agent = GRC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"GRC\", ax=axes[0])\n","\n","agent = SimpleRandom(d_action)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"Random agent\", ax=axes[1])\n","\n","agent = Zero(d_action)\n","agent.init(d_action)\n","plot_lds_with_a_given_agent(env, agent, \"Zero agent\", ax=axes[2])\n","\n","#agent = SFC(env.A, env.B, env.C)\n","#agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"SFC\", ax=axes[3])\n","\n","plt.tight_layout()\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":702},"id":"3VhZKqj6nOaN","executionInfo":{"status":"ok","timestamp":1748785326327,"user_tz":240,"elapsed":6794,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"17bb5f13-54bc-45f5-da82-f0aa85a6a0ca"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["The autoreload extension is already loaded. To reload it, use:\n"," %reload_ext autoreload\n","the eigenvalues of our system: [ 0.9379067 0.9391432 -0.8867083 -0.88125324 0.92279553 -0.89337987\n"," -0.8875922 0.9275792 0.92987067 -0.8931594 ]\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":[],"metadata":{"id":"xQIAC7kzuDsk"},"execution_count":null,"outputs":[]}]} \ No newline at end of file diff --git a/deluca/envs/_lds.py b/deluca/envs/_lds.py index 152fa11..399b415 100644 --- a/deluca/envs/_lds.py +++ b/deluca/envs/_lds.py @@ -40,6 +40,16 @@ def __call__(self, t, key): del t return jax.random.normal(key, (self.d, 1)) * self.std +class SinusDisturbance(Disturbance): + def init(self, d, amplitude=0.5): + self.d = d + self.amplitude = amplitude + key = jax.random.PRNGKey(0) + self.phases = jax.random.normal(key, (self.d, 1)) + + def __call__(self, t, key): + return (jax.numpy.sin( t * self.phases )) * self.amplitude + class LDS(Env): """LDS.""" @@ -56,9 +66,9 @@ def init(self, d_in = 1, d_hidden = 25, d_out = 1, A = None, B = None, C = None, self.t = 0 if disturbance is None: self.disturbance = GaussianDisturbance() - self.disturbance.init(self.d) else: self.disturbance = disturbance + self.disturbance.init(self.d) self.key = key def __call__(self, u, key = None): From 8bfea8ab5ffd9166eed1eae584d2e3ab11e5444d Mon Sep 17 00:00:00 2001 From: eladhazan Date: Wed, 4 Jun 2025 20:16:09 +0000 Subject: [PATCH 20/27] added the main agents to external --- deluca/agents/__init__.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/deluca/agents/__init__.py b/deluca/agents/__init__.py index 227b5b7..6c10b49 100644 --- a/deluca/agents/__init__.py +++ b/deluca/agents/__init__.py @@ -15,6 +15,10 @@ from deluca.agents._bang_bang import BangBang from deluca.agents._pid import PID from deluca.agents._random import Random +from deluca.agents._random import SimpleRandom from deluca.agents._zero import Zero +from deluca.agents._grc import GRC +from deluca.agents._sfc import SFC +from deluca.agents._lqg import LQG -__all__ = ["BangBang", "PID", "Random", "Zero"] +__all__ = ["BangBang", "PID", "Random", "SimpleRandom", "Zero", "GRC", "SFC", "LQG"] From ae6ea6834640d2a9539ed2c6c8b6d8c60971c3c6 Mon Sep 17 00:00:00 2001 From: eladhazan Date: Wed, 4 Jun 2025 20:43:11 +0000 Subject: [PATCH 21/27] added default params to LQG and empty update function --- deluca/agents/_lqg.py | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/deluca/agents/_lqg.py b/deluca/agents/_lqg.py index 1b35ea9..32309a6 100644 --- a/deluca/agents/_lqg.py +++ b/deluca/agents/_lqg.py @@ -30,10 +30,10 @@ def __init__( A: jnp.ndarray, B: jnp.ndarray, C: jnp.ndarray, - Q: jnp.ndarray, - R: jnp.ndarray, - W: jnp.ndarray, - V: jnp.ndarray + Q: jnp.ndarray = None, + R: jnp.ndarray = None, + W: jnp.ndarray = None, + V: jnp.ndarray = None ) -> None: """ Description: Initialize the dynamics of the model. @@ -50,7 +50,16 @@ def __init__( self.A, self.B, self.C = A, B, C # System Dynamics self.d, self.n, self.p = self.A.shape[0], self.B.shape[1], self.C.shape[0] # State, Action, Observation Dimensions - + + if Q is None: + Q = jax.numpy.identity(self.d) + if R is None: + R = jax.numpy.identity(self.n) + if W is None: + W = jax.numpy.identity(self.d) + if V is None: + V = jax.numpy.identity(self.p) + self.P = jnp.array(solve_discrete_are(np.asarray(A), np.asarray(B), np.asarray(Q), np.asarray(R))) self.K = jnp.linalg.inv(self.B.T @ self.P @ self.B + R) @ (self.B.T @ self.P @ self.A) Sigma = jnp.array(solve_discrete_are(np.asarray(A).T, np.asarray(C).T, np.asarray(W), np.asarray(V))) @@ -73,3 +82,7 @@ def __call__(self, y: jnp.ndarray) -> jnp.ndarray: residual = y - self.C @ self.x_hat self.x_hat = self.A @ self.x_hat + self.B @ u + self.L @ residual return u + + + def update(self, y: jnp.ndarray, u: jnp.ndarray) -> None: + return None From e97072818be38abd85cfc3ee367fcd29714ae056 Mon Sep 17 00:00:00 2001 From: eladhazan Date: Wed, 4 Jun 2025 21:28:09 +0000 Subject: [PATCH 22/27] fixed random calls in DRC --- deluca/agents/_drc.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/deluca/agents/_drc.py b/deluca/agents/_drc.py index 0d0b5a7..5cf37fb 100644 --- a/deluca/agents/_drc.py +++ b/deluca/agents/_drc.py @@ -21,8 +21,8 @@ from jax import grad from jax import jit -from deluca.agents.core import Agent -from deluca.utils import Random +from deluca.core import Agent +#from deluca.utils import Random def quad_loss(x: jnp.ndarray, u: jnp.ndarray) -> Real: @@ -75,8 +75,9 @@ def __init__( cost_fn = cost_fn or quad_loss - self.random = Random(seed) - +# self.random = Random(seed) + key = jax.random.PRNGKey(0) + d_state, d_action = B.shape # State & Action Dimensions C = jnp.identity(d_state) if C is None else C @@ -102,9 +103,7 @@ def __init__( # initial linear policy / perturbation contributions / bias self.K = K if K is not None else jnp.zeros((d_action, d_obs)) - self.M = lr_scale * jax.random.normal( - self.random.generate_key(), shape=(m, d_action, d_obs) - ) + self.M = lr_scale * jax.random.normal(key, shape=(m, d_action, d_obs)) # Past m nature y's such that y_nat[0] is the most recent self.y_nat = jnp.zeros((m, d_obs, 1)) From e352d4f38638fa045db2b33d9e10fafb3f58bddc Mon Sep 17 00:00:00 2001 From: Elad Hazan Date: Wed, 4 Jun 2025 17:30:52 -0400 Subject: [PATCH 23/27] Add files via upload --- colabs/test_agents_on_lds.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/colabs/test_agents_on_lds.ipynb b/colabs/test_agents_on_lds.ipynb index 96db5f0..aaac29f 100644 --- a/colabs/test_agents_on_lds.ipynb +++ b/colabs/test_agents_on_lds.ipynb @@ -1 +1 @@ -{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1ZArDMR7PAiWBecPgHCikbKXN_V7j7SJ2","timestamp":1748725042432}]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XOcLsTo1vS5A","executionInfo":{"status":"ok","timestamp":1749067051752,"user_tz":240,"elapsed":1574,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"169dbb7c-5ae6-4115-c8a0-83c6bb7d216c"},"outputs":[{"output_type":"stream","name":"stdout","text":["Cloning into 'deluca'...\n","remote: Enumerating objects: 2604, done.\u001b[K\n","remote: Counting objects: 100% (307/307), done.\u001b[K\n","remote: Compressing objects: 100% (138/138), done.\u001b[K\n","remote: Total 2604 (delta 249), reused 187 (delta 169), pack-reused 2297 (from 2)\u001b[K\n","Receiving objects: 100% (2604/2604), 3.23 MiB | 5.83 MiB/s, done.\n","Resolving deltas: 100% (1590/1590), done.\n"]}],"source":["!git clone https://github.com/google/deluca.git"]},{"cell_type":"code","source":["%cd deluca\n","\n","!pip install -e ."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"eBKI9_uzKNAY","executionInfo":{"status":"ok","timestamp":1749067077217,"user_tz":240,"elapsed":24342,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"1fcca168-7763-4c86-d4e0-9048e86c7554"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["/content/deluca\n","Obtaining file:///content/deluca\n"," Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (2.0.2)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (1.15.3)\n","Requirement already satisfied: jax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.5.2)\n","Requirement already satisfied: optax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.2.4)\n","Requirement already satisfied: flax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.10.6)\n","Collecting brax (from deluca==0.0.17)\n"," Downloading brax-0.12.3-py3-none-any.whl.metadata (20 kB)\n","Requirement already satisfied: absl-py in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.4.0)\n","Collecting dm-env (from brax->deluca==0.0.17)\n"," Downloading dm_env-1.6-py3-none-any.whl.metadata (966 bytes)\n","Requirement already satisfied: etils in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.12.2)\n","Requirement already satisfied: flask in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.1)\n","Collecting flask-cors (from brax->deluca==0.0.17)\n"," Downloading flask_cors-6.0.0-py3-none-any.whl.metadata (961 bytes)\n","Requirement already satisfied: grpcio in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.71.0)\n","Requirement already satisfied: gym in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.25.2)\n","Requirement already satisfied: jaxlib>=0.4.6 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.5.1)\n","Collecting jaxopt (from brax->deluca==0.0.17)\n"," Downloading jaxopt-0.8.5-py3-none-any.whl.metadata (3.3 kB)\n","Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.6)\n","Collecting ml-collections (from brax->deluca==0.0.17)\n"," Downloading ml_collections-1.1.0-py3-none-any.whl.metadata (22 kB)\n","Collecting mujoco (from brax->deluca==0.0.17)\n"," Downloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (44 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.4/44.4 kB\u001b[0m \u001b[31m476.9 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting mujoco-mjx (from brax->deluca==0.0.17)\n"," Downloading mujoco_mjx-3.3.2-py3-none-any.whl.metadata (3.4 kB)\n","Requirement already satisfied: orbax-checkpoint in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.11.13)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (11.2.1)\n","Collecting pytinyrenderer (from brax->deluca==0.0.17)\n"," Downloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (1.2 kB)\n","Collecting tensorboardx (from brax->deluca==0.0.17)\n"," Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl.metadata (5.8 kB)\n","Collecting trimesh (from brax->deluca==0.0.17)\n"," Downloading trimesh-4.6.10-py3-none-any.whl.metadata (18 kB)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (4.13.2)\n","Requirement already satisfied: ml_dtypes>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (0.4.1)\n","Requirement already satisfied: opt_einsum in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (3.4.0)\n","Requirement already satisfied: msgpack in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (1.1.0)\n","Requirement already satisfied: tensorstore in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.74)\n","Requirement already satisfied: rich>=11.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (13.9.4)\n","Requirement already satisfied: PyYAML>=5.4.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (6.0.2)\n","Requirement already satisfied: treescope>=0.1.7 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: chex>=0.1.87 in /usr/local/lib/python3.11/dist-packages (from optax->deluca==0.0.17) (0.1.89)\n","Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from chex>=0.1.87->optax->deluca==0.0.17) (0.12.1)\n","Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (3.0.0)\n","Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (2.19.1)\n","Requirement already satisfied: dm-tree in /usr/local/lib/python3.11/dist-packages (from dm-env->brax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: blinker>=1.9.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (1.9.0)\n","Requirement already satisfied: click>=8.1.3 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (8.2.1)\n","Requirement already satisfied: itsdangerous>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (2.2.0)\n","Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.0.2)\n","Requirement already satisfied: werkzeug>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.1.3)\n","Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (3.1.1)\n","Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (0.0.8)\n","Collecting glfw (from mujoco->brax->deluca==0.0.17)\n"," Downloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl.metadata (5.4 kB)\n","Requirement already satisfied: pyopengl in /usr/local/lib/python3.11/dist-packages (from mujoco->brax->deluca==0.0.17) (3.1.9)\n","Requirement already satisfied: nest_asyncio in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (1.6.0)\n","Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (5.29.5)\n","Requirement already satisfied: humanize in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (4.12.3)\n","Requirement already satisfied: simplejson>=3.16.0 in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (3.20.1)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorboardx->brax->deluca==0.0.17) (24.2)\n","Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich>=11.1->flax->deluca==0.0.17) (0.1.2)\n","Requirement already satisfied: attrs>=18.2.0 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (25.3.0)\n","Requirement already satisfied: wrapt>=1.11.2 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (1.17.2)\n","Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (2025.3.2)\n","Requirement already satisfied: importlib_resources in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (6.5.2)\n","Requirement already satisfied: zipp in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (3.22.0)\n","Downloading brax-0.12.3-py3-none-any.whl (14.2 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.2/14.2 MB\u001b[0m \u001b[31m57.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading dm_env-1.6-py3-none-any.whl (26 kB)\n","Downloading flask_cors-6.0.0-py3-none-any.whl (11 kB)\n","Downloading jaxopt-0.8.5-py3-none-any.whl (172 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m172.4/172.4 kB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading ml_collections-1.1.0-py3-none-any.whl (76 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.7/76.7 kB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.6 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.6/6.6 MB\u001b[0m \u001b[31m68.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco_mjx-3.3.2-py3-none-any.whl (6.7 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.7/6.7 MB\u001b[0m \u001b[31m70.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m46.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading tensorboardX-2.6.2.2-py2.py3-none-any.whl (101 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading trimesh-4.6.10-py3-none-any.whl (711 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m711.2/711.2 kB\u001b[0m \u001b[31m27.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl (243 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m243.5/243.5 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hInstalling collected packages: pytinyrenderer, glfw, trimesh, tensorboardx, ml-collections, dm-env, mujoco, flask-cors, mujoco-mjx, jaxopt, brax, deluca\n"," Running setup.py develop for deluca\n","Successfully installed brax-0.12.3 deluca-0.0.17 dm-env-1.6 flask-cors-6.0.0 glfw-2.9.0 jaxopt-0.8.5 ml-collections-1.1.0 mujoco-3.3.2 mujoco-mjx-3.3.2 pytinyrenderer-0.0.14 tensorboardx-2.6.2.2 trimesh-4.6.10\n"]}]},{"cell_type":"markdown","source":["#This cell creates an LDS environment and plots the signal with random activations."],"metadata":{"id":"SJ_Hx9Q28jle"}},{"cell_type":"code","source":["%load_ext autoreload\n","%autoreload 2\n","import jax\n","import numpy as np\n","import jax.numpy as jnp\n","import matplotlib.pyplot as plt\n","\n","from deluca.core import Env\n","from deluca.core import field\n","from deluca.envs import _lds as lds\n","from deluca.envs._lds import SinusDisturbance\n","\n","\n","\n","env = lds.LDS() #LDS with random initiations and dimensions as specified\n","#env = lds.LDS(2,10,3) #LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","disturbance = SinusDisturbance()\n","disturbance.init(d_hidden, 0.5)\n","obs = env.init(d_action,d_hidden,d_obs, disturbance = disturbance)\n","env.show_me_the_signal(1000)"],"metadata":{"id":"NZgnFh7KJoCh","executionInfo":{"status":"ok","timestamp":1749067109519,"user_tz":240,"elapsed":11210,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"6b8316bf-f2dc-42de-e402-795e536b693f","colab":{"base_uri":"https://localhost:8080/","height":448}},"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["trajectory length = 1000\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Now I'd like to plot the signal with different activations, but instead of a build in function, i want to use agents."],"metadata":{"id":"1ryBUW4q8r9Y"}},{"cell_type":"code","source":["# prompt: I want the same cell as above, but plot the figures side by side\n","%load_ext autoreload\n","%autoreload 2\n","from deluca.core import Agent\n","from deluca.agents._grc import GRC\n","from deluca.agents._random import SimpleRandom\n","from deluca.agents._lqg import LQG\n","from deluca.agents._zero import Zero\n","from deluca.agents._sfc import SFC\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","def plot_lds_with_a_given_agent(env, agent, name_of_agent, traj_length=1000, window_size=50, ax=None):\n"," obs = np.zeros(shape=(d_obs, 1))\n"," action = agent(obs)\n"," losses = np.zeros(traj_length)\n"," window_losses = np.zeros(traj_length - window_size)\n","\n"," for i in range(traj_length):\n"," obs = env(action)\n"," action = agent(obs)\n"," losses[i] = np.linalg.norm(obs) + np.linalg.norm(action) # simple quadratic loss\n"," agent.update(obs, action)\n"," if i >= window_size - 1:\n"," window_losses[i - window_size] = np.mean(losses[i - window_size + 1: i + 1])\n","\n"," ax.plot(window_losses)\n"," ax.set_xlabel('Time step (sliding window)')\n"," ax.set_ylabel('Loss')\n"," ax.set_title(f\"Loss of {name_of_agent} on LDS\")\n","\n","\n","env = lds.LDS() # LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","disturbance = SinusDisturbance()\n","disturbance.init(d_hidden, 0.5)\n","obs = env.init(d_action,d_hidden,d_obs, disturbance = disturbance)\n","\n","fig, axes = plt.subplots(2, 2, figsize=(12, 8))\n","axes = axes.flatten()\n","\n","agent = GRC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"GRC\", ax=axes[0])\n","\n","agent = SimpleRandom(d_action)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"Random agent\", ax=axes[1])\n","\n","agent = Zero(d_action)\n","agent.init(d_action)\n","plot_lds_with_a_given_agent(env, agent, \"Zero agent\", ax=axes[2])\n","\n","agent = SFC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"SFC\", ax=axes[3])\n","\n","plt.tight_layout()\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"3VhZKqj6nOaN","outputId":"0bdf0bd2-cb8f-4cd3-de9a-db8df3c9d8cb"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["The autoreload extension is already loaded. To reload it, use:\n"," %reload_ext autoreload\n"]}]},{"cell_type":"code","source":[],"metadata":{"id":"xQIAC7kzuDsk"},"execution_count":null,"outputs":[]}]} \ No newline at end of file +{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1ZArDMR7PAiWBecPgHCikbKXN_V7j7SJ2","timestamp":1748725042432}]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XOcLsTo1vS5A","executionInfo":{"status":"ok","timestamp":1749067051752,"user_tz":240,"elapsed":1574,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"169dbb7c-5ae6-4115-c8a0-83c6bb7d216c"},"outputs":[{"output_type":"stream","name":"stdout","text":["Cloning into 'deluca'...\n","remote: Enumerating objects: 2604, done.\u001b[K\n","remote: Counting objects: 100% (307/307), done.\u001b[K\n","remote: Compressing objects: 100% (138/138), done.\u001b[K\n","remote: Total 2604 (delta 249), reused 187 (delta 169), pack-reused 2297 (from 2)\u001b[K\n","Receiving objects: 100% (2604/2604), 3.23 MiB | 5.83 MiB/s, done.\n","Resolving deltas: 100% (1590/1590), done.\n"]}],"source":["!git clone https://github.com/google/deluca.git"]},{"cell_type":"code","source":["%cd deluca\n","\n","!pip install -e ."],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"eBKI9_uzKNAY","executionInfo":{"status":"ok","timestamp":1749067077217,"user_tz":240,"elapsed":24342,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"1fcca168-7763-4c86-d4e0-9048e86c7554"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["/content/deluca\n","Obtaining file:///content/deluca\n"," Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (2.0.2)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (1.15.3)\n","Requirement already satisfied: jax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.5.2)\n","Requirement already satisfied: optax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.2.4)\n","Requirement already satisfied: flax in /usr/local/lib/python3.11/dist-packages (from deluca==0.0.17) (0.10.6)\n","Collecting brax (from deluca==0.0.17)\n"," Downloading brax-0.12.3-py3-none-any.whl.metadata (20 kB)\n","Requirement already satisfied: absl-py in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.4.0)\n","Collecting dm-env (from brax->deluca==0.0.17)\n"," Downloading dm_env-1.6-py3-none-any.whl.metadata (966 bytes)\n","Requirement already satisfied: etils in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.12.2)\n","Requirement already satisfied: flask in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.1)\n","Collecting flask-cors (from brax->deluca==0.0.17)\n"," Downloading flask_cors-6.0.0-py3-none-any.whl.metadata (961 bytes)\n","Requirement already satisfied: grpcio in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (1.71.0)\n","Requirement already satisfied: gym in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.25.2)\n","Requirement already satisfied: jaxlib>=0.4.6 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.5.1)\n","Collecting jaxopt (from brax->deluca==0.0.17)\n"," Downloading jaxopt-0.8.5-py3-none-any.whl.metadata (3.3 kB)\n","Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (3.1.6)\n","Collecting ml-collections (from brax->deluca==0.0.17)\n"," Downloading ml_collections-1.1.0-py3-none-any.whl.metadata (22 kB)\n","Collecting mujoco (from brax->deluca==0.0.17)\n"," Downloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (44 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.4/44.4 kB\u001b[0m \u001b[31m476.9 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hCollecting mujoco-mjx (from brax->deluca==0.0.17)\n"," Downloading mujoco_mjx-3.3.2-py3-none-any.whl.metadata (3.4 kB)\n","Requirement already satisfied: orbax-checkpoint in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (0.11.13)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (11.2.1)\n","Collecting pytinyrenderer (from brax->deluca==0.0.17)\n"," Downloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (1.2 kB)\n","Collecting tensorboardx (from brax->deluca==0.0.17)\n"," Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl.metadata (5.8 kB)\n","Collecting trimesh (from brax->deluca==0.0.17)\n"," Downloading trimesh-4.6.10-py3-none-any.whl.metadata (18 kB)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from brax->deluca==0.0.17) (4.13.2)\n","Requirement already satisfied: ml_dtypes>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (0.4.1)\n","Requirement already satisfied: opt_einsum in /usr/local/lib/python3.11/dist-packages (from jax->deluca==0.0.17) (3.4.0)\n","Requirement already satisfied: msgpack in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (1.1.0)\n","Requirement already satisfied: tensorstore in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.74)\n","Requirement already satisfied: rich>=11.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (13.9.4)\n","Requirement already satisfied: PyYAML>=5.4.1 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (6.0.2)\n","Requirement already satisfied: treescope>=0.1.7 in /usr/local/lib/python3.11/dist-packages (from flax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: chex>=0.1.87 in /usr/local/lib/python3.11/dist-packages (from optax->deluca==0.0.17) (0.1.89)\n","Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from chex>=0.1.87->optax->deluca==0.0.17) (0.12.1)\n","Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (3.0.0)\n","Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax->deluca==0.0.17) (2.19.1)\n","Requirement already satisfied: dm-tree in /usr/local/lib/python3.11/dist-packages (from dm-env->brax->deluca==0.0.17) (0.1.9)\n","Requirement already satisfied: blinker>=1.9.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (1.9.0)\n","Requirement already satisfied: click>=8.1.3 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (8.2.1)\n","Requirement already satisfied: itsdangerous>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (2.2.0)\n","Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.0.2)\n","Requirement already satisfied: werkzeug>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from flask->brax->deluca==0.0.17) (3.1.3)\n","Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (3.1.1)\n","Requirement already satisfied: gym-notices>=0.0.4 in /usr/local/lib/python3.11/dist-packages (from gym->brax->deluca==0.0.17) (0.0.8)\n","Collecting glfw (from mujoco->brax->deluca==0.0.17)\n"," Downloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl.metadata (5.4 kB)\n","Requirement already satisfied: pyopengl in /usr/local/lib/python3.11/dist-packages (from mujoco->brax->deluca==0.0.17) (3.1.9)\n","Requirement already satisfied: nest_asyncio in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (1.6.0)\n","Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (5.29.5)\n","Requirement already satisfied: humanize in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (4.12.3)\n","Requirement already satisfied: simplejson>=3.16.0 in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->brax->deluca==0.0.17) (3.20.1)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorboardx->brax->deluca==0.0.17) (24.2)\n","Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich>=11.1->flax->deluca==0.0.17) (0.1.2)\n","Requirement already satisfied: attrs>=18.2.0 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (25.3.0)\n","Requirement already satisfied: wrapt>=1.11.2 in /usr/local/lib/python3.11/dist-packages (from dm-tree->dm-env->brax->deluca==0.0.17) (1.17.2)\n","Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (2025.3.2)\n","Requirement already satisfied: importlib_resources in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (6.5.2)\n","Requirement already satisfied: zipp in /usr/local/lib/python3.11/dist-packages (from etils->brax->deluca==0.0.17) (3.22.0)\n","Downloading brax-0.12.3-py3-none-any.whl (14.2 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.2/14.2 MB\u001b[0m \u001b[31m57.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading dm_env-1.6-py3-none-any.whl (26 kB)\n","Downloading flask_cors-6.0.0-py3-none-any.whl (11 kB)\n","Downloading jaxopt-0.8.5-py3-none-any.whl (172 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m172.4/172.4 kB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading ml_collections-1.1.0-py3-none-any.whl (76 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.7/76.7 kB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (6.6 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.6/6.6 MB\u001b[0m \u001b[31m68.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading mujoco_mjx-3.3.2-py3-none-any.whl (6.7 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.7/6.7 MB\u001b[0m \u001b[31m70.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading pytinyrenderer-0.0.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9 MB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m46.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading tensorboardX-2.6.2.2-py2.py3-none-any.whl (101 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading trimesh-4.6.10-py3-none-any.whl (711 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m711.2/711.2 kB\u001b[0m \u001b[31m27.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hDownloading glfw-2.9.0-py2.py27.py3.py30.py31.py32.py33.py34.py35.py36.py37.py38.p39.p310.p311.p312.p313-none-manylinux_2_28_x86_64.whl (243 kB)\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m243.5/243.5 kB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hInstalling collected packages: pytinyrenderer, glfw, trimesh, tensorboardx, ml-collections, dm-env, mujoco, flask-cors, mujoco-mjx, jaxopt, brax, deluca\n"," Running setup.py develop for deluca\n","Successfully installed brax-0.12.3 deluca-0.0.17 dm-env-1.6 flask-cors-6.0.0 glfw-2.9.0 jaxopt-0.8.5 ml-collections-1.1.0 mujoco-3.3.2 mujoco-mjx-3.3.2 pytinyrenderer-0.0.14 tensorboardx-2.6.2.2 trimesh-4.6.10\n"]}]},{"cell_type":"markdown","source":["#This cell creates an LDS environment and plots the signal with random activations."],"metadata":{"id":"SJ_Hx9Q28jle"}},{"cell_type":"code","source":["%load_ext autoreload\n","%autoreload 2\n","import jax\n","import numpy as np\n","import jax.numpy as jnp\n","import matplotlib.pyplot as plt\n","\n","from deluca.core import Env\n","from deluca.core import field\n","from deluca.envs import _lds as lds\n","from deluca.envs._lds import SinusDisturbance\n","\n","\n","\n","env = lds.LDS() #LDS with random initiations and dimensions as specified\n","#env = lds.LDS(2,10,3) #LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","disturbance = SinusDisturbance()\n","disturbance.init(d_hidden, 0.5)\n","obs = env.init(d_action,d_hidden,d_obs, disturbance = disturbance)\n","env.show_me_the_signal(1000)"],"metadata":{"id":"NZgnFh7KJoCh","executionInfo":{"status":"ok","timestamp":1749067109519,"user_tz":240,"elapsed":11210,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"6b8316bf-f2dc-42de-e402-795e536b693f","colab":{"base_uri":"https://localhost:8080/","height":448}},"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["trajectory length = 1000\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAjMAAAGdCAYAAADnrPLBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAvpJJREFUeJztnXecHVX5/z9z792aZHfTNyEJaUAgQAgtBEKTSFVAsYCoNEE0qBAUiAIq/jAIiIpfBAvFAoJ8v4CAGgy9JQECAQIkEEgjySakbMludveW+f1x75l55syZdmdu233er9e+9pa5M2dmzpzznKdquq7rYBiGYRiGqVBipW4AwzAMwzBMGFiYYRiGYRimomFhhmEYhmGYioaFGYZhGIZhKhoWZhiGYRiGqWhYmGEYhmEYpqJhYYZhGIZhmIqGhRmGYRiGYSqaRKkbUAwymQw2btyIQYMGQdO0UjeHYRiGYRgf6LqOjo4OjB49GrGYs/6lXwgzGzduxNixY0vdDIZhGIZh8mD9+vUYM2aM4/f9QpgZNGgQgOzFaGhoKHFrGIZhGIbxQ3t7O8aOHWvM4070C2FGmJYaGhpYmGEYhmGYCsPLRYQdgBmGYRiGqWhYmGEYhmEYpqJhYYZhGIZhmIqGhRmGYRiGYSoaFmYYhmEYhqloWJhhGIZhGKaiYWGGYRiGYZiKhoUZhmEYhmEqGhZmGIZhGIapaFiYYRiGYRimomFhhmEYhmGYioaFGYZhGIZhKhoWZhiGKTiPv7URz7//SambwTBMH6VfVM1mGKZ0bNvZg0vuewMA8Mz3j8GEYQNK3CKGYfoarJlhGKagtO1KGq9f+IC1MwzDRA8LMwzDFJSeVMZ8ncy4bMkwDJMfLMwwDFNQqDDTm2ZhhmGY6GFhhmGYgtKTTBuve1MszDAMEz0szDAMU1CoZibJmhmGYQoACzMMwxSUbqKZYWGGYZhCwMIMwzAFxaqZ0UvYEoZh+ioszDAMU1As0UzsM8MwTAFgYYZhmILSk2IzE8MwhYWFGYZhCgrNLcPCDMMwhYCFGYZhCgpHMzEMU2hYmGEYpqBQM1Nvih2AGYaJHhZmGIYpKJwBmGGYQsPCDMMwBcXiM8PRTAzDFAAWZhiGKSgczcQwTKFhYYZhmILCDsAMwxQaFmYYhikotJwBJ81jGKYQsDDDMExBYc0MwzCFpqDCzPPPP4/PfvazGD16NDRNwyOPPGL5Xtd1XHvttRg1ahTq6uowe/ZsfPDBB5Zttm/fjrPPPhsNDQ1oamrCBRdcgJ07dxay2QzDRAiXM2AYptAUVJjp7OzEtGnTcNtttym/v/HGG3HrrbfijjvuwJIlSzBgwACccMIJ6O7uNrY5++yz8c4772DhwoV4/PHH8fzzz+Oiiy4qZLMZhomQHmJm2razF7rOuWYYhomWRCF3ftJJJ+Gkk05SfqfrOn7961/j6quvxmmnnQYA+Mtf/oKRI0fikUcewZlnnon33nsPCxYswKuvvoqDDz4YAPDb3/4WJ598Mm6++WaMHj26kM1nGCYCqDZmVzKN1q4kBg+oLmGLGIbpa5TMZ2b16tVoaWnB7Nmzjc8aGxsxY8YMLFq0CACwaNEiNDU1GYIMAMyePRuxWAxLlixx3HdPTw/a29stfwzDlAbZtLSxbVeJWsIwTF+lZMJMS0sLAGDkyJGWz0eOHGl819LSghEjRli+TyQSGDJkiLGNivnz56OxsdH4Gzt2bMStZxjGLzTPDABsau122JJhGCY/+mQ007x589DW1mb8rV+/vtRNYph+i8gAPKA6DgDoSqbdNmcYhglMyYSZ5uZmAMDmzZstn2/evNn4rrm5GVu2bLF8n0qlsH37dmMbFTU1NWhoaLD8MQxTGoSZaVBtFQCglyOaGIaJmJIJMxMmTEBzczOeeuop47P29nYsWbIEM2fOBADMnDkTra2tWLp0qbHN008/jUwmgxkzZhS9zQzDBEeYmQbWZuMNWJhhGCZqChrNtHPnTqxatcp4v3r1aixbtgxDhgzBuHHjcOmll+L//b//hz322AMTJkzANddcg9GjR+P0008HAOy999448cQTceGFF+KOO+5AMpnEJZdcgjPPPJMjmRimQjA1M9nhhhPnMQwTNQUVZl577TUce+yxxvu5c+cCAM455xzcc889uOKKK9DZ2YmLLroIra2tmDVrFhYsWIDa2lrjN/feey8uueQSHHfccYjFYjjjjDNw6623FrLZDMNERCajG5oYNjMxDFMoCirMHHPMMa4JsjRNw3XXXYfrrrvOcZshQ4bgvvvuK0TzGIYpML1ECzOoJmH7jGEYJgr6ZDQTwzDlgYhkAkwzE2tmGIaJGhZmGIYpGML5N6YBdbnQbNbMMAwTNSzMMAxTMITzb00ijupEdrhhzQzDMFHDwgzDMAVDaGZqqmKoibMwwzBMYWBhhmGYgtDa1YvX17YCAGoSMUMzw6HZDMNETUGjmRiGiY5rHlmOqngM1352n1I3xRfH/fI5bOvsBQDUVsVRxZoZhmEKBGtmGKYC2NLRjb8uXou7XlqNzp5UqZvjCyHIAFbNTA9rZhiGiRgWZhimAkilzXxNzpmbyhfqAJxkzQzDMBHDwgzDVACVKMBQqhMx08zEmhmGYSKGhRmGYSInk7GKX2993IoaDs1mGKZAsDDDMBWGW4mQcmFXMm15n0zrqGYHYIZhCgQLMwxTAVABJlP+sgw6e+1OyomcMJOshBNgGKaiYGGGYSqNCpAFdvWmbZ/lZBmbCYphGCYsLMwwTIWRqQAzU2ePVZj56mHjEI9lh5s0CzMMw0QMCzMMUwFQ+aUShJkuycz0k89ORVzTALAwwzBM9LAwwzAVRiWIAl3EzHTZ7D2RiMcQj+WEmQoQxhiGqSxYmGGYCiBjcQAuf2EglclGLO09qgHfm70HAJjCDGtmGIaJGBZmGKYCoPN/BcgyRsbi2ipziBEOwCzMMAwTNSzMMEwFQLUxlSDMCIGlKkaFGXYAZhimMLAwwzAVgF5xZqZsG4VpCQA7ADMMUzBYmGGYCiBTYdFMQmBJxIkwww7ADMMUCBZmGKYCKFcz09MrNuPYm5/F6+t2WD5XambYAZhhmALBwgzDVAAZUs6onISZ8+95Dau3duLCP79m+Tyda3CChRmGYYoACzMMUwGUe2h2t1RY0k0z05OylzpgGIYJAwszDFMBlHsG4KqEdSgxfGZINJPQ0nQnM7j92Q+L1ziGYfo8LMwwTAVg8ZkpYTucoEILACTTds1MjLz+xYIVxWkYwzD9AhZmGKYCsDoAl584U0WilgAHnxnNug3DMExUsDDDMBWANTS7dO1woipuHUrcfGYYhmGihoUZhqkA9DINzRbYNDNp5zwzDMMwUcPCDMNUAOWeNM9JM5OwlDNgYYZhmMJQcmFm/Pjx0DTN9jdnzhwAwDHHHGP77uKLLy5xqxmmuJR7aLYszKTZzMQwTBFJlLoBr776KtJpM+/E8uXL8elPfxpf/OIXjc8uvPBCXHfddcb7+vr6oraRYUpNuWYAFshmJlMzY36eYGGGYZgCUXJhZvjw4Zb3N9xwAyZNmoSjjz7a+Ky+vh7Nzc3FbhrDlA1UgClPYUbWzGSjmeJEyIlxNBPDMAWi5GYmSm9vL/72t7/h/PPPh0YGvnvvvRfDhg3Dvvvui3nz5qGrq8t1Pz09PWhvb7f8MUwlU45mJuqUXJ1w8plhzQzDMIWn5JoZyiOPPILW1lace+65xmdf+cpXsPvuu2P06NF46623cOWVV2LlypV46KGHHPczf/58/PSnPy1CixmmOJSjA7BIjAe4+cyYn8dYmGEYpkCUlTBz55134qSTTsLo0aONzy666CLj9X777YdRo0bhuOOOw4cffohJkyYp9zNv3jzMnTvXeN/e3o6xY8cWruEMU2DKMQMwrbEka12SaXvSPBld1y0aWIZhmHwpG2Fm7dq1ePLJJ101LgAwY8YMAMCqVaschZmamhrU1NRE3kaGKRV6GWYA7k6apbxpPpmu3hT+/sp6AO4RTKmMbnMcZhiGyYey8Zm5++67MWLECJxyyimu2y1btgwAMGrUqCK0imHKg0yGvC4PWcZSKZu277mVnxiv3TQzPamM43cMwzBBKAvNTCaTwd13341zzjkHiYTZpA8//BD33XcfTj75ZAwdOhRvvfUWLrvsMhx11FHYf//9S9hihiku5RiaTc1MadKouuq48dqtqb2pDMAKVIZhIqAsNDNPPvkk1q1bh/PPP9/yeXV1NZ588kkcf/zxmDJlCi6//HKcccYZeOyxx0rUUoYpDeXoAEzNTBnSwPpqc0HS1ZuGE1QYCsKWjm78661NSKVZs8MwTJay0Mwcf/zxSj+AsWPH4rnnnitBiximvNDLMDTbSTND6exJOf4+mcrvPE7+zQvYurMXV5+yN75x5MS89sEwTN+iLDQzDMO4Y/GTKQ9ZxqKZeXblJ0Y4NtWYuAkzep4nsnVnr3FMhmEYgIUZhqkIrEnzStgQAnUABoC7X1oNwEyYBwAdLsJM2PPgSCiGYQQszDBMBVCOGYCpZgYA/v32JgBmwjwAGDfEuY5a2POQE/UxDNN/4dGAYSoAS22m0jXDgqyZSeSy/SaJmWnOsZMdfx82X05VgocvhmGy8GjAMBVAWWpmpGgkkSBPaGYOHT8EA2usMQa3fGma8TqsmamGNTMMw+Tg0YBhKgA68ZdLBuAeycwksgCnjLpMdp+Wzx84BsMGZpPLsJmJYZio4NGAYSoAi2amTNKrOGlmUrkGJhwcdIWME/Y8qhLsAMwwTBYWZhimAtDLsdCkrJkRwkyumrZTKYNYrrhkWM1MdTzuvRHDMP0CFmYYpgIoxwzAacnpxdTMCDOTengxNDN5nAcV6qrZAbisaO9O4sRfP49fLXy/1E1h+iE8GjBMBZApw6rZctZfWZhx0sxohmYm+DF7SaRUNeeZKSv+vmQdVrR04DdPfVDqpvQrHn7jY8y593VbdGF/oyzKGTAM447VAbh07aDYNTPZtVE67eEzk1tC5aOZoZW2WTNTXpRJt+x3XPbAmwCAA8Y24cKj+m95Dx4NGKYC0MswA7DwjREkfGpmhM9MPhomuvqMOeyfKQ3VHF1WUtp2JUvdhJLCvY9hKgBalbpcfGbkdtjMTA6TWyyEmYk6HZfJZWBysKastKhSIfQnuPcxTAVgMTOVrhkWUhmnaKaM5b2MZoRmhzMzlYvvEJOFCjN8b4pPf69VxsIMw1QAZekALOWJidmimbxCs/M5ZvmZ25gsNUSY6ZU7B1NwnDSh/YX+ffYVTDqj57WyZSoTKr+Ui5kp7aCZEQKHU4ZeIePkI5RRbVC5XAcmC/WZkYuQMoXHSRPaX2BhpgJJpTM4/lfP4Yu/X1TqpjBFwqqZKWFDCDbNTE7jkkyzZqY/Qu93T6p/hwmXgv7uM8Oh2RXIqk924sNPOgF0IpXO9Hv1Yn/AmjSvdO2gyJoZIXCJz73zzOSjmSnDGHUGgNWXS84OzRQGKtz393mgf599hULnEOoQyfRdyrFqdkqSqsTAakYzedRmyuM8WDNTvlCzYZAEbrc/+yEWLN9UiCb1eZJEPdrfzUysmalA6CTQm8pgQE0JG8MUBb0MHYBlYUS8TxlmJvfQ7HxOg+a2KRehjslChUu/PjOvr9uBXyxYAQBYc8MphWhWn4YuZvu7MMOamQqERgqwZqZ/UI7WFSFY7NZUB8DUGArNTJWjz0z2P2tm+hb0fsoV1Z3Y2tFTqOb0C3rJ+N/ffWZYmKlAunvNgaKXhZl+QaYMMwCLNon8ImlDM5Ptk3EHM1OY2kw0mqlcNFRMFqtmxp8wQ02RPJYFhy5sy2VcKBUszFQgu8hAwVED/YNyzABsaGByE5Joo7DjVzmYmcQKMrxmpjyuA5PF6jPjTzARJkcA2NXLY1lQqADY358HFmYqkC1ENctmpv5BFxnod/akcM0jy7Hko20lbJEpWMiaGSFs11XHlb8Ll2em/DRUTJZMHg7AtAt0JVNRN6nPQx2A+3veMXYArkDmPfS28ZqFmf7Bzh5zoL9l4fvoTWXw18VrS+o0aQgzuZBQ8X5XblVeV6UWZsKYmcpRQ8VkoVGWfoUZqlnu7GHNTFCsmpkSNqQMYM1MhZGWeiybmfoHHUSYKRffAtPMlB1GhHAhfLq8NDNh88ywLFNeWB2A/fVRuhhjM1NwetjMZMDCTIUhT2TlMrH1J9Zs7cTTKzYX9Zgd3eWngs/IZqaMXzNTVBmA+/fgXW7Q29HjVzNDfGs6e8uvj5c77DNjwsJMhSELL0HNTNt29uCh1z9mISgEx9z8LM6/5zW8snp70Y65sztZtGP5JWUzM2U/78pNSk5mJjPPDGtm+hL5+MxQzTJrZoJDr19/95lhYabC6ElbH/igQslVD72Nuf94Ez9+9J0om9UveWdjW9GORX1mygXZAdgwM3n6zMCyfbBj8kq0XMknad72TlNIZ81McOi4kK8ss3xDGy78y2v4YHNHRK0qDSzMVBhyzZOgmpmF72bNI39/ZV1kbepPUDPHgJri+c/vLEMzky2aKaiZKQ/lIEczlS86gmlmUukMfvXk+8b7tl3lp30sd+i4kK9w//nfvYyF727GuXe/GlWzSkLJhZmf/OQn0DTN8jdlyhTj++7ubsyZMwdDhw7FwIEDccYZZ2Dz5uL6K5QTvWlZmAmmmhXZWpn8oAPugOriCTMdZayZkR2AhbnA2cwEy/b5HBPgpHnlBhUu/SyyZOHlwy2dUTepz2PVzOT3PIg5ZUPrrkjaVCpKLswAwNSpU7Fp0ybj78UXXzS+u+yyy/DYY4/hwQcfxHPPPYeNGzfi85//fAlbW1rCOgCLVTSTH9s7e43XxTRzlGMIvsgrQzUzmYzuWzPDtZn6FkELTcp374MtlW3mKAUd3eHNTH2Fssgzk0gk0NzcbPu8ra0Nd955J+677z586lOfAgDcfffd2HvvvbF48WIcdthhxW5qyZEnNXbkLS47ukxhhl77nlQaNQn15B0Fckh+OaDKM0P7p3eeGa7N1JegDqgPLv0YN5yxv2u9ILlPb27vLljb+ipUM1OOY0QxKYtl+gcffIDRo0dj4sSJOPvss7FuXdafY+nSpUgmk5g9e7ax7ZQpUzBu3DgsWrTIcX89PT1ob2+3/PUVZOEl1c87cLFpJ6pxkX1zZUsH9rp6Aa577N2CHFPX9bIcqESdJOoATEtt1HqamfI5JmtmyhX5fr66xj3aTx67yrGPlzsdJMqxv5tdSy7MzJgxA/fccw8WLFiA22+/HatXr8aRRx6Jjo4OtLS0oLq6Gk1NTZbfjBw5Ei0tLY77nD9/PhobG42/sWPHFvgsiocszPAAUFzoACxszbcsXAkAuOul1QU5ZrneYuHAa9XMZIWZRExzXJXHQmlmaKHJwD9nCoh8P6lJUEVa+p7vZ3CiiGbqK5TczHTSSScZr/fff3/MmDEDu+++O/7xj3+gri4/Z9V58+Zh7ty5xvv29vY+I9DIDr+smSkudPUjBMtCC5SpfMJ+ioCsmUnr5jWpcfHNEvUnw9dm4r5fTsi3o8MjN1Ja+oH8nvGGloAIOw5pzhbBiqDkmhmZpqYm7Lnnnli1ahWam5vR29uL1tZWyzabN29W+tgIampq0NDQYPnrK9g1M/lPdHe+uLrfJ1oKCg0mE5qZQgszZSrLGNfCiGbK6Eb/dHM0D1ObyRrNFPz3TOGQhUuvrNXy2MXCaXDoNQtrZqpwWab8hJmdO3fiww8/xKhRo3DQQQehqqoKTz31lPH9ypUrsW7dOsycObOErSwdcmh2UM0M7bA/e/xdPPle/w1zz4e0SjNT4DG4XDUzYjKqimu596YDsJswI8xM+QiBXM6gfJFvZ7uHZkYeu8q0m5c1UTrExypcNVNyYeb73/8+nnvuOaxZswYvv/wyPve5zyEej+Oss85CY2MjLrjgAsydOxfPPPMMli5divPOOw8zZ87sl5FMgD1pnmx3DsrHOyo7t0Cxoasf4QBcaO2W2yD/k0ffKZnjn1HOgDgA+xNmYGwfFNbMlC9BNTOyTw0Lp8Gh1yysma7ShZmS+8x8/PHHOOuss7Bt2zYMHz4cs2bNwuLFizF8+HAAwK9+9SvEYjGcccYZ6OnpwQknnIDf/e53JW516egJqZmRGVhb8i5QUdDJVGhmCq05cdv/PS+vwZcOHot9RhfflCqHZmd0YmaKe2tm8sozw5qZskUWqr3NTBzNFBY6NIR9HnrTGfSmMhWbi6zkM9n999/v+n1tbS1uu+023HbbbUVqUXnTKWWCDTsARJGM7b4l6/Damu248Qv7I+EyiVUy725sR08qbVHliom70Opxr3v85setJRFmxMpahGCnM7phBnXLuROuNhMLM+WK3E0/2dnjur3NzMS3MzBWn5nw+/ufpz/A3OP3Cr+jEtA3Z54+zIdbdgKAEfYaVjMjC0dB0XUdP3z4bTz0xga8uGprqH2VK5mMjpNvfQGf+93LaKVJ83KTeaGjMIxMu/EYLj56ku3719fuKOjxVei6KbjUVgnNDHw5AMdCOACnLIUmg/+eKRx/XbwWADBuSD0AYOG7La6VsGUhnYXT4FjMTBE8EI++uTH0PkoFCzMVxgc5YWbvUYMAZIu1BUEeMMIKM7Seh5tpoZKh2qutO+0ZgAsemp0TmmIxYMSgGtv3b6xvLejxVVAhuoZqZorqMxPtdd+6swd/W7zW03GVsbN8Qxs+6chqYo7ecziq4hq6kxls63TWzgjBNEx/6O9Qt6Morl8lLxD65uzTh2lpy6b8Hj90AIDgE6msydkZUph5n5SNr+DnwBVaZ4bKa0ULzc4NUolYDPWKekcffrIz730/8Oo6fOtvSwMXLE0SIbo2YQozYj+ueWYMn5k88sxYajMF/rkr5979Cq5+ZDnm/d/b0e64H7ClwyxFEI9pGJirKO+mmRFKtiqSdJEJhh6xmamS7wELMxWGMDkIP4WgZia5s4bVzNCkTXLYeF+hO0UTU5mfJw0HYH/34B+vrcel979hEQT8IPYf09TFG3U9/4iqK//vbfxneQseeHV9oN8lU+bxTDOT7itpXqg8MzoVZqIdeJdvyJY9+c/yTZHutz9AI2E0zazLtcul4KScdJEVM8Gh43kUgkgll0QouQMwEwzR2Wil4iBErZmhx0/20aKX3SQcngoiYjDOSAOKUxr/K/73LQDAzElD8eVDxvk+vrjGiXgM9dXqRzat64iFSHvV2hXMtJIkviu0LwqBtlBmJvqTQi0itQoPUS0FVJiJaZohdHf58JlhzUz+ZCzPQ/jrV8lZmFmYqTDkcNigYcHygOGmBg66v2Shs8eVCGpmosKMOHc6iCTTGcRj7tWzgwoO4jjxmKY0M4ltHOo6+iLoQCiuQ3U8ZghvQUOzw2cA7pv9rRKRc5QIYUalmensSeGaR5YbQoxIusg+M8GhC6koZMFKVq6zMFNhiA5Ls64GQXYYDit/pKWJvC9ChRlaTkJcO6qJSaYzjtWi88UQZjQNCQetT9iJIMjPu5NpXP3wcgDZfhjXgmYAFsfMwwE4Yh8BFayXCQ7tlhldR32Vs8/Mbc+swkNvbDDe06SLTDDoNcvH1Cz/ppLvAfvMVBgZycwU1mcmTG0nwPow9FmfGWJmoucoJmO6Ki2EdipFNDOJuHqqDauiD/Lru15ajadWbAEAVCViiMWCCTNaiKrZ1pVoYQZetjIFh5rmMhkdtS5mpk1t3Zb3Rm2vyp1HS0ZYH7JkH6qPxcJMhZEJaWeWhZ+wk6CqVlFfg0b6UGFFXDs6+fnRTgWdLE2fGQ3xmPqRzUcmXb6hzXyjGMScNCdrt3YZr6viMUMzY8kzE3fWTkVlZqrkgbevYdXMAPUuDsByv6pmn5m8CetD1peyMLMwU2GIvmZoZgJqAmyJqkLKH3Sl3HfNTMQBOKXymTG3LcQ18GNmCuq498HmDnzmty8a7+Ux7Pn3P8FB/+9JLHzXXoiUChHUZyad0bGrN+tQ7uTbA4RzALao1QtmZmLVTFCoqTWt66bPTK4/XPvP5fj8715SLnioFo/9oIKRCauZkeaPSr78LMxUGDQbLBBMktZ13aaZCVtXKNUPhBmrZoZmoM2eu7X4ZPSjAXUAdioGF3RF9ZqUNViXDE1fv+sVbO/sxYV/ec3y+T9eXY8Hl35svK+Ka6aZSdcNs4IqhFwgts9n4CyKAzDLMko+2NyBh9/4WHnd6SeZDBVmss/LXxatxevrWvHsyi2231Jn8UrWDJSCsJrKvqSZYQfgCkMOzX5lzXbs7EkZSarcUPXT0A7A/SyaqdcizIj/hRXoqDDj5DMTdCCTFTy6no0yeXdTOw4aN9jxd1f831uW9xYzU0ZHV+5aDXARZozaTHkMnNaMp4F/zoTg0796HgDQUFuF4/YeaflOTk8wIDcedSWtqR9UZqcqIszwPQ1GWDOTvJit5NBs1sxUGHJoNgD8z9OrfP1WpBu37i+kA3A/8JmxOAArzEz0+S+EMCMGnHhMc8xhE3RFJedSyejA2X9agi/esQh/W7LW934S8RiEG09a143oFad8OIDpM/P6uh2O2zihh1Sr+4EVM+6sJFm/BRlpUhVmxm7JAXhXbxprt3dZPqtKUGGmcifTUmDRzOQhzchuCpVs5mNhpsIwQ7PNW7d2W6ev317+4DLbZ2HnXktG3H5qZsoENDMF9ckwyxm4+MwEFWak9zp0LMvVeHrwtY9t2ztRHddIeQIzo7SbmWl7rr7V6+taA9cWs6rVA/3UNxzNZIf2+4baKtv3spAp0hPI0UxXPfQ23ljXavmsmmgb+4sw89qa7bhxwYrAZURkwvrMyONGKqNXrEDDZqYKgnYyupqp85nX5KVV22yfRamZ6avCTMrBlKbSzDhdT6cBQtd1JNO6ayizWWjS2Wcm6EBm08yQcwwymVMzEwB0+nAAfulDs7p6dyqDgQEKlFoG3woddCuRbaTAqmq8kUOE612S5slUJ/qfmekLdywCADTUVeHioyflvZ+wwozsQ6nr2cK6UefKKgasmakg6EBOzUw1ITpeWIcvqqbsq2YmJzOSymfGKbrM6Tpf+Jel2PPq/+CfyzYov6f7T0SYZ0YWuqiQFkQxkSAOwACws9tbMzPn2MnG6zBV3zmaqXhQE7Vq0ZKxCPS6WZupN+250q/qxw7AH4UoEgvI1z3471XPX9is8KWChZkKgnbcKjKpiUJ/YfeZD5Y8M33UAdiSGJAIbOJzeSBX4eRY9+R72dDn792/DJvbu5XbmIUmnX1mPvXL57Be8kVwg/oBAVLCwwCqGdmPR9T6cvOZOfOQscbroE7jxcgzw2YmOzu6TM1Mj2LRImsIaDkDrzGGLswq1cSRL06aVr/Q655XFfrczRk2sMa4D360aeUICzMVhJNvhl8zk8qUETY0uz/kmaGDMZ30hYBCw5qTTsKMD6lR5aBNf5sgpQNU/OapDzyPIZBt9VRICzK86josbero9jYzaZpmDJxB+0wxoplYlrFD71O3YrKzZGbOmMJsV2/as+8n+rFmJuawOPFLWOFeaJKr4v6Kg5YzLMxUELSz0gHFj3SfyZhFAF/54XG47SsH5j4P16b+UJvJ6RwNzQw5bSefGWqbdrpdTp+bodkxJBwyAANwFXRkemTNDBVmAoyv8ZgG2iSxavcSsIW5LGjSRzppyivRLR3dgc1WUfHxji7cu2RtaIfOcoX2X7Vmxnyd1k0zU3cy7TnJVsU1M1y/f8kythQJQaGXNmhpm+xvzEhJes8qERZmKgjaV4cOrDZe+6mJRDt6TVUcuw+tz33OmhkvnJLiqZLmOU3OfsImnXw1jNpMGhB38JkBgIG1/v35u100M0FU33VVcaUQ5eVAKPwkgtbzohMjXZUu39CGQ69/Cmf9cTGAcOYK2TnaD2fc/jJ+9PBy/OZJ/9qxSiJtEWYUmhnJ3EFX+V7aloN2H0xKXPQvaSasmYle23y0WobWN6YZ2lTWzDAFh3bWQycMMcJ0/Tje0t8miJ9D+NBs6k/SNwcii3kvZTczZXysjlIWjUKw41s1My7CjI/EiQJZM0MF0SDDa111XOnH4xadBZg+X0GFacvgnbuQqXQGf39lHQDg1TU78PhbGzHtp//FCx98Emjfgnyml83tWRPhv97elNcxyx3af2V/K8CeNK+O1Gby0hgcMn6IIRDL/bKvE6XPTFAtJ2AuzhLxmLEAYZ8ZpuDQ1WZc0/CdT+0BwK9mxtwmTvKVhA3NpgNVX62aTU/LkgE499IyoDgM3BnFJCzjZWZKuIRmA8CgAJoZ2VRAzyHI+FpXFYemabbfVHuEWwtzWWAzk6SZ6U1lcOSNz+DeJeuMzy+57w20d6dw/j2vBto3ZdWWnXmp27d39npvVIFQ851aM2N9bYRm96Y9tZKJmNl/jrrpGbR1JcM3uEII62xuHXvs4+/Vj7yNax5Z7vh7OrbI9bQqDRZmKgi6Ko3HNGP1m49mxqinE9JI7aS16EvoDj4zRp4Zsq0fn5ngYdRCM+OcNA8Aajy0IRR5oqZNCmJmEas52dTkqZlJ5LSKIZLmpTM6VrZ0YFObOgos367d0ZPC7Fuewzf+/Jr3xvJvu70ngpa2bryRR/bjUmLxmSHak5dXbcXvnl1lyzNjmplSniny5Yi4he/Zi5v2VYL4ualw0wpv7+zF3xavw18Xr0XbLrWASH1mhLa0UqNSWZipIOQJR3Q+P74qKUkQEpNi6NDsfuAz45TbROUzc9kDbyr9NfykHXca8y2FJl2EmSBCkqtmJsD+hTBD2xXT4BhCLqjKWzNjbU/SRbPo1QYvXly11XujPJhz3+v43O9ext8W+y8bUWrove8mfecrf1qCGxestFRXT2d0wycqo3vfY7mAalhtcSURNprJLfs41aY5+ZCliJlJ3LNSOdGHhYWZCkJ0XNH/a/LQzGRVuubgEdoBuAjRTLqu41t/W4rv/P2NguzfCycZIaPwmQGAdze127alk4GjKUpXCzxUmHEjSDSDfN/9mJlU/WxgjV0z46WVAZD3wClrZtwEODctVilZmqtYfvuzH2Lp2h24+pG3y960YjEzKcxvm1p3Ga8zum5J7ugV4ZUVZsix+nhIk56nSVe1H0s0k/Qs0avoFVxAS6Xk43tTDrAwU0GICUdMakHMTClpQhT/Q4dmW3xmCvMQbN3Zi/8sb8Fjb24syaDvmAjPSJpn/V51TekA7RSxIbZZ/NE2TLvuv3jo9Y8tn3sJM0EiQcQqbtyQelubnQY+VT/76mG729pW5aM8QSIejZmp0MLMum1d2EAm6qg54/aX8bfF6/Dzf79XsGNEQUqhmaGTMo1ey2Ss114Vyk2RNY75FEysJGifDeMALF8msd/eVMYm6DiZ+qiZSeT7cdN2ljMszFQQovMKn4Yg4a3ptCmB0/9hNTPFKDRJ56RSPGhOKlpDmJFGFVUqGJVmRt6v2Obivy1FR3cKc//xZnb/uvXeORHk8ot7NXH4AMsxnNoPAD1p6wr7wYtnoqk+myKANs2P704iHoEDsO4hzASo+eTEUTc9gyNueLogEyy9zu9vsVeiLics/TfXd2hUE81C3lCXsORD8lpsxWPWZJB9XTNDzUFh5G257yczGWzv7MVBP1uIS/7+hmMaA9U+quKm20KlJi5kYaaCEAOqePCDaWZMCRwwbbUZPVxODmrfLlRtJtq6ax5Zjvbu4mpnnJ5tcdnky6fSbKh8ZuRBw/TBsf6WFpp0b2cAM1Nun0LwsPrMqI/T2WMVZqjQElQzUx3A34tiGaDT7sJMWJ8ZSiEi9eiqvNy1ESmLMJN93UGeQ3rPf3LqVEkz42Fm0jSL03mlTqZ+oQuyMA7A8vOeSut46PWP0dGTwr/e2uQrO7C4lzQhZ9ASI+UCCzMVhOwzUx1EMyNso7nf0MEmzNhB+32hNDN0oP/P8hb8v8ffLchxHI/vpJkxyhl4b69KbuWkJpbn4LRvzUwQM1P2XlUn4ra2OI2vckREtYMw48dnxhg4A0d2kde67qpZjNJnptDCTLlrI6g/hrgWHT1m5JaYAGfvPRJjBtfnKrxnv/PKHZONZjLf93lhhi76IhRmNrV14//9yzRX+omgFM8PLWLLDsBMwTEnu5yZKeG/vs3/Lv0499vse7rKD2NqKkYGYNne++qaHQU5jhOOwoyDz4zqOtBrnHL43bsbs47Dsh09LWnVnAgyCYg2VMcVmhmHAVYWZmoSpp8EbXMQn5kwVbNTGd11FRlEM+OlGSmE1pFe5nKfwFPSc774o214ZfV2y2cALEKJWDh5+cxommbRBnqFclc6tM+G0Yp7dRmqNXcWZsyFkhFhWOZ90YmSCzPz58/HIYccgkGDBmHEiBE4/fTTsXLlSss2xxxzTC4xl/l38cUXl6jFpUP0MSGI1MT9m5l+//xHALLOtICkmQkxTtOHZOvOXtwaoNhhPscAgHaHnAmFwun6mNFMkrpXMRjIVYUB+3ld9/i7yGR0mzBhljOIUJjJTT41OV8HOpk7HcVNM0OFGa+EeXSbwIUmqcN5KoNv/nWp47ZBNDNeE2hUwgy9zhYzU5lP4PS6f7xjF878w2LMe+ht4zNxH+k5ievvp16VRbCrUDOHX2ifDyM4ePUZP0EHtIhtIk/Tb7lQcmHmueeew5w5c7B48WIsXLgQyWQSxx9/PDo7Oy3bXXjhhdi0aZPxd+ONN5aoxaVDl81MAXxmZKwq7vw7rzwJ3LLw/cjVlHLznBJAFQqngUCMFfJ49OS7m7GixRqeTR1dxSCjmkA7ulOQZQHDV8qlLpPT/pwQq0MhVKQtmhn1b2zCTNzBZ8aXA7AYOAM6AAcY/P1oiARegqCXdsEv1F+iksKRaftUz5+7MON97cIWTKwkVMVq88Hrt3TMcerfSeIzU5WnU3654D//eYFYsGCB5f0999yDESNGYOnSpTjqqKOMz+vr69Hc3Fzs5pUVYsIRE0dVAM2MTLwAmhljfxE/C7KwVezBzklIMDIAS9///vmP8PvnP8KaG05R7kMMQrriuu/o6rWZmfxqZoIMjElJM0MHMKejyBqxGhLBQiNzanyZmfLMMxNAYAsS9url1xGVZiZliWSpIAdgj/skJkV6yQ0zk496SzrxPCt3LVVYLM7UoTQz7t/7cQAWpqgqkmeGQ7Mjoq2tDQAwZMgQy+f33nsvhg0bhn333Rfz5s1DV1dXKZpXUkQfE2YIQzOThyQdj0oz42FSiYJSD25uh89kdF+FI1Wh2aqJuXVXUuEzE70DsGiD8Huhk/UzK9UFGmVhxqKZoT4zCW8hwjQzBXUA9r99EKdduYq4bV+pDHZ09obycQCkgp40gieCPv7syi247IFlBYn285p0TZ8ZhWbGx33oT5oZ+qyF8ZXy+q3VAdh9mxjJM8OamQjIZDK49NJLccQRR2Dfffc1Pv/KV76C3XffHaNHj8Zbb72FK6+8EitXrsRDDz2k3E9PTw96enqM9+3t9oyslYgtmskwMwUviBfLFXfT9XADqVfkThSU2oTrJkyldd2XsGWxXzuEZgNZzYztGEbSPPe1RzAzU04zYwjE3hdZNhdQYYY6lPvxmcl3FRikqwbRpngVlXzu/S24+b/v43PTd8OvvnyA/0ZIODl/RrEYPvfubGHNwfXVuPaz+4TfIcHrmVaZmcRv3AodCujey11LFRYq0N7z8hpcceJeqK8OPhV7Cda+NDMk/1hVhUczlZUwM2fOHCxfvhwvvvii5fOLLrrIeL3ffvth1KhROO644/Dhhx9i0qRJtv3Mnz8fP/3pTwve3mJjZAAWmhmfodlOA1EipiGZ1iM3M0UdjaA6xsbWXRjdVBfpcZxwG1szuu7LrKaqmq0aYNq6khaTzZqtnUSY8X8ML+Q8M/7qe1m3oQJMPGA0kxGJlwqomQnQt4L4uXR7mEJ+ufB9AMDDb2wIKcwQfwmPisf5sqkt+ozF3poZu5lpW4AK4pZstX1cmJHP75/LNuKsQ8cF34+XA7CiKK7TPmIxLe90CeVC2ZiZLrnkEjz++ON45plnMGbMGNdtZ8yYAQBYtWqV8vt58+ahra3N+Fu/fn3k7S0FokPKZiYvVb3TRBVFfSalmSlyzYx9f8f/6vlIj+GG2/m4DbzWatt2M5NKmNnR1WsRDL53/xu+NTP51GbKt/K6TNA8M6YgHkyrGMjMFEBjuctDMxOVfO7klBnlYjhMinwnvFbrov/4TQLnFjZfqdE0fpGf03zN6F6PwuNvb3I9RktbN379ZDb6NK5xnpnQ6LqOSy65BA8//DCefvppTJgwwfM3y5YtAwCMGjVK+X1NTQ0aGhosf30B0XmN2kwiEiXjngnVaXAwKmeH6LuqhyRqwV61AtlJEnYVGrfBZme3cztUifIAdzNTV2/aMhmt2rLTppn5zZkH4LCJQ/DPOUf4bqeMmHyCFCt1E5ppm4cMqPbcV5DjCoIKyd0RmpmigprV6OlE6RdWAFnGt8+MX0HKLsyY+y9EgsJyQn7ug0TdUcTz4GTWvW/JOsdjAsCFf3nNeB23mJkqUzNTcjPTnDlzcN999+Gf//wnBg0ahJaWFgBAY2Mj6urq8OGHH+K+++7DySefjKFDh+Ktt97CZZddhqOOOgr7779/iVtfXOTQbBoC25vKoK46rvqZ4yQkzARhNDOqQS56n5nSPlxuE42on6QildEh8srRayzuh+qy96Yylsmosa6KFJrM3u/TDtgNpx2wm+23oRyAA2SRVkEnp5ENtZ77EtobagpKpjO48C+v4cBxg/Hd4/awHz/ghN+byiCVzviq0VQ0YcaSYyQaR1AZp6SHYfDtM+NzXk7ENDgZoaIKgy9X7MJMfvdLjEtVcQ29Ht1XNYa9vaHNeB3TgpmZ1m/vwqjG2kjqn0VFyVty++23o62tDccccwxGjRpl/D3wwAMAgOrqajz55JM4/vjjMWXKFFx++eU444wz8Nhjj5W45cVHzgBMJXK3ychJbWhUzg7jANwPopncnu0XV211/I7eEypQis9Vk3NvOmNZ3dZVxwOUM3D92oJYffk1VQJWwfXqU/a2fJcgA/KoRh/CjCKtwMJ3N+PZlZ/glpx/ikw+E/6ij7bhH6+u93SW9PKZiQq66qXCbJSm2QIoZjw1MynDZ8anZkbaTuU43FeRzy/hVwKUkJOouh/T+l6eE2IafDsA//edFhx54zO4+G/OCStLQck1M16DzNixY/Hcc88VqTXljdx5qUTvpq53EnTEABJm7FBNyH1OM5Pn8a3+EeY96MlpAVRCWm8qY9FyDK6vNiIOVINWIqa5+uA4IcwdfipcC8Qg97PTpuJrM8dbvqP7afahmRE5ami/9TI5BTm/eExDOqPja3e+AgAYO6QeMycNddzeT5Zav6QzOj7Y0oE9Rwyy3bNeJ81MhAJ7hCWpDLwmOBF+7dtnRtJG0D7f10Oz5fPLVzMjL279bCtYs82a2iROQrO9FjZ/enE1AODJ97b4bmsxKLlmhvGPHJqtaZqviCYnG6h4CMLlOlB91seEGZ8TzYlTrUkdkx6aGZWQJE/or63dgQXvZE2vKs3Mf753pDER+J0E0iQ3jh9nXYFs7qLUVpkmzqZ6b58Z0W9pDhKvFSbtB151l+qrrCbXOfe97lpqI0oz0y8WrMCJv37BUvRPYBVwyecR9vFCOAD7D832tz+5L1s0MxXqs+EX+Vrme7+EIsBPDTJ5DNvQao14i5GkeV5uB1EWcI0SFmYqCFOYsUeOJF1WtU4OwMJKVe5mptILM/62kwUDi38Eeb11ZzYH0jMr7Sub3lTGUTBVDVp7jByEa3ImH78aJNouPzlhBG7J+6hmpt7Bd4tSrUjWR1f1Ko0tPT2vdtfXWNuwvbMXtyx831FoCWNmkq/7H3J10O56abVt2z++8JHx2k8hwLwogQOwuF2+zUyyMENuZ1/XzMj3Ot/xMi0tboMcU9a0xTXNdzmDIAVci0nJzUyMfwwzkyzM9LhrZjzNTGHyzJQomgnIToRBNAv54newsQsz5u/oAL1++y5886+v4Yl3Ntv20ZNKOwufDhOFGFz8Toh0/zVV3oKHwKiwq1CL0wratT72qQoJp4NkTypj2w8VGqoTMddw6mwSsh7b5zt7Usr2hdHMBJl8F75r3vNCCelaAaQZv231O9HJfiJRZSSvBKIqzxLIzORRDDebAdhfoUnWzDChEYM5HQeEvdXN38DTzBRCk6JMmhfxIO2kcfDKDRLZ8fMUZlIW/wjrPlSCDAA8smwj1m9XJz1TCRGAaZ7xex9pf/DjMyMmenE+qgmLflYXQJihviqyMCNDz8/Lz8BJO7Rma6fy8zCaGbf+/tU/LcEnHXahSv5dlNNDPnNNbyqDTzp6sKWjG1s6um3f+8394tvMFJc1M/3XATjf8xUykS8zk8cxqWbGK7KxXDUzLMxUEHIGYIDWZwpuZopFYGYqRm0mp4d9l1c8YkT4XSjKpo9eBzNTvjitwMx8QT41M7kT0jR/zoc3/GcFAKKZUfjMULNQbXWApHkOQrjskNva1Yv3WzoAZCdMrwF1gEN6+C/csUj5edDkfRQ3IfLFVVvxiwUrAv8uKPT65+ODcdptL+GQ65/Eodc/hUOvf8o2ZvidcP0eW96Ovq/UPCd+sZt88gwwyDgvLryOKd/feAwYMagGALCp1S7MWrdlYYYJiZwBGPCeFACrueObR080Xguh6Np/LsfG1vxSoBdDM+MozJSZZoZWkQasg1TQgooqnNS7QTVs1PfFj4/DY29utP5OIQAF8WcB1DWhqMAnV1o+8hfP4Ct/WgIge75emhSnnEtOhKmK7eWwuoOk9Z84fIDxmgrJYX12qeYvn0jf9zZZ69fJZje/ppB8c9zQBVq/08zknQE4fwdgmxNyTMOEYdm+2dLe7bpQzDeUvNCUZ6sYJXIGYMDMHukuzGS/G9VYi6tOnGJ8LlS7yze045L7Xs+zTUUQZnLHOHBcE1790Wzj867e4mQBVp3jdz412fbZYCmK57TbXsKduTDGKK6J06Dl12dm284eLF273WJr9xNKayZXdHYApkf2M6GpfGbohCmbmTpIxudYTEPbLvfK0H5MXZQwwqbXZEQvR8riR2WeY1g/F+tKO/zKWT4j/z4z/vYvt5Camfq+z0w0ZiZxy+Oahtoq9wtvyzOjMDM11Vejqb4KALBmm9ocC/jLa1MKWJipIOTQbMBc4d7/6jpsdyjsJga6EYNqLBMNVe2++XGb7Xd+UD2IUee4E8eorYpj+KAa7JYrMFksdbRqrFE5karS+P/s8XcBBK8OrSKsMDPrF8/gjNsX4cUPthq/82MWMEI2XXxmvPJFyaiFGaKZIWYmed9eAtjx+4x09C9yIkzWWa/Jlz5z1kKTeR/SBhXGoojMlk2WfoU92p+OmzJCuc0kop0SUCHIrR+37Uri5idW4oPNHb7aU47Ii6PQDsAxDXeec4j7th6aGfFMD8ktyDpcyrTQxUzQ576QsDBTQYiHQFP4zPz77Racc9cryt+JgUiuARJXmKuCUoyq2bI61SiIVqQVnEozIzvOxjRgqEtNonwEr89Pt5YscBJm/OYLEma5597/xPidH42xvH+lz4z3biyoajPRCZMKF52SyttNrX7TF/bHrWdNDxxxEcbM5NUNaUscHWlDCiBRF2e0O6n62z8dm35z1nTlNvecd6jtfK3RTM696fp/vYv/eWYVPl3EQrNRI48F6TzvHfWhPGLyMHxw/Un49jGT1Nt6hGaLZ9xPRBN9/qIwn0cFCzMVhPAjoBMpFVBorQ2K6JjyapWu4PINcVYJLlEPrOLhFw+RkSSuWJoZxeAqa2ZimoZBtVWO+8hHlfzjU6fis9NGG++dbNVBy1KIgSum+XPYNIVHZ5+ZoNKMynGdXiPqM9MumZTc5JSDxw9BbVU8cM2YIMUNbRODx0RPr7GT0BRWmWLR+ESg8qHP9ScdPXh/805fv6NCiSpS7tDxQ7BbU52rmcntWXkrTw1yOWH3mQm3HzMjfAxXnDgFg2rtzu82p2MHzUyVkQXYRZgh9zjKzNlhYWGmgtjRlTUjUd8MP0KIGGxtmhkygOQtzCgGni/esQjXPLI8r/2pkKO4qnKTerGSa/kxM8U0DQNqnP008hHwquMxi4bBSYsSNJNzjAiFfoSZuGRmUmk9gkawiWij9u6UMflaHIDJICn7x7hpZkQ/DpoivjfAoCybDFdscjd50EvstJINaxpKpqgvTvjngp7iWX9c7Pt3VNCVzYGXzd4TD3zzMMQUjud+NTPFyCtVaOwmn/wWf05JLFXPh5eZKWZovb0T51HBs1g1zfxQ+T2jHyF8Yqhvhh/zkBjoXIWZkGXoZf66eG1e+1Mh5riYZGb6aGsnbntmFdq73Z1BAWBT2y589rcv4h+vrQ98fD9mJk0DJg0f6DjY5qNFSsStwoaTZkYMZn4PIeabeMxuZtpvt0abIGCmOXeOngg6yYxqrM1WTk5l0NKeDQV1MjPZNTMapo1pVO5X3Bcv/yKZIGamHz1sFdQfzUV7ORFz8JmJEipgRZEGgE5+q7b408oAwGkHmJpE2VG0vjru6Bzut9BkvuNUOeGlJQm6H/k6q3zKvHygxG+qfZiZ0g6+baWm8ntGPyGZzuCV1dsBSMKMj0lEqNDlSUrzUAn7IWr/GLdjiAdOTK7XPLIcNz2xEj9X1MCRuemJlXh7Qxuu+N+3Ah/fj2ZG07KfLbv20zhk/GDb9l4D1sRhdqfIBKmXAjhHipgOwH4Tm2nGf1u+j5hmE5pkzY8sFAPAD07YC2OH1NmqaTuRiMcwbkg9ADORHTXX0NDgdskZMRbT8MOT1ccRz4OT4OekQQpiZvrfpR+jpc3MxeEVSSIucSajO/aDKKOZ/r28JdS+gPxMVY9/ZxbGDK63fEaFx1oSLn/FCXsBAL562DgAcjkD53shpz+oROw+M3kKM8a4aP1cFW3kpQ0Sj7R4bpIu95+2v5w0M1zOoEK4+uHleG3tDgDA4ICamVTawcwUgc9MMXxwxcAqKu3K/hCvrtnuuY8w0Sqqgd3uAJxtW311AgNr7I+Vl1/F098/BpmMjkk/+relzg0dmBw1M8KnxWVQpOfgZmaKa7n9EWWI7DOj0m6MGVyPF674lOPxVYwdUo+Ptnbi4x27LPsHrEKHLcGXpjlGK4nnwckBWNezERiyhoCaafygEychL62bOJZbRFuUZqbeVAYvrdqKIyYPy3t/TtoRTXOOVlT1+5gGCLGUhssfP7UZr1/zaQzOhQLTPuU2udOyGZWKLEjknWfG4Xn0o5mRhWrRRw0HYLeM8pYUCqyZYQLyADGPDA2gmfnnsg14+cNtAOzCjKpgZVCKEVFkTKKSZkYw0MXxVpCv5gmgUWTmZ3JSNos5SCFgignv4N3tWhtjHzHN8Acy9qXIKSTjx2mPah7iRDMjD3zxmGYTkMU2bj4z+SBKDogB0amitKxNiSu0RwJxn90cgFXztKje7aVloW0QeGndxJZuQk9YBac8IQotbr4sW9+q/Nxt8TRmcJ3tM/pcyNd2yIBqYxK1ZADu62YmD/+VoPuxLUhUmhkf5QwA8/q6jevWFArlo5mp/J7RD9l7VIPx2k0IWdHSju/dvwz/zRW3k81MdJJwmijd0HXdmBiEyYASlX+AvAKRV+UNCu99GWoWCloGQVwnmiJfntDpeGK7zhndGAC8ijDK52ZNkKgWIqoMO7fzoEjNNkIzE4sBmnTbYwqth5w0L6p05mYtGLsDMF1J2p0VndsgJkc3B2DV5CF8ZpzKINggu/CajMT39HmQmx/WXGv3w/D/7KlyhVz6wDLltk6Lgnu/MUMpQPqt2eXbZ4Ycv5xynARBFtbC+sy4VSA3tiWHyGR0rJZqlMljq9tYkrSYmVgzwwREJIoDYKSdBtyFELlEgTzY0P6az/xEn8E/fP0g2/ddEdVOklcg8qpcFYooQwfh7z/4ZqDjizGTamNklTodjOV70pvOGKtyLw2Rm5O2l2bGzfHTuoIyNV2qVZ1TRWM3n5l8kDVK1E5PJ3d5zqJF8ZxwE7hUfjMimmmAwlSi3of52ktwENdeaMdimn0REjacWp7Yg0yQQTQD1Qozz4VHTnA0acUtmhlnYeayT+9pvPYbzRTEz6mckM1o+WcAdhBmPMxM1z66HI+/tcn6mwCh2ZYUCqyZYYIyPFcE7I6vHmj53E0zE5cmJVlFq7tMGH6gnXpUQx0OHNdk+T6qcgPmQ5t9L6+6B9X4MTOZA+m/3t7ksqXi+LmLQ1eW9TUJfPngscZ7Op7IwkB3Mm1M1CoHRpop1SmSCHCumi0GoJ5UxnFgpCuo3pQZBaEyM8ltFJO/nO8nLHIWYNp2KnDIwkcs5uwzI3ATdpTCTG7wdqq27bYPr8lImNFo8krZ9yNscVa5DXJtKzeCCD4qYdwtvT39zm2sOmBsE/713VkA/GtmClFodt22Lsx9YBlWtLRHvm9BZGamID4z5Jh/W7zO9r2R9sJHaDYVdHpYM8MERXSgOkkN7mZDrpI6uZuZKZ/Hif5epfqPSjNjmpnUYbd+UtdH4TNDB9KYBhw+eajxXrNoZqzt6UllDK2JPImdtG8z/vD1g433tkgiH+Hz4njbOntx5C+eRociVJ1GHYi+FNc0m+NpTNNsbRQTvdBAROUzI4eBOiV+s5mZNM2zDW7fq+YOw8zkUzND2+SVBVXsWzhVVsVjNpNLRg9nNpEnSKfSJiqcBClVe1QCiVuuInobvLRpDTnfNzdNFz1SVOML5aK/voaH3tiAU3/7UuT7Fnj5r/hFzr8l8BPNJGNGM6md1du7k0afKlfNDEczVQhJh/Bqt9WO3KllMxPtr/nYbWmnTsRitkEtqpVTStLMyOfhJ4eLPLmlM7ovDUMynTGuExUm4ppm+T3dlTy2dyfTxjnITpC7NdVZ9mPL0kzPwcPMBAAb27rxv0s/xnlHTLBsQ6MODGEmptlXdTHN1qeSKd3iH1UozYzVAdhda0ivxS1fmobdmuowqtE0xbq1UTV5CIHEr2aGtkneX1Vcswg4vZKwVhVXFwbU9fyjmuT5f2ePf62o07Ofyuj28UbRB926g6Vvewmgcas5U9kmWqizABnAP8jl1CmkCUtc75iWFWLzDaKQ828J/EQzyRi+ZrlnkkbHZTI6pl+3EDWJGF6/5tNSaDZrZpiAiMFRHkzcNDPyJCCvjOjX+STaooNgLGZfoXUGGFDdkGsCyRonP47G8oAtsim70dLWjQOvW4gNOd+jKqqZkUw01lBf/5oZWUCxmQLJayenVnkfyzfYVeQqzYwyz4ym2bRYyXTGsgKLKgur6QAsND/UZwbktfXetXb1WvrAoNoqzJg4FOOGmk7obloAlcYh6eIAfOj4IbbPqDZDnoxqZc2W5DNTFY8p/UfCOAHLvw3ifO8UCq0SFoJrZvxHTBqZpt2EmYxdSIySqLSObgjBQlyP/M1MpoaVotTM+LxUVcY9MH/w4Sc7kc7o6OpNY3tnr0VrU06aGRZmKoReoqKmuA0Q8kMiP6h0UM8n8ohK+7KmAgC6I+roRk0gKeW2wM+gJk84fgaQO1/8CB1EIKuyaGL8a2aS6YxxDrKgIN8TWTPjJ+JMFnK2dHTbtqEZbnuJ74s87sVj9jb2pjOWaxxVrg/Z2ZAK1LqLz0xPKuN47QV+NTNrtnaibVfSuD9yyD0ADKiJ4we5JG+qNsl9SVyrLx08xvJ9ivjMqI6T76QmtwcIKMw4CFGqvDhBhRk/DuzG97nFiq47axJojpZCpIUohjBjjgXZPhC5z0yMvs5pu3wKyvICA7CH6TvVUCs1LMxUCMm0WphxGyDcknQB0uoyD5UtfUCyqfHtIclRICY5I2leBJoZP2Y1ObulXHcmLgk3Ank4TKV1x2gmWXiRfWboGOR0r2Vtjup6LM0lXMy2x4yq0SS/mXjMQTOTuxaaFrzukRM2M5ODn4x8q3TdKtCqxmlVG41MvLntV2/txDE3P4vD5z9l9GWVb5WmaZhz7GTLZ1bNjLpvifMT72mhTll743QefvFKV++G02Sq1MwEjGSzluNw7zdxcs/cTF9u7QtLVURaRzfSDv0j8H5yP3MzM4nnwO9YrKrN1Npl+uBldJ1Ds5lwiAmqOmHtuG5JvuSHXV690bf5qGzFA6LlJkV5/giz0qSIh12s3GQBwM/ALavS/Tzc8oNKhQlNcni2GJmk65DKZIxVZI1kXpAHeFWOGoGTtsHLh2jttk786sn3bd8b+WY0q1Ama17ad6WMa1GTiDnW1wlKtaGZybaH9hcqKMv3Kp3RLddN5cCqSqonzlNs/9KqrQCAzt60cYxjSWSZYNvOHgDW+2oJzXYItZVD5sVxY5qm1syEMTPJ2qEAWlFHwUExJqg0M26Oy/Q2eJmZ6D31I2AVos6VUzLGKJG1tHk7AEsaa0FMoQ3zr5nJmZmoM77lWZQLwrJmhgkIDeukDHLJfiunzZYnhag0M2IlIE+2UVW1FoKAkdgp5q2JsO8jD82M9KDSay9rZjSLZsZ6HRYsb8H7m7OOhXbNjLumzc8llAUgua7Ke1JVZyG4mpmAze9UDsC7kmlsytUiijIDq2totkOYNpDtd1SgVV0jVYRbXBJm5H0CwPRxTXjskllYevVs4zsxYNNzd9PMCOSVtzinmKZOIBcmPDuMmclJsFfV51FpvNz6qFv+JRlrVmV1+y2amYjGF0pUWkc3ZJ+Z/DUzpnBMoZoZ0We9Fm+i+8iJLAHr/U3ruuU5Zc0ME5heBzOTW/ZbWWMhS+f0XT72ZznviLxij0wzYwhyYcxMss+M92/kaCw60MmRQFS+khUXf3xhtfHaSzPzjSMnAjBzz/iZ4OQSCPKKWhYyDQdghWYmrnAABszKyXL7wyDb5y2aGXIKcj/KZHTLOas0A6oVtjhNsT/6K7GLmKZhvzGNGDqwxvhOXK8DxjaRNtD2qftSTdy68qaTjyrfUBizrPwIBNG0BtHMKBOyufRRS8Sjh6BA75nT2EGvdW8qg9uf/RCv+ajN5peoIvXcEPdGmBrzve9y/i2Byk/J71ic8NDMpDM6OwAz+aPruqPPTGO9s2bGPoHL+zVfB1FLC4w8B6JwoTTQReWgZ/oaxCz/BX7MTHZTgPdxXc1MmvV83XxmKLUeDsAn7tuMZ79/DH7/tWxGZT+5R2SbuXyu8mCXtGlmqFBm1cyIejsffqLWLIVBHMdwAHbQxsiXIKPrlnNWjdOqSUl85nZJVWGtol2/OXO6sn1OwkCVZEYTP4nHNAfNjHO7vBDtEWbnQA7ADs+p6rlSXVe3dtNr7aXVi2nm8+CUQ4Ze6z+/vAa/WLACX7hjket+gxBVdms3xLgisohHXc6ARspVJfw6AOe0RYoMwLIzPh1f3li/I3jDCwQLMxVAOqMbg4I8IDS4mJnkwUieGP0MyF7tApzNTGGzmgrkAoeyKniTVLZBuQ+bmcl7sJeFGTnPDF1pWoQZF58SWbMRVwye44cNMAS2fMY52fFbXk0nJY0avW9xzWokE5mnhRNglMKMuI9CkHbK+isPxDaHYEXKR5W5QFwHt1WqKqxVhG03N9ZidGOtvX0eZiYhLIjtNE1Th2ZHEM0k/J2CVAF3kntUz4hKM+MmcNNz8hIUNE0z+tsnHT3qNpExTdSci5JiRDMJZ/oBNdFEM8n3hArKVT7NTAIzaZ7azJTRdctYunxDO1p9pLkoBizMVABUKKmSHIAb6tx8ZpyFF/l9PoKH4dBoFC501xDkixyaLQtNG9u68cY69xWCrDL3M4B0p5w1M3KOFr9joCwM1HuYbfK5L3K4pGxyEcKDuF90LIzFNLTuMqMXhg7ITi6iNEVUYdmAfRXoHM3kfg3UPjPOyd2M/Sn2q9I8WPMpCb8b8r1DmQebz4xhZoreZ0Zcr3w0M06CvUiWSFEJe65mJini0YsRDVlhcXO7Pb0AEJ3p2gm3autR0S3VActXMyNrxgXUuVw8Y74dgI2kec5mJnksbd8VTT6xsLAwUwFQ+7e8uhngkrHUPoFbv6djWD4WIbE/08wkHT+jRxKebUwWuXNXrfD++MJH7vtQRMR44RaaHYtZCzJSR2y3YB9ZmPn01JGubcjn8skaJdl9RExeYgykq9F4DNhBQjGFhqMzp/ZX+Xrki90B2LzeboUmZdQ+MwrNjCGIZLdX2fvdzEyAPSIq+312P7KAYggzCjOTqg9HI8xk2xDEZ8bp2U9m7LW+VG4vbn006PM/MqeZ2eykmSlAbhlKMTQz4vkUCRrD+8w4CzNmVmXz+71GDgIATCQFi2XNP+0/Fmf8jH2R2q4on1IKWJipAOgqS37Y3Ewasplp0ogBDlvmN5DKak551Tbvobfx2f95MfRqSgxgImmdasBpdNFQAc7hs27I10SegKiQQCt3y9FMFKrZGN1Y62omBPKr17NLFmZkXyYhHBrmQav5rI2ojcVA2ZVLHhhlNJMcOeFUwsDrXqlDs92imbLvVZEYqshc+vwZ2h2FFklOk1AtOwATM5PKGTYKM5MQqKLQzKTSVpPCHV89UKmZceuiQcPNR+Y0M1tKppkphjAjzExCM5OfgCZHkwq8zEziHv741Km2fQoBnGp35WgmObSchZmA3HbbbRg/fjxqa2sxY8YMvPLKK6VuUtEwcszE1Tk+rj5lbwDAMBKBAZgPyfih9fj+8XtaqjwD4c1MZpmBnLlCMYm/s7Eda7d1Bt43JSWtQFSqYC/zRz6h2TJyyDLVzFBzn6tmhkx4fiKD8rkv3cm0IQR90tGDWxa+b/lerLpiCuEwHovhyD2GAwBGNdYag6GpmYnOzCQEwE1tu9ArVfwOYmbaY8Qg22eqnCaa5DMjC32A2ieECsIxSSAC7Bld5TYIHyazMKBaKAyVNC/32xpDmAniM6PeNiVlfj52ygjPisx+9+1EQ122T3R0q00XQc4rH+TIwEKwy3AAdvaZ6Uml8eXfL7I9u5S0g3lTJcyo8japBH7Rh3sdopmyPjPZ74YOqAbgfK+KTUUIMw888ADmzp2LH//4x3j99dcxbdo0nHDCCdiyZUupm1YUhDOfUw6Eo/bMTj7yoCIG2UPGD8Eln9rDXmjS0kmDt8tYGeQeitMOGB18Jz5ISTl2VE6oXqsDefXjR7UrX235+tPL2WDRzDhDM7/60XLkc18yuumwO+e+1/HKamvoqhzNFJfMTJd8ajJu+Px+ePjbRxjfiTpbUToA77dbI4YPqkFrVxKvrtnuLMw4XIQFlx6JO885GPvu1mj7TlX9Wlxu0e9lMyLgZGYytzOzCJO2ptWaGXGtRHp+mjQvas1MWlotpzO67/2JyKFJw62a22TGGrlSFYsp/V7ctIdBBTQxETvlL3ETvKKgOJoZb5+Zx9/chCWrt+PWpz5w3I8R6u/DZ8aiSST9UNzzmZOGAjD7T29KrZnJZMwMwE31LMwE5pZbbsGFF16I8847D/vssw/uuOMO1NfX46677ip104pCbzrb+Z1SbTtFaYiByMmpTR5ogpo0DDNTbvdH7Tkcd55zMPYYMdCy3b/e2oTz7n4FOzrz83oXk4kYaGgkyJTm7Krca9+2a5PHxCGbmah5hpqL3FKi0wlPduZW0ZxTuwfliF88je5k2ibIAPZoJtkXqLYqjjMPHYfmxloSKhu9MJOIx4z7t6mt26aNSWd0fO3OJbj16VXK309pbsBxe6t9jlTVrw2tSm6cVpuZFNFMZEKPS343gNmX5Aglqh1KZcyq4zEHn5kwGYDN0GyzDX5NTd/4y2sAgA8/sWpQU+mMcY2q4zHEFCVLssd23ndQAa0u50ei0poBziaZqIpO0rEyqnIsMsKEU1/j7DPT5SMZnfidLIBbQrOFz4wi+i4e0/DEpUdh+U9PMAQTw8xEgh/ovECv8xBDM8NmJl/09vZi6dKlmD3bzMgZi8Uwe/ZsLFqkzi/Q09OD9vZ2y18lI1aQThOJmHDkh0KsVpw0OvIzFPTZlatZA8Bxe4/ENJJcDAB+ufB9PLPyE9z+3IfBDpDDEMpiQpgxjze6KZsHhTqtqpAH9nxWwfIENGKQadajBSkvPHIidicVnCnUTBP3odL+1jGT8PkDd8Od5xwcqK1dvWk88U6L8jtTCFWHZlOEoNPZI8oZRGdmAoDhOdPo1p09tgF32fpWvPDB1rz2q6p+LTvvypoZP9E2skAEuDgAx+OWbUwfM/UzmY9/lMDw2yFjhF9hxinHVDKtG0KFeOYKbWYS19Apz4zT/lRatnygxWQLUZU7ndGN/Qozk2ph5UeQctTMqMxMCq1nPKYhEY8Z+W4AJ80MEWZSdmGmbRcLM77YunUr0uk0Ro60rsBGjhyJlhb1YD1//nw0NjYaf2PHjlVuV85kMjr+uWwD1m7rNKIunCYSMQjLD0VSIWxYsW4fdODpNgY6KXeKg9NIZ09+6kj5POh1EA6DXrkO5HPLT5ixnhc1ZdBzHjKgGs/94Fh8/sDdbPugk42fwIkBNQnc8qUDHDUQApXJ6sNc1l4nxOlYfWYkYSZ3zcWkFmU0EwAMHZgdEG/4zwpLbpSwi2JV7SPxGIhJQJ6snPotRVNGM+nKY9o1M+YkotTMhJg75WgmILx/ycV/W4p127oAmOemNDO57COoC0pddfYHTmYmp3PqSXlrMvxAtZSFyG5L2ykEbtVY5Gd8Ev1F9n2hWkmhJVblRVLdSznCMPtb2n7zc7FgW5vrI6Wm7IWZfJg3bx7a2tqMv/Xr15e6SYF5ZNkGfO/+ZTj6pmeNjuWkmRGSuaymNjQnvjUzwQY/sXqqkya4uMPx3OpIuSFCduNxu2ZGmGG2e5iZonAAVmlS/vT1g3HkHsPwrWMm2b5TOdjRaxBl1V/VSn9DqzoiRBBTRDPZ6rxI5xClmQmwriJXbjZrSGUyeqg6Oap2CmFFaEDk1a+fiVfOVZPJmAkt5cUGbX86LfvMRBuaLX6aiGlm4rMINAu3Pp312RD3SSXvuWkR9h1t92dyQxxHLiUicDonObeSX97f3IF3NrYZ72l/zycruhdUgyQWQytaOoxipgI/fcEYF118ZsT1VGpmFDfTNDN5a2b2HtUAIHsNy4GyF2aGDRuGeDyOzZut2R43b96M5uZm5W9qamrQ0NBg+as0XiX1RoQ071R11gg5lTUzUuZcGbcq2n4Qqyd5Rep0vEEudaTcMByAc7MNXX02N2bNFO3dKVcnwHxCs2VUpzV7n5H46wUzDHMXRTVh0Qkuyqq/qmNtaHVfMamimWQBQhaEvSofB6XWIU9SGP8RQJ2ywPQty76X+78fzUzMEIiy76lQLDsAV8VjxuSfzGQM01RM0yzmDEEoB+BcgzTN1Pr4nYwn53zczjrUrsEWjuTimQtqZvrpaVOhacDnptu1lCqEz4yTmclRmMlD8EhndBz/q+dxyq0vGn4flhIvBTAziTGzKm4tG3Jhzm9J4Kf7p0l/ohw6fgiOmDwUX5+5O6aNabRsC9gDNyhGNBO5nk5lb/bM5atZszVctGpUlL0wU11djYMOOghPPfWU8Vkmk8FTTz2FmTNnlrBlhYV20B4PzUzcQTPj5QDsVkXbD8L0IPsKqMJbAVhssyr+8PyHOP22l2yRSSlJw0QjgkYMMh1kW11st7akeT7OVd4iaBE61YRFJ9koV34qs8XmdnXiMYEqmknuK7JgGrXPzDkzxys/p1ETUSEnzZP7u1O/ddtH2iLMWK+NppkCeDqjkygS9f2KImlePGY+J36FZTGunDDVvjgUfdTNzOQmg00d3Yhl1xyPm784zVdbvKKZojQz0euzbWdWs+ukhYiKXuIyQK/l6+taLdtZk0aqz1nXzXtOGTygGvd+4zBcd9q+hsBkiVz1YWbqcQjNFnNRIqYZi9PuMik2WfbCDADMnTsXf/zjH/HnP/8Z7733Hr71rW+hs7MT5513XqmbVjASCnWnl8+MCAEVyGUAZORnJLAwI8xMkrOlX02QzM//vQLL1rfij89bs/nKtZnoCri+Om4kzHPzm5EfYD9Vs+WVsluCQhVeqdGjXPmpTDJeg7FKMyPfO9m0FrWZaUBNAl88aIzt84yuR6q5uu8bM2wJ7+Tdy46Uw3L+PFQIF5uIvkGja+RrE9PMyuqptFkawCk0O4yfEO3fqogrN9x8KLZ1ZgViIWQETZoHZIvh+l0IGGYmB2HG6ZnJRzOjdLx10EJEhZEzLBFzzTacVozjMtRs6YT47ukVW/Dm+lbL/pTCDNHq6QqBvTcnNFK/ryBpAApJRQgzX/7yl3HzzTfj2muvxQEHHIBly5ZhwYIFNqfgvgQdNMSD6mVmAqwSvVitOE1AcvcL2h9NzYw/nxm/PiLbJP+XpKRhokJddSKGwbnK4ds7nTUz4rqISf//lm7wbIfcXqGy9YtXzoooJ2vVSt9LWBI/ibsIM7J2KWphBgCGSskeASCtR+dTdO7h43H45GG2hHfyilce3O+78DB8ep+ReOCbhxmfyfugMrHNEZ74r8ih2SqH7SjMTDFNM8YDv93LTOZn76/Cx8PNzBQmCktGaIBUZibdRcB10uS4Qc3S4gwylom7EA7AZoSpmxBiWZQ6PAdiE7dFFu3Tp932kmXfbpoZwBw/VA7AVfGYZdsox7J8yc+JoQRccskluOSSS0rdjLzo6E5iS0cPJg0f6L1xjoRFmHEXSujiOZ3RIcZUp2gjga3wZJ7RTLKZyWnFIVdzdkKOepIzDVPNTHUiZpyfm6pZnJsYnF9ctRW6rrsOBPLksv+YJvzl/EMxdog67FrGK5tolGYUlWYmmc4gpjkLqWJiokKXrE2SBdMoMwALRCZRStbMFG6A/OHJU/DAq+vx7ZxztuEzI1acHmamPUcOwh+/frC0Tfa/rtiHXTNDa+NYQ7NVWrswQoG4x3GSC8avcCSH6qtw08yEMY/ZjlPt7ACcJs7Wqu+CQjUeKtOjyO8VJaJPV8VjrosdejpZ7Z9zYVI3pZdKYHEqgwBY+3BvKoOaRNyaZ0aYmeKaZczpTWcc55liUTHCTCVz9E3PYntnL/713VmY6tO7n6r3DTOTQ2ehodf0YRQTt6pCL5C1kT/8hqmhyNfMJDtxOjlS+l1py8KMnDTPmqvFVNm7RSipfGR6Uu4PoGp/ItuyH7w0M4X2mUmmMllhzeG+mnlmSCI/2QG4CJoZlWM4zcchOGnfZmzr7MUVJ+zla78XHTUJFx1lRpnJ5hf59vopOyVrZugkaqvdpWnGtU0SMxPts5RQtZkMQUkjNaj87Y8KQk64aWbOnzUhSFNdEakLetMZZDK6RXhy0zTmI1DR8Ui8tmghIspdQ+lNeZuZ/vHqevzpRdPU7qyZ8W9mohhmJkUfpBpD0VargGea/OliLVkGfjMszBQBETb8zIotAYQZ87VhZnIYbakCgE7A3R65Qa47bSoO2n0wrn5kOYDgZiaRpbK+ytqNnJLB+U05LqfHNn1/RDSTuX9dNz93E5ZUE0V3Mu0qzIRdcaoEDIoqS22Ux0qmddfSCoZmxmJmkh2AC+szAwADVcKMwqSw726NmHPs5LyPI/vM2MxMAaKZ0tJKPutDoNm2NTKwEr8CTVObmcK4HVjMTAE1M34mRZH/hTb7oqMmYs6xkz2LvAZBNnPUxkjenJTb8x38WLR/JdP2ibunAKYToY2tjsds46SuZzVPV/zfW5bPHX1mRDSTixCqdNh2Cc2O5fpxMq0b847KzJSIxSzbFiLyKygV4TPTVwhyv2lHFysEJ6GETjhpMqHv8jAzDaqtwlcP2504EAc0MxkOwNIE6OQz43Nwle3lcgZgOhE01VcZE4absKQyoXllDQ1b78VppXvnOQdj4rAB+P3XDgq1f8reo+zFFnvTGdeil2IQpJOYfO/k9wURZhRRbrqu24RTP9FGbpiRSNn38mS/sc09L092H2b76D7imj0RHnXGpT4zcUcH4PCamXjMnhzQC2r+EkVrb/nSNMs2olwHPceYpkUqyABWfzjZqddtwgxrZlIJM4V0AK6Kx2zCRFdvWmmKdyrh4MfMpHpmzMzB6t/I4dkWAS9pOgADZn9wEzSLBWtmioifCBoB7ei7SH0U5bYxDcKaQB8GLzOTIKYBaeTvACwLS06Tjl9hRjYzGarN3ASgaRruPvcQtHcnMaqxzjEDMkU1sDtFTBi/CemhLw9WPzt9XwDZkg9eGX2D8qOT90FVPIZ7l6yzfO52TYQQaM0zY5+QKVGHZgNqYebJ97bgaMmk58cM5IZcwywf4UEuiUDrk8l+MJpmXttUOmOZfFSatFsWvo8jJg8L3CZrO6gDsE/NDHEI/caRE3HWoeMwoCaBnz72rpGq/qDdBwOwVocPmKnAF1VxcyzL+sCZx3PzocrPzGTuTzwndIgutAOwbOZp25W0XF+zne4OwG5Cvvz80iSPTpnhqxMxoMccd1W5d8TYke3HadbM9DeCJAKjKzejYrFLKvkqhamlx0MzI1ClaPeDU2ZiRwdgv2YmIszoum4ch57HsVNG4LQDsom4xMTgtIIB1FoxpyyjgnyyBFNk9e94h3pNUdBYX4XrP7ef7XO3W1qfC6mng6o9mqk0ZiYA+OvitZb3YTUztgzAedxe41mREu/FNbuZKZ3RDQGHljOISf4GgqVrdwRvEEQ7YLQjsAOwZGYSmWmpL5OoTE41MV6pB/KBmuBkYcJt/AitmVH5hxQ5NLu1K6n0PXEah3Qfmhn5FtE5yMmsKq6/sAgo88zktgmaoLGQsDBTRII8b3Tg3imEGZdVseEEqzAz+dHMAMEHBFEzyWs1L8jHAZiqmp2EMjN9u7n/DzZ34FM3P4uH3/gYgForVnjNjPV92Mk4LPLhRb8IpJmJuDYT4JxMUS5gF/b6iZ8b/i75lLSQ9mGaaDTbSrc7mbGUFqAZW2nFdFGYdc+R/qMdZSylEoQ5zXc0U/a/fK/p5RbPHhVmhg+0R6FFQY0ipT5QCM0MEWYMPyrz+0JoGyxmJul6t+1KKs/RydwtC6Eq5O/omOaUQkM84yKaS+0zkwvGSAgHdxZm+hVBBk86pwhhRpVRVmAMmhYzk7XireOxpBTtfklKUrrRFkefGX8dvqs3jXkPvQ3AGlHgnAHZrpW6/ME38dHWTlz2wJsA1IJJj4cwE1YzY5scQu0tPA1SbSxVVldvn5nozUyDatR+F/JAHNasYUYzIfc/fzOTqd0xtS3ytZo8YqDh0JokZqa4JPh86eBs0kA5+WQQqJlJdlL2gjoxOyGePYswQ7JvR0m1IqV+9r3z+QS5l7qu47E3N1pqCgmBIV1gzUwvCeaQNSNtu3oNoYrilMIhHzOTRZjx0sy4aKsShpkp+78czEzsM1NEgkyOdFMhlDhJ0gAxtZCOLye8ckL2A/CLEE6qFVEcyu0D5FX5+yvrcNWJU4zcMTHN2XxlRoyYD1SL5MypuvRumpl8Vu0ycrRC0AzCUTOqsdai7RDRVEGimaKuzQQAA2rU/VO+Wm5RG34w+rnhMxN8H6ZJFpb/cjTTb848APEYNZnoZvh0zPqsCc1Uvg7nuq5jS0e2v8dDRTM5byPOwyrM2JMdRoFKM9PRncTJt77g+Jsgl+6p97bgO39/w/JZsR2AqxMxpc+MyszkdB8NM5PLIykLLFRYc/qdXGySjoUL383WSKySzEzlEJrNmpkiEsRsQbc1hBmXyVCux6Lrumc0k0DsNrDPjBFl5M9nxlYfKaPjG39+FV/6/SKl8NCTTpO6VHFHYUBohugKRvaHUV17N2EmrFYGsNurC+EwGYTmRutK2sgd4pJnptBVswFn3wv5fkcXzRTGARiW31IzUx1JUSA0WIZPQTpjydg6fGANDhzXhBkThmDogKxQkK+q/h+vrccT72QnmXjMnk/HC3oOTohrRx1Uo45kEog+RoWJR9/c6PqbIIuPtze02T5LKvLMFELbIMbMqrjdZ2Z7p9rM5JRs1FeeGYUDsMDVARjqaCaB6Ndi218ufB8/fewdrN/uXty2kLAwU0SChD7TTrdLCodTYeRayf3O6mvifpvlkFW/CGm8SprgnNopP6hPvbcZT763Ba+s3o4tHfaiiMm07pkrBzDNb9SM1dkrZRFWRTO5OABHUWvEZiYpsTTT3GAVZpSamSIXmhT8UlGIUPaZCO8AnP1vRK7kIcwYgkLGKszEY1ZNhZiQDTNTympmisU0/N+3Dsf9Fx1mbJNv+YZ/vd1ieS9XB/fCLb29TENtAvuMasDEYQMK5tBuagbM59MpklMQJLhCpQkUY4cq222U9BrRTHafmQ8/2akUoJzGIj9CqHwMun+n2y0Lk6rDV0uamaVrd+Dul9bgk53uxW0LCQszRcTrgWvrShqSLd12S676sVunlXOt0E7rZRqQ/QD8IgYA2ZfH0WdGGqzXESk+o+u2dqbSGWNCq3WZRMUDSzUz8gMoBuzrP7ev8ZlbtVdRYC8M8kBSas1MbVUcTfXmarpe5TPjcS8LoZkB1BNMlySQhg2eERoop0KTfrDVZiICyggizMhq+F4pNBvIamg0knPGb7kPmXFD6ozXG9u6A5uZ/DiSCjRNw6OXHIEnLjuqINFMgFozM6jWXQsUZPFRr/BNEnlSrAUeC2lm0mya9hUt7UqB1klj58dnRv6uu9f02XHSdAufJTH2quYF0WdlIdOteGahYWGmiHg9cIdc/ySOvPEZtLR1WzQzQmvhqpmRTC00eZ5XjSAjmimgMCOOZdfMqI8nDw70emR03SYUJdMZsy6Vi2ZGnLvb9RXn9ul9RhoOl9t3OlfZvvAvSx2/84s9OqS00kxM0yxCYa2PaCbZRFmIaCYAGKhwApaTJ4a9frToI5BfLSTZJEsdb6lmxtAoKhyAZQ2dKq1CEGi3X7O1M3g5A4doJicS8Zhndusw1EiTKeC9EAhyL1WZt4UgSa9llLXTzH0SB2DppNZu7XKIZvLwmXG5NvIxhJZfVctNIIfGq4ZV2cwkKGXEJgszBYY+ZF7CjNCmvPVxq1KwcDNTmAN1JvefOnq5dzDTMdJ1MxviwZOlcdkhWGDzmSHnqOv2h6Y3pZvZj100AqoMwNS0lkxnjEituKZh96EDAABrtnU67vO9Te2O3/nFHo1TWmEmHoMlJFiZZ0a6d6Mb6yzvvdT9+eLkBEwJbWYipQWAsEnzYNlHPKZZBD8zBDcX7ZGyhmZTTH+3/CZPunDZe1SD4djp1+/LTzRTMZF9NgDvaxPWLJxUaCEKEW5MzUyycL6zN2UzrQLO50Z9sJyQtT9CmHHTqhmh2SkRmm0/vtivl49dMWFhpsDQfuj2vNES9nXVcaUK3E2FJ+eZER3Qj9ov32gmmjPB2k4HzYw0INFBOE2SitH9dxsVw11y7IhifuQC09w6NLIpHtMwcVhWmHll9fZQlYq9kK99qacKOVmbMs+MdO9kp+FCmRYmjTBzrDg5loY9tKyZyWcClOs7GTlacs/Qd4/bAzMmDMGn9h4BwGpm0h2EBkMYz9OsIRYFg2oS+N7sPWx+PX5/L8+JBXw0XKlR+MxQwYKaSgVB5ECVpkPlR5WvpswNI4OuYnGm69nEeTLOZiZvzYw8FHcbmhkXYcYWmm3fRvQVvznGigELMwXGYkpxGVxoJ07EYq7SsApjQk9bNTN+nE7FJkEHrxTxzLe0xUEzIz+UVDOT0U1hRgxmqUzG0My4OTEnpBU3YH2o/vjCR8brWEwzin1uaN2FZ9//xHG/gktn74F/f/dIz+1k5Gtfcs2MplkmLHGdqVlQvneFCMVW0VBbhZeu+hRe+dFx+Nz03ZTbhNbMGL4k9jTtfpEjoszikdnv5356TzzwzZmG8C2u368XfmDbVuCnUKobYr/fPW4PNNRW2co2uCGKGwL+Cm0WAzk0GLD6AH7vuD1svwkSzaTSWBnm+QL7zBhjZq4f/ez0fXHJsZMNgXZ7l9307aiZ8eG47WRmctKeA3bNmGrBJz5SVYovFZxnpsBYJH2XB47m/+hNZ5Qd2E0wqZIm9LQRNu3PqU9uqx/kOh1mW5x8Zqz7pwNQhpiZahIx9KQyWTMTCc12gmZZFdDrJ6qWA9kBe9zQeuw5ciDe37wTbYqVkMyls/f03EaFPDmUeq6IxzTLBC4GLWrCUwmidVVxz2zJUbBbU52tPZSw0SXifoSJZnIzM6mgmplX1my3tMPYJmFukw8paVIzhDYf5+e0ACglwlxHE2aKZ/v4fUYqx7Qg/n4qIcVMaUE/i14zYxZ5zJ7D1w7bHQBw3yvrsL2zV+nHp0qkB/hMmmdzAM5pZlwWKdVSf1Q9JzrU/Z41M30YOoG7PXCtRCLvSaaVwoybml02tYhj+VltiYV54KR5TpoZhw7dLU2I9NroVDOTG8wsDsAuD59R/8YhmokKiuJhG5XzBYkin4wT9mim0jsAU8SgNWm4aeJROYt7hfZHjZMwHDbs09Dgpa3PSD78YsEKbNvZ4xkeSwX9j3fsUm5rpBbIU5gRmiZDmJGSA7r+1pJErbyEGeoATtNAqHxEgoxdKiElpZi4H39rY973xAlDmyKdg6iDtV0RRel0H0Vb3YYV+Z7u8mNmsiXNc96/PMZxNFMfJi1N2E7QCbeH5KSguE2GCckJ1hjgXNSJ8n5/+PByvLRqq+f2AkefGYcHRa61QwfSNFF30wgQ6jDnhCrPDB0A2slxxbkGrV+TDzYzUxGeNhGpoap3tCuZBj1bcQ2mNA8yP1P0F6+ki1HjZNoSKQryRa6uno8VgSYF+/fyFnPR4JhbybzionyG3C/E85LR8+uPaUkzEwugmaHXQJ5gS+UzMyDXh7uSZmi+uGfZkGL7b4JcN1WdtqShrTM/605mcNdLq33v19+x1eZ/Icxs6wxgZvKhmZEd9kVWeLfxVDYzqfqRYZq0jXEszPRZ6EPmZsMWqzZARD6oNDNuZiardkIsKPxIymIQe29TO87+0xLP7YGsYCYGGLuZSX1M2aRDrw3VqpjCjG4bqJXtVxTZpA9ge7c5KMqqeCfNjBAKxg3JPzGYfO2LoZl56NuH4/QDRuPP5x9q+27EoBqLkCxWuLsPrcdZh47Flw4eo8znUajcMk44DbSnO/jS+EVoL+UMwEMH+C+YSE2WPcm0p98CdWLt7DVLc1jaRZ6XfHLNiGckkYdmhvaHcjEziWePJrWkJm3VcxREgaLSzIjLII+7P//3CtfkmkHJOAgBoj7ZDpXPjINU6eRQTmmQnOn9+MwYJQpINnkn5DGulH5XLMwUmJRPYebVnD0dcNbMuEYzCb8RIzQ7+99fIizPTWzQAcGeNVbdrTp6Uha1Lb029LXwj0laUsA7t6VKyn4MWK91m0Uzk/0vO4PKiOumEgr8Il/7YjzmU5ob8Oszp2MPqQLzAWObcPr03ZSrbU3TMP/z++PGL0xT7rPUmpmbvzgNL1/1KRyQqy6dLzbNTO5i3HDG/pgxYQj+8LWDPPdBV85Zp/Xsa6fnrDtp7192M5N5vl5OwOu2deEHD76JVVtIkUTZZ0bhEO9E2iLcWr8bM7gOpUAU3OzsoWYm06StGgYD+cwohRnd8p9y98vRaWecIpAMzYzCZ8YrA7Db2DhI0tD6iWYSAklaoa0SiI9KoX12goWZAuPXAfjDT3Yar3tTap8Z9wzAVs1MJoBmJh+NATXpyKpMt4RMVEti1VrZMxZbKg37CEunDsD0ugszU0wztRFifzc9sdJ2rXVdN7LPqhJs+aWUSfPke3L1KXtj2MD8CgPWlFiYGVAdx+im8BNrIqYepMcMrsMD35yJ46c2e+6DambSGbuJR0b2E1NtSzUz5979iutK+KK/voYHl36Mz/3uZdIOSZgxqma7ngoA6zMor6pv/uI0HLvXcNx34QzvHUWIoZkhZiZq0tYUy4KwZiZTW2ff3i25ZlCcfKyERnR7IDOTu78WYBc2fAkzPvIxiY9YM9OPSPvUzNBokR6SYIsSZEI3NDMFEmbESoke23zv3K2oozNdTanNTKa5zT0s3W5mopdaXrnS37R3p/DPZRss+8tqxrKv60IJM9b3xdTi20ImcwfX4X/QF9QXW5gJ0J+CEJf6ScZhYvELTSfg1D9Vwow9NNv84NU1O5R1ygQrWrIamQ6yKBDnI5tQfTkAu0QzjR1Sj7vPOxSHTxrmuZ8oEc+cxQGYmJlUlzqIZkYVHSRHp1GiTE/gtDgTmhlhZjpxajNO3q/ZsU2AKVAE6b/CZOaUPgNwFvpVcDRTP4IOFm4ZJak62tEB2NXMZDW1BEmaZ0+W5T0wUNu+rZ6PyzGpycea08F8XWtEMxE1vo9SDl4mPfrQ09wqa7ZZK71SG3ldiIm8lBmA4zHNMrCYfhTB93XdaVPRUJvAFSfuFVXzXJHNWm6aviCYg7Q1ciWIrPTbs6Ybr9MZ06fLSb2uWgHbQ/b9O97Sa9HRnX2W0saznj2W6Gd+IvVowrxSl9sQDMiZmbqUPjMx5XMUJJpJFaHkVkm9EMKMXTOTPWdhvh9Ym/DMF5RP/zV9Zlw0M9Jc4jYfyH2ZhZk+jF/NDF3BOToA+yg0+e7GbBp+sVrLRzOjSqktY10pWX/v9vBTDZSToKesZ+NyGnIpB6cVqWVyJ02UH1ax6q2rioeqQVPq0Gw6YIUZZPYYOQjLrj0e3z5mchTN8kTOKRRVCYVYzDrJm/5Y/q/NZ6eNxlmHjjP246Xq/9Epe9vb4XE8t2Rt9Fr85NF3ASjMTAFSLRh1mcpEkAHUDsDUzKQSHMMmzROXSrUb0R87e1KhyyZ4RTMJEmQx4ugzYwiiATQzPsxMds2M6vi5PsflDPoPFlOKy4PQY9HMpJVqU7eO8v7mrPr50Tc3Zo8rRTi4Ie93Z0/KYUsTYWZSOfu6HZMmPqMLJPrAVqvMTEEiuci1o6nP4w6aGXmwaM+teOUBJih2n5lQuwsMXcWHFaSKGXIp57VxS/AVBNsgnaeZSQjbmYx3tN3uQwfgpi/sb/nM61q6ac/oQuH5D7LZq1PSsx6karYfv4tiI8xMnaRquhhvqhNqn5k/vbgav33qA1/7VzkAe2lmtnf2YuqPn8Bnf/uir2M4YUQzOfjMCGI+hBnRT7zu3a1Em2j4zLg8UzHb4tC+jZPPDBea7MM4hR9T0hndkv2zN5VRrjTcJvT9dmu07tNQQXrfYnm3nT6EGdHRVbZXNx8HqzCjjmwyo5m8V76AeV2SRo4dc180hwqdROhDKAuOQjMTtTBT7BwMdOITbSlkLaqokDUzUSXiktXnXv4uThjqf52YmVz2ITtQe52Om2aGrqiFBkNOmheknIGXmawUuGtm1D4zug78cuH7+HhHl/1LCdX1NYQZxTWrTsTwfK7sybshC9CaofzWz+WxJq5pxJHbyWfGW2sNAKdOG43Judpn4pq6mW5NoT/XZjYzMYBz+DGF5qIAsv4zQfPMfOPIicrj+tHQy2pK6lzohJvmx+1BoUIble3o+YqVeTKd8czjQY8n9kGfveYGs1AibSvdnzyACc2MnKMhKDbfiFB7C47VzJT9X8AcgZFh08xEZGaSEyU6FVj0wriWxMzk1j9lM5nX6tVt8qACqvDncnQA9mNmylOgKyRVCh84L58ZgR+tsjo0O/tfNe5WSf5nYXAyDTVImhnq8+acATj73482RPR94Zvp7jNj9S1TdaNjpozIbWvdD0cz9WEsTq7pDJLpDO5/ZR2Wb2gzPpdzUXQl04EzAFOnSV3XiRDgfYvllYosXKl/47x/pzwzgFUzQx9S6jNjMTP50Mw4lXIArKv8mIMw88cXVuPyf7xpvDc1M+GEmVIXmqSqZHHsfKKZio3sAByVA6Y9z0z286AaM9Hnsw7AuX24aWak9qu0mQsuNQuZuiWAswgzOQ2G7Oyfn2amfIQZ2RwImBqF6oQ6A7DAT7FO1aIyowMrWzqMxIbyd5EJMw7RmXLqgXhMMzM5O/SHICZC0f4gPjPiOnVL80F1PIav5PzGaF/WNM4A3KehQkk6o+P6f72Hqx562zJ5yuGbO7uTRqf368RJv9N1Imz46FtymQE/Bdby1cxQ52IqRBkOyxrNQOlvsrCXcrBreQDrACK3+/9e/xif5EJiO6LymbFFM4XaXWCicgAuNrIwE5WZSa6urueplRCXNZXRiTnXeXtZGFNNJFOaGzBiUE1uv/4cgA3NjM0B2N08QfGjWSo2Zgi9eR1W5nwCJwwb4DoW+DORqzQzuiVxKSWt666a3CA4lQEYN6TeMj7EY95mJkOY8TGLi2dIXB+30Gzqq/PB5g6slaI9j9lruM2kCZReu8fCTIGRw4+F097KzR3GYPrvtzdZftPRnTJMMDUOk7EM/S5NNDNuWhKBXGYgyOpG9VC4edd7OQDHNM0QhnpTGZKy27ktCbJSBqyDDfVXsEYz2dsojiU0Mw2ROwAXWTMTV2hmyl8xUzAzk6mZsQq9QedxI8zdogF1MTPZhBn1tqZZwfnYVMtj+sxYn8UgeWacHFJLiZxmom1X0ij3MnVUo+v9ok7DTjiFZovP5ec+nc5YBOp8q5sDzll7qxMx7EYyLsc0zWbusbfZ3NaLpvpsyY4PtmSTs44k5ncZKszc+vQq2/fdZAyn16XU2r2SCTNr1qzBBRdcgAkTJqCurg6TJk3Cj3/8Y/T29lq20TTN9rd48eJSNTswspmpkfhhbO/sRUd3Ev/vX+9ZftPRnTImVquZxPk49Lt0xqyb5Edql+3MfurDiAcs6KrZYmZSRHplhRkxmGXgx8FSThhoNTORCZ1cC7fnX6hi66oidgAutmZG4QBcET4zcmh2oaKZ8jQzxch+fDkA+9DMAP40KvRa1Eo+M6INppnJ+RwE5uRaPsKMUWst17Yduay4A6rjaKyvgpv32c4ebxO5SvOc0ekCzXp/0pKZyU/qCifcCpM21Zk1wuIxKlSo9+UnbYVAaP0E44cOcNyWPicq7XQPsSSoclmVinCjdQhWrFiBTCaD3//+95g8eTKWL1+OCy+8EJ2dnbj55pst2z755JOYOnWq8X7o0KHFbm7eyJoZulra1NatHAR39qQwNJPt2BYziU8zU4ZEWfjRzMgTnC/NTNr5oXSDrmqsztEiYzExM6V0VMW9bfpV0uCXIasfi6lFo9fIvh/xUYpEToSh1HlmqKBZ7GKRYbAnzYtKM2Ou+GlUV9D7YtHM+HEAln1mHJ5Jr5U4AEtYsk0zk9tvkDwzZmi556ZFQxY6jaSAcZEU0Pm3fsxMTuUMxPgxa/IwvL+5w8i2nMnoFmEv61OYnz+dm2mTarnjsRjiMSF0O5iZAqQWGC4LM8OcC+jS50R2TAaswpy1zf1UmDnxxBNx4oknGu8nTpyIlStX4vbbb7cJM0OHDkVzs3fdlHJEzjNDk8Zt6ejG8IF2dV878ZmhA7ubFoR2aLpizKeDuWUqpsfItsnfKJiIaUhldMuDYHUAtpuZkukMdD17/u7lDKx5Zi59YBmArEnF4gTrld8jd69EW9zsyn6wFZos8rNOh0Bhbjt80lA8+uZGS/6dcsOPw2w+iAmbPh9AHmYmUqXdjxOmHDlSnXAwM/nQqNTXmOOBGBvk1b45GXk/x+UYzUSFGd2yMLP7acjk7zNjjml1VXH853tH4gf/+xb+d+nHtkVobxjNjIvDNS04Gtc0T0fuIOUMZM3MiEHOZiZ6/RsVEZ3Ux5Me208kWSEpI3kcaGtrw5AhQ2yfn3rqqRgxYgRmzZqFRx991HM/PT09aG9vt/yVCtnMRIWZZFq3DDhfPngsgKyZ6cNPOgFYvdz95FoBsjb3QgszqnpHlFP2H2V5LyIvrD4z1DnarPItVuK9JGmemyAi+0K8/OE247uEgxpUtdgRwlDKyNsR7vEotc+MrjC3/ey0ffH94/fEo3NmFbUtQZDvdVQZgONE6KXzQ+BoJkuemdw+3ISZwJoZZ43KQFIFWd7e8JkJYGYyBffymQoSUkJLOZu522PpK+Gno8+MeR01kueFam2AsGam7H9Vf7FqOazCt3pf/jUzwyRhxq2ALjWjDqixb9fr4DNTasqmB69atQq//e1v8c1vftP4bODAgfjlL3+JBx98EP/6178wa9YsnH766Z4Czfz589HY2Gj8jR07ttDNd0QuZ7Cr1+wIdNUxfmg9fnqaaUrburMHA6rjOGoPs8ibq5lJcgB2s8164cfMJA+gMv9z1nT87uwDjfei3oqTMCMGC02zZvRN+7ALyxmAKXQioQO2KkTZUGvn/leFfFBLHc1Ex0Ax6DTWV+GST+2BcUOd1czlRtR5ZtLEPATkYWYiDrZ+6uP4iWai+3UTZmi7hbZAmEXF782oLe9JVzyPUdYfCgtNkZ/K2DUzqgzAArEIdEN1fTO63Q8wTjTE9FqG0cy4BTTQ8SmbAdga2GBvs9qZWIUYf8X2bmZnqplxSiIoKLVpiRJ5D77qqquUTrv0b8WKFZbfbNiwASeeeCK++MUv4sILLzQ+HzZsGObOnYsZM2bgkEMOwQ033ICvfvWruOmmm1zbMG/ePLS1tRl/69evj/o0fUMHn2RGt6jo0hmrhkPuYM2NtRY1n99S79QBOB/1sR/1tJdmRtM0i9QuVgK9aXL+iqrZ8ZhmrMSzZibv85AdgCl04qA+MCrNTNpmZgqpmYnLwkyRNTPkdTk5eAYlqgGTCgtWYSbYfsR93Nja7UsDKmc0dvLFopmFVbR29WJlzo8DMIVVOXeJaab1XpTQmkflQsI2llmFNbeu/PKqrZ77VzsA60aeKiFEiOv56yc/QPsuU+MTiZlJcRJ08ZTwFZqNXHu9O3Ad0cTUV8VdxwOq6aYaqd+dfSAmDh+AX35pmm3bciByn5nLL78c5557rus2Eyea2Wo3btyIY489Focffjj+8Ic/eO5/xowZWLhwoes2NTU1qKmpcd2mWNCaS+mMju6MdTIXk3hVPAYt5y8iHra66jgGKNTKTsRjmjFQGyGjefgb+Msz4x3NRB9YYet31MykTTOTEE6eWrEFn502Ovu5y3HkJE+q7+TXqrT+aWmlG9oB2KaZKZ2ZibH2E9pXgt4X0T9fWbPdeB1FNJOXRmXGz5+y+pzpwixqFaiMJJI+7ExlqZkhzykt5unHZ2ZbZy90XXedrFWLNYtvjhTiDgCPvbXReB3KzOQi/FItdzY0O/vaKcReD2Bmomalumr3aZ9qZkR7P3/gbjh5v1E4eT+r+0CfFmaGDx+O4cOH+9p2w4YNOPbYY3HQQQfh7rvvRsyHj8KyZcswatQoz+3KhQ5iw5XVhbpuX3VUx2NIpkVocNwiUXsKM5qGNPTwmpkIfGYAq227vspuZlKHZlsH+8dyhTPdQ7Pt6c8FjmYmF58ZsUILaw+Wu3PRHYBZlrFAo4Vu+e/7xudBhRm6vfDPchMG5H7kZJr1CqmWJ1G5OKLYbxVxUPZCCDzVETlZR4HFZK7wmfG6XemM7uo0riw0mXEuCwFYn6VwZqbsf7XPjNV8Q31XVATJk0SFGTd/GXFswOqu4DQW+g0AKQYli2basGEDjjnmGOy+++64+eab8cknnxjficilP//5z6iursb06dMBAA899BDuuusu/OlPfypJm/Nhp0udIyr5is5SlYgBuZTaddUJ1DskfVMRiwFIi/3mlwcGCJoB2Lkz0wfWcACmodnkODTfhWrl6qYFF+pZlRDmaGZS7EdMCmkxqIVUvcvXptjCjJ/Q3P4EjXq75+U1xudBV5eq7euqnCcIefswPjMUoWCwaWZIniYvxPNYTpqZWExDTBO5XzK2MdJL+EymdSRc5mt1OQNzzKxSCTNkxPBT7sUJN6ddambylwE4+9+PCZlqY3wLM2ndHAsdndY9D100SibMLFy4EKtWrcKqVaswZswYy3dUPf6zn/0Ma9euRSKRwJQpU/DAAw/gC1/4QrGbmzduoYIWDYoQZizpymOW0GwvLQv1vjeiLHwM1J+dNhqPvbnRMHH5SZrnJ8+MxcxkRDMRB0bqT0TKGahCV/1oZjK6XSVLrycVLpSaGWFmkga1fInHNJy0bzP+s7wFQPHNTD7nxLJE06LXLNVVZ+//Lql8SODQbMV9lHPjUDTNnJyBCIWZnDnZSJGvCTOTf58Zw8xUTrMSss9qbzqDVJqOkdk2ej1GyUwGdXC+H6pFjw57vTn6vEalmXHLGC1rZtz6gzVPkvdx6aLYK+cUrWEWpGBxqSlZE88991zouq78E5xzzjl499130dnZiba2NixZsqSiBBnAPVSQ5jYQEy0dVOqrE5ZB0kswsWYm9a+Z+fWXD8Az3z8GXzgoG/UVKJrJR8g0YD5Acq0q83XO3KZpSm2P34SB8qqLqputmhlnn5kow1Vn7z3SeM0+M/4pxJWqz61OO3vSFk1KUOdo1XPoppkBrIK00zPjtRKXSUshw+IYVXloZsrJARiwCnayqcNTM+MhbDjVZqKh2dnjqH+vKkbpF7foTDo+xTV3YYZ+FNQB2AtaHsZLA+9HYC4W5dWD+yBuwkxa1w2btWzvBrKrvZoAYXBmynpTM+Ono8djGiYMG0Bs7dH4zNAxR0R0pDJqYUb4qTiZmdwGsCpLKKe17dUBNDNpWTMTgR8BVd8X21eugmWZgiBytHT2pDBkQLXH1s6ohJFan6p7wNmkI8YAv4UMl61vxdadPeYxjDFEOAAH0MyUkZkJsDprp2WfGY/fep03XaxNHd0AwFrOQFX6gz5LG3J1ovzyweYO/OmFj9CbypDikArNDBmfYkQzozIX08/8CONBMoCrfGacxnk/AnOxKJmZqb/gKsxk7Jl6q6VCcgNJbQyvLkuTZaUlx2I/GFEQPgZTQ/PjVn2VPGSiYCaN1KArUHPAcjAzuUYzmddMHsgsZiZLaLb9HFOZDHb2pLBma7ZKbBSe+vT4RU+ap/QM6r8IU+euZBr7j2nEhtZgk5JA1RdrPSYL+hMnzYwQ2FWaAxUffdKJw2942rZfuYq8G6YDcJkJMySyKyVpgb001OKctu3swYJ3WnDqtNEYRNLyiwl4waVHYvmGdnz/wTctPjNmNA/JCUaepbXbvXPZUD79q+dzx9UNPyfPcgYeGYCDZrCmY4/X9TPOP2336ZRJpspnjGFhpsC4OQDrRE1sOABbfGbiGDawBt/51GRogCVMWwU1M/XkMUgZ+Sl82IRl+7JbewBzZSAnERQIP52Yg2bGvZwB0cxIA7jVzOR+LTIZ4Ct/XGxMclF46peyJlJl+8xE7zSjen6+86nJgfej6oteanx6L6oc+kSQatduvw+SZ6ZcNTO0PpC84JMFQ1n4E8LMOXe/guUb2rH4o+347VnTje9TxHQidkU1MwkPzcz67V15ndNbH7e6hmbLC6942lycytD2BDVfz5o8zPV7i8+MpBWTCVNBPGpYmAnB8g1t2NzejQPGNmHoQHVeG/+aGau9GzAHyMuP38tXe6gDsJCYnQZOFaatPRqfGfqQCTMTFWC6pRw8gJvPjHNbaPSDvIqxmpmoz4ydVCaDtz5uM95HYWYqpS9Cg6LibaVQCB1WTSJm9JOO3CJjoMcCQYXqlnr5zFCzQJVjZEgwnxnb7w0H4AB5Zkieq3LCMDORki/m82v2jgE1CbTtSlp+K8av5RvaAQALlm8CQISZtDl2iVtB88yIKEbLYotcyw6XBaobVfGYa9ZeOj7FLD4z6vILAr8a5B+ePAWvrdmBbx0zyXU7i7+Sh++lH+1fsSivHlxhXPXQW7jgz69ZJkCZLhdnsbRiNVAtaWaCIPpbRteNTLtBNDNumXRlfOWZsfjMZNvx6poduOvF1djS0W2x94sBRtPUNmIvE41w1pVNZNbVjvl6/zFNtn3Ix43CAbiUK94bvzANU5oH4X++Mt174zKjEBY5TdOMtO4d3dkJMB9ToqovukUzAdaVtJOQHA9oZrK2yVw9G2YmH/spX81M9hz++MJHuOr/3rZ8Rm/ZAIVGTI42kjUX1E8xRheAaetYTIUZS0qJPDVnVJjxFc1kOITb92X1mfF3/IuOmoQ/fP1gwxHeCVr2w8tnZuYkdy1PMSmvHlxhDK7POhFu7+x13KarNyvF7z2qwfadrutIyw7AxF/EKx+ADDUzCc1MkEHKrcaRTNBoJjrYX/f4u1jy0XbLtiliZlINFl5h6U65Zuj500nk89N3w/zP72dtg+xvE4HPzLSxjditqQ4zJgwJva+gTB4xEAsuPQqf2X900Y9drghTU3tudZ1PhJnK38pTmIH3StrNzORleqLPoXiOu5NprN7q7t9RjuUMAHM8/OeyjUYovSnMWDUzMraIRul6G7XXclnXAVGc1+pnSDVkVEDys9gT0L5SFY/ZSk9Qqhw0M8r+EMLM5AXVzBgpOByOsVfzIPz5/EPRUJvAvJOmRNqOoJRXD64whDCzo8tNmMk+iJ+aYs+KTPPMKDUzAYUZ6v3em4fPjJGfogB5ZoQDsIBqZej+YpqGkQ12k53XCtrQzEgCCV25ydECZx06zrKtnGE1CgfgmkQcz/3gGPz9wsNC76s/4VZMMAyirIYwFeRzj1VzmZdJkk4+TlpGt1BcL20APQ/xHH+8YxeOvflZLMjlOVJR7poZilFoknxVrxBmZGGD+nusaGm3aJWpNtvmM0OuOR0b/Cz2VL+rjmuuie6CZACmbSuUMAOY/cOtLM7Rew7HWz85Ad882t18VWjKqwdXGCK8048wo9LM0DwRKp8Zr9WeDI1mymeQchIIVPjJY2MNzba2QxYcaNXsUY11uOOrBzruS4VKNQxYBUKvjLhygsMozExiP36SFzKEAl2u2pzvltCY5nNfVOGoXqt1P9mY3fOKeGlmqAbS2m//smiN4+/KsZwBoB5XlJoZxYJPDmCgk/OJv37BeF0Vixn7ojm/VPchX81Me7fpz7N6W5dr0jwqEHsVmqTjZdT1kej+RCBJ2NIuxaByPQTLANPMlHTcRgyae40cZPtO12FLCFUlhWYHgUry+STDqs4rz4zz/q1J86znIvsStbR1AzAFxGOnjHDclwonfx9qH1YNQjRoRnbWjsIBmCkv5H6SzxitEjamKXywKH58elVVs6/43zeRTOu47rSpHr81X8vP/IhBzkV3y1Uzo9I2qKpmq9ot+82JsVU2D2Z9ZrKvs5qZ7OsqhQMwFWaC+MxQZ+Hn3zdL9ihDs6mZKeaeNM/uFB0dtP/0GCa+8uofKliYCcGQAdncBTscfGZ6UxlDyzFcMaCkaSryeHgHYPGAdPaksPDdzdn9BRikxLZ+0nXLFWZVWKOZrO3Y1WsVHD7Y0gEg6+cB2CM+vHxmEiSU0/I78rB7rag6e6wCVjkVUetvFEqMFP0h6eEL4Ibcx848ZGwkWjxZu7izJ4V/vPYxAODbHhEoCYuju/WcVGOPoKdMyxmsaOmwfaYqM6ASepw0Mzu6krbPDZ8ZXUdGMp1H4TPT1aMOAFENLRYzk0cGYDMiK/r7RoUZw1+pAtZ15dWDK4wmD5+ZXUT7oPIgp6FvwvmLagOC+swIzcxNT6w0PguiXTCEmYiimahqXPaZkTUz4nmdOGwAAOvKRLx3gybZckJlPqN73dljHezcBDWmsBQqv6C8ks3HzCRPLlGZEGUfiTTpr7JZVoY+K/JCwCltBGBqjr0iXMoBlc8MFWaE0CabAcWE3y3V5KqKx0g0kz2ogd7nnnR+woyIKpVRFpqM0/HO2XQO2KNgo4T6Eon0GWGL7haD8m9hGSMmf6fO3ZkbKKrimlJDonv4zATWzOR+unKzuaoJkrStOp49ntfACfiLZqJjimxm2uUQsj6iodZ4LeddcENVXO8rM6wOviohjTri7ZRWUSzKlI5Dxmejv5rqqzy2DIbcj6LQzEQ1oYjnVzxbtL96LTBoG2Qh3K11YlEhHKPLGZXPTDwGvPKj47Dg0iMxeXhWq9ubloXN7H9Z40wnbR2qcgYOZqYgDsBJ9X3zTJoXi7mmyvCTgT0MibhVAKwEnxkWZkLglgcAMAcKJ6GEOgCLTkkn/aCrJdXAXCgzk1jRuamnLZqZhLtmRkBDLast3v3u7VGFlV82e0/LNl6ZjWUHYD9CHVMYbvnSAfjmURPx0LcOj3S/8uCfj/Pk7L2t/lxRRZPQAn+AdRJzEv4FcRdhxi0JnyHMBNQClwIxvtFbFtM0jBhUiynNDebkLwstud+pnmfTAdheVNFpbEtldN9FXHschFBVnxE+mEB2vHMynQPETFogU7g4d9PMxMJMn8Yr/biY8J3KEKQz9hBnat8OnDTPQ9r3QggzfibxdbmU3mOH1DtuQ593OTKrK+kgzNBQaqp29UyaZ1/FyJdD6QBMXssOwCMUIeJMcRg+qAbzTt4bE3Or7aiQB/98TESjGutwxYlmVu6ooklkB2DqMOqWfFNug2xmcstRU65mpnMPH2/7zAwPVpufxQQsm5nEtVEt0sSwklEsLK840Tlvil8nYKeFoarL0PEmW9bFOSDDzJVTGCFD7FdolqKOmCoELMyEwC0PwNMrNuPU/3kJgLPvi67bfWZojpWgPjNvrGu1fRbEsU9s25vyLnG/dltWmNl9qLMwk5ESRlFkB2ABFfyoQ5yXMCMmqR7SdvkBVJuZzNeijlZTfRUe+vbhGDGo1rY9U9nIY3++Y/SwAeZzGtVAL1fNvuqht43vuhyeF1Ub5BImtNt3dCctQn25amYumDXB9plRaJJcbqoxENdPNjMlFGODwPCZyQBdPaZbAACMbqrDFw4ao2yfX1OT08JQ1WdGEhO7Dvfq5+IeFkrIsJmZKsB/kIWZENBaSDLn3/Oa8XqAw6qHJs0TkzEVDiKpDRTAzCScdL3s872pDDblQqnHuWhmGupMfwf5oXM0M1U7mZncr4UQBungEZMGP+GH4UTrrqwj9/SxTThw3GDXbZnKRNbM5Ks+D6I19Itb1WwvzQz1aZAreAtNz47OXuz3k//ic797ybbfchNm5IABQO0zQ4cFI0+WXM7ARTMj9rWpbRc2tnUjpgGTR5hpNByrRftILOp0TNomyhBiZtrR2evhM2NmMS4ENjNTBWhmyku3WGGIcVGlmaH5S5wGijS10+Y67oHjBuMrM8ahuaHWsx6RH/LTzHgIM+ThcqvkPWHYAFz7mX0wZEC1bVDY5WRmqglnZqJtFxPV05cfg+fe/wRfPmSs7XfZTLPZe/D+5p0ArEIY07eIIpoJsE4iUc0n1AFYfga9zUzqGmTZ/WX39fwHWbOVKMAImL445WZmkgMGAPN5tkQzKTIfZ3SrT0tCsdDZd7dsElPxcxG2PXV0IxpdFmECL/87gdNYOkgxbtJzmTKqwfDhc/eZKayZqZJ8ZsqrB1cYZsZde2cbOqAaW3dmV/pOwoyu2zulpmn4+ef2U26fD6q2OSGcdDe39yCT0R0HerpPLyHj/Jy6eH3Ox0bg5NBoMTOR43tqZuJ2fx/RtvHDBmB8LuTbhmK3DbUszPRV5H6U7yBNtaZRDfRCIMnouu356OrxMjM5fyfWHvS5zWR0/PfdzcbCpNw0M7UqzUxcEc2kyDlD/V8AU0gQZqYpzYPwyLePAGAvK3Divs3WY5L+MmRANdp2JS0adS9Upq3zj5jguFB9/ZpPY0dXL3ZrqsNHn2QXV9s7e3HkjU/j2s9Mxaf3GQnAXzRpGIRAbORBqwDNDJuZQmDkNlGYmahnuqgfIkdBpDN6wQu9+ckZI6CRTzf/d6XjdtSh0O/D5MfMFI9plqinKovPjL/9W81M3u0a3Wj3ixlUyzJ+X8UmzOQ5SMt1vqKAVs3uSlqFl18ufN/9ty6dXZjBqTDTlUzj4r8tNd6Xm2ZGpVFW5Zmx5KJSlHPJfp79L8aGIQOqjclavnUiaadq//GYRlJA5K+ZcfM/GTKgGpNyTu90/Fu/fRcu/IvpupAscGi2PB+xMNPHibloZkRafgCoz0Xy/ObM6bj73EMw59hsNs+0rhc8nfh+uzX63pa24XfPfmi83rqzB394/kNsyxWHVK16vLALM/aVZn113LJioQ+U1/URk4vKzOTGH79+sO0zNjP1XaIyMyUKopnJ/s9kdE+zkq09LueRzoUS/+B/3zI+kzU95VbOQKW5MEOzNeV2xvXTdYuDrtheCDN0wSQfR/ZTtDgYxzRlCgg3lMKMzz7ntsBNFzADcPbY1jaWm7Crorx6cIXhFppNQ6yFsDOgJoFjp4wwit1liGamEIXe7r/osEDFKp38ay7482v4+b9X4NIHlgEwV3pBpHV5W2Feo2PJQMmOTB8olQ1dta1bNJOKPUYOwrvXnWD5jM1MfRe5T+S74LRoDSNLmmfmFfHKK2P/rbswI0zeAloA8RdnRGfWLiS1OVOYVTNjvjYjk3SLRlpsrlo4ypdNFg5oteh4TDOEWFWxURWqaCa/woxK69LS1o3uZLqgtZkAuyDVUMfCTJ9GVRhOQB+Y7VK5AzH4ZXTzoSvEyoiauvzg1IY317cCAF74YCsAe3VZPzg9dDR6STbv0AfKK5NxQnJe1jT16k5FXVXcMkCymanvEpXPTBB/Lr9EqZk5dq/hxuuMrkOHdYxqJXWKTt5vVMCWlgaRd8vRZ4bUVKLChhifTc2MuTCSxwhbUkVJM2NqgH1qZhTmKL+J7uR8QQBw2Pyn8I0/v2bLiRM1smamEhZ4LMyEwCwEZn62dlsnjrjhaTz0+gbjM7kQpcq2WwifmaBOfVSYUTngif0ZwkyAicBp9UrbOEh6YGieHVWoJkUM5uJ6BgmX1TSrr86ACkjtzuSHTTOTbzQT6S9RmZno4sgrr4yMfF63njUde4/KRuykMzpkRULbLlOYqZSCqvUKzYymEGwyutUMZJSH8KGZkcdhWWitDqiZCeoz42e7F1dtLWihScB+HRojLitSCCqjF5cpqhoeP3v8XWxo3WXZbrqUs4Tadg3NTATCzHWnTbW8dwubVuFVsVuYgaLUzFDTkqwRqbZoZtwFDDn8MugEQ81xXsdiKhe5H+arVakqgAOwaJuXmen8IybYPpPPY1BtFU7OReZkJE0FYDUzlatz5+y9R1re1+W0uBqsAoZAvJTNTGLiFyboGoswI2lmXITdbL0k50R2KlTRTFH4zBReM0P9ioCB7DPTt1E5AMudfGRDDS4/fk/l7zI6iWaKwMz09ZnjLdE5QTUzdJUzuqnO9r0QNtIR+MwIaIE7WTNDBxq/ZiYxeARdsNQSAabcnCGZ6JAFj3wT3lkdgEM1ydwP8cFzMjPtM6oBp+zfbPtcNUHSDOWyIoGamcq1iOAfvnYQDt7dXAjWG2YmcxvLa2pm8q2ZkR2AnTUzMeoz4zOaSeUz43fcdEuaKo5fsNBsst+G2qrIBPZCwqN2CFQl2uV7fsmn9nCcpGlyrJqIzExaAAFAxRGThwLIJryTGZg7j3w0M06aknoXnxkqkHgKM5KZKbhmxr9/DlO5RKaZocJMRM8uFT6cQn8TcU0d6aM4D2oGlzUzLbkM3poWnWYpamIxDQPJmCDMzo7RTIpFImCeuyrbsXwpZWFGTsontLbdIZLm+RVANE1z7J+GZqZAZiaa1LQSnH8BFmZCEVcIM/JAo5pUqXlKaHKi0MwAVt+SfDIInzg1u+pThZsPksxMQVa1Tg8lLSwpZ8Wk6mQ5q6mMWZcl5zMTcIBmM1P/ILJyBmQ/UfnM0MWRU062mKZBEW+gnNTo5C4/zx/v2GU5ZrlCr60QZqhWzBKCTTRbVJgR564qqmkzM0naENlnpjE3sVOfIzfUPjP+x3qn+/PSqmwwRrxAZiYR7AE4l+MpN1iYCQFVawrkrqXqt+ZDR1SfEa3uZC1QUETbnnv/E6xoabeEncsOwEEGQifBaoCLz0yQOcLIAJwM7gAMADVVbGbqD8iPWb5yiMXMFFF3oQ7Aqnpv2WNpSq2NSninmh454vLjHV3G/soZel5i/KF+dqKeGkDN99ZcWOLcOxWaGVkGlCOImurMiNDOnpRR6qBNilB1QpiZ6DGDjJtOfjP/Wd6Sa2/h71+hErpGTWW0skwxVj4umhnVJC76X5o4AEfVYVQ1P4IgzqmrN40Tf/2CxZFOtDEfM5MT1tBsqyAWRLNkcwAOqplJsJmpP2DTzORtZnL2u1Bxx1cPwuD6Kvzl/EMdtzEyimfM2kLTxjTiqD3NMOsBNQllwjbVAj1Oxhn5N+tzmplyr7lD21dflXMAJp9R3x9xS3Z09uLK/zMTBIoEc8KpekAAzcxp00cbr7t604ZwE1QzQ4WZIH3Oq9iw3zDvoFx10hTjdSVUzAa4NlMojEKTurPPjNLMRJM7RZwBOGyOFPlBE5oOwK6JiuI5sjoASz4zAZ4hU5jJOQCH0MywMNN3ic5nJpg598R9m3HC1JGu21JfOrE+GjPYWpW+sa5KWbFZlRxTnNsba3fgM7990fLdzu6UZZtyhV6u2mr7c9naZdfMPPTGBss2QksjCjfSMceWNE+auKnJOZXJGCHKvoWZ3GKQppkIsnD1Mkl5CTv5ctah43DDf1YAiK4qfKEp6ag9fvx4aJpm+bvhhhss27z11ls48sgjUVtbi7Fjx+LGG28sUWvtCKFE12GspOT7rhosaNK8ZISh2QBw7uHjAZiOvEGR27ulo9v8Tqz08nQ+U12LQTUumpkA+xYP/atrdgAA2nb5UwMbvydtYzNT38WeAThPnxkyiegOJiEZL6GH+uBlyHgyeID5XDTWJZQVm+sUkYtinNnY1m37TkyyQfw3SgGNDlWli6CaGad7afrMqByArb9RJaoTpNK6YWaix3VDLK5o2wNpZjy2LZQwWokLupJrZq677jpceOGFxvtBgwYZr9vb23H88cdj9uzZuOOOO/D222/j/PPPR1NTEy666KJSNNcC7UjpjI5EXLM9UEpbtmEbV4cLhmHGxKF47gfHoFlRQNEP8sPR0m4OhBpZOQLBU8G/fvWn8f6WDnzxjkXGZ1SAsWtm/B9g4nBr9JXfPBACazQTOwD3VaIqNEknPZ+yjCcqB+CYpmHIALM0SmNdFSYOH2j7rSoNgx8TUrlrZmgUlkr7NIyUjfGK/MnHAVjejyHMBDQzUWEmiM+MZ+BDkcoZVAIlF2YGDRqE5mZ73gQAuPfee9Hb24u77roL1dXVmDp1KpYtW4Zbbrml7ISZVEZHIq7QzCijmbL/05mM8aBFqS7cfag9rNovNmGGrOqEEJPJ02emsb4KYyW1ORVgbCayALs/Zb9RuARvBGoPheaZKZTqlik9NjNTBJoZJ2fdoFAHYKHtiWnAUFK0trGuCpNHDMRfLzgUPckMvpGrpKwqBOgnoq/co5loFBZt6/9963Dc8dyHuPqUvY3PnE5F1sxYfWas27oWd8zoGJETnja327VdKgxhJk+fGZU2ilKoorjlLuSqKLn4dcMNN2Do0KGYPn06brrpJqRSZhrvRYsW4aijjkJ1tfkwn3DCCVi5ciV27NjhuM+enh60t7db/goBveGmWlhe+dl/JwatbuKPUi6mDXlwp8KMOMeUIcwEb7P8E6qZket/nDot63w3fqhVAFIhX/fjpowI1C7qM5NPSDtTGciDdN7RTJZnP0yLTGjSvIwhzGgYIgkzAHDkHsOx/5hG43PVpNcXNDM0cos+lwftPhh//PrBloWbk/AmCzNUsPDKACy3ZbfB2WSiG3bsctyOYkYzmQJUEK3HOI+xb+wQ77Gxv1BSzcx3v/tdHHjggRgyZAhefvllzJs3D5s2bcItt9wCAGhpacGECRMsvxk5cqTx3eDBg5X7nT9/Pn76058WtvGwPghOuVdUphJTmDETE5WLWk8eEKijmxhgzQzAwfcv+9nUEac+uWr20XsOx+PfmYXdfQgzMnd87aBA23utgJi+QVRmJjqxqgrN5oNoS4qYmTRNs2hmmkjxWGoOVeWp8nNu5a6ZUUVuOeEkvIn7I8xMtPaaHx9HYz8ZHWOasmPRts5e7OpNK32VKGE1M16ZhocPrHH9vj8R+Qx61VVX2Zx65b8VK7Je0nPnzsUxxxyD/fffHxdffDF++ctf4re//S16enpCtWHevHloa2sz/tavXx/FqdmwaGZyfU7upqqOKwYQmmUxKgfgsMiDWzepLSLO0TAz5bGsVdWQEQy05ZnRsO9ujXnlzgkqHKoKazJ9j6iEGYpfB2AvVA7AMQ04YFwTZkwYgs/sPwqzJg8ztqcJMlXPoh8zU9lrZgKovZx87HQ9GzUq/OioloRqxwF3rWwqo6OhLmEk+tzU5q2dMUKz8/SZ+eLBY12/P1Cq+9efiVwzc/nll+Pcc8913WbixInKz2fMmIFUKoU1a9Zgr732QnNzMzZv3mzZRrx38rMBgJqaGtTUFF5ijStWZ/KzoBpQErYEb+WTUlxuB33Y0zYzU3hhZuzgevz4s/tgQHWipNop1sz0D2yFBCMwKWYisjPRjL1CPoppGuqrE3jgmzNt29e4VH+m+3Oj3Ctm+62BBLibmWjhTuos7ceETdE0DXXVcXT2ppV1l2SUSfMCjHMn7duMb8yagD+9uNr23U1f2L8iqlkXi8iFmeHDh2P48OHeGypYtmwZYrEYRozI+jvMnDkTP/rRj5BMJlFVlb1pCxcuxF577eVoYiom9OFxMjOpBhQ5J0o5DShye6kpTKxA83UABuyTSXUihvMUVYCLzWenjcYvF76PfUY1lLopTAGxPZ8RLCKi9plJZXTjGXMbGqgWQTWR+5kzy10zE8zMpP48owM7cyam6njMsmhKxGO4+OhJuOO5D30fR4zXXm3TSVLU2jzNTJqmYdYew5TCzDj2l7FQMp+ZRYsWYcmSJTj22GMxaNAgLFq0CJdddhm++tWvGoLKV77yFfz0pz/FBRdcgCuvvBLLly/Hb37zG/zqV78qVbNtxGOaLS+E/L2MiIQQWo8ykmXsZiaimRGDdlpXC25+kH9TLo7P44cNwCs/Os5wsGT6JnJ/iyJyLapoJqsDcPYzv87obr55bpR7dldVgkAn3LTbqoR5gqBaWaNyttS2VVt2IqbBCJ2n2dNF9mIguJ+Sk/Dj5a/T3yiZMFNTU4P7778fP/nJT9DT04MJEybgsssuw9y5c41tGhsb8d///hdz5szBQQcdhGHDhuHaa68ti7BsQVzTkIZZyE2TvGZUA4qQ7MtRMyMPCD3EZ0aco5E0L4+B0KaZKRNfIQAYMSi/3DxM5SA7mUchTEeVZ8bwmdGtPjN+2HOkPfeMHw1AX9LMuAlvHd3ZQIZ6heAS1F9OaHZo/aedPSnMvuU5AMCq609CIh6zmKGsZqaAwozDeZXLQrBcKJkwc+CBB2Lx4sWe2+2///544YUXitCi/IjHNCBtTvBBNDPCIa2cBhS5LdTMZEQz5VE1WyALS5zThSkmsjN5FML0qKZohGBDmEnTPDPuz8ejlxyB9dt3Yf8xTbbv+lqeGS/cxtH2bqGZsU95++3WaPvMDXHNaNj4h1t2Gq93dCUxfFCNpWJ2raXQZLA+53QfyyUCtlzgqxESGoEA2Fdpqv4mDyDlNKDYhRlqZrIKM1EIYZzThSkmVDNTHY+F6n93n3cIvvOpyTh531FRNM0QXDa2dePWp1dZPnNi/zFNOGV/9fH9OACXe90dVYVwJ+Tzfe4HxxivRS2qAQrTzOGTh+FXX56Gxy6ZpdyvyFl17F5ZX1DhwPvte1/HLxZkI3NXb+00thf1orbuzEblNtVXWcoSBNbMOIyzxdJqRxWtV2hKngG40qEVsIFsVl/r985mJkFZaWZcHIDFqZm1mcqn3QzjB5plOqya/ti9RuDYvYIlZ3RDNcmFETZ85Zkpc81oKoBmRr5UNA/PzpzPjJOfyeemj3Hc76/OPABPLG/B8VOzEbRCm9zalcTtz36IHxy/F9Zu6zK2397Zi47uJH7y6DsAgFGNdThgXBOGDazGAWMHY/eAjrtOt5E1M1ZYmAkJddoD7A+fUpiJV5BmJqUwM4VwAGaYUkKFmXLrvspcMSHa6Of5zCeLdzEJpJlRREoKTM1M8CmvobbKku9FHq9bdyUt4+SOriSu/ec7WPzRdgDAbk21mNLcgNeu/nTgYwPO97FYJnqaqLGcKe+eXAFQpz3AHtmgWh3JnTBeRqsjP2amMKHZDFNKqJmp10eekGKiLEob4hnzo3Upp4WUikCh2S7CjOEArPCZCYqcJ2bbzh5LPpzWrl78c9kG432+RX8FTuOsKutzlPzPV6bjgLFNuO60qQU9TlSwMBMSozic0MykvTUz8mqonKKZ3B2As//DJM1jmFJCJyI/Sc+KiUqwCKM9shVuVVDuz/Bnp2X9gaaN8XbSlf2f6KJxR1dWmPFzTbyQF6PbOnstGvkdXUlL7qGw6R6cNDOF9pn5zP6j8cicIzBmcGXks2EzU0hMM1P2vex971bOQFBO44n84FBhRg7NLveBkGEqiXxzxTjRVOdtHih3zcxPTp2KGROG4lM+CsfKZrqqWAwxLbsI25FzypWL2eaDvPjctrPXsoil6SwAq+9OPjibmcpnEVwOsDATEjNrZ1aakYvOqfqb3AnLSTMjD25J8pDqkiktn9pMlDIfRxmmqKgWB2GekSYfqe7LfUFSX53AGQc5O+dS6LCqaVkTXTymIZPWjYK5hdDMbO+yamZk7XxNSHOQ0z0q93tXbMpnFq1QhNQsuq+smVGbmTTX96XEtWpsBLWZKFELcT88eQoA4Bdn7BfpfhmmGKi0JGE0M7U+MtuWu2YmCNTMJM5LXL/WnJmpIYIM3/K4l0pnLD4zstNyeGEm1M/7DayZCYno10JrIUvlfhyAyyk80s3h0FY1O+RAGLVC6qKjJuHLB4/j4mtMRaIKGy50HqZyKXAbBXGLMJMdXMQY1bpLmJmidwBOZ3SLZiYpa2ZCFrHlqFF/sMwXEtMBOPteNjP50cyIuiHlgNvYZibNy21bZpoZACzIMBWLKmy40LJGVRmZuMNCx1WhmRECTmtnTjMTgc9MlXRTMroszEStmWFhxg99pyeXCDGhy9lx3ZB9ZrZ19kbfsDxxS/aYkRIDhlVR8zPKMCbK0OyQq/JLZ++BkQ01jt9XJfrOQ0gvldB2i2vakVswRuEzI2tmWtqsodlyAcpCOQAzVliYCYkYfzKSP4lAVVHXXs6gfG6DmzAWRdVsijwoMEwxKKfipl6EFfgvnb0nFs87DodOGAIAGCdlny2nsScsVIMh0l/I18+PH5EXspvAXS+txqtrthvve1PROgBTITfsvvoyfGVCYjgA5/pvxibM2H8jqw3lEgilZPAA53DO7mQaa7d1Yt32XQDCqz9ZfcqUgkqqNhyFz4ymafjd2QfiihP3wt3nHWL5ri8Veo0rHIDlMSYK/0SVALh1p6ld75XMTGH7Gz2vKISxvkrlPNVlihhshAZGtpfW+3DqC5LlstAMrEng3989EqcdMNr23cc7duHom57FY29uBBDezBQ2tJth8uHioycCAE7M1dopZ6IyMQwbWINvHzMZo6RstH1JO2qJZjKElui14F4CkRgfBeE1M+br2qq+c7+ihqOZQmKambL/u3qzCZPOOnQc9ho5ECMbvFNZBymmVgz2Gd2AvZoHeW4X1gGYNTNMKfjWMZMxY+JQ7Lebd1bZUhO1rCELR30p8ZrKAVhUrpY/D0PQaxY2moku+sL63/Rl+k5PLhFicBDmpa7erKPZOYfvjnOPmOBrH36chouNH61JWM0KCzNMKYjHNBwyfkhZquzvu3AGhg00HXajdv6UdydH5lQyVMZwGluiMTMF20dYUx7tA5VkIi02fGVCIkczdfZkNTNBqrMmy8hnRuBH0GCfGYaJlsMnDcPfvnGo8T7qPDOycNRXzUxO2pNozEzB9qEhpDBDxskzD8lW795z5MBQ++yLsJkpJNTMlM7o2JWrZTQgQHVWt3DoUuFnRcjCDMNED9V4Rv2I2OoX9VEH4EJqZoJqs8LKo/RwJ0xtxsxJQzF+6IBwO+2DsDATkhhxABYmJkDt+FtJFEMz05dSqTNMVNDnqtBmpr70DFJBxem8okgSGFQzQ82G+UD7Q0NtFcYOqYwq1sWGhZmQ0HIGwvk3HtM8Pdi/MWsC/vTi6kI3L2/8OPeyZoZhooeaQqJ+RDRNg6aZ2uCqPuSDQcdcJzNTPArNTIB9/O2CGRg+KJwwU1+dwC/O2A8ZnTOcu9F3enKJEHbadMYsS1BfHfe0dV/9mX0K3rYwFMMB2E9VX4bpb1DlQSFqM1FtT18qZ0AFGCdH2Sg0UUH2MWuPYaGPBwBfPmQczjp0XCT76qv0nZ5cIuIWM1Nw599yxc/zmm9o9m/Pmo59d2vA/M/tn9fvGaYvY9XMRC/MxJX5WCofKsAUVJjpQ07TfYnKn3VLjBh3MrpuamZqKttfBvAnqOQ7MHx22mh8dpo9KR/DMLLPTPT7t9Yw6jsTM9XMOJqZIskz03cEwL5E3+nJJYKWM+hLmhk/JqSwSfMYhrFTaKdcS96SPjQxU22M01lFYbbrS/Ws+hJ8V0JCyxl05qKZBvjUzPz6ywcAAG78QvmZW3xFM3E5AoaJHLpIKEQ+Tfpo96WJuVgFRPuSaa4vUfkqhBJD88x0BUyYd/r03XDivs1lmYm0kGYmhmGcSViEmeilmVgf9ZmhpqVCrrP6kgDYl+C7EhJazkBoZuoDJMwrR0EGYDMTw5QKqhUtRD5N+tz21dpMhcRNADxh6siitIGx03d6comgSfOEA/CACk+YB9gL3B0wtslzG4ZhwkM1M3pBNDPqYzH+cHMAvvWs6dhjBJcaKAU8HYVEjAXbu3rRmXMAru8DDsBySOjD3z4cFx89yfJZnNWtDBM5Fs1MQXxmiGamDyXNKxZuZqaaRLxste19ncqfdUuMGBhuXLDS+MyvA3A5I4+hmqbZVnHsAMww0UMjbgqhmdH6aNI8Stjijm44mZkum70nAKC2qm9e03KnZFf92WefzaXWtv+9+uqrAIA1a9Yov1+8eHGpmm1DNRb0Bc1M+66k7TPZR4bNTAxTWAoRzdSbShuv+5IDcLFQ+RktvXo2vjd7DwDl6wfZ1ynZrHv44Ydj06ZNls+uueYaPPXUUzj44IMtnz/55JOYOnWq8X7o0KFFaaMfVHkLBvYBzUybQpixaWb66KqOYcqFQkQztXebBXEnDOub1ZcLG81k3/kAEvRx8dGT8MIHW3Hi1ObCNYKxUTJhprq6Gs3N5s1OJpP45z//ie985zs2AWHo0KGWbcsJlamlL2hm6hROzHK0AGtmGKawFMJnRrBbU12f1yJMHjEQq7bsjHSfKs0MFXCOmDwMS354XOhq2UwwymY6evTRR7Ft2zacd955tu9OPfVUjBgxArNmzcKjjz5agtY5owoG6As+M2ccOMb2mSzMFKJuDMMwJnpBgrOz9IVxyov/vXhm5PtUmebksXFkQ23RQsWZLGUjzNx555044YQTMGaMOYkOHDgQv/zlL/Hggw/iX//6F2bNmoXTTz/dU6Dp6elBe3u75a9QqCb0vqCZqa2KY/q4JstnshaKhRmGKSyF8JkR9IVxyoum+mocvefwSPepimYqRHVzJhiRCzNXXXWVo2Ov+FuxYoXlNx9//DGeeOIJXHDBBZbPhw0bhrlz52LGjBk45JBDcMMNN+CrX/0qbrrpJtc2zJ8/H42Njcbf2LFjoz5NA1Un7isrHjk9uLxK5OeXYQpLIXxmBH1lnFIxcbjpCxR1YkAuNFmeRC6aX3755Tj33HNdt5k4caLl/d13342hQ4fi1FNP9dz/jBkzsHDhQtdt5s2bh7lz5xrv29vbCybQqDSJfWXFM2yQ1eabKuQykWEYG4X0mekr4xTlgYsOw3+Wt2DOsZONz47fZySefG8zGmqjOd++VGm8LxF5bx4+fDiGD/ev1tN1HXfffTe+/vWvo6qqynP7ZcuWYdSoUa7b1NTUoKamOM5XKlNLX6iaDQDXnLIPPt7eha/PHA8ASKetI2shB1qGYQqTZ0ZQ3wcylcvMmDgUMyZao12/cNAYDB5Qjf3HNEZyjCr2hSlLSj7rPv3001i9ejW+8Y1v2L7785//jOrqakyfPh0A8NBDD+Guu+7Cn/70p2I30xFVfaL6PqK+bW6sxT8vmWW8lzUzLMswTGFhn5nwxGIaPr1PdDWTWDNTnpS8N9955504/PDDMWXKFOX3P/vZz7B27VokEglMmTIFDzzwAL7whS8UuZXOqIT0gQEKTVYShbTfMwxjp5DP3JjBdQXbd1+GEw2WJyWfde+77z7H78455xycc845RWxNcFRmppo+Wu/Epplh4YZhCsKp00bjP8s34axDx0W+79+ceQCefG8LLpg1IfJ99we4OGd5UnJhptJR9eu+GqaXZgdghikKvznzANycnobqAiyMTjtgN5x2wG6R77e/IEd5MuUB35WQyILLaQeMLlFLCk8qzcIMwxQDTdMKIsgw4UnEY3jo24fj6zN3L3VTGAJrZkJCszze9pUDccr+7pFWlUw6k7G8VyWPYhiG6escOG4wpo1pgq4DB48fXOrmMGBhJjTUzNTXHcMGkjwNR+4xDDMnlU/BT4ZhmGISj2n42en7lroZTA4WZkJCHYD7embIi46ahDfWteLUaaNxZgEcExmGYRgmH1iYCQn1mYn3cbNLY10V7rvwsFI3g2EYhmEs9O3ZtwhQMxNnhmQYhmGY4sPCTEhiFs0MCzMMwzAMU2xYmAkJLWfAaa4ZhmEYpvjw7BsSSzQTa2YYhmEYpuiwMBMSambq66HZDMMwDFOOsDATEqtmhi8nwzAMwxQbnn1DorEDMMMwDMOUFBZmQkIFmL6eNI9hGIZhyhEWZkJClTGsmWEYhmGY4sPCTEg6e9LG66b66hK2hGEYhmH6JyzMhGRj6y7j9cAarg7BMAzDMMWGhZmQbGzb5b0RwzAMwzAFg4WZkBw4bjAAoKGWtTIMwzAMUwp4Bg7Jt4+ZjBGDavCpvUeWuikMwzAM0y9hYSYkddVxfG3m+FI3g2EYhmH6LWxmYhiGYRimomFhhmEYhmGYioaFGYZhGIZhKhoWZhiGYRiGqWhYmGEYhmEYpqJhYYZhGIZhmIqGhRmGYRiGYSoaFmYYhmEYhqloWJhhGIZhGKaiYWGGYRiGYZiKpmDCzPXXX4/DDz8c9fX1aGpqUm6zbt06nHLKKaivr8eIESPwgx/8AKlUyrLNs88+iwMPPBA1NTWYPHky7rnnnkI1mWEYhmGYCqRgwkxvby+++MUv4lvf+pby+3Q6jVNOOQW9vb14+eWX8ec//xn33HMPrr32WmOb1atX45RTTsGxxx6LZcuW4dJLL8U3vvENPPHEE4VqNsMwDMMwFYam67peyAPcc889uPTSS9Ha2mr5/D//+Q8+85nPYOPGjRg5Mltx+o477sCVV16JTz75BNXV1bjyyivxr3/9C8uXLzd+d+aZZ6K1tRULFizw3Yb29nY0Njaira0NDQ0NkZwXwzAMwzCFxe/8XbKq2YsWLcJ+++1nCDIAcMIJJ+Bb3/oW3nnnHUyfPh2LFi3C7NmzLb874YQTcOmll7ruu6enBz09Pcb7trY2ANmLwjAMwzBMZSDmbS+9S8mEmZaWFosgA8B439LS4rpNe3s7du3ahbq6OuW+58+fj5/+9Ke2z8eOHRtF0xmGYRiGKSIdHR1obGx0/D6QMHPVVVfhF7/4hes27733HqZMmRJkt5Ezb948zJ0713ifyWSwfft2DB06FJqmRXac9vZ2jB07FuvXr2fzVYHha10c+DoXB77OxYGvc/Eo1LXWdR0dHR0YPXq063aBhJnLL78c5557rus2EydO9LWv5uZmvPLKK5bPNm/ebHwn/ovP6DYNDQ2OWhkAqKmpQU1NjeUzp4iqKGhoaOAHpUjwtS4OfJ2LA1/n4sDXuXgU4lq7aWQEgYSZ4cOHY/jw4Xk3iDJz5kxcf/312LJlC0aMGAEAWLhwIRoaGrDPPvsY2/z73/+2/G7hwoWYOXNmJG1gGIZhGKbyKVho9rp167Bs2TKsW7cO6XQay5Ytw7Jly7Bz504AwPHHH4999tkHX/va1/Dmm2/iiSeewNVXX405c+YYWpWLL74YH330Ea644gqsWLECv/vd7/CPf/wDl112WaGazTAMwzBMpaEXiHPOOUcHYPt75plnjG3WrFmjn3TSSXpdXZ0+bNgw/fLLL9eTyaRlP88884x+wAEH6NXV1frEiRP1u+++u1BNDkx3d7f+4x//WO/u7i51U/o8fK2LA1/n4sDXuTjwdS4epb7WBc8zwzAMwzAMU0i4NhPDMAzDMBUNCzMMwzAMw1Q0LMwwDMMwDFPRsDDDMAzDMExFw8JMCG677TaMHz8etbW1mDFjhi0JIOPM/Pnzccghh2DQoEEYMWIETj/9dKxcudKyTXd3N+bMmYOhQ4di4MCBOOOMM2xJFNetW4dTTjkF9fX1GDFiBH7wgx8glUoV81QqihtuuAGaplnqm/F1jo4NGzbgq1/9KoYOHYq6ujrst99+eO2114zvdV3Htddei1GjRqGurg6zZ8/GBx98YNnH9u3bcfbZZ6OhoQFNTU244IILjJQWDJBOp3HNNddgwoQJqKurw6RJk/Czn/3MUruHr3N+PP/88/jsZz+L0aNHQ9M0PPLII5bvo7qub731Fo488kjU1tZi7NixuPHGG8M3viQxVH2A+++/X6+urtbvuusu/Z133tEvvPBCvampSd+8eXOpm1YRnHDCCfrdd9+tL1++XF+2bJl+8skn6+PGjdN37txpbHPxxRfrY8eO1Z966in9tdde0w877DD98MMPN75PpVL6vvvuq8+ePVt/44039H//+9/6sGHD9Hnz5pXilMqeV155RR8/fry+//7769/73veMz/k6R8P27dv13XffXT/33HP1JUuW6B999JH+xBNP6KtWrTK2ueGGG/TGxkb9kUce0d9880391FNP1SdMmKDv2rXL2ObEE0/Up02bpi9evFh/4YUX9MmTJ+tnnXVWKU6pLLn++uv1oUOH6o8//ri+evVq/cEHH9QHDhyo/+Y3vzG24eucH//+97/1H/3oR/pDDz2kA9Affvhhy/dRXNe2tjZ95MiR+tlnn60vX75c//vf/67X1dXpv//970O1nYWZPDn00EP1OXPmGO/T6bQ+evRoff78+SVsVeWyZcsWHYD+3HPP6bqu662trXpVVZX+4IMPGtu89957OgB90aJFuq5nH7xYLKa3tLQY29x+++16Q0OD3tPTU9wTKHM6Ojr0PfbYQ1+4cKF+9NFHG8IMX+fouPLKK/VZs2Y5fp/JZPTm5mb9pptuMj5rbW3Va2pq9L///e+6ruv6u+++qwPQX331VWOb//znP7qmafqGDRsK1/gK4pRTTtHPP/98y2ef//zn9bPPPlvXdb7OUSELM1Fd19/97nf64MGDLWPHlVdeqe+1116h2stmpjzo7e3F0qVLMXv2bOOzWCyG2bNnY9GiRSVsWeXS1tYGABgyZAgAYOnSpUgmk5ZrPGXKFIwbN864xosWLcJ+++1nqax+wgknoL29He+8804RW1/+zJkzB6eccorlegJ8naPk0UcfxcEHH4wvfvGLGDFiBKZPn44//vGPxverV69GS0uL5Vo3NjZixowZlmvd1NSEgw8+2Nhm9uzZiMViWLJkSfFOpow5/PDD8dRTT+H9998HALz55pt48cUXcdJJJwHg61woorquixYtwlFHHYXq6mpjmxNOOAErV67Ejh078m5foNpMTJatW7cinU5bBncAGDlyJFasWFGiVlUumUwGl156KY444gjsu+++AICWlhZUV1fbCoSOHDkSLS0txjaqeyC+Y7Lcf//9eP311/Hqq6/avuPrHB0fffQRbr/9dsydOxc//OEP8eqrr+K73/0uqqurcc455xjXSnUt6bUWteoEiUQCQ4YM4Wud46qrrkJ7ezumTJmCeDyOdDqN66+/HmeffTYA8HUuEFFd15aWFkyYMMG2D/Hd4MGD82ofCzNMyZkzZw6WL1+OF198sdRN6XOsX78e3/ve97Bw4ULU1taWujl9mkwmg4MPPhg///nPAQDTp0/H8uXLcccdd+Ccc84pcev6Dv/4xz9w77334r777sPUqVOxbNkyXHrppRg9ejRf534Mm5nyYNiwYYjH47aIj82bN6O5ublErapMLrnkEjz++ON45plnMGbMGOPz5uZm9Pb2orW11bI9vcbNzc3KeyC+Y7JmpC1btuDAAw9EIpFAIpHAc889h1tvvRWJRAIjR47k6xwRo0aNwj777GP5bO+998a6desAmNfKbdxobm7Gli1bLN+nUils376dr3WOH/zgB7jqqqtw5plnYr/99sPXvvY1XHbZZZg/fz4Avs6FIqrrWqjxhIWZPKiursZBBx2Ep556yvgsk8ngqaeewsyZM0vYsspB13VccsklePjhh/H000/b1I4HHXQQqqqqLNd45cqVWLdunXGNZ86cibffftvy8CxcuBANDQ22SaW/ctxxx+Htt982qtYvW7YMBx98MM4++2zjNV/naDjiiCNs6QXef/997L777gCACRMmoLm52XKt29vbsWTJEsu1bm1txdKlS41tnn76aWQyGcyYMaMIZ1H+dHV1IRazTl3xeByZTAYAX+dCEdV1nTlzJp5//nkkk0ljm4ULF2KvvfbK28QEgEOz8+X+++/Xa2pq9HvuuUd/99139YsuukhvamqyRHwwznzrW9/SGxsb9WeffVbftGmT8dfV1WVsc/HFF+vjxo3Tn376af21117TZ86cqc+cOdP4XoQMH3/88fqyZcv0BQsW6MOHD+eQYQ9oNJOu83WOildeeUVPJBL69ddfr3/wwQf6vffeq9fX1+t/+9vfjG1uuOEGvampSf/nP/+pv/XWW/ppp52mDG2dPn26vmTJEv3FF1/U99hjj34fMkw555xz9N12280IzX7ooYf0YcOG6VdccYWxDV/n/Ojo6NDfeOMN/Y033tAB6Lfccov+xhtv6GvXrtV1PZrr2traqo8cOVL/2te+pi9fvly///779fr6eg7NLiW//e1v9XHjxunV1dX6oYceqi9evLjUTaoYACj/7r77bmObXbt26d/+9rf1wYMH6/X19frnPvc5fdOmTZb9rFmzRj/ppJP0uro6fdiwYfrll1+uJ5PJIp9NZSELM3ydo+Oxxx7T9913X72mpkafMmWK/oc//MHyfSaT0a+55hp95MiRek1NjX7cccfpK1eutGyzbds2/ayzztIHDhyoNzQ06Oedd57e0dFRzNMoa9rb2/Xvfe97+rhx4/Ta2lp94sSJ+o9+9CNLqC9f5/x45plnlOPyOeeco+t6dNf1zTff1GfNmqXX1NTou+22m37DDTeEbrum6yRtIsMwDMMwTIXBPjMMwzAMw1Q0LMwwDMMwDFPRsDDDMAzDMExFw8IMwzAMwzAVDQszDMMwDMNUNCzMMAzDMAxT0bAwwzAMwzBMRcPCDMMwDMMwFQ0LMwzDMAzDVDQszDAMwzAMU9GwMMMwDMMwTEXDwgzDMAzDMBXN/wcQuXDPuqfA/wAAAABJRU5ErkJggg==\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Now I'd like to plot the signal with different activations, but instead of a build in function, i want to use agents."],"metadata":{"id":"1ryBUW4q8r9Y"}},{"cell_type":"code","source":["# prompt: I want the same cell as above, but plot the figures side by side\n","%load_ext autoreload\n","%autoreload 2\n","from deluca.core import Agent\n","from deluca.agents._grc import GRC\n","from deluca.agents._random import SimpleRandom\n","from deluca.agents._lqg import LQG\n","from deluca.agents._zero import Zero\n","from deluca.agents._sfc import SFC\n","from deluca.agents._drc import DRC\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","\n","def plot_lds_with_a_given_agent(env, agent, name_of_agent, traj_length=1000, window_size=50, ax=None):\n"," obs = np.zeros(shape=(d_obs, 1))\n"," action = agent(obs)\n"," losses = np.zeros(traj_length)\n"," window_losses = np.zeros(traj_length - window_size)\n","\n"," for i in range(traj_length):\n"," obs = env(action)\n"," action = agent(obs)\n"," losses[i] = np.linalg.norm(obs) + np.linalg.norm(action) # simple quadratic loss\n"," agent.update(obs, action)\n"," if i >= window_size - 1:\n"," window_losses[i - window_size] = np.mean(losses[i - window_size + 1: i + 1])\n","\n"," ax.plot(window_losses)\n"," ax.set_xlabel('Time step (sliding window)')\n"," ax.set_ylabel('Loss')\n"," ax.set_title(f\"Loss of {name_of_agent} on LDS\")\n","\n","\n","env = lds.LDS() # LDS with random initiations and dimensions as specified\n","d_obs = 2\n","d_action = 3\n","d_hidden = 10\n","disturbance = SinusDisturbance()\n","disturbance.init(d_hidden, 0.5)\n","obs = env.init(d_action,d_hidden,d_obs, disturbance = disturbance)\n","\n","fig, axes = plt.subplots(2, 3, figsize=(12, 8))\n","axes = axes.flatten()\n","\n","\n","agent = GRC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"GRC\", ax=axes[0])\n","\n","agent = LQG(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"LQG\", ax=axes[1])\n","\n","agent = SimpleRandom(d_action)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"Random agent\", ax=axes[2])\n","\n","agent = Zero(d_action)\n","agent.init(d_action)\n","plot_lds_with_a_given_agent(env, agent, \"Zero agent\", ax=axes[3])\n","\n","agent = SFC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"SFC\", ax=axes[4])\n","\n","agent = DRC(env.A, env.B, env.C)\n","agent.init()\n","plot_lds_with_a_given_agent(env, agent, \"DRC\", ax=axes[5])\n","\n","\n","plt.tight_layout()\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":831},"id":"3VhZKqj6nOaN","executionInfo":{"status":"ok","timestamp":1749071881149,"user_tz":240,"elapsed":332979,"user":{"displayName":"Elad Hazan","userId":"16316235310463925593"}},"outputId":"ca555a70-7f18-44ee-9d37-b12265895b04"},"execution_count":17,"outputs":[{"output_type":"stream","name":"stdout","text":["The autoreload extension is already loaded. To reload it, use:\n"," %reload_ext autoreload\n"]},{"output_type":"display_data","data":{"text/plain":["
"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":[],"metadata":{"id":"PqEyUdbOt0Ff"},"execution_count":null,"outputs":[]}]} \ No newline at end of file From 8742f3c884d389c8969b5cfad99a4dd93fef3aac Mon Sep 17 00:00:00 2001 From: Daniel Suo Date: Mon, 9 Jun 2025 13:13:28 +0000 Subject: [PATCH 24/27] Replace deprecated jax.tree_* functions with jax.tree.* --- deluca/lung/utils/scripts/train_simulator.py | 2 +- deluca/training/ppo.py | 4 ++-- deluca/utils/tree.py | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/deluca/lung/utils/scripts/train_simulator.py b/deluca/lung/utils/scripts/train_simulator.py index 88b67a1..38ac309 100644 --- a/deluca/lung/utils/scripts/train_simulator.py +++ b/deluca/lung/utils/scripts/train_simulator.py @@ -118,7 +118,7 @@ def loop_over_loader(model_optimState_lrMult_loss, X_Y, optim, rollout_fn, rollout_fn) updates, optim_state = optim.update(grad, optim_state, model) if scheduler == "ReduceLROnPlateau": - updates = jax.tree_map(lambda g: lr_mult * g, updates) + updates = jax.tree.map(lambda g: lr_mult * g, updates) model = optax.apply_updates(model, updates) return (model, optim_state, lr_mult, loss), None diff --git a/deluca/training/ppo.py b/deluca/training/ppo.py index c8208ac..6fb3551 100644 --- a/deluca/training/ppo.py +++ b/deluca/training/ppo.py @@ -186,7 +186,7 @@ def train_step(optim, optim_state, agent, experiences, batch_size: int, @jax.jit def train_step_batch(carry, batched_exps): loss, agent, optim_state = carry - # batched_exps = jax.tree_map(lambda x: x[counter:counter + batch_size], + # batched_exps = jax.tree.map(lambda x: x[counter:counter + batch_size], # experiences) grad_fn = jax.value_and_grad(ppo_loss_fn) l, grads = grad_fn(agent, batched_exps, clip_param, vf_coeff, entropy_coeff) @@ -197,7 +197,7 @@ def train_step_batch(carry, batched_exps): # TODO(dsuo): convert to jax.lax.scan. # for b in batch_inits: - # batched_exps = jax.tree_map(lambda x: x[b:b + batch_size], experiences) + # batched_exps = jax.tree.map(lambda x: x[b:b + batch_size], experiences) # grad_fn = jax.value_and_grad(ppo_loss_fn) # l, grads = grad_fn(agent, batched_exps, clip_param, vf_coeff, entropy_coeff) # loss += l diff --git a/deluca/utils/tree.py b/deluca/utils/tree.py index 1ace9e6..1e3f35f 100644 --- a/deluca/utils/tree.py +++ b/deluca/utils/tree.py @@ -45,8 +45,8 @@ def func(args1, args2): tree_def = jax.tree_util.tree_structure(pytrees[0]) pytree = jax.tree_util.tree_transpose( - outer_treedef=jax.tree_structure([0 for p in pytrees]), - inner_treedef=jax.tree_structure(pytrees[0]), + outer_treedef=jax.tree.structure([0 for p in pytrees]), + inner_treedef=jax.tree.structure(pytrees[0]), pytree_to_transpose=pytrees) leaves = tree_def.flatten_up_to(pytree) From 779ae9225b870d9ab0334d6ca96ca3534fa62981 Mon Sep 17 00:00:00 2001 From: Daniel Suo Date: Mon, 9 Jun 2025 13:16:04 +0000 Subject: [PATCH 25/27] Replace uses of `jnp.array` in types with `jnp.ndarray`. --- deluca/agents/_predestined.py | 2 +- deluca/agents/_random.py | 4 ++-- deluca/agents/_zero.py | 2 +- deluca/lung/controllers/_deep_actor_critic.py | 4 ++-- deluca/lung/controllers/_deep_apg.py | 4 ++-- deluca/lung/controllers/_deep_cnn.py | 6 +++--- deluca/lung/controllers/_deep_mlp.py | 6 +++--- deluca/lung/controllers/_pid.py | 2 +- deluca/lung/controllers/_predestined.py | 2 +- deluca/lung/core.py | 4 ++-- deluca/lung/envs/_delay_lung.py | 4 ++-- deluca/lung/envs/_learned_lung.py | 2 +- deluca/lung/utils/scripts/run_controller.py | 20 +++++++++---------- deluca/tests/lung/utils/data/analyzer_test.py | 4 ++-- .../lung/utils/data/breath_dataset_test.py | 4 ++-- .../lung/utils/scripts/run_controller_test.py | 4 ++-- .../utils/scripts/test_controller_test.py | 4 ++-- .../lung/utils/scripts/test_simulator_test.py | 4 ++-- .../utils/scripts/train_controller_test.py | 4 ++-- .../utils/scripts/train_simulator_test.py | 4 ++-- 20 files changed, 45 insertions(+), 45 deletions(-) diff --git a/deluca/agents/_predestined.py b/deluca/agents/_predestined.py index b39c21a..52858f9 100644 --- a/deluca/agents/_predestined.py +++ b/deluca/agents/_predestined.py @@ -23,7 +23,7 @@ class Predestined(Agent): time: float = deluca.field(jaxed=False) steps: int = deluca.field(jaxed=False) - u: jnp.array = deluca.field(jaxed=False) + u: jnp.ndarray = deluca.field(jaxed=False) def __call__(self, state, obs, *args, **kwargs): action = jax.lax.dynamic_slice(self.u, (state.steps.astype(int),), (1,)) diff --git a/deluca/agents/_random.py b/deluca/agents/_random.py index d1d329e..158401f 100644 --- a/deluca/agents/_random.py +++ b/deluca/agents/_random.py @@ -38,14 +38,14 @@ class SimpleRandom(Agent): This agent return a normally distributed action. """ # d_action: int = field(1, jaxed=False) -# agent_state: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) +# agent_state: jnp.ndarray = field(default_factory=lambda: jnp.ndarray([[1.0]]), jaxed=False) # key: int = field(default_factory=lambda: jax.random.key(0), jaxed=False) def __init__(self, n: int, key: jax.random.key = jax.random.PRNGKey(0)): self.n = n self.key = key - def __call__(self, obs: jnp.array, key: jax.random.key = None): + def __call__(self, obs: jnp.ndarray, key: jax.random.key = None): if key is None: self.key, subkey = jax.random.split(self.key, 2) return jax.random.normal(subkey, shape = (self.n, 1)) diff --git a/deluca/agents/_zero.py b/deluca/agents/_zero.py index ec120f3..bb5139c 100644 --- a/deluca/agents/_zero.py +++ b/deluca/agents/_zero.py @@ -20,7 +20,7 @@ class Zero(Agent): d_action: int = field(1, jaxed=False) - agent_state: jnp.array = field(default_factory=lambda: jnp.array([[1.0]]), jaxed=False) + agent_state: jnp.ndarray = field(default_factory=lambda: jnp.ndarray([[1.0]]), jaxed=False) def init(self,d_action): self.d_action = d_action diff --git a/deluca/lung/controllers/_deep_actor_critic.py b/deluca/lung/controllers/_deep_actor_critic.py index 1bd1ca0..1b7c120 100644 --- a/deluca/lung/controllers/_deep_actor_critic.py +++ b/deluca/lung/controllers/_deep_actor_critic.py @@ -79,7 +79,7 @@ def __call__(self, x): class DeepACControllerState(deluca.Obj): - errs: jnp.array + errs: jnp.ndarray key: int time: float = float('inf') steps: int = 0 @@ -92,7 +92,7 @@ class DeepAC(Controller): params: list = deluca.field(jaxed=True) model: nn.module = deluca.field(ActorCritic, jaxed=False) - featurizer: jnp.array = deluca.field(jaxed=False) + featurizer: jnp.ndarray = deluca.field(jaxed=False) H: int = deluca.field(100, jaxed=False) input_dim: int = deluca.field(1, jaxed=False) history_len: int = deluca.field(10, jaxed=False) diff --git a/deluca/lung/controllers/_deep_apg.py b/deluca/lung/controllers/_deep_apg.py index 4ef0926..fd6fe9d 100644 --- a/deluca/lung/controllers/_deep_apg.py +++ b/deluca/lung/controllers/_deep_apg.py @@ -75,7 +75,7 @@ def __call__(self, x): return outputs class DeepControllerState(deluca.Obj): - errs: jnp.array + errs: jnp.ndarray key: int time: float = float('inf') steps: int = 0 @@ -88,7 +88,7 @@ class Deep(Controller): params: list = deluca.field(jaxed=True) model: nn.module = deluca.field(CNN, jaxed=False) - featurizer: jnp.array = deluca.field(jaxed=False) + featurizer: jnp.ndarray = deluca.field(jaxed=False) H: int = deluca.field(100, jaxed=False) input_dim: int = deluca.field(1, jaxed=False) history_len: int = deluca.field(10, jaxed=False) diff --git a/deluca/lung/controllers/_deep_cnn.py b/deluca/lung/controllers/_deep_cnn.py index b81d875..59fd54b 100644 --- a/deluca/lung/controllers/_deep_cnn.py +++ b/deluca/lung/controllers/_deep_cnn.py @@ -55,7 +55,7 @@ def __call__(self, x): class DeepControllerState(deluca.Obj): waveform: deluca.Obj # waveform can change during training - errs: jnp.array + errs: jnp.ndarray time: float = float("inf") steps: int = 0 dt: float = DEFAULT_DT @@ -65,7 +65,7 @@ class DeepCnn(Controller): """deep cnn controller.""" params: list = deluca.field(jaxed=True) model: nn.module = deluca.field(DeepNetwork, jaxed=False) - featurizer: jnp.array = deluca.field(jaxed=False) + featurizer: jnp.ndarray = deluca.field(jaxed=False) H: int = deluca.field(100, jaxed=False) input_dim: int = deluca.field(1, jaxed=False) history_len: int = deluca.field(10, jaxed=False) @@ -129,7 +129,7 @@ def true_func(null_arg): # changed decay compare from None to float(inf) due to cond requirements u_in = jax.lax.cond( - jnp.isinf(decay), true_func, lambda x: jnp.array(decay), None) + jnp.isinf(decay), true_func, lambda x: jnp.ndarray(decay), None) # Implementing "leaky" clamp to solve the zero gradient problem if self.use_leaky_clamp: u_in = jax.lax.cond(u_in < 0.0, lambda x: x * 0.01, lambda x: x, u_in) diff --git a/deluca/lung/controllers/_deep_mlp.py b/deluca/lung/controllers/_deep_mlp.py index 25685e8..d97616b 100644 --- a/deluca/lung/controllers/_deep_mlp.py +++ b/deluca/lung/controllers/_deep_mlp.py @@ -36,8 +36,8 @@ class DeepControllerState(deluca.Obj): waveform: deluca.Obj # waveform can change during training - errs: jnp.array - fwd_targets: jnp.array + errs: jnp.ndarray + fwd_targets: jnp.ndarray time: float = float("inf") steps: int = 0 dt: float = DEFAULT_DT @@ -134,7 +134,7 @@ def true_func(null_arg): # changed decay compare from None to float(inf) due to cond requirements u_in = jax.lax.cond( - jnp.isinf(decay), true_func, lambda x: jnp.array(decay), None) + jnp.isinf(decay), true_func, lambda x: jnp.ndarray(decay), None) u_in = jax.lax.clamp(0.0, u_in.astype(jnp.float64), self.clip).squeeze() # update controller_state new_dt = jnp.max( diff --git a/deluca/lung/controllers/_pid.py b/deluca/lung/controllers/_pid.py index af9583e..b8b1a74 100644 --- a/deluca/lung/controllers/_pid.py +++ b/deluca/lung/controllers/_pid.py @@ -48,7 +48,7 @@ def __call__(self, x): class PID(Controller): """PID controller.""" model: nn.module = deluca.field(PIDNetwork, jaxed=False) - params: jnp.array = deluca.field(jaxed=True) # jnp.array([3.0, 4.0, 0.0] + params: jnp.ndarray = deluca.field(jaxed=True) # jnp.array([3.0, 4.0, 0.0] RC: float = deluca.field(0.5, jaxed=False) dt: float = deluca.field(0.03, jaxed=False) model_apply: collections.abc.Callable = deluca.field(jaxed=False) diff --git a/deluca/lung/controllers/_predestined.py b/deluca/lung/controllers/_predestined.py index 4beb400..dcb47e5 100644 --- a/deluca/lung/controllers/_predestined.py +++ b/deluca/lung/controllers/_predestined.py @@ -27,7 +27,7 @@ class Predestined(Controller): time: float = deluca.field(jaxed=False) steps: int = deluca.field(jaxed=False) dt: float = deluca.field(jaxed=False) - u_ins: jnp.array = deluca.field(jaxed=False) + u_ins: jnp.ndarray = deluca.field(jaxed=False) def __call__(self, state, obs, *args, **kwargs): action = jax.lax.dynamic_slice(self.u_ins, (state.steps.astype(int),), (1,)) diff --git a/deluca/lung/core.py b/deluca/lung/core.py index c2103ea..9053652 100644 --- a/deluca/lung/core.py +++ b/deluca/lung/core.py @@ -35,8 +35,8 @@ class BreathWaveform(deluca.Obj): peep: float = deluca.field(5., jaxed=False) pip: float = deluca.field(35., jaxed=False) bpm: int = deluca.field(20, jaxed=False) - fp: jnp.array = deluca.field(jaxed=False) - xp: jnp.array = deluca.field(jaxed=False) + fp: jnp.ndarray = deluca.field(jaxed=False) + xp: jnp.ndarray = deluca.field(jaxed=False) in_bounds: Tuple[int, int] = deluca.field((0, 1), jaxed=False) ex_bounds: Tuple[int, int] = deluca.field((2, 4), jaxed=False) period: float = deluca.field(jaxed=False) diff --git a/deluca/lung/envs/_delay_lung.py b/deluca/lung/envs/_delay_lung.py index e991411..99a1e96 100644 --- a/deluca/lung/envs/_delay_lung.py +++ b/deluca/lung/envs/_delay_lung.py @@ -26,8 +26,8 @@ class Observation(deluca.Obj): class SimulatorState(deluca.Obj): - in_history: jnp.array - out_history: jnp.array + in_history: jnp.ndarray + out_history: jnp.ndarray steps: int = 0 time: float = 0.0 volume: float = 0.0 diff --git a/deluca/lung/envs/_learned_lung.py b/deluca/lung/envs/_learned_lung.py index 1e9cce1..644c0ce 100644 --- a/deluca/lung/envs/_learned_lung.py +++ b/deluca/lung/envs/_learned_lung.py @@ -92,7 +92,7 @@ def false_func(state, u_in, model_idx, u_normalizer, update_history, class LearnedLung(LungEnv): """Learned lung.""" params: list = deluca.field(jaxed=True) - init_rng: jnp.array = deluca.field(jaxed=False) + init_rng: jnp.ndarray = deluca.field(jaxed=False) u_window: int = deluca.field(5, jaxed=False) p_window: int = deluca.field(3, jaxed=False) u_history_len: int = deluca.field(5, jaxed=False) diff --git a/deluca/lung/utils/scripts/run_controller.py b/deluca/lung/utils/scripts/run_controller.py index 896dab4..abb5430 100644 --- a/deluca/lung/utils/scripts/run_controller.py +++ b/deluca/lung/utils/scripts/run_controller.py @@ -85,12 +85,12 @@ def run_controller( env.cleanup() timeseries = { - "timestamp": jnp.array(timestamps), - "pressure": jnp.array(pressures), - "flow": jnp.array(flows), + "timestamp": jnp.ndarray(timestamps), + "pressure": jnp.ndarray(pressures), + "flow": jnp.ndarray(flows), "target": waveform.at(timestamps), - "u_in": jnp.array(u_ins), - "u_out": jnp.array(u_outs), + "u_in": jnp.ndarray(u_ins), + "u_out": jnp.ndarray(u_outs), } for key, val in timeseries.items(): @@ -187,12 +187,12 @@ def run_controller_scan( env.cleanup() timeseries = { - "timestamp": jnp.array(timestamps), - "pressure": jnp.array(pressures), - "flow": jnp.array(flows), + "timestamp": jnp.ndarray(timestamps), + "pressure": jnp.ndarray(pressures), + "flow": jnp.ndarray(flows), "target": waveform.at(timestamps), - "u_in": jnp.array(u_ins), - "u_out": jnp.array(u_outs), + "u_in": jnp.ndarray(u_ins), + "u_out": jnp.ndarray(u_outs), } for key, val in timeseries.items(): diff --git a/deluca/tests/lung/utils/data/analyzer_test.py b/deluca/tests/lung/utils/data/analyzer_test.py index 5ffef33..18e5c2b 100644 --- a/deluca/tests/lung/utils/data/analyzer_test.py +++ b/deluca/tests/lung/utils/data/analyzer_test.py @@ -38,9 +38,9 @@ def setUp(self): [0 for i in range(29)] + [1 for i in range(29)] + [0]) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out diff --git a/deluca/tests/lung/utils/data/breath_dataset_test.py b/deluca/tests/lung/utils/data/breath_dataset_test.py index 0d3221f..bf67230 100644 --- a/deluca/tests/lung/utils/data/breath_dataset_test.py +++ b/deluca/tests/lung/utils/data/breath_dataset_test.py @@ -40,9 +40,9 @@ def setUp(self): [0 for i in range(29)] + [1 for i in range(29)] + [0]) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out diff --git a/deluca/tests/lung/utils/scripts/run_controller_test.py b/deluca/tests/lung/utils/scripts/run_controller_test.py index 00b62a0..3aefa8b 100644 --- a/deluca/tests/lung/utils/scripts/run_controller_test.py +++ b/deluca/tests/lung/utils/scripts/run_controller_test.py @@ -55,9 +55,9 @@ def setUp(self): target = jnp.abs(target + jax.random.normal(jax.random.PRNGKey(3), (88,))) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out diff --git a/deluca/tests/lung/utils/scripts/test_controller_test.py b/deluca/tests/lung/utils/scripts/test_controller_test.py index ae64803..ded264c 100644 --- a/deluca/tests/lung/utils/scripts/test_controller_test.py +++ b/deluca/tests/lung/utils/scripts/test_controller_test.py @@ -55,9 +55,9 @@ def setUp(self): target = jnp.abs(target + jax.random.normal(jax.random.PRNGKey(3), (88,))) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out diff --git a/deluca/tests/lung/utils/scripts/test_simulator_test.py b/deluca/tests/lung/utils/scripts/test_simulator_test.py index 0acfec2..1a23a27 100644 --- a/deluca/tests/lung/utils/scripts/test_simulator_test.py +++ b/deluca/tests/lung/utils/scripts/test_simulator_test.py @@ -45,9 +45,9 @@ def setUp(self): target = jnp.abs(target + jax.random.normal(jax.random.PRNGKey(3), (88,))) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out diff --git a/deluca/tests/lung/utils/scripts/train_controller_test.py b/deluca/tests/lung/utils/scripts/train_controller_test.py index 94231c6..8cfd93c 100644 --- a/deluca/tests/lung/utils/scripts/train_controller_test.py +++ b/deluca/tests/lung/utils/scripts/train_controller_test.py @@ -49,9 +49,9 @@ def setUp(self): target = jnp.abs(target + jax.random.normal(jax.random.PRNGKey(3), (88,))) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out diff --git a/deluca/tests/lung/utils/scripts/train_simulator_test.py b/deluca/tests/lung/utils/scripts/train_simulator_test.py index ebebd64..2d4f227 100644 --- a/deluca/tests/lung/utils/scripts/train_simulator_test.py +++ b/deluca/tests/lung/utils/scripts/train_simulator_test.py @@ -54,9 +54,9 @@ def setUp(self): target = jnp.abs(target + jax.random.normal(jax.random.PRNGKey(3), (88,))) timeseries = { - 'timestamp': jnp.array([0.03 * i for i in range(88)]), + 'timestamp': jnp.ndarray([0.03 * i for i in range(88)]), 'pressure': pressure, - 'flow': jnp.array([0 for i in range(88)]), + 'flow': jnp.ndarray([0 for i in range(88)]), 'target': target, 'u_in': u_in, 'u_out': u_out From e5a31a751cb9449dc0c633d3fc937036de18400e Mon Sep 17 00:00:00 2001 From: Daniel Suo Date: Mon, 9 Jun 2025 13:24:27 +0000 Subject: [PATCH 26/27] Flax is changing the `RNNCellBase` API: - when calling the constructor of a class, it is now required to pass in a `features` argument - when calling the `initialize_carry` method, instead of passing in the `batch_dims` and `size`, you only have to pass in an `input_shape` More details about the changes and how to upgrade to the new API can be found [here](https://flax--3053.org.readthedocs.build/en/3053/guides/rnncell_upgrade_guide.html). --- deluca/lung/utils/nn/lstm.py | 86 +++++++++++++++++++----------------- 1 file changed, 46 insertions(+), 40 deletions(-) diff --git a/deluca/lung/utils/nn/lstm.py b/deluca/lung/utils/nn/lstm.py index 3bd03f9..7c22635 100644 --- a/deluca/lung/utils/nn/lstm.py +++ b/deluca/lung/utils/nn/lstm.py @@ -15,57 +15,63 @@ """lstm module.""" import functools from typing import Callable + import flax.linen as nn import jax import jax.numpy as jnp - # pylint: disable=g-bare-generic class LSTM(nn.Module): - """LSTM encoder, returning state after EOS is input.""" - n_layers: int = 2 # or 4 - hidden_dim: int = 20 - out_dim: int = 1 - bptt: int = 3 # or 10 or 29 - activation_fn: Callable = nn.tanh + """LSTM encoder, returning state after EOS is input.""" - @nn.compact - def __call__(self, inputs): - # inputs.shape = (batch_size, seq_length, vocab_size). - batch_size = (inputs.shape[0],) - lstm = LSTMNetwork( - n_layers=self.n_layers, activation_fn=self.activation_fn) - init_lstm_state = lstm.initialize_carry(batch_size, self.hidden_dim) - init_lstm_state = (init_lstm_state[0].astype(jnp.float64), - init_lstm_state[1].astype(jnp.float64)) - _, y = lstm(init_lstm_state, inputs) - y = nn.Dense(features=self.out_dim, use_bias=True, name='lstm_fc')(y) - return y[0, -1, 0] # squeeze for consistent shape w/ boundary model output + n_layers: int = 2 # or 4 + hidden_dim: int = 20 + out_dim: int = 1 + bptt: int = 3 # or 10 or 29 + activation_fn: Callable = nn.tanh + + @nn.compact + def __call__(self, inputs): + # inputs.shape = (batch_size, seq_length, vocab_size). + batch_size = (inputs.shape[0],) + lstm = LSTMNetwork(n_layers=self.n_layers, activation_fn=self.activation_fn) + init_lstm_state = lstm.initialize_carry(batch_size, self.hidden_dim) + init_lstm_state = ( + init_lstm_state[0].astype(jnp.float64), + init_lstm_state[1].astype(jnp.float64), + ) + _, y = lstm(init_lstm_state, inputs) + y = nn.Dense(features=self.out_dim, use_bias=True, name="lstm_fc")(y) + return y[0, -1, 0] # squeeze for consistent shape w/ boundary model output class LSTMNetwork(nn.Module): - """A simple unidirectional LSTM.""" - n_layers: int = 2 # or 4 - activation_fn: Callable = nn.tanh + """A simple unidirectional LSTM.""" + + n_layers: int = 2 # or 4 + activation_fn: Callable = nn.tanh - @functools.partial( - nn.transforms.scan, - variable_broadcast='params', - in_axes=1, - out_axes=1, - split_rngs={'params': False}) - @nn.compact - def __call__(self, carry, x): - for _ in range(self.n_layers): - carry, x = nn.OptimizedLSTMCell(activation_fn=self.activation_fn)(carry, - x) - return carry, x + @functools.partial( + nn.transforms.scan, + variable_broadcast="params", + in_axes=1, + out_axes=1, + split_rngs={"params": False}, + ) + @nn.compact + def __call__(self, carry, x): + for _ in range(self.n_layers): + carry, x = nn.OptimizedLSTMCell(features, activation_fn=self.activation_fn)( + carry, x + ) + return carry, x - @staticmethod - def initialize_carry(batch_dims, hidden_dim): - # (N, C, H, W) = (N, 1, 1, W) where W = feature_dim and N is batch_size - # Use fixed random key since default state init fn is just zeros. - return nn.OptimizedLSTMCell.initialize_carry( - jax.random.PRNGKey(0), batch_dims, hidden_dim) + @staticmethod + def initialize_carry(batch_dims, hidden_dim): + # (N, C, H, W) = (N, 1, 1, W) where W = feature_dim and N is batch_size + # Use fixed random key since default state init fn is just zeros. + return nn.OptimizedLSTMCell.(hidden_dim, parent=-None).initialize_carry( + jax.random.PRNGKey(0), batch_dims, hidden_dim + ) From 81346b96458d430a14b7579936af6f167f4bd9a0 Mon Sep 17 00:00:00 2001 From: eladhazan Date: Mon, 9 Jun 2025 21:31:07 +0000 Subject: [PATCH 27/27] some fixes to zero agent --- deluca/agents/_zero.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/deluca/agents/_zero.py b/deluca/agents/_zero.py index bb5139c..ccc2a4d 100644 --- a/deluca/agents/_zero.py +++ b/deluca/agents/_zero.py @@ -19,16 +19,16 @@ class Zero(Agent): - d_action: int = field(1, jaxed=False) - agent_state: jnp.ndarray = field(default_factory=lambda: jnp.ndarray([[1.0]]), jaxed=False) + d_action: int = 1 +# agent_state: jnp.ndarray = field(default_factory=lambda: jnp.ndarray([[1.0]]), jaxed=False) def init(self,d_action): self.d_action = d_action - self.agent_state = None +# self.agent_state = None return None def __call__(self, obs): return jnp.zeros((self.d_action,1)) - def update(self, state: jnp.ndarray, u: jnp.ndarray) -> None: + def update(self, y:jnp.array, u: jnp.ndarray) -> None: return None