From 0bd38cbdf5c07a75db79f5adfba61009fdc3ff04 Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 14:44:48 -0400 Subject: [PATCH 01/10] feat: move state objects in from autora-workflow --- src/autora/state/delta.py | 321 ++++++++++++++++ src/autora/state/history.py | 722 +++++++++++++++++++++++++++++++++++ src/autora/state/param.py | 143 +++++++ src/autora/state/protocol.py | 158 ++++++++ src/autora/state/snapshot.py | 201 ++++++++++ src/autora/state/wrapper.py | 87 +++++ 6 files changed, 1632 insertions(+) create mode 100644 src/autora/state/delta.py create mode 100644 src/autora/state/history.py create mode 100644 src/autora/state/param.py create mode 100644 src/autora/state/protocol.py create mode 100644 src/autora/state/snapshot.py create mode 100644 src/autora/state/wrapper.py diff --git a/src/autora/state/delta.py b/src/autora/state/delta.py new file mode 100644 index 00000000..9b8221a1 --- /dev/null +++ b/src/autora/state/delta.py @@ -0,0 +1,321 @@ +"""Classes to represent cycle state $S$ as $S_n = S_{0} + \\sum_{i=1}^n \\Delta S_{i}""" +from __future__ import annotations + +import dataclasses +import inspect +from collections import UserDict +from dataclasses import dataclass, fields, replace +from functools import singledispatch, wraps +from typing import Generic, List, TypeVar + +import numpy as np +import pandas as pd + +S = TypeVar("S") +T = TypeVar("T") + + +@dataclass(frozen=True) +class State: + """ + Base object for dataclasses which use the Delta mechanism. + + Examples: + >>> from dataclasses import dataclass, field + + We define a dataclass where each field (which is going to be delta-ed) has additional + metadata "delta" which describes its delta behaviour. + >>> @dataclass(frozen=True) + ... class ListState(State): + ... l: List = field(default_factory=list, metadata={"delta": "extend"}) + ... m: List = field(default_factory=list, metadata={"delta": "replace"}) + + Now we instantiate the dataclass... + >>> l = ListState(l=list("abc"), m=list("xyz")) + >>> l + ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z']) + + ... and can add deltas to it. `l` will be extended: + >>> l + Delta(l=list("def")) + ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['x', 'y', 'z']) + + ... wheras `m` will be replaced: + >>> l + Delta(m=list("uvw")) + ListState(l=['a', 'b', 'c'], m=['u', 'v', 'w']) + + ... they can be chained: + >>> l + Delta(l=list("def")) + Delta(m=list("uvw")) + ListState(l=['a', 'b', 'c', 'd', 'e', 'f'], m=['u', 'v', 'w']) + + ... and we update multiple fields with one Delta: + >>> l + Delta(l=list("ghi"), m=list("rst")) + ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't']) + + Passing a nonexistent field will cause an error: + >>> l + Delta(o="not a field") + Traceback (most recent call last): + ... + AttributeError: key=`o` is missing on ListState(l=['a', 'b', 'c'], m=['x', 'y', 'z']) + + We can also use the `.update` method to do the same thing: + >>> l.update(l=list("ghi"), m=list("rst")) + ListState(l=['a', 'b', 'c', 'g', 'h', 'i'], m=['r', 's', 't']) + + We can also define fields which `append` the last result: + >>> @dataclass(frozen=True) + ... class AppendState(State): + ... n: List = field(default_factory=list, metadata={"delta": "append"}) + + >>> m = AppendState(n=list("ɑβɣ")) + >>> m + AppendState(n=['ɑ', 'β', 'ɣ']) + + `n` will be appended: + >>> m + Delta(n="∂") + AppendState(n=['ɑ', 'β', 'ɣ', '∂']) + + """ + + def __add__(self, other: Delta): + updates = dict() + for key, other_value in other.data.items(): + try: + self_field = next(filter(lambda f: f.name == key, fields(self))) + except StopIteration: + raise AttributeError("key=`%s` is missing on %s" % (key, self)) + delta_behavior = self_field.metadata["delta"] + self_value = getattr(self, key) + if delta_behavior == "extend": + extended_value = extend(self_value, other_value) + updates[key] = extended_value + elif delta_behavior == "append": + appended_value = append(self_value, other_value) + updates[key] = appended_value + elif delta_behavior == "replace": + updates[key] = other_value + else: + raise NotImplementedError( + "delta_behaviour=`%s` not implemented" % (delta_behavior) + ) + + new = replace(self, **updates) + return new + + def update(self, **kwargs): + return self + Delta(**kwargs) + + +class Delta(UserDict, Generic[S]): + """ + Represents a delta where the base object determines the extension behavior. + + Examples: + >>> from dataclasses import dataclass + + First we define the dataclass to act as the basis: + >>> from typing import Optional, List + >>> @dataclass(frozen=True) + ... class ListState: + ... l: Optional[List] = None + ... m: Optional[List] = None + ... + """ + + pass + + +Result = Delta +"""`Result` is an alias for `Delta`.""" + + +@singledispatch +def extend(a, b): + """ + Function to extend supported datatypes. + + """ + raise NotImplementedError("`extend` not implemented for %s, %s" % (a, b)) + + +@extend.register(list) +def extend_list(a, b): + """ + Examples: + >>> extend([], []) + [] + + >>> extend([1,2], [3]) + [1, 2, 3] + """ + return a + b + + +@extend.register(pd.DataFrame) +def extend_pd_dataframe(a, b): + """ + Examples: + >>> extend(pd.DataFrame({"a": []}), pd.DataFrame({"a": []})) + Empty DataFrame + Columns: [a] + Index: [] + + >>> extend(pd.DataFrame({"a": [1,2,3]}), pd.DataFrame({"a": [4,5,6]})) + a + 0 1 + 1 2 + 2 3 + 3 4 + 4 5 + 5 6 + """ + return pd.concat((a, b), ignore_index=True) + + +def append(a: List[T], b: T) -> List[T]: + # TODO: add DOCTESTS + return a + [b] + + +@extend.register(np.ndarray) +def extend_np_ndarray(a, b): + """ + Examples: + >>> extend(np.array([(1,2,3), (4,5,6)]), np.array([(7,8,9)])) + array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + """ + return np.row_stack([a, b]) + + +@extend.register(dict) +def extend_dict(a, b): + """ + Examples: + >>> extend({"a": "cats"}, {"b": "dogs"}) + {'a': 'cats', 'b': 'dogs'} + """ + return dict(a, **b) + + +def wrap_to_use_state(f): + """Decorator to make target `f` into a function on a `State` and `**kwargs`. + + This wrapper makes it easier to pass arguments to a function from a State. + + It was inspired by the pytest "fixtures" mechanism. + + Args: + f: + + Returns: + + Examples: + >>> from autora.state.delta import State, Delta + >>> from dataclasses import dataclass, field + >>> import pandas as pd + >>> from typing import List, Optional + + The `State` it operates on needs to have the metadata described in the state module: + >>> @dataclass(frozen=True) + ... class S(State): + ... conditions: List[int] = field(metadata={"delta": "replace"}) + + We indicate the inputs required by the parameter names. + The output must be a `Delta` object. + >>> from autora.state.delta import Delta + >>> @wrap_to_use_state + ... def experimentalist(conditions): + ... new_conditions = [c + 10 for c in conditions] + ... return Delta(conditions=new_conditions) + + >>> experimentalist(S(conditions=[1,2,3,4])) + S(conditions=[11, 12, 13, 14]) + + >>> experimentalist(S(conditions=[101,102,103,104])) + S(conditions=[111, 112, 113, 114]) + + >>> from autora.variable import VariableCollection, Variable + >>> from sklearn.base import BaseEstimator + >>> from sklearn.linear_model import LinearRegression + + >>> @wrap_to_use_state + ... def theorist(experimental_data: pd.DataFrame, variables: VariableCollection, **kwargs): + ... ivs = [v.name for v in variables.independent_variables] + ... dvs = [v.name for v in variables.dependent_variables] + ... X, y = experimental_data[ivs], experimental_data[dvs] + ... new_model = LinearRegression(fit_intercept=True).set_params(**kwargs).fit(X, y) + ... return Delta(model=new_model) + + >>> @dataclass(frozen=True) + ... class T(State): + ... variables: VariableCollection # field(metadata={"delta":... }) omitted ∴ immutable + ... experimental_data: pd.DataFrame = field(metadata={"delta": "extend"}) + ... model: Optional[BaseEstimator] = field(metadata={"delta": "replace"}, default=None) + + >>> t = T( + ... variables=VariableCollection(independent_variables=[Variable("x")], + ... dependent_variables=[Variable("y")]), + ... experimental_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]}) + ... ) + >>> t_prime = theorist(t) + >>> t_prime.model.coef_, t_prime.model.intercept_ + (array([[1.]]), array([2.])) + + Arguments from the state can be overridden by passing them in as keyword arguments (kwargs): + >>> theorist(t, experimental_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\ + ... .model.intercept_ + array([12.]) + + ... and other arguments supported by the inner function can also be passed + (if and only if the inner function allows for and handles `**kwargs` arguments alongside + the values from the state). + >>> theorist(t, fit_intercept=False).model.intercept_ + 0.0 + + Any parameters not provided by the state must be provided by default values or by the + caller. If the default is specified: + >>> @wrap_to_use_state + ... def experimentalist(conditions, offset=25): + ... new_conditions = [c + offset for c in conditions] + ... return Delta(conditions=new_conditions) + + ... then it need not be passed. + >>> experimentalist(S(conditions=[1,2,3,4])) + S(conditions=[26, 27, 28, 29]) + + If a default isn't specified: + >>> @wrap_to_use_state + ... def experimentalist(conditions, offset): + ... new_conditions = [c + offset for c in conditions] + ... return Delta(conditions=new_conditions) + + ... then calling the experimentalist without it will throw an error: + >>> experimentalist(S(conditions=[1,2,3,4])) + Traceback (most recent call last): + ... + TypeError: experimentalist() missing 1 required positional argument: 'offset' + + ... which can be fixed by passing the argument as a keyword to the wrapped function. + >>> experimentalist(S(conditions=[1,2,3,4]), offset=2) + S(conditions=[3, 4, 5, 6]) + + """ + # Get the set of parameter names from function f's signature + parameters_ = set(inspect.signature(f).parameters.keys()) + + @wraps(f) + def _f(state_: S, /, **kwargs) -> S: + # Get the parameters needed which are available from the state_. + # All others must be provided as kwargs or default values on f. + assert dataclasses.is_dataclass(state_) + from_state = parameters_.intersection( + {i.name for i in dataclasses.fields(state_)} + ) + arguments_from_state = {k: getattr(state_, k) for k in from_state} + arguments = dict(arguments_from_state, **kwargs) + delta = f(**arguments) + new_state = state_ + delta + return new_state + + return _f diff --git a/src/autora/state/history.py b/src/autora/state/history.py new file mode 100644 index 00000000..fbb33944 --- /dev/null +++ b/src/autora/state/history.py @@ -0,0 +1,722 @@ +""" Classes for storing and passing a cycle's state as an immutable history. """ +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Union + +from numpy.typing import ArrayLike +from sklearn.base import BaseEstimator + +from autora.state.delta import Delta +from autora.state.protocol import ( + ResultKind, + SupportsControllerStateHistory, + SupportsDataKind, +) +from autora.state.snapshot import Snapshot +from autora.variable import VariableCollection + + +class History(SupportsControllerStateHistory): + """ + An immutable object for tracking the state and history of an AER cycle. + """ + + def __init__( + self, + variables: Optional[VariableCollection] = None, + params: Optional[Dict] = None, + conditions: Optional[List[ArrayLike]] = None, + observations: Optional[List[ArrayLike]] = None, + models: Optional[List[BaseEstimator]] = None, + history: Optional[Sequence[Result]] = None, + ): + """ + + Args: + variables: a single datum to be marked as "variables" + params: a single datum to be marked as "params" + conditions: an iterable of data, each to be marked as "conditions" + observations: an iterable of data, each to be marked as "observations" + models: an iterable of data, each to be marked as "models" + history: an iterable of Result objects to be used as the initial history. + + Examples: + Empty input leads to an empty state: + >>> History() + History([]) + + ... or with values for any or all of the parameters: + >>> from autora.variable import VariableCollection + >>> History(variables=VariableCollection()) # doctest: +ELLIPSIS + History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]) + + >>> History(params={"some": "params"}) + History([Result(data={'some': 'params'}, kind=ResultKind.PARAMS)]) + + >>> History(conditions=["a condition"]) + History([Result(data='a condition', kind=ResultKind.CONDITION)]) + + >>> History(observations=["an observation"]) + History([Result(data='an observation', kind=ResultKind.OBSERVATION)]) + + >>> from sklearn.linear_model import LinearRegression + >>> History(models=[LinearRegression()]) + History([Result(data=LinearRegression(), kind=ResultKind.MODEL)]) + + Parameters passed to the constructor are included in the history in the following order: + `history`, `variables`, `params`, `conditions`, `observations`, `models` + >>> History(models=['m1', 'm2'], conditions=['c1', 'c2'], + ... observations=['o1', 'o2'], params={'a': 'param'}, + ... variables=VariableCollection(), + ... history=[Result("from history", ResultKind.VARIABLES)] + ... ) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + History([Result(data='from history', kind=ResultKind.VARIABLES), + Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), + Result(data={'a': 'param'}, kind=ResultKind.PARAMS), + Result(data='c1', kind=ResultKind.CONDITION), + Result(data='c2', kind=ResultKind.CONDITION), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='o2', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='m2', kind=ResultKind.MODEL)]) + """ + self.data: List + + if history is not None: + self.data = list(history) + else: + self.data = [] + + self.data += _init_result_list( + variables=variables, + params=params, + conditions=conditions, + observations=observations, + models=models, + ) + + def update( + self, + variables=None, + params=None, + conditions=None, + observations=None, + models=None, + history=None, + ): + """ + Create a new object with updated values. + + Examples: + The initial object is empty: + >>> h0 = History() + >>> h0 + History([]) + + We can update the variables using the `.update` method: + >>> from autora.variable import VariableCollection + >>> h1 = h0.update(variables=VariableCollection()) + >>> h1 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]) + + ... the original object is unchanged: + >>> h0 + History([]) + + We can update the variables again: + >>> h2 = h1.update(variables=VariableCollection(["some IV"])) + >>> h2._by_kind # doctest: +ELLIPSIS + Snapshot(variables=VariableCollection(independent_variables=['some IV'],...), ...) + + ... and we see that there is only ever one variables object returned. + + Params is treated the same way as variables: + >>> hp = h0.update(params={'first': 'params'}) + >>> hp + History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS)]) + + ... where only the most recent "params" object is returned from the `.params` property. + >>> hp = hp.update(params={'second': 'params'}) + >>> hp.params + {'second': 'params'} + + ... however, the full history of the params objects remains available, if needed: + >>> hp # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS), + Result(data={'second': 'params'}, kind=ResultKind.PARAMS)]) + + When we update the conditions, observations or models, a new entry is added to the + history: + >>> h3 = h0.update(models=["1st model"]) + >>> h3 # doctest: +NORMALIZE_WHITESPACE + History([Result(data='1st model', kind=ResultKind.MODEL)]) + + ... so we can see the history of all the models, for instance. + >>> h3 = h3.update(models=["2nd model"]) # doctest: +NORMALIZE_WHITESPACE + >>> h3 # doctest: +NORMALIZE_WHITESPACE + History([Result(data='1st model', kind=ResultKind.MODEL), + Result(data='2nd model', kind=ResultKind.MODEL)]) + + ... and the full history of models is available using the `.models` parameter: + >>> h3.models + ['1st model', '2nd model'] + + The same for the observations: + >>> h4 = h0.update(observations=["1st observation"]) + >>> h4 + History([Result(data='1st observation', kind=ResultKind.OBSERVATION)]) + + >>> h4.update(observations=["2nd observation"] + ... ) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + History([Result(data='1st observation', kind=ResultKind.OBSERVATION), + Result(data='2nd observation', kind=ResultKind.OBSERVATION)]) + + + The same for the conditions: + >>> h5 = h0.update(conditions=["1st condition"]) + >>> h5 + History([Result(data='1st condition', kind=ResultKind.CONDITION)]) + + >>> h5.update(conditions=["2nd condition"]) # doctest: +NORMALIZE_WHITESPACE + History([Result(data='1st condition', kind=ResultKind.CONDITION), + Result(data='2nd condition', kind=ResultKind.CONDITION)]) + + You can also update with multiple conditions, observations and models: + >>> h0.update(conditions=['c1', 'c2']) # doctest: +NORMALIZE_WHITESPACE + History([Result(data='c1', kind=ResultKind.CONDITION), + Result(data='c2', kind=ResultKind.CONDITION)]) + + >>> h0.update(models=['m1', 'm2'], variables={'m': 1} + ... ) # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='m2', kind=ResultKind.MODEL)]) + + >>> h0.update(models=['m1'], observations=['o1'], variables={'m': 1} + ... ) # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL)]) + + We can also update with a complete history: + >>> History().update(history=[Result(data={'m': 2}, kind=ResultKind.VARIABLES), + ... Result(data='o1', kind=ResultKind.OBSERVATION), + ... Result(data='m1', kind=ResultKind.MODEL)], + ... conditions=['c1'] + ... ) # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'m': 2}, kind=ResultKind.VARIABLES), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='c1', kind=ResultKind.CONDITION)]) + + """ + + if history is not None: + history_extension = history + else: + history_extension = [] + + history_extension += _init_result_list( + variables=variables, + params=params, + conditions=conditions, + observations=observations, + models=models, + ) + new_full_history = self.data + history_extension + + return History(history=new_full_history) + + def __add__(self, other: Delta): + """The initial object is empty: + >>> h0 = History() + >>> h0 + History([]) + + We can update the variables using the `.update` method: + >>> from autora.variable import VariableCollection + >>> h1 = h0 + Delta(variables=VariableCollection()) + >>> h1 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + History([Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)]) + + ... the original object is unchanged: + >>> h0 + History([]) + + We can update the variables again: + >>> h2 = h1 + Delta(variables=VariableCollection(["some IV"])) + >>> h2._by_kind # doctest: +ELLIPSIS + Snapshot(variables=VariableCollection(independent_variables=['some IV'],...), ...) + + ... and we see that there is only ever one variables object returned. + + Params is treated the same way as variables: + >>> hp = h0 + Delta(params={'first': 'params'}) + >>> hp + History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS)]) + + ... where only the most recent "params" object is returned from the `.params` property. + >>> hp = hp + Delta(params={'second': 'params'}) + >>> hp.params + {'second': 'params'} + + ... however, the full history of the params objects remains available, if needed: + >>> hp # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS), + Result(data={'second': 'params'}, kind=ResultKind.PARAMS)]) + + When we update the conditions, observations or models, a new entry is added to the + history: + >>> h3 = h0 + Delta(models=["1st model"]) + >>> h3 # doctest: +NORMALIZE_WHITESPACE + History([Result(data='1st model', kind=ResultKind.MODEL)]) + + ... so we can see the history of all the models, for instance. + >>> h3 = h3 + Delta(models=["2nd model"]) # doctest: +NORMALIZE_WHITESPACE + >>> h3 # doctest: +NORMALIZE_WHITESPACE + History([Result(data='1st model', kind=ResultKind.MODEL), + Result(data='2nd model', kind=ResultKind.MODEL)]) + + ... and the full history of models is available using the `.models` parameter: + >>> h3.models + ['1st model', '2nd model'] + + The same for the observations: + >>> h4 = h0 + Delta(observations=["1st observation"]) + >>> h4 + History([Result(data='1st observation', kind=ResultKind.OBSERVATION)]) + + >>> h4 + Delta(observations=["2nd observation"] + ... ) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + History([Result(data='1st observation', kind=ResultKind.OBSERVATION), + Result(data='2nd observation', kind=ResultKind.OBSERVATION)]) + + + The same for the conditions: + >>> h5 = h0 + Delta(conditions=["1st condition"]) + >>> h5 + History([Result(data='1st condition', kind=ResultKind.CONDITION)]) + + >>> h5 + Delta(conditions=["2nd condition"]) # doctest: +NORMALIZE_WHITESPACE + History([Result(data='1st condition', kind=ResultKind.CONDITION), + Result(data='2nd condition', kind=ResultKind.CONDITION)]) + + You can also update with multiple conditions, observations and models: + >>> h0 + Delta(conditions=['c1', 'c2']) # doctest: +NORMALIZE_WHITESPACE + History([Result(data='c1', kind=ResultKind.CONDITION), + Result(data='c2', kind=ResultKind.CONDITION)]) + + >>> h0 + Delta(models=['m1', 'm2'], variables={'m': 1} + ... ) # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='m2', kind=ResultKind.MODEL)]) + + >>> h0 + Delta(models=['m1'], observations=['o1'], variables={'m': 1} + ... ) # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'m': 1}, kind=ResultKind.VARIABLES), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL)]) + + We can also update with a complete history: + >>> History() + Delta(history=[Result(data={'m': 2}, kind=ResultKind.VARIABLES), + ... Result(data='o1', kind=ResultKind.OBSERVATION), + ... Result(data='m1', kind=ResultKind.MODEL)], + ... conditions=['c1'] + ... ) # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'m': 2}, kind=ResultKind.VARIABLES), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='c1', kind=ResultKind.CONDITION)]) + """ + return self.update(**other) + + def __repr__(self): + return f"{type(self).__name__}({self.history})" + + @property + def _by_kind(self): + return _history_to_kind(self.data) + + @property + def variables(self) -> VariableCollection: + """ + + Examples: + The initial object is empty: + >>> h = History() + + ... and returns an emtpy variables object + >>> h.variables + VariableCollection(independent_variables=[], dependent_variables=[], covariates=[]) + + We can update the variables using the `.update` method: + >>> from autora.variable import VariableCollection + >>> h = h.update(variables=VariableCollection(independent_variables=['some IV'])) + >>> h.variables # doctest: +ELLIPSIS + VariableCollection(independent_variables=['some IV'], ...) + + We can update the variables again: + >>> h = h.update(variables=VariableCollection(["some other IV"])) + >>> h.variables # doctest: +ELLIPSIS + VariableCollection(independent_variables=['some other IV'], ...) + + ... and we see that there is only ever one variables object returned.""" + return self._by_kind.variables + + @property + def params(self) -> Dict: + """ + + Returns: + + Examples: + Params is treated the same way as variables: + >>> h = History() + >>> h = h.update(params={'first': 'params'}) + >>> h.params + {'first': 'params'} + + ... where only the most recent "params" object is returned from the `.params` property. + >>> h = h.update(params={'second': 'params'}) + >>> h.params + {'second': 'params'} + + ... however, the full history of the params objects remains available, if needed: + >>> h # doctest: +NORMALIZE_WHITESPACE + History([Result(data={'first': 'params'}, kind=ResultKind.PARAMS), + Result(data={'second': 'params'}, kind=ResultKind.PARAMS)]) + """ + return self._by_kind.params + + @property + def conditions(self) -> List[ArrayLike]: + """ + Returns: + + Examples: + View the sequence of models with one conditions: + >>> h = History(conditions=[(1,2,3,)]) + >>> h.conditions + [(1, 2, 3)] + + ... or more conditions: + >>> h = h.update(conditions=[(4,5,6),(7,8,9)]) # doctest: +NORMALIZE_WHITESPACE + >>> h.conditions + [(1, 2, 3), (4, 5, 6), (7, 8, 9)] + + """ + return self._by_kind.conditions + + @property + def observations(self) -> List[ArrayLike]: + """ + + Returns: + + Examples: + The sequence of all observations is returned + >>> h = History(observations=["1st observation"]) + >>> h.observations + ['1st observation'] + + >>> h = h.update(observations=["2nd observation"]) + >>> h.observations # doctest: +ELLIPSIS + ['1st observation', '2nd observation'] + + """ + return self._by_kind.observations + + @property + def models(self) -> List[BaseEstimator]: + """ + + Returns: + + Examples: + View the sequence of models with one model: + >>> s = History(models=["1st model"]) + >>> s.models # doctest: +NORMALIZE_WHITESPACE + ['1st model'] + + ... or more models: + >>> s = s.update(models=["2nd model"]) # doctest: +NORMALIZE_WHITESPACE + >>> s.models + ['1st model', '2nd model'] + + """ + return self._by_kind.models + + @property + def history(self) -> List[Result]: + """ + + Examples: + We initialze some history: + >>> h = History(models=['m1', 'm2'], conditions=['c1', 'c2'], + ... observations=['o1', 'o2'], params={'a': 'param'}, + ... variables=VariableCollection(), + ... history=[Result("from history", ResultKind.VARIABLES)]) + + Parameters passed to the constructor are included in the history in the following order: + `history`, `variables`, `params`, `conditions`, `observations`, `models` + + >>> h.history # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + [Result(data='from history', kind=ResultKind.VARIABLES), + Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), + Result(data={'a': 'param'}, kind=ResultKind.PARAMS), + Result(data='c1', kind=ResultKind.CONDITION), + Result(data='c2', kind=ResultKind.CONDITION), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='o2', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='m2', kind=ResultKind.MODEL)] + + If we add a new value, like the params object, the updated value is added to the + end of the history: + >>> h = h.update(params={'new': 'param'}) + >>> h.history # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + [..., Result(data={'new': 'param'}, kind=ResultKind.PARAMS)] + + """ + return self.data + + def filter_by(self, kind: Optional[Set[Union[str, ResultKind]]] = None) -> History: + """ + Return a copy of the object with only data belonging to the specified kinds. + + Examples: + >>> h = History(models=['m1', 'm2'], conditions=['c1', 'c2'], + ... observations=['o1', 'o2'], params={'a': 'param'}, + ... variables=VariableCollection(), + ... history=[Result("from history", ResultKind.VARIABLES)]) + + >>> h.filter_by(kind={"MODEL"}) # doctest: +NORMALIZE_WHITESPACE + History([Result(data='m1', kind=ResultKind.MODEL), + Result(data='m2', kind=ResultKind.MODEL)]) + + >>> h.filter_by(kind={ResultKind.OBSERVATION}) # doctest: +NORMALIZE_WHITESPACE + History([Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='o2', kind=ResultKind.OBSERVATION)]) + + If we don't specify any filter criteria, we get the full history back: + >>> h.filter_by() # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + History([Result(data='from history', kind=ResultKind.VARIABLES), + Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), + Result(data={'a': 'param'}, kind=ResultKind.PARAMS), + Result(data='c1', kind=ResultKind.CONDITION), + Result(data='c2', kind=ResultKind.CONDITION), + Result(data='o1', kind=ResultKind.OBSERVATION), + Result(data='o2', kind=ResultKind.OBSERVATION), + Result(data='m1', kind=ResultKind.MODEL), + Result(data='m2', kind=ResultKind.MODEL)]) + + """ + if kind is None: + return self + else: + kind_ = {ResultKind(s) for s in kind} + filtered_history = _filter_history(self.data, kind_) + new_object = History(history=filtered_history) + return new_object + + +@dataclass(frozen=True) +class Result(SupportsDataKind): + """ + Container class for data and variables. + + Examples: + >>> Result() + Result(data=None, kind=None) + + >>> Result("a") + Result(data='a', kind=None) + + >>> Result(None, "MODEL") + Result(data=None, kind=ResultKind.MODEL) + + >>> Result(data="b") + Result(data='b', kind=None) + + >>> Result("c", "OBSERVATION") + Result(data='c', kind=ResultKind.OBSERVATION) + """ + + data: Optional[Any] = None + kind: Optional[ResultKind] = None + + def __post_init__(self): + if isinstance(self.kind, str): + object.__setattr__(self, "kind", ResultKind(self.kind)) + + +def _init_result_list( + variables: Optional[VariableCollection] = None, + params: Optional[Dict] = None, + conditions: Optional[Iterable[ArrayLike]] = None, + observations: Optional[Iterable[ArrayLike]] = None, + models: Optional[Iterable[BaseEstimator]] = None, +) -> List[Result]: + """ + Initialize a list of Result objects + + Returns: + + Args: + variables: a single datum to be marked as "variables" + params: a single datum to be marked as "params" + conditions: an iterable of data, each to be marked as "conditions" + observations: an iterable of data, each to be marked as "observations" + models: an iterable of data, each to be marked as "models" + + Examples: + Empty input leads to an empty state: + >>> _init_result_list() + [] + + ... or with values for any or all of the parameters: + >>> from autora.variable import VariableCollection + >>> _init_result_list(variables=VariableCollection()) # doctest: +ELLIPSIS + [Result(data=VariableCollection(...), kind=ResultKind.VARIABLES)] + + >>> _init_result_list(params={"some": "params"}) + [Result(data={'some': 'params'}, kind=ResultKind.PARAMS)] + + >>> _init_result_list(conditions=["a condition"]) + [Result(data='a condition', kind=ResultKind.CONDITION)] + + >>> _init_result_list(observations=["an observation"]) + [Result(data='an observation', kind=ResultKind.OBSERVATION)] + + >>> from sklearn.linear_model import LinearRegression + >>> _init_result_list(models=[LinearRegression()]) + [Result(data=LinearRegression(), kind=ResultKind.MODEL)] + + The input arguments are added to the data in the order `variables`, + `params`, `conditions`, `observations`, `models`: + >>> _init_result_list(variables=VariableCollection(), + ... params={"some": "params"}, + ... conditions=["a condition"], + ... observations=["an observation", "another observation"], + ... models=[LinearRegression()], + ... ) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + [Result(data=VariableCollection(...), kind=ResultKind.VARIABLES), + Result(data={'some': 'params'}, kind=ResultKind.PARAMS), + Result(data='a condition', kind=ResultKind.CONDITION), + Result(data='an observation', kind=ResultKind.OBSERVATION), + Result(data='another observation', kind=ResultKind.OBSERVATION), + Result(data=LinearRegression(), kind=ResultKind.MODEL)] + + """ + data = [] + + if variables is not None: + data.append(Result(variables, ResultKind.VARIABLES)) + + if params is not None: + data.append(Result(params, ResultKind.PARAMS)) + + for seq, kind in [ + (conditions, ResultKind.CONDITION), + (observations, ResultKind.OBSERVATION), + (models, ResultKind.MODEL), + ]: + if seq is not None: + for i in seq: + data.append(Result(i, kind=kind)) + + return data + + +def _history_to_kind(history: Sequence[Result]) -> Snapshot: + """ + Convert a sequence of results into a Snapshot instance: + + Examples: + History might be empty + >>> history_ = [] + >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + Snapshot(variables=VariableCollection(...), params={}, + conditions=[], observations=[], models=[]) + + ... or with values for any or all of the parameters: + >>> history_ = _init_result_list(params={"some": "params"}) + >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + Snapshot(..., params={'some': 'params'}, ...) + + >>> history_ += _init_result_list(conditions=["a condition"]) + >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + Snapshot(..., params={'some': 'params'}, conditions=['a condition'], ...) + + >>> _history_to_kind(history_).params + {'some': 'params'} + + >>> history_ += _init_result_list(observations=["an observation"]) + >>> _history_to_kind(history_) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS + Snapshot(..., params={'some': 'params'}, conditions=['a condition'], + observations=['an observation'], ...) + + >>> from sklearn.linear_model import LinearRegression + >>> history_ = [Result(LinearRegression(), kind=ResultKind.MODEL)] + >>> _history_to_kind(history_) # doctest: +ELLIPSIS + Snapshot(..., models=[LinearRegression()]) + + >>> from autora.variable import VariableCollection, IV + >>> variables = VariableCollection(independent_variables=[IV(name="example")]) + >>> history_ = [Result(variables, kind=ResultKind.VARIABLES)] + >>> _history_to_kind(history_) # doctest: +ELLIPSIS + Snapshot(variables=VariableCollection(independent_variables=[IV(name='example', ... + + >>> history_ = [Result({'some': 'params'}, kind=ResultKind.PARAMS)] + >>> _history_to_kind(history_) # doctest: +ELLIPSIS + Snapshot(..., params={'some': 'params'}, ...) + + """ + namespace = Snapshot( + variables=_get_last_data_with_default( + history, kind={ResultKind.VARIABLES}, default=VariableCollection() + ), + params=_get_last_data_with_default( + history, kind={ResultKind.PARAMS}, default={} + ), + observations=_list_data( + _filter_history(history, kind={ResultKind.OBSERVATION}) + ), + models=_list_data(_filter_history(history, kind={ResultKind.MODEL})), + conditions=_list_data(_filter_history(history, kind={ResultKind.CONDITION})), + ) + return namespace + + +def _list_data(data: Sequence[SupportsDataKind]): + """ + Extract the `.data` attribute of each item in a sequence, and return as a list. + + Examples: + >>> _list_data([]) + [] + + >>> _list_data([Result("a"), Result("b")]) + ['a', 'b'] + """ + return list(r.data for r in data) + + +def _filter_history(data: Iterable[SupportsDataKind], kind: Set[ResultKind]): + return filter(lambda r: r.kind in kind, data) + + +def _get_last(data: Sequence[SupportsDataKind], kind: Set[ResultKind]): + results_new_to_old = reversed(data) + last_of_kind = next(_filter_history(results_new_to_old, kind=kind)) + return last_of_kind + + +def _get_last_data_with_default(data: Sequence[SupportsDataKind], kind, default): + try: + result = _get_last(data, kind).data + except StopIteration: + result = default + return result diff --git a/src/autora/state/param.py b/src/autora/state/param.py new file mode 100644 index 00000000..1fca3cfc --- /dev/null +++ b/src/autora/state/param.py @@ -0,0 +1,143 @@ +""" Functions for handling cycle-state-dependent parameters. """ +from __future__ import annotations + +import copy +import logging +from typing import Dict, Mapping + +import numpy as np + +from autora.state.protocol import SupportsControllerState +from autora.utils.deprecation import deprecate as deprecate +from autora.utils.dictionary import LazyDict + +_logger = logging.getLogger(__name__) + + +def _get_state_dependent_properties(state: SupportsControllerState): + """ + Examples: + Even with an empty data object, we can initialize the dictionary, + >>> from autora.state.snapshot import Snapshot + >>> state_dependent_properties = _get_state_dependent_properties(Snapshot()) + + ... but it will raise an exception if a value isn't yet available when we try to use it + >>> state_dependent_properties["%models[-1]%"] # doctest: +ELLIPSIS + Traceback (most recent call last): + ... + IndexError: list index out of range + + Nevertheless, we can iterate through its keys no problem: + >>> [key for key in state_dependent_properties.keys()] # doctest: +NORMALIZE_WHITESPACE + ['%observations.ivs[-1]%', '%observations.dvs[-1]%', '%observations.ivs%', + '%observations.dvs%', '%experiment_data.conditions[-1]%', + '%experiment_data.observations[-1]%', '%experiment_data.conditions%', + '%experiment_data.observations%', '%models[-1]%', '%models%'] + + """ + + n_ivs = len(state.variables.independent_variables) + n_dvs = len(state.variables.dependent_variables) + state_dependent_property_dict = LazyDict( + { + "%observations.ivs[-1]%": deprecate( + lambda: np.array(state.observations[-1])[:, 0:n_ivs], + "%observations.ivs[-1]% is deprecated, " + "use %experiment_data.conditions[-1]% instead.", + ), + "%observations.dvs[-1]%": deprecate( + lambda: np.array(state.observations[-1])[:, n_ivs:], + "%observations.dvs[-1]% is deprecated, " + "use %experiment_data.observations[-1]% instead.", + ), + "%observations.ivs%": deprecate( + lambda: np.row_stack( + [np.empty([0, n_ivs + n_dvs])] + list(state.observations) + )[:, 0:n_ivs], + "%observations.ivs% is deprecated, use %experiment_data.conditions% instead.", + ), + "%observations.dvs%": deprecate( + lambda: np.row_stack(state.observations)[:, n_ivs:], + "%observations.dvs% is deprecated, " + "use %experiment_data.observations% instead", + ), + "%experiment_data.conditions[-1]%": lambda: np.array( + state.observations[-1] + )[:, 0:n_ivs], + "%experiment_data.observations[-1]%": lambda: np.array( + state.observations[-1] + )[:, n_ivs:], + "%experiment_data.conditions%": lambda: np.row_stack( + [np.empty([0, n_ivs + n_dvs])] + list(state.observations) + )[:, 0:n_ivs], + "%experiment_data.observations%": lambda: np.row_stack(state.observations)[ + :, n_ivs: + ], + "%models[-1]%": lambda: state.models[-1], + "%models%": lambda: state.models, + } + ) + return state_dependent_property_dict + + +def _resolve_properties(params: Dict, state_dependent_properties: Mapping): + """ + Resolve state-dependent properties inside a nested dictionary. + + In this context, a state-dependent-property is a string which is meant to be replaced by its + updated, current value before the dictionary is used. A state-dependent property might be + something like "the last theorist available" or "all the experimental results until now". + + Args: + params: a (nested) dictionary of keys and values, where some values might be + "cycle property names" + state_dependent_properties: a dictionary of "property names" and their "real values" + + Returns: a (nested) dictionary where "property names" are replaced by the "real values" + + Examples: + + >>> params_0 = {"key": "%foo%"} + >>> cycle_properties_0 = {"%foo%": 180} + >>> _resolve_properties(params_0,cycle_properties_0) + {'key': 180} + + >>> params_1 = {"key": "%bar%", "nested_dict": {"inner_key": "%foobar%"}} + >>> cycle_properties_1 = {"%bar%": 1, "%foobar%": 2} + >>> _resolve_properties(params_1,cycle_properties_1) + {'key': 1, 'nested_dict': {'inner_key': 2}} + + >>> params_2 = {"key": "baz"} + >>> _resolve_properties(params_2,cycle_properties_1) + {'key': 'baz'} + + """ + params_ = copy.copy(params) + for key, value in params_.items(): + if isinstance(value, dict): + params_[key] = _resolve_properties(value, state_dependent_properties) + elif isinstance(value, str) and ( + value in state_dependent_properties + ): # value is a key in the cycle_properties dictionary + params_[key] = state_dependent_properties[value] + else: + _logger.debug(f"leaving {params=} unchanged") + + return params_ + + +def resolve_state_params(params: Dict, state: SupportsControllerState) -> Dict: + """ + Returns the `params` attribute of the input, with `cycle properties` resolved. + + Examples: + >>> from autora.state.history import History + >>> params = {"experimentalist": {"source": "%models[-1]%"}} + >>> s = History(models=["the first model", "the second model"]) + >>> resolve_state_params(params, s) + {'experimentalist': {'source': 'the second model'}} + + """ + state_dependent_properties = _get_state_dependent_properties(state) + resolved_params = _resolve_properties(params, state_dependent_properties) + return resolved_params diff --git a/src/autora/state/protocol.py b/src/autora/state/protocol.py new file mode 100644 index 00000000..e1a16be7 --- /dev/null +++ b/src/autora/state/protocol.py @@ -0,0 +1,158 @@ +from enum import Enum +from typing import ( + Any, + Dict, + Generic, + Mapping, + Optional, + Protocol, + Sequence, + Set, + TypeVar, + Union, + runtime_checkable, +) + +from numpy.typing import ArrayLike +from sklearn.base import BaseEstimator + +from autora.variable import VariableCollection + +State = TypeVar("State") + + +class ResultKind(str, Enum): + """ + Kinds of results which can be held in the Result object. + + Examples: + >>> ResultKind.CONDITION is ResultKind.CONDITION + True + + >>> ResultKind.CONDITION is ResultKind.VARIABLES + False + + >>> ResultKind.CONDITION == "CONDITION" + True + + >>> ResultKind.CONDITION == "VARIABLES" + False + + >>> ResultKind.CONDITION in {ResultKind.CONDITION, ResultKind.PARAMS} + True + + >>> ResultKind.VARIABLES in {ResultKind.CONDITION, ResultKind.PARAMS} + False + """ + + CONDITION = "CONDITION" + OBSERVATION = "OBSERVATION" + MODEL = "MODEL" + PARAMS = "PARAMS" + VARIABLES = "VARIABLES" + + def __repr__(self): + cls_name = self.__class__.__name__ + return f"{cls_name}.{self.name}" + + +class SupportsDataKind(Protocol): + """Object with attributes for `data` and `kind`""" + + data: Optional[Any] + kind: Optional[ResultKind] + + +class SupportsStateParamsField(Protocol): + """Support a state with a params property.""" + + params: Dict + + +class SupportsStateParamsProperty(Protocol): + """Support a state with a params property.""" + + @property + def params(self) -> Dict: + ... + + +SupportsStateParams = Union[SupportsStateParamsField, SupportsStateParamsProperty] + + +class SupportsControllerStateFields(Protocol): + """Support representing snapshots of a controller state as mutable fields.""" + + variables: VariableCollection + params: Dict + conditions: Sequence[ArrayLike] + observations: Sequence[ArrayLike] + models: Sequence[BaseEstimator] + + def update(self: State, **kwargs) -> State: + ... + + +class SupportsControllerStateProperties(Protocol): + """Support representing snapshots of a controller state as immutable properties.""" + + def update(self: State, **kwargs) -> State: + ... + + @property + def variables(self) -> VariableCollection: + ... + + @property + def params(self) -> Dict: + ... + + @property + def conditions(self) -> Sequence[ArrayLike]: + ... + + @property + def observations(self) -> Sequence[ArrayLike]: + ... + + @property + def models(self) -> Sequence[BaseEstimator]: + ... + + +SupportsControllerState = Union[ + SupportsControllerStateFields, SupportsControllerStateProperties +] + + +class SupportsControllerStateHistory(SupportsControllerStateProperties, Protocol): + """Represents controller state as a linear sequence of entries.""" + + def __init__(self, history: Sequence[SupportsDataKind]): + ... + + def filter_by(self: State, kind: Optional[Set[Union[str, ResultKind]]]) -> State: + ... + + @property + def history(self) -> Sequence[SupportsDataKind]: + ... + + +class Executor(Protocol, Generic[State]): + """A Callable which, given some state, and some parameters, returns an updated state.""" + + def __call__(self, __state: State, params: Dict) -> State: + ... + + +ExecutorCollection = Mapping[str, Executor] + + +@runtime_checkable +class SupportsLoadDump(Protocol): + def dump(self, data, file) -> None: + ... + + def load(self, file) -> Any: + ... diff --git a/src/autora/state/snapshot.py b/src/autora/state/snapshot.py new file mode 100644 index 00000000..21be8171 --- /dev/null +++ b/src/autora/state/snapshot.py @@ -0,0 +1,201 @@ +""" Classes for storing and passing a cycle's state as an immutable snapshot. """ +from dataclasses import dataclass, field +from typing import Dict, List + +from numpy.typing import ArrayLike +from sklearn.base import BaseEstimator + +from autora.state.delta import Delta +from autora.state.protocol import SupportsControllerStateFields +from autora.variable import VariableCollection + + +@dataclass(frozen=True) +class Snapshot(SupportsControllerStateFields): + """An object passed between and updated by processing steps in the Controller.""" + + # Single values + variables: VariableCollection = field(default_factory=VariableCollection) + params: Dict = field(default_factory=dict) + + # Sequences + conditions: List[ArrayLike] = field(default_factory=list) + observations: List[ArrayLike] = field(default_factory=list) + models: List[BaseEstimator] = field(default_factory=list) + + def update( + self, + variables=None, + params=None, + conditions=None, + observations=None, + models=None, + ): + """ + Create a new object with updated values. + + Examples: + The initial object is empty: + >>> s0 = Snapshot() + >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(variables=VariableCollection(...), params={}, conditions=[], + observations=[], models=[]) + + We can update the params using the `.update` method: + >>> s0.update(params={'first': 'params'}) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(..., params={'first': 'params'}, ...) + + ... but the original object is unchanged: + >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(..., params={}, ...) + + For params, only one object is returned from the respective property: + >>> s0.update(params={'first': 'params'}).update(params={'second': 'params'}).params + {'second': 'params'} + + ... and the same applies to variables: + >>> from autora.variable import VariableCollection, IV + >>> (s0.update(variables=VariableCollection([IV("1st IV")])) + ... .update(variables=VariableCollection([IV("2nd IV")]))).variables + VariableCollection(independent_variables=[IV(name='2nd IV',...)], ...) + + When we update the conditions, observations or models, the respective list is extended: + >>> s3 = s0.update(models=["1st model"]) + >>> s3 + Snapshot(..., models=['1st model']) + + ... so we can see the history of all the models, for instance. + >>> s3.update(models=["2nd model"]) + Snapshot(..., models=['1st model', '2nd model']) + + The same applies to observations: + >>> s4 = s0.update(observations=["1st observation"]) + >>> s4 + Snapshot(..., observations=['1st observation'], ...) + + >>> s4.update(observations=["2nd observation"]) # doctest: +ELLIPSIS + Snapshot(..., observations=['1st observation', '2nd observation'], ...) + + + The same applies to conditions: + >>> s5 = s0.update(conditions=["1st condition"]) + >>> s5 + Snapshot(..., conditions=['1st condition'], ...) + + >>> s5.update(conditions=["2nd condition"]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(..., conditions=['1st condition', '2nd condition'], ...) + + You can also update with multiple conditions, observations and models: + >>> s0.update(conditions=['c1', 'c2']) + Snapshot(..., conditions=['c1', 'c2'], ...) + + >>> s0.update(models=['m1', 'm2'], variables={'m': 1}) + Snapshot(variables={'m': 1}, ..., models=['m1', 'm2']) + + >>> s0.update(models=['m1'], observations=['o1'], variables={'m': 1}) + Snapshot(variables={'m': 1}, ..., observations=['o1'], models=['m1']) + + + Inputs to models, observations and conditions must be Lists + which can be cast to lists: + >>> s0.update(models='m1') # doctest: +ELLIPSIS + Traceback (most recent call last): + ... + AssertionError: 'm1' must be a list, e.g. `['m1']`?) + + """ + + def _coalesce_lists(old, new): + assert isinstance( + old, List + ), f"{repr(old)} must be a list, e.g. `[{repr(old)}]`?)" + if new is not None: + assert isinstance( + new, List + ), f"{repr(new)} must be a list, e.g. `[{repr(new)}]`?)" + return old + list(new) + else: + return old + + variables_ = variables or self.variables + params_ = params or self.params + conditions_ = _coalesce_lists(self.conditions, conditions) + observations_ = _coalesce_lists(self.observations, observations) + models_ = _coalesce_lists(self.models, models) + return Snapshot(variables_, params_, conditions_, observations_, models_) + + def __add__(self, other: Delta): + """ + Add a delta to the object. + + Examples: + The initial object is empty: + >>> s0 = Snapshot() + >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(variables=VariableCollection(...), params={}, conditions=[], + observations=[], models=[]) + + We can update the params using the `+` operator: + >>> from autora.state.delta import Delta + >>> s0 + Delta(params={'first': 'params'}) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(..., params={'first': 'params'}, ...) + + ... but the original object is unchanged: + >>> s0 # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(..., params={}, ...) + + For params, only one object is returned from the respective property: + >>> (s0 + Delta(params={'first': 'params'}) + Delta(params={'second':'params'})).params + {'second': 'params'} + + ... and the same applies to variables: + >>> from autora.variable import VariableCollection, IV + >>> (s0 + Delta(variables=VariableCollection([IV("1st IV")])) + + ... Delta(variables=VariableCollection([IV("2nd IV")]))).variables + VariableCollection(independent_variables=[IV(name='2nd IV',...)], ...) + + When we update the conditions, observations or models, the respective list is extended: + >>> s3 = s0 + Delta(models=["1st model"]) + >>> s3 + Snapshot(..., models=['1st model']) + + ... so we can see the history of all the models, for instance. + >>> s3 + Delta(models=["2nd model"]) + Snapshot(..., models=['1st model', '2nd model']) + + The same applies to observations: + >>> s4 = s0 + Delta(observations=["1st observation"]) + >>> s4 + Snapshot(..., observations=['1st observation'], ...) + + >>> s4 + Delta(observations=["2nd observation"]) # doctest: +ELLIPSIS + Snapshot(..., observations=['1st observation', '2nd observation'], ...) + + + The same applies to conditions: + >>> s5 = s0 + Delta(conditions=["1st condition"]) + >>> s5 + Snapshot(..., conditions=['1st condition'], ...) + + >>> s5 + Delta(conditions=["2nd condition"]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE + Snapshot(..., conditions=['1st condition', '2nd condition'], ...) + + You can also update with multiple conditions, observations and models: + >>> s0 + Delta(conditions=['c1', 'c2']) + Snapshot(..., conditions=['c1', 'c2'], ...) + + >>> s0 + Delta(models=['m1', 'm2'], variables={'m': 1}) + Snapshot(variables={'m': 1}, ..., models=['m1', 'm2']) + + >>> s0 + Delta(models=['m1'], observations=['o1'], variables={'m': 1}) + Snapshot(variables={'m': 1}, ..., observations=['o1'], models=['m1']) + + + Inputs to models, observations and conditions must be Lists + which can be cast to lists: + >>> s0 + Delta(models='m1') # doctest: +ELLIPSIS + Traceback (most recent call last): + ... + AssertionError: 'm1' must be a list, e.g. `['m1']`?) + """ + return self.update(**other) diff --git a/src/autora/state/wrapper.py b/src/autora/state/wrapper.py new file mode 100644 index 00000000..10986b5f --- /dev/null +++ b/src/autora/state/wrapper.py @@ -0,0 +1,87 @@ +"""Utilities to wrap common theorist, experimentalist and experiment runners as `f(State)`. +so that $n$ processes $f_i$ on states $S$ can be represented as +$$f_n(...(f_1(f_0(S))))$$ +""" +from __future__ import annotations + +from typing import Callable, Iterable, TypeVar + +import numpy as np +import pandas as pd +from sklearn.base import BaseEstimator + +from autora.experimentalist.pipeline import Pipeline +from autora.state.delta import Delta, State, wrap_to_use_state +from autora.variable import VariableCollection + +S = TypeVar("S") +X = TypeVar("X") +Y = TypeVar("Y") +XY = TypeVar("XY") +Executor = Callable[[State], State] + + +def theorist_from_estimator(estimator: BaseEstimator) -> Executor: + """ + Convert a scikit-learn compatible estimator into a function on a `State` object. + + Supports passing additional `**kwargs` which are used to update the estimator's params + before fitting. + """ + + @wrap_to_use_state + def theorist( + experimental_data: pd.DataFrame, variables: VariableCollection, **kwargs + ): + ivs = [v.name for v in variables.independent_variables] + dvs = [v.name for v in variables.dependent_variables] + X, y = experimental_data[ivs], experimental_data[dvs] + new_model = estimator.set_params(**kwargs).fit(X, y) + return Delta(model=new_model) + + return theorist + + +def experiment_runner_from_x_to_y_function(f: Callable[[X], Y]) -> Executor: + """Wrapper for experiment_runner of the form $f(x) \rarrow y$, where `f` returns just the $y$ + values""" + + @wrap_to_use_state + def experiment_runner(conditions: pd.DataFrame, **kwargs): + x = conditions + y = f(x, **kwargs) + experimental_data = pd.DataFrame.merge(x, y, left_index=True, right_index=True) + return Delta(experimental_data=experimental_data) + + return experiment_runner + + +def experiment_runner_from_x_to_xy_function(f: Callable[[X], XY]) -> Executor: + """Wrapper for experiment_runner of the form $f(x) \rarrow (x,y)$, where `f` + returns both $x$ and $y$ values in a complete dataframe.""" + + @wrap_to_use_state + def experiment_runner(conditions: pd.DataFrame, **kwargs): + x = conditions + experimental_data = f(x, **kwargs) + return Delta(experimental_data=experimental_data) + + return experiment_runner + + +def experimentalist_from_pipeline(pipeline: Pipeline) -> Executor: + """Wrapper for experimentalists of the form $f() \rarrow x$, where `f` + returns both $x$ and $y$ values in a complete dataframe.""" + + @wrap_to_use_state + def experimentalist(params): + conditions = pipeline(**params) + if isinstance(conditions, (pd.DataFrame, np.ndarray, np.recarray)): + conditions_ = conditions + elif isinstance(conditions, Iterable): + conditions_ = np.array(list(conditions)) + else: + raise NotImplementedError("type `%s` is not supported" % (type(conditions))) + return Delta(conditions=conditions_) + + return experimentalist From 5b93e74c1eee30f55f6f9a6c362125763d188c30 Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 14:55:09 -0400 Subject: [PATCH 02/10] docs: add functional notebook --- ...Workflows using Functions and States.ipynb | 1033 +++++++++++++++++ mkdocs.yml | 3 +- 2 files changed, 1035 insertions(+), 1 deletion(-) create mode 100644 docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb new file mode 100644 index 00000000..07889298 --- /dev/null +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -0,0 +1,1033 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear And Cyclical Workflows Using Functions And States" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the functions in `autora.workflow`, we can build flexible pipelines and cycles which operate on state objects.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Optional\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import pandas as pd\n", + "from sklearn.base import BaseEstimator\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "from dataclasses import field, dataclass\n", + "\n", + "from autora.state.delta import State, Delta, wrap_to_use_state\n", + "from autora.state.wrapper import theorist_from_estimator, experiment_runner_from_x_to_y_function\n", + "from autora.variable import VariableCollection, Variable\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experiment Runner And Theorist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define a two part AER pipeline consisting of an experiment runner and a theorist (we use the seed conditions\n", + "always).\n", + "\n", + "The key part here is that both experiment runner and theorist are functions which:\n", + "- operate on the `State`, and\n", + "- return a modified object of the **same type** `State`.\n", + "\n", + "### Defining The State\n", + "\n", + "We define the state as a dataclass, subclassed from `autora.workflow.State` with fields representing the variables,\n", + "parameters, experimental data, (possibly) conditions, and (possibly) a model.\n", + "\n", + "This state has no \"history\"; it represents a snapshot of the data at one time. Other exemplar state objects are\n", + "available in the subpackage `autora.workflow.state` and include some with in-built histories." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@dataclass(frozen=True)\n", + "class Snapshot(State):\n", + " variables: VariableCollection = field(metadata={\"delta\": \"replace\"})\n", + " params: dict = field(metadata={\"delta\": \"replace\"})\n", + " experimental_data: pd.DataFrame = field(metadata={\"delta\": \"extend\"})\n", + " conditions: pd.Series = field(default=None, metadata={\"delta\": \"replace\"})\n", + " model: Optional[BaseEstimator] = field(default=None, metadata={\"delta\": \"replace\"})\n", + "\n", + "s = Snapshot(\n", + " variables=VariableCollection(independent_variables=[Variable(\"x\", value_range=(-15,15))],\n", + " dependent_variables=[Variable(\"y\")]),\n", + " params={},\n", + " conditions=pd.DataFrame({\"x\": np.linspace(-15,15,101)}),\n", + " experimental_data = pd.DataFrame(columns=[\"x\",\"y\"]),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), params={}, experimental_data=Empty DataFrame\n", + "Columns: [x, y]\n", + "Index: [], conditions= x\n", + "0 -15.0\n", + "1 -14.7\n", + "2 -14.4\n", + "3 -14.1\n", + "4 -13.8\n", + ".. ...\n", + "96 13.8\n", + "97 14.1\n", + "98 14.4\n", + "99 14.7\n", + "100 15.0\n", + "\n", + "[101 rows x 1 columns], model=None)" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining The Experiment Runner\n", + "\n", + "For this example, we'll use a polynomial of degree 3 as our \"ground truth\" function. We're also using pandas\n", + "DataFrames and Series as our data interchange format." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "coefs = [432, -144, -3, 1] # from https://www.maa.org/sites/default/files/0025570x28304.di021116.02p0130a.pdf\n", + "\n", + "def ground_truth(x: pd.Series) -> pd.Series:\n", + " y = pd.Series(coefs[0] + coefs[1] * x + coefs[2] * x**2 + coefs[3] * x**3, name=\"y\")\n", + " return y\n", + "\n", + "def noisy_observation(x: pd.Series, std=1000, rng=None) -> pd.Series:\n", + " if rng is None:\n", + " rng = np.random.default_rng()\n", + " y = ground_truth(x) + rng.normal(0, std, len(x))\n", + " return y\n", + "\n", + "def noisy_observation_df(df: pd.DataFrame, std=1000, rng=None) -> pd.DataFrame:\n", + " y = pd.DataFrame({\"y\": noisy_observation(df[\"x\"], std=std, rng=rng)}) \n", + " return y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given this state, we define a two part AER pipeline consisting of an experiment runner and a theorist. We'll just\n", + "reuse the initial seed `conditions` in this example.\n", + "\n", + "First we define and test the experiment runner.\n", + "\n", + "The key part here is that both the experiment runner and the theorist are functions which operate on the `State`. Therefore, we use a wrapper function `experiment_runner_from_x_to_y_function` that wraps the previously defined `noisy_observation_df` function and returns a function with the same functionality, but operating on the `State`. In this case, we want to use the `State` field `conditions` as input and extend the `State` field `experiment_data`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_runner = experiment_runner_from_x_to_y_function(noisy_observation_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we run the experiment runner, we can see the updated state object which is returned – it has new experimental data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xy
0-15.0-1458.700731
1-14.7-1276.478978
2-14.4-1103.370488
3-14.1-936.664807
4-13.8-782.287323
.........
9613.8501.465073
9714.1609.144953
9814.4720.532236
9914.7844.232073
10015.0971.582533
\n", + "

101 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " x y\n", + "0 -15.0 -1458.700731\n", + "1 -14.7 -1276.478978\n", + "2 -14.4 -1103.370488\n", + "3 -14.1 -936.664807\n", + "4 -13.8 -782.287323\n", + ".. ... ...\n", + "96 13.8 501.465073\n", + "97 14.1 609.144953\n", + "98 14.4 720.532236\n", + "99 14.7 844.232073\n", + "100 15.0 971.582533\n", + "\n", + "[101 rows x 2 columns]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "experiment_runner(s, std=1).experimental_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining The Theorist\n", + "\n", + "Now we define a theorist, which does a linear regression on the polynomial of degree 5. We define a regressor and a\n", + "method to return its feature names and coefficients, and then the theorist to handle it. Here, we use a different wrapper `theorist_from_estimator` that wraps the regressor and returns a function with the same functionality, but operating on `State` fields. In this case, we want to use the `State` field `experiment_data` and extend the `State` field `models`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Completely standard scikit-learn pipeline regressor\n", + "regressor = make_pipeline(PolynomialFeatures(degree=5), LinearRegression())\n", + "theorist = theorist_from_estimator(regressor)\n", + "\n", + "def get_equation(r):\n", + " t = r.named_steps['polynomialfeatures'].get_feature_names_out()\n", + " c = r.named_steps['linearregression'].coef_\n", + " return pd.DataFrame({\"t\": t, \"coefficient\": c.reshape(t.shape)})\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Directly Chaining State Based Functions\n", + "\n", + "Now we run the theorist on the result of the experiment_runner (by chaining the two functions)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t = theorist(experiment_runner(s, rng=np.random.default_rng(1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fitted coefficients are:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "get_equation(t.model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating A Pipeline With State Based Functions\n", + "\n", + "Now we can define the simplest pipeline which runs the experiment runner and theorist in sequence and returns the\n", + "updated state:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def pipeline(state: State, rng=None) -> State:\n", + " s_ = state\n", + " t_ = experiment_runner(s_, rng=rng)\n", + " u_ = theorist(t_)\n", + " return u_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Running this pipeline is the same as running the individual steps – just pass the state object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-161.235264
2x^2-2.092934
3x^31.487881
4x^4-0.002423
5x^5-0.002523
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -161.235264\n", + "2 x^2 -2.092934\n", + "3 x^3 1.487881\n", + "4 x^4 -0.002423\n", + "5 x^5 -0.002523" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u = pipeline(s, rng=np.random.default_rng(1))\n", + "get_equation(u.model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the pipeline function operates on the `State` itself and returns a `State`, we can chain these pipelines in the same fashion as we chain the theorist and experiment_runner:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-138.656740
2x^2-2.719829
3x^30.810569
4x^4-0.001475
5x^50.000620
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -138.656740\n", + "2 x^2 -2.719829\n", + "3 x^3 0.810569\n", + "4 x^4 -0.001475\n", + "5 x^5 0.000620" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u_ = pipeline(pipeline(s, rng=np.random.default_rng(1)))\n", + "get_equation(u_.model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show what's happening, we'll show the data, best fit model and ground truth:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-138.656740
2x^2-2.719829
3x^30.810569
4x^4-0.001475
5x^50.000620
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -138.656740\n", + "2 x^2 -2.719829\n", + "3 x^3 0.810569\n", + "4 x^4 -0.001475\n", + "5 x^5 0.000620" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def show_best_fit(state):\n", + " state.experimental_data.plot.scatter(\"x\", \"y\", s=1, alpha=0.5, c=\"gray\")\n", + "\n", + " observed_x = state.experimental_data[[\"x\"]].sort_values(by=\"x\")\n", + " observed_x = pd.DataFrame({\"x\": np.linspace(observed_x[\"x\"].min(), observed_x[\"x\"].max(), 101)})\n", + "\n", + " plt.plot(observed_x, state.model.predict(observed_x), label=\"best fit\")\n", + " \n", + " allowed_x = pd.Series(np.linspace(*state.variables.independent_variables[0].value_range, 101), name=\"x\")\n", + " plt.plot(allowed_x, ground_truth(allowed_x), label=\"ground truth\")\n", + " \n", + " plt.legend()\n", + "\n", + "def show_coefficients(state):\n", + " return get_equation(state.model)\n", + "\n", + "show_best_fit(u)\n", + "show_coefficients(u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use this pipeline to make a trivial cycle, where we keep on gathering data until we reach 1000 datapoints. Any\n", + " condition defined on the state object could be used here, though." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v = s\n", + "while len(v.experimental_data) < 1_000: # any condition on the state can be used here.\n", + " v = pipeline(v)\n", + "show_best_fit(v)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating Generators With State Based Functions\n", + "\n", + "We can redefine the pipeline as a generator, which can be operated on using iteration tools:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def cycle(state: State) -> State:\n", + " s_ = state\n", + " while True:\n", + " s_ = experiment_runner(s_)\n", + " s_ = theorist(s_)\n", + " yield s_\n", + "\n", + "cycle_generator = cycle(s)\n", + "\n", + "for i in range(1000):\n", + " t = next(cycle_generator)\n", + "show_best_fit(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also define a cycle (or a sequence of steps) which yield the intermediate results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "v0 = s\n", + "def cycle(state: State) -> State:\n", + " s_ = state\n", + " while True:\n", + " print(\"#-- running experiment_runner --#\\n\")\n", + " s_ = experiment_runner(s_)\n", + " yield s_\n", + " print(\"#-- running theorist --#\\n\")\n", + " s_ = theorist(s_)\n", + " yield s_\n", + "\n", + "cycle_generator = cycle(v0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At the outset, we have no model and an emtpy experimental_data dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v0.model=None, \n", + "v0.experimental_data.shape=(0, 2)\n" + ] + } + ], + "source": [ + "print(f\"{v0.model=}, \\n{v0.experimental_data.shape=}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the first `next`, we only run the \"experiment_runner\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#-- running experiment_runner --#\n", + "\n", + "v1.model=None, \n", + "v1.experimental_data.shape=(101, 2)\n" + ] + } + ], + "source": [ + "v1 = next(cycle_generator)\n", + "print(f\"{v1.model=}, \\n{v1.experimental_data.shape=}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next step, we run the theorist on that data, but we don't add any new data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#-- running theorist --#\n", + "\n", + "v2.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n", + " ('linearregression', LinearRegression())]), \n", + "v2.experimental_data.shape=(101, 2)\n" + ] + } + ], + "source": [ + "v2 = next(cycle_generator)\n", + "print(f\"{v2.model=}, \\n{v2.experimental_data.shape=}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next step, we run the experiment runner again and gather more observations:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#-- running experiment_runner --#\n", + "\n", + "v3.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n", + " ('linearregression', LinearRegression())]), \n", + "v3.experimental_data.shape=(202, 2)\n" + ] + } + ], + "source": [ + "v3 = next(cycle_generator)\n", + "print(f\"{v3.model=}, \\n{v3.experimental_data.shape=}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding The Experimentalist\n", + "Modifying the code to use a custom experimentalist is simple.\n", + "We define an experimentalist which adds four observations each cycle:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), params={}, experimental_data=Empty DataFrame\n", + "Columns: [x, y]\n", + "Index: [], conditions= x\n", + "0 2.281691, model=None)" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "experimentalist_rng = np.random.default_rng(180)\n", + "@wrap_to_use_state\n", + "\n", + "def experimentalist(variables: VariableCollection, n_samples=1):\n", + " names = [v.name for v in variables.independent_variables]\n", + " low = [v.value_range[0] for v in variables.independent_variables]\n", + " high = [v.value_range[1] for v in variables.independent_variables]\n", + " x_range = experimentalist_rng.uniform(low, high, size=n_samples)\n", + " conditions = pd.DataFrame({\"x\": x_range})\n", + " return Delta(conditions=conditions)\n", + "\n", + "experimentalist(s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "u0 = s\n", + "for i in range(5):\n", + " u0 = experimentalist(u0, n_samples=10)\n", + " u0 = experiment_runner(u0)\n", + " u0 = theorist(u0)\n", + " show_best_fit(u0)\n", + " plt.title(f\"{i=}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mkdocs.yml b/mkdocs.yml index b9a35944..dd9f7238 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -20,4 +20,5 @@ nav: - Random: - Home: 'experimentalists/sampler/random/index.md' - Quickstart: 'experimentalists/sampler/random/quickstart.md' - +- Cycle: + - Functional: 'cycle/Linear and Cyclical Workflows using Functions and States.ipynb' From 0f0b645512a29334ca26445a4a7f8c2bd289102b Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 14:58:45 -0400 Subject: [PATCH 03/10] test: update variable names in tests to conform to standard --- src/autora/state/delta.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/autora/state/delta.py b/src/autora/state/delta.py index 9b8221a1..1a6fefaf 100644 --- a/src/autora/state/delta.py +++ b/src/autora/state/delta.py @@ -240,30 +240,30 @@ def wrap_to_use_state(f): >>> from sklearn.linear_model import LinearRegression >>> @wrap_to_use_state - ... def theorist(experimental_data: pd.DataFrame, variables: VariableCollection, **kwargs): + ... def theorist(experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs): ... ivs = [v.name for v in variables.independent_variables] ... dvs = [v.name for v in variables.dependent_variables] - ... X, y = experimental_data[ivs], experimental_data[dvs] + ... X, y = experiment_data[ivs], experiment_data[dvs] ... new_model = LinearRegression(fit_intercept=True).set_params(**kwargs).fit(X, y) ... return Delta(model=new_model) >>> @dataclass(frozen=True) ... class T(State): ... variables: VariableCollection # field(metadata={"delta":... }) omitted ∴ immutable - ... experimental_data: pd.DataFrame = field(metadata={"delta": "extend"}) + ... experiment_data: pd.DataFrame = field(metadata={"delta": "extend"}) ... model: Optional[BaseEstimator] = field(metadata={"delta": "replace"}, default=None) >>> t = T( ... variables=VariableCollection(independent_variables=[Variable("x")], ... dependent_variables=[Variable("y")]), - ... experimental_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]}) + ... experiment_data=pd.DataFrame({"x": [0,1,2,3,4], "y": [2,3,4,5,6]}) ... ) >>> t_prime = theorist(t) >>> t_prime.model.coef_, t_prime.model.intercept_ (array([[1.]]), array([2.])) Arguments from the state can be overridden by passing them in as keyword arguments (kwargs): - >>> theorist(t, experimental_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\ + >>> theorist(t, experiment_data=pd.DataFrame({"x": [0,1,2,3], "y": [12,13,14,15]}))\\ ... .model.intercept_ array([12.]) From 0e6b6ad01efec9f417a9c0930ef4c81b516a372a Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 15:06:38 -0400 Subject: [PATCH 04/10] test: update variable names in tests to conform to standard --- src/autora/state/wrapper.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/autora/state/wrapper.py b/src/autora/state/wrapper.py index 10986b5f..13bf5528 100644 --- a/src/autora/state/wrapper.py +++ b/src/autora/state/wrapper.py @@ -31,11 +31,11 @@ def theorist_from_estimator(estimator: BaseEstimator) -> Executor: @wrap_to_use_state def theorist( - experimental_data: pd.DataFrame, variables: VariableCollection, **kwargs + experiment_data: pd.DataFrame, variables: VariableCollection, **kwargs ): ivs = [v.name for v in variables.independent_variables] dvs = [v.name for v in variables.dependent_variables] - X, y = experimental_data[ivs], experimental_data[dvs] + X, y = experiment_data[ivs], experiment_data[dvs] new_model = estimator.set_params(**kwargs).fit(X, y) return Delta(model=new_model) @@ -50,8 +50,8 @@ def experiment_runner_from_x_to_y_function(f: Callable[[X], Y]) -> Executor: def experiment_runner(conditions: pd.DataFrame, **kwargs): x = conditions y = f(x, **kwargs) - experimental_data = pd.DataFrame.merge(x, y, left_index=True, right_index=True) - return Delta(experimental_data=experimental_data) + experiment_data = pd.DataFrame.merge(x, y, left_index=True, right_index=True) + return Delta(experiment_data=experiment_data) return experiment_runner @@ -63,8 +63,8 @@ def experiment_runner_from_x_to_xy_function(f: Callable[[X], XY]) -> Executor: @wrap_to_use_state def experiment_runner(conditions: pd.DataFrame, **kwargs): x = conditions - experimental_data = f(x, **kwargs) - return Delta(experimental_data=experimental_data) + experiment_data = f(x, **kwargs) + return Delta(experiment_data=experiment_data) return experiment_runner From 9044aeb459a1f9871f0a509d7a6f1a7021beb48f Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 15:08:37 -0400 Subject: [PATCH 05/10] docs: update variable names in docs to conform to standard --- ...Workflows using Functions and States.ipynb | 550 +----------------- 1 file changed, 25 insertions(+), 525 deletions(-) diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index 07889298..97cc8cf8 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -21,6 +21,7 @@ "outputs": [], "source": [ "from typing import Optional\n", + "from dataclasses import field, dataclass\n", "\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", @@ -29,7 +30,6 @@ "from sklearn.linear_model import LinearRegression\n", "from sklearn.pipeline import make_pipeline\n", "from sklearn.preprocessing import PolynomialFeatures\n", - "from dataclasses import field, dataclass\n", "\n", "from autora.state.delta import State, Delta, wrap_to_use_state\n", "from autora.state.wrapper import theorist_from_estimator, experiment_runner_from_x_to_y_function\n", @@ -73,7 +73,7 @@ "class Snapshot(State):\n", " variables: VariableCollection = field(metadata={\"delta\": \"replace\"})\n", " params: dict = field(metadata={\"delta\": \"replace\"})\n", - " experimental_data: pd.DataFrame = field(metadata={\"delta\": \"extend\"})\n", + " experiment_data: pd.DataFrame = field(metadata={\"delta\": \"extend\"})\n", " conditions: pd.Series = field(default=None, metadata={\"delta\": \"replace\"})\n", " model: Optional[BaseEstimator] = field(default=None, metadata={\"delta\": \"replace\"})\n", "\n", @@ -82,7 +82,7 @@ " dependent_variables=[Variable(\"y\")]),\n", " params={},\n", " conditions=pd.DataFrame({\"x\": np.linspace(-15,15,101)}),\n", - " experimental_data = pd.DataFrame(columns=[\"x\",\"y\"]),\n", + " experiment_data = pd.DataFrame(columns=[\"x\",\"y\"]),\n", ")" ] }, @@ -90,33 +90,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), params={}, experimental_data=Empty DataFrame\n", - "Columns: [x, y]\n", - "Index: [], conditions= x\n", - "0 -15.0\n", - "1 -14.7\n", - "2 -14.4\n", - "3 -14.1\n", - "4 -13.8\n", - ".. ...\n", - "96 13.8\n", - "97 14.1\n", - "98 14.4\n", - "99 14.7\n", - "100 15.0\n", - "\n", - "[101 rows x 1 columns], model=None)" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "s" ] @@ -186,117 +160,9 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
xy
0-15.0-1458.700731
1-14.7-1276.478978
2-14.4-1103.370488
3-14.1-936.664807
4-13.8-782.287323
.........
9613.8501.465073
9714.1609.144953
9814.4720.532236
9914.7844.232073
10015.0971.582533
\n", - "

101 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " x y\n", - "0 -15.0 -1458.700731\n", - "1 -14.7 -1276.478978\n", - "2 -14.4 -1103.370488\n", - "3 -14.1 -936.664807\n", - "4 -13.8 -782.287323\n", - ".. ... ...\n", - "96 13.8 501.465073\n", - "97 14.1 609.144953\n", - "98 14.4 720.532236\n", - "99 14.7 844.232073\n", - "100 15.0 971.582533\n", - "\n", - "[101 rows x 2 columns]" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "experiment_runner(s, std=1).experimental_data" + "experiment_runner(s, std=1).experiment_data" ] }, { @@ -393,82 +259,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tcoefficient
010.000000
1x-161.235264
2x^2-2.092934
3x^31.487881
4x^4-0.002423
5x^5-0.002523
\n", - "
" - ], - "text/plain": [ - " t coefficient\n", - "0 1 0.000000\n", - "1 x -161.235264\n", - "2 x^2 -2.092934\n", - "3 x^3 1.487881\n", - "4 x^4 -0.002423\n", - "5 x^5 -0.002523" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "u = pipeline(s, rng=np.random.default_rng(1))\n", "get_equation(u.model)" @@ -485,82 +276,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tcoefficient
010.000000
1x-138.656740
2x^2-2.719829
3x^30.810569
4x^4-0.001475
5x^50.000620
\n", - "
" - ], - "text/plain": [ - " t coefficient\n", - "0 1 0.000000\n", - "1 x -138.656740\n", - "2 x^2 -2.719829\n", - "3 x^3 0.810569\n", - "4 x^4 -0.001475\n", - "5 x^5 0.000620" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "u_ = pipeline(pipeline(s, rng=np.random.default_rng(1)))\n", "get_equation(u_.model)" @@ -577,97 +293,12 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tcoefficient
010.000000
1x-138.656740
2x^2-2.719829
3x^30.810569
4x^4-0.001475
5x^50.000620
\n", - "
" - ], - "text/plain": [ - " t coefficient\n", - "0 1 0.000000\n", - "1 x -138.656740\n", - "2 x^2 -2.719829\n", - "3 x^3 0.810569\n", - "4 x^4 -0.001475\n", - "5 x^5 0.000620" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAGwCAYAAABmTltaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABmuklEQVR4nO3deVxU9f7H8dcw7CAgKgKKCuK+r7inSaLZ4i8rLVMr20wrtxZbtN2uLVa3xbar3rqVLWal5pK5pOKSS7kn4oIi4AoIsg3n98fkFGnKKHAYeD8fj3kgc75z5jPjMPOe7/me79diGIaBiIiIiBSbm9kFiIiIiLgaBSgRERERJylAiYiIiDhJAUpERETESQpQIiIiIk5SgBIRERFxkgKUiIiIiJPczS6gIiosLCQ5OZkqVapgsVjMLkdERESKwTAMMjMzCQ8Px83twn1MClClIDk5mYiICLPLEBERkUuQlJRE7dq1L9hGAaoUVKlSBbD/BwQEBJhcjYiIiBRHRkYGERERjs/xC1GAKgVnD9sFBAQoQImIiLiY4gy/0SByEREREScpQImIiIg4SQFKRERExEkaAyUiIhWOzWYjPz/f7DKknPHw8MBqtZbIvhSgRESkwjAMg5SUFE6dOmV2KVJOBQUFERoaetnzNCpAiYhIhXE2PIWEhODr66vJjMXBMAyys7NJS0sDICws7LL2pwAlIiIVgs1mc4SnatWqmV2OlEM+Pj4ApKWlERISclmH8zSIXEREKoSzY558fX1NrkTKs7Ovj8sdI6cAJSIiFYoO28mFlNTrQwFKRERExEkKUCIiIiJOUoASERExWc+ePRkzZozZZQAwd+5coqOjsVqtjBkzhpkzZxIUFGR2WeWOApSIiEgFt3z5ciwWS7Hmx7r33nu58cYbSUpK4rnnnmPQoEH8/vvvju1PP/00rVu3Lr1iXYSmMRCpIJKTk0lMTCQqKorw8HCzyxERF3T69GnS0tKIi4sr8j5y9vR/+ZN6oEQqiMTERBISEkhMTDS7FJFywzAMsvMKTLkYhuFUrQUFBYwePZrAwECqV6/OU089VWQfubm5TJgwgVq1auHn50dMTAzLly93bD9w4ADXXnstVatWxc/Pj2bNmrFgwQL2799Pr169AKhatSoWi4Xbb7/9nPtfvnw5VapUAeDKK6/EYrGwfPnyIofwZs6cyTPPPMOvv/6KxWLBYrEwc+ZMpx5nRaEeKJEKIioqqshPEYEz+TaaTlpkyn3veDYOX8/if8zOmjWLESNGsH79en755Rfuuece6tSpw9133w3A6NGj2bFjB59//jnh4eF888039O3bl61bt9KgQQNGjRpFXl4eK1euxM/Pjx07duDv709ERARff/01AwcOZPfu3QQEBJy3R6lLly7s3r2bRo0a8fXXX9OlSxeCg4PZv3+/o82gQYPYtm0bCxcu5McffwQgMDDw8p4oF+UyPVDvvvsuLVu2JCAggICAADp37swPP/zg2J6Tk8OoUaOoVq0a/v7+DBw4kNTU1CL7OHjwIP3798fX15eQkBAefvhhCgoKirRZvnw5bdu2xcvLi+jo6EqbrMX1hIeH061bNx2+E3FRERERTJs2jUaNGjFkyBAeeOABpk2bBtg/v2bMmMGXX35J9+7dqV+/PhMmTKBbt27MmDHD0aZr1660aNGCqKgorrnmGnr06IHVaiU4OBiAkJAQQkNDzxt6PD09CQkJASA4OJjQ0FA8PT2LtPHx8cHf3x93d3dCQ0MJDQ2ttIf3XKYHqnbt2rz00ks0aNAAwzCYNWsW119/PZs3b6ZZs2aMHTuW+fPn8+WXXxIYGMjo0aO54YYbWL16NWCf4r9///6EhoayZs0ajhw5wrBhw/Dw8ODFF18EYN++ffTv35/77ruP//3vfyxdupS77rqLsLAw4uLizHz4IiJyCXw8rOx41pz3bx8P55YJ6dSpU5FJHjt37syrr76KzWZj69at2Gw2GjZsWOQ2ubm5jmVrHnzwQUaOHMnixYuJjY1l4MCBtGzZ8vIfiJyXywSoa6+9tsjvL7zwAu+++y5r166ldu3afPTRR3z66adceeWVAMyYMYMmTZqwdu1aOnXqxOLFi9mxYwc//vgjNWvWpHXr1jz33HM8+uijPP3003h6ejJ9+nQiIyN59dVXAWjSpAmrVq1i2rRpClAiIi7IYrE4dRitvDp9+jRWq5WNGzees36bv78/AHfddRdxcXHMnz+fxYsXM2XKFF599VUeeOABM0qu8FzmEN5f2Ww2Pv/8c7KysujcuTMbN24kPz+f2NhYR5vGjRtTp04d4uPjAYiPj6dFixbUrFnT0SYuLo6MjAy2b9/uaPPXfZxtc3Yf/yQ3N5eMjIwiFxFXkJyczKpVq0hOTja7FJFKb926dUV+X7t2LQ0aNMBqtdKmTRtsNhtpaWlER0cXuYSGhjpuExERwX333cecOXMYP348H3zwAYDjUJzNZrvsOj09PUtkP67OpQLU1q1b8ff3x8vLi/vuu49vvvmGpk2bkpKSgqen5zkTfdWsWZOUlBQAUlJSioSns9vPbrtQm4yMDM6cOfOPdU2ZMoXAwEDHJSIi4nIfqkiZ0Jl7IuXHwYMHGTduHLt37+azzz7j3//+Nw899BAADRs2ZMiQIQwbNow5c+awb98+1q9fz5QpU5g/fz4AY8aMYdGiRezbt49NmzaxbNkymjRpAkDdunWxWCzMmzePo0ePcvr06Uuus169euzbt48tW7Zw7NgxcnNzL//BuyCXClCNGjViy5YtrFu3jpEjRzJ8+HB27NhhdllMnDiR9PR0xyUpKcnskkSKJSoqiujoaJ25J1IODBs2jDNnztCxY0dGjRrFQw89xD333OPYPmPGDIYNG8b48eNp1KgRAwYMYMOGDdSpUwew9y6NGjWKJk2a0LdvXxo2bMg777wDQK1atXjmmWd47LHHqFmzJqNHj77kOgcOHEjfvn3p1asXNWrU4LPPPru8B+6iLIazE1WUI7GxsdSvX59BgwbRu3dvTp48WaQXqm7duowZM4axY8cyadIkvvvuO7Zs2eLYvm/fPqKioti0aRNt2rShR48etG3bltdff93RZsaMGYwZM4b09PRi15WRkUFgYCDp6ekEBASUwCMVEZGLycnJYd++fURGRuLt7W12OVJOXeh14sznt0v1QP1dYWEhubm5tGvXDg8PD5YuXerYtnv3bg4ePEjnzp0B+9kMW7duJS0tzdFmyZIlBAQE0LRpU0ebv+7jbJuz+xAREREBFzoLb+LEifTr1486deqQmZnJp59+yvLly1m0aBGBgYGMGDGCcePGERwcTEBAAA888ACdO3emU6dOAPTp04emTZsydOhQpk6dSkpKCk8++SSjRo3Cy8sLgPvuu4+33nqLRx55hDvvvJOffvqJL774wnF8WURERARcKEClpaUxbNgwjhw5QmBgIC1btmTRokVcddVVAEybNg03NzcGDhxIbm4ucXFxjmO/AFarlXnz5jFy5Eg6d+6Mn58fw4cP59lnn3W0iYyMZP78+YwdO5Y33niD2rVr8+GHH2oKAxERESnCpcdAlVcaAyUiUvY0BkqKQ2OgREREREyiACUiIiLiJAUoEREREScpQImIiIg4SQFKREREnDZz5sxzllAzw+23386AAQPK/H4VoERERKTE7d+/H4vFUmQFkPK0v8ulACUiIuKC8vLyzC6hRLjq41CAEhERMVlmZiZDhgzBz8+PsLAwpk2bRs+ePRkzZoyjTb169XjuuecYNmwYAQEBjoWGv/76a5o1a4aXlxf16tXj1VdfLbJvi8XC3Llzi1wXFBTEzJkzgT97dubMmUOvXr3w9fWlVatWxMfHF7nNzJkzqVOnDr6+vvzf//0fx48fv+BjioyMBKBNmzZYLBZ69uwJ/HnI7YUXXiA8PJxGjRoVq85/2t9Zr7zyCmFhYVSrVo1Ro0aRn59/wfoul8vMRC4iIuI0w4D8bHPu28MXLJZiNR03bhyrV6/mu+++o2bNmkyaNIlNmzbRunXrIu1eeeUVJk2axOTJkwHYuHEjN998M08//TSDBg1izZo13H///VSrVo3bb7/dqXKfeOIJXnnlFRo0aMATTzzBLbfcQkJCAu7u7qxbt44RI0YwZcoUBgwYwMKFCx01/JP169fTsWNHfvzxR5o1a4anp6dj29KlSwkICGDJkiXFru9C+1u2bBlhYWEsW7aMhIQEBg0aROvWrbn77rudeg6coQAlIiIVV342vBhuzn0/ngyefhdtlpmZyaxZs/j000/p3bs3ADNmzCA8/Ny6r7zySsaPH+/4fciQIfTu3ZunnnoKgIYNG7Jjxw5efvllpwPUhAkT6N+/PwDPPPMMzZo1IyEhgcaNG/PGG2/Qt29fHnnkEcf9rFmzhoULF/7j/mrUqAFAtWrVCA0NLbLNz8+PDz/8sEgIupgL7a9q1aq89dZbWK1WGjduTP/+/Vm6dGmpBigdwhMRETFRYmIi+fn5dOzY0XFdYGCg49DWX7Vv377I7zt37qRr165FruvatSt79uzBZrM5VUfLli0d/w4LCwPs69CevZ+YmJgi7Tt37uzU/v+qRYsWToWni2nWrBlWq9Xxe1hYmKP20qIeKBERqbg8fO09QWbddwnz87t4j9bfWSwW/r7s7fnGB3l4eBS5DUBhYaHT91cc53scxa3zfP5a+9l9lVbtZylAiYhIxWWxFOswmpmioqLw8PBgw4YN1KlTB4D09HR+//13evToccHbNmnShNWrVxe5bvXq1TRs2NDRI1OjRg2OHDni2L5nzx6ys50bF9akSRPWrVtX5Lq1a9de8DZne5iK2xN2sTqd3V9pU4ASERExUZUqVRg+fDgPP/wwwcHBhISEMHnyZNzc3Bw9Qf9k/PjxdOjQgeeee45BgwYRHx/PW2+9xTvvvONoc+WVV/LWW2/RuXNnbDYbjz766Dk9Nhfz4IMP0rVrV1555RWuv/56Fi1adMHxTwAhISH4+PiwcOFCateujbe3N4GBgf/Y/mJ1Oru/0qYxUCIiIiZ77bXX6Ny5M9dccw2xsbF07dqVJk2a4O3tfcHbtW3bli+++ILPP/+c5s2bM2nSJJ599tkiA8hfffVVIiIi6N69O7feeisTJkzA19e5w4udOnXigw8+4I033qBVq1YsXryYJ5988oK3cXd358033+S9994jPDyc66+//oLtL1ans/srbRbj7wcc5bJlZGQQGBhIeno6AQEBZpcjIlIp5OTksG/fPiIjIy8aPMq7rKwsatWqxauvvsqIESPMLqdCudDrxJnPbx3CExERMdnmzZvZtWsXHTt2JD09nWeffRbA9F4W+WcKUCIiIuXAK6+8wu7du/H09KRdu3b8/PPPVK9e3eyy5B8oQImIiJisTZs2bNy40ewyxAkaRC4iIiLiJAUoERGpUHRulFxISb0+FKBERKRCODtnkLOTRErlcvb14excWH+nMVAiIlIhWK1WgoKCHGug+fr6XnQiSqk8DMMgOzubtLQ0goKCiqyddykUoEREpMIIDQ0FKPWFZMV1BQUFOV4nl0MBSkREKgyLxUJYWBghISHFXohWKg8PD4/L7nk6SwFKREQqHKvVWmIflCLno0HkIiIiIk5SgBIRERFxkgKUiIiIiJMUoEREREScpAAlIiIi4iQFKBEREREnKUCJiIiIOEkBSkRERMRJClAiIiIiTlKAEhEREXGSApSIiIiIkxSgRERERJykACUiIiLiJAUoEREREScpQImIiIg4SQFKRERExEkKUCIiIiJOUoASERERcZIClIiIiIiTFKBEREREnKQAJXKJkpOTWbVqFcnJyWaXIiIiZczd7AJEXFViYiIJCQkAhIeHm1yNiIiUJQUokUsUFRVV5KeIiFQeClAilyg8PFw9TyIilZTGQImIiIg4SQFKRERExEkuE6CmTJlChw4dqFKlCiEhIQwYMIDdu3cXaZOTk8OoUaOoVq0a/v7+DBw4kNTU1CJtDh48SP/+/fH19SUkJISHH36YgoKCIm2WL19O27Zt8fLyIjo6mpkzZ5b2wxMREREX4jIBasWKFYwaNYq1a9eyZMkS8vPz6dOnD1lZWY42Y8eO5fvvv+fLL79kxYoVJCcnc8MNNzi222w2+vfvT15eHmvWrGHWrFnMnDmTSZMmOdrs27eP/v3706tXL7Zs2cKYMWO46667WLRoUZk+XhERESm/LIZhGGYXcSmOHj1KSEgIK1asoEePHqSnp1OjRg0+/fRTbrzxRgB27dpFkyZNiI+Pp1OnTvzwww9cc801JCcnU7NmTQCmT5/Oo48+ytGjR/H09OTRRx9l/vz5bNu2zXFfgwcP5tSpUyxcuLBYtWVkZBAYGEh6ejoBAQEl/+BFRESkxDnz+e0yPVB/l56eDkBwcDAAGzduJD8/n9jYWEebxo0bU6dOHeLj4wGIj4+nRYsWjvAEEBcXR0ZGBtu3b3e0+es+zrY5u4/zyc3NJSMjo8hFREREKi6XDFCFhYWMGTOGrl270rx5cwBSUlLw9PQkKCioSNuaNWuSkpLiaPPX8HR2+9ltF2qTkZHBmTNnzlvPlClTCAwMdFwiIiIu+zGKiIhI+eWSAWrUqFFs27aNzz//3OxSAJg4cSLp6emOS1JSktkliYiISClyuYk0R48ezbx581i5ciW1a9d2XB8aGkpeXh6nTp0q0guVmppKaGioo8369euL7O/sWXp/bfP3M/dSU1MJCAjAx8fnvDV5eXnh5eV12Y9NREREXIPL9EAZhsHo0aP55ptv+Omnn4iMjCyyvV27dnh4eLB06VLHdbt37+bgwYN07twZgM6dO7N161bS0tIcbZYsWUJAQABNmzZ1tPnrPs62ObsPEREREZc5C+/+++/n008/5dtvv6VRo0aO6wMDAx09QyNHjmTBggXMnDmTgIAAHnjgAQDWrFkD2KcxaN26NeHh4UydOpWUlBSGDh3KXXfdxYsvvgjYpzFo3rw5o0aN4s477+Snn37iwQcfZP78+cTFxRWrVp2FJyIi4nqc+fx2mQBlsVjOe/2MGTO4/fbbAftEmuPHj+ezzz4jNzeXuLg43nnnHcfhOYADBw4wcuRIli9fjp+fH8OHD+ell17C3f3Po5nLly9n7Nix7Nixg9q1a/PUU0857qM4FKBERERcT4UMUK5EAapySk5OJjExkaioKC0yLCLigpz5/Ha5QeQi5VViYiIJCQkAClAiIhWcApRICYmKiiryU0REKi4FKJESEh4erp4nEZFKwmWmMRAREREpLxSgRERERJykACUiIiLiJAUoEREREScpQImIiIg4SQFKRERExEkKUCIiIiJOUoASERERcZIClIiIiIiTFKBEREREnKQAJSIiIuIkBSgRERERJylAiYiIiDhJAUpERETESQpQIlJEcnIyq1atIjk5+by/i4gIuJtdgIiUL4mJiSQkJAAQHh5+zu8iIqIAJSJ/ExUVdcGfIiKiACUifxMeHl6kp+nvv4uIiMZAiYiIiDhNAUpERETESQpQIiIiIk5SgBIRERFxkgKUiIiIiJMUoEREREScpAAlIiIi4iQFKBEREREnKUCJiIiIOEkBSkRERMRJClAiIiIiTlKAEhG5gOTkZFatWkVycrLZpYiUW5Xx70SLCYuIXEBiYiIJCQkAWlRZ5B9Uxr8TBSgRkQuIiooq8lNEzlUZ/04UoERELiA8PLzSfKMWuVSV8e9EY6BEREREnKQAJSIiIuIkBSgRERERJylAiYiIiDhJAUpERETESQpQIiIiIk5SgBIRERFxkgKUiAv4+zIJlXHZBBGR8kQTaYq4gL8vk1AZl00QkcopOTmZxMREoqKiytX7nQKUiAv4+zIJlXHZBBGpnMrrF0YFKBEX8PdlEirjsgkVTXn9Vi1S3pTXL4wKUCIiJiiv36pFypvy+oVRAUpE5A9l2StUXr9Vi0jxKECJiPyhLHuFivOtWof5RMovBSgRkT+UVK9QSQUfHeYTKb8UoMRl6du5lLSSGmtRUsFHh/lEyi+Xmkhz5cqVXHvttYSHh2OxWJg7d26R7YZhMGnSJMLCwvDx8SE2NpY9e/YUaXPixAmGDBlCQEAAQUFBjBgxgtOnTxdp89tvv9G9e3e8vb2JiIhg6tSppf3Q5BKc/ZBKTEw0uxSRIqKiooiOjr7s4BMeHk63bt30BUGkHHKpAJWVlUWrVq14++23z7t96tSpvPnmm0yfPp1169bh5+dHXFwcOTk5jjZDhgxh+/btLFmyhHnz5rFy5Uruuecex/aMjAz69OlD3bp12bhxIy+//DJPP/0077//fqk/PnFOSX1ISemozLOlK/iIVHwWwzAMs4u4FBaLhW+++YYBAwYA9t6n8PBwxo8fz4QJEwBIT0+nZs2azJw5k8GDB7Nz506aNm3Khg0baN++PQALFy7k6quv5tChQ4SHh/Puu+/yxBNPkJKSgqenJwCPPfYYc+fOZdeuXcWqLSMjg8DAQNLT0wkICCj5By/iAlatWkVCQgLR0dF069bN7HJERC7Kmc9vl+qBupB9+/aRkpJCbGys47rAwEBiYmKIj48HID4+nqCgIEd4AoiNjcXNzY1169Y52vTo0cMRngDi4uLYvXs3J0+ePO995+bmkpGRUeQiUtmph1BEKrIKM4g8JSUFgJo1axa5vmbNmo5tKSkphISEFNnu7u5OcHBwkTaRkZHn7OPstqpVq55z31OmTOGZZ54pmQci8neGAVlHITPF/jP7OGQdg5xTUJALtrw/f1rcwOoJ7l5g9QB3H/ANBp+q4FvN/u8q4eBXHSyWUi27vE5+JyIu7vBGWPwUXPUc1G5nWhkVJkCZaeLEiYwbN87xe0ZGBhERESZWJK4oOyeXtP3bydr3C6TtwDvzAP5ZBwnKPYxX4ZmSvTN3HwiqY79UrQs1GkNIEwhpag9ZIiLlkWHYw9OB1bD+faj9nmmlVJgAFRoaCkBqaiphYWGO61NTU2ndurWjTVpaWpHbFRQUcOLECcftQ0NDSU1NLdLm7O9n2/ydl5cXXl5eJfI4pOLLyi1gV0ome5KSyUtYSVDqWuqc2UUDYx/1LLnnvY3NsHCcQI4bVThpVOEEAZwy/MjBkzw8yMOdPMMdC+BpyceLAjwowIccgixZBFsyqeZ2muqWTAKNdNwKzsCx3fbL3/nXhNAWUKs91G4PtdqVSKjStBMictl2zbeHJ3dv6P2UqaVUmAAVGRlJaGgoS5cudQSmjIwM1q1bx8iRIwHo3Lkzp06dYuPGjbRrZ+/2++mnnygsLCQmJsbR5oknniA/Px8PDw8AlixZQqNGjc57+E7kYo6dzmX9vhOs33uU9IR4ok+tpovbdm60JOJuKfyzoQXO4EWitT6pvg3I9K9LbpV65AfVw1q1Hl7eXri7ueFhteDt5ka4G+QVFJJ79pJvIyOngBNZeZzMyuNEdh5HM3M5fOoMp7LzHXfjQQFhluPUthyltuUo0dZU2ninUJ9DBOclw+lUSEiFhB//rC24PtTrCpFXQL3uUKXoofLi0KSQInJZbPmwZJL9351HQ2BtU8txqQB1+vRpxxsw2AeOb9myheDgYOrUqcOYMWN4/vnnadCgAZGRkTz11FOEh4c7ztRr0qQJffv25e6772b69Onk5+czevRoBg8e7HhDv/XWW3nmmWcYMWIEjz76KNu2beONN95g2rRpZjxkcUGFhQZbDp1iyY5Ulu1IJujYRvq6rec+6wZCLSeL/NWd8K5NRmhX3Ot1IrB+R6rUakIzNyvNSrimzJx8Dp86Q9KJMyQePc3vqafZk5bJ96mnOZNngzx7O19yaGg5REevA/T0P0jTwt8Jyj4AJ/baL5v+a29YvRHU7wUN46BuV/uYq4vQpJAicll++Y/9fcivBnQbY3Y1rjWNwfLly+nVq9c51w8fPpyZM2diGAaTJ0/m/fff59SpU3Tr1o133nmHhg0bOtqeOHGC0aNH8/333+Pm5sbAgQN588038ff3d7T57bffGDVqFBs2bKB69eo88MADPProo8WuU9MYVD6FhQbxiceZ91syP+5Mw//0fgZZlzPQupIalnRHu3x3P2zRcXg3ioXIHhBk7li5wkKDgyey+fXQKX47lM6vSafYlpxOTv6fPWOBnKardyL/F7iXdsY2qmbswsJf3jY8/SGqJzTsC42uBr9qZf9ApMLRIV8p4swpeLMNnDkB/V+DDiNK5W6c+fx2qQDlKhSgKo8Dx7P4auMh5mw6zLFT6fRzW88t7j8R4/bnnGGF3kG4Nb4Gml5nDxrF6K0xU76tkO3JGaxNPM66xOP8sv8kmbkFju2BnGZg8D6u89tBs9PxeJz5y7hCi9UeDJsNgMbXKkzJJdM8YmXDZYLqkkmw+g177/fINWAtnQNoClAmU4Cq2GyFBou3pzBjzX7W7ztBIKcZal3CHR6LqIZ9DjDD4oYl+ipoO8x+mMvqYXLVl85WaPDboVOs/P0Yy39PY0vSKc6+a1gopId/MsOq7yYmNx7/kzv+vKHFag+MrW6Bxv3B09eU+sU1ucwHu4tziaB68gC81d4+VcutX9jfU0uJApTJFKAqpsycfL745RAz1+wj6cQZanGUu9x/4BaP5XgbfywXFFAb2g2H1kMgsJa5BZeSk1l5rNxzlCU7Ulm++yin/9I71drvOKNCttEldxV+J7b/eSNPf2h6PbQaDHW7gVuFmcNXxKW5RFD9agRs+8p+Esuwb/n1UDpTF+3ikbjGtIoIKtG7UoAymQJUxXIqO4/3VybycfwBMnMLqMFJHvb+loGWpVgNm71RaAvo8pD90JUL9zY5K7fAxpqE4yzansKi7Smc/MvZfh0DTvFQjU10zFyMR8bBP29UNfKPkHkb+NcwoWoRcRkH18J/4gAL3LsSwloy5MO1rE44zg1ta/Haza1L9O4UoEymAFUxZObk859V+/nw50QycwsI4DSPBSzi5oL5uBf+0eMUeYX9bJCoXqU+s3d5l28rZFXCMb7fksyi7Slk5f0RLjEYEpbMnf5riUpbjCU30361m4f90F77O+3jpir58ycif1Nog/evgJSt0GYoXP8Wq/Yc47aP1uFpdWPp+CuICC7ZoQEKUCZTgHJtOfk2Zq3Zz7sr9nIqOx93CngkaAV32L7EI/+PdQ5rd4TYyVCvnI4ZMFlOvo2lO9P4amMSK34/SuEf7zLBHvk8VmcH/fMW43d08583qNEEYu6FloM0VkpE7DZ8BPPHgVcgPLARw6861721mq2H07mjaz0mX1vSE74oQJlOAcp1Ld2ZyjPf7+DgiWwABlTdz7MeMwjI2GNvUKMJ9J4Ejfqpx6SY0jJymLP5MF/+ksTeo1mO66+teYwHA1cTfWQelvw/rvcOsg+8j7nX9EnyRMRE2Sfg323hzEno+y/odB8Lth7h/v9tws/TyopHelHdv+TPaFaAMpkClOvZdyyLZ7/fzrLdRwFoUiWb6SFzqXt4nr2BT7C9x6nNUHCzluh9u8QgzhJgGAa/HDjJp+sOMn/rEfIK7HNNhXvn8nTtzfTK+BaPjAP2xm7u0PxG6PIAhDY3sWoRMcW8cfDLR/b1Oe/9mQLc6DNtJYnHsniodwPGXtXw4vu4BM58frvUTOQiJS2voJC3liUwffle8myFeFhhWqMd9Et6A+vhTAwsWNoNh96TS22R3cqyxInFYqFDvWA61AvmqWua8vXGQ/xv3QH2H4d7EjphtXRkTJ19DGMeganr4LfP7Zf6vaHrQ+VmnFRlCbwipjnyG2ycYf93v6lgdeer9QdJPJZFsJ8nd3WPNLe+PyhASaW17XA6E778lV0p9kHN19a38pLHR/glLgbgmGdtDrUaR+v+pTPj7VmVcYmTYD9P7u4RxYhukaz4/Sj/Wb2Pn/cc49UD9XmVh7g+JJVHqiwiPHkxlr1LYe9S+7izHg9Dg6suGqRKM+RUlsArYgrDgAUPg1EIzW6AyO7k5Nt4/Uf7MIpRvaKp4l0+znRWgJJK52yv0zvLEigoNAj28+SDdkm03focljMnwM2DjPYPsMu/J1HRDUq9nvDw8Er7QezmZqFX4xB6NQ4hIS2TmWv28/XGw3ybVpNv04bRIeB6nglZRpMj32I5tB4+vQlCW9qDVONr/nE+qdIMOZUx8IqUmd++gKS14OELfZ4H4L/x+0nJyKFWkA9DYuqYXOCfNAaqFGgMVPmVkHaaBz/bzI4j9rPpBjQN5CXvGXjv+MreILQFDJiucTcmOpmVxydrDzArfj/HTttXOa7vfZp/ha+k3dE5WPLtA/wJaQa9JtqD1N96pHSYTcQFZZ+AtzpA9jG48inoMYH07HyueGUZp7LzefnGltzUvnTXD9UgcpMpQJVP32w+xBPfbCM7z0ZVXw9e6+VFz18nYDn2u33Zke7j7T0b7p5mlyrYp0L4ZvNhPliZSOIx+1l64Z5ZTK21mi7Hv8Yt74/5pEJbQM/HdWakiKv7djRs/hhqNIZ7fwZ3T579fgf/Wb2PRjWrsOCh7ljdSvdvXAHKZApQ5UtOvo2nv9vO5xuSAOhSvxrTW+wm4MdHoeAMVAmDG2dA3c4mVyrnk3ToMF+u+Z2FSQa/Hz0DQA1rNi/X/pkeJ77C7ewUCOFt7N9a61+pICXiavavhplX2/99x0Ko25m9R08TN20lBYUGH4/oSPcGpb9ygTOf31qQSiq0vUdPM+Dt1Xy+IQmLBcZfWYdPQj4hYOGD9vAU1cv+TUfhqdw6sH8fwdkHeKqjBzPu6ED7ulU5avPl9gNxdM6exoqQ2yj08IXkzfDJDTDrWkjaYHbZIlJcBbkwb4z9322HO96PX5i/k4JCg9gmIWUSnpylQeRS5spqfMqK348y+n+byMwtoLq/J+9cH0HHdaPh0AbAAr0etx+2K+F5naRk/XXQdnh4CL0ahRC/9zhvLP2dtYkw/ODV1LR2Y1rYUjqf/BbL/p/ho1ho1N8+6WlIY5MfgYj8k+TkZPJ/fJ66x34HvxC46hnA/v7906403N0sPH51E5OrPD8FKClzpX0auGEYzFqzn2fn7aDQgA71qjL9Ki+qfTsQMg6BdyDcNNN+qEfKvfOdpdi5fjU61+/M2sTjvPHjHuIT4dZD/0c99x68XnMhrU78gGX3fPj9B/vkp70eJzmzUAPLRcqZI1tX0jrxc/svfaeAT1UKbIU8P28HAMO71COqhr+JFf4zBSgpc6V5Gni+rZCnv9vO/9YdBODGdrWZ0iwJj8/vgfwsCK4Pt34B1aNL/L6l7HWKqkane6qxNvE4ry3+nfX7YcDhITT3vJLXqn1Hw5MrYNMs2PolBbWvY7+tDaD5m0TKBcOg+f6PsGIjJ6I73s0HAvDZ+oPsSTtNVV8PHryy9KeSuVQaRF4KNIjcHOln8rn/fxtZnXAciwUe69uYezx+wLL4ScCAyCvg5lngU9XsUqUUGIZhn4xz8W5+PZQOwBXeCfwr4EtCM7YCkOcZRHbMWIJ6PaBDt1JuVZppOM4uFuzuA6PWQtV6pGfn0/OVZZzMzue565sxtHO9Mi1Jg8il0knLzGHw+2tZnXAcP08rH9zWjnvzZmFZ/ARgQPs74bavK314Sk5OZtWqVSQnJ5tdSolKTk5m9erVRPvnM3dUVz4Y1p5GNauwIieaTmmP8ah1Ahm+dfDMO0XQz5NhenfYu8zsskXO6+wwh8TERLNLKT0n98Pip+z/jp0MVesBMO3H3zmZnU/Dmv7c0rH8TJp5PjqEJy4v6UQ2t320jgPHswn2dWdCWw86//Y47P7a3iD2Gftaajq1vcIuQ/L3x3VV05pc2TiEb7cc5rUlvzP7ZFvmZLXkoYCV3GN8iWfadvh4ADSIg7gXoHr5PUwglU+Fn+2+sNA+51N+FtTpAh3vBezLa/03fj8Ak65phru1fPfxKECJS9udksnQj9aRlplL7ao+jGtpo93Wyfhl/wYWN7j2DWg7zOwyy42K+sZ8vsdldbNwQ9va9G8ZxmfrDvLvnxJ4JeNKPqAjz1edT/+c+bjtWWRfZ6/jvXDFI+ATZNIjEPlThV/e6ZePYP/P9uVaBrwNbm7YCg2emLuNQgOubRVOtwbVza7yojQGqhRoDFTZ2HTwJHfM2ED6mXwa1azCx0ObEjjnVryS12FYPbHc+B9ocq3ZZTqt0ox/KGOncwt4f2UiH6xM5Ey+jUjLEaZV/YrW2fH2Br7V7BNxth2m8VEipeXEPni3C+RnQ7+XIeYeAD5Ze4An526jipc7S8dfQUiAtynlaQyUVHgbD5xk6IfrSD+TT9s6Qcy+vTkh392GV/I68KyC5bavSzQ8leXYoUox/sEE/l7ujLuqISse7sktHetwgDAGnHiA2/MfI827HmQft0/m994VcGCN2eVWKBV17J04yXHoLhvqdYcOdwFwNDOXqQt3ATC+T0PTwpOzFKDE5WxJOsXt/1lPVp6NzlHV+GRYM4K+uRUOxoNXIAz/FiJ7lOh9lmWoiYqKIjo6usIdZisvQgK8mXJDCxaP7UFskxCW21rS5dSzTDHuINe9CqRuhRn94Ou7IEMf+CWhvH0pUKAzyfr34cAq8PCD6/4NbvYIMmXBTjJyCmheK6DMz7q7HBoDJS5l66F0hn60jszcAmIig/no1sb4fnHLn+Fp2DdQq12J329Zjh2q8OMfyonokCp8OLwDaxKO8cKCnbyXfBVf5MbwtN8crrMtwbL1S9i1AK54GDqN0iLTl6G8jb2rqCdTlGup22HJJPu/r3oGgiMBiN97nDmbD2OxwAsDWpT6YsElSWOgSoHGQJWObYfTGfLHYbsO9aoyc0hT/L66FQ6sBq8AGDoXapd8eJKKr7DQYM7mw7yyaDcpGTk0tyTyqv//aJS/096gWjT0mwrRvc0tVEqExhmWsfwz8MGVkLbDfubrrbPBYiG3wEb/N1eRkHaa2zrV4fkBLcyu1KnPbwWoUqAAVfJ+T83k5vfiOZVtH/P03+Gt8P9ysP1MDq8AGPoN1G5/SfvWm6mclZ1nH2g+fcVecvMLuMG6isneXxBgO2Fv0OQ6iHsRgiLMLVTElSx4BNa/Z1/rbuQa8LcvDPzKot28tSyB6v5eLB1/BYE+HiYXWsqDyIcPH87KlSsvuTgRZyWfOsOwj9ZzKjufVhFBzLq9Hf7f32sPT57+cNucSw5PUP7GZ4h5fD3dGRPbkGUTevJ/bSL42taDrllT+a/Rj0LcYOd38HZH+PlVKMgzu1yR8u/3RfbwBDDgXUd42noonXdX7AXg+QHNykV4cpbTASo9PZ3Y2FgaNGjAiy++yOHDh0ujLhEATmXnMew/60nJyCE6xJ9Zt7enyo8Pw655YPWEWz6DiA6XdR8atC1/Fxbow2uDWjN3VFei64QzKXcoV+e+yK9uTexnEC19FqZ3hcQVZpcqlYRLDnzPTIW599v/HTMSGsQCkFdQyMNf/Yqt0OCalmH0bR5mYpGXzukANXfuXA4fPszIkSOZPXs29erVo1+/fnz11Vfk5+eXRo1SSZ3JszFi1i8kpJ0mNMCbWXd2JGjtv2DTf+2TZA78qETOtgsPD6dbt246fCfnaB0RxJyRXXh9UGtOVmnA9dlPMjZvJOluQXDsd/jvdfDVCMhMMbtUqeBKqqe8zIJYYSF8ez9kH4OazSH2acemt5YlsCslk2p+njxzXbPSraMUXdI0BjVq1GDcuHH8+uuvrFu3jujoaIYOHUp4eDhjx45lz549JV2nVDIFtkIe+GwzGw+cJMDbnVl3dqTWzhn2QycA10yDpteZW2Ql5pLfhi+RxWJhQJta/DS+Jw9c2YD5blfQPftl/mvrYz+st+0r+Hd7WPsu2ArMLldMVJp/FyXVU15mQxZWT4OEH8HdGwZ+CB72uZ22J6fzzjL7GZDPXt+cav5epVtHKbqseaCOHDnCkiVLWLJkCVarlauvvpqtW7fStGlTpk2bVlI1SiVjGAaTvtvOjztT8XR348PhHWh0bDEsmmhv0HsStLvd1Boru8o4bszPy53xfRqxdNwVdGlWn0n5t3Nt7nNsJRryMmHhY/BBLzj0i9mlVmpmhvvS/LsoqZ7yMhmysG8l/PS8/d/9pkJIEwDybYU8/OVvFBQa9GseSv+Wrnno7iyn54HKz8/nu+++Y8aMGSxevJiWLVsyZswYbr31VseI9W+++YY777yTsWPHlnjBUvHNXLOfT9cdxGKBNwe3oaP7XvhmpH1jzEjoNs7cAqXczetTliKCfZk+tB2r9hzjme/9uS7taQZbl/G452yqpPwGH8baA37sZPCpana5lY6Zczy5wt9Fqc8zl3EEvroTjEJoPaTIWqRTvt3MjiMZBHpbefb65qVXQxlxOkCFhYVRWFjILbfcwvr162nduvU5bXr16kVQUFAJlCeVzcrfj/LcvB0APN6vCX1r58EHt4AtFxpdDXEvgMV1JlqrqDTZJ3RrUJ0FD3Xnk7UHeG2JJ4vPtGeix2fcaF0JG2fAzu/tr9eWg/SaLUNmhphK/3dhy4ev7oCso/ZxT1e/4njt/7L/BDPW28cK3tbEkxpVXPfQ3VlOzwP18ccfc9NNN+Ht7Rpr1ZhB80Bdmr1HTzPg7dVk5hRwY7vavHxtPSz/6WuffK1mC7hzIXj5m12myDmOnc7llUW7mf1LEh3YyYueM4i2HLJvrNcd+r8KNRqZW6RUOpc6x90lz423+ElY82/73Hz3LIdq9QHIyMmn3+s/c/jUGbrW8uDlgc0vK2iW5tx9pToP1NChQxWepMSlZ+dz96xfyMwpoG2dIF64vjGWr0bYw5N/KNz6ucKTlFvV/b14aWBL5t7flbzanemX+yL/yh9MDp72+cre7Wqf+iAv2+xSpRK51DFZl3S7Hd/ZwxPA9W87wpNhGDz5zTYOnzpDRLAP0+/uddmhp7yMwdRaeGK6Alshoz/bROKxLMIDvXlvaHu8lk6GhCXg7mOf6ymw9iXtW7OMS1lq9ce0B19vOsS/FvryfVZnnnafSSyb7WeQbv3KflijYR+zS5VK4FIPZzp9u5Rt8M199n93Hl3kDOlvNh/mu1+TsbpZeGNwG6p4X/6EmeVlrJmWcikFOoTnnJd+2MX0FXvx8bDy5X2daX7sB/jmXvvGm/8LTa+/5H2vWrWKhIQEoqOj6datWwlVLHJxGTn5vL5kD7Pi99GbDTzjMYswyx9LwjS9Hvq+BAEK9eLiTh+1r3OXfhCiesKQr8Fq75s5cDyL/m+u4nRuAeOuasiDvRuYW2sxlOohPJGStHRnKtP/mM5/6o0tae52AL5/yL6xxyOXFZ5As4yLeQK8PZh0bVMWPNiDzHp96Z37Cu8V9KcAN9jxLcZbHSD+Hc0dJa6rIA++GGoPT8H14aaZjvCUbyvkoc+3cDq3gI71ghnVK9rcWkuBeqBKgXqgiifpRDbX/HsV6Wfyub1LPZ6ODYP3e8KpAxAdC7d+AW5Ws8sUuWyGYTDvtyO8MH8nQZm/84LHR7Rz+2PC4dAWcM3rl7Weo0iZMwz47gHY/DF4BcJdP0KNho7Nz3y/nRmr91PF250fHupO7aq+JhZbfOqBknIvt8DGqE83kX7GvkDw430bwpy77eEpqC7c8IHCk1QYFouFa1uFs3T8FfS6ohe32J7msfy7OGX4QcpWjA9j4fsxcOZkmdVUmWaTl1Kwbro9PFnc4Mb/FAlP3245zIzV+wF49aZWLhOenKUAJcVWkm+4L8zfyW+H0gn08eDtW9vguWrqn9P+D/oEfINLoGKR8sXPy51H+zZm4ZieJNcfxJW5r/KVrQcWDNg4A+Pf7WHLZ/Zv96WsvJzJJC5o13xY9Lj9332edywSDPB7aiaPfb0VgPt71qdPs1AzKiwTClBSbCX1hvv9r8n8N/4AAK8Pak3tY6th5VT7xmvfgLCWl1uqSLkWVcOfWXd04KWhvXjdfyyDcp9iT2EtLNnHYO59MLM/pO0s3Ro0PlAuRdL6P2cabzsMOt3v2JSZk899H2/kTL6NrtHVGN+nYs99pmkMpNiKc+roxaYNSDqRzcQ59m8no3rVp1e4Dab/ccZdh7ug1eCSL1ykHLJYLPRpFkqPhjWYvqI2/7e8EUNt83jQfQ4+B1ZjTO+GpfNouOIR8PQr8fuv9LNmi/OO/g6f3gwFOdAgDvpPc8w0bhgGD3/5G4nHsggL9ObNwW2wulXsGfjVAyXFVpzFLC/US2UrNBg7235WRvu6VRl7ZX345h7IPm6fabzPC6VZvki55O1hZUxsQ34Y15u9je7mqryXWWxrh6WwAFa/jvF2R/uyMDrfR8yUmQKfDLSP06vVDm6a4TjjDmD6ikQWbk/Bw2rhnSFtqebv+ku1XIx6oKREXaiX6t3lCfxy4CT+Xu5MG9Qa9/jX7at2e/jZ/xg9NMO9VF4Rwb68P6w9K3+vy9Pf12P28ZU84zGL2umHYPZtEH0VXD0VgnXITcpYTgZ8cuOf0xXc+kWRXtGF21KYumgXAJOuaUqbOpVjEW31QMll+fvA8n/qpfo16RSv/2g/bfuZ65oRcfo3WDbFvrH/K1C9wQX3K1JZ9GhYg4UP9SCm7xCuN17jrYLryTOskLAE4+1O9r+b/DNmlymVRV42fDYYUreCXwjc9jX4VXds3nY4nbGzt2AYMLRTXW7rVNfEYsuWAlQlVVIBpTgDy7PzChg7ewsFhQb9W4RxQxM/+PouMGzQ4mZodcsl7VekovJ0d+OeHvVZMCGOxBbjiMubykpbCyy2XFjxEsbbMbD7B7PLlIouPwc+vwUOrLYvEDzkSwiOdGxOSc9hxKwNnMm30aNhDSZf2xSLpWKPe/orHcKrpM4GFOCyBpIWZ2D58/N3kngsi9AAb14Y0AzLvLshPcl+KOKa1xyDEJ3dr0hFVzPAm9cGteaXmDpM/rYhn6cu4SmPTwg7dcDeK9AgDvq9pMN6UvIK8uCLYZC43D7MYshXEN7asTkrt4ARszaQmpFLgxB/3rq1De7WytUno5nIS4ErzEReVovsLtuVxh0zNwDwv7ti6Jq11D5w3M0D7loC4W1K7b7F9Wjx539mKzSYvSGJafN+4U5jDiOsC/C02DCsXli6PgTdxoJnxZywUMqYLR++vB12zbMv6H7bV1Dvz7VEbYUG932ykSU7Uqnm58ncUV2JCK4Yrz3NRC4XVZwz6i5XRk6+Y8qCEd0i6VojBxY8bN/Y81GFJzmHDt3+M6ubhVtj6vDxHe3ZEjGcq/P/9edhvZVTKXyrPWybo7P15PLYCuyLue+aB1YvuOXTIuHJMAye+GYrS3ak4unuxvvD2leY8OQsHcKTUjNlwS5SMnKoV82XCVc1hNk3Qm461GoPXceaXZ6UQ2V96NYVe7waR9XhvXvrsCc1k2e/b8H/En/gKY9PqJ1xGL66A2PDh1j6TYXQ5o7buOLjFBMU5MLXI+zTZrh5wM3/hfpXFmnyr4W7+XxDEm4WeGNQa9rVrRxn3J2PeqD+wdtvv029evXw9vYmJiaG9evXm12SS1mTcIzP1h8E4KWBLfH5dQYkLrN3B//f9CLzh4icVRY9o3/lyj1eDWpW4b8jYhg4ZCR3+r3NtPyB5BgeWA6sxnivO8wbB1nHgZJ7nDo7tgLLy4bPbrGHJ6unPTw16gv8+f8+9fvNTF+xF4ApN7SgX4swMys2nQLUecyePZtx48YxefJkNm3aRKtWrYiLiyMtLc3s0lxCdl4Bj875DYDbOtUhMvd3bAufsG+86plzpiwQMYurL2dydjbz78ddhV/cE1zH68y3dcRiFMIvH1H4ZhuIf4eoehEl8jhdOXDKBeRk2CfJ3LsUPHzt8zw1vtqxOTExkdm/HOKd1fbgPLFfYwZ1qGNWteWGBpGfR0xMDB06dOCtt94CoLCwkIiICB544AEee+yxi97eFQaRl6Znv9/Bf1bvo1aQD4se6krh9CsISN/JqaqtCHpgObgpt4uUhqOZuby2ZDf7f1nIU+6f0NTNvuakLTgaa98p0OCq8571WlzFORSow4UuJvsEfHIDJG8Gr0D7VAV1Yoo0+Xj5diYt3I8BjOxZn0f7Njan1jLgzOe3jqP8TV5eHhs3bmTixImO69zc3IiNjSU+Pv68t8nNzSU3N9fxe0ZGRqnXWV5tPHCCGWv2AfDiDS3w3/w+pO+kwOpLbr/XFJ5ESlGNKl5MuaElOzrV48X5Xam9fw4T3L+g+okE+PQmCiN74hb3QpHxUc4ozvp5JTVFipSBE4nwv5vgeAL4VoPb5hSZqgDg2y2HeXrxAQzglo4RPBJXsRcIdoY+zf7m2LFj2Gw2atasWeT6mjVrkpKSct7bTJkyhcDAQMclIiKiLEotd/IKCnn0660YBtzYrjZXVD8NP9nXt3Pv/y9qNmxvcoUilUPT8AA+vqsLfYY+wh1VpvNeQX9yDXfc9i3HmN4N49vRkHGkVO7b1Q+LVhpJ6+HDWHt4CqgNty84JzzN2XSIsbO3YCs0uKldbZ4f0KJSTZR5MQpQJWDixImkp6c7LklJSWaXZIqPVu0jIe001f09eerqJjBvDBScgcge0Gao2eWJVCoWi4UrG9dkzth+eF/9Ijda32CerRMWDCybP7aPj1o2BXIzS/R+y/pEALkE27+BmdfYF3IPawV3L4WQooflvtiQxPgvf6XQgFs61uFfA1tidfszPOmEAgWoc1SvXh2r1UpqamqR61NTUwkNDT3vbby8vAgICChyqWwOnczmzaX2te4ev7oJgb9/aZ/B1t0brnn9ssZdiMil87C6MbxLPf73yCC2d32DQQXPsqkwGreCM7DiJWyvt4b1H9hnnjaRPpDLgGHAqtftk2TacqFhP3vPU5Win23/W3eAR77+zbG+3QsDmuPmVvQ9XCcUKECdw9PTk3bt2rF06VLHdYWFhSxdupTOnTubWFn59uz3OziTb6NjZDD/18ADFj1u39DrcahW39ziRIQAbw8e7duYaRPu4ZNmH3J//kMkFoZiPXMMFkzA9lYH2PY1FBaaUp8+kEtZXpZ9DdIfJ9t/73gvDP4fePk7mhiGwVs/7eGJb7YBcEfXejx7fbNzwhPoUC1oEPl5jRs3juHDh9O+fXs6duzI66+/TlZWFnfccYfZpZVLS3emsnhHKu5uFp4f0BzLwgch5xSEtoROo8wuT0T+IjzIh9cGtWF79yie/6Ev4Ylf8JD7HGqc2g9f3Ykt5DWssZOgQZ8y7TnW+pel6PhemH0bpO0AN3eIexFi7i3SpMBWyKTvtvPpOvv8fSN71ueRuEb/OOapOCcUVHSaxuAfvPXWW7z88sukpKTQunVr3nzzTWJiYi5+QyrXNAY5+TaumraCpBNnuLdHFBPr77cvcmqxwt0/nTMo8XLo9GiRkrdm7zHeWLCZmJTPudt9PlUsZwCw1eqANXYyRHY3uUK5LLsW2Jdmyc0A/5pw0yyoW/RoSnZeAQ9+tpkfd6ZhscAz1zVjWOd65tRrMmc+vxWgSkFlClCvLd7Nmz8lEBbozY+j2+H3QRfIOAxdH4Krni3R+1q1ahUJCQlER0fTrVu3i99ARIrFMAx+2JbCB4s2EHfqC4ZbF+FjsY+JKqzXA7deE6FuF5OrFKcU5MGy52H1G/bfIzrBzbPOGe90/HQud876hV+TTuHl7sYbg9vQt/n5x/tWBpoHSsrEvmNZTF9hH68w+dqm+K2dZg9PQXXgiotPOOqskuriV0+WSFEWi4WrW4TRp+k1fLO5DYOWDGBg1ufcYv0Jz/0rYcZKe5Dq+RjU62p2uU6plH/vR3fb17RLsS/mTsx90Od5sHoUabbtcDr3fryRw6fOEOTrwYfD2tO+XrAJBbsmBSi5ZC/M30GerZArGtYgLiQd5thnbqffVPAs+dW5S+qYe2WZ6K9SfnDIZXG3unFT+wiuax3O7A3tGbh0DYNzvuIm63J7kJq5ksK63XDrMQGierrE2bWV5e8dsJ9lt+FDWPwkFOSATzBc9yY0ufacpnM2HWLinK3kFhRSr5ovHw7vQHSI/3l2Kv9EAUouyao9x/hxZxrubhae6t8Eyw9DoLAAGvaFRv3MLu+CKstg1Ur1wSElysvdyrDO9bi5fQSfrO3EDcvXckvuH0HqwCr4eBWF4W1x6z4eGl1drlcYMPvvvcy+yJxKIufrkXgn/Wz/vX5vGPDOOYfs8m2FvDB/JzPX7AfgysYhTBvUmkAfD8Q5ClACOPdHbis0eH7+DgBu61SX6KOLYd8K+5xPfV8qi3IvS2U5e8TsDw5xfd4eVu7qHsWQmLp8srYT/7d8LTfmzeUW6094J2+C2UMorN4It64PQYsbwd3L7JLPYfbfe6l/kSm0wbr34Kfn8c7PwoY7+xuOoP7gl84JtsmnzjDm8y2s338CgAd7N2BM7wbnnaZALk4BSgDn/shnb0hiV0omgT4ejOkeBv8ZaN/QbRwER5Z2qVJMZn9wSFGufEjVx9PK3T2iGNKpDp+u68T1KzZzbc63DLMuJuDYbvj2fgqXPoNbx3ug/Z3gq3E0Z5XqF5nkLfD9Q3BkCwC5oe3YFnkXYS16nhOe5v92hIlzfiMjpwB/L3emDWrNVU1rnrNLKT4FKAGK/0eemZPPa0t2A/BQ7wYEbXgNMo9A1Xr2M+9E5LwqwiFVX0937uoexW2d6vLlxvbcuOwmep2ez+3uiwg7nQo/PYex8hUsbYZAx3ughhaeLZUvMlnHYcVL9vFORiF4BUKfZ/FqM4x2fwtOmTn5PP3dDr7edAiAVrUDeX1wGyKr+5VsTZWQpjEoBRV5GoOXftjF9BV7iarux6LbQvB4v7t97NOtX0DDOLPLk0rAVXtyXLXuC8krKOTbLYf5aMVumhz/kbvdF9DU7cCfDSKvgI5325cMser7+mXLz4F10+HnV+3zOgE0u8E+dKLKub1J6/edYMKXv3LwRDZuFhjVK5oHezfAw1p+x6yZTdMYSKlIOpHNf1btA+Dxfo3xWDLSHp4aXa3wJGXGVXtyKuIhVU93+1l7A9vWZumuFkxafi0eh1Zzh3Uhvd02Yd23AvatwAiojaXdcGg9BAJrmV226ym02ZfZWfospP+xWH1oS/vUBFFXnNP8VHYeL/2wi8832NvWCvLh9cGt6aApCkqUeqBKQUXtgRr1v03M33qErtHV+KRHOpZPbwY3Dxi1TuvdSZmpiD05Fckv+0/w4c/72LZjK7dalzLY+hPBltMAGBY3LNGx0Gao/Wxdq878uiBbPvz2Bax6DY7bvzQQUAt6T4IWN58zzskwDL7dksxz83ZwPMs+EergDhE83r8JAd56rotDPVBS4n5NOsX8rUewWODJvg2wzO1r39DpPoUnKVMVsSenpJkZMtvXC6Z9vWCSTjRh5pqOxG64mSvyVjPIfTmd3HbCnsX2i291aH6DPQjUbu8Sc0qVmfwc2PIJrHoD0u1r0+FTFbo8AJ3uBw+fc26y80gGL8zfyaqEYwA0CPHnxRtaqNepFClASbFMXbQLgBva1KbJ4a/h2O/gWw16PGxyZSLyd+XhMGdEsC9PXdOUMbEN+Gpjcx5f25fCYwncbF3BjdaVhGQfg/Xv2y9VI6HFTdB8oH3geWUNUycS4ZcZsPkTOGOfagC/EHtwan8neJ070WXyqTO8tuR3vt50CMOwH1Z9qHcD7u4ehae7xjqVJh3CKwUV7RDeqj3HuO2jdXhYLSwb1ZraH3eBMyeh/6vQ4S6zyxORvymPhzkNwyB+73E+XnuApTuS6cxWrreupq/bBnwtuX82rNbAPnN2k2shvE3FD1MFeZDwI/zyH/tP/vhIDoyALg9C26Hn7XFKz87n3RV7mbF6H7kFhQD0bxnGI3GNqFtNZ9hdKi0mbLKKFKAMw+D6t1fz26F0bu9Sj6c9P4G170CNJnDfKp1ZIyJOS0nP4auNSXzxyyGOnjjBVW4bud66hu7WrXhS8GfDgFoQHWu/RPUEb9d+P3UotMGB1bD1K9j5nf0L6VnRsfYvpg36gJv1nJumZuTw4c+JfLruIFl5NgA6RgYzsV9j2tSpWlaPoMJSgDJZRQpQP2w9wsj/bcLX08qqu+oQPPOPaQtu+9r+hy4icokKCw3W7TvBF78ksWDrETwKTtPLbQtx1g30dv8VHyPnz8Zu7hARY58aoW4X+7ip8/TMlFu5mbBvpb2XafcP9vnzzvILgZY32w/T/cOY0n3HsnhvxV7mbDpMns3e49Q4tAoT+jSid5MQLBW9p66MKECZrKIEqAJbIX1eX0ni0Swe7N2Acccmw+4F9m9GQ740uzwRqUAyc/JZuC2Fb7cks2bvMTyMPDq77eAKt1+J89pKuC256A2snhDeFup2th/qC29jP+xVXoJEXhYkb4akdbB3GRyMt3/5PMs7EJpcZ18Cp1738/Y25RUUsnhHCp+vT3IMDgfoWC+YkT3r07NRDQWnEqYAZbKKEqBmbzjIo19vpaqvB6tv8cH3f9eAxQr3x2uGYREpNWkZOXz3azLztx5h88FTANSxpNLD7TdifffSjh1UyT927g19gu1BqmZTqN7QPp6qekPwq1Z6xRoGZB2Fo7vtJ9ekboNDGyB1Bxi2om2Do4oekjzP2oGGYbA7NZNvNh3mq42HHNMRWCxwZaMQRvasT3udWVdqFKBMVhECVE6+jV6vLOdIeg5PXt2Yu/aMtH+TajscrnvT7PJEpJJISc9h0fYUFm5LYd2+4xQaAAZ1LGlc4fU7cQEHaGIkEpyVgOWvPTx/5R1kH08VEP7HpZZ9vT7vQPAKsP/09LP3Alnc7F8ULRYoyLX3JOWdhvxsOHMKTqdAZqr9EFzmETi+F3JOnf9+A2rbDzXW7QrRvf/x8JxhGGw7nMEP247ww7YU9h3LcmwLqeLFoA4R3Nw+gohg38t4JqU4FKBMVhEC1Eer9vHcvB2EBXqz4rozeH45BNy94cHN9jcgEZEydiIrj5/3HGX57qOs+P0oJ/7onQHwIo8YvxT6VUulpXcqtW2HCDi9D8vZmbtLlQWq1oXqjey987XbQ+0OF3yvTMvMIX7vcVYnHGN1wnEOnzrj2Obp7sYVDWtwc/sIejWqgbuWXikzmkhTLktOvo3pK/YC8GCvKDyX32Lf0GmkwpOUqPJ4ur2UX8F+nlzfuhbXt66FrdDg10OnWL3nGGv3HeeX/SdZmVWHlVl1HO09rBZah3rSvXoWTf1PE+WZTpjlJD45KfYz33Iy7GvK5aRDXrZ9YV7D9sfPQrB62XumPP3Awxe8qkCVMKgS+uelaqS9Z+kCA9pz8m3sPJLBtuQMth9OZ+OBk+xJO12kjY+HlV6Na9C3eRhXNg7B30sfz+Wd/ofkHJ+uO8jRzFxqBflwk8dqOLrT3gXedYzZpUkFUx4mfCwJCoJlz+pmoW2dqrStU5UHaEBugY1fk9JZm3icLUmn2JJ0ihNZeWw4nMuGw+5A0B+XutSo4kVkNT9qV/WhdpgPtav6Eh7kQ7CfJ8F+ngT5euDtce6g7n+Sk2/jxKkznMjK42hmLgeOZ3HwxBkOnshi//Fs9h3LwlZY9GCPxQJNwwLoGl2dLvWrERNZDR/P4t+nmE8BysWV9Bv3X3ufRveojfuKB+wbuo8Dn6DL3r/IX0VFRRX56aoqShB0ZV7uVjpGBtMx0j7A2jAMDp08w5akU2xLTmdP6ml+T83k0MkzHM3M5WhmLuv3//P+/Dyt+Hi64+XuhpeHG55WN9ytFgpsBnm2QvJtheQVFJJxpoAz+bZ/3tEfqvl50rxWIC1qBdK8ViAxkcFU9fMsoUcvZlCAcnEl/cb9+fqDpGXmEh7ozU2FCyHjkH3AZcd7LnvfIn9XUda1qyhBsCKxWCxEBPsSEezLta3+fI2dzi0gIe00SSeyOXTyDIdO2n8eST/Diax8TmbnYSs0yMqzOSaqLA53NwtV/Typ5udJnWBf6lbzpU41P+oE+9Kwpj+hAd6acqCCUYBycSX5xp2Tb+Pds2OfutXEffUI+4aej7nWhHUiZayiBMHKwN/LndYRQbSOCDrvdsMwyMgp4GRWHtl5NvJsheTm238WFBp4Wt3wsLrhYbXgYXUjwNuDqn4e+Hu5KyBVMgpQLq4k37i/+CWJ1IxcwgK9uTFvrn2QZfWG0OrWEtm/iEh5Z7FYCPTxINDHw+xSpJzTuZECQG6BjXeW2XufHupSHfd10+0bej2h9e5EpNJLTk5m1apVJCcnX7yxVAoKUALAFxuSSMnIITTAmxtz50JeJtRsbl9qoAzozUlEyrOz400TExPNLkXKCXUtCHkFhby73N77NKZLMO5r3rdv6DkR3MomY+ssJhEpz3SigPydApTw3a/JJKfnUN3fixtzv7EvWxDaEhr3L7Ma9OYkIuWZThSQv1OAquQKCw3e++PMu1EdA3Df8KF9Q6/Hy3RVc705iYiIK9EYqErup11p7Ek7TRUvd24tmAv5WfbVzBv2Nbs0ERGRcksBqpI7O+/T3W398Nr0H/uVPcu290lERMTVKEBVYhv2n2DjgZN4Wt24y/IdFJyBWu2hwVVmlyYiIlKuKUBVYtP/OPNueEsffH+bZb+y10T1PolIuaTpTqQ8UYCqpHanZLJ0VxoWC4zyWQwFOVCrHdTvbXZpIuJCyjLUaC4mKU90Fl4ldfbMuxua+BG07b/2K7tPUO+TiDilLOdw03QnUp4oQFVCh05m892v9m+LDwetgMRMCGmmM+9ExGllGWo03YmUJwpQldDM1fspKDToFelL6M4Z9iu7jyuzWcdFpOJQqJGSlJycTGJiIlFRUeX+daUAVcmczi1g9oYkAJ6oGQ9HTkJwFDT7P5MrExGRys6VlvVSgKpkvvwliczcAhpV96B+wkz7ld3GgpvV1LpERERcaZybAlQlYis0mLlmPwDP1tmCZUcqBNSGloPNLUxExESudNioonOlQ8Ia9FIB/dNpxT/tSuPA8WyqeVvocPiPM++6PgjuniZUKRWJ5ucRV6bpEeRSqAeqAvqnY8j/WbUPgGeiduGWmAR+NaDtMFNqlIrFlcYtiPydKx02kvJDAaoCOt+bwfbkdOITj2N1g7j02fYrO40EDx8zSpQKRh9A4spc6bCRlB8KUBXQ+d4MZqzeD8C4yCQ8Du8CDz9of6cJ1UlFpA8gEalsNAaqEjiamct3W+xjU4YWfme/st1w8KlqYlUiIq5NY/8qN/VAVQL/W3eAPFshN4QeI+DIarBY7YfvRETkkmnsX+WmAFXB5RUU8snagwCM818Mp7BPmhlUx9S6RORcOp3etZg59k+vFfMpQFVwC7encOx0Li3906l1+Af7lV0fNLcoETkv9Wi4FjPH/um1Yj4FqAruk/gDAEwO+RlLsg0ir4CwViZXJSLno7MZpbj0WjGfAlQFtjslk/X7TxDklk2bo9/ar+yi3ieR8kpnM0px6bViPp2FV4F9svaP3qfQtbjlZ0FIM4jubXJVIiIirk8BqoI6nVvAnE2H8KCA/mf+mLqgywNgsZhbmIiISAXgMgHqhRdeoEuXLvj6+hIUFHTeNgcPHqR///74+voSEhLCww8/TEFBQZE2y5cvp23btnh5eREdHc3MmTPP2c/bb79NvXr18Pb2JiYmhvXr15fCIypdczcfJivPxvCgLXieSQP/UGg+0OyyREREKgSXCVB5eXncdNNNjBx5/vmLbDYb/fv3Jy8vjzVr1jBr1ixmzpzJpEmTHG327dtH//796dWrF1u2bGHMmDHcddddLFq0yNFm9uzZjBs3jsmTJ7Np0yZatWpFXFwcaWlppf4YS4phGI7Dd/d4LrZf2WGEFg0uBzTxnohIxWAxDMMwuwhnzJw5kzFjxnDq1Kki1//www9cc801JCcnU7NmTQCmT5/Oo48+ytGjR/H09OTRRx9l/vz5bNu2zXG7wYMHc+rUKRYuXAhATEwMHTp04K233gKgsLCQiIgIHnjgAR577LFi1ZiRkUFgYCDp6ekEBASUwKN2zi/7T3Dj9HhiPPYy2/oUWD1h7A7wr1HmtUhRq1atIiEhgejoaLp162Z2OSIi8hfOfH67TA/UxcTHx9OiRQtHeAKIi4sjIyOD7du3O9rExsYWuV1cXBzx8fGAvZdr48aNRdq4ubkRGxvraHM+ubm5ZGRkFLmY6eM/ep8mBi+3X9HiJoWnciIqKoro6Gideiwi4uIqTIBKSUkpEp4Ax+8pKSkXbJORkcGZM2c4duwYNpvtvG3O7uN8pkyZQmBgoOMSERFREg/pkhw7ncuCrUeoyQlaZaywXxlz3yXtS4ebSl54eDjdunXT6cciIi7O1AD12GOPYbFYLnjZtWuXmSUWy8SJE0lPT3dckpKSTKvly18OkW8zGB/8MxajAOp2hbCWl7SvszPdJiYmlnCVIiIirs3UiTTHjx/P7bfffsE2xT3UERoaes7ZcqmpqY5tZ3+eve6vbQICAvDx8cFqtWK1Ws/b5uw+zsfLywsvL69i1VmaDMPgi1+S8CKP6wr+GDwec+8l708z3YqIiJyfqQGqRo0a1KhRMmNzOnfuzAsvvEBaWhohISEALFmyhICAAJo2bepos2DBgiK3W7JkCZ07dwbA09OTdu3asXTpUgYMGADYB5EvXbqU0aNHl0idpWn9vhPsO5bFbZ5r8c47CYER0Kj/Je9PM92KVB5anFbEOS4zBurgwYNs2bKFgwcPYrPZ2LJlC1u2bOH06dMA9OnTh6ZNmzJ06FB+/fVXFi1axJNPPsmoUaMcvUP33XcfiYmJPPLII+zatYt33nmHL774grFjxzruZ9y4cXzwwQfMmjWLnTt3MnLkSLKysrjjjjtMedzOmL0hCTAY5bvEfkXHu8Gq1XpE5OJ0yF7EOS7z6Tpp0iRmzZrl+L1NmzYALFu2jJ49e2K1Wpk3bx4jR46kc+fO+Pn5MXz4cJ599lnHbSIjI5k/fz5jx47ljTfeoHbt2nz44YfExcU52gwaNIijR48yadIkUlJSaN26NQsXLjxnYHl5k34mnwXbjhBj2UVYzl7w8IW2w8wuS0RchA7ZizjH5eaBcgWlOQ/UP3Wzf7z2AE/N3cZ/q7xNj/zV0O4OuPb1Er1vERGRisyZz2+X6YESu7Pd7ECRADV7w0FqcJJuBevsV3S4y4zyREREKgUFKBdzvm72bYfT2XY4gzEey3EzCiCiE4Q2N6tEERGRCk8BysWc78y4L35JwoqN4V7LoAD1PolUIjp7TsQcLnMWnpxfTr6NbzYfprfbJqoWHAPf6tD0OrPLEpEyUpnPntNqCWIm9UC5uIXbUsjMKeAu35+gEGg7FNzNn9RTRMpGZT577p/GhIqUBQUoF/f5hoPUsxyhY+GvgMV+9p2IVBqVecLbyhwexXwKUC4s6UQ2axNP8KT7UvsVDfpA1brmFiUiFUZ5H19VmcOjmE8ByoV9s/kwXuQx2PNn++E7DR4XkRKkQ2Qi/0wBykUZhsGcTYe41hqPf2EmBNWB6N5mlyUiFYgOkYn8MwUoF7Xp4En2H8/mTa8f7Ve0vxPcrOYWJSIVig6RifwzTWPgor7edJimlv20tOwFNw9oM9TskkRERCoNBSgXlJNvY96vyQyyLrNf0eQa8KtublEiIiKViAKUC/ppVxp5OVnc4L7afkXbYeYWJCIiUskoQLmgOZsO0c9tPVXIhqC6ENnT7JJEREQqFQUoF3PsdC7Ldx9lsPsfh+/aDgU3/TeKiIiUJX3yupjvtiRT1zhEjNsusLhB6yFmlyQiIlLpKEC5mDmbD3Gzdbn9lwZxEKBTjEVERMqaApQL2Z2Sye7DJ7jR+rP9inbDzS1IRESkklKAciFzNh8i1m0j1SwZUCUMoq8yuyQREZFKSTORu5Crm4fhsz0eTmMf+2TVf5+IiIgZ9AnsQlr5p8PpDfZf2txmbjEiIiKVmA7huZLNnwAGRPWE4EizqxEREam01APlSup1hdSrodVgsysRERGp1BSgXElUT/tFRERETKVDeCIiIiZKTk5m1apVJCcnm12KOEE9UCIiIiZKTEwkISEBgPBwTY7sKhSgRERETBQVFVXkp7gGBSgREREThYeHq+fJBWkMlIiIiIiTFKBEREREnKQAJSIiIuIkBSgRERERJylAiYiIiDhJAUpERETESQpQIiIiIk5SgBIRERFxkgKUiIiIiJMUoEREREScpAAlIiIi4iQFKBEREREnKUCJiIiIOEkBSkRERMRJClAiIiIiTlKAEilFycnJrFq1iuTkZLNLERGREuRudgEiFVliYiIJCQkAhIeHm1yNiIiUFAUokVIUFRVV5KeISGWRnJxMYmIiUVFRFfILpAKUSCkKDw+vkG8cIiIXU9F74BWgRERE/qai956UhYreA68AJSIi8jcVvfekLFT0HngFKBERkb+p6L0ncvkUoEREpEy5wuGxit57IpdPAUpERMqUDo9JReASE2nu37+fESNGEBkZiY+PD/Xr12fy5Mnk5eUVaffbb7/RvXt3vL29iYiIYOrUqefs68svv6Rx48Z4e3vTokULFixYUGS7YRhMmjSJsLAwfHx8iI2NZc+ePaX6+EREKpOoqCiio6N1eExcmksEqF27dlFYWMh7773H9u3bmTZtGtOnT+fxxx93tMnIyKBPnz7UrVuXjRs38vLLL/P000/z/vvvO9qsWbOGW265hREjRrB582YGDBjAgAED2LZtm6PN1KlTefPNN5k+fTrr1q3Dz8+PuLg4cnJyyvQxi4hUVOHh4XTr1q1S9j5pdYKKw2IYhmF2EZfi5Zdf5t133yUxMRGAd999lyeeeIKUlBQ8PT0BeOyxx5g7dy67du0CYNCgQWRlZTFv3jzHfjp16kTr1q2ZPn06hmEQHh7O+PHjmTBhAgDp6enUrFmTmTNnMnjw4GLVlpGRQWBgIOnp6QQEBJTkwxYRERe2atUqEhISiI6Oplu3bmaXI3/jzOe3S/RAnU96ejrBwcGO3+Pj4+nRo4cjPAHExcWxe/duTp486WgTGxtbZD9xcXHEx8cDsG/fPlJSUoq0CQwMJCYmxtHmfHJzc8nIyChyERER+Tsdvqw4XDJAJSQk8O9//5t7773XcV1KSgo1a9Ys0u7s7ykpKRds89ftf73d+dqcz5QpUwgMDHRcIiIiLvGRiYhIRVaZD19WNKYGqMceewyLxXLBy9nDb2cdPnyYvn37ctNNN3H33XebVHlREydOJD093XFJSkoyuyQREREpRaZOYzB+/Hhuv/32C7b5azdncnIyvXr1okuXLkUGhwOEhoaSmppa5Lqzv4eGhl6wzV+3n70uLCysSJvWrVv/Y41eXl54eXld8HGIiIhIxWFqgKpRowY1atQoVtvDhw/Tq1cv2rVrx4wZM3BzK9p51rlzZ5544gny8/Px8PAAYMmSJTRq1IiqVas62ixdupQxY8Y4brdkyRI6d+4MQGRkJKGhoSxdutQRmDIyMli3bh0jR468zEcrIiIiFYVLjIE6fPgwPXv2pE6dOrzyyiscPXqUlJSUIuOSbr31Vjw9PRkxYgTbt29n9uzZvPHGG4wbN87R5qGHHmLhwoW8+uqr7Nq1i6effppffvmF0aNHA2CxWBgzZgzPP/883333HVu3bmXYsGGEh4czYMCAsn7YIiIiUk65xEzkS5YsISEhgYSEBGrXrl1k29lZGAIDA1m8eDGjRo2iXbt2VK9enUmTJnHPPfc42nbp0oVPP/2UJ598kscff5wGDRowd+5cmjdv7mjzyCOPkJWVxT333MOpU6fo1q0bCxcuxNvbu2werIiIiJR7LjsPVHmmeaBERERcT6WYB0pERETELApQIiIiIk5SgBIRERFxkgKUiIiIiJMUoEREREScpAAlIiIi4iQFKBEREREnKUBVAsnJyaxatYrk5GSzSxEREakQXGImcrk8iYmJJCQkABAeHm5yNSIiIq5PAaoSiIqKKvJTRERELo8CVCUQHh6unicREZESpDFQIiIiIk5SgBIRERFxkgKUiIiIiJMUoEREREScpAAlIiIi4iQFKBEREREnKUCJiIiIOEkBSkRERMRJClAiIiIiTlKAEhEREXGSApSIiIiIkxSgRERERJykACUiIiLiJHezC6iIDMMAICMjw+RKREREpLjOfm6f/Ry/EAWoUpCZmQlARESEyZWIiIiIszIzMwkMDLxgG4tRnJglTiksLCQ5OZkqVapgsVhKdN8ZGRlERESQlJREQEBAie67otFzVXx6ropPz1Xx6bkqPj1XxVeaz5VhGGRmZhIeHo6b24VHOakHqhS4ublRu3btUr2PgIAA/ZEVk56r4tNzVXx6ropPz1Xx6bkqvtJ6ri7W83SWBpGLiIiIOEkBSkRERMRJClAuxsvLi8mTJ+Pl5WV2KeWenqvi03NVfHquik/PVfHpuSq+8vJcaRC5iIiIiJPUAyUiIiLiJAUoEREREScpQImIiIg4SQFKRERExEkKUC7ihRdeoEuXLvj6+hIUFHTeNhaL5ZzL559/XraFlhPFeb4OHjxI//798fX1JSQkhIcffpiCgoKyLbQcqlev3jmvo5deesnsssqNt99+m3r16uHt7U1MTAzr1683u6Ry5+mnnz7nNdS4cWOzyyoXVq5cybXXXkt4eDgWi4W5c+cW2W4YBpMmTSIsLAwfHx9iY2PZs2ePOcWa7GLP1e23337O66xv375lVp8ClIvIy8vjpptuYuTIkRdsN2PGDI4cOeK4DBgwoGwKLGcu9nzZbDb69+9PXl4ea9asYdasWcycOZNJkyaVcaXl07PPPlvkdfTAAw+YXVK5MHv2bMaNG8fkyZPZtGkTrVq1Ii4ujrS0NLNLK3eaNWtW5DW0atUqs0sqF7KysmjVqhVvv/32ebdPnTqVN998k+nTp7Nu3Tr8/PyIi4sjJyenjCs138WeK4C+ffsWeZ199tlnZVegIS5lxowZRmBg4Hm3AcY333xTpvWUd//0fC1YsMBwc3MzUlJSHNe9++67RkBAgJGbm1uGFZY/devWNaZNm2Z2GeVSx44djVGjRjl+t9lsRnh4uDFlyhQTqyp/Jk+ebLRq1crsMsq9v79nFxYWGqGhocbLL7/suO7UqVOGl5eX8dlnn5lQYflxvs+34cOHG9dff70p9RiGYagHqoIZNWoU1atXp2PHjvznP//B0DRf5xUfH0+LFi2oWbOm47q4uDgyMjLYvn27iZWVDy+99BLVqlWjTZs2vPzyyzq0ib1Xc+PGjcTGxjquc3NzIzY2lvj4eBMrK5/27NlDeHg4UVFRDBkyhIMHD5pdUrm3b98+UlJSirzGAgMDiYmJ0WvsHyxfvpyQkBAaNWrEyJEjOX78eJndtxYTrkCeffZZrrzySnx9fVm8eDH3338/p0+f5sEHHzS7tHInJSWlSHgCHL+npKSYUVK58eCDD9K2bVuCg4NZs2YNEydO5MiRI7z22mtml2aqY8eOYbPZzvu62bVrl0lVlU8xMTHMnDmTRo0aceTIEZ555hm6d+/Otm3bqFKlitnllVtn33vO9xqr7O9L59O3b19uuOEGIiMj2bt3L48//jj9+vUjPj4eq9Va6vevAGWixx57jH/9618XbLNz585iD7586qmnHP9u06YNWVlZvPzyyxUmQJX081WZOPPcjRs3znFdy5Yt8fT05N5772XKlCmmL50grqFfv36Of7ds2ZKYmBjq1q3LF198wYgRI0ysTCqSwYMHO/7dokULWrZsSf369Vm+fDm9e/cu9ftXgDLR+PHjuf322y/YJioq6pL3HxMTw3PPPUdubm6F+OAryecrNDT0nLOnUlNTHdsqmst57mJiYigoKGD//v00atSoFKpzDdWrV8dqtTpeJ2elpqZWyNdMSQoKCqJhw4YkJCSYXUq5dvZ1lJqaSlhYmOP61NRUWrdubVJVriMqKorq1auTkJCgAFXR1ahRgxo1apTa/rds2ULVqlUrRHiCkn2+OnfuzAsvvEBaWhohISEALFmyhICAAJo2bVoi91GeXM5zt2XLFtzc3BzPU2Xl6elJu3btWLp0qePs1sLCQpYuXcro0aPNLa6cO336NHv37mXo0KFml1KuRUZGEhoaytKlSx2BKSMjg3Xr1l30DGyBQ4cOcfz48SLhszQpQLmIgwcPcuLECQ4ePIjNZmPLli0AREdH4+/vz/fff09qaiqdOnXC29ubJUuW8OKLLzJhwgRzCzfJxZ6vPn360LRpU4YOHcrUqVNJSUnhySefZNSoURUmcF6K+Ph41q1bR69evahSpQrx8fGMHTuW2267japVq5pdnunGjRvH8OHDad++PR07duT1118nKyuLO+64w+zSypUJEyZw7bXXUrduXZKTk5k8eTJWq5VbbrnF7NJMd/r06SI9cfv27WPLli0EBwdTp04dxowZw/PPP0+DBg2IjIzkqaeeIjw8vFJOSXOh5yo4OJhnnnmGgQMHEhoayt69e3nkkUeIjo4mLi6ubAo07fw/ccrw4cMN4JzLsmXLDMMwjB9++MFo3bq14e/vb/j5+RmtWrUypk+fbthsNnMLN8nFni/DMIz9+/cb/fr1M3x8fIzq1asb48ePN/Lz880ruhzYuHGjERMTYwQGBhre3t5GkyZNjBdffNHIyckxu7Ry49///rdRp04dw9PT0+jYsaOxdu1as0sqdwYNGmSEhYUZnp6eRq1atYxBgwYZCQkJZpdVLixbtuy8703Dhw83DMM+lcFTTz1l1KxZ0/Dy8jJ69+5t7N6929yiTXKh5yo7O9vo06ePUaNGDcPDw8OoW7eucffddxeZmqa0WQxD57mLiIiIOEPzQImIiIg4SQFKRERExEkKUCIiIiJOUoASERERcZIClIiIiIiTFKBEREREnKQAJSIiIuIkBSgRERERJylAiYiIiDhJAUpERETESQpQIiIiIk5SgBIRuYijR48SGhrKiy++6LhuzZo1eHp6snTpUhMrExGzaDFhEZFiWLBgAQMGDGDNmjU0atSI1q1bc/311/Paa6+ZXZqImEABSkSkmEaNGsWPP/5I+/bt2bp1Kxs2bMDLy8vsskTEBApQIiLFdObMGZo3b05SUhIbN26kRYsWZpckIibRGCgRkWLau3cvycnJFBYWsn//frPLERETqQdKRKQY8vLy6NixI61bt6ZRo0a8/vrrbN26lZCQELNLExETKECJiBTDww8/zFdffcWvv/6Kv78/V1xxBYGBgcybN8/s0kTEBDqEJyJyEcuXL+f111/n448/JiAgADc3Nz7++GN+/vln3n33XbPLExETqAdKRERExEnqgRIRERFxkgKUiIiIiJMUoEREREScpAAlIiIi4iQFKBEREREnKUCJiIiIOEkBSkRERMRJClAiIiIiTlKAEhEREXGSApSIiIiIkxSgRERERJz0/88H1/UUPDYyAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def show_best_fit(state):\n", - " state.experimental_data.plot.scatter(\"x\", \"y\", s=1, alpha=0.5, c=\"gray\")\n", + " state.experiment_data.plot.scatter(\"x\", \"y\", s=1, alpha=0.5, c=\"gray\")\n", "\n", - " observed_x = state.experimental_data[[\"x\"]].sort_values(by=\"x\")\n", + " observed_x = state.experiment_data[[\"x\"]].sort_values(by=\"x\")\n", " observed_x = pd.DataFrame({\"x\": np.linspace(observed_x[\"x\"].min(), observed_x[\"x\"].max(), 101)})\n", "\n", " plt.plot(observed_x, state.model.predict(observed_x), label=\"best fit\")\n", @@ -696,21 +327,10 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "v = s\n", - "while len(v.experimental_data) < 1_000: # any condition on the state can be used here.\n", + "while len(v.experiment_data) < 1_000: # any condition on the state can be used here.\n", " v = pipeline(v)\n", "show_best_fit(v)" ] @@ -728,18 +348,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def cycle(state: State) -> State:\n", " s_ = state\n", @@ -786,25 +395,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "At the outset, we have no model and an emtpy experimental_data dataframe." + "At the outset, we have no model and an emtpy experiment_data dataframe." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "v0.model=None, \n", - "v0.experimental_data.shape=(0, 2)\n" - ] - } - ], + "outputs": [], "source": [ - "print(f\"{v0.model=}, \\n{v0.experimental_data.shape=}\")" + "print(f\"{v0.model=}, \\n{v0.experiment_data.shape=}\")" ] }, { @@ -818,21 +418,10 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#-- running experiment_runner --#\n", - "\n", - "v1.model=None, \n", - "v1.experimental_data.shape=(101, 2)\n" - ] - } - ], + "outputs": [], "source": [ "v1 = next(cycle_generator)\n", - "print(f\"{v1.model=}, \\n{v1.experimental_data.shape=}\")" + "print(f\"{v1.model=}, \\n{v1.experiment_data.shape=}\")" ] }, { @@ -846,22 +435,10 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#-- running theorist --#\n", - "\n", - "v2.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n", - " ('linearregression', LinearRegression())]), \n", - "v2.experimental_data.shape=(101, 2)\n" - ] - } - ], + "outputs": [], "source": [ "v2 = next(cycle_generator)\n", - "print(f\"{v2.model=}, \\n{v2.experimental_data.shape=}\")" + "print(f\"{v2.model=}, \\n{v2.experiment_data.shape=}\")" ] }, { @@ -875,22 +452,10 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#-- running experiment_runner --#\n", - "\n", - "v3.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n", - " ('linearregression', LinearRegression())]), \n", - "v3.experimental_data.shape=(202, 2)\n" - ] - } - ], + "outputs": [], "source": [ "v3 = next(cycle_generator)\n", - "print(f\"{v3.model=}, \\n{v3.experimental_data.shape=}\")" + "print(f\"{v3.model=}, \\n{v3.experiment_data.shape=}\")" ] }, { @@ -906,21 +471,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), params={}, experimental_data=Empty DataFrame\n", - "Columns: [x, y]\n", - "Index: [], conditions= x\n", - "0 2.281691, model=None)" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "experimentalist_rng = np.random.default_rng(180)\n", "@wrap_to_use_state\n", @@ -940,58 +491,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAHHCAYAAABwaWYjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABxuUlEQVR4nO3dd3hUVf7H8fek94SQDqGE3jshCAqIBEVXFAuKii7iiqAiVnbXgq6yP3sX1wKsa2+ooEgRRCQgLfQeMEAaLb1n5vfHNQORloEkNzP5vJ5nnin3zsx3hiHzmXPOPcdis9lsiIiIiEi1uZldgIiIiIizUYASERERcZAClIiIiIiDFKBEREREHKQAJSIiIuIgBSgRERERBylAiYiIiDhIAUpERETEQQpQIiIiIg5SgBKRBm3WrFlYLBb27dtndiki4kQUoEREalh2djYRERFYLBa++OILs8sRkVqgACUiDdrNN99MUVERzZs3r7HHfOyxxygsLKyxxxOR+kcBSkQaNHd3d3x8fLBYLDXyeJs3b+att97i4YcfrpHHE5H6SQFKRBq0mh4Dde+993LVVVcxcODAGnk8EamfPMwuQESkPsnPz6e4uPis+3l6ehIcHFzlts8//5wVK1awbds2DUoXcXEKUCIiJ5g0aRKzZ88+634XXXQRS5cutV8vKirigQce4L777qNFixYKUCIuTgFKROQEDz30EDfddNNZ92vUqFGV6//+978pKyvj73//e22VJiL1iAKUiMgJOnbsSMeOHR26z759+3juued44403CAgIqKXKRKQ+UYASETlBTk4ORUVFZ93Py8uL0NBQwJi2oEmTJgwaNMjedZeRkQHAoUOH2LdvH82aNcPNTcftiLgKBSgRkRPce++9Do+BSk1NZffu3cTFxZ2031133QXAsWPHCAkJqclSRcREClAiIic4lzFQ//rXvzh8+HCV7Zs3b+bRRx/loYceIiEhAX9//xqvVUTMowAlInKCcxkDNWDAgJNuq2xt6tOnDyNHjqyBykSkPlGHvIiIiIiDLDabzWZ2ESIiIiLORC1QIiIiIg5SgBIRERFxkAKUiIiIiIMUoEREREQcpAAlIiIi4iAFKBEREREHaSLNWmC1WklLSyMwMBCLxWJ2OSIiIlINNpuNvLw8YmJizrp2pQJULUhLSyM2NtbsMkREROQc7N+/n6ZNm55xHwWoWhAYGAgY/wBBQUEmVyMiIiLVkZubS2xsrP17/EwUoGpBZbddUFCQApSIiIiTqc7wGw0iFxEREXGQApSIiIiIgxSgRERERBykMVAiIuJyKioqKCsrM7sMqWc8PT1xd3evkcdSgBIREZdhs9nIyMggOzvb7FKkngoJCSEqKuq852lUgBIREZdRGZ4iIiLw8/PTZMZiZ7PZKCwsJCsrC4Do6OjzejwFKBERcQkVFRX28NS4cWOzy5F6yNfXF4CsrCwiIiLOqztPg8hFRMQlVI558vPzM7kSqc8qPx/nO0ZOAUpERFyKuu3kTGrq86EAJSIiIuIgBSgRERGTDRo0iMmTJ5tdBgBz5syhdevWuLu7M3nyZGbNmkVISIjZZdU7ClAiIiIubunSpVgslmpN7/C3v/2Na665hv379/PUU09x/fXXs3PnTvv2J554gu7du9desU5CR+GJiIgIAPn5+WRlZZGYmEhMTIz99sqj1+Q4tUCJ1KK0tDSWL19OWlqa2aWISD1XXl7OpEmTCA4OJiwsjEcffRSbzWbfXlJSwgMPPECTJk3w9/cnPj6epUuX2rf//vvvXHHFFTRq1Ah/f386derE999/z759+xg8eDAAjRo1wmKxcOutt570/EuXLiUwMBCAIUOGYLFYWLp0aZUuvFmzZjFt2jQ2bNiAxWLBYrEwa9as2npL6jW1QInUopSUFHbv3g1Q5deciNQNm81GUVmFKc/t6+nu0BFfs2fPZty4cfz222+sWbOGO+64g2bNmjF+/HgAJk2axNatW/nkk0+IiYnh66+/Zvjw4WzatIk2bdowceJESktLWbZsGf7+/mzdupWAgABiY2P58ssvGTVqFDt27CAoKOiULUr9+/dnx44dtGvXji+//JL+/fsTGhrKvn377Ptcf/31bN68mfnz57No0SIAgoODz++NclIKUCK1KC4ursq5iNStorIKOj72oynPvfXJRPy8qv81Gxsby0svvYTFYqFdu3Zs2rSJl156ifHjx5OamsrMmTNJTU21/xh74IEHmD9/PjNnzuSZZ54hNTWVUaNG0aVLF6Dq353Q0FAAIiIiTjsg3MvLi4iICPv+UVFRJ+3j6+tLQEAAHh4ep9zekChAidSimJgYtTyJSLX069evSotVQkICL7zwAhUVFWzatImKigratm1b5T4lJSX2WdfvueceJkyYwIIFCxg6dCijRo2ia9eudfoaGhIFKBERcVm+nu5sfTLRtOeuKfn5+bi7u7N27dqTlh8JCAgA4PbbbycxMZF58+axYMECpk+fzgsvvMDdd99dY3XIcQpQIiLisiwWi0PdaGZatWpVlesrV66kTZs2uLu706NHDyoqKsjKymLgwIGnfYzY2FjuvPNO7rzzTqZOnco777zD3XffjZeXF2CsF3i+vLy8auRxnJ2OwhMREakHUlNTmTJlCjt27ODjjz/mtdde49577wWgbdu2jBkzhltuuYWvvvqKvXv38ttvvzF9+nTmzZsHwOTJk/nxxx/Zu3cv69atY8mSJXTo0AGA5s2bY7FYmDt3LocOHSI/P/+c62zRogV79+4lOTmZw4cPU1JScv4v3gkpQImIiNQDt9xyC0VFRfTt25eJEydy7733cscdd9i3z5w5k1tuuYX777+fdu3aMXLkSFavXk2zZs0Ao3Vp4sSJdOjQgeHDh9O2bVvefPNNAJo0acK0adN45JFHiIyMZNKkSedc56hRoxg+fDiDBw8mPDycjz/++PxeuJOy2E6cZEJqRG5uLsHBweTk5BAUFGR2OSIiDUJxcTF79+6lZcuW+Pj4mF2O1FNn+pw48v2tFigRERERBylAiYiIiDhIAUpERETEQQpQIiIiIg5SgBIRERFxkAKUiIiIiIMUoEREREQcpAAlIiIi4iAFKBEREREHKUCJiIiIw2bNmkVISIjZZXDrrbcycuTIOn9eBSgRERGpcfv27cNisZCcnFwvH+98KUCJiIg4odLSUrNLqBHO+jqcJkBNnz6dPn36EBgYSEREBCNHjmTHjh1V9ikuLmbixIk0btyYgIAARo0aRWZmZpV9UlNTGTFiBH5+fkRERPDggw9SXl5eZZ+lS5fSs2dPvL29ad26NbNmzartlyciIg1YXl4eY8aMwd/fn+joaF566SUGDRrE5MmT7fu0aNGCp556iltuuYWgoCDuuOMOAL788ks6deqEt7c3LVq04IUXXqjy2BaLhTlz5lS5LSQkxP7dVtmy89VXXzF48GD8/Pzo1q0bSUlJVe4za9YsmjVrhp+fH1dddRVHjhw542tq2bIlAD169MBisTBo0CDgeJfb008/TUxMDO3atatWnad7vErPP/880dHRNG7cmIkTJ1JWVnbG+s6X0wSon3/+mYkTJ7Jy5UoWLlxIWVkZw4YNo6CgwL7Pfffdx3fffcfnn3/Ozz//TFpaGldffbV9e0VFBSNGjKC0tJQVK1Ywe/ZsZs2axWOPPWbfZ+/evYwYMYLBgweTnJzM5MmTuf322/nxxx/r9PWKiEgNsNmgtMCck81W7TKnTJnCr7/+yrfffsvChQv55ZdfWLdu3Un7Pf/883Tr1o3169fz6KOPsnbtWq677jpGjx7Npk2beOKJJ3j00UfP6Yf/P/7xDx544AGSk5Np27YtN9xwg72BYdWqVYwbN45JkyaRnJzM4MGD+de//nXGx/vtt98AWLRoEenp6Xz11Vf2bYsXL2bHjh0sXLiQuXPnVqu+Mz3ekiVL2LNnD0uWLLF/t9d244dHrT56DZo/f36V67NmzSIiIoK1a9dy4YUXkpOTw3vvvcdHH33EkCFDAJg5cyYdOnRg5cqV9OvXjwULFrB161YWLVpEZGQk3bt356mnnuLhhx/miSeewMvLixkzZtCyZUt7gu/QoQPLly/npZdeIjExsc5ft4iInIeyQngmxpzn/nsaePmfdbe8vDxmz57NRx99xMUXXwwY318xMSfXPWTIEO6//3779TFjxnDxxRfz6KOPAtC2bVu2bt3Kc889x6233upQuQ888AAjRowAYNq0aXTq1Indu3fTvn17XnnlFYYPH85DDz1kf54VK1ac9N18ovDwcAAaN25MVFRUlW3+/v68++67eHl5Vbu+Mz1eo0aNeP3113F3d6d9+/aMGDGCxYsXM378+Go/vqOcpgXqz3JycgAIDQ0FYO3atZSVlTF06FD7Pu3bt6dZs2b2ZsikpCS6dOlCZGSkfZ/ExERyc3PZsmWLfZ8TH6Nynz83ZZ6opKSE3NzcKicREZHqSElJoaysjL59+9pvCw4Otndtnah3795Vrm/bto0LLrigym0XXHABu3btoqKiwqE6unbtar8cHR0NQFZWlv154uPjq+yfkJDg0OOfqEuXLg6Fp7Pp1KkT7u7u9uvR0dH22muL07RAnchqtTJ58mQuuOACOnfuDEBGRgZeXl4nHVIZGRlJRkaGfZ8Tw1Pl9sptZ9onNzeXoqIifH19T6pn+vTpTJs2rUZem4iI1CBPP6MlyKznrmH+/mdv0fozi8WC7U/diacaH+Tp6VnlPmB839aGU72O6tZ5KifWXvlYtVV7JacMUBMnTmTz5s0sX77c7FIAmDp1KlOmTLFfz83NJTY21sSKREQEAIulWt1oZoqLi8PT05PVq1fTrFkzwOhl2blzJxdeeOEZ79uhQwd+/fXXKrf9+uuvtG3b1t4iEx4eTnp6un37rl27KCwsdKjGDh06sGrVqiq3rVy58oz3qWxhqm5L2NnqdPTxapvTBahJkyYxd+5cli1bRtOmTe23R0VFUVpaSnZ2dpVWqMzMTHtfaVRUlH0Q2onbK7dVnv/5yL3MzEyCgoJO2foE4O3tjbe393m/NhERaXgCAwMZO3YsDz74IKGhoURERPD444/j5uZmbwk6nfvvv58+ffrw1FNPcf3115OUlMTrr7/Om2++ad9nyJAhvP766yQkJFBRUcHDDz98UovN2dxzzz1ccMEFPP/881x55ZX8+OOPZxz/BBAREYGvry/z58+nadOm+Pj4EBwcfNr9z1ano49X25xmDJTNZmPSpEl8/fXX/PTTT/bDGSv16tULT09PFi9ebL9tx44dpKam2vtpExIS2LRpU5V+0YULFxIUFETHjh3t+5z4GJX7nE9fr4iIyJm8+OKLJCQkcPnllzN06FAuuOACOnTogI+Pzxnv17NnTz777DM++eQTOnfuzGOPPcaTTz5ZZQD5Cy+8QGxsLAMHDuTGG2/kgQcewM/Pse7Ffv368c477/DKK6/QrVs3FixYwD//+c8z3sfDw4NXX32Vt99+m5iYGK688soz7n+2Oh19vFpncxITJkywBQcH25YuXWpLT0+3nwoLC+373HnnnbZmzZrZfvrpJ9uaNWtsCQkJtoSEBPv28vJyW+fOnW3Dhg2zJScn2+bPn28LDw+3TZ061b5PSkqKzc/Pz/bggw/atm3bZnvjjTds7u7utvnz51e71pycHBtgy8nJqZkXLyIiZ1VUVGTbunWrraioyOxSzlt+fr4tODjY9u6775pdiss50+fEke9vp+nCe+uttwBOmjhr5syZ9qT90ksv4ebmxqhRoygpKSExMbFKM6a7uztz585lwoQJJCQk4O/vz9ixY3nyySft+7Rs2ZJ58+Zx33338corr9C0aVPeffddTWEgIiK1Zv369Wzfvp2+ffuSk5Nj/14yvZVFTstiszkw05dUS25uLsHBweTk5BAUFGR2OSIiDUJxcTF79+6lZcuWZ+36qm/Wr1/P7bffzo4dO/Dy8qJXr168+OKLdOnSxezSXM6ZPieOfH87TQuUiIiIq+rRowdr1641uwxxgNMMIhcRERGpLxSgRETEpWhkipxJTX0+FKBERMQlVM4Z5OgkkdKwVH4+HJ0L6880BkpERFyCu7s7ISEh9rn+/Pz8zjoRpTQcNpuNwsJCsrKyCAkJqbJ23rlQgBIREZdRuapEbS8kK84rJCTE/jk5HwpQ4rTS0tJISUkhLi6OmJgYs8sRkXrAYrEQHR1NREREtReilYbD09PzvFueKilAidNKSUlh9+7dAApQIlKFu7t7jX1RipyKApQ4rbi4uCrnIiIidUUBSpxWTEyMWp5ERMQUmsZARERExEEKUCIiIiIOUoASERERcZAClIiIiIiDFKBEREREHKQAJSIiIuIgBSgRERERBylAiYiIiDhIAUpERETEQQpQIqeRlpbG8uXLSUtLM7sUERGpZ7SUi8hpaLFiERE5HQUokdPQYsUiInI6ClAip6HFikVE5HQ0BkpERETEQQpQIudJg81FRBoedeGJnCcNNhcRaXgUoETOkwabi4g0PApQIudJg82rLy0tjZSUFOLi4vSeiYhTU4ASkTqj7k4RcRUKUCJSZ9TdKSKuQgFKROqMujtFxFVoGgMRERERBylAiYiIiDjIqQLUsmXLuOKKK4iJicFisTBnzpwq22+99VYsFkuV0/Dhw6vsc/ToUcaMGUNQUBAhISGMGzeO/Pz8Kvts3LiRgQMH4uPjQ2xsLM8++2xtvzQRERFxIk4VoAoKCujWrRtvvPHGafcZPnw46enp9tPHH39cZfuYMWPYsmULCxcuZO7cuSxbtow77rjDvj03N5dhw4bRvHlz1q5dy3PPPccTTzzBf/7zn1p7XSIiIuJcnGoQ+aWXXsqll156xn28vb2Jioo65bZt27Yxf/58Vq9eTe/evQF47bXXuOyyy3j++eeJiYnhww8/pLS0lPfffx8vLy86depEcnIyL774YpWgJSIiIg2XU7VAVcfSpUuJiIigXbt2TJgwgSNHjti3JSUlERISYg9PAEOHDsXNzY1Vq1bZ97nwwgvx8vKy75OYmMiOHTs4duxY3b0QERERqbecqgXqbIYPH87VV19Ny5Yt2bNnD3//+9+59NJLSUpKwt3dnYyMDCIiIqrcx8PDg9DQUDIyMgDIyMigZcuWVfaJjIy0b2vUqNFJz1tSUkJJSYn9em5ubk2/NBEREalHXCpAjR492n65S5cudO3alVatWrF06VIuvvjiWnve6dOnM23atFp7fBEREalfXK4L70RxcXGEhYXZl46IiooiKyuryj7l5eUcPXrUPm4qKiqKzMzMKvtUXj/d2KqpU6eSk5NjP+3fv7+mX4qIiIjUIy4doA4cOMCRI0eIjo4GICEhgezsbNauXWvf56effsJqtRIfH2/fZ9myZZSVldn3WbhwIe3atTtl9x0YA9eDgoKqnERERMR1OVWAys/PJzk5meTkZAD27t1LcnIyqamp5Ofn8+CDD7Jy5Ur27dvH4sWLufLKK2ndujWJiYkAdOjQgeHDhzN+/Hh+++03fv31VyZNmsTo0aPty0vceOONeHl5MW7cOLZs2cKnn37KK6+8wpQpU8x62SIiIlLPWGw2m83sIqpr6dKlDB48+KTbx44dy1tvvcXIkSNZv3492dnZxMTEMGzYMJ566in7IHAwJtKcNGkS3333HW5ubowaNYpXX32VgIAA+z4bN25k4sSJrF69mrCwMO6++24efvjhateZm5tLcHAwOTk5ao0SERFxEo58fztVgHIWClAiIiLOx5Hvb6fqwhMRERGpDxSgRERERBykACUiIiLiIAUoEREREQcpQImIiIg4SAFKRERExEEKUCIiIiIOUoASEXFSaWlpLF++nLS0NLNLEWlwPMwuQEREzk1KSop9sfTK5ahEpG4oQEmDkpaWRkpKCnFxcfrCEacXFxdX5VxE6o4ClDQo+sUuriQmJkafYxGTKEBJg6Jf7CIiUhMUoKRB0S92ERGpCToKT0RERMRBClAiIiIiDlKAEhEREXGQApSIiIiIgxSgRERERBykACUiIiLiIAUoEREREQcpQImIiIg4SAFKRESknkhLS2P58uWkpaWZXYqchWYiFxERqSe0XqfzUIASERGpJ7Rep/NQgBIREakntF6n89AYKBEREREHKUCJiNQiDQoWcU3qwhMRqUUaFCzimhSgRERqkQYFi7gmBSgRkVqkQcEirkljoEREREQcpAAlIiIi4iAFKBEREREHKUCJiIiIOMipAtSyZcu44ooriImJwWKxMGfOnCrbbTYbjz32GNHR0fj6+jJ06FB27dpVZZ+jR48yZswYgoKCCAkJYdy4ceTn51fZZ+PGjQwcOBAfHx9iY2N59tlna/uliYiIiBNxqgBVUFBAt27deOONN065/dlnn+XVV19lxowZrFq1Cn9/fxITEykuLrbvM2bMGLZs2cLChQuZO3cuy5Yt44477rBvz83NZdiwYTRv3py1a9fy3HPP8cQTT/Cf//yn1l+fiNk06aOISPVYbDabzewizoXFYuHrr79m5MiRgNH6FBMTw/33388DDzwAQE5ODpGRkcyaNYvRo0ezbds2OnbsyOrVq+nduzcA8+fP57LLLuPAgQPExMTw1ltv8Y9//IOMjAy8vLwAeOSRR5gzZw7bt2+vVm25ubkEBweTk5NDUFBQzb94kVqyfPlydu/eTevWrRkwYIDZ5YiI1ClHvr+dqgXqTPbu3UtGRgZDhw613xYcHEx8fDxJSUkAJCUlERISYg9PAEOHDsXNzY1Vq1bZ97nwwgvt4QkgMTGRHTt2cOzYsVM+d0lJCbm5uVVOUj+oRcUxcXFxtG7dWpM+ioichcsEqIyMDAAiIyOr3B4ZGWnflpGRQURERJXtHh4ehIaGVtnnVI9x4nP82fTp0wkODrafYmNjz/8FSY2oXEYjJSXF7FKcQkxMDAMGDNDEjyIiZ+EyAcpMU6dOJScnx37av3+/2SXJH1y+RcVmg7IiKDwKOQchLwOKsqG81NgmIuJqCg5D+gazq3CdpVyioqIAyMzMJDo62n57ZmYm3bt3t++TlZVV5X7l5eUcPXrUfv+oqCgyMzOr7FN5vXKfP/P29sbb27tGXofULKdfRqOiDLK2QcZGOLYPcg4cP+VnGuGJ0wQlixt4BUJgFATFHD+FxkFkJwhrB54+dflqRETO37rZsPhJ6HkL/OU108pwmQDVsmVLoqKiWLx4sT0w5ebmsmrVKiZMmABAQkIC2dnZrF27ll69egHw008/YbVaiY+Pt+/zj3/8g7KyMjw9PQFYuHAh7dq1o1GjRnX/wqRhKTwKe36CfcuNX1iZW6CipHr3dfMAm9U4gXFekmOcDu84eX+LOzRuDVGdIbYfNO8PER3BTQ3TIlJPWa2w7gPjcrMEU0txqgCVn5/P7t277df37t1LcnIyoaGhNGvWjMmTJ/Ovf/2LNm3a0LJlSx599FFiYmLsR+p16NCB4cOHM378eGbMmEFZWRmTJk1i9OjR9laKG2+8kWnTpjFu3DgefvhhNm/ezCuvvMJLL71kxksWV2ezQdo62LkAdi+Cg2s5qUXJOxiiu0JYWwhuAsGxENzUaFnyCgBPX/DwBXcP4/EqyqCsEMqLoTgX8tIhNw1yDxqnw7sgczMUHTOC1eEdsPlL47l8gqFZf4i7CNpdCo1a1PU7IiINRFpaGikpKcTFxVW/p2DfL3BsL3gHQccra7fAs3CqALVmzRoGDx5svz5lyhQAxo4dy6xZs3jooYcoKCjgjjvuIDs7mwEDBjB//nx8fI53U3z44YdMmjSJiy++GDc3N0aNGsWrr75q3x4cHMyCBQuYOHEivXr1IiwsjMcee6zKXFEi5y17P2z8BDZ8Akd2V90W0QlaDYYmvSC6GzRqWf1WIYsFPLyMExghK7ztyfvZbMZ4qcwtkLYeUldA6ioozoGdPxin+Y8YLVLtLoV2I6BJT+PxRURqQOVBPkD1A9S6/xrnXa4FL/9aqqx6nHYeqPpM80DJKVkrYNu3sPo9o4uusqXJ0w/aXAKtL4HWFxvjlMxQUQ4ZG4zadi2E31eAreL49kYtoev10PU6aNzKnBpFxGU43AJVeBReaAcVpXDHzxDTvcZrcuT7WwGqFihASRWlhZD8ISS9bgwEr9RiIHS/ETpcAd6BppV3WoVHjW7FHd8bXYxlBce3Ne0D3ccYYcrkX4Ei0kCsfMtoGY/uBn9bVitP4cj3t1N14Yk4lZI84z/8qhlQeMS4zTcU+twOPW+GkGbm1nc2fqFGQOp6HZQWwPZ5RpdjyhI4sNo4LXzcCIF9boew1mZXLCKuymaDtbONyz1vMbeWP6gFqhaoBaqBqyiH9R/Akmeg4I9pM0KaQ8Ik6DHG+Vts8jJg42ew5n1jMGelVkOg/90QN1hjpUSkZu1fDe8NNQ6YeWCHccBLLVALlEgdqdKHHx1tjB1a+Cgc+mPdxNA4GPwP6DjSOErOFQRGwQX3GIFwz0/w239g1wLj8p6fILo7DLjP6Jp0cze7WhFxBetmGeedrqq18OQoF/mLLmKOyqNIvIoPEbPkIyNIAPg2gosegd5/PX5EnKtxc4M2Q43T0b1GV+Xa2ZCeDJ+PNeaYGjDFGHjuKuFRROpecS5s/sq43GusubWcQDPmiZyHuJYtGOCzk96rJhrhyd0L+t8D9yRDvztdNzz9WWhLuPT/4L7NcOFDxi/EI7vhm7vgzX7GHz+r1ewqRcQZbf7SmNsurB3ExptdjZ0ClMi5OrKHmAV/o/X2N3ArKzD+Y9/5Kwx7CnxDzK7OHP5hMOQfcN8WuORJY9D8kV3wxW3w9oWw80et0Scijll3wuDxejS+UgFKxFE2m7GUwFsXwO/LjXmchv8f3PbDqSetbIi8A+GCe+HeDTDo78aafJmb4KPrYPYVkL7R7ApFxBmkJRuT/bp5QrfRZldThQKUiCNKC2DOBPh2EpQXQcsL4a4ko7tOA6ZP5hMEgx6GyRuNrk13b2MphrcvhG8mGkf01ZK0tDSWL19OWlparT2HiNSy1e8Y551GGi3c9YgClEh1ZW2Hd4bAho/B4gYXPwY3f6P14qrDL9To2rx7DXQeBdhg/f/g1Z6w7Hkor+aCyQ6oHOCfkpJS448tInWg6Bhs+sK43Od2c2s5BQUokerY+Dm8M9iYniAgCsZ+BwPvr/4adWIIaQbXvA/jFkKT3sbs5j89ZXSHpiyt0aeKi4ujdevWxMXF1ejjikgdWf+hsSh6ZJd6NXi8kv76i5yJzQZLpsNXtxtHgcQNhjuXQ4sBZlfm3GL7wu2L4Op3wD/CGGj+3yvhi3E11q0XExPDgAEDqr9IqYjUH1YrrH7XuNxnXL0aPF5JAUrkdMpL4Ks74Od/G9cvuBdu+hICws2ty1VYLMYyMZNWQ9+/Gd2im7+A13obfzg17YFL0Fg0OScpPxkrHXgHG38n6iEFKJFTKThitIhs+gzcPOCKV43D8jVQvOb5hsBlz8L4nyCmJ5Tmwbz7YdYIOLzb7OrkPGksmpyT3/5ofep+Y71d/koBSuTPju0z1lxKTTJ+/Yz5ol7NfuuyYnoY3XqXPgue/pC6AmZcAMtfNtYXFKeksWjisGO/w875xuU+48yt5QwUoEROdHg3vH8pHE0xBjyPWwCtBptdVcPh5g7xfzOmhogbbAwgXfQ4vHuxcRSkOB2NRZPqqNLVu3YmYIO4QRDWxuzSTksBSqRS5laYeSnkpRlLBoxbCBHtza6qYWrUHG7+Gka+BT4hxvp6b18IK17X2CgRF1TZ1bt313ZY91/jxno4dcGJFKBEANI3GGNuCrKMQ2ZvnQeBUWZX1bBZLMb4h7tWQuuhUFECC/4Bsy83ullFxGVUdvV2ZCcUHoGgJtD2UrPLOiMFKJEDa43lRYqOGoOYx36rI+3qk6BoYxza5S8bY6N+/9WYN2r9h1pXT8RFxMTEMOCCC2i04xPjhl63gbuHuUWdhQKUNGwZm+CDq6A4B5olwC3fGLNmS/1isUDv22DCr8a/U2k+fHMXfPFXKMo2uzoRqQmpSca6dx4+xv/3ek4BShquI3vgg6uhJAdi+xlzPPkEmV2VnEloS6N79eLHwOIOW76CGQPg9ySzKxOR85X0hnHe9fp6t+7dqShAScOUmwb/HXl8zNONn9bbuUaqq8FMWOjmbiyjM26BsQ5hzn6YdZkxY7y1wuzqRORcHE2B7fOMy/3uMreWalKAkoan4IgRnnJSIbQV3PyVMZmjk2twExY27Q1/+wW63QA2qzFj/H+vrLGlYESkDq16G7AZB4w4ydHPClDSsJTkw4fXwOEdEBgDt8yBgAizq6oRDXLCQp8guGoGXPUfY4D5vl+MLr09S8yuTESqqygb1n1gXE6YaGopjlCAkobDWgFfjYe0deAbaoSnkGZmV1VjGvSEhd2uh7/9DBGdoOCQcWDAT0+rS0/EGaz7L5QVQERHYwJdJ6EAJQ3Hosdhx/fg7g03fgbh7cyuSGpSWBsYvxh63QrYYNmz8MFIyD9kcmEicloV5X903wH9JhhH3DoJBShpGNbOhhWvGZdHvgmxfcytR2qHpy9c8QqMes/o0tu7zJjBfP9vZlcmIqey7RvIPQB+YdDlOrOrcYgClLi+vctg3hTj8qCp0OUac+uR2tflGhj/E4S1NZbmmXmp8StXE2+K1B82GyS9aVzuczt4+phbj4MUoMS1HdkDn94M1nLofA1c9LDZFUldiWhvhKiOI41//x8egi9vh9ICsysTEYDfV8DBNcawij7jzK7GYQpQ4rpK8uHj0VCcDU16w5WvO1X/uiurszmrvAPh2lmQOB3cPGDzF/BeotbSE6kPlr9onHe/0SmPhlaAEtdks8F398DhncZ0BaM/MsbHSL1Qp3NWWSyQcBeM/Q78wyFzE/xnEOz5qfafW0ROLX0j7F4EFje44B6zqzknClDimla/C5u/NFodrp0JgZFmVyQnMGXOqub94Y6fjQWji47B/0bBr69oXJSIGZa/ZJx3uhpCnXPuOgUocT0H1sL8qcblS56EZv3MrUdOYtqcVcFN4LYfoPtNxuzlCx8zxkWVFdVtHSIN2ZE9sHWOcXnAZDMrOS8KUOJaCo/C52PBWgYd/uI0aypJHfL0McbDXfb88XFR7w+HnINmVybSMPz6ivEDps0wiOpidjXnzKUC1BNPPIHFYqlyat/++Jo6xcXFTJw4kcaNGxMQEMCoUaPIzMys8hipqamMGDECPz8/IiIiePDBBykvL6/rlyLnwmqFr+4wFpcNbQVXvqFB43JqFgv0HQ+3fGPMSp+ebIyL0nxRIrUrNx02fGxcHjDF3FrOk4fZBdS0Tp06sWjRIvt1D4/jL/G+++5j3rx5fP755wQHBzNp0iSuvvpqfv31VwAqKioYMWIEUVFRrFixgvT0dG655RY8PT155pln6vy1iIOSXofdC8HDB677r7FOWj1XVmHlUF4JmbnFZOYa50fyS8grKSevuJy84jLyS8opq7BRYT1+sljAy90NT3c3PD3c8PZwI9DHgyAfT4J8PAjy9STU34vwQG8iAn0ID/SmkZ8nFgXKqloMgDuWwMc3QtYWmDUCLn8ZeowxuzIR15T0OlSUQrMEaJ5gdjXnxeUClIeHB1FRUSfdnpOTw3vvvcdHH33EkCFDAJg5cyYdOnRg5cqV9OvXjwULFrB161YWLVpEZGQk3bt356mnnuLhhx/miSeewMvLq65fjlRXxiZY/KRx+dL/g6jO5tbzJ8VlFWzPyGNrWi4ph/JJOVzA3sMFpB4tpMJaN4OYvTzcaBriS9NQP2Ib+RIb6kfLMH9ahQfQvLEfnu4u1SBdfY1awLgF8PXfYPtc+OYuOLQdhj4Bbu5mVyfiOgqPwpqZxmUnb30CFwxQu3btIiYmBh8fHxISEpg+fTrNmjVj7dq1lJWVMXToUPu+7du3p1mzZiQlJdGvXz+SkpLo0qULkZHHj9hKTExkwoQJbNmyhR49epzyOUtKSigpKbFfz83Nrb0XKCcrK4IvxxvjntqNgJ5jza6I/UcLSdpzhPX7j7HxQA47MvIoP01Q8nCzEBnkQ0SQN1FBPjQO8CLIx5NAH08CfDwI9PbA090NdzcLHm4W3N0s2LBRWm6jtMJKWbmV4vIK8ovLyS0uI7eonJyiMo4WlJKVV0xWXgnZhWWUlltJOVxAyuGTJ5L0cLPQrLEfbSIC6BAdRIfoIDpGB9G0kW/DaLXyDoDrPoCl04019Fa8Cod3wah3jLmkROT8/fYfY9HgyC7Q5hKzqzlvLhWg4uPjmTVrFu3atSM9PZ1p06YxcOBANm/eTEZGBl5eXoSEhFS5T2RkJBkZGQBkZGRUCU+V2yu3nc706dOZNm1azb4Yqb5F0+DQNvCPgL+8asq4p+zCUpbuOMSKPYdZsecIB46dfFRXY38vOjUJpnV4AHHh/sSF+dMy3J/IQB/c3Gq35pLyCjJzSjhwrJD9xwo5cKyI1KOFpBwqYM+hfApLK0g5VEDKoQJ+3HJ8XGCgjwddmgTTtWkI3WON8+hgH9cMVW5uMOQfxiLTc+6CnT8Yk27e+AmENDO7OhHnVpR9fNmWgfe5xPhUlwpQl156qf1y165diY+Pp3nz5nz22Wf4+tbeJIpTp05lypTjzZG5ubnExsbW2vPJCfb8BKveMi5f+Qb4h9XZU6fnFLFgSyY/bslg1d6jVbriPNwsdI8NoU/LULo1DaZL0xBiTAwe3h7uNGvsR7PGfidts9lsZOQWszsrnx0ZeWxLz2Nbei67svLIKy5nxZ4jrNhzxL5/RKA3fVqE0qt5I3q3aETH6CA8XKn7r8s1RrfexzcY46LeGWJMxBrb1+zKRJzXyregJAfCOxjLK7kAlwpQfxYSEkLbtm3ZvXs3l1xyCaWlpWRnZ1dphcrMzLSPmYqKiuK336oehVN5lN6pxlVV8vb2xtvbu+ZfgJxZ4VGjpQCMhSjbDqv1p8wrLmPexnS+WHuANb8fq7KtfVQgF7UNJ6FVY/q0CMXf2zn+e1ksFqKDfYkO9mVgm3D77WUVVnZl5rPxQDYbDmSzYX8OOzLzyMorYd6mdOZtSgfAz8ud3i1C6RcXSkJcY7o0CXb+QNW0tzG4/KPRxszlsy6HkW9qIWqRc1F0DFb+0fo06GGXGVvoHH/hz1F+fj579uzh5ptvplevXnh6erJ48WJGjRoFwI4dO0hNTSUhwTgSICEhgaeffpqsrCwiIox1eRYuXEhQUBAdO3Y07XXIacy9D/LSoXEbuOSpWnsam81GUsoRPl9zgB82p1NcZgWMFuhezRqR2CmKYZ0iad7Yv9ZqMIOnuxsdY4LoGBPE6L5GF1ZRaQUbDmSz9vdjrNl3lDW/HyOvuJxlOw+xbOchAPy93ImPa8yA1mEMbBNG64gA5+zyC24Kf50PX42HHd/Dl+PgaApc+KBLdD+I1JmkN6EkFyI6QYcrza6mxlhsNtdZx+CBBx7giiuuoHnz5qSlpfH444+TnJzM1q1bCQ8PZ8KECXz//ffMmjWLoKAg7r77bgBWrFgBGNMYdO/enZiYGJ599lkyMjK4+eabuf322x2axiA3N5fg4GBycnIICqr/h9I7pW3fwac3gcUdxi+GmFMP8D8fxWUVfLshjfeX72V7Rp799lbh/lzbO5arejQhMsinxp/XmVitNrZn5LFq7xGS9hxh1d6j5BSVVdknMsibAa3DGdw+nIGtwwn28zSp2nNkrTBmLE963bje9Xr4y2vgoVZnkbMqPAovd4XSPONAjY5/MbuiM3Lk+9ulWqAOHDjADTfcwJEjRwgPD2fAgAGsXLmS8HCjW+Kll17Czc2NUaNGUVJSQmJiIm+++ab9/u7u7sydO5cJEyaQkJCAv78/Y8eO5cknnzTrJcmpFB2Defcbly+4t8bD09GCUj5I+p0PVu7jcH4pYHRTjezRhGt7NaV7bIhztqjUAjc3i72V6rYLWmK12tiWkcvyXYdZvvswv+09SmZuCV+uO8CX6w7g7mahZ7MQBrWLYEj7CNpHBdb/99LNHRKfhsatjc/dxk8hOxWu/xD8G5tdnUj9lvS6EZ4iu0D7y82upka5VAtUfaEWqFr2zSRY/4HxhXbnr8bSHDUgp6iMd39J4f3leykorQAgOtiHW/u3YHTfZgT7OlnLyRmkpaWRkpJCXFxcra5HV1xWwZp9x/h5ZxZLdxxiV1Z+le1NQny5uEMEF3eIpF9cKN4e9XxsxJ4l8NlYYzBsaByM+QIatzK7KpH6qeAIvNIVSvONHxwd6n+AcuT72+EANXbsWMaNG8eFF154XkW6MgWoWpTyM/z3jybg236A5v3P+yHzS8qZuXwv7/ySQm6xsWxPx+gg7hzUiks7RznFBJOOBqLly5eze/duWrduzYABA+qgQsOBY4X8vPMQS7ZnsXz3Yft4MoAAbw8GtQtnWKcoBrULJ8inngbWrO3w0bVGK5RvI+MIvRr4HIq4nEVPwPKXIKor/G2ZU4wdrNUuvJycHIYOHUrz5s257bbbGDt2LE2aNDnnYkWqrbQQvrvHuNx73Hl/aVmtNj5fu59n5+/gSIHRVdc2MoApl7RlWMeoWp+bqSalpKSwe/dugGoFqLi4uCrndaVpIz/GxDdnTHxzikorWLHnMIu2ZbF4WyZZeSXM3ZjO3I3peLpbSGgVxqWdoxjWMZLGAfVovFFEe7h9MXw8Gg6uhf9eCVe+CV2vNbsykfoj/xCs+o9xefDfnSI8OeqcuvAOHTrEBx98wOzZs9m6dStDhw5l3LhxXHnllXh61tNfjXVILVC15Md/GP3pQU3grpXntdbd2t+P8sS3W9l0MAeAuDB/7h3ahsu7xuDuRMGpUl11ydUWq9XGxoM5/LglgwVbMthz6Phs6W4WiG/ZmEu7RDG8UxQR9WXgfmkhfH2HcUADwOB/woUPuOQXhYjD5j0Aq9+BmJ4w/ien+X9Rq114f7Zu3TpmzpzJu+++S0BAADfddBN33XUXbdq0OZ+HdWoKULUgbb0xoaHNCjd+Bm0Tz+lhDuWVMP37bXy1/iAAgd4eTL6kLbckNHeKrrqGYndWPj9uyWD+5gx7yAXjb3CfFqFc3jWa4Z2jiAg0OUxZrbDoMVjxmnG9x03GYsTu+iEpDdiRPfBGX7CWw9i50HKg2RVVW50FqPT0dP773/8yc+ZMDhw4wKhRozh48CA///wzzz77LPfdd9+5PrRTU4CqYVYrvHcJHFwDnUfBNe87/BA2m41vN6Tx+LdbyC4sw2KB63rF8uDwdoTVp+4hOcn+o4XM35zB95vTWZ+abb/dYoG+LUK5olsMl3aOMreb77d34IeHjIAfNxiumw0+webVI2Kmz8bC1jnQZhiM+dzsahxSqwGqrKyMb7/9lpkzZ7JgwQK6du3K7bffzo033mh/sq+//pq//vWvHDt27CyP5poUoGrYuv/Ct3eDVyDcvQYCTz8r/Klk5RbzjzmbWbjVmFW+Q3QQ06/uQvfYEIcex9m7yVzBwewifvhjFvQTw5S7m4ULWodxRddohnWKMueIyZ0/wue3GYulRnSCMZ8Zk3GKNCQH1sK7QwAL3LkcojqbXZFDajVAhYWFYbVaueGGGxg/fjzdu3c/aZ/s7Gx69OjB3r17HSrcVShA1aDCo/B6byg8AsOehv6THLr7N8kHeeybLeQUleHpbmHS4DbcNbjVOXXXmXXkmpzagWOFfL8pne82pFfp5vNyd2Nw+3Cu7N6EIe0j8PGsw6kR0pLho+shPwMCoowQFd2t7p5fxEw2G8y+Avb9At1uhKveMrsih9VqgPrggw+49tpr8fGpJwM56yEFqBo0735Y/a6xAOWdv1R7bElRaQWPf7uZz9YcAKBzkyCeu6YbHaLP/d9DLVD1197DBczdkMa3G9KqzDUV4O3BsE6RXNm9CRe0alw3a/Rl74eProOsreAVANfOgjaX1P7zipht5wJjig93b7h7LYTEml2Rw+p0ELmcTAGqhqRvgP8MMsaVODAQcWdmHhM/XMeurHwsFrh7SBvuHtJag8QbAJvNWFrm2w1pfJucxsHsIvu2sABvLu8azcgeTejWNLh2Z0AvzoFPb4a9PxvLDV3+IvS6tfaeT8Rs1gqYMRCytkD/u2HYv8yu6JwoQJlMAaoGWK3wfiIc+M2hgeOfrdnPY99sprjMSnigN69c353+rcNquVipj6xWG+tSj/FNchpzN6ZxrPD4Gn0tw/wZ2b0JI3vE1N4i0OWl8N29sOEj4/rA+2HIo05zOLeIQ5I/gjkTjIMn7kkGv1CzKzonClAmU4CqAes/hG/uMrpAJq2GoDN3mZVVWJn23Rb+tzIVgIFtwnjxuu6EB+oIOzE+H7/sOsSc9Wks2JpRZQb0Hs1CuKpHEy7vGkOov1fNPrHNBkv/DT//27je5Vq48g0tRCyupSQPXuttjP0bOg0GTDa7onOmAGUyBajzVJIHr/aEgiy45EljweAzyC4s5a4P17FizxEsFpgytC0TB7d2qpnEpe7kl5SzYEsGX68/yK+7D2P94y+gh5uFQe0iuKpHEy7uUMODz9d/aMyiby2H5gNg9P+MZWBEXEHlki2NWsLEVU79A0EBymQKUOfpp6dh2bPGYq13rQKP07cK7M7K4/bZa9h3pBB/L3deHt2DSzpG1mGx4syycov5dkMac5IPsvlgrv32QB8PRnSJ5qoeTejTIrRmwvien+DTW4yV6cPaGfPjNGp+/o8rYqYje+DNflBRCqM/hvaXmV3ReVGAMpkC1HnITTNan8qL4LoPoONfTrvrsp2HmPjhOvJKymnayJd3x/amfZTebzk3uzLz+Hr9Qb750+DzJiG+XNWjCSN7NKF1RMD5PUnGZvjwWshLA/8IY5qDmB7nWbnUNw3qiN2PRsPOH6DVELjpK6cf46cAZTIFqPMwZyIk/w9i+8Ff55/2P+M3yQe5/7MNlFtt9G0Ryls39axfC86K07Jabazae5Q56w/y/aZ08krK7du6NQ3mqh5NuKJbzLl/3nIOGtMcZG4GTz+4Zia0G15D1Ut90GDmjNu9CP43Ctw8YMIKCG9ndkXnTQHKZApQ5yhjk3EYLDZjtfumvU+523+T9vH4t1uw2eAv3WJ4/tpueHloigKpecVlFSzalslX6w7y885DVPwxYMrDzcJFbcO5qmcThnaIdHy8VHEufHYLpCwBixtc9hz0ub0WXoGYoUG0QFWUwVv94fBO6DcRhj9jdkU1QgHKZApQ58Bmgw9GQspS6HQ1XDvzFLvYeHnRLl5ZvAuAsQnNefyKThosLnXicH4J321I4+v1B9l44PjM54HeHlzWJZqrejahryPjpSrK4LvJRosrQP97jCOY3PRjQJxA0hvw49/BL8yYNNM3xOyKaoQClMkUoM7BrkXw4Shw9zKmLWjUospmq9XGtO+2MDvpdwAmD23DvRe3qd3JEEVOY3eWMV5qzvqTx0td2T2Gq3s2oXVE4NkfyGaDZc/Dkj8mHex0FYycAZ5a6UHqsbxMeL0PlOTAFa9Cr7FmV1RjFKBMpgDloIpymDEADm2DhEmQ+HSVzTabjX/O2cyHq1KxWGDaXzpxS0ILc2oVOYHVauO3fUf5et3J46U6NwliZPcm/KVbDBFBZwlEGz6FbyaCtcwY/zf6I/BvXMvVi5yjz2+DLV8ZB0Dcvhjc6nC9yVqmAGUyBSgHrf+f8eXhEwL3JleZH8dms/H4t1v4b9LvWCzwwrXduLqnVriX+qe4rILF27L4ev0Blu44RPkf46XcLHBB6zCu6tGExE5R+Ht7nPoB9i6DT24yftWHxsGYL6Bxqzp8BSLVsGshfHiNsUTRHUtcbrFsBSiTKUA5oLzEmME2JxUueQouuMe+yWaz8eTcrcz8dR8WCzx3TTeu6aXwJPXf0YJS5m5MY876g6xLzbbf7uPpxrCOUYzsEcPANuEnr8+Ytd2Y5iAnFXxD4YaPoVm/86qlQQxolrpRWgBv9DM+n6foLXAFClAmU4BywG/vwPcPQECU0frk6QsY4enpedt4d/leAJ4d1ZXr+jjfyt4ivx8pYM56Y7LOvYcL7LeH+nsxoks0I3vE0LNZo+Pj+fIy4ePrIW29sar9VTOg89Xn/PwN5pB6qX0//gOSXofgZjBxJXjV0jqSJlKAMpkCVDWVFcEr3Y31ky57HvqOt296ccEOXv1pNwDTr+7CDX2bmVSkNCS12Vpjs9nYcCCHOesPMndjGofzS+3bmoT48pfuMVzZPcaYDLa0AL4cDzvmGTtc/DgMuO+cJilUC5TUiPQN8J/BYKuAGz+HtsPMrqhWKECZTAGqmla8Dgv+YfyauXuNff2kD5L28eg3WwB4amRnbu6n5S6kbtRVa015hZVf9xzhm/UH+XFLBgWlFfZtbSMDuKJrDFd0iaTF2mdg1VvGhh43w+UvgbtnrdUlckrWCnj3YqNVtNNVcO0ssyuqNQpQJlOAqoaSPHilGxQegb+8Dj1vBmD+5nQmfLgOmw3uG9qWe4e2MblQaUjMaK2pHHz+TfJBlu44RGmF1b6tW9NgHg5dRsKu57DYrNDyIrjuvy4z5444iaQ34cep4B1sTDMT6LrrjSpAmUwBqhqWPQc//QtCW8HE38Ddg1UpR7j5/d8oLbdyY3wznh7ZWfM8SYOSU1TGj1sy+G5DGr/uPswfB/Ix2G09b3q/hq+tmPLQtnjc/PlJc6WJ1IrDu4xpZsqLjRbQ3n81u6JapQBlMgWosyg6Bi93Mw7XHvUedLmG7Rm5XDsjibzicoZ1jOStm3rhrhnGpQE7lFfCD5vT+W5DGqv3HaOjZR/veT1PtOUoOW7BJPV5jV4DhhMeqDUg6yunH39WUQ7vD4ODayFuMNz8tdMvFnw2jnx/n2ZCEpFatOJ1IzxFdIROV5OVV8xtM1eTV1xO7+aNePWGHgpP0uCFB3pzS0ILbkloQXpOEfM2pvOP9U2ZcvgxOrOPwSvH8fDyO8hs/hcu6xpNYqdIIgI1g3l9kpKSwu7dxsEwThmgfn3JCE/ewXDlGy4fnhylFqhaoBaoMyg8Ci93gdJ8uP5/lLS5jNH/Wcn61Gxahfvz5YT+hPh5mV2lSL11IPMwZZ/fTsvDSwB4pfxqXiofhcVioU/zUIZ3jmJ45yhiQnxNrlScugUqfSO8M8SYHf+qt6HbaLMrqhPqwjOZAtQZLP03LJ0OkV2w/W0ZD365iS/WHiDIx4NvJg2gZZjrzStSHzn1H3YBqxUWPwG/vgLAL94XcnvOXynh+I+PbrEhJHaKZHinKOLCA0wqVJxSeQn8ZxBkbYX2l8P1/2swrU/qwpP6qSQPVv5xSPbAKbz36z6+WHsANwu8MaanwlMdcvquhYbOzQ0ueRIat4a59zGwZBmbmufyZdtn+WpXBWt+P8aG/dls2J/Ns/N30CYigMROUVzSMZKuTYN1cIac2ZJnjPDkFwaXv9xgwpOjFKCk7qx+D4qzoXEbfvbozzPfrwXgnyM6MrBNuLm1NTBxcXFVzsVJ9bwFGrWEz27GKzOZGwrHcsMNH5MV0JOF2zKZvzmDpD1H2JWVz66s3by+ZDdRQT4M7RjBJR2j6BcXireH6ywEKzVg7y+w4lXj8hUvQ4D+Np+OuvBqgbrwTqG0EF7pCgWHOHTxywxZHENecTnX947l36O66BexyPk4mgIfjYbDO8DDF656y5jwEGNqhCXbs1iwNYOfdxyqMmmnv5c7F7YN5+IOkQxuF07jAB3R16DlHzKmLMjPgO5jYOSbZldU5zQGqga88cYbPPfcc2RkZNCtWzdee+01+vbtW637KkCdwsoZMP9hrMHNuIJX2JJZRK/mjfhofLx+AYvUhOIc+GIc7F5oXL/oYbjoEaO7r3KXsgqS9hxhwdZMFm3L5FBeiX2bxQLdY0MY0i6Cwe0j6BQTpB82DYnVCh9eA3sWQ1g7uGOJS651dzYKUOfp008/5ZZbbmHGjBnEx8fz8ssv8/nnn7Njxw4iIiLOen8FqD8pL4FXe0DuQb5ucj/37elFY38vvr93IJFBOuxapMZYK2DhY8aCr2AMAL5qBngHnryr1camgzks3pbJom1ZbE3PrbI9ItCbQe3CGdQuggtahxHsqyVkXNovL8LiaUYL5vifILKj2RWZQgHqPMXHx9OnTx9ef934I2S1WomNjeXuu+/mkUceOev9FaD+ZO0s+O5einwi6J79LKUWLz74azwD2oTVeSk6+kwahPUfwtzJUFEK4R3gho8g9Mzj3dKyi1i64xA/bc/i192HKSo73tXn7mahR2wIF7UNZ2DbcLo0CdZcba4kdSXMvMxYKPgvrxlj6xooHYV3HkpLS1m7di1Tp0613+bm5sbQoUNJSkoysTInVVEOy18C4JXC4ZTgxT1D2pgSnkBHn0kD0WMMhLeDT8bAoW3wn8HGArCtBp/2LjEhvtwY34wb45tRUl7BqpSj/LzzED/vPMTurHzW/H6MNb8f44WFOwn29aR/q8YMaBPGwNbhNGvsV3evTWpW4VH44q9GeOpyrbFodT1TWm7l192HiY8Lxc+r/sSW+lNJPXH48GEqKiqIjKy6WGJkZCTbt28/5X1KSkooKTk+liA3N/eU+zVIW76CY/vItgQxu3QQ/Vs15t6LzVsgWEefSYPRtDfcsRQ+vQkOroH/XQ1Dn4D+95z1sHRvD2Nw+YVtw3kUOHCskGU7D/PzzixW7DlCTlEZP2zO4IfNGcZTNfKlf6vG9G8VRv9WjYlQ17xzsFbAV+Mh96CxLunlL9WbKQtKy60s332IeRszWLg1g9zict4c05PLukSbXZqdAlQNmD59OtOmTTO7jPrHZrMfDvtuaSL+AcG8PLq7qU3/MTExanmShiMoGm6dB/Puh+T/GeOj0tbDX14H7+pPrtm0kZ+9daq8wsrGgzks33WYX3YdYn1qNgeOFfHZmgN8tuYAAHFh/sTHNaZfXCjxLRsTFaxAVS8tehx2LzLGPV0765Rj5epSQUk5v+w6ZBzksDWT3OJy+7aIQG8KSsrPcO+6pzFQf1JaWoqfnx9ffPEFI0eOtN8+duxYsrOz+eabb066z6laoGJjYzUGKmUp/PdKimxe9C99jTduH0r/VuZ03Yk0aDYbrHkPfnjEWJojvAOM/hAatzrvcYEFJeWs3neUpD1HWLHnCJvTcvjzt0qzUD/6tAilT4tG9GkZSlyYv47wM9uGT+DrvxmXr3kfOo8ypYzKsXcLt2bw654jlJZb7dsiAr25tHMUl3WJpneL0Dr58a0xUOfBy8uLXr16sXjxYnuAslqtLF68mEmTJp3yPt7e3nh7a/6UPytd9gpewGcVF3Hdhd0UnkTMYrFAn9shsgt8dssf46IGwVVvk3I46LzGBfp7ezCoXQSD2hlHKOcUlvHbvqOsSjnCqr1H2ZKWQ+rRQlKPFvLlOqOFqrG/Fz2aNaJn8xB6NmtE16bB9Wpsi8s7uBa+vce4PPD+Og1PJeUVrNl3jJ93HmLpjix2ZuZX2d4s1I9LOkYyrGNknYWmc6UWqFP49NNPGTt2LG+//TZ9+/bl5Zdf5rPPPmP79u0njY06FR2FB7bMLVje6o/VZmFc0NvMuPcazfckUh/kZcBnY2H/SuNq9/FsCL2CuNZtaqV7O7e4jHW/H2P1vqOs3neM5P3ZVVoZwDjKr31UIN1iQ+jeNIRusSG0jgio11+eTisvwwjPeenQ9lIY/VGVucJqWnmFlU0Hc1ix5whJe46wet9RSk7493f7Y/6xiztEcknHSNpEBJjaOqlpDGrA66+/bp9Is3v37rz66qvEx8dX674KUJDy7ljiDsxhvrUvLe76kvZRDfN9EKmXykuN8VCr/libssVAGPUeBJ79B+L5KimvYPPBXNanHmPt78dYl3qMzNySk/bz83KnY3QQnZsE06VJMJ2bBNMq3B8P99r7snd5ZUUw+wo4sBrC28O4heBTs3+bi0orSN6fzZp9R1n9+zHW/X6M/D+NXQoP9OaituHGtBhtwgjx8zrNo9U9BSiTNfQAdSA1hcj3euNpqWBOr1mMvOIqs0sSkVPZ/BV8ezeU5kNAJFwzE1pcUKcl2Gw20nKK2bg/m+QDxgLImw7kVFlyppKXhxvtIgPpEB1Ix+gg2kcH0TYykFD/+vMFXG9ZK4zu2+1zwSfEmCyzcavze0irjZTDBWzYn03y/mw2HMhmW3ouZRVVY0WQjwcJJxyl2drkVqYzUYAyWUMOUBVWG3Oe/xujCj9lu2dH2kxdoWZ4kfrs8C749GZjXJTFHQZPhQFTwM28LvcKq42UQ/lsTsth04FcNh/MYUvaqUMVQFiAN+2iAmgTEUjriABahQfQOiKAsACvevtFXadsNph7H6ydCe7ecPNX0GKAQw9RXFbB7qx8tqbnsjXtj1N67kmtSwCRQd5/HDQQSq/mjegQHeQ03wMKUCZryAFq1pLNjFw6jBBLAYdHvEdYn2vMLklEzqa0wJjqYMPHxvWWF8HV79RJl151Wa02Uo8Wsi09l23pxpf3jsw89h8tOu19gnw8aBkeQIvGfrRo7E/LMH+aNfYjtpFfwwpXS/8Plj4DWOC62dDxytPumldcxt7DBew9XMDurHx2ZuaxKzOffUcKsJ4iLfh4utGlSTDdmobQvVkI3ZqG0LSRr9O+twpQJmuoAWr/0UJmvzyVf7rNIs+vGYEPJJv6K1ZEHJT8kRGkygrBPxyuehtaX2x2VWdUUFLOrqx8dmbksTMzjz2H8tlzqID9xwpPmk7hRL6e7jRt5EtsqB8xIT7EhPgSE+xLdLAP0cG+RAR54+PpAn+//lhKC4ARL1Dc/TYyc4tJyy5m/7FCDhwr4sDRQvYfK2Tv4UIO5588Hq1SsK8nHaOD6BgTRKcY47xVeACeLjQuTQHKZA0xQNlsNsa+l8RTqWNp7paF9bIXcOt7u9lliYijDu2Az2+DrC3G9QvuhcH/BA/nGmdUXFbB3sMF7DtcwL4jhew7XMDeIwWkHikkM6/4jOGqUqCPBxGB3kQE+tA4wIvG/l40DvAm1N+LRn5eBPt6EuLnSbCvJ0E+nvh7u9f5IPfyCit5xeXkFJWRXVRGdmEp2YVlHM4voVHqQq7a9QhuWPnI53qeL7uWowWlZ33MsABv4sL8iQv3p01kIO0iA2kbGUB4oLcpLUt1uYap5oGSOvf1+oN4piyiuVcWFd4huHe/0eySRORchLeD8Yvhx7/Dmvfh11eMSXGvfhfC25pdXbX5eLrTITqIDtEnfwmWlFcYLTB/tLykZxeTllNEenYx6TlFZOQWU1xmBJO84nL2HCpw4HndCPD2wN/bA19Pd7w93fHxcMPH0x0vDzc83S14uLnh4W7Bw82CBYt99RSLBaxWKLfaKLdajfMKK8VlVkrKKygpNy4XlJRTUFJOfkl5lSkBTjTUbS1ver6Mm8XKJ+WD+Hv2X4BSe43Rwb40beRL00Z+xIYa5y0b+9MizI9AH0+H3+/aVF/XMFWAkvN2OL+EJ+du5VX3BQC497oZvLS4qIjT8vQ11kVrNcQ4Si99A7x9ISQ+Db3/Wm/WSztX3h7utAwzxkSdis1mI6+knKzcErJyi8nKK+FIQSlHC0o4kl/KkYJScgrLyC4qJaeojJyiMorLjCBTXGaluKyUw/lnb+mpSQHeHvYWsSGWNdx75BU8qGBX+DDcev8fM0MCiAryITrYh2BfT6cao1Rf1zBVF14taGhdePd+sp7NG1az2PtBbFiw3JsMjVqYXZaI1ITcdJgzAVKWGNfbDocrXq1XA8zrg9Jyq71VKP+PFiIjTFVQVFZBcVkFpRVWyits9pal8j9GZVd+Ddts4OZmtEy5/3Hu4W60Xnl7uOH9R0uWv7c7/t4e+Ht5EODtQYCPx/FxSNu/N6YrsJZBp6uNgwHc1VZSXerCkzqzZEcW3ySnMc1zIQCWdpcqPIm4kqBouOkrWDXDWHx253x4Mx4ue95YAsSJWjJqk5eHG14eXjQyc04qhac65TpD56XOFZdV8Pg3WwigkNGey40b+95hblEiUvPc3CDhLrhjKUR1haJj8OU4+HwsFBw2uzoB2PgZfHazwlMdUoCSc/bOshRSjxZym38S3tZCCGsLcYPMLktEaktkJ2MG60FTwc0Dtn4Db8QbM5prNIg5bDZY/jJ8NR6s5dDlWoWnOqIAJefkwLFC3li6GwtW/ua72Lix7x1qzhdxde6eMOgRuH0xRHSCwsPwxW3w8WjIOWB2dQ2LtQLmP2J0rQIkTIKr/qPwVEcUoOScPD1vG8VlVsbH/E5A/j7wCoRuo80uS0TqSkx3uGMJXPQIuHkaY6PeiIdVbxtf7FK7yoqN4LpqhnF92NPGUZJu+lqvK3qnxWG/7DrED5szcHezcE/gH0fm9BgD3oHmFiYidcvD21g7787lEBtvLEr8w0Pw3jBISza7OteVmwazLze6UN29YNR70H+S2VU1OApQLiYtLY3ly5eTlpZWK49fWm7l8W+NGYrv7elJwO9/dN/1GV8rzyciTiCiPdw2H0a8AN5BcHAN/GeQsYBt4VGzq3Mt+5Ybc3IdWA0+wXDTl9BFa46aQQHKxVTO2JqSknLG/c41aM38dS8phwoIC/Dib/4/AzZodTGEtT6PqkXE6bm5QZ/bYeJvxkBmbMZM5q/1gjUz1a13vmw2SHoDZv8FCg5BZBe442doeaHZlTVYClAuJi4ujtatW591xtbqBq0THcor4dXFuwB4ZFgrvDf9sXJ7n3HnXK+IuJigaBj1Ltw6DyI6QtFRmDsZ/nMR7FlidnXOqTgHvvirsbyOrQK6Xg/jFkBoS7Mra9A0VN/FxMTEVGutoHOZGv/lRTspKK2gW9NgrvZNNo6+CYyGNonnWq6IuKoWA+Bvv8Dqd2HJM5CxCT4YCa0vgUuehMiOZlfoHFKWwpyJkHvAmDoicTr0Ha8jnusBBagGqrpBq9LurHw+Wb0fgL9f1gG3X/7P2NDjZh0yKyKn5u4B/e40uvSWPWuEqd0LYc9i6H4jXPQwhDQzu8r6qbQQFj0Bv71tXG/UEq56G5rFm1qWHKcuPKmWf/+wnQqrjaEdIokPzoa9ywAL9LzZ7NJEpL7zbwyX/p8xPqrjlWCzwvr/was94bvJkL3f7Arrl9+T4O2Bx8NT73HGkY4KT/WKApSc1cqUIyzalom7m4VHLm0Pa2cZG1oP1a9HEam+xq3guv/CuIXQ8iJj2ZG1M+HVHjB3ymmDVG0fXVxv5KbBl+Nh5nA4shsCY4x1CC9/EbwDzK5O/kQBSs7IarXxzPfbALihbyytQz0h+UNjY+/bTKxMxHU0mIBQKbYvjP0WbvsBWgw0gtSa9+CVbkaASN9QZfdzOejFqZSXwPKX4LXesOkzjNb9sXDXCmh9sdnVyWlo8Iqc0Xcb09h4IAd/L3fuvbgtbJ8LhUc0eFykBlUGBMChsYlOr3l/uHUu7P3FGCO1d5kRIDZ9ZrRQ9b8HWg05p4NenEJFufFaf34Wju01bmvaFy57FmJ6mFubnJUClJxWSXkFz/24A4A7L2pFeKD38e47DR4XqTEuGxCqq+VA45SWDCtegy1fw96fjVNIc2J6jSWm+00QGGl2pTWjvBQ2fgK/vADH9hm3BUQaRyd2uU7LsTgJi82mJbRrWm5uLsHBweTk5BAUFGR2OefsveV7eWruViKDvFn6wGB88/bBaz0BC0zeqPFPIlI7slNh5Vuw/kMoyTFuc/OA9iOg+xiIGwweXubWeC4Kj8KGj2HlDMhJBaDCJxT3Afcak5BqnJPpHPn+VhOCnFJhaTlvLTW6FCYPbYuvl/vx1qc2lyg8iUjtCWkGw6fDkEeN1qi1M42lS7Z+Y5x8G0GHv0DnUcZ8U27uJz1EWloaKSkpxMXFmdstarPB7yuMv59bv4GKEgBKvRqR7H8R5d1vpv+AoebVJ+dMAUpOafaK3zmcX0qzUD+u6dUUKsog+SNjY69bTa1NRBoILz9jofIeYyBjM6z/wAhU+ZmwbrZx8g83jghuPRRaDQG/UMDkcWVWK6StM8aMbv0Wju45vi2qK/S+jcMRgyhNTWu43bYuQAFKTpJXXMbby4z/8Pde3AZPdzfY9r0x87h/hAaPi0jdi+pszCWV+IyxoO7mL40WnYJDRrfYho/B4gZNekGLAXTwa41nszBi6yqg5KbB/t+MmcN3/AD5Gce3efobC/72uhWa9AQgBohppvDkzBSg5CQzf91HdmEZrcL9GdmjiXFj5dQF3a7X4HERMY+bO8RdZJwuex72r4RdC2H3IsjaanT1HVhNY6AxwKYWRqgKawdhbSCsrTEflafvuT1/eSlk/w5HU4y5mg6uNYJTzp/msPIKhLbDoN1l0DYRvAPP73VLvaNvQqkip7CMd34x5lqZPLQt7m4WyM+CnT8aO3S/ycTqRERO4OEFLS80TsOegpwDsOcnI9AcWA2HthtHuVUe6WZnAb/G4B9mdAH6h4FPiDFQ3c0dLO7GkXClhcZCvsU5UJxt/C3M2W/MpP5nFjeI7AzN+hmBqcVA8PCu9bdAzKMAJVW880sKecXltI8KZESXaOPGjZ8ZK4A36QUR7c0tUETkdIKbQs9bjBNAUbYxFil9AxzeDYd3GqfibGNIQuFhI2Q5ytMfQuMgtKUxpim2r/H3UUfRNSgKUGJ3tKCUmb8ak7ndd0lb3NwsxhEkld133W80sToREQf5hhgDy1sNOX6bzWZMBpyfaYyfKjhsnIqzwVph/Fi0lhuXvfzBJ/iPU4gxQD00zpizyWIx6UVJfaEAJXZv/7yHgtIKujQJZljHPyasS1tvjCtw9zYOGRYRcWYWyx9dd2FmVyJOTtOdCmC0Pv036XcAplzSFkvlr6vKqQs6XG7MveJkGtwaYyIiUifUAiUAzPp1L0VlRuvToHbhxo1lxbDpc+Ny9zHmFXceGuwaYyIiUqtcqgWqRYsWWCyWKqd///vfVfbZuHEjAwcOxMfHh9jYWJ599tmTHufzzz+nffv2+Pj40KVLF77//vu6egmmyCsuY9aKfQBMHNzqeOvTju+NcQFBTSBukFnlnZe4uDhat26tyepERKRGuVwL1JNPPsn48ePt1wMDj8+9kZuby7Bhwxg6dCgzZsxg06ZN/PWvfyUkJIQ77rgDgBUrVnDDDTcwffp0Lr/8cj766CNGjhzJunXr6Ny5c52/nrrwv5Wp5BaX0yrcn2Edo45vsM/9NPqUSyU4g5iYGLU8iYhIjXO5ABUYGEhUVNQpt3344YeUlpby/vvv4+XlRadOnUhOTubFF1+0B6hXXnmF4cOH8+CDDwLw1FNPsXDhQl5//XVmzJhRZ6+jrhSXVfDecmPep7sGtTaOvANjVt09PxmXnbT7TkREpLa4VBcewL///W8aN25Mjx49eO655ygvL7dvS0pK4sILL8TL6/gq3omJiezYsYNjx47Z9xk6tOrCjomJiSQlJZ32OUtKSsjNza1ychafrt7P4fxSmjby5S/dT2ip2fiZMVlcbD9j1l4RERGxc6kWqHvuuYeePXsSGhrKihUrmDp1Kunp6bz44osAZGRk0LJlyyr3iYyMtG9r1KgRGRkZ9ttO3CcjI4PTmT59OtOmTavhV1P7SsutvP2zsebd3y5qZax5V2njZ8Z5t9EmVCYiIlK/1fsWqEceeeSkgeF/Pm3fbswkO2XKFAYNGkTXrl258847eeGFF3jttdcoKSmp1RqnTp1KTk6O/bR///6z36kemJN8kLScYsIDvbm2V9PjGzK3QNYWcPeCTiNNq09ERKS+qvctUPfffz+33nrrGfc53RFW8fHxlJeXs2/fPtq1a0dUVBSZmZlV9qm8Xjlu6nT7nG5cFYC3tzfe3s615lGF1cZbS43Wp/EDW+LjecIg8crWpzbDnHLuJxERkdpW7wNUeHg44eHh53Tf5ORk3NzciIiIACAhIYF//OMflJWV4enpCcDChQtp164djRo1su+zePFiJk+ebH+chQsXkpCQcH4vpJ5ZsCWDvYcLCPb1ZEx88+MbrFbY9IVxuet15hRXz6SlpZGSkkJcXJyO6BMREcAJuvCqKykpiZdffpkNGzaQkpLChx9+yH333cdNN91kD0c33ngjXl5ejBs3ji1btvDpp5/yyiuvMGXKFPvj3HvvvcyfP58XXniB7du388QTT7BmzRomTZpk1kurFe8uN9a8uyWhOf7eJ+To1BWQewC8g6FNoknV1S+Vk3GmpKSYXYqIiNQT9b4Fqrq8vb355JNPeOKJJygpKaFly5bcd999VcJRcHAwCxYsYOLEifTq1YuwsDAee+wx+xQGAP379+ejjz7in//8J3//+99p06YNc+bMcak5oNalHmPt78fwcnfj5oTmVTdu/NQ47/gX8PSp++LqocouYk3GKSIilSw2m81mdhGuJjc3l+DgYHJycggKCjK7nJNM/HAd8zalc02vpjx/bbfjG8pL4Pk2UJwDY7+DlheaV6SIiEgdc+T722W68KR69h8t5IfN6QDcPrDqlA7sWmCEp6Am0HyACdWJiIg4BwWoBmbWin1YbTCwTRjto/6Uriu77zqPAreG/dFIS0tj+fLlpKWlmV2KiIjUQy4zBkrOLre4jE9XG3NUjRvwp9anomzY+aNxuev1dVtYPVQ5cBzQkXciInISBagG5NPf9pNfUk6biAAuavunqSG2fQsVpRDREaJcZ8D8udLAcRERORMFqAaivMLKzF+NqQtuH9gSi8VSdYfKyTM19xNgtDqp5UlERE6nYQ90aUC+35xBWk4xYQFeXNm9SdWNuemwb7lxufM1dV+ciIiIk1GAaiBm/dH6dFO/5lWXbQHY+g1gg9h4CImt++JEREScjAJUA7D5YA7rUrPxdLdwY3yzk3fY8rVx3umqui1MRETESSlANQD/TdoHwPDO0UQE/ml28ZwDsH8lYIGOI+u6NBEREaekAOXisgtL+SbZmMvolj8v2wKwZY5x3rw/BEXXXWEiIiJOTAHKxX2+5gAl5VbaRwXSu3mjk3dQ952IiIjDNI2BC7Nabfxv1e8A3JLQwj51QVpaGikpKbQJ9yby4BqwuEHHK80sVURExKkoQLmwn3cd4vcjhQT6eDCyx/E5jSpn2W6yL9m4ocUACIgwp0iRP6kM+HFxcZqLS0TqLQUoF/ZBktH6dE2vpvh5Hf+nrpxdu0ny28YN6r6TekTL6IiIM1CAchF//tW+/2ghS3ZkAXBzv6qDx2NiYojxLoJFW8HiDh3UfSf1h5bRERFnoADlIv78q/1/K3/HZoOBbcKICw84+Q6Vg8fjLgL/xnVYqciZaRkdEXEGClAu4sRf7cVlFXy6Zj9gDB4/JR19JyIics4UoFzEib/av0k+SHZhGTHBPgxpf4rB4Yd2QuZmcPOA9pfXcaUiIiLOT/NAuaBPVxutT9f2jsXdzXLyDlu/Mc7jBoNfaB1WJiIi4hoUoFzM70cKWLHnCBYLXNu76al32vZHgOo0ss7qEhERcSUKUC6msvXpwjbhNG3kd/IOR/dCxibj6Lu2l9ZxdSIiIq5BAcqFlFdY+XztAQBG94k99U7b5xrnLS7Q0XciIiLnSAHKhSzZcYhDeSU09vfi4g6Rp95p23fGeYe/1F1hIiIiLkYByoV88lsqYMw87uVxin/a3HTYv8q4rKPvREREzpkClIvIyCm2zzx+3dm675r2haDoOqpMRETE9ShAuYgv1u7HaoO+LUJpdaqZx+GE7rsr6q4wERERF6QA5QKsVpt95vHRfU/T+lR4FPYtNy4rQImIiJwXBSgXsGLPEfYfLSLQx4NLO5+ma27H92CrgKguENqybgsUERFxMQpQLqBy7NPI7k3w9XI/9U46+k5ERKTGaC08F/DPER24rEs0YQFep96hJA/2/GRcVvediIjTS0tLIyUlhbi4OPs6qFK3FKBcgMVioVfzRqffYeePUFEKjVtDePu6K0xERGpFSkoKu3fvBlCAMokCVENwYved5RSLC4uIiFOJi4urci51TwHK1ZUVw66FxuUOmjxTRMQVxMTEqOXJZBpE7ur2/QJlBRAYAzE9za5GRETEJThNgHr66afp378/fn5+hISEnHKf1NRURowYgZ+fHxERETz44IOUl5dX2Wfp0qX07NkTb29vWrduzaxZs056nDfeeIMWLVrg4+NDfHw8v/32Wy28ojqy43vjvN2l6r6TOpOWlsby5ctJS0szuxQRkVrhNAGqtLSUa6+9lgkTJpxye0VFBSNGjKC0tJQVK1Ywe/ZsZs2axWOPPWbfZ+/evYwYMYLBgweTnJzM5MmTuf322/nxxx/t+3z66adMmTKFxx9/nHXr1tGtWzcSExPJysqq9ddY42w22PGDcbndZebWIg1K5QDXlJQUs0sREakVFpvNZjO7CEfMmjWLyZMnk52dXeX2H374gcsvv5y0tDQiIyMBmDFjBg8//DCHDh3Cy8uLhx9+mHnz5rF582b7/UaPHk12djbz588HID4+nj59+vD6668DYLVaiY2N5e677+aRRx6pVo25ubkEBweTk5NDUFBQDbzqc3RwHbwzGLwC4KEU8PA2rxZpUHSItYg4I0e+v52mBepskpKS6NKliz08ASQmJpKbm8uWLVvs+wwdOrTK/RITE0lKSgKMVq61a9dW2cfNzY2hQ4fa9zmVkpIScnNzq5zqhcrWp1ZDFJ6kTsXExDBgwACFJxFxWS4ToDIyMqqEJ8B+PSMj44z75ObmUlRUxOHDh6moqDjlPpWPcSrTp08nODjYfoqNPc16dHVN3Xci50RjuETkbEwNUI888ggWi+WMp+3bt5tZYrVMnTqVnJwc+2n//v1mlwTZqZC5CSxu0GaY2dWIOBWN4RKRszF1Hqj777+fW2+99Yz7VHeSsKioqJOOlsvMzLRvqzyvvO3EfYKCgvD19cXd3R13d/dT7lP5GKfi7e2Nt3c96yLbYYzpolkC+Dc2txYRJ6NJCkXkbEwNUOHh4YSHh9fIYyUkJPD000+TlZVFREQEAAsXLiQoKIiOHTva9/n++++r3G/hwoUkJCQA4OXlRa9evVi8eDEjR44EjEHkixcvZtKkSTVSZ505cfoCEXGIJikUkbNxmjFQqampJCcnk5qaSkVFBcnJySQnJ5Ofnw/AsGHD6NixIzfffDMbNmzgxx9/5J///CcTJ060tw7deeedpKSk8NBDD7F9+3befPNNPvvsM+677z7780yZMoV33nmH2bNns23bNiZMmEBBQQG33XabKa/7nBTnwL7lxmWNfxIREalxTrOUy2OPPcbs2bPt13v06AHAkiVLGDRoEO7u7sydO5cJEyaQkJCAv78/Y8eO5cknn7Tfp2XLlsybN4/77ruPV155haZNm/Luu++SmJho3+f666/n0KFDPPbYY2RkZNC9e3fmz59/0sDyem33IrCWQVhbaNzK7GpERERcjtPNA+UMTJ8H6svbYdPncMG9cMmTZ99fREREGuY8UPKHijLYtcC4rO47ERGRWqEA5WpSk4wxUH5h0LSP2dWIiIi4JAUoV1M5fUHbRHBzN7cWEXGYJvEUcQ5OM4hcqqmy+06TZ4o4pcpJPAFNpSBSjylAuZKjKXBkF7h5QKvBZlcjIudAk3iKOAcFKFeya6Fx3iwBfILNrUVEzokm8RRxDhoD5UrUfSciIlInFKBcRWkB7P3FuKwAJSIiUqsUoFzF3l+gogRCmkF4O7OrERERcWkKUK5i14/GeZthYLGYW4uIiIiLU4ByBTbb8QHk6r4TERGpdQpQruDQdsjZDx4+0GKg2dWIiIi4PAUoV7Dzj+67FgPBy8/cWkRERBoABShXUNl91zbR3DpEREQaCAUoZ1eUbSwgDNDmElNLERERaSgUoJxdyhKwVUBYO2jUwuxqREREGgQFKGe3s3L2cbU+iYiIIS0tjeXLl5OWlmZ2KS5La+E5M6sVdi8yLmv6AhER+UNKSgq7d+8G0NqKtUQBypllboKCLPAKMBYQFhERAeLi4qqcS81TgHJmuxcb5y0GgoeXubU4KC0tjZSUFOLi4vTrSESkhsXExOhvay1TgHJme34yzltfbG4d50DNyyIi4swUoJxVST6krjQutxpibi3nQM3LIiLizBSgnNW+X8BaZkxd0LiV2dU4TM3LIiLizDSNgbOqHP/Uyvm670RERJydApSz2vNHgHLC8U8iIiLOTgHKGR3dC0dTwM3DOAJPRERE6pQClDOqbH2KjQefIHNrERERaYAUoJzR7j+mL3DCo+9ERERcgQKUs6kog73LjMsa/yQiImIKBShns/83KM0DvzCI6mZ2NSIiIg2SApSzqRz/1GowuOmfT0REnEdaWhrLly8nLS3N7FLOmybSdDaa/0lERJyUKy3jpQDlTAoOQ/oG47IGkIuIiJNxpWW8FKCcyZ4lgA0iu0BgpNnViIiIOMSVlvFymkE0Tz/9NP3798fPz4+QkJBT7mOxWE46ffLJJ1X2Wbp0KT179sTb25vWrVsza9askx7njTfeoEWLFvj4+BAfH89vv/1WC6/oHKQnG+et1fpUU1ypP15EROqO0wSo0tJSrr32WiZMmHDG/WbOnEl6err9NHLkSPu2vXv3MmLECAYPHkxycjKTJ0/m9ttv58cff7Tv8+mnnzJlyhQef/xx1q1bR7du3UhMTCQrK6u2Xlr1JT4N9yRD3zvMrsRlVPbHp6SkmF2KiIg4EYvNZrOZXYQjZs2axeTJk8nOzj5pm8Vi4euvv64Smk708MMPM2/ePDZv3my/bfTo0WRnZzN//nwA4uPj6dOnD6+//joAVquV2NhY7r77bh555JFq1Zibm0twcDA5OTkEBbnOTOFpaWmkpKQQFxfnMk2wrviaRETk3Djy/e00LVDVNXHiRMLCwujbty/vv/8+J+bDpKQkhg4dWmX/xMREkpKSAKOVa+3atVX2cXNzY+jQofZ9TqWkpITc3NwqJ1fkiq01MTExDBgwQOFJREQc4lKDyJ988kmGDBmCn58fCxYs4K677iI/P5977rkHgIyMDCIjqw6+joyMJDc3l6KiIo4dO0ZFRcUp99m+fftpn3f69OlMmzat5l9QPeNKR0+IiIicD1NboB555JFTDvw+8XSm4PJnjz76KBdccAE9evTg4Ycf5qGHHuK5556rxVdgmDp1Kjk5OfbT/v37a/05zaDWGhEREYOpLVD3338/t9566xn3OZ/Wjvj4eJ566ilKSkrw9vYmKiqKzMzMKvtkZmYSFBSEr68v7u7uuLu7n3KfqKio0z6Pt7c33t7e51yniIiIOBdTA1R4eDjh4eG19vjJyck0atTIHm4SEhL4/vvvq+yzcOFCEhISAPDy8qJXr14sXrzYPhDdarWyePFiJk2aVGt1ioiIiHNxmjFQqampHD16lNTUVCoqKkhOTgagdevWBAQE8N1335GZmUm/fv3w8fFh4cKFPPPMMzzwwAP2x7jzzjt5/fXXeeihh/jrX//KTz/9xGeffca8efPs+0yZMoWxY8fSu3dv+vbty8svv0xBQQG33XZbXb9kERERqa9sTmLs2LE24KTTkiVLbDabzfbDDz/YunfvbgsICLD5+/vbunXrZpsxY4atoqKiyuMsWbLE1r17d5uXl5ctLi7ONnPmzJOe67XXXrM1a9bM5uXlZevbt69t5cqVDtWak5NjA2w5OTnn+nJFRESkjjny/e1080A5A1edB0pERMSVNeh5oERERERqmwKUiIiIiIMUoEREREQcpAAlIiIi4iAFKBEREREHKUCJiIiIOEgBSkRERMRBClAiIiIiDnKapVycSeXcpLm5uSZXIiIiItVV+b1dnTnGFaBqQV5eHgCxsbEmVyIiIiKOysvLIzg4+Iz7aCmXWmC1WklLSyMwMBCLxVKjj52bm0tsbCz79+/XMjFnofeq+vReVZ/eq+rTe1V9eq+qrzbfK5vNRl5eHjExMbi5nXmUk1qgaoGbmxtNmzat1ecICgrSf7Jq0ntVfXqvqk/vVfXpvao+vVfVV1vv1dlanippELmIiIiIgxSgRERERBykAOVkvL29efzxx/H29ja7lHpP71X16b2qPr1X1af3qvr0XlVffXmvNIhcRERExEFqgRIRERFxkAKUiIiIiIMUoEREREQcpAAlIiIi4iAFKCfx9NNP079/f/z8/AgJCTnlPhaL5aTTJ598UreF1hPVeb9SU1MZMWIEfn5+RERE8OCDD1JeXl63hdZDLVq0OOlz9O9//9vssuqNN954gxYtWuDj40N8fDy//fab2SXVO0888cRJn6H27dubXVa9sGzZMq644gpiYmKwWCzMmTOnynabzcZjjz1GdHQ0vr6+DB06lF27dplTrMnO9l7deuutJ33Ohg8fXmf1KUA5idLSUq699lomTJhwxv1mzpxJenq6/TRy5Mi6KbCeOdv7VVFRwYgRIygtLWXFihXMnj2bWbNm8dhjj9VxpfXTk08+WeVzdPfdd5tdUr3w6aefMmXKFB5//HHWrVtHt27dSExMJCsry+zS6p1OnTpV+QwtX77c7JLqhYKCArp168Ybb7xxyu3PPvssr776KjNmzGDVqlX4+/uTmJhIcXFxHVdqvrO9VwDDhw+v8jn7+OOP665AmziVmTNn2oKDg0+5DbB9/fXXdVpPfXe69+v777+3ubm52TIyMuy3vfXWW7agoCBbSUlJHVZY/zRv3tz20ksvmV1GvdS3b1/bxIkT7dcrKipsMTExtunTp5tYVf3z+OOP27p162Z2GfXen/9mW61WW1RUlO25556z35adnW3z9va2ffzxxyZUWH+c6vtt7NixtiuvvNKUemw2m00tUC5m4sSJhIWF0bdvX95//31smubrlJKSkujSpQuRkZH22xITE8nNzWXLli0mVlY//Pvf/6Zx48b06NGD5557Tl2bGK2aa9euZejQofbb3NzcGDp0KElJSSZWVj/t2rWLmJgY4uLiGDNmDKmpqWaXVO/t3buXjIyMKp+x4OBg4uPj9Rk7jaVLlxIREUG7du2YMGECR44cqbPn1mLCLuTJJ59kyJAh+Pn5sWDBAu666y7y8/O55557zC6t3snIyKgSngD79YyMDDNKqjfuueceevbsSWhoKCtWrGDq1Kmkp6fz4osvml2aqQ4fPkxFRcUpPzfbt283qar6KT4+nlmzZtGuXTvS09OZNm0aAwcOZPPmzQQGBppdXr1V+bfnVJ+xhv536VSGDx/O1VdfTcuWLdmzZw9///vfufTSS0lKSsLd3b3Wn18BykSPPPII//d//3fGfbZt21btwZePPvqo/XKPHj0oKCjgueeec5kAVdPvV0PiyHs3ZcoU+21du3bFy8uLv/3tb0yfPt30pRPEOVx66aX2y127diU+Pp7mzZvz2WefMW7cOBMrE1cyevRo++UuXbrQtWtXWrVqxdKlS7n44otr/fkVoEx0//33c+utt55xn7i4uHN+/Pj4eJ566ilKSkpc4ouvJt+vqKiok46eyszMtG9zNefz3sXHx1NeXs6+ffto165dLVTnHMLCwnB3d7d/TiplZma65GemJoWEhNC2bVt2795tdin1WuXnKDMzk+joaPvtmZmZdO/e3aSqnEdcXBxhYWHs3r1bAcrVhYeHEx4eXmuPn5ycTKNGjVwiPEHNvl8JCQk8/fTTZGVlERERAcDChQsJCgqiY8eONfIc9cn5vHfJycm4ubnZ36eGysvLi169erF48WL70a1Wq5XFixczadIkc4ur5/Lz89mzZw8333yz2aXUay1btiQqKorFixfbA1Nubi6rVq066xHYAgcOHODIkSNVwmdtUoByEqmpqRw9epTU1FQqKipITk4GoHXr1gQEBPDdd9+RmZlJv3798PHxYeHChTzzzDM88MAD5hZukrO9X8OGDaNjx47cfPPNPPvss2RkZPDPf/6TiRMnukzgPBdJSUmsWrWKwYMHExgYSFJSEvfddx833XQTjRo1Mrs8002ZMoWxY8fSu3dv+vbty8svv0xBQQG33Xab2aXVKw888ABXXHEFzZs3Jy0tjccffxx3d3duuOEGs0szXX5+fpWWuL1795KcnExoaCjNmjVj8uTJ/Otf/6JNmza0bNmSRx99lJiYmAY5Jc2Z3qvQ0FCmTZvGqFGjiIqKYs+ePTz00EO0bt2axMTEuinQtOP/xCFjx461ASedlixZYrPZbLYffvjB1r17d1tAQIDN39/f1q1bN9uMGTNsFRUV5hZukrO9XzabzbZv3z7bpZdeavP19bWFhYXZ7r//fltZWZl5RdcDa9eutcXHx9uCg4NtPj4+tg4dOtieeeYZW3Fxsdml1RuvvfaarVmzZjYvLy9b3759bStXrjS7pHrn+uuvt0VHR9u8vLxsTZo0sV1//fW23bt3m11WvbBkyZJT/m0aO3aszWYzpjJ49NFHbZGRkTZvb2/bxRdfbNuxY4e5RZvkTO9VYWGhbdiwYbbw8HCbp6enrXnz5rbx48dXmZqmtllsNh3nLiIiIuIIzQMlIiIi4iAFKBEREREHKUCJiIiIOEgBSkRERMRBClAiIiIiDlKAEhEREXGQApSIiIiIgxSgRERERBykACUiIiLiIAUoEREREQcpQImInMWhQ4eIiorimWeesd+2YsUKvLy8WLx4sYmViYhZtBaeiEg1fP/994wcOZIVK1bQrl07unfvzpVXXsmLL75odmkiYgIFKBGRapo4cSKLFi2id+/ebNq0idWrV+Pt7W12WSJiAgUoEZFqKioqonPnzuzfv5+1a9fSpUsXs0sSEZNoDJSISDXt2bOHtLQ0rFYr+/btM7scETGRWqBERKqhtLSUvn370r17d9q1a8fLL7/Mpk2biIiIMLs0ETGBApSISDU8+OCDfPHFF2zYsIGAgAAuuugigoODmTt3rtmliYgJ1IUnInIWS5cu5eWXX+aDDz4gKCgINzc3PvjgA3755Rfeeusts8sTEROoBUpERETEQWqBEhEREXGQApSIiIiIgxSgRERERBykACUiIiLiIAUoEREREQcpQImIiIg4SAFKRERExEEKUCIiIiIOUoASERERcZAClIiIiIiDFKBEREREHKQAJSIiIuKg/wfvwjlP3b+moAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "u0 = s\n", "for i in range(5):\n", From 2b42a24905cec9a24a923427887b3fbcc179639d Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 15:10:00 -0400 Subject: [PATCH 06/10] docs: update variable names in docs to conform to standard --- ...Workflows using Functions and States.ipynb | 603 +++++++++++++++++- 1 file changed, 589 insertions(+), 14 deletions(-) diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index 97cc8cf8..d0d4faaf 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -90,7 +90,33 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), params={}, experiment_data=Empty DataFrame\n", + "Columns: [x, y]\n", + "Index: [], conditions= x\n", + "0 -15.0\n", + "1 -14.7\n", + "2 -14.4\n", + "3 -14.1\n", + "4 -13.8\n", + ".. ...\n", + "96 13.8\n", + "97 14.1\n", + "98 14.4\n", + "99 14.7\n", + "100 15.0\n", + "\n", + "[101 rows x 1 columns], model=None)" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "s" ] @@ -160,7 +186,115 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xy
0-15.0-1457.368847
1-14.7-1276.238863
2-14.4-1101.204891
3-14.1-938.114081
4-13.8-780.385208
.........
9613.8501.515831
9714.1608.036899
9814.4722.340558
9914.7844.702516
10015.0972.762139
\n", + "

101 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " x y\n", + "0 -15.0 -1457.368847\n", + "1 -14.7 -1276.238863\n", + "2 -14.4 -1101.204891\n", + "3 -14.1 -938.114081\n", + "4 -13.8 -780.385208\n", + ".. ... ...\n", + "96 13.8 501.515831\n", + "97 14.1 608.036899\n", + "98 14.4 722.340558\n", + "99 14.7 844.702516\n", + "100 15.0 972.762139\n", + "\n", + "[101 rows x 2 columns]" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "experiment_runner(s, std=1).experiment_data" ] @@ -220,7 +354,82 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-161.235264
2x^2-2.092934
3x^31.487881
4x^4-0.002423
5x^5-0.002523
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -161.235264\n", + "2 x^2 -2.092934\n", + "3 x^3 1.487881\n", + "4 x^4 -0.002423\n", + "5 x^5 -0.002523" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "get_equation(t.model)" ] @@ -259,7 +468,82 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-161.235264
2x^2-2.092934
3x^31.487881
4x^4-0.002423
5x^5-0.002523
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -161.235264\n", + "2 x^2 -2.092934\n", + "3 x^3 1.487881\n", + "4 x^4 -0.002423\n", + "5 x^5 -0.002523" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "u = pipeline(s, rng=np.random.default_rng(1))\n", "get_equation(u.model)" @@ -276,7 +560,82 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-169.149674
2x^22.803475
3x^31.617091
4x^4-0.022233
5x^5-0.002868
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -169.149674\n", + "2 x^2 2.803475\n", + "3 x^3 1.617091\n", + "4 x^4 -0.022233\n", + "5 x^5 -0.002868" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "u_ = pipeline(pipeline(s, rng=np.random.default_rng(1)))\n", "get_equation(u_.model)" @@ -293,7 +652,92 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tcoefficient
010.000000
1x-169.149674
2x^22.803475
3x^31.617091
4x^4-0.022233
5x^5-0.002868
\n", + "
" + ], + "text/plain": [ + " t coefficient\n", + "0 1 0.000000\n", + "1 x -169.149674\n", + "2 x^2 2.803475\n", + "3 x^3 1.617091\n", + "4 x^4 -0.022233\n", + "5 x^5 -0.002868" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def show_best_fit(state):\n", " state.experiment_data.plot.scatter(\"x\", \"y\", s=1, alpha=0.5, c=\"gray\")\n", @@ -327,7 +771,18 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "v = s\n", "while len(v.experiment_data) < 1_000: # any condition on the state can be used here.\n", @@ -348,7 +803,18 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def cycle(state: State) -> State:\n", " s_ = state\n", @@ -402,7 +868,16 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v0.model=None, \n", + "v0.experiment_data.shape=(0, 2)\n" + ] + } + ], "source": [ "print(f\"{v0.model=}, \\n{v0.experiment_data.shape=}\")" ] @@ -418,7 +893,18 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#-- running experiment_runner --#\n", + "\n", + "v1.model=None, \n", + "v1.experiment_data.shape=(101, 2)\n" + ] + } + ], "source": [ "v1 = next(cycle_generator)\n", "print(f\"{v1.model=}, \\n{v1.experiment_data.shape=}\")" @@ -435,7 +921,19 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#-- running theorist --#\n", + "\n", + "v2.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n", + " ('linearregression', LinearRegression())]), \n", + "v2.experiment_data.shape=(101, 2)\n" + ] + } + ], "source": [ "v2 = next(cycle_generator)\n", "print(f\"{v2.model=}, \\n{v2.experiment_data.shape=}\")" @@ -452,7 +950,19 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#-- running experiment_runner --#\n", + "\n", + "v3.model=Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=5)),\n", + " ('linearregression', LinearRegression())]), \n", + "v3.experiment_data.shape=(202, 2)\n" + ] + } + ], "source": [ "v3 = next(cycle_generator)\n", "print(f\"{v3.model=}, \\n{v3.experiment_data.shape=}\")" @@ -471,7 +981,21 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Snapshot(variables=VariableCollection(independent_variables=[Variable(name='x', value_range=(-15, 15), allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], dependent_variables=[Variable(name='y', value_range=None, allowed_values=None, units='', type=, variable_label='', rescale=1, is_covariate=False)], covariates=[]), params={}, experiment_data=Empty DataFrame\n", + "Columns: [x, y]\n", + "Index: [], conditions= x\n", + "0 2.281691, model=None)" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "experimentalist_rng = np.random.default_rng(180)\n", "@wrap_to_use_state\n", @@ -491,7 +1015,58 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "u0 = s\n", "for i in range(5):\n", From 2921ad116ddff16a95747382c9c4d9f3a0c0a6a3 Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 16:04:04 -0400 Subject: [PATCH 07/10] Update docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb Co-authored-by: Younes Strittmatter --- ...near and Cyclical Workflows using Functions and States.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index d0d4faaf..d3f15bcb 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Using the functions in `autora.workflow`, we can build flexible pipelines and cycles which operate on state objects.\n" +"Using the functions in `autora.state`, we can build flexible pipelines and cycles which operate on state objects.\n" ] }, { From fa6a13b2df97fa116e640882dff2a5f3fc0312fe Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 16:04:11 -0400 Subject: [PATCH 08/10] Update docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb Co-authored-by: Younes Strittmatter --- ...near and Cyclical Workflows using Functions and States.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index d3f15bcb..b2b7e33c 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -56,7 +56,7 @@ "\n", "### Defining The State\n", "\n", - "We define the state as a dataclass, subclassed from `autora.workflow.State` with fields representing the variables,\n", + "We define the state as a dataclass, subclassed from `autora.state.delta.State` with fields representing the variables,\n", "parameters, experimental data, (possibly) conditions, and (possibly) a model.\n", "\n", "This state has no \"history\"; it represents a snapshot of the data at one time. Other exemplar state objects are\n", From b8ea4c2403b1ca9b309973f652a8528349612937 Mon Sep 17 00:00:00 2001 From: John Gerrard Holland Date: Fri, 7 Jul 2023 16:04:18 -0400 Subject: [PATCH 09/10] Update docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb Co-authored-by: Younes Strittmatter --- ...near and Cyclical Workflows using Functions and States.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index b2b7e33c..09ce2da1 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -60,7 +60,7 @@ "parameters, experimental data, (possibly) conditions, and (possibly) a model.\n", "\n", "This state has no \"history\"; it represents a snapshot of the data at one time. Other exemplar state objects are\n", - "available in the subpackage `autora.workflow.state` and include some with in-built histories." + "available in the subpackage `autora.state` and include some with in-built histories." ] }, { From bb9f15f7df0ff04ffebc4b4510276d42828e83ed Mon Sep 17 00:00:00 2001 From: benwandrew Date: Fri, 7 Jul 2023 20:26:15 +0000 Subject: [PATCH 10/10] docs: remove empty cell --- ...d Cyclical Workflows using Functions and States.ipynb | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb index 09ce2da1..d9473ab7 100644 --- a/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb +++ b/docs/cycle/Linear and Cyclical Workflows using Functions and States.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ -"Using the functions in `autora.state`, we can build flexible pipelines and cycles which operate on state objects.\n" + "Using the functions in `autora.state`, we can build flexible pipelines and cycles which operate on state objects.\n" ] }, { @@ -1076,13 +1076,6 @@ " show_best_fit(u0)\n", " plt.title(f\"{i=}\")\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": {