diff --git a/src/beanmachine/ppl/experimental/goal_inference/agent/boundedly_rational_agent.py b/src/beanmachine/ppl/experimental/goal_inference/agent/boundedly_rational_agent.py
new file mode 100644
index 0000000000..bdcca9a51a
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/agent/boundedly_rational_agent.py
@@ -0,0 +1,338 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+import copy
+
+from typing import List, Tuple
+
+import torch
+from beanmachine.facebook.goal_inference.agent.observation_model import ObservationModel
+
+from beanmachine.facebook.goal_inference.environment import State
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_execution_path,
+ Plan,
+ Planner,
+ StateNode,
+)
+
+from beanmachine.facebook.goal_inference.planner.stoch_astar import (
+ StochasticAstarProposalPlanner,
+)
+from torch.distributions.negative_binomial import NegativeBinomial
+
+
+class BoundedRationalAgent:
+
+ """
+ An Agent that makes and executes short term plans based on budgetary contrainsts.
+
+ Arguments:
+
+ planner: The strategy for determining short term plans
+ initial_state: Initial state of the problem
+ r: Parameter of negative binomial distribution. Determines the number of failures that must be exceeded
+ p: Parameter of negative binomial distribution. Determines the success/failure rate
+ max_steps: Maximum number of steps to execute
+
+ Attributes:
+
+ planner: The strategy for determining short term plans
+ r: Parameter of negative binomial distribution. Determines the number of failures that must be exceeded
+ p: Parameter of negative binomial distribution. Determines the success/failure rate
+ max_steps: Maximum number of steps to execute
+ action_step: Action step within the current plan
+ agent_step: Total number of steps by the agent
+ budget_dist(r,p): A negative binomial distribution: Samples the number of successful trials before r failures if the probability of success is p
+ plan_history: The series of plans constructed by this agent
+ plan_index: Index of curr_plan in plan_history
+ initial_node: Graph node defining the environment at the first time step.
+ curr_node: Graph node defining environment at current time step
+ proposal_planner: Proposal planner for path rejuvenation
+ """
+
+ def __init__(
+ self,
+ planner: Planner,
+ initial_state: State,
+ r: int = 2,
+ p: float = 0.95,
+ max_steps: int = 1000,
+ ):
+ self.planner: Planner = planner
+ self.r: int = r
+ self.p: float = p
+ self.max_steps: int = max_steps
+ self.agent_step: int = 0
+ self.action_step: int = 0
+ self.budget_dist: NegativeBinomial = NegativeBinomial(r, p)
+ self.plan_history: List[Plan] = []
+ self.plan_index: int = -1
+ self.initial_node: StateNode = StateNode(initial_state, None, [])
+ self.curr_node: StateNode = self.initial_node
+ self.proposal_planner: StochasticAstarProposalPlanner = (
+ StochasticAstarProposalPlanner(self.planner)
+ )
+
+ @property
+ def curr_plan(self) -> Plan:
+ """Gets the current plan based on the plan_history and plan_index
+
+ Returns:
+ curr_plan: The current plan
+ """
+ if self.plan_index == -1:
+ return Plan([], [], [], 0)
+ else:
+ return self.plan_history[self.plan_index]
+
+ def execute_search(self) -> Tuple[Plan, bool]:
+ """Evolves the system to a solution or until max_steps is reached. Uses short term plans.
+
+ Returns:
+ plan: The plan executed by the agent
+ solved: Whether a solution to the problem was reached
+ """
+
+ while (
+ not self.planner.domain.evaluate_goal(self.curr_node.state)
+ and self.agent_step < self.max_steps
+ ):
+ self.replan()
+ self.execute_plan()
+
+ return (
+ # pyre-fixme[19]: Expected 4 positional arguments.
+ Plan(
+ *get_execution_path(self.curr_node),
+ self.planner.visited_nodes,
+ self.max_steps,
+ ),
+ self.planner.domain.evaluate_goal(self.curr_node.state),
+ )
+
+ def execute_plan(self) -> None:
+ """Executes a short term plan. Stops Early if states deviate from expectation"""
+ while self.action_step < len(self.curr_plan.actions):
+ self._execute_step()
+
+ def replan(self) -> None:
+ """Updates the current plan based on the current state"""
+ new_plan, solved = self.planner.generate_plan(
+ self.curr_node.state,
+ int(self.budget_dist.sample((1,)).item()),
+ )
+ # Don't consider empty plans which can occur if a solution is already reached
+ if len(new_plan.actions) > 0:
+ self.action_step = 0
+ self.plan_history.append(new_plan)
+ self.plan_index += 1
+
+ def _execute_step(self) -> None:
+ """Executes a single action from the current plan"""
+ if not self.is_next_step_deviating():
+ new_node = StateNode(
+ self.curr_plan.states[self.action_step + 1],
+ executed=self.curr_plan.actions[self.action_step],
+ parent_node=self.curr_node,
+ )
+ self.curr_node = new_node
+ self.agent_step += 1
+ self.action_step += 1
+
+ else:
+ # The new state can deviate from the expected plan if actions are not deterministic
+ # In that case, we need a new plan before continuing (otherwise planned actions may be invalid)
+ self.action_step = len(self.curr_plan.actions)
+
+ def is_next_step_deviating(self) -> bool:
+ """Determines if next state deviates from expected plan
+
+ Returns:
+ is_deviating: Whether the next state deviates from the expectation of the plan
+ """
+ act = self.curr_plan.actions[self.action_step]
+ next_predicted_state = self.curr_plan.states[self.action_step + 1]
+ new_state = self.planner.domain.execute(self.curr_node.state, *act)
+ return not new_state == next_predicted_state
+
+ def step(self, num_steps: int = 1) -> None:
+ """Advances the agent by one time step
+
+ Arguments:
+ num_steps: The number of time steps to advance
+ """
+ for _step in range(num_steps):
+ while (
+ self.action_step >= len(self.curr_plan.actions)
+ or self.is_next_step_deviating()
+ ):
+ if self.planner.domain.evaluate_goal(self.curr_node.state):
+ break
+ self.replan()
+ # Make sure that current plan is not empty and agent is not at end of plan
+ # This condition can fail if a solution has been reached
+ if self.curr_plan.actions and self.action_step < len(
+ self.curr_plan.actions
+ ):
+ self._execute_step()
+
+ def propose_path(
+ self,
+ observations: List[State],
+ proposal_time_deviation: int,
+ noise_model: ObservationModel,
+ ) -> None:
+ """Proposes a new path for the bounded-rational agent starting from proposal_time_deviation
+
+ Arguments:
+ observations: The observed path
+ proposal_time_deviation: The time step to start proposing a new path
+ noise_model: A model for P(observation | state)
+ """
+ # Set time of bounded-agent to where proposed path diverges from previous path
+ self._set_to_timestep(proposal_time_deviation, clear=True)
+ while (
+ not self.planner.domain.evaluate_goal(self.curr_node.state)
+ and self.agent_step < len(observations) - 1
+ ):
+ while (
+ self.action_step >= len(self.curr_plan.actions)
+ or self.is_next_step_deviating()
+ ):
+ if self.planner.domain.evaluate_goal(self.curr_node.state):
+ break
+ # Propose the next plan
+ self.propose_plan(observations, noise_model)
+ # Make sure that current plan is not empty and agent is not at end of plan
+ # This condition can fail if a solution has been reached
+ if self.curr_plan.actions and self.action_step < len(
+ self.curr_plan.actions
+ ):
+ self._execute_step()
+
+ def propose_plan(
+ self, observations: List[State], noise_model: ObservationModel
+ ) -> None:
+ """Proposes the next plan during path rejuvenation
+
+ Arguments:
+ observations: The observed path
+ noise_model: A model for P(observation | state)
+
+ """
+ new_plan, solved = self.proposal_planner.propose(
+ self.curr_node.state,
+ observations,
+ self.budget_dist.sample((1,)).item(),
+ noise_model,
+ )
+ # Add this plan to the history of this agent
+ if len(new_plan.actions) > 0:
+ self.action_step = 0
+ self.plan_history.append(new_plan)
+ self.plan_index += 1
+
+ def __copy__(self) -> BoundedRationalAgent:
+ """Creates a shallow copy of a BoundedRationalAgent
+
+ Returns:
+ agent_copy: A shallow copy of the agent
+ """
+ agent_copy = BoundedRationalAgent(
+ self.planner,
+ self.initial_node.state,
+ r=self.r,
+ p=self.p,
+ max_steps=self.max_steps,
+ )
+
+ agent_copy.agent_step = self.agent_step
+ agent_copy.action_step = self.action_step
+ agent_copy.plan_history = copy.copy(self.plan_history)
+ agent_copy.plan_index = self.plan_index
+ agent_copy.curr_node = self.curr_node
+ return agent_copy
+
+ def get_log_prob(
+ self,
+ observations: List[State],
+ proposal_time_deviation: int,
+ noise_model: ObservationModel,
+ ) -> torch.Tensor:
+ """Evaluates the log probability of a series of plans
+
+ Arguments:
+ observations: The observed path
+ proposal_time_deviation: The time step to start proposing a new path
+ noise_model: A model for P(observation | state)
+
+ Returns:
+ log_prob: The log probability of the proposed series of plans
+
+ """
+ # Plans before divergence are not changed
+ time_step = 0
+ self.plan_index = 0
+ while time_step < proposal_time_deviation:
+ time_step += len(self.curr_plan.actions)
+ self.plan_index += 1
+ log_prob = torch.tensor(0.0)
+ # Compute contribution to proposal probability from each plan
+ while self.plan_index < len(self.plan_history):
+ # Computes probability of plan budget
+ log_prob_plan_length = self.budget_dist.log_prob(
+ torch.tensor(self.curr_plan.budget)
+ )
+ # Computes probability of specific planning process
+
+ log_prob_plan_visit = self.proposal_planner.get_log_prob(
+ self.curr_plan,
+ observations[
+ self.agent_step : self.agent_step + len(self.curr_plan.states)
+ ],
+ noise_model,
+ )
+ log_prob += log_prob_plan_length
+ log_prob += log_prob_plan_visit
+ self.plan_index += 1
+ self.plan_index = len(self.plan_history) - 1
+
+ return log_prob
+
+ def _set_to_timestep(self, time_step: int, clear: bool = True):
+ """Set time of bounded-agent to where proposed path diverges from previous path
+
+ Arguments:
+ proposal_time_deviation: The time step to start proposing a new path
+ clear: Whether to remove future plans when setting the time
+
+ """
+ # Start at initial conditions of bounded agent
+ self.plan_index = 0
+ self.agent_step = 0
+ self.action_step = 0
+ self.curr_node = self.initial_node
+ # Follow execute previous plans until deviation time
+ while self.agent_step < time_step:
+ new_node = StateNode(
+ self.curr_plan.states[self.action_step + 1],
+ executed=self.curr_plan.actions[self.action_step],
+ parent_node=self.curr_node,
+ )
+ self.curr_node = new_node
+ self.agent_step += 1
+ self.action_step += 1
+ # When plan is finished switch to the next one
+ if (
+ self.action_step == len(self.curr_plan.actions)
+ and self.agent_step != time_step
+ ):
+ self.action_step = 0
+ self.plan_index += 1
+
+ # Erase the remainder of the plans from the previous path
+ # Erase when proposing NOT when evaluating probability of proposal
+ if clear:
+ self.plan_history = self.plan_history[: self.plan_index + 1]
diff --git a/src/beanmachine/ppl/experimental/goal_inference/agent/boundedly_rational_agent_test.py b/src/beanmachine/ppl/experimental/goal_inference/agent/boundedly_rational_agent_test.py
new file mode 100644
index 0000000000..829c15e00b
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/agent/boundedly_rational_agent_test.py
@@ -0,0 +1,227 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import copy
+import dataclasses
+
+import pytest
+from beanmachine.facebook.goal_inference.agent.boundedly_rational_agent import (
+ BoundedRationalAgent,
+)
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_plan_from_actions,
+ Plan,
+)
+
+
+@pytest.fixture
+def agent_one(dkg_stoch_astar_planner, dkg_state_one):
+ return BoundedRationalAgent(dkg_stoch_astar_planner, dkg_state_one, r=10, p=0.5)
+
+
+@pytest.fixture
+def agent_two(dkg_stoch_astar_planner, dkg_state_two):
+ return BoundedRationalAgent(dkg_stoch_astar_planner, dkg_state_two, r=10, p=0.5)
+
+
+@pytest.fixture
+def agent_three(dkg_stoch_astar_planner, dkg_state_three):
+ return BoundedRationalAgent(dkg_stoch_astar_planner, dkg_state_three, r=10, p=0.5)
+
+
+def test_initialize_dkg_bounded_agent(agent_one):
+ assert agent_one.agent_step == 0
+
+
+def test_dkg_bounded_agent_problem_1(agent_one):
+ plan, solved = agent_one.execute_search()
+ assert solved
+ planner = agent_one.planner
+ state = agent_one.curr_node.state
+ assert planner.domain.evaluate_goal(state)
+
+
+def test_dkg_bounded_agent_problem_2(agent_two):
+ plan, solved = agent_two.execute_search()
+ assert solved
+ planner = agent_two.planner
+ state = agent_two.curr_node.state
+ assert planner.domain.evaluate_goal(state)
+
+
+def test_dkg_bounded_agent_impossible_task(agent_two):
+ # Make task impossible
+ new_at = agent_two.curr_node.state.at
+ new_at.pop("key1")
+ agent_two.curr_node.state = dataclasses.replace(
+ agent_two.curr_node.state, keys={}, at=new_at
+ )
+ plan, solved = agent_two.execute_search()
+ assert (agent_two.agent_step >= 1000) and not solved
+
+
+def test_dkg_bounded_agent_replan(agent_two):
+ agent_two.replan()
+ curr_plan = agent_two.curr_plan
+ assert isinstance(agent_two.curr_plan, Plan)
+ assert len(curr_plan.states) == len(curr_plan.actions) + 1
+
+
+def test_replan_after_solved_is_unchanged(agent_two):
+ plan, solved = agent_two.execute_search()
+ num_plans = len(agent_two.plan_history)
+ assert solved
+ agent_two.replan()
+ curr_plan = agent_two.curr_plan
+ assert curr_plan.states == agent_two.plan_history[num_plans - 1].states
+
+
+def test_dkg_bounded_agent_execute_plan(agent_two):
+ agent_two.replan()
+ curr_plan = agent_two.curr_plan
+ initial_steps = agent_two.agent_step
+ agent_two.execute_plan()
+ assert agent_two.curr_node.state == curr_plan.states[-1]
+ assert agent_two.agent_step == initial_steps + len(curr_plan.actions)
+
+
+def test_dkg_bounded_agent_execute_plan_break(agent_two):
+ agent_two.replan()
+ while len(agent_two.curr_plan.actions) < 3:
+ agent_two.replan()
+ curr_plan = agent_two.curr_plan
+ initial_steps = agent_two.agent_step
+ # Create an unexpected state
+ curr_plan.states[-1] = curr_plan.states[0]
+ agent_two.execute_plan()
+ assert agent_two.curr_node.state == curr_plan.states[-2]
+ assert agent_two.agent_step == initial_steps + len(curr_plan.actions) - 1
+
+
+def test_dkg_bounded_agent_total_plan(agent_two):
+ plan, solved = agent_two.execute_search()
+ assert solved
+ assert isinstance(plan, Plan)
+ assert len(plan.states) == len(plan.actions) + 1
+ assert len(plan.actions) == agent_two.agent_step
+
+
+def test_execute_step_match_expected(agent_two):
+ agent_two.replan()
+ while len(agent_two.curr_plan.actions) < 3:
+ agent_two.replan()
+ curr_plan = agent_two.curr_plan
+ agent_two._execute_step()
+ assert agent_two.agent_step == 1
+ assert agent_two.action_step == 1
+ assert agent_two.curr_node.state == curr_plan.states[1]
+ agent_two._execute_step()
+ assert agent_two.agent_step == 2
+ assert agent_two.action_step == 2
+ assert agent_two.curr_node.state == curr_plan.states[2]
+
+
+def test_execute_step_break_expected(agent_two):
+ agent_two.replan()
+ while len(agent_two.curr_plan.actions) < 3:
+ agent_two.replan()
+ curr_plan = agent_two.curr_plan
+ # Create an unexpected state
+ curr_plan.states[2] = curr_plan.states[0]
+ agent_two._execute_step()
+ assert agent_two.agent_step == 1
+ assert agent_two.action_step == 1
+ assert agent_two.curr_node.state == curr_plan.states[1]
+ agent_two._execute_step()
+ assert agent_two.agent_step == 1
+ assert agent_two.action_step == len(curr_plan.actions)
+ assert agent_two.curr_node.state == curr_plan.states[1]
+
+
+def test_advance_single_time_step(agent_three):
+ agent_three.replan()
+ while len(agent_three.curr_plan.actions) < 3:
+ agent_three.replan()
+ agent_three.step()
+ curr_plan = agent_three.curr_plan
+ assert agent_three.agent_step == 1
+ assert agent_three.action_step == 1
+ assert agent_three.curr_node.state == curr_plan.states[1]
+ agent_three.step()
+ assert agent_three.agent_step == 2
+ assert agent_three.action_step == 2
+ assert agent_three.curr_node.state == curr_plan.states[2]
+
+
+def test_advance_n_time_steps(agent_three):
+ agent_three.replan()
+ while len(agent_three.curr_plan.actions) < 3:
+ agent_three.replan()
+ agent_three.step()
+ curr_plan = agent_three.curr_plan
+ assert agent_three.agent_step == 1
+ assert agent_three.action_step == 1
+ assert agent_three.curr_node.state == curr_plan.states[1]
+ # Time step through a new plan
+ steps_for_new_plan = len(curr_plan.actions)
+ agent_three.step(steps_for_new_plan)
+ curr_plan = agent_three.curr_plan
+ assert agent_three.agent_step == steps_for_new_plan + 1
+ assert agent_three.action_step == 1
+ assert agent_three.curr_node.state == curr_plan.states[1]
+
+
+def test_advance_n_time_steps_break_expected(
+ agent_three,
+):
+ agent_three.replan()
+ while len(agent_three.curr_plan.actions) < 3:
+ agent_three.replan()
+ curr_plan = agent_three.curr_plan
+ # Create an unexpected state
+ curr_plan.states[-1] = curr_plan.states[0]
+ # Should break from first plan one step early and be one step into second plan
+ agent_three.step(len(curr_plan.actions))
+ assert agent_three.agent_step == len(curr_plan.actions)
+ assert agent_three.action_step == 1
+ assert agent_three.curr_node.state == agent_three.curr_plan.states[1]
+
+
+def test_advance_time_steps_after_solution(agent_two):
+ plan, solved = agent_two.execute_search()
+ assert solved
+ old_time_step = agent_two.agent_step
+ old_state = agent_two.curr_node.state
+ agent_two.step()
+ assert agent_two.agent_step == old_time_step
+ assert agent_two.curr_node.state == old_state
+
+
+def test_agent_copy(agent_two):
+ new_agent = copy.copy(agent_two)
+ assert new_agent.agent_step == agent_two.agent_step
+ new_agent.step()
+ assert new_agent.agent_step != agent_two.agent_step
+
+
+def test_bounded_agent_set_time(dkg_stoch_astar_planner, dkg_state_three):
+ agent = BoundedRationalAgent(dkg_stoch_astar_planner, dkg_state_three, r=2, p=0.95)
+ agent_actions = [
+ ["right"],
+ ["right"],
+ ["right"],
+ ]
+ plan = get_plan_from_actions(
+ dkg_stoch_astar_planner.domain, dkg_state_three, agent_actions
+ )
+ agent.plan_history.append(plan)
+ agent.plan_index += 1
+ length_plan_one = len(agent.curr_plan.actions)
+ agent.execute_plan()
+ agent.replan()
+ agent.execute_plan()
+ agent.replan()
+ agent.execute_plan()
+ time = length_plan_one + 1
+ agent._set_to_timestep(time)
+ assert agent.plan_index == 1
+ assert agent.agent_step == time
diff --git a/src/beanmachine/ppl/experimental/goal_inference/agent/observation_model.py b/src/beanmachine/ppl/experimental/goal_inference/agent/observation_model.py
new file mode 100644
index 0000000000..8cf67e5b9d
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/agent/observation_model.py
@@ -0,0 +1,89 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+from abc import ABC, abstractmethod
+from typing import List
+
+import torch
+from beanmachine.facebook.goal_inference.environment import State
+
+
+class ObservationModel(ABC):
+ """Defines a probability distribution for observing states"""
+
+ @abstractmethod
+ def apply_noise(self, state) -> State:
+ """Applies noise to a state to obtain an observation
+
+ Arguments:
+ state: The state to apply noise to
+
+ Returns:
+ noisy_state: The state with noise applied
+
+ """
+ pass
+
+ @abstractmethod
+ def get_log_prob(self, state, observation) -> torch.Tensor:
+ """Gets the log probability of a observation given a state
+
+ Arguments:
+ state: The reference state
+ observation: The noisy observation
+
+ Returns:
+ log_prob: The log of P(observation|state)
+
+ """
+ pass
+
+
+class DeterministicObservation(ObservationModel):
+ """Defines an observation model with no noise"""
+
+ def apply_noise(self, state: State) -> State:
+ """Applies no noise to a state
+
+ Arguments:
+ state: The state to apply noise to
+
+ Returns:
+ state: The state with no noise applied
+
+ """
+ return dataclasses.replace(state)
+
+ def get_log_prob(self, state: State, observation: State) -> torch.Tensor:
+ """Gets the log probability of a observation given a state assuming P(observation | state) is a delta function
+
+ Arguments:
+ state: The reference state
+ observation: The noisy observation
+
+ Returns:
+ log_prob: The log of P(observation|state)
+
+ """
+ if state == observation:
+ return torch.tensor(0.0)
+ return torch.tensor(-float("inf"))
+
+
+def apply_noise_to_states(
+ states: List[State], noise_model: ObservationModel
+) -> List[State]:
+ """Applies noise to a series of states, returning a set of observations
+
+ Arguments:
+ states: The series of states to apply noise to
+ noise_model: The model defining the applied noise
+
+ Returns:
+ observations: A series of observations corresponding to states with applied noise
+
+ """
+ observations = []
+ for state in states:
+ observations.append(noise_model.apply_noise(state))
+ return observations
diff --git a/src/beanmachine/ppl/experimental/goal_inference/agent/observation_model_test.py b/src/beanmachine/ppl/experimental/goal_inference/agent/observation_model_test.py
new file mode 100644
index 0000000000..cac4c9b4cd
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/agent/observation_model_test.py
@@ -0,0 +1,18 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+
+import torch
+
+from beanmachine.facebook.goal_inference.agent.observation_model import (
+ DeterministicObservation,
+)
+
+
+def test_deterministic_noise(dkg_state_two):
+ noise_model = DeterministicObservation()
+ new_state = noise_model.apply_noise(dkg_state_two)
+ assert new_state == dkg_state_two
+ new_state_two = dataclasses.replace(dkg_state_two, x=dkg_state_two.x + 1)
+ assert torch.isneginf(noise_model.get_log_prob(new_state_two, dkg_state_two))
+ assert noise_model.get_log_prob(new_state, dkg_state_two) == 0.0
diff --git a/src/beanmachine/ppl/experimental/goal_inference/conftest.py b/src/beanmachine/ppl/experimental/goal_inference/conftest.py
new file mode 100644
index 0000000000..445f877bc7
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/conftest.py
@@ -0,0 +1,87 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import pytest
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_domain import DKGDomain
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.parser import parse
+
+from beanmachine.facebook.goal_inference.planner.astar import AstarPlanner
+
+from beanmachine.facebook.goal_inference.planner.planner import get_plan_from_actions
+
+from beanmachine.facebook.goal_inference.planner.stoch_astar import (
+ StochasticAstarPlanner,
+)
+
+from beanmachine.facebook.goal_inference.utils import manhattan_gem_heuristic
+
+
+@pytest.fixture(scope="module")
+def dkg_domain():
+ return DKGDomain()
+
+
+@pytest.fixture(scope="module")
+def dkg_state_one():
+ return parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-1.pddl"
+ )
+
+
+@pytest.fixture(scope="module")
+def dkg_state_two():
+ return parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-2.pddl"
+ )
+
+
+@pytest.fixture(scope="module")
+def dkg_state_three():
+ return parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-3.pddl"
+ )
+
+
+@pytest.fixture(scope="module")
+def dkg_state_four():
+ return parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-4.pddl"
+ )
+
+
+@pytest.fixture(scope="function")
+def dkg_astar_planner(dkg_domain):
+ return AstarPlanner(dkg_domain, manhattan_gem_heuristic)
+
+
+@pytest.fixture(scope="function")
+def dkg_stoch_astar_planner(dkg_domain):
+ return StochasticAstarPlanner(dkg_domain, manhattan_gem_heuristic, 0.1)
+
+
+@pytest.fixture(scope="function")
+def dkg_observation_set(dkg_domain, dkg_state_three):
+ actions = [
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["left"],
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["pickup", "key1"],
+ ["right"],
+ ["right"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ]
+ observed_plan = get_plan_from_actions(dkg_domain, dkg_state_three, actions)
+ return observed_plan.states
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_definitions.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_definitions.py
new file mode 100644
index 0000000000..a2e613663c
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_definitions.py
@@ -0,0 +1,140 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set, Tuple
+
+from beanmachine.facebook.goal_inference.environment import State
+
+from beanmachine.facebook.goal_inference.planner.planner import StateNode
+
+
+class Gem:
+ """A Gem object can be held by the agent
+
+ Arguments/Attributes:
+ name: The name of the Gem
+
+ """
+
+ __slots__ = "name"
+
+ def __init__(self, name: str):
+ self.name: str = name
+
+
+@dataclass(frozen=True, eq=True)
+class CGemState(State):
+ """A State of a continuous gems game is defined by the properties of the environment and the agent
+
+ Arguments/Attributes:
+
+ width: The width of the environment
+ height: The height of the environment
+
+ gems: Map from name to Gem for all gems in the problem
+ gem_size: The size of the gems. All points with manhattan distance to a gem < gem_size will be considered the gem.
+
+ has: Map from name to Gem for all gems held by agent.
+ at: Map from name to location for all gems not held by the agent.
+
+ obstacles: Positions of the center of obstacles
+ obstacle_size: The size of the obstacles. All points with manhattan distance to an obstacle < obstacle_size will be blocked.
+
+ agent_size: The size of the agent. All points with manhattan distance to a agent(x,y) < agent_size will be considered the agent.
+ x: X-position of Agent
+ y: Y-position of Agent
+ angle: Current Facing direction of agent. Angle is measured in degrees from rightward direction (0 is same as standard unit circle)
+
+ """
+
+ goal: Tuple[str, str]
+
+ width: float
+ height: float
+
+ gems: Dict[str, Gem]
+ gem_size: float
+
+ has: Dict[str, Gem]
+ at: Dict[str, Tuple[float, float]]
+
+ obstacles: Set[Tuple[float, float]]
+ obstacle_size: float
+
+ agent_size: float
+ x: float
+ y: float
+ angle: float
+
+ def __str__(self) -> str:
+ """Records the current state of the system as a string
+ Returns:
+ state_str: A string representation of the state
+
+ """
+ state_str = "Current State of Continuous Gems Problem\n”"
+ state_str += "Holding\n”"
+ state_str += str(list(self.has.keys()))
+ state_str += "\n"
+ state_str += "On Ground\n"
+ state_str += str(list(self.at.keys()))
+ state_str += "\n"
+ state_str += "X Position"
+ state_str += str(round(self.x * 4.0) / 4.0)
+ state_str += "\n"
+ state_str += "Y Position"
+ state_str += str(round(self.y * 4.0) / 4.0)
+ state_str += "\n"
+ state_str += "Angle"
+ state_str += str(round(self.angle, -1))
+ return state_str
+
+ def __hash__(self):
+ """Computes a hash of the state based on the string representation
+ Returns:
+ hash: The computed hash of the state
+ """
+ return hash(str(self))
+
+ def __eq__(self, other: CGemState) -> bool:
+ """Modifies the equality comparision by discretizing continuous variables
+
+ Arguments:
+ other: The State to compare with
+
+ Returns:
+ is_equal: Whether the two states are equal
+
+ """
+ if not isinstance(other, CGemState):
+ raise (RuntimeError("Tried to compare a CGemState with another object!"))
+ x_position = round(self.x * 4.0) / 4.0 == round(other.x * 4.0) / 4.0
+ y_position = round(self.y * 4.0) / 4.0 == round(other.y * 4.0) / 4.0
+ angle = round(self.angle, -1) == round(other.angle, -1)
+ has = self.has.keys() == other.has.keys()
+ return x_position and y_position and angle and has
+
+
+class CGemStateNode(StateNode):
+
+ """
+ Defines CGem nodes for graph-based representation of relationship between states.
+
+ Arguments/Attributes:
+ executed: Previous operation to get to this point in format [action_name,*args]
+ parent_node: Parent to this node
+ state: current State
+
+ """
+
+ def __init__(
+ self,
+ state: CGemState,
+ parent_node: Optional[CGemStateNode],
+ executed: List[str],
+ ):
+ self.executed: List[str] = executed
+ self.parent_node: Optional[CGemStateNode] = parent_node
+ self.state: CGemState = state
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_definitions_test.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_definitions_test.py
new file mode 100644
index 0000000000..bc66c8351c
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_definitions_test.py
@@ -0,0 +1,57 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemState,
+ Gem,
+)
+
+
+def test_initialize_gem():
+ gem1 = Gem("gem1")
+ gem2 = Gem("gem2")
+ assert gem1.name == "gem1"
+ assert gem1.name != gem2.name
+
+
+def test_initialize_cgem_state():
+ state_one = CGemState(
+ ("has", "gem1"),
+ 5.0,
+ 5.0,
+ {},
+ 0.5,
+ {},
+ {},
+ set(),
+ 0.5,
+ 0.5,
+ 2.0,
+ 2.0,
+ 50.0,
+ )
+ assert state_one.x == 2.0
+ assert state_one.y == 2.0
+
+
+def test_compare_cgem_state():
+ state_one = CGemState(
+ ("has", "gem1"),
+ 5.0,
+ 5.0,
+ {},
+ 0.5,
+ {},
+ {},
+ set(),
+ 0.5,
+ 0.5,
+ 2.0,
+ 2.0,
+ 50.0,
+ )
+ state_two = dataclasses.replace(state_one, x=state_one.x)
+ state_three = dataclasses.replace(state_one, x=state_one.x + 1)
+ assert state_one == state_two
+ assert state_one != state_three
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_domain.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_domain.py
new file mode 100644
index 0000000000..69bca49684
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_domain.py
@@ -0,0 +1,267 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+import math
+
+from typing import Any, List
+
+import numpy as np
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemState,
+)
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_utils import (
+ check_intersection,
+)
+from beanmachine.facebook.goal_inference.environment import Action, Domain
+
+from beanmachine.facebook.goal_inference.utils import manhattan_distance
+
+
+class CGemDomain(Domain):
+ """A hard-coded Domain of a continuous gems problem defining predicates (statements that evaluate to True or False) and possible actions
+
+ Atrributes:
+
+ name: Name specifying the domain is a Continuous Gems domain
+
+ Predicates -> True or False (Boolean) statements based on the current state
+
+ obstacle(x: int, y:int) -> Is there an obstacle at position x,y
+ has(name: str) -> Is the agent holding the object referred to by name
+ at(name: str, x:float, y:float) -> Is the object referred to by name on the ground at position x,y
+
+ Actions (Precondition) -> Modify the existing state given that a precondition is True
+
+ rotate(angle) -> rotate the direction the agent is facing angle degrees
+ move(distance) -> move forward distance in the direction the agent is facing
+ pickup(gem_name) -> pickup gem_name
+
+ """
+
+ def __init__(self):
+ self.name = "Continuous Gems"
+
+ self.predicates = {}
+
+ self.predicates["obstacle"] = self._obstacle
+ self.predicates["has"] = self._has
+ self.predicates["at"] = self._at
+
+ self.actions = {}
+
+ self.actions["rotate"] = Action(
+ "rotate", self._rotate_precondition, self._rotate
+ )
+ self.actions["move"] = Action("move", self._move_precondition, self._move)
+ self.actions["pickup"] = Action(
+ "pickup", self._pickup_precondition, self._pickup
+ )
+
+ def _obstacle(self, state: CGemState, x: float, y: float) -> bool:
+ """Determines if there is an obstacle at position (x,y)
+
+ Arguments:
+ state: State to analyze
+ x: X-position to analyze
+ y: Y-position to analyze
+
+ Returns:
+ _obstacle: Whether there is an obstacle at position (x,y)
+ """
+ for obstacle_position in state.obstacles:
+ if manhattan_distance(obstacle_position, (x, y)) < state.obstacle_size:
+ return True
+ return False
+
+ def _has(self, state: CGemState, name: str) -> bool:
+ """Determines if the agent is holding the object name
+
+ Arguments:
+ state: State to analyze
+ name: Name of the object to look for
+
+ Returns:
+ _has: Whether the agent is holding the object name
+ """
+ return name in state.has
+
+ def _at(self, state: CGemState, name: str, x: float, y: float) -> bool:
+ """Determins if there is the object name is a location (x,y)
+
+ Arguments:
+ state: State to analyze
+ name: Name of the object to look for
+ x: X-Position to analyze
+ y: Y-position to analyze
+
+ Returns:
+ _at: Whether there is the object name is a location (x,y)
+
+ """
+
+ return (
+ name in state.at
+ and manhattan_distance(state.at[name], (x, y)) < state.gem_size
+ )
+
+ def _rotate_precondition(self, state: CGemState, rotation_angle: float) -> bool:
+ """Determines whether a rotation is feasible in the current state
+
+ Arguments:
+ state: The current state
+ rotation_angle: The size of the rotation in degrees
+
+ Returns:
+ true: Rotations are always allowed
+
+ """
+ return True
+
+ def _rotate(self, state: CGemState, rotation_angle: float) -> CGemState:
+ """Rotates an agent by rotation_angle degrees
+
+ Arguments:
+ state: Current State
+ rotation_angle: How far to rotate the agent's orientation
+
+ Returns:
+ new_state: A new state with a modified angle
+
+ """
+ return dataclasses.replace(state, angle=(state.angle + rotation_angle) % 360.0)
+
+ def _move_precondition(self, state: CGemState, distance: float) -> bool:
+ """Determines whether a movement is feasible in the current state
+ The move is discretized into 10 substeps. Each substep is checked to ensure it does not collide with obstacles
+
+ Arguments:
+ state: Current State
+ distance: The size of the step forward
+
+ Returns:
+ can_move: True if the movement does not collide with obstacles
+
+ """
+ curr_x = state.x
+ curr_y = state.y
+ # Check for collisions with obstacles along the possible path
+ for _step in range(10):
+ # Move forward based on agent's direction
+ curr_x += 0.1 * distance * math.cos(math.radians(state.angle))
+ curr_y += 0.1 * distance * math.sin(math.radians(state.angle))
+ # Check for collisions with obstacles
+ for obstacle in state.obstacles:
+ if check_intersection(
+ obstacle, state.obstacle_size, (curr_x, curr_y), state.agent_size
+ ):
+ return False
+ if (
+ curr_x - state.agent_size < 0.0
+ or curr_x + state.agent_size > state.width
+ or curr_y - state.agent_size < 0.0
+ or curr_y + state.agent_size > state.height
+ ):
+ return False
+ return True
+
+ def _move(self, state: CGemState, distance: float) -> CGemState:
+ """Moves an agent forward by distance
+
+ Arguments:
+ state: Current State
+ distance: How far to move the agent forward
+
+ Returns:
+ new_state: A new state with a modified location
+
+ """
+ new_x = state.x + distance * math.cos(math.radians(state.angle))
+ new_y = state.y + distance * math.sin(math.radians(state.angle))
+ return dataclasses.replace(state, x=new_x, y=new_y)
+
+ def _pickup_precondition(self, state: CGemState, gem_name: str):
+ """Determines whether picking up gem_name is feasible in the current state
+ A gem can be pickup if the agent's rectangle overlaps with the gem's rectangle
+
+ Arguments:
+ state: Current State
+ gem_name: Gem to try and pickup
+
+ Returns:
+ _pickup_precondition: Whether the gem can be picked up
+
+ """
+ return gem_name in state.at and check_intersection(
+ state.at[gem_name], state.gem_size, (state.x, state.y), state.agent_size
+ )
+
+ def _pickup(self, state: CGemState, gem_name: str) -> CGemState:
+ """Picks up a gem with name gem_name
+
+ Arguments:
+ state: Current State
+ gem_name: Gem to pickup
+
+ Returns:
+ new_state: A new state holding the specified gem
+
+ """
+ new_has = state.has.copy()
+ new_at = state.at.copy()
+ new_has[gem_name] = state.gems[gem_name]
+ new_at.pop(gem_name)
+ return dataclasses.replace(state, has=new_has, at=new_at)
+
+ def get_possible_actions(self, state: CGemState) -> List[List[Any]]:
+ """Determines list of actions whose preconditions are met and will execute
+
+ Next possible actions include:
+ (1) A rotation sample from a Uniform distribution [0.0,360.0)
+ (2) A forward move with distance drawn from Uniform(0,1) (If possible)
+ (3) Any possible pickups
+
+ Arguments:
+ state: Current state
+ Returns:
+ possible_actions: A list of possible actions for the next time step
+ """
+ possible_actions = []
+ rotation = 360 * np.random.rand()
+ if self.is_action_possible(state, "rotate", rotation):
+ possible_actions.append(["rotate", rotation])
+ step = np.random.rand()
+ if self.is_action_possible(state, "move", step):
+ possible_actions.append(["move", step])
+
+ for name in state.at:
+ if self.is_action_possible(state, "pickup", name):
+ possible_actions.append(["pickup", name])
+
+ return possible_actions
+
+ def is_action_possible(self, state: CGemState, action_name: str, *args) -> bool:
+ """Evaluates whether the predicate of the action is satisfied
+
+ Arguments:
+ state: Current State to analyze
+ action_name: Action being attempted
+ *args: Parameters of the action
+
+ Returns:
+ is_action_possible: Whether the predicate of the action is satisfied
+
+ """
+ return self.actions[action_name].check_precondition(state, *args)
+
+ def evaluate_goal(self, state: CGemState) -> bool:
+ """Evaluates whether the current goal is achieved
+
+ Arguments:
+ state: Current State to analyze
+
+ Returns:
+ is_goal_achieved: Whether the current goal is achieved
+
+ """
+ return self.predicates[state.goal[0]](state, state.goal[1])
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_domain_test.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_domain_test.py
new file mode 100644
index 0000000000..d032c31498
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_domain_test.py
@@ -0,0 +1,85 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import math
+
+import pytest
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_domain import CGemDomain
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_parse import parse
+
+
+@pytest.fixture(scope="function")
+def cgem_domain():
+ return CGemDomain()
+
+
+@pytest.fixture(scope="function")
+def state_one():
+ return parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-1.json"
+ )
+
+
+def test_domain_predicates(cgem_domain, state_one):
+ assert not cgem_domain.predicates["has"](state_one, "gem1")
+ assert cgem_domain.predicates["at"](state_one, "gem1", 4.0, 0.5)
+ assert cgem_domain.predicates["at"](state_one, "gem1", 4.1, 0.6)
+ assert not cgem_domain.predicates["at"](state_one, "gem1", 4.6, 0.6)
+ assert cgem_domain.predicates["obstacle"](state_one, 2.0, 2.0)
+ assert cgem_domain.predicates["obstacle"](state_one, 2.1, 2.1)
+ assert not cgem_domain.predicates["obstacle"](state_one, 0.01, 0.01)
+
+
+def test_domain_rotate(cgem_domain, state_one):
+ assert cgem_domain.is_action_possible(state_one, "rotate", 10.0)
+ assert cgem_domain.is_action_possible(state_one, "rotate", -10.0)
+ new_state = cgem_domain.execute(state_one, "rotate", -10.0)
+ assert math.isclose(new_state.angle, 350.0, abs_tol=0.1)
+ new_state = cgem_domain.execute(new_state, "rotate", 15.0)
+ assert math.isclose(new_state.angle, 5.0, abs_tol=0.1)
+ new_state = cgem_domain.execute(new_state, "rotate", 15.0)
+ assert math.isclose(new_state.angle, 20.0, abs_tol=0.1)
+
+
+def test_domain_move(cgem_domain, state_one):
+ new_state = cgem_domain.execute(state_one, "rotate", 180.0)
+ assert not cgem_domain.is_action_possible(new_state, "move", 0.8)
+ assert not cgem_domain.is_action_possible(new_state, "move", 10.0)
+ assert cgem_domain.is_action_possible(new_state, "move", 0.1)
+ new_state = cgem_domain.execute(new_state, "move", 0.1)
+ assert math.isclose(new_state.x, state_one.x - 0.1, abs_tol=0.01)
+ assert math.isclose(new_state.y, state_one.y, abs_tol=0.01)
+ new_state_two = cgem_domain.execute(new_state, "rotate", -135.0)
+ new_state_two = cgem_domain.execute(new_state_two, "move", 0.1)
+ assert math.isclose(
+ new_state_two.x, new_state.x + 0.1 * math.sqrt(2.0) / 2.0, abs_tol=0.01
+ )
+ assert math.isclose(
+ new_state_two.y, new_state.y + 0.1 * math.sqrt(2.0) / 2.0, abs_tol=0.01
+ )
+
+
+def test_domain_pickup(cgem_domain, state_one):
+ assert not cgem_domain.evaluate_goal(state_one)
+ new_state = cgem_domain.execute(state_one, "rotate", 270.0)
+ new_state = cgem_domain.execute(new_state, "move", 0.5)
+ new_state = cgem_domain.execute(new_state, "rotate", 90.0)
+ new_state = cgem_domain.execute(new_state, "move", 2.9)
+ assert not cgem_domain.is_action_possible(new_state, "pickup", "gem2")
+ new_state = cgem_domain.execute(new_state, "pickup", "gem1")
+ assert cgem_domain.evaluate_goal(new_state)
+
+
+def test_domain_next_possible_actions(cgem_domain, state_one):
+ possible_actions = cgem_domain.get_possible_actions(state_one)
+ assert len(possible_actions) == 2
+ assert possible_actions[0][0] == "rotate"
+ assert possible_actions[1][0] == "move"
+ new_state = cgem_domain.execute(state_one, "move", 2.9)
+ possible_actions = cgem_domain.get_possible_actions(new_state)
+ assert possible_actions[0][0] == "rotate"
+ assert possible_actions[-1] == ["pickup", "gem1"]
+ new_state_two = cgem_domain.execute(state_one, "rotate", 270.0)
+ new_state_two = cgem_domain.execute(new_state_two, "move", 0.74999)
+ possible_actions = cgem_domain.get_possible_actions(new_state_two)
+ assert len(possible_actions) == 1
+ assert possible_actions[0][0] == "rotate"
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_observation_model.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_observation_model.py
new file mode 100644
index 0000000000..41773b8f87
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_observation_model.py
@@ -0,0 +1,111 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import copy
+import dataclasses
+
+import torch
+from beanmachine.facebook.goal_inference.agent.observation_model import ObservationModel
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemState,
+)
+from beanmachine.facebook.goal_inference.environment import State
+from torch.distributions.bernoulli import Bernoulli
+from torch.distributions.normal import Normal
+
+
+class CGemObservation(ObservationModel):
+ """Defines a probability distribution for observing states for a continuous gems problem.
+
+ Agent positions (x,y) and angles are modified with Gaussian noise
+ Held gems are modified with bernoulli noise
+
+ Arguments/Attributes:
+ position_noise: Scale of the noise applied when observing positions
+ bernoulli_noise: Chance of gem being flipped from held->unheld or unheld -> held
+ angle_noise: Scale of the noise applied when observing angles
+ """
+
+ def __init__(
+ self,
+ position_noise: float = 0.5,
+ bernoulli_noise: float = 0.05,
+ angle_noise=120.0,
+ ):
+ self.position_noise: Normal = Normal(0.0, position_noise)
+ self.bernoulli_noise: Bernoulli = Bernoulli(bernoulli_noise)
+ self.angle_noise: Normal = Normal(0.0, angle_noise)
+
+ def apply_noise(self, state: CGemState) -> State:
+ """Applies noise to a state to obtain an observation
+
+ Arguments:
+ state: The state to apply noise to
+
+ Returns:
+ noisy_state: The state with noise applied
+
+ """
+
+ new_at = copy.copy(state.at)
+ new_has = copy.copy(state.has)
+
+ # Apply Noise to gems
+ for gem_id in state.gems:
+ if gem_id in new_at:
+ # Chance that gem at (x,y) is not observed
+ if self.bernoulli_noise.sample():
+ new_at.pop(gem_id)
+
+ else:
+ # Chance that held gem is not observed
+ if self.bernoulli_noise.sample():
+ new_has.pop(gem_id)
+
+ # Apply Gaussian noise to positions / angles
+ return dataclasses.replace(
+ state,
+ has=new_has,
+ at=new_at,
+ x=state.x + self.position_noise.sample().item(),
+ y=state.y + self.position_noise.sample().item(),
+ angle=(state.angle + self.angle_noise.sample().item()) % 360.0,
+ )
+
+ def get_log_prob(self, state: CGemState, observation: CGemState) -> torch.Tensor:
+ """Gets the log probability of a observation given a state
+
+ Arguments:
+ state: The reference state
+ observation: The noisy observation
+
+ Returns:
+ log_prob: The log of P(observation|state)
+
+ """
+
+ log_prob_gems = 0.0
+ # Evaluate Probability of Item positions
+ for gem_id in state.gems:
+ # If gem is not flipped
+ if (gem_id in state.has and gem_id in observation.has) or (
+ gem_id in state.at and gem_id in observation.at
+ ):
+ log_prob_gems += self.bernoulli_noise.log_prob(torch.tensor(0.0))
+ # If gem is flipped
+ else:
+ log_prob_gems += self.bernoulli_noise.log_prob(torch.tensor(1.0))
+
+ # Evaluate probability of positions
+ log_prob_x = self.position_noise.log_prob(torch.tensor(state.x - observation.x))
+ log_prob_y = self.position_noise.log_prob(torch.tensor(state.y - observation.y))
+
+ # Evaluate probability of angles
+ difference = torch.tensor(state.angle - observation.angle)
+ if difference > 180.0:
+ difference = 360.0 - difference
+ elif difference < -180.0:
+ difference = -(difference + 360.0)
+
+ log_prob_angle = self.angle_noise.log_prob(difference)
+
+ return log_prob_x + log_prob_y + log_prob_angle + log_prob_gems
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_observation_test.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_observation_test.py
new file mode 100644
index 0000000000..3e2005f162
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_observation_test.py
@@ -0,0 +1,64 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+import math
+
+import torch
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_observation_model import (
+ CGemObservation,
+)
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_parse import parse
+from torch.distributions.normal import Normal
+
+
+def test_cgem_observation_noise_positions_and_angles():
+ state = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-2.json"
+ )
+ noise_model = CGemObservation(bernoulli_noise=0.0)
+ noisy_state = noise_model.apply_noise(state)
+ assert state.x != noisy_state.x
+ assert state.y != noisy_state.y
+ assert state.angle != noisy_state.angle
+ assert state.has == noisy_state.has
+ assert state.at == noisy_state.at
+
+
+def test_cgem_observation_noise_gems():
+ state = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-2.json"
+ )
+ noise_model = CGemObservation(
+ position_noise=0.01, angle_noise=0.01, bernoulli_noise=1.0
+ )
+ noisy_state = noise_model.apply_noise(state)
+ assert math.isclose(state.x, noisy_state.x, abs_tol=0.25)
+ assert math.isclose(state.y, noisy_state.y, abs_tol=0.25)
+ assert not noisy_state.at.keys()
+ assert not noisy_state.has.keys()
+
+
+def test_cgem_observation_log_prob():
+ state = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-2.json"
+ )
+ noise_model = CGemObservation()
+ new_state = dataclasses.replace(state, x=state.x + 1.0)
+ log_prob = noise_model.get_log_prob(state, new_state)
+
+ calc_log_prob = torch.tensor(0.0)
+ calc_log_prob += Normal(torch.tensor(state.x), torch.tensor(0.5)).log_prob(
+ torch.tensor(state.x + 1)
+ )
+
+ calc_log_prob += Normal(torch.tensor(state.y), torch.tensor(0.5)).log_prob(
+ torch.tensor(state.y)
+ )
+
+ calc_log_prob += Normal(torch.tensor(state.angle), torch.tensor(120.0)).log_prob(
+ torch.tensor(state.angle)
+ )
+
+ calc_log_prob += torch.log(torch.tensor(0.95)) * (len(state.gems.keys()))
+
+ assert torch.isclose(calc_log_prob, log_prob, atol=0.01)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_parse.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_parse.py
new file mode 100644
index 0000000000..7078303422
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_parse.py
@@ -0,0 +1,45 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import json
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemState,
+ Gem,
+)
+
+
+def parse(file_path: str) -> CGemState:
+ """Reads in selected continuous gems problem. Intializes state by parsing file for objects, rules, and goal.
+
+ Arguments:
+ file_path: Path pointing to the selected problem
+
+ Returns:
+ initial_state: The initial state of the continuous gems problem
+ """
+ with open(file_path) as problem_file:
+ cgem_problem_data = json.load(problem_file)
+
+ at = {}
+ gems = {}
+ for gem_id in cgem_problem_data["gem_locations"]:
+ gems[gem_id] = Gem(gem_id)
+ at[gem_id] = tuple(cgem_problem_data["gem_locations"][gem_id])
+ has = {}
+ obstacles = [tuple(obstacle) for obstacle in cgem_problem_data["obstacles"]]
+
+ return CGemState(
+ tuple(cgem_problem_data["goal"]),
+ cgem_problem_data["width"],
+ cgem_problem_data["height"],
+ gems,
+ cgem_problem_data["gem_size"],
+ has,
+ at,
+ set(obstacles),
+ cgem_problem_data["obstacle_size"],
+ cgem_problem_data["agent_size"],
+ cgem_problem_data["x"],
+ cgem_problem_data["y"],
+ cgem_problem_data["angle"],
+ )
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_parse_test.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_parse_test.py
new file mode 100644
index 0000000000..156af86378
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_parse_test.py
@@ -0,0 +1,67 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_parse import parse
+
+
+def test_cgem_parse_problem_one():
+ problem_one = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-1.json"
+ )
+ assert problem_one.goal == ("has", "gem1")
+ assert problem_one.width == 5.0
+ assert problem_one.height == 5.0
+ assert problem_one.gem_size == 0.25
+ assert list(problem_one.at.keys()) == ["gem1", "gem2"]
+ assert problem_one.at["gem1"] == (4.0, 0.5)
+ assert problem_one.at["gem2"] == (0.5, 4.0)
+ assert (2.0, 2.0) in problem_one.obstacles
+ assert (2.0, 2.5) in problem_one.obstacles
+ assert (4.0, 4.0) in problem_one.obstacles
+ assert (0.5, 4.0) not in problem_one.obstacles
+ assert problem_one.obstacle_size == 0.25
+ assert problem_one.agent_size == 0.25
+ assert problem_one.x == 1.0
+ assert problem_one.y == 1.0
+ assert problem_one.angle == 0.0
+
+
+def test_cgem_parse_problem_two():
+ problem_one = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-2.json"
+ )
+ assert problem_one.goal == ("has", "gem1")
+ assert problem_one.width == 5.0
+ assert problem_one.height == 5.0
+ assert problem_one.gem_size == 0.25
+ assert list(problem_one.at.keys()) == ["gem1", "gem2"]
+ assert problem_one.at["gem1"] == (0.5, 4.0)
+ assert problem_one.at["gem2"] == (4.0, 4.0)
+ assert (1.5, 0.5) in problem_one.obstacles
+ assert (4.5, 0.5) in problem_one.obstacles
+ assert (4.0, 4.0) not in problem_one.obstacles
+ assert problem_one.obstacle_size == 0.5
+ assert problem_one.agent_size == 0.25
+ assert problem_one.x == 1.5
+ assert problem_one.y == 1.5
+ assert problem_one.angle == 0.0
+
+
+def test_cgem_parse_problem_three():
+ problem_one = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-3.json"
+ )
+ assert problem_one.goal == ("has", "gem1")
+ assert problem_one.width == 5.0
+ assert problem_one.height == 5.0
+ assert problem_one.gem_size == 0.25
+ assert list(problem_one.at.keys()) == ["gem1", "gem2"]
+ assert problem_one.at["gem1"] == (0.5, 4.5)
+ assert problem_one.at["gem2"] == (4.5, 0.5)
+ assert (0.25, 1.5) in problem_one.obstacles
+ assert (2.0, 1.5) in problem_one.obstacles
+ assert (0.321, 0.87) not in problem_one.obstacles
+ assert problem_one.obstacle_size == 0.25
+ assert problem_one.agent_size == 0.25
+ assert problem_one.x == 2.5
+ assert problem_one.y == 2.5
+ assert problem_one.angle == 0.0
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_plot.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_plot.py
new file mode 100644
index 0000000000..877ac21647
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_plot.py
@@ -0,0 +1,180 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from typing import Dict, List, Optional
+
+import matplotlib
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemState,
+)
+
+from beanmachine.facebook.goal_inference.plotting.utils import (
+ create_gif,
+ format_gem_data,
+ get_gem_figure,
+ get_gem_inference_plot,
+)
+
+from matplotlib import colors
+from matplotlib.patches import Rectangle
+
+
+""" Set Plot Settings.
+Colors are defined as follows:
+Empty -> White
+Obstacle -> Black
+Agent -> Red
+Gem -> blue, green, or purple
+"""
+
+CMAP = colors.ListedColormap(["white", "black", "red", "blue", "green", "purple"])
+BOUNDS = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
+NORM = colors.BoundaryNorm(BOUNDS, CMAP.N)
+plt.rcParams["axes.edgecolor"] = "black"
+plt.rcParams["axes.linewidth"] = 2.50
+
+
+def plot(state: CGemState):
+
+ """Creates graphic for current state
+
+ Arguments:
+ state: State to plot
+ """
+
+ fig, ax = get_gem_figure(state)
+ hold_data = get_data_matrix(state)
+ add_data_to_axes(ax, state, hold_data)
+ plt.show()
+ plt.close()
+
+
+def plot_gif(
+ states: List[CGemState],
+ inference_data: Optional[List[Dict[str, int]]] = None,
+ file_path: Optional[str] = None,
+) -> None:
+ """Creates a gif from a list of states and inference data (if available)
+
+ Arguments:
+ states: Series of states to turn into a gif
+ inference_data: Computation of the posterior P(goal|observations) at each time step
+ file_path: Path to location to save the gif
+ """
+
+ fig, ax = get_gem_figure(states[0], inference_data)
+
+ def animation_function(frame):
+ state = states[frame]
+ hold_data = get_data_matrix(state)
+ add_data_to_axes(ax, state, hold_data)
+ if inference_data is not None:
+ prob_goal = get_gem_inference_plot(inference_data, frame)
+ for goal in prob_goal:
+ ax[2].plot(prob_goal[goal], color=CMAP(NORM(2.5 + float(goal[3]))))
+
+ create_gif(fig, animation_function, states, file_path)
+
+ plt.close()
+
+
+def get_data_matrix(state: CGemState) -> np.ndarray:
+ """Computes formatted holding data
+
+ Arguments:
+ state: The current state
+
+ Returns:
+ data_hold: Correctly formatted data array of the held gems
+ """
+
+ data_hold = get_hold_data(state)
+
+ data_hold = format_gem_data(
+ data_hold,
+ )
+
+ return data_hold
+
+
+def get_hold_data(state: CGemState) -> np.ndarray:
+ """Computes holding data matrix (defining colors) based on objects agent currently holds
+
+ Arguments:
+ state: The current state
+
+ Returns:
+ data_hold: Data array containing identities of the held gems
+ """
+
+ data_hold = np.zeros((1, 8))
+
+ count = 0
+
+ for item_id in state.gems:
+ if item_id in state.has:
+ data_hold[0, count] = 2.0 + int(item_id[3])
+ count += 1
+
+ return data_hold
+
+
+def add_data_to_axes(
+ ax: List[matplotlib.axes.Axes], state: CGemState, hold_data: np.ndarray
+) -> None:
+ """Adds Environment and held data to subplots
+
+ Arguments:
+ ax: List of axes objects in the current figure
+ state: Current state to plot
+ hold_data: Correctly formmatted data array for held gems
+
+ """
+ # Plot Agent
+ ax[0].add_patch(
+ Rectangle(
+ (state.x - state.agent_size, state.y - state.agent_size),
+ state.agent_size * 2.0,
+ state.agent_size * 2.0,
+ color="red",
+ )
+ )
+
+ # Plot Obstacles
+ for obstacle in state.obstacles:
+ ax[0].add_patch(
+ Rectangle(
+ (obstacle[0] - state.obstacle_size, obstacle[1] - state.obstacle_size),
+ state.obstacle_size * 2.0,
+ state.obstacle_size * 2.0,
+ color="black",
+ )
+ )
+
+ # Plot Gems
+ for gem_id in state.gems:
+ if gem_id in state.at:
+ ax[0].add_patch(
+ Rectangle(
+ (
+ state.at[gem_id][0] - state.gem_size,
+ state.at[gem_id][1] - state.gem_size,
+ ),
+ state.gem_size * 2.0,
+ state.gem_size * 2.0,
+ color=CMAP(NORM(2.5 + float(gem_id[3]))),
+ )
+ )
+
+ # Plot Held Objects
+ ax[1].imshow(
+ hold_data,
+ cmap=CMAP,
+ norm=NORM,
+ origin="lower",
+ interpolation="none",
+ extent=[0.5, 1.5, 0.5, 8.5],
+ )
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_utils.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_utils.py
new file mode 100644
index 0000000000..7ca9a91ef9
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_utils.py
@@ -0,0 +1,28 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from typing import Tuple
+
+
+def check_intersection(
+ obstacle_position: Tuple[float, float],
+ obstacle_size: float,
+ agent_position: Tuple[float, float],
+ agent_size: float,
+) -> bool:
+ """Determines whether the agent intersects an obstacle by computing whether to two rectangles intersect
+
+ Arguments:
+ obstacle_position: Center of the obstacle
+ obstacle_size: Size of the obstacle
+ agent_position: Center of the agent
+ agent_size: Size of the agent
+
+ Returns:
+ check_intersection: Whether the agent intersects with the object
+ """
+ return not (
+ obstacle_position[0] + obstacle_size < agent_position[0] - agent_size
+ or obstacle_position[0] - obstacle_size > agent_position[0] + agent_size
+ or obstacle_position[1] + obstacle_size < agent_position[1] - agent_size
+ or obstacle_position[1] - obstacle_size > agent_position[1] + agent_size
+ )
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_utils_test.py b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_utils_test.py
new file mode 100644
index 0000000000..724aa69240
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/cgem_utils_test.py
@@ -0,0 +1,13 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_utils import (
+ check_intersection,
+)
+
+
+def test_intersection():
+ assert not check_intersection((0.0, 0.0), 1.0, (2.0, 2.0), 0.1)
+ assert not check_intersection((0.0, 0.0), 1.0, (2.0, 2.0), 0.9)
+ assert check_intersection((0.0, 0.0), 1.0, (2.0, 2.0), 1.0)
+ assert check_intersection((0.0, 0.0), 0.1, (0.0, 0.0), 0.1)
+ assert check_intersection((0.0, 0.0), 1.0, (2.0, 0.0), 1.0)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-1.json b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-1.json
new file mode 100644
index 0000000000..afc5a0389e
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-1.json
@@ -0,0 +1,75 @@
+{
+ "goal": [
+ "has",
+ "gem1"
+ ],
+ "width": 5.0,
+ "height": 5.0,
+ "gem_size": 0.25,
+ "gem_locations": {
+ "gem1": [
+ 4.0,
+ 0.5
+ ],
+ "gem2": [
+ 0.5,
+ 4.0
+ ]
+ },
+ "obstacles": [
+ [
+ 2.0,
+ 2.0
+ ],
+ [
+ 2.0,
+ 2.5
+ ],
+ [
+ 3.0,
+ 3.5
+ ],
+ [
+ 4.0,
+ 4.5
+ ],
+ [
+ 2.5,
+ 2.5
+ ],
+ [
+ 3.5,
+ 2.5
+ ],
+ [
+ 3.0,
+ 2.5
+ ],
+ [
+ 3.0,
+ 3.0
+ ],
+ [
+ 3.0,
+ 4.0
+ ],
+ [
+ 3.5,
+ 4.0
+ ],
+ [
+ 4.0,
+ 4.0
+ ],
+ [
+ 4.0,
+ 5.0
+ ]
+
+ ],
+ "obstacle_size": 0.25,
+ "agent_size": 0.25,
+ "x": 1.0,
+ "y": 1.0,
+ "angle": 0.0
+}
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-2.json b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-2.json
new file mode 100644
index 0000000000..9c08466201
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-2.json
@@ -0,0 +1,74 @@
+{
+ "goal": [
+ "has",
+ "gem1"
+ ],
+ "width": 5.0,
+ "height": 5.0,
+ "gem_size": 0.25,
+ "gem_locations": {
+ "gem1": [
+ 0.5,
+ 4.0
+ ],
+ "gem2": [
+ 4.0,
+ 4.0
+ ]
+ },
+ "obstacles": [
+ [
+ 0.5,
+ 0.5
+ ],
+ [
+ 1.5,
+ 0.5
+ ],
+ [
+ 2.5,
+ 0.5
+ ],
+ [
+ 3.5,
+ 0.5
+ ],
+ [
+ 4.5,
+ 0.5
+ ],
+ [
+ 1.0,
+ 0.5
+ ],
+ [
+ 2.5,
+ 1.5
+ ],
+ [
+ 3.5,
+ 1.5
+ ],
+ [
+ 4.5,
+ 1.5
+ ],
+ [
+ 2.5,
+ 2.5
+ ],
+ [
+ 3.5,
+ 2.5
+ ],
+ [
+ 4.5,
+ 2.5
+ ]
+ ],
+ "obstacle_size": 0.5,
+ "agent_size": 0.25,
+ "x": 1.5,
+ "y": 1.5,
+ "angle": 0.0
+}
diff --git a/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-3.json b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-3.json
new file mode 100644
index 0000000000..f45537043a
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/continuous_gems/test_problems/problem-3.json
@@ -0,0 +1,90 @@
+{
+ "goal": [
+ "has",
+ "gem1"
+ ],
+ "width": 5.0,
+ "height": 5.0,
+ "gem_size": 0.25,
+ "gem_locations": {
+ "gem1": [
+ 0.5,
+ 4.5
+ ],
+ "gem2": [
+ 4.5,
+ 0.5
+ ]
+ },
+ "obstacles": [
+ [
+ 0.25,
+ 1.5
+ ],
+ [
+ 0.5,
+ 1.5
+ ],
+ [
+ 1.0,
+ 1.5
+ ],
+ [
+ 1.5,
+ 1.5
+ ],
+ [
+ 2.0,
+ 1.5
+ ],
+ [
+ 2.5,
+ 1.5
+ ],
+ [
+ 3.0,
+ 1.5
+ ],
+ [
+ 3.5,
+ 1.5
+ ],
+ [
+ 4.75,
+ 3.5
+ ],
+ [
+ 4.5,
+ 3.5
+ ],
+ [
+ 4.0,
+ 3.5
+ ],
+ [
+ 3.5,
+ 3.5
+ ],
+ [
+ 3.0,
+ 3.5
+ ],
+ [
+ 2.5,
+ 3.5
+ ],
+ [
+ 2.0,
+ 3.5
+ ],
+ [
+ 1.5,
+ 3.5
+ ]
+ ],
+ "obstacle_size": 0.25,
+ "agent_size": 0.25,
+ "x": 2.5,
+ "y": 2.5,
+ "angle": 0.0
+}
diff --git a/src/beanmachine/ppl/experimental/goal_inference/docs/README.rst b/src/beanmachine/ppl/experimental/goal_inference/docs/README.rst
new file mode 100644
index 0000000000..e92469d024
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/docs/README.rst
@@ -0,0 +1,4 @@
+Sequential Monte Carlo for Goal Inference
+##################
+
+**Author: James Damewood**
diff --git a/src/beanmachine/ppl/experimental/goal_inference/docs/TARGETS b/src/beanmachine/ppl/experimental/goal_inference/docs/TARGETS
new file mode 100644
index 0000000000..53f6dffa20
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/docs/TARGETS
@@ -0,0 +1,17 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+load("@fbcode_macros//build_defs:sphinx_wiki.bzl", "sphinx_wiki")
+
+oncall("hackppl")
+
+sphinx_wiki(
+ name = "docs",
+ srcs = ["README.rst"],
+ apidoc_modules = {
+ "beanmachine.facebook.goal_inference": "api",
+ },
+ python_library_deps = [
+ "//beanmachine/facebook/goal_inference:goal_inference",
+ ],
+ wiki_root_path = "Users/jkdamewo/goal_inference_api",
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/definitions_test.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/definitions_test.py
new file mode 100644
index 0000000000..4addead020
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/definitions_test.py
@@ -0,0 +1,70 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import pytest
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import (
+ Direction,
+ Gem,
+ Item,
+ Key,
+)
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.parser import parse
+
+####### Test Definition
+
+
+@pytest.fixture
+def key():
+ k1 = Key("key1")
+ return k1
+
+
+@pytest.fixture
+def gem():
+ g1 = Gem("gem1")
+ return g1
+
+
+@pytest.fixture
+def state():
+ state = parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-1.pddl"
+ )
+ return state
+
+
+@pytest.fixture
+def right_direction():
+ right_direction = Direction("right")
+ return right_direction
+
+
+def test_gem_name(gem):
+ assert gem.name == "gem1"
+
+
+def test_gem_class(gem):
+ assert isinstance(gem, Gem) and isinstance(gem, Item)
+
+
+def test_key_name(key):
+ assert key.name == "key1"
+
+
+def test_key_class(key):
+ assert isinstance(key, Key) and isinstance(key, Item)
+
+
+def test_direction_name(right_direction):
+ assert right_direction.name == "right"
+
+
+def test_direction_class(right_direction):
+ assert isinstance(right_direction, Direction) and not isinstance(
+ right_direction, Item
+ )
+
+
+def test_str(state):
+ assert isinstance(str(state), str)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_definitions.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_definitions.py
new file mode 100644
index 0000000000..a1dd9bfd25
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_definitions.py
@@ -0,0 +1,155 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set, Tuple
+
+from beanmachine.facebook.goal_inference.environment import State
+
+from beanmachine.facebook.goal_inference.planner.planner import StateNode
+
+
+class Item:
+ """An Item object can be held by the agent
+
+ Arguments/Attributes:
+ name: The name of the Item
+ """
+
+ __slots__ = "name"
+
+ def __init__(self, name: str):
+ self.name: str = name
+
+
+class Key(Item):
+ """A Key is an Item that can open doors
+
+ Arguments/Attributes:
+ name: The name of the Key
+ """
+
+ pass
+
+
+class Gem(Item):
+ """A Gem is an Item that can be the goal
+
+ Arguments/Attributes:
+ name: The name of the Gem
+ """
+
+ pass
+
+
+class Direction:
+ """A Direction determines the possible interactions with the environment [e.g. movement, unlocking doors]
+
+ Arguments/Attributes:
+ name: The name of the Direction
+ """
+
+ __slots__ = "name"
+
+ def __init__(self, name: str):
+ self.name: str = name
+
+
+@dataclass(frozen=True, eq=True)
+class DKGState(State):
+ """A State of a doors, keys, and gems game is defined by the properties of the environment and the Agent
+
+ Arguments/Attributes:
+
+ width: The width of the environment
+ height: The height of the environment
+ xdiff: Movement/Interaction along x-axis when given a direction
+ ydiff: Movement/Interaction along y-axis when given a direction
+
+ doors: Positions of doors
+ walls: Positions of walls
+
+ items: Map from name to Item for all Items remaining in game
+ directions: Map from name to Direction
+ keys: Map from name to Key for all Keys remaining in game
+ gems: Map from name to Gem for all Gems remaining in game
+
+ has: Map from name to Item for all Items held by Agent
+ at: Map from name to Location for all Items not held by the Agent
+
+ x: X-position of Agent
+ y: Y-position of Agent
+
+ """
+
+ goal: Tuple[str, str]
+
+ width: int
+ height: int
+ xdiff: Dict[str, int]
+ ydiff: Dict[str, int]
+
+ doors: Set[(Tuple[int, int])]
+ walls: Set[(Tuple[int, int])]
+
+ items: Dict[str, Item]
+ directions: Dict[str, Direction]
+ keys: Dict[str, Key]
+ gems: Dict[str, Gem]
+
+ has: Dict[str, Item]
+ at: Dict[str, Tuple[int, int]]
+
+ x: int
+ y: int
+
+ def __str__(self) -> str:
+ """Records the current state of the system as a string
+ Returns:
+ state_str: A string representation of the state
+ """
+ state_str = "Current State of DKG Problem\n”"
+ state_str += "Holding\n”"
+ state_str += str(list(self.has.keys()))
+ state_str += "\n"
+ state_str += "On Ground\n"
+ state_str += str(list(self.at.keys()))
+ state_str += "\n"
+ state_str += "X Position"
+ state_str += str(self.x)
+ state_str += "\n"
+ state_str += "Y Position"
+ state_str += str(self.y)
+ return state_str
+
+ def __hash__(self):
+ """Computes a hash of the state based on the string representation
+ Returns:
+ hash: The computed hash of the state
+ """
+ return hash(str(self))
+
+
+class DKGStateNode(StateNode):
+
+ """
+ Defines DKG nodes for graph-based representation of relationship between states.
+
+ Arguments/Attributes:
+
+ executed: Previous operation to get to this point in format [action_name,*args]
+ parent_node: Parent to this node
+ state: current State
+
+ """
+
+ def __init__(
+ self,
+ state: DKGState,
+ parent_node: Optional[DKGStateNode],
+ executed: List[str],
+ ):
+ self.executed: List[str] = executed
+ self.parent_node: Optional[DKGStateNode] = parent_node
+ self.state: DKGState = state
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_domain.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_domain.py
new file mode 100644
index 0000000000..41487068d4
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_domain.py
@@ -0,0 +1,359 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+
+from typing import List
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import DKGState
+from beanmachine.facebook.goal_inference.environment import Action, Domain
+
+
+class DKGDomain(Domain):
+ """A hard-coded Domain of a doors, keys, and gems game defining predicates (statements that evaluate to True or False) and possible Actions
+
+ Atrributes:
+
+ name: Name specifying the domain is a DKG domain
+
+ Predicates -> True or False (Boolean) statement based on the current state
+
+ wall(x: int,y: int) -> Is there a wall at position x,y
+ door(x: int,y: int) -> Is there a door at position x,y
+ obstacle(x: int, y:int) -> Is there a door or wall at position x,y
+ has(name: str) -> Is the agent holding the object name
+ at(name: str, x:int, y:int) -> Is the object name on the ground at position x,y
+
+ Actions (Precondition) -> Modify the existing state given that a precondition is True
+
+ down (If not blocked by boundary or obstacle) -> move state down
+ up (If not blocked by boundary or obstacle) -> move state up
+ left (If not blocked by boundary or obstacle) -> move state left
+ right (If not blocked by boundary or obstacle) -> move state right
+ pickup (If Agent is at x,y and item is at x,y) -> Pickup Item
+ unlock (If Agent has a key and there is a door in specified direction) -> Unlock Door (losing key)
+ """
+
+ def __init__(self):
+ self.name = "DKG"
+
+ self.predicates = {}
+
+ self.predicates["wall"] = self._wall
+ self.predicates["door"] = self._door
+ self.predicates["obstacle"] = self._obstacle
+ self.predicates["has"] = self._has
+ self.predicates["at"] = self._at
+
+ self.actions = {}
+
+ self.actions["down"] = Action("down", self._down_precondition, self._down)
+ self.actions["up"] = Action("up", self._up_precondition, self._up)
+ self.actions["right"] = Action("right", self._right_precondition, self._right)
+ self.actions["left"] = Action("left", self._left_precondition, self._left)
+ self.actions["pickup"] = Action(
+ "pickup", self._pickup_precondition, self._pickup
+ )
+ self.actions["unlock"] = Action(
+ "unlock", self._unlock_precondition, self._unlock
+ )
+
+ def _wall(self, state: DKGState, x: int, y: int) -> bool:
+ """Determines if there is a wall at position (x,y)
+
+ Arguments:
+ state: Current state
+ x: X-position to test
+ y: Y-position to test
+
+ Returns:
+ _wall: Whether there is a wall at (x,y)
+ """
+ return (x, y) in state.walls
+
+ def _door(self, state: DKGState, x: int, y: int) -> bool:
+ """Determines if there is a door at position (x,y)
+
+ Arguments:
+ state: Current state
+ x: X-position to test
+ y: Y-position to test
+
+ Returns:
+ _door: Whether there is a door at (x,y)
+ """
+ return (x, y) in state.doors
+
+ def _obstacle(self, state: DKGState, x: int, y: int) -> bool:
+ """Determines if there is a door or wall at position (x,y)
+
+ Arguments:
+ state: Current state
+ x: X-position to test
+ y: Y-position to test
+
+ Returns:
+ _obstalce: Whether there is a door or wall at (x,y)
+ """
+ return self._wall(state, x, y) or self._door(state, x, y)
+
+ def _has(self, state: DKGState, name: str) -> bool:
+ """Determines if the agent is holding the object name
+
+ Arguments:
+ state: State to analyze
+ name: Name of the object to look for
+
+ Returns:
+ _has: Whether the agent is holding the object name
+ """
+ return name in state.has
+
+ def _at(self, state: DKGState, name: str, x: int, y: int) -> bool:
+ """Determins if there is the object name is a location (x,y)
+
+ Arguments:
+ state: State to analyze
+ name: Name of the object to look for
+ x: X-Position to analyze
+ y: Y-position to analyze
+
+ Returns:
+ _at: Whether there is the object name is a location (x,y)
+ """
+ return name in state.at and state.at[name] == (x, y)
+
+ def _down_precondition(self, state: DKGState) -> bool:
+ """Determines if agent can move down without colliding with a wall, door, or world boundary
+
+ Arguments:
+ state: Current state
+
+ Returns:
+ can_mode_down: True if agent can move down
+ """
+
+ return state.y > 1 and not self._obstacle(state, state.x, state.y - 1)
+
+ def _down(self, state: DKGState) -> DKGState:
+ """Moves an agent downward one
+
+ Arguments:
+ state: Current State
+
+ Returns:
+ new_state: A new state after moving downward
+ """
+
+ return dataclasses.replace(state, y=state.y - 1)
+
+ def _up_precondition(self, state: DKGState) -> bool:
+ """Determines if agent can move up without colliding with a wall, door, or world boundary
+
+ Arguments:
+ state: Current state
+
+ Returns:
+ can_mode_up: True if agent can move up
+ """
+ return state.y < state.height and not self._obstacle(
+ state, state.x, state.y + 1
+ )
+
+ def _up(self, state: DKGState) -> DKGState:
+ """Moves an agent upward one
+
+ Arguments:
+ state: Current State
+
+ Returns:
+ new_state: A new state after moving upward
+ """
+ return dataclasses.replace(state, y=state.y + 1)
+
+ def _left_precondition(self, state: DKGState) -> bool:
+ """Determines if agent can move left without colliding with a wall, door, or world boundary
+
+ Arguments:
+ state: Current state
+
+ Returns:
+ can_mode_left: True if agent can move left
+ """
+ return state.x > 1 and not self._obstacle(state, state.x - 1, state.y)
+
+ def _left(self, state: DKGState) -> DKGState:
+ """Moves an agent left one
+
+ Arguments:
+ state: Current State
+
+ Returns:
+ new_state: A new state after moving left
+ """
+ return dataclasses.replace(state, x=state.x - 1)
+
+ def _right_precondition(self, state: DKGState) -> bool:
+ """Determines if agent can move right without colliding with a wall, door, or world boundary
+
+ Arguments:
+ state: Current state
+
+ Returns:
+ can_mode_right: True if agent can move right
+ """
+ return state.x < state.width and not self._obstacle(state, state.x + 1, state.y)
+
+ def _right(self, state: DKGState) -> DKGState:
+ """Moves an agent right one
+
+ Arguments:
+ state: Current State
+
+ Returns:
+ new_state: A new state after moving right
+ """
+ return dataclasses.replace(state, x=state.x + 1)
+
+ def _pickup_precondition(self, state: DKGState, item_name: str) -> bool:
+ """Determines whether picking up item_name is feasible in the current state
+ The item can be picked up if it is on the ground at the same location as the agent
+
+ Arguments:
+ state: Current State
+ item_name: Item to try and pickup
+
+ Returns:
+ _pickup_precondition: Whether the item can be picked up
+
+ """
+ return self._at(state, item_name, state.x, state.y) and (
+ item_name in state.items
+ )
+
+ def _pickup(self, state: DKGState, item_name: str) -> DKGState:
+ """Picks up an item with name item_name
+
+ Arguments:
+ state: Current State
+ item_name: Item to pickup
+
+ Returns:
+ new_state: A new state holding the specified item
+
+ """
+ new_has = state.has.copy()
+ new_at = state.at.copy()
+ new_has[item_name] = state.items[item_name]
+ new_at.pop(item_name)
+ return dataclasses.replace(state, has=new_has, at=new_at)
+
+ def _unlock_precondition(
+ self, state: DKGState, key_name: str, direction_name: str
+ ) -> bool:
+ """Determines whether a door in direction direction_name can be unlocked with key key_name
+ The agent must be holding the key key_name
+ The door must also be at a location specified by the direction
+
+ Arguments:
+ state: Current State
+ key_name: Key to use to unlock door
+ direction_name: Direction of door
+
+ Returns:
+ _unlock_precondition: Whether the door can be unlocked
+
+ """
+ return (
+ key_name in state.has
+ and key_name in state.keys
+ and self._door(
+ state,
+ state.x + state.xdiff[direction_name],
+ state.y + state.ydiff[direction_name],
+ )
+ )
+
+ def _unlock(self, state: DKGState, key_name: str, direction_name: str) -> DKGState:
+ """Unlocks a door with key key_name
+ Removes the door from the game
+ Removes the used key from the game
+
+ Arguments:
+ state: Current State
+ key_name: Key to use to unlock door
+ direction_name: Direction of the door to unlock
+
+ Returns:
+ new_state: A new state with the door unlocked and the key removed
+
+ """
+ new_items = state.items.copy()
+ new_keys = state.keys.copy()
+ new_has = state.has.copy()
+ new_doors = state.doors.copy()
+ new_items.pop(key_name)
+ new_keys.pop(key_name)
+ new_has.pop(key_name)
+ new_doors.remove(
+ (
+ state.x + state.xdiff[direction_name],
+ state.y + state.ydiff[direction_name],
+ )
+ )
+ return dataclasses.replace(
+ state, items=new_items, keys=new_keys, has=new_has, doors=new_doors
+ )
+
+ def get_possible_actions(self, state: DKGState) -> List[List[str]]:
+ """Determines list of actions whose preconditions are met and will execute
+
+ Arguments:
+ state: Current state
+ Returns:
+ possible_actions: A list of possible actions for the next time step
+ """
+ possible_actions = []
+ if self.is_action_possible(state, "right"):
+ possible_actions.append(["right"])
+ if self.is_action_possible(state, "up"):
+ possible_actions.append(["up"])
+ if self.is_action_possible(state, "left"):
+ possible_actions.append(["left"])
+ if self.is_action_possible(state, "down"):
+ possible_actions.append(["down"])
+
+ for name in state.at:
+ if self.is_action_possible(state, "pickup", name):
+ possible_actions.append(["pickup", name])
+
+ for name in state.has:
+ for direction in state.directions:
+ if self.is_action_possible(state, "unlock", name, direction):
+ possible_actions.append(["unlock", name, direction])
+
+ return possible_actions
+
+ def is_action_possible(self, state: DKGState, action_name: str, *args) -> bool:
+ """Evaluates whether the predicate of the action is satisfied
+
+ Arguments:
+ state: Current State to analyze
+ action_name: Action being attempted
+ *args: Parameters of the action
+
+ Returns:
+ is_action_possible: Whether the predicate of the action is satisfied
+
+ """
+ return self.actions[action_name].check_precondition(state, *args)
+
+ def evaluate_goal(self, state: DKGState) -> bool:
+ """Evaluates whether the current goal is achieved
+
+ Arguments:
+ state: Current State to analyze
+
+ Returns:
+ is_goal_achieved: Whether the current goal is achieved
+ """
+ return self.predicates[state.goal[0]](state, state.goal[1])
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_observation_model.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_observation_model.py
new file mode 100644
index 0000000000..924414e7ed
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_observation_model.py
@@ -0,0 +1,106 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import copy
+import dataclasses
+
+import torch
+from beanmachine.facebook.goal_inference.agent.observation_model import ObservationModel
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import DKGState
+from beanmachine.facebook.goal_inference.environment import State
+from torch.distributions.bernoulli import Bernoulli
+from torch.distributions.normal import Normal
+
+
+class DKGObservation(ObservationModel):
+ """Defines a probability distribution for observing states for Doors, Keys, and Gems problem.
+ Agent positions (x,y) are modified with Gaussian noise
+ Presence of held Items, Doors, and Items on the ground is modified with bernoulli noise
+
+ Arguments/Attributes:
+ gaussian_noise: Scale of the noise applied when observing positions
+ bernoulli_noise: Chance of a held Item, Door, or Item on the ground not being observed
+
+ """
+
+ def __init__(self, gaussian_noise: float = 0.25, bernoulli_noise: float = 0.05):
+ self.gaussian_noise: Normal = Normal(0.0, gaussian_noise)
+ self.bernoulli_noise: Bernoulli = Bernoulli(bernoulli_noise)
+
+ def apply_noise(self, state: DKGState) -> State:
+ """Applies noise to a state to obtain an observation
+
+ Arguments:
+ state: The state to apply noise to
+
+ Returns:
+ noisy_state: The state with noise applied
+ """
+ new_at = copy.copy(state.at)
+ new_has = copy.copy(state.has)
+ new_doors = copy.copy(state.doors)
+
+ # Apply Noise to items
+ for item_id in state.items:
+ if item_id in new_at:
+ # Chance that item at (x,y) is not observed
+ if self.bernoulli_noise.sample():
+ new_at.pop(item_id)
+
+ else:
+ # Chance that held item is not observed
+ if self.bernoulli_noise.sample():
+ new_has.pop(item_id)
+
+ # Apply Noise to doors
+ for doorloc in state.doors:
+ # Change door is not observed
+ if self.bernoulli_noise.sample():
+ new_doors.remove(doorloc)
+
+ # Apply Gaussian noise to positions
+ return dataclasses.replace(
+ state,
+ at=new_at,
+ has=new_has,
+ doors=new_doors,
+ x=state.x + self.gaussian_noise.sample().item(),
+ y=state.y + self.gaussian_noise.sample().item(),
+ )
+
+ def get_log_prob(self, state: DKGState, observation: DKGState) -> torch.Tensor:
+ """Gets the log probability of a observation given a state
+
+ Arguments:
+ state: The reference state
+ observation: The noisy observation
+
+ Returns:
+ log_prob: The log of P(observation|state)
+
+ """
+ log_prob_items = 0.0
+ # Evaluate Probability of Item positions
+ for item_id in state.items:
+ # If Item is not flipped
+ if (item_id in state.has and item_id in observation.has) or (
+ item_id in state.at and item_id in observation.at
+ ):
+ log_prob_items += self.bernoulli_noise.log_prob(torch.tensor(0.0))
+ # If Item is flipped
+ else:
+ log_prob_items += self.bernoulli_noise.log_prob(torch.tensor(1.0))
+
+ # Evaluate Probability of door positions
+ log_prob_doors = 0.0
+ for doorloc in state.doors:
+ # If Door is not flipped
+ if doorloc in observation.doors:
+ log_prob_doors += self.bernoulli_noise.log_prob(torch.tensor(0.0))
+ # If Door is flipped
+ else:
+ log_prob_doors += self.bernoulli_noise.log_prob(torch.tensor(1.0))
+
+ # Evaluate probability of positions
+ log_prob_x = self.gaussian_noise.log_prob(torch.tensor(state.x - observation.x))
+ log_prob_y = self.gaussian_noise.log_prob(torch.tensor(state.y - observation.y))
+ return log_prob_x + log_prob_y + log_prob_items + log_prob_doors
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_observation_model_test.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_observation_model_test.py
new file mode 100644
index 0000000000..f68af42944
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_observation_model_test.py
@@ -0,0 +1,49 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+
+import math
+
+import torch
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_observation_model import (
+ DKGObservation,
+)
+from torch.distributions.normal import Normal
+
+
+def test_dkg_gaussian_noise(dkg_state_two):
+ noise_model_bern = DKGObservation(gaussian_noise=0.001, bernoulli_noise=1.0)
+ new_state = noise_model_bern.apply_noise(dkg_state_two)
+ assert not new_state.at.keys()
+ assert not new_state.has.keys()
+ assert not new_state.doors
+ assert math.isclose(new_state.x, dkg_state_two.x, abs_tol=0.1)
+ assert math.isclose(new_state.y, dkg_state_two.y, abs_tol=0.1)
+
+ noise_model_gaus = DKGObservation(gaussian_noise=0.25, bernoulli_noise=0.0)
+ new_state = noise_model_gaus.apply_noise(dkg_state_two)
+ assert new_state.at.keys() == dkg_state_two.at.keys()
+ assert new_state.has.keys() == dkg_state_two.has.keys()
+ assert new_state.doors == dkg_state_two.doors
+ assert new_state.x != dkg_state_two.x
+ assert new_state.y != dkg_state_two.y
+
+ noise_model_mixed = DKGObservation(gaussian_noise=0.25, bernoulli_noise=0.05)
+ new_state_two = dataclasses.replace(dkg_state_two, x=dkg_state_two.x + 1)
+ new_prob = Normal(torch.tensor(dkg_state_two.x), torch.tensor(0.25)).log_prob(
+ torch.tensor(dkg_state_two.x + 1)
+ )
+
+ new_prob += Normal(torch.tensor(dkg_state_two.y), torch.tensor(0.25)).log_prob(
+ torch.tensor(dkg_state_two.y)
+ )
+
+ new_prob += torch.log(torch.tensor(0.95)) * (
+ len(dkg_state_two.doors) + len(dkg_state_two.items.keys())
+ )
+ assert torch.isclose(
+ noise_model_mixed.get_log_prob(dkg_state_two, new_state_two),
+ new_prob,
+ atol=0.01,
+ )
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_plot.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_plot.py
new file mode 100644
index 0000000000..ea0b54b96f
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/dkg_plot.py
@@ -0,0 +1,190 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from typing import Dict, List, Optional, Tuple
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import DKGState
+
+from beanmachine.facebook.goal_inference.plotting.utils import (
+ create_gif,
+ format_gem_data,
+ get_gem_figure,
+ get_gem_inference_plot,
+)
+
+from matplotlib import colors
+
+
+""" Set Plot Settings.
+Colors are defined as follows:
+Empty -> White
+Wall -> Black
+Door -> Grey
+Key -> Gold
+Agent -> Red
+Gem -> blue, green, or purple
+ """
+
+CMAP = colors.ListedColormap(
+ ["white", "black", "grey", "gold", "red", "blue", "green", "purple"]
+)
+BOUNDS = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
+NORM = colors.BoundaryNorm(BOUNDS, CMAP.N)
+
+
+def plot(state: DKGState):
+ """Creates graphic for current state in a Doors, Keys, and Gems problem
+
+ Arguments:
+ state: State to plot
+ """
+ fig, ax = get_gem_figure(state, is_doors_keys_gems=True)
+ env_data, hold_data = get_data_matrix(state)
+
+ ax[0].imshow(
+ env_data,
+ cmap=CMAP,
+ norm=NORM,
+ origin="lower",
+ interpolation="none",
+ extent=[0.5, state.width + 0.5, 0.5, state.height + 0.5],
+ )
+ ax[1].imshow(
+ hold_data,
+ cmap=CMAP,
+ norm=NORM,
+ origin="lower",
+ interpolation="none",
+ extent=[0.5, 1.5, 0.5, 8.5],
+ )
+
+ plt.show()
+ plt.close()
+
+
+def plot_gif(
+ states: List[DKGState],
+ inference_data: Optional[List[Dict[str, int]]] = None,
+ file_path: Optional[str] = None,
+) -> None:
+ """Creates a gif from a list of states and inference data (if available)
+
+ Arguments:
+ states: Series of states to turn into a gif
+ inference_data: Computation of the posterior P(goal|observations) at each time step
+ file_path: Path to location to save the gif
+ """
+
+ fig, ax = get_gem_figure(states[0], inference_data, is_doors_keys_gems=True)
+
+ def animation_function(frame):
+ env_data, hold_data = get_data_matrix(states[frame])
+ ax[0].imshow(
+ env_data,
+ cmap=CMAP,
+ norm=NORM,
+ origin="lower",
+ interpolation="none",
+ extent=[0.5, states[frame].width + 0.5, 0.5, states[frame].height + 0.5],
+ )
+ ax[1].imshow(
+ hold_data,
+ cmap=CMAP,
+ norm=NORM,
+ origin="lower",
+ interpolation="none",
+ extent=[0.5, 1.5, 0.5, 8.5],
+ )
+ if inference_data is not None:
+ prob_goal = get_gem_inference_plot(inference_data, frame)
+ for goal in prob_goal:
+ ax[2].plot(prob_goal[goal], color=CMAP((4.0 + int(goal[3])) / 8.0))
+
+ create_gif(fig, animation_function, states, file_path)
+
+ plt.close()
+
+
+def get_data_matrix(state: DKGState) -> Tuple[np.ndarray, np.ndarray]:
+ """Computes formatted environment and holding data
+
+ Arguments:
+ state: The current state
+
+ Returns:
+ data_env: Correctly formatted data array of the environment
+ data_hold: Correctly formatted data array of the held gems
+ """
+
+ data_env = get_env_data(state)
+
+ data_env = format_gem_data(data_env)
+
+ data_hold = get_hold_data(state)
+
+ data_hold = format_gem_data(data_hold)
+
+ return data_env, data_hold
+
+
+def get_env_data(state: DKGState) -> np.ndarray:
+
+ """Computes environment data matrix (defining colors) based on current environment.
+
+ Arguments:
+ state: The current state
+
+ Returns:
+ data_env: Data array describing environment (positions of agent/Items/doors/walls etc)
+ """
+
+ data_env = np.zeros((state.width, state.height))
+ for i in range(1, state.width + 1):
+ for j in range(1, state.height + 1):
+ if (i, j) in state.walls:
+ data_env[i - 1, j - 1] = 1.0
+ elif (i, j) in state.doors:
+ data_env[i - 1, j - 1] = 2.0
+
+ for k in state.keys:
+ if k in state.at:
+ x_pos, y_pos = state.at[k]
+ data_env[x_pos - 1, y_pos - 1] = 3.0
+
+ data_env[state.x - 1, state.y - 1] = 4.0
+
+ for g in state.gems:
+ if g in state.at:
+ x_pos, y_pos = state.at[g]
+ # Make sure that each gem is a different color ("gem1" -> blue, "gem2" -> green, "gem3" -> purple)
+ data_env[x_pos - 1, y_pos - 1] = 4.0 + int(g[3])
+
+ return data_env
+
+
+def get_hold_data(state: DKGState) -> np.ndarray:
+ """Computes holding data matrix (defining colors) based on objects agent currently holds
+
+ Arguments:
+ state: The current state
+
+ Returns:
+ data_hold: Data array containing identities of the held gems
+ """
+ data_hold = np.zeros((1, 8))
+
+ count = 0
+
+ for item_id in state.keys:
+ if item_id in state.has:
+ data_hold[0, count] = 3.0
+ count += 1
+
+ for item_id in state.gems:
+ if item_id in state.has:
+ data_hold[0, count] = 4.0 + int(item_id[3])
+ count += 1
+
+ return data_hold
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/domain_test.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/domain_test.py
new file mode 100644
index 0000000000..ab9e2d5f5c
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/domain_test.py
@@ -0,0 +1,222 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+
+import pytest
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_domain import DKGDomain
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.parser import parse
+
+
+@pytest.fixture
+def state():
+ dkg_state = parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-1.pddl"
+ )
+ return dkg_state
+
+
+@pytest.fixture
+def domain():
+ dkg_domain = DKGDomain()
+ return dkg_domain
+
+
+def test_wall(state, domain):
+
+ for i in range(state.width):
+ for j in range(state.height):
+ assert domain.predicates["wall"](state, i + 1, j + 1) == (
+ (i + 1, j + 1) in state.walls
+ )
+
+
+def test_door(state, domain):
+ for i in range(state.width):
+ for j in range(state.height):
+ assert domain.predicates["door"](state, i + 1, j + 1) == (
+ (i + 1, j + 1) in state.doors
+ )
+
+
+def test_obstacle(state, domain):
+ for i in range(state.width):
+ for j in range(state.height):
+ assert domain.predicates["obstacle"](state, i + 1, j + 1) == (
+ (i + 1, j + 1) in state.doors or (i + 1, j + 1) in state.walls
+ )
+
+
+def test_has(state, domain):
+
+ for name in state.items:
+ assert (name in state.has) == domain.predicates["has"](state, name)
+
+ ### Assert No directions are held
+
+ for direction in state.directions:
+ assert not domain.predicates["has"](state, direction)
+
+ ### items on ground are not held
+
+ for name in state.at:
+ assert not domain.predicates["has"](state, name)
+
+
+def test_at(state, domain):
+
+ for name in state.at:
+ x_init = state.at[name][0]
+ y_init = state.at[name][1]
+ for i in range(state.width):
+ for j in range(state.height):
+ if i == x_init and j == y_init:
+ assert domain.predicates["at"](state, name, i, j)
+ else:
+ assert not domain.predicates["at"](state, name, i, j)
+
+
+#### Test Execution
+
+
+def test_action_up(state, domain):
+
+ state_two = domain.actions["up"].execute(state)
+
+ assert state_two == state
+
+ state_three = dataclasses.replace(state, y=state.y - 1)
+ state_four = domain.actions["up"].execute(state_three)
+
+ assert state_four.x == state_three.x
+ assert state_four.y == state_three.y + 1
+
+
+def test_action_down(state, domain):
+
+ state_two = domain.execute(state, "down")
+
+ assert state_two.x == state.x
+ assert state_two.y == state.y - 1
+
+ state_three = domain.execute(state_two, "down")
+
+ assert state_three.x == state_two.x
+ assert state_three.y == state_two.y - 1
+
+ state_four = domain.execute(state_three, "down")
+
+ assert state_four == state_three
+
+
+def test_action_left(state, domain):
+
+ state_two = domain.execute(state, "left")
+
+ assert state_two == state
+
+ state.walls.remove((2, 3))
+ state_three = dataclasses.replace(state, x=2)
+
+ state_four = domain.execute(state_three, "left")
+
+ assert state_four.x == state_three.x - 1
+ assert state_four.y == state_three.y
+
+
+def test_action_right(state, domain):
+
+ state_two = domain.execute(state, "right")
+
+ assert state_two == state
+
+ state.walls.remove((2, 3))
+ state_three = dataclasses.replace(state, x=1)
+ state_four = domain.execute(state_three, "right")
+
+ assert state_four.x == state_three.x + 1
+ assert state_four.y == state_three.y
+
+
+def test_action_pickup(state, domain):
+
+ state_two = domain.execute(state, "pickup", "key2")
+ assert state_two == state
+
+ state_three = dataclasses.replace(state, y=2)
+ state_four = domain.execute(state_three, "pickup", "key2")
+ assert state_four == state_three
+
+ state_five = domain.execute(state_four, "pickup", "key1")
+ assert "key1" in state_five.has
+
+
+def test_action_unlock(state, domain):
+
+ assert (2, 1) in state.doors
+
+ state_two = dataclasses.replace(state, x=1, y=1)
+
+ state_three = domain.execute(state_two, "unlock", "key1", "up")
+ assert state_three == state_two
+
+ state_four = domain.execute(state_three, "unlock", "key1", "left")
+ assert state_four == state_three
+
+ state_five = domain.execute(state_four, "unlock", "key1", "right")
+ assert state_five == state_four
+
+ state_six = dataclasses.replace(state_five, has={"key1": None})
+
+ state_seven = domain.execute(state_six, "unlock", "key1", "up")
+ assert state_seven == state_six
+
+ state_eight = domain.execute(state_seven, "unlock", "key1", "left")
+ assert state_eight == state_seven
+
+ state_nine = domain.execute(state_eight, "unlock", "key1", "right")
+ assert (2, 1) not in state_nine.doors
+
+
+def test_get_possible_actions(state, domain):
+ poss_actions = domain.get_possible_actions(state)
+ assert poss_actions[0] == ["down"]
+ assert len(poss_actions) == 1
+
+ state = domain.execute(state, "down")
+ poss_actions = domain.get_possible_actions(state)
+ assert poss_actions[0] == ["up"]
+ assert poss_actions[1] == ["down"]
+ assert poss_actions[2] == ["pickup", "key1"]
+ assert len(poss_actions) == 3
+
+ state = domain.execute(state, "pickup", "key1")
+ state = domain.execute(state, "down")
+ poss_actions = domain.get_possible_actions(state)
+ assert poss_actions[0] == ["up"]
+ assert poss_actions[1] == ["unlock", "key1", "right"]
+ assert len(poss_actions) == 2
+
+ state = domain.execute(state, "unlock", "key1", "right")
+ poss_actions = domain.get_possible_actions(state)
+ assert poss_actions[0] == ["right"]
+ assert poss_actions[1] == ["up"]
+ assert len(poss_actions) == 2
+
+
+def test_evaluate_goal(state, domain):
+ assert not domain.evaluate_goal(state)
+ state_two = dataclasses.replace(state, has={"key1": state.keys["key1"]})
+ assert not domain.evaluate_goal(state_two)
+ state_three = dataclasses.replace(state, has={"gem2": None})
+ assert not domain.evaluate_goal(state_three)
+ state_four = dataclasses.replace(state, has={"gem1": state.gems["gem1"]})
+ assert domain.evaluate_goal(state_four)
+
+
+def test_is_action_possible(state, domain):
+ assert not domain.is_action_possible(state, "pickup", "gem1")
+ assert domain.is_action_possible(state, "down")
+ state = domain.execute(state, "down")
+ assert domain.is_action_possible(state, "pickup", "key1")
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/parser.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/parser.py
new file mode 100644
index 0000000000..089a40d8c3
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/parser.py
@@ -0,0 +1,312 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from typing import Any, Dict, List, Set, Tuple
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import (
+ Direction,
+ DKGState,
+ Gem,
+ Item,
+ Key,
+)
+
+
+def parse(file_path: str) -> DKGState:
+ """Reads in selected problem. Intializes state by parsing file for objects, conditions, and goal.
+
+ Arguments:
+ file_path: path to the selected problem
+
+ Returns:
+ dkg_state: Initial state of the doors, keys, and gems problem
+ """
+ full_file = open(file_path, "r")
+ full_problem = full_file.read()
+ full_file.close()
+
+ data_parse = full_problem.split(":")
+ objs_data = ""
+ condition_data = ""
+ goal_data = ""
+
+ for data_type in data_parse:
+ if data_type[:7] == "objects":
+ objs_data = data_type
+
+ elif data_type[:4] == "init":
+ condition_data = data_type
+
+ elif data_type[:4] == "goal":
+ goal_data = data_type
+
+ items, gems, keys, directions = parse_objects(objs_data)
+
+ width, height, xdiff, ydiff, doors, walls, x, y, at = parse_conditions(
+ condition_data
+ )
+
+ goal = parse_goal(goal_data)
+
+ has = {}
+
+ return DKGState(
+ goal,
+ width,
+ height,
+ xdiff,
+ ydiff,
+ doors,
+ walls,
+ items,
+ directions,
+ keys,
+ gems,
+ has,
+ at,
+ x,
+ y,
+ )
+
+
+def parse_objects(
+ obj_string: str,
+) -> Tuple[Dict[str, Item], Dict[str, Gem], Dict[str, Key], Dict[str, Direction]]:
+ """Sets State Objects [items,gems,keys] by parsing object substring of PDDL file.
+
+ Arguments:
+ obj_string: The substring of the PDDL file where objects are defined
+
+ Returns:
+ items: A map from Item names to the Item objects
+ gems: A map from Gem names to the Gem objects
+ keys: A map from Key names to the Key objects
+ directions: A map from Direction names to the Direction objects
+ """
+ items = {}
+ gems = {}
+ keys = {}
+ directions = {}
+
+ obj_dict = obj_parser(obj_string)
+ if "gem" in obj_dict:
+ for g in obj_dict["gem"]:
+ new_gem = Gem(g)
+ gems[g] = new_gem
+ items[g] = new_gem
+
+ if "key" in obj_dict:
+ for k in obj_dict["key"]:
+ new_key = Key(k)
+ keys[k] = new_key
+ items[k] = new_key
+
+ if "direction" in obj_dict:
+ for d in obj_dict["direction"]:
+ new_direction = Direction(d)
+ directions[d] = new_direction
+
+ return items, gems, keys, directions
+
+
+def parse_param_condition(
+ condition: List[str],
+) -> Tuple[Any, ...]:
+ """Handles condition parsing for setting of environment parameters
+
+ Arguments:
+ condition: A string in the form e.g. (= width 3) that relates to a parameter of the environment
+
+ Returns:
+ parsed_condition: The condition parsed into a more easily manipulated format (variable, *args)
+ """
+ # Parameters can appear with and without paranthesis
+ if condition[1][0] == "(":
+ condition[1] = condition[1][1:]
+ if condition[1][-1] == ")":
+ condition[1] = condition[1][:-1]
+
+ if condition[1] == "xpos":
+ return ("x", int(condition[2]))
+ elif condition[1] == "ypos":
+ return ("y", int(condition[2]))
+ elif condition[1] == "width":
+ return ("width", int(condition[2]))
+ elif condition[1] == "height":
+ return ("height", int(condition[2]))
+ elif condition[1] == "xdiff":
+ return ("xdiff", condition[2][:-1], int(condition[-1]))
+ elif condition[1] == "ydiff":
+ return ("ydiff", condition[2][:-1], int(condition[-1]))
+ else:
+ raise ValueError("Unknown Parameter")
+
+
+def parse_conditions(
+ condition_string: str,
+) -> Tuple[
+ int,
+ int,
+ Dict[str, int],
+ Dict[str, int],
+ Set[Tuple[int, int]],
+ Set[Tuple[int, int]],
+ int,
+ int,
+ Dict[str, Tuple[int, int]],
+]:
+ """Sets parameters [x,y,width,height,xdiff,ydiff] and locations of doors/walls/items
+
+ Arguments:
+ condition_string: The substring of the PDDL file where conditions are defined
+
+ Returns:
+ width: Width of environment
+ height: Height of environment
+ xdiff: Movement/Interaction along x-axis when given a direction
+ ydiff: Movement/Interaction along y-axis when given a direction
+ doors: Positions of doors
+ walls: Positions of walls
+ x: X-position of Agent
+ y: Y-position of Agent
+ at: Map from name to location for all Items not held by the Agent
+
+ """
+ params = {}
+ params["xdiff"] = {}
+ params["ydiff"] = {}
+ doors = set()
+ walls = set()
+ at = {}
+
+ # Separate conditions
+ conditions = condition_parser(condition_string)
+ for condition in conditions:
+ condition_splt = condition.split()
+ # Identify if condition relates to an environment variable
+ if condition_splt[0] == "=":
+ condition_parsed = parse_param_condition(condition_splt)
+ if len(condition_parsed) == 3:
+ params[condition_parsed[0]][condition_parsed[1]] = condition_parsed[2]
+ else:
+ params[condition_parsed[0]] = condition_parsed[1]
+
+ elif condition_splt[0] == "wall":
+ walls.add((int(condition_splt[1]), int(condition_splt[2])))
+
+ elif condition_splt[0] == "at":
+ at[condition_splt[1]] = (int(condition_splt[2]), int(condition_splt[3]))
+
+ elif condition_splt[0] == "doorloc":
+ doors.add((int(condition_splt[1]), int(condition_splt[2])))
+
+ elif condition_splt[0] == "itemloc" or condition_splt[0] == "door":
+ pass
+
+ else:
+ raise ValueError("Unknown Rule")
+
+ return (
+ params["width"],
+ params["height"],
+ params["xdiff"],
+ params["ydiff"],
+ doors,
+ walls,
+ params["x"],
+ params["y"],
+ at,
+ )
+
+
+def parse_goal(goal_string: str) -> Tuple[str, str]:
+ """Parses goal into predicate and argument
+ e.g. "has gem1" -> ("has","gem1")
+
+ Arguments:
+ goal_string: Substring of PDDL file related to the goal. Example: "goal (has gem3)"
+
+ Returns:
+ new_goal: Goal in the format ("has","gem1")
+
+ """
+ # Clean text around goal
+ goal = goal_parser(goal_string)
+ splt = goal.split()
+ new_goal = (splt[0], splt[1:][0])
+ return new_goal
+
+
+def obj_parser(obj_string: str) -> Dict[str, List]:
+ """Parses Objects listed in PDDL file into Dictionary e.g obj_dict["key"] = ["key1","key2","key3"...]"""
+ # Cleaning Input
+ obj_string = obj_string[7:]
+ obj_string = obj_string.replace("\n", "")
+ obj_string = obj_string.replace(")", "")
+ obj_string = obj_string.replace("(", "")
+ obj_split = obj_string.split()
+
+ # Create Dict
+ obj_dict = {}
+
+ active_names = []
+ index = 0
+ while index < len(obj_split):
+ if obj_split[index] == "-":
+ index += 1
+ obj_type = obj_split[index]
+ obj_dict[obj_type] = active_names
+ active_names = []
+
+ else:
+ active_names.append(obj_split[index])
+
+ index += 1
+
+ return obj_dict
+
+
+def condition_parser(condition_string: str) -> List[str]:
+ """Parses text stream of initial conditions into list of single conditions
+ e.g. "(wall 2 7)
+ (wall 4 7)
+ (at key1 5 7)
+ (itemloc 5 7)"
+
+ -> ["wall 2 7","wall 4 7","at key1 5 7","itemloc 5 7"]
+
+ Arguments:
+ condition_string: Substring of PDDL file related to starting conditions
+
+ Returns:
+ condition_split: List of separate conditions
+ """
+
+ # Cleaning Object
+ condition_string = condition_string[4:]
+ condition_string = condition_string.replace("\n", "")
+
+ # Get separate rules
+ condition_string = " ".join(condition_string.split())
+ condition_split = condition_string.split(") (")
+
+ # Fix off by one
+ condition_split = condition_split[:-1]
+ condition_split[0] = condition_split[0][1:]
+ last_pos = len(condition_split[-1]) - 1
+ while not condition_split[-1][last_pos].isalnum():
+ last_pos -= 1
+ condition_split[-1] = condition_split[-1][: last_pos + 1]
+
+ return condition_split
+
+
+def goal_parser(goal_string: str) -> str:
+ """Cleans text around goal phrase e.g. "goal (has gem3)" -> "has gem3"
+
+ Arguments:
+ goal_string: goal in format "goal (has gem3)"
+ Returns:
+ goal: goal in format "has gem3"
+
+ """
+ return goal_string[goal_string.find("(") + 1 : goal_string.find(")")]
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/parser_test.py b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/parser_test.py
new file mode 100644
index 0000000000..75801ea680
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/parser_test.py
@@ -0,0 +1,212 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.parser import parse
+
+
+def test_state_load_problem_1():
+ state = parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-1.pddl"
+ )
+ ### walls
+ assert len(state.has) == 0
+ assert (2, 3) in state.walls
+ assert (2, 2) in state.walls
+ ### doors
+ assert (2, 1) in state.doors
+ ### items
+ assert "key1" in state.at and state.at[("key1")] == (1, 2)
+ assert "gem1" in state.at and state.at[("gem1")] == (3, 3)
+
+ ### boundaries
+ assert state.width == 3
+ assert state.height == 3
+ ### agent
+ assert state.x == 1
+ assert state.y == 3
+
+ ### xdiff / ydiff
+ assert state.xdiff["right"] == 1
+ assert state.xdiff["left"] == -1
+ assert state.xdiff["up"] == 0
+ assert state.xdiff["down"] == 0
+ assert state.ydiff["right"] == 0
+ assert state.ydiff["left"] == 0
+ assert state.ydiff["up"] == 1
+ assert state.ydiff["down"] == -1
+
+ assert state.goal == ("has", "gem1")
+
+
+def test_state_load_problem_2():
+ state = parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-2.pddl"
+ )
+
+ ### walls
+ assert len(state.has) == 0
+ assert (2, 2) in state.walls
+ assert (2, 3) in state.walls
+ assert (2, 4) in state.walls
+ assert (4, 2) in state.walls
+ assert (4, 3) in state.walls
+ assert (4, 4) in state.walls
+ ### doors
+ assert (4, 1) in state.doors
+ assert (4, 5) in state.doors
+
+ ### items
+ assert "key1" in state.at and state.at[("key1")] == (3, 3)
+ assert "gem1" in state.at and state.at[("gem1")] == (5, 2)
+ assert "gem2" in state.at and state.at[("gem2")] == (5, 4)
+
+ ### boundaries
+ assert state.width == 5
+ assert state.height == 5
+ ### agent
+ assert state.x == 1
+ assert state.y == 3
+
+ ### xdiff / ydiff
+ assert state.xdiff["right"] == 1
+ assert state.xdiff["left"] == -1
+ assert state.xdiff["up"] == 0
+ assert state.xdiff["down"] == 0
+ assert state.ydiff["right"] == 0
+ assert state.ydiff["left"] == 0
+ assert state.ydiff["up"] == 1
+ assert state.ydiff["down"] == -1
+
+ assert state.goal == ("has", "gem1")
+
+
+def test_state_load_problem_3():
+ state = parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-3.pddl"
+ )
+
+ ### walls
+ assert len(state.has) == 0
+ assert (1, 2) in state.walls
+ assert (2, 2) in state.walls
+ assert (3, 2) in state.walls
+ assert (5, 1) in state.walls
+ assert (5, 2) in state.walls
+ assert (5, 3) in state.walls
+
+ assert (5, 4) in state.walls
+ assert (7, 2) in state.walls
+ assert (7, 3) in state.walls
+ assert (7, 4) in state.walls
+ assert (7, 5) in state.walls
+ assert (7, 6) in state.walls
+ assert (2, 4) in state.walls
+ assert (2, 5) in state.walls
+ assert (2, 6) in state.walls
+ assert (3, 6) in state.walls
+ assert (4, 6) in state.walls
+ assert (5, 6) in state.walls
+ assert (6, 6) in state.walls
+ assert (7, 6) in state.walls
+ assert (4, 8) in state.walls
+ assert (6, 7) in state.walls
+ ### doors
+ assert (4, 7) in state.doors
+ assert (5, 5) in state.doors
+ assert (8, 6) in state.doors
+
+ ### items
+ assert "key1" in state.at and state.at[("key1")] == (1, 7)
+ assert "key2" in state.at and state.at[("key2")] == (7, 7)
+ assert "gem1" in state.at and state.at[("gem1")] == (1, 8)
+ assert "gem2" in state.at and state.at[("gem2")] == (8, 8)
+ assert "gem3" in state.at and state.at[("gem3")] == (8, 1)
+
+ ### boundaries
+ assert state.width == 8
+ assert state.height == 8
+ ### agent
+ assert state.x == 1
+ assert state.y == 1
+
+ ### xdiff / ydiff
+ assert state.xdiff["right"] == 1
+ assert state.xdiff["left"] == -1
+ assert state.xdiff["up"] == 0
+ assert state.xdiff["down"] == 0
+ assert state.ydiff["right"] == 0
+ assert state.ydiff["left"] == 0
+ assert state.ydiff["up"] == 1
+ assert state.ydiff["down"] == -1
+
+ assert state.goal == ("has", "gem3")
+
+
+def test_state_load_problem_4():
+ state = parse(
+ "beanmachine/facebook/goal_inference/doors_keys_gems/test_problems/problem-4.pddl"
+ )
+
+ ### walls
+ assert len(state.has) == 0
+ assert (4, 1) in state.walls
+ assert (5, 1) in state.walls
+ assert (6, 1) in state.walls
+ assert (2, 2) in state.walls
+ assert (3, 2) in state.walls
+ assert (4, 2) in state.walls
+ assert (6, 2) in state.walls
+ assert (7, 2) in state.walls
+ assert (8, 2) in state.walls
+ assert (2, 3) in state.walls
+ assert (8, 3) in state.walls
+ assert (2, 4) in state.walls
+ assert (4, 4) in state.walls
+ assert (6, 4) in state.walls
+ assert (8, 4) in state.walls
+ assert (2, 5) in state.walls
+ assert (4, 5) in state.walls
+ assert (6, 5) in state.walls
+ assert (8, 5) in state.walls
+ assert (2, 6) in state.walls
+ assert (4, 6) in state.walls
+ assert (5, 6) in state.walls
+ assert (6, 6) in state.walls
+ assert (8, 6) in state.walls
+ assert (2, 7) in state.walls
+ assert (4, 7) in state.walls
+ assert (6, 7) in state.walls
+ assert (8, 7) in state.walls
+ assert (2, 8) in state.walls
+ assert (3, 8) in state.walls
+ assert (4, 8) in state.walls
+ assert (6, 8) in state.walls
+ assert (8, 8) in state.walls
+ ### doors
+ assert (5, 4) in state.doors
+ assert (7, 8) in state.doors
+
+ ### items
+ assert "key1" in state.at and state.at[("key1")] == (5, 7)
+ assert "key2" in state.at and state.at[("key2")] == (5, 9)
+ assert "gem1" in state.at and state.at[("gem1")] == (7, 1)
+ assert "gem2" in state.at and state.at[("gem2")] == (5, 2)
+ assert "gem3" in state.at and state.at[("gem3")] == (5, 5)
+
+ ### boundaries
+ assert state.width == 9
+ assert state.height == 9
+ ### agent
+ assert state.x == 3
+ assert state.y == 1
+
+ ### xdiff / ydiff
+ assert state.xdiff["right"] == 1
+ assert state.xdiff["left"] == -1
+ assert state.xdiff["up"] == 0
+ assert state.xdiff["down"] == 0
+ assert state.ydiff["right"] == 0
+ assert state.ydiff["left"] == 0
+ assert state.ydiff["up"] == 1
+ assert state.ydiff["down"] == -1
+
+ assert state.goal == ("has", "gem3")
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-1.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-1.pddl
new file mode 100644
index 0000000000..1ed695866e
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-1.pddl
@@ -0,0 +1,24 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; sWG
+; kW.
+; .D.
+(define (problem doors-keys-gems-1)
+ (:domain doors-keys-gems)
+ (:objects
+ up down right left - direction
+ key1 - key gem1 - gem
+ )
+ (:init
+ (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= width 3) (= height 3)
+ (= xpos 1) (= ypos 3)
+ (wall 2 3) (wall 2 2) (door 2 1)
+ (at key1 1 2) (at gem1 3 3)
+ (doorloc 2 1) (itemloc 1 2) (itemloc 3 3)
+ )
+ (:goal (has gem1))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-2.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-2.pddl
new file mode 100644
index 0000000000..51c9f401dd
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-2.pddl
@@ -0,0 +1,28 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; ...D.
+; .W.Wg
+; sWkW.
+; .W.WG
+; ...D.
+(define (problem doors-keys-gems-2)
+ (:domain doors-keys-gems)
+ (:objects
+ up down right left - direction
+ key1 - key gem1 gem2 - gem
+ )
+ (:init
+ (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= width 5) (= height 5)
+ (= xpos 1) (= ypos 3)
+ (wall 2 2) (wall 2 3) (wall 2 4)
+ (door 4 1) (wall 4 2) (wall 4 3) (wall 4 4) (door 4 5)
+ (at key1 3 3) (at gem1 5 2) (at gem2 5 4)
+ (doorloc 4 1) (doorloc 4 5)
+ (itemloc 3 3) (itemloc 5 2) (itemloc 5 4)
+ )
+ (:goal (has gem1))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-3.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-3.pddl
new file mode 100644
index 0000000000..bb6c1e2401
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-3.pddl
@@ -0,0 +1,38 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; g..W...g
+; k..D.Wk.
+; .WWWWWWD
+; .W..D.W.
+; .W..W.W.
+; ....W.W.
+; WWW.W.W.
+; s...W..G
+(define (problem doors-keys-gems-3)
+ (:domain doors-keys-gems)
+ (:objects
+ up down right left - direction
+ key1 key2 - key gem1 gem2 gem3 - gem
+ )
+ (:init
+ (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= width 8) (= height 8)
+ (= xpos 1) (= ypos 1)
+ (wall 1 2) (wall 2 2) (wall 3 2)
+ (wall 5 1) (wall 5 2) (wall 5 3) (wall 5 4)
+ (wall 7 2) (wall 7 3) (wall 7 4) (wall 7 5) (wall 7 6)
+ (wall 2 4) (wall 2 5) (wall 2 6)
+ (wall 3 6) (wall 4 6) (wall 5 6) (wall 6 6) (wall 7 6)
+ (wall 4 8) (wall 6 7)
+ (door 4 7) (door 5 5) (door 8 6)
+ (doorloc 4 7) (doorloc 5 5) (doorloc 8 6)
+ (at key1 1 7) (at key2 7 7)
+ (at gem1 1 8) (at gem2 8 8) (at gem3 8 1)
+ (itemloc 1 7) (itemloc 7 7)
+ (itemloc 1 8) (itemloc 8 8) (itemloc 8 1)
+ )
+ (:goal (has gem3))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-4.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-4.pddl
new file mode 100644
index 0000000000..a20e9da7e9
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-4.pddl
@@ -0,0 +1,68 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; ....k....
+; .WWW.WDW.
+; .W.WkW.W.
+; .W.WWW.W.
+; .W.WGW.W.
+; .W.WDW.W.
+; .W.....W.
+; .WWWgWWW.
+; ..sWWWg..
+(define (problem doors-keys-gems-4)
+ (:domain doors-keys-gems)
+ (:objects up down left right - direction key1 key2 - key gem1 gem2 gem3 - gem)
+ (:init (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= (width) 9) (= (height) 9) (= (xpos) 3) (= (ypos) 1)
+ (wall 4 1)
+ (wall 5 1)
+ (wall 6 1)
+ (at gem1 7 1)
+ (itemloc 7 1)
+ (wall 2 2)
+ (wall 3 2)
+ (wall 4 2)
+ (at gem2 5 2)
+ (itemloc 5 2)
+ (wall 6 2)
+ (wall 7 2)
+ (wall 8 2)
+ (wall 2 3)
+ (wall 8 3)
+ (wall 2 4)
+ (wall 4 4)
+ (door 5 4)
+ (doorloc 5 4)
+ (wall 6 4)
+ (wall 8 4)
+ (wall 2 5)
+ (wall 4 5)
+ (at gem3 5 5)
+ (itemloc 5 5)
+ (wall 6 5)
+ (wall 8 5)
+ (wall 2 6)
+ (wall 4 6)
+ (wall 5 6)
+ (wall 6 6)
+ (wall 8 6)
+ (wall 2 7)
+ (wall 4 7)
+ (at key1 5 7)
+ (itemloc 5 7)
+ (wall 6 7)
+ (wall 8 7)
+ (wall 2 8)
+ (wall 3 8)
+ (wall 4 8)
+ (wall 6 8)
+ (door 7 8)
+ (doorloc 7 8)
+ (wall 8 8)
+ (at key2 5 9)
+ (itemloc 5 9))
+ (:goal (has gem3))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-5.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-5.pddl
new file mode 100644
index 0000000000..a3ce0bd7ae
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-5.pddl
@@ -0,0 +1,91 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; k.......k
+; WWWWDWWWW
+; WWWW.WWWW
+; WWWW.WWWW
+; .D..k..D.
+; .WWW.WWW.
+; .WWWsWWWD
+; .WWW.WWW.
+; gWWWgWWWG
+(define (problem doors-keys-gems-5)
+ (:domain doors-keys-gems)
+ (:objects up down left right - direction
+ key1 key2 key3 - key
+ gem1 gem2 gem3 - gem)
+ (:init (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= (width) 9) (= (height) 9) (= (xpos) 5) (= (ypos) 3)
+ (at gem1 1 1)
+ (itemloc 1 1)
+ (wall 2 1)
+ (wall 3 1)
+ (wall 4 1)
+ (at gem2 5 1)
+ (itemloc 5 1)
+ (wall 6 1)
+ (wall 7 1)
+ (wall 8 1)
+ (at gem3 9 1)
+ (itemloc 9 1)
+ (wall 2 2)
+ (wall 3 2)
+ (wall 4 2)
+ (wall 6 2)
+ (wall 7 2)
+ (wall 8 2)
+ (wall 2 3)
+ (wall 3 3)
+ (wall 4 3)
+ (wall 6 3)
+ (wall 7 3)
+ (wall 8 3)
+ (door 9 3)
+ (doorloc 9 3)
+ (wall 2 4)
+ (wall 3 4)
+ (wall 4 4)
+ (wall 6 4)
+ (wall 7 4)
+ (wall 8 4)
+ (door 2 5)
+ (doorloc 2 5)
+ (at key1 5 5)
+ (itemloc 5 5)
+ (door 8 5)
+ (doorloc 8 5)
+ (wall 1 6)
+ (wall 2 6)
+ (wall 3 6)
+ (wall 4 6)
+ (wall 6 6)
+ (wall 7 6)
+ (wall 8 6)
+ (wall 9 6)
+ (wall 1 7)
+ (wall 2 7)
+ (wall 3 7)
+ (wall 4 7)
+ (wall 6 7)
+ (wall 7 7)
+ (wall 8 7)
+ (wall 9 7)
+ (wall 1 8)
+ (wall 2 8)
+ (wall 3 8)
+ (wall 4 8)
+ (door 5 8)
+ (doorloc 5 8)
+ (wall 6 8)
+ (wall 7 8)
+ (wall 8 8)
+ (wall 9 8)
+ (at key2 1 9)
+ (itemloc 1 9)
+ (at key3 9 9)
+ (itemloc 9 9))
+ (:goal (has gem3))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-6.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-6.pddl
new file mode 100644
index 0000000000..408e5ae457
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-6.pddl
@@ -0,0 +1,83 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; WW.W.W.WW
+; WW.WGW.WW
+; WW.WDW.WW
+; WW.....WW
+; sWgWWW.D.
+; .WWWkWWW.
+; .........
+; WWWW.WWWW
+; WWWk.gWWW
+(define (problem doors-keys-gems-6)
+ (:domain doors-keys-gems)
+ (:objects up down left right - direction
+ key1 key2 - key
+ gem1 gem2 gem3 - gem)
+ (:init (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= (width) 9) (= (height) 9) (= (xpos) 1) (= (ypos) 5)
+ (wall 1 1)
+ (wall 2 1)
+ (wall 3 1)
+ (at key1 4 1)
+ (itemloc 4 1)
+ (at gem1 6 1)
+ (itemloc 6 1)
+ (wall 7 1)
+ (wall 8 1)
+ (wall 9 1)
+ (wall 1 2)
+ (wall 2 2)
+ (wall 3 2)
+ (wall 4 2)
+ (wall 6 2)
+ (wall 7 2)
+ (wall 8 2)
+ (wall 9 2)
+ (wall 2 4)
+ (wall 3 4)
+ (wall 4 4)
+ (at key2 5 4)
+ (itemloc 5 4)
+ (wall 6 4)
+ (wall 7 4)
+ (wall 8 4)
+ (wall 2 5)
+ (at gem2 3 5)
+ (itemloc 3 5)
+ (wall 4 5)
+ (wall 5 5)
+ (wall 6 5)
+ (door 8 5)
+ (doorloc 8 5)
+ (wall 1 6)
+ (wall 2 6)
+ (wall 8 6)
+ (wall 9 6)
+ (wall 1 7)
+ (wall 2 7)
+ (wall 4 7)
+ (door 5 7)
+ (doorloc 5 7)
+ (wall 6 7)
+ (wall 8 7)
+ (wall 9 7)
+ (wall 1 8)
+ (wall 2 8)
+ (wall 4 8)
+ (at gem3 5 8)
+ (itemloc 5 8)
+ (wall 6 8)
+ (wall 8 8)
+ (wall 9 8)
+ (wall 1 9)
+ (wall 2 9)
+ (wall 4 9)
+ (wall 6 9)
+ (wall 8 9)
+ (wall 9 9))
+ (:goal (has gem3))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-7.pddl b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-7.pddl
new file mode 100644
index 0000000000..4323ae04e6
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/doors_keys_gems/test_problems/problem-7.pddl
@@ -0,0 +1,91 @@
+;; ASCII ;;
+; W: wall, D: door, k: key, g: gem, G: goal-gem, s: start, .: empty
+; WgWWkWWgW
+; W.WW.WWDW
+; W..D.D..W
+; WWWW.WWWW
+; .......D.
+; .WWW.WWW.
+; .WWW.WWWD
+; .WWWDWWW.
+; sWWk.kWWG
+(define (problem doors-keys-gems-7)
+ (:domain doors-keys-gems)
+ (:objects up down left right - direction
+ key1 key2 key3 - key
+ gem1 gem2 gem3 - gem)
+ (:init (= (xdiff up) 0) (= (ydiff up) 1)
+ (= (xdiff down) 0) (= (ydiff down) -1)
+ (= (xdiff right) 1) (= (ydiff right) 0)
+ (= (xdiff left) -1) (= (ydiff left) 0)
+ (= (width) 9) (= (height) 9) (= (xpos) 1) (= (ypos) 1)
+ (wall 2 1)
+ (wall 3 1)
+ (at key1 4 1)
+ (itemloc 4 1)
+ (at key2 6 1)
+ (itemloc 6 1)
+ (wall 7 1)
+ (wall 8 1)
+ (at gem3 9 1)
+ (itemloc 9 1)
+ (wall 2 2)
+ (wall 3 2)
+ (wall 4 2)
+ (door 5 2)
+ (doorloc 5 2)
+ (wall 6 2)
+ (wall 7 2)
+ (wall 8 2)
+ (wall 2 3)
+ (wall 3 3)
+ (wall 4 3)
+ (wall 6 3)
+ (wall 7 3)
+ (wall 8 3)
+ (door 9 3)
+ (doorloc 9 3)
+ (wall 2 4)
+ (wall 3 4)
+ (wall 4 4)
+ (wall 6 4)
+ (wall 7 4)
+ (wall 8 4)
+ (door 8 5)
+ (doorloc 8 5)
+ (wall 1 6)
+ (wall 2 6)
+ (wall 3 6)
+ (wall 4 6)
+ (wall 6 6)
+ (wall 7 6)
+ (wall 8 6)
+ (wall 9 6)
+ (wall 1 7)
+ (door 4 7)
+ (doorloc 4 7)
+ (door 6 7)
+ (doorloc 6 7)
+ (wall 9 7)
+ (wall 1 8)
+ (wall 3 8)
+ (wall 4 8)
+ (wall 6 8)
+ (wall 7 8)
+ (door 8 8)
+ (doorloc 8 8)
+ (wall 9 8)
+ (wall 1 9)
+ (at gem1 2 9)
+ (itemloc 2 9)
+ (wall 3 9)
+ (wall 4 9)
+ (at key3 5 9)
+ (itemloc 5 9)
+ (wall 6 9)
+ (wall 7 9)
+ (at gem2 8 9)
+ (itemloc 8 9)
+ (wall 9 9))
+ (:goal (has gem3))
+)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/environment.py b/src/beanmachine/ppl/experimental/goal_inference/environment.py
new file mode 100644
index 0000000000..8d37406999
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/environment.py
@@ -0,0 +1,68 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from typing import Any, Callable, Dict, List, Tuple
+
+
+class Action:
+ """An Action has a precondition that must be true before being executed on a state.
+
+ Public Atrributes:
+
+ name: The name of the action
+ precondition: Evaluates whether a state meets criteria for effect to execute
+ effect: Defines change in state when the action is performed
+
+ """
+
+ def __init__(self, name: str, precondition: Callable, effect: Callable):
+ self.name: str = name
+ self.precondition: Callable = precondition
+ self.effect: Callable = effect
+
+ def check_precondition(self, state: State, *args) -> bool:
+ """Checks if the precondition evaluates to true"""
+ return self.precondition(state, *args)
+
+ def execute(self, state: State, *args) -> State:
+ """execute: Changes the state according to the effect if the precondition is met"""
+ if self.check_precondition(state, *args):
+ return self.effect(state, *args)
+ else:
+ return state
+
+
+@dataclass(frozen=True, eq=True)
+class State(ABC):
+ goal: Tuple[str, ...]
+
+
+class Domain(ABC):
+
+ __slots__ = "actions", "predicates"
+
+ def __init__(self):
+ self.actions: Dict[str, Action]
+ self.predicates: Dict[str, Callable]
+
+ def execute(self, state: State, action_name: str, *args):
+ return self.actions[action_name].execute(state, *args)
+
+ @abstractmethod
+ def get_possible_actions(self, state) -> List[List[Any]]:
+ """Gets All Possible Next Actions"""
+ pass
+
+ @abstractmethod
+ def is_action_possible(self, state, action_name, *args) -> bool:
+ """Determines if an action is possible"""
+ pass
+
+ @abstractmethod
+ def evaluate_goal(self, state) -> bool:
+ """Evaluates if the current goal has been achieved"""
+ pass
diff --git a/src/beanmachine/ppl/experimental/goal_inference/inference/kernels.py b/src/beanmachine/ppl/experimental/goal_inference/inference/kernels.py
new file mode 100644
index 0000000000..af327eb5ec
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/inference/kernels.py
@@ -0,0 +1,332 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import copy
+
+from abc import ABC, abstractmethod
+from random import randint
+from typing import Callable, List, Tuple
+
+import torch
+from beanmachine.facebook.goal_inference.agent.boundedly_rational_agent import (
+ BoundedRationalAgent,
+)
+from beanmachine.facebook.goal_inference.agent.observation_model import ObservationModel
+
+from beanmachine.facebook.goal_inference.environment import State
+from beanmachine.facebook.goal_inference.planner.planner import get_execution_path
+
+from beanmachine.facebook.goal_inference.planner.stoch_astar import null_heuristic
+
+from torch.distributions.categorical import Categorical
+
+
+class DeviateTimeRejuvenateProposal:
+ """Defines a probability distribution for proposing t*
+ where t* is the time step where a proposed path deviates from the
+ previous case.
+
+ The (unnormalized) proability distribution is uniform (1.0) expect for the
+ value where the P(Observation[i]|State[i]) decreases the most which has a
+ value of max_prob
+
+ The intuition is that the point with the greatest drop in P(Observation[i]|State[i])
+ should be close to the point where this particle-agent deviates from the trajectory
+ we are inferring
+
+ Attributes/Arguments:
+
+ max_prob: Weight of point with greatest decrease in P(Observation[i]|State[i])
+ """
+
+ def __init__(self, max_prob: float = 10.0):
+ self.max_prob: float = max_prob
+
+ def propose(
+ self,
+ agent: BoundedRationalAgent,
+ observations: List[State],
+ noise_model: ObservationModel,
+ ) -> Tuple[int, torch.Tensor]:
+ """Proposes a new time*, which will be used as the break point for the new agent-trajectory
+
+ Arguments:
+ agent: BoundedRationalAgent from whom a new path can be proposed
+ observations: List of observations being inferred
+ noise_model: Model for P(observation|state)
+
+ Returns:
+ time_deviate: Time step t* from which to propose new path
+ log_prob: Log probability of proposed t*
+
+ """
+ proposal_distribution = self._get_prob(agent, observations, noise_model)
+ time_deviate = Categorical(probs=proposal_distribution).sample().long()
+ return time_deviate.item(), torch.log(proposal_distribution[time_deviate])
+
+ def get_log_prob(
+ self,
+ agent: BoundedRationalAgent,
+ observations: List[State],
+ noise_model: ObservationModel,
+ time_deviate: int,
+ ) -> torch.Tensor:
+ """Returns the log probability of a t* from the proposal distribution
+
+ Arguments:
+ agent: BoundedRationalAgent from whom a new path can be proposed
+ observations: List of observations being inferred
+ noise_model: Model for P(observation|state)
+ time_deviate: Time step t* from which to propose new path
+
+ Returns:
+ log_prob: Log probability of proposed t*
+
+ """
+ return torch.log(self._get_prob(agent, observations, noise_model)[time_deviate])
+
+ def _get_prob(
+ self,
+ agent: BoundedRationalAgent,
+ observations: List[State],
+ noise_model: ObservationModel,
+ ) -> torch.Tensor:
+ """Get Normalized Proposal Distribution P(t*|observations,states)
+
+ Arguments:
+ agent: BoundedRationalAgent from whom a new path can be proposed
+ observations: List of observations being inferred
+ noise_model: Model for P(observation|state)
+
+ Returns:
+
+ distribution: Normalized P(t*|observations,states)
+
+ """
+ agent_path = get_execution_path(agent.curr_node)[0]
+ probs = torch.zeros(len(agent_path))
+ # Compute P(observation|state) at each time step
+ for time_step in range(len(agent_path)):
+ probs[time_step] = torch.exp(
+ noise_model.get_log_prob(agent_path[time_step], observations[time_step])
+ )
+ probs = torch.nan_to_num(probs, nan=0.0, neginf=0.0)
+ prob_differences = probs[1:] - probs[0:-1]
+ distribution = torch.ones(len(agent_path) - 1)
+ # Sets probability of maximum probability decrease
+ distribution[torch.argmin(prob_differences)] = self.max_prob
+ distribution = distribution / torch.sum(distribution)
+ return distribution
+
+
+class PathRejuvenateProposal:
+ """Defines a probability distribution for proposing new plans and states that
+ deviate from an original trajectory
+
+ During planning, Nodes are biased by an additional weight associated with the
+ probability of that path given the observations.
+
+ """
+
+ def propose(
+ self,
+ agent: BoundedRationalAgent,
+ observations: List[State],
+ proposal_time_deviate: int,
+ noise_model: ObservationModel,
+ ) -> Tuple[BoundedRationalAgent, torch.Tensor]:
+ """Proposes an agent with a new trajectory and the log probability of that agent
+
+ Arguments:
+ agent: BoundedRationalAgent from whom a new path can be proposed
+ observations: List of observations being inferred
+ proposal_time_deviate: Time step t* from which to propose new path
+ noise_model: Model for P(observation|state)
+
+ Returns:
+
+ proposed_agent: An Agent with a modified path
+ proposed_prob: The log probability of that proposed path
+
+ """
+ proposed_agent = copy.copy(agent)
+ proposed_agent.propose_path(observations, proposal_time_deviate, noise_model)
+ return proposed_agent, self.get_log_prob(
+ proposed_agent, observations, proposal_time_deviate, noise_model
+ )
+
+ def get_log_prob(
+ self,
+ agent: BoundedRationalAgent,
+ observations: List[State],
+ proposal_time_deviate: int,
+ noise_model: ObservationModel,
+ ) -> torch.Tensor:
+ """Evaluates the log probability of the new agent trajectory
+
+ Arguments:
+ agent: BoundedRationalAgent from whom a new path can be proposed
+ observations: List of observations being inferred
+ proposal_time_deviate: Time step t* from which to propose new path
+ noise_model: Model for P(observation|state)
+
+ Returns:
+ log_prob: The log probability of that proposed path
+
+ """
+ return agent.get_log_prob(observations, proposal_time_deviate, noise_model)
+
+
+class HeuristicGoalProposal:
+ """Defines a goal proposal distribution using a given heuristic
+ the proposal probability of each goal is
+ proportional to ~exp(-heuristic/scale)
+
+ Attributes/Arguments:
+
+ heuristic: The heuristic on which the distribution is based
+ scale: Determines the sharpness of the proposal distribution
+ """
+
+ def __init__(self, heuristic: Callable = null_heuristic, scale: float = 10.0):
+ self.heuristic = heuristic
+ self.scale = scale
+
+ def propose(
+ self,
+ agent: BoundedRationalAgent,
+ possible_goals: List[Tuple[str, ...]],
+ ) -> Tuple[Tuple[str, ...], torch.Tensor]:
+ """Proposes an new goal for an agent
+
+ Arguments:
+ agent: Agent whose goal can be modified
+ possible_goals: Goals the agent can have
+
+ Returns:
+ possible_goal: New goal for the agent
+ log_prob: Log Probability of the proposed goal
+
+ """
+ proposal_distribution = self._get_goal_log_probs(agent, possible_goals)
+ goal_index = Categorical(logits=proposal_distribution).sample().long().item()
+ return possible_goals[goal_index], proposal_distribution[goal_index]
+
+ def get_log_prob(
+ self,
+ agent: BoundedRationalAgent,
+ possible_goals: List[Tuple[str, ...]],
+ goal: Tuple[str, ...],
+ ) -> torch.Tensor:
+ """Evaluates the log probability of a goal
+
+ Arguments:
+ agent: Agent whose goal can be modified
+ possible_goals: Goals the agent can have
+ goal: Target goal to evaluate probability of
+
+ Returns:
+ log_prob: Log Probability of the target goal
+
+ """
+ proposal_distribution = self._get_goal_log_probs(agent, possible_goals)
+ target_goal_id = possible_goals.index(goal)
+ return proposal_distribution[target_goal_id]
+
+ def _get_goal_log_probs(
+ self,
+ agent: BoundedRationalAgent,
+ possible_goals: List[Tuple[str, ...]],
+ ) -> torch.Tensor:
+ """Computes Log Proposal Distribution P(goal|state)
+
+ Arguments:
+ agent: Agent whose goal can be modified
+ possible_goals: Goals the agent can have
+
+ Returns:
+ log_probs: Normalized Log P(goal|state)
+
+ """
+ curr_node = agent.curr_node
+ heuristic_values = []
+ for goal in possible_goals:
+ heuristic_values.append(self.heuristic(curr_node, goal))
+ heuristic_values = torch.tensor(heuristic_values)
+ log_probs = -heuristic_values / self.scale
+ log_probs -= torch.logsumexp(log_probs, dim=0)
+ return log_probs
+
+
+class GoalPrior(ABC):
+ """Defines a distribution for sampling the prior distribution of goals of particle-agents"""
+
+ @abstractmethod
+ def sample_prior(self, possible_goals: List[Tuple[str, ...]]) -> Tuple[str, ...]:
+ """Samples from the possible goals according to the prior
+
+ Arguments:
+ possible_goals: The possible goals to sample from
+
+ Returns:
+ sample_goal: The goal that was sampled
+
+ """
+ pass
+
+
+class UniformGoalPrior(GoalPrior):
+
+ """Defines a Uniform distribution for sampling the prior distribution of goals
+ of particle-agents"""
+
+ def sample_prior(self, possible_goals: List[Tuple[str, ...]]) -> Tuple[str, ...]:
+ """Uniformly samples from possible goals
+
+ Arguments:
+ possible_goals: Goals that can be sampled
+
+ Returns:
+ goal: A possible goal drawn from a uniform distribution
+
+ """
+ number_of_goals = len(possible_goals)
+ return possible_goals[randint(0, number_of_goals - 1)]
+
+
+class StratifiedGoalPrior(GoalPrior):
+ """Defines a (Stratified) Uniform distribution for sampling the prior distribution
+ of goals of particle-agents
+
+ Example - 300 particles with 3 goals -> exactly 100 particles / goal
+
+ Arguments:
+ number_of_samples: Total number of samples to draw from prior
+
+ Attributes:
+ number_of_samples: Total number of samples to draw from prior
+ current_sample: Identifier for the nth sample out of number_of_samples
+
+ """
+
+ def __init__(self, number_of_samples: int):
+ self.number_of_samples: int = number_of_samples
+ self.current_sample: int = 0
+
+ def sample_prior(self, possible_goals: List[Tuple[str, ...]]) -> Tuple[str, ...]:
+ """Samples from Stratified Prior
+
+ Arguments:
+ possible_goals: Goals that can be sampled
+
+ Returns:
+ goal: A possible goal drawn from a stratified distribution
+
+ """
+ if self.current_sample < self.number_of_samples:
+ current_goal = int(
+ self.current_sample * len(possible_goals) / self.number_of_samples
+ )
+ self.current_sample += 1
+ return possible_goals[current_goal]
+ else:
+ raise (RuntimeError("Too many samples drawn from stratified prior"))
diff --git a/src/beanmachine/ppl/experimental/goal_inference/inference/kernels_test.py b/src/beanmachine/ppl/experimental/goal_inference/inference/kernels_test.py
new file mode 100644
index 0000000000..9593da2237
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/inference/kernels_test.py
@@ -0,0 +1,205 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import math
+
+import pytest
+
+import torch
+
+from beanmachine.facebook.goal_inference.agent.boundedly_rational_agent import (
+ BoundedRationalAgent,
+)
+
+from beanmachine.facebook.goal_inference.agent.observation_model import (
+ DeterministicObservation,
+)
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_observation_model import (
+ DKGObservation,
+)
+from beanmachine.facebook.goal_inference.inference.kernels import (
+ DeviateTimeRejuvenateProposal,
+ HeuristicGoalProposal,
+ PathRejuvenateProposal,
+ StratifiedGoalPrior,
+ UniformGoalPrior,
+)
+
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_execution_path,
+ get_plan_from_actions,
+)
+from beanmachine.facebook.goal_inference.utils import manhattan_gem_heuristic
+
+
+@pytest.fixture(scope="function")
+def dkg_agent(dkg_state_three, dkg_astar_planner):
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_three)
+ agent_actions = [
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["left"],
+ ["down"],
+ ["down"],
+ ["right"],
+ ["down"],
+ ]
+ plan = get_plan_from_actions(
+ dkg_astar_planner.domain, dkg_state_three, agent_actions
+ )
+ agent.plan_history.append(plan)
+ agent.plan_index += 1
+ agent.execute_plan()
+ return agent
+
+
+def test_time_proposal_distribution_noise(dkg_observation_set, dkg_agent):
+ proposal = DeviateTimeRejuvenateProposal()
+ noise_model = DKGObservation()
+ prob_dist = proposal._get_prob(dkg_agent, dkg_observation_set, noise_model)
+ assert prob_dist.shape[0] == 12
+ assert torch.isclose(torch.argmax(prob_dist), torch.tensor(5))
+ assert torch.isclose(prob_dist[5], torch.tensor(10.0 / 21.0))
+ assert torch.isclose(prob_dist[0], torch.tensor(1.0 / 21.0))
+ assert torch.isclose(prob_dist[-1], torch.tensor(1.0 / 21.0))
+
+
+def test_time_proposal_distribution_no_noise(dkg_observation_set, dkg_agent):
+ proposal = DeviateTimeRejuvenateProposal()
+ noise_model = DeterministicObservation()
+ prob_dist = proposal._get_prob(dkg_agent, dkg_observation_set, noise_model)
+ assert prob_dist.shape[0] == 12
+ assert torch.isclose(torch.argmax(prob_dist), torch.tensor(5))
+ assert torch.isclose(prob_dist[5], torch.tensor(10.0 / 21.0))
+ assert torch.isclose(prob_dist[0], torch.tensor(1.0 / 21.0))
+ assert torch.isclose(prob_dist[-1], torch.tensor(1.0 / 21.0))
+
+
+def test_time_proposal_log_prob_noise(dkg_observation_set, dkg_agent):
+ proposal = DeviateTimeRejuvenateProposal()
+ noise_model = DKGObservation()
+ prob_max = proposal.get_log_prob(dkg_agent, dkg_observation_set, noise_model, 5)
+ prob_min = proposal.get_log_prob(dkg_agent, dkg_observation_set, noise_model, 1)
+ assert torch.isclose(prob_max, torch.log(torch.tensor(10.0 / 21.0)))
+ assert torch.isclose(prob_min, torch.log(torch.tensor(1.0 / 21.0)))
+
+
+def test_time_proposal_log_prob_no_noise(dkg_observation_set, dkg_agent):
+ proposal = DeviateTimeRejuvenateProposal()
+ noise_model = DeterministicObservation()
+ prob_max = proposal.get_log_prob(dkg_agent, dkg_observation_set, noise_model, 5)
+ prob_min = proposal.get_log_prob(dkg_agent, dkg_observation_set, noise_model, 1)
+ assert torch.isclose(prob_max, torch.log(torch.tensor(10.0 / 21.0)))
+ assert torch.isclose(prob_min, torch.log(torch.tensor(1.0 / 21.0)))
+
+
+def test_time_proposal_propose(dkg_observation_set, dkg_agent):
+ proposal = DeviateTimeRejuvenateProposal()
+ noise_model = DKGObservation()
+ proposed_time, log_prob_proposed_time = proposal.propose(
+ dkg_agent, dkg_observation_set, noise_model
+ )
+ assert proposed_time < len(dkg_observation_set)
+ assert torch.isclose(
+ log_prob_proposed_time,
+ torch.log(
+ proposal._get_prob(dkg_agent, dkg_observation_set, noise_model)[
+ proposed_time
+ ]
+ ),
+ )
+
+
+def test_path_propose(dkg_astar_planner, dkg_state_three, dkg_observation_set):
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_three, r=1, p=0.9999)
+ agent_actions = [
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ]
+ plan = get_plan_from_actions(
+ dkg_astar_planner.domain, dkg_state_three, agent_actions
+ )
+ agent.plan_history.append(plan)
+ agent.plan_index += 1
+ agent.execute_plan()
+ agent_actions = [
+ ["up"],
+ ["up"],
+ ["left"],
+ ["down"],
+ ["down"],
+ ["right"],
+ ["down"],
+ ]
+ plan = get_plan_from_actions(
+ dkg_astar_planner.domain, agent.curr_node.state, agent_actions
+ )
+ agent.action_step = 0
+ agent.plan_history.append(plan)
+ agent.plan_index += 1
+ agent.execute_plan()
+
+ proposal = PathRejuvenateProposal()
+ noise_model = DeterministicObservation()
+ new_agent, prob = proposal.propose(agent, dkg_observation_set[:13], 5, noise_model)
+ new_path = get_execution_path(new_agent.curr_node)[0]
+ assert new_path == dkg_observation_set[:13]
+ assert prob < 0.0
+
+
+def test_uniform_prior_goal_prob():
+ prior = UniformGoalPrior()
+ goal_record = {("goal1"): 0, ("goal2"): 0, ("goal3"): 0}
+ for _ in range(100):
+ new_goal = prior.sample_prior(list(goal_record.keys()))
+ goal_record[new_goal] += 1
+ assert math.isclose(goal_record[("goal1")], 33, abs_tol=10)
+ assert math.isclose(goal_record[("goal1")], 33, abs_tol=10)
+ assert math.isclose(goal_record[("goal1")], 33, abs_tol=10)
+
+
+def test_heuristic_goal_proposal(dkg_agent):
+ goals = [("has", "gem1"), ("has", "gem2"), ("has", "gem3")]
+ proposal = HeuristicGoalProposal(heuristic=dkg_agent.planner.heuristic)
+ prop_dist = proposal._get_goal_log_probs(dkg_agent, goals)
+
+ dist_goal_1 = float(manhattan_gem_heuristic(dkg_agent.curr_node, ("has", "gem1")))
+ dist_goal_2 = float(manhattan_gem_heuristic(dkg_agent.curr_node, ("has", "gem2")))
+ dist_goal_3 = float(manhattan_gem_heuristic(dkg_agent.curr_node, ("has", "gem3")))
+
+ log_probs = torch.tensor([dist_goal_1, dist_goal_2, dist_goal_3])
+ log_probs = -log_probs / 10.0
+ log_probs -= torch.logsumexp(log_probs, dim=0)
+
+ assert torch.isclose(log_probs[0], prop_dist[0], atol=0.1)
+ assert torch.isclose(log_probs[1], prop_dist[1], atol=0.1)
+ assert torch.isclose(log_probs[2], prop_dist[2], atol=0.1)
+
+ assert torch.isclose(
+ prop_dist[0], proposal.get_log_prob(dkg_agent, goals, ("has", "gem1")), atol=0.1
+ )
+ assert torch.isclose(
+ prop_dist[1], proposal.get_log_prob(dkg_agent, goals, ("has", "gem2")), atol=0.1
+ )
+ assert torch.isclose(
+ prop_dist[2], proposal.get_log_prob(dkg_agent, goals, ("has", "gem3")), atol=0.1
+ )
+
+
+def test_stratified_prior_goal_prob():
+ prior = StratifiedGoalPrior(100)
+ goal_record = {("goal1"): 0, ("goal2"): 0, ("goal3"): 0}
+ for _ in range(100):
+ new_goal = prior.sample_prior(list(goal_record.keys()))
+ goal_record[new_goal] += 1
+ assert math.isclose(goal_record[("goal1")], 33, abs_tol=2)
+ assert math.isclose(goal_record[("goal1")], 33, abs_tol=2)
+ assert math.isclose(goal_record[("goal1")], 33, abs_tol=2)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/inference/sequential_inverse_plan_search.py b/src/beanmachine/ppl/experimental/goal_inference/inference/sequential_inverse_plan_search.py
new file mode 100644
index 0000000000..68c1ab06ac
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/inference/sequential_inverse_plan_search.py
@@ -0,0 +1,528 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import copy
+import dataclasses
+
+from typing import Any, Dict, List, Tuple
+
+import torch
+
+from beanmachine.facebook.goal_inference.agent.boundedly_rational_agent import (
+ BoundedRationalAgent,
+)
+
+from beanmachine.facebook.goal_inference.agent.observation_model import (
+ DeterministicObservation,
+ ObservationModel,
+)
+
+from beanmachine.facebook.goal_inference.environment import State
+
+from beanmachine.facebook.goal_inference.inference.kernels import (
+ DeviateTimeRejuvenateProposal,
+ HeuristicGoalProposal,
+ PathRejuvenateProposal,
+ StratifiedGoalPrior,
+)
+
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_execution_path,
+ Planner,
+)
+from beanmachine.facebook.goal_inference.planner.stoch_astar import (
+ null_heuristic,
+ StochasticAstarPlanner,
+)
+from torch.distributions.categorical import Categorical
+
+
+EPS = 10e-20
+
+DEFAULT_NOISE_MODEL = DeterministicObservation()
+
+
+class SIPS:
+
+ """
+ Peforms Sequential Inverse Planning Search algorithm for goal inference
+ Full details can be found here: https://papers.nips.cc/paper/2020/file/df3aebc649f9e3b674eeb790a4da224e-Paper.pdf
+
+ Summary of Algorithm:
+
+ SIPS is a particle filtering scheme used to estimate the goal posterior P(g|obs) from observations
+ where observations are obtained from an agent that does not necessarily make optimal choices.
+
+ "Particles" are each associated with an agent trajectory generated assuming a particular goal.
+ The particle-trajectory set is initialized with a uniform prior over possible goals.
+ At each time step, each particle-trajectory is advanced one time step using a model agent.
+ Each particle-trajectory receives a weight given the similarity to the target observations.
+ Intuition: particle-trajectories with similar paths to the target observations are more likely
+ to correspond to the target goal and thus receive higher weight.
+
+ The posterior P(g|obs) at each time step can be obtained by summing the normalized weights associated
+ with goal g.
+
+ In order to ensure a good particle-trajectory distribution, if the effective sample size of the
+ distribution decreases below a threshold, particles are resampled using multinomial sampling.
+
+ In addition, the goals/trajectories of the particle-trajectories can be changed through goal/path rejuventation.
+ This process involves a Metroplis Hastings steps with a proposal defined by the user
+
+ Arguments:
+
+ planner: The short-term strategy for particle-trajectories
+ noise_model: Defines a probability distribution for observing states
+ agent_args: Arguments for the boundedly-rational agents used for particle-trajectories
+
+ Attributes:
+
+ planner: The short-term strategy for particle-trajectories
+ agent_args: Arguments for the boundedly-rational agents used for particle-trajectories
+ noise_model: Defines a probability distribution for observing states
+ path_proposal: Proposal that defines distribution for rejuvenating paths
+ time_proposal: Proposal that defines distribution for t*, time step where to start path rejuvenation
+ goal_prior: function that initialzes the goals of the particle-agents based on a prior
+ goal_proposal: Proposal for proposing changes to the goal state
+
+ """
+
+ def __init__(
+ self,
+ planner: Planner,
+ noise_model: ObservationModel = DEFAULT_NOISE_MODEL,
+ **kwargs: Dict[str, Any],
+ ):
+ self.planner: Planner = planner
+ self.agent_args: Dict[str, Any] = kwargs
+ # Fall back on deterministic observations if no noise model is provided
+ self.noise_model: ObservationModel = noise_model
+ self.path_proposal: PathRejuvenateProposal = PathRejuvenateProposal()
+ self.time_proposal: DeviateTimeRejuvenateProposal = (
+ DeviateTimeRejuvenateProposal()
+ )
+ if isinstance(self.planner, StochasticAstarPlanner):
+ self.goal_proposal: HeuristicGoalProposal = HeuristicGoalProposal(
+ heuristic=self.planner.heuristic
+ )
+ else:
+ self.goal_proposal: HeuristicGoalProposal = HeuristicGoalProposal(
+ heuristic=null_heuristic
+ )
+
+ def _initialize_filter(
+ self,
+ num_particles: int,
+ initial_state: State,
+ possible_goals: List[Tuple[str, ...]],
+ ) -> Tuple[torch.Tensor, List[BoundedRationalAgent]]:
+ """Initializes the particle-agent distribution
+
+ Arguments:
+ num_particles: The total number of agents to initialize
+ initial_state: The initial state of the problem
+ possible_goals: The possible goals of the initial agents
+
+ Returns:
+ initialized_weights: Uniform weights for the agents
+ agents: The initialized set of BoundedRational agents
+
+ """
+ agents = []
+ goal_prior = StratifiedGoalPrior(num_particles)
+ for _part_idx in range(num_particles):
+ # Draw from P(g)
+ sampled_goal = goal_prior.sample_prior(possible_goals)
+ new_state = dataclasses.replace(initial_state, goal=sampled_goal)
+ agents.append(
+ BoundedRationalAgent(self.planner, new_state, **self.agent_args)
+ )
+ return torch.zeros(len(agents)), agents
+
+ def infer(
+ self,
+ num_particles: int,
+ initial_state: State,
+ possible_goals: List[Tuple[str, ...]],
+ observations: List[State],
+ resample_threshold: float = 0.25,
+ rejuvenate: bool = True,
+ goal_rejuvenation_prob: float = 0.5,
+ ) -> List[Dict[str, float]]:
+ """Computes the normalized posterior P(g|obs) over time
+
+ Arguments:
+ num_particles: The number of particle-agents used in the filter
+ initial_state: The initial state of the problem
+ possible_goals: The possible goals that could be infered
+ observations: The trajectory from which the goal will be inferred
+ resample_threshold: Value for comparison with Effective_Sample_Size/num_particles.
+ If Effective_Sample_Size/num_particles falls below this value,
+ the particle distribution is resampled.
+ rejuvenate: Whether to perform goal/path rejuvenation
+ goal_rejuvenation_prob: Probability that goals are rejuvenated after resampling
+
+ Returns:
+ infered_goal: List of records of posterior. infered_goal[i] is the posterior at time_step i
+ """
+ # Initialize particle-trajectories. Goals are drawn from P(g)
+ log_weights, agents = self._initialize_filter(
+ num_particles, initial_state, possible_goals
+ )
+ infered_goal = []
+ infered_goal.append(get_posterior(log_weights, agents, possible_goals))
+ # Use observations to update particle-trajectory weights based on likelihood of observations
+ for obs_step in range(1, len(observations)):
+ agents, log_weights = self._update_filter(
+ agents,
+ log_weights,
+ obs_step,
+ observations[: obs_step + 1],
+ initial_state,
+ possible_goals,
+ resample_threshold,
+ rejuvenate,
+ goal_rejuvenation_prob,
+ )
+ # Adjust weights for numerical stability
+
+ log_weights -= torch.logsumexp(log_weights, dim=0)
+ # Get posterior up until this time step
+ infered_goal.append(get_posterior(log_weights, agents, possible_goals))
+
+ return infered_goal
+
+ def _update_filter(
+ self,
+ agents: List[BoundedRationalAgent],
+ log_weights: torch.Tensor,
+ obs_step: int,
+ observations: List[State],
+ initial_state: State,
+ possible_goals: List[Tuple[str, ...]],
+ resample_threshold: float,
+ rejuvenate: bool,
+ goal_rejuvenation_prob: float,
+ ) -> Tuple[List[BoundedRationalAgent], torch.Tensor]:
+ """Updates particle-agents with new observation
+
+ Arguments:
+ agents: Current set of BoundedRational Agents
+ log_weights: Current agent weights
+ obs_step: Current time_step of inference
+ observations: Trajectory from which the goal will be inferred
+ initial_state: Initial state of the problem
+ possible_goals: The possible goals that can be infered
+ resample_threshold: Value for comparison with Effective_Sample_Size/num_particles.
+ If Effective_Sample_Size/num_particles falls below this value,
+ the particle distribution is resampled.
+ rejuvenate: Whether to perform goal/path rejuvenation
+ goal_rejuvenation_prob: Probability that goals are rejuvenated after resampling
+
+ Returns:
+ agents: Updated BoundedRational Agents
+ log_weights: Updated agent weights
+
+ """
+ # Test the effective sample size - resample if too low
+ if (
+ self._effective_sample_size(log_weights) / log_weights.shape[0]
+ < resample_threshold
+ ):
+ log_weights, agent_idx = self._residual_resample(log_weights)
+
+ for i in range(len(agents)):
+ new_agent = copy.copy(agents[agent_idx[i]])
+ if rejuvenate:
+ agents[i] = self._rejuvenate(
+ new_agent,
+ initial_state,
+ possible_goals,
+ observations,
+ goal_rejuvenation_prob,
+ )
+ else:
+ agents[i] = new_agent
+
+ for part_idx in range(len(log_weights)):
+ # Update particle-trajectory using model agent
+ agents[part_idx].step()
+ # Update weight of this particle-trajectory P({observations}|{states}) with P(observation_i|state_i)
+ log_weights[part_idx] += self.noise_model.get_log_prob(
+ agents[part_idx].curr_node.state, observations[obs_step]
+ )
+ return agents, log_weights
+
+ def _effective_sample_size(self, log_weights: torch.Tensor) -> torch.Tensor:
+ """Computes the effective sample size of the current particles
+
+ Arguments:
+ log_weights: Current weights of the agents
+
+ Returns:
+ eff_sample_size: Effective sample size of the current distribution of agents
+
+ """
+ part_weights = get_real_weights(log_weights)
+ sum_weights_sqrd = torch.square(torch.sum(part_weights))
+ sum_sqrd_weights = torch.sum(torch.square(part_weights))
+ eff_sample_size = sum_weights_sqrd / sum_sqrd_weights
+ return eff_sample_size
+
+ def _multinomial_resample(
+ self, log_weights: torch.Tensor
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Resamples the particle distribution with multinomial resampling.
+
+ New Agents are drawn from previous distribution in proportion to the weights
+
+ Arguments:
+ log_weights: Current weights of the agents
+
+ Returns:
+ uniform_weights: New Uniform weights
+ sampled_indexes: Indexes of sampled agents
+ """
+ return (
+ torch.zeros(log_weights.shape),
+ Categorical(logits=log_weights).sample_n(log_weights.shape[0]).long(),
+ )
+
+ def _residual_resample(
+ self, log_weights: torch.Tensor
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Resamples the particle distribution with residual resampling.
+
+ Let the number of agents be N
+
+ Previous Agents are sampled at least int(weight*N) times
+
+ Remaining Agents are drawn in proportion to residual weights
+ residual weight = [weight*N - int(weight*N)]
+
+ Arguments:
+ log_weights: Current weights of the agents
+
+ Returns:
+ uniform_weights: New Uniform weights
+ sampled_indexes: Indexes of sampled agents
+ """
+ part_weights = get_real_weights(log_weights)
+ N = part_weights.shape[0]
+ num_copies = (N * part_weights).int()
+ # Ensure each particle-agent is sampled at least int(N*part_weight) times
+ agent_idx = torch.repeat_interleave(torch.arange(N), num_copies)
+ k = torch.sum(num_copies)
+ # Sample remaining agents based on decimal part of N*part_weight
+ residual = N * part_weights - num_copies
+ if torch.sum(residual) != 0.0 and N - k > 0:
+ residual /= torch.sum(residual)
+ agent_idx = torch.cat(
+ (agent_idx, Categorical(probs=residual).sample_n(N - k)), dim=0
+ )
+ return torch.zeros(part_weights.shape), agent_idx.long()
+
+ def _rejuvenate(
+ self,
+ agent: BoundedRationalAgent,
+ initial_state: State,
+ possible_goals: List[Tuple[str, ...]],
+ observations: List[State],
+ goal_rejuvenation_prob: float,
+ ) -> BoundedRationalAgent:
+ """Rejuvenates Agents by changing paths / goals
+
+ Arguments:
+ agent: The agent to modify
+ initial_state: The initial state of the problem
+ possible_goals: The possible goals to infer
+ observations: Trajectory from which the goal will be inferred
+ goal_rejuvenation_prob: Probability that goals are rejuvenated after resampling
+
+ Returns:
+ agent: The modified agent is return if the MC move is accepted. Otherwise the initial agent is returned.
+
+ """
+ # Determine whether to rejuventate goals or paths
+ if torch.bernoulli(torch.tensor(goal_rejuvenation_prob)):
+ alpha, proposed_agent = self._goal_rejuvenation(
+ agent, initial_state, possible_goals
+ )
+ else:
+ alpha, proposed_agent = self._path_rejuvenation(
+ agent, initial_state, observations
+ )
+ # Evaluate Likelihood of path given observations P(states|Observations)
+ old_path_log_prob = self._get_path_log_prob(agent, observations)
+ proposed_path_log_prob = self._get_path_log_prob(proposed_agent, observations)
+ # Accept/Reject Step
+ alpha += proposed_path_log_prob - old_path_log_prob
+ if torch.log(torch.rand(1)) < alpha:
+ return proposed_agent
+ else:
+ return agent
+
+ def _goal_rejuvenation(
+ self,
+ agent: BoundedRationalAgent,
+ initial_state: State,
+ possible_goals: List[Tuple[str, ...]],
+ ) -> Tuple[torch.Tensor, BoundedRationalAgent]:
+ """Rejuventates the goal of a particle-agent
+
+ Proposes a new goal for a boundedrational agent
+ The strategy for the proposal is determined by self.goal_proposal
+
+ Currently, by default goals are
+
+ Arguments:
+ agent: The BoundedRational Agent to modify
+ initial_state: The initial state of the problem
+ possible_goals: The possible goals to infer
+
+ Returns:
+ log_proposal_prob: The proposal portion of the acceptance/rejection log probability
+ proposed_agent: The modified agent
+ """
+
+ # Get proposed goal and log probability of goal
+ proposed_goal, proposal_log_prob_new_goal = self.goal_proposal.propose(
+ agent, possible_goals
+ )
+ # Get log probability of old goal
+ proposal_log_prob_old_goal = self.goal_proposal.get_log_prob(
+ agent, possible_goals, agent.curr_node.state.goal
+ )
+ # Propose new agent with sampled goal
+ proposed_agent = BoundedRationalAgent(
+ self.planner,
+ dataclasses.replace(initial_state, goal=proposed_goal),
+ **self.agent_args,
+ )
+ # Advance timestep of proposed agent to same time as previous agent
+ proposed_agent.step(num_steps=agent.agent_step)
+ return proposal_log_prob_old_goal - proposal_log_prob_new_goal, proposed_agent
+
+ def _path_rejuvenation(
+ self,
+ agent: BoundedRationalAgent,
+ initial_state: State,
+ observations: List[State],
+ ) -> Tuple[torch.Tensor, BoundedRationalAgent]:
+ """Rejuventates the path of a paricle-agent
+
+ (1) Proposes a time t* from which a new path can be proposed
+ (2) Proposes a new path following time t*
+
+ Arguments:
+ agent: The BoundedRational Agent to modify
+ initial_state: The initial state of the problem
+ observations: Trajectory from which the goal will be inferred
+
+ Returns:
+ alpha: The proposal portion of the acceptance/rejection log probability
+ proposed_agent: The modified agent
+
+ """
+
+ # Get t* and P(t*|state,observations)
+ (
+ proposal_time_deviate,
+ proposal_log_prob_old_time_deviate,
+ ) = self.time_proposal.propose(agent, observations, self.noise_model)
+
+ # Get Proposed Agent and P(Agent|observations,t*)
+ proposed_agent, proposal_log_prob_new_path = self.path_proposal.propose(
+ agent, observations, proposal_time_deviate, self.noise_model
+ )
+
+ # Get P(Old_Agent|observations,t*)
+ proposal_log_prob_old_path = self.path_proposal.get_log_prob(
+ agent, observations, proposal_time_deviate, self.noise_model
+ )
+
+ # Get P(t*|new_states,observations)
+ proposal_log_prob_new_time_deviate = self.time_proposal.get_log_prob(
+ proposed_agent, observations, self.noise_model, proposal_time_deviate
+ )
+
+ alpha = proposal_log_prob_old_path - proposal_log_prob_new_path
+ alpha += proposal_log_prob_new_time_deviate - proposal_log_prob_old_time_deviate
+
+ return alpha, proposed_agent
+
+ def _get_path_log_prob(
+ self, agent: BoundedRationalAgent, observations: List[State]
+ ) -> torch.Tensor:
+ """Computes Log P(observations|states) for a trajectory
+
+ Arguments:
+ agent: The agent to compare with the observations
+ observations: Trajectory from which the goal will be inferred
+
+ Returns:
+ log_prob: Log P(observations|states)
+
+ """
+ log_prob = torch.tensor(0.0)
+ agent_path = get_execution_path(agent.curr_node)[0]
+ # Evaluates Log P(observations|states) = Log P(observation_1|State_1)+ Log P(observation_2|State_2)...
+ for time_step in range(len(observations)):
+ ### If the agent path has reached the goal just repeat the final state
+ if time_step == len(agent_path):
+ agent_path.append(agent_path[-1])
+ # Computes Log P(observation_i|State_i)
+ log_prob += self.noise_model.get_log_prob(
+ agent_path[time_step], observations[time_step]
+ )
+ return log_prob
+
+
+def get_real_weights(log_weights: torch.Tensor) -> torch.Tensor:
+ """Computes weights from log weights in a numerically stable way
+
+ Arguments:
+ log_weights: Weights to convert to non-log scale
+
+ Return:
+ part_weights: Weights in non-log scale
+
+ """
+ log_weights -= torch.logsumexp(log_weights, dim=0)
+ part_weights = torch.exp(log_weights)
+ part_weights = torch.nan_to_num(part_weights, nan=0.0, neginf=0.0)
+ return part_weights
+
+
+def get_posterior(
+ log_weights: torch.Tensor,
+ agents: List[BoundedRationalAgent],
+ possible_goals: List[Tuple[str, ...]],
+) -> Dict[Tuple[str, ...], float]:
+ """Computes the normalized posterior P(g|obs) at one time step
+
+ Arguments:
+ log_weights: Current weights of the agents
+ agents: The current set of BoundedRational agents
+ possible_goals: The possible goals to infer
+ Returns:
+ curr_infer: posterior at the current time_step
+ """
+ part_weights = get_real_weights(log_weights)
+ curr_infer = {}
+ for goal in possible_goals:
+ curr_infer[goal] = 0.0
+ norm = 0
+ # Sum all weights associated with each goal
+ for part_idx in range(len(agents)):
+ norm += part_weights[part_idx].item()
+ curr_infer[agents[part_idx].curr_node.state.goal] += part_weights[
+ part_idx
+ ].item()
+ if norm == 0:
+ return curr_infer
+
+ # Normalize the posterior
+ for goal_id in curr_infer:
+ curr_infer[goal_id] /= norm
+
+ return curr_infer
diff --git a/src/beanmachine/ppl/experimental/goal_inference/inference/sequential_inverse_plan_search_test.py b/src/beanmachine/ppl/experimental/goal_inference/inference/sequential_inverse_plan_search_test.py
new file mode 100644
index 0000000000..914b42330e
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/inference/sequential_inverse_plan_search_test.py
@@ -0,0 +1,454 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import dataclasses
+import math
+
+from typing import Dict, List
+
+import pytest
+
+import torch
+
+from beanmachine.facebook.goal_inference.agent.boundedly_rational_agent import (
+ BoundedRationalAgent,
+)
+
+from beanmachine.facebook.goal_inference.agent.observation_model import (
+ apply_noise_to_states,
+)
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_domain import CGemDomain
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_observation_model import (
+ CGemObservation,
+)
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_parse import parse
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_observation_model import (
+ DKGObservation,
+)
+
+from beanmachine.facebook.goal_inference.inference.sequential_inverse_plan_search import (
+ SIPS,
+)
+from beanmachine.facebook.goal_inference.planner.stoch_astar import (
+ StochasticAstarPlanner,
+)
+from beanmachine.facebook.goal_inference.utils import manhattan_gem_heuristic
+
+
+@pytest.fixture(scope="function")
+def dkg_SIPS_no_noise(dkg_stoch_astar_planner):
+ return SIPS(
+ dkg_stoch_astar_planner,
+ r=1000,
+ p=0.5,
+ )
+
+
+@pytest.fixture(scope="function")
+def dkg_SIPS_noise(dkg_stoch_astar_planner):
+ return SIPS(
+ dkg_stoch_astar_planner,
+ DKGObservation(),
+ r=1000,
+ p=0.5,
+ )
+
+
+def get_last_inference_prediction(infer_data: List[Dict[str, float]]):
+ """Returns the time step of posterior with nonzero weights"""
+ time_step = len(infer_data) - 1
+ while time_step > 0:
+ for goal_id in infer_data[time_step]:
+ if infer_data[time_step][goal_id] != 0:
+ return infer_data[time_step]
+ time_step -= 1
+ return infer_data[0]
+
+
+def test_dkg_problem_one_SIPS_no_noise(
+ dkg_astar_planner, dkg_state_one, dkg_SIPS_no_noise
+):
+ (
+ plan,
+ solved,
+ ) = dkg_astar_planner.generate_plan(dkg_state_one)
+ observations = plan.states
+ infered_goal = dkg_SIPS_no_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 1.0, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_two_SIPS_no_noise(
+ dkg_astar_planner, dkg_state_two, dkg_SIPS_no_noise
+):
+ (
+ plan,
+ solved,
+ ) = dkg_astar_planner.generate_plan(dkg_state_two)
+ observations = plan.states
+ infered_goal = dkg_SIPS_no_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.5, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.5, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_three_SIPS_no_noise(
+ dkg_astar_planner, dkg_state_three, dkg_SIPS_no_noise
+):
+ (
+ plan,
+ solved,
+ ) = dkg_astar_planner.generate_plan(dkg_state_three)
+ observations = plan.states
+ infered_goal = dkg_SIPS_no_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2"), ("has", "gem3")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem3")], 0.333, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem3")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_four_SIPS_no_noise(
+ dkg_astar_planner, dkg_state_four, dkg_SIPS_no_noise
+):
+ (
+ plan,
+ solved,
+ ) = dkg_astar_planner.generate_plan(dkg_state_four)
+ observations = plan.states
+ infered_goal = dkg_SIPS_no_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2"), ("has", "gem3")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem3")], 0.333, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem3")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_one_SIPS_noise(dkg_astar_planner, dkg_state_one, dkg_SIPS_noise):
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_one, r=1000, p=0.5)
+ plan, solved = agent.execute_search()
+ observations = apply_noise_to_states(plan.states, DKGObservation())
+ infered_goal = dkg_SIPS_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 1.0, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_two_SIPS_noise(dkg_astar_planner, dkg_state_two, dkg_SIPS_noise):
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_two, r=1000, p=0.5)
+ plan, solved = agent.execute_search()
+ observations = apply_noise_to_states(plan.states, DKGObservation())
+ infered_goal = dkg_SIPS_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.5, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.5, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_three_SIPS_noise(
+ dkg_astar_planner, dkg_state_three, dkg_SIPS_noise
+):
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_three, r=1000, p=0.5)
+ (
+ plan,
+ solved,
+ ) = agent.execute_search()
+ observations = apply_noise_to_states(plan.states, DKGObservation())
+ infered_goal = dkg_SIPS_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2"), ("has", "gem3")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem3")], 0.333, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem3")], 1.0, abs_tol=0.2
+ )
+
+
+def test_dkg_problem_four_SIPS_noise(dkg_astar_planner, dkg_state_four, dkg_SIPS_noise):
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_four, r=1000, p=0.5)
+ plan, solved = agent.execute_search()
+ observations = apply_noise_to_states(plan.states, DKGObservation())
+ infered_goal = dkg_SIPS_noise.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2"), ("has", "gem3")],
+ observations,
+ resample_threshold=0.0,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.333, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem3")], 0.333, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem3")], 1.0, abs_tol=0.2
+ )
+
+
+def test_update_filter_single_agent(dkg_stoch_astar_planner, dkg_state_three):
+ infer_model = SIPS(
+ dkg_stoch_astar_planner,
+ r=1000,
+ p=0.5,
+ )
+ agent_one = BoundedRationalAgent(
+ dkg_stoch_astar_planner, dkg_state_three, r=1, p=0.5
+ )
+ agent_one.step(5)
+ while agent_one.action_step >= len(agent_one.curr_plan.actions):
+ agent_one.replan()
+ agent_two = BoundedRationalAgent(
+ dkg_stoch_astar_planner, dkg_state_three, r=1, p=0.5
+ )
+ agent_two.step(5)
+ while agent_two.action_step >= len(agent_two.curr_plan.actions):
+ agent_two.replan()
+ predicted_next_state_one = agent_one.curr_plan.states[agent_one.action_step + 1]
+ predicted_next_state_two = agent_two.curr_plan.states[agent_two.action_step + 1]
+ observation = predicted_next_state_one
+ new_agents, new_weights = infer_model._update_filter(
+ [agent_one, agent_two],
+ torch.tensor([-0.6931, -0.6931]),
+ 1,
+ [dkg_state_three, observation],
+ dkg_state_three,
+ [("has", "gem1"), ("has", "gem2"), ("has", "gem3")],
+ 0.0,
+ False,
+ 0.0,
+ )
+ assert agent_one.curr_node.state == predicted_next_state_one
+ assert agent_two.curr_node.state == predicted_next_state_two
+ assert torch.isclose(new_weights[0], torch.tensor(-0.6931), atol=0.1)
+ if predicted_next_state_one == predicted_next_state_two:
+ assert torch.isclose(new_weights[1], torch.tensor(-0.6931), atol=0.1)
+ else:
+ assert torch.isneginf(new_weights[1])
+
+
+def test_effective_sample_size_uniform(dkg_SIPS_no_noise):
+ weights_uniform = torch.zeros(100)
+ ess = dkg_SIPS_no_noise._effective_sample_size(weights_uniform)
+ assert torch.isclose(ess, torch.tensor(100.0), atol=0.0001)
+
+
+def test_effective_sample_size_peaked(dkg_SIPS_no_noise):
+ weights_peaked = torch.ones(100) * -100
+ weights_peaked[0] = 0.0
+ ess = dkg_SIPS_no_noise._effective_sample_size(weights_peaked)
+ assert torch.isclose(ess, torch.tensor(1.0), atol=0.01)
+
+
+def test_resampling_new_weights_multinomial(dkg_SIPS_no_noise):
+ weights = torch.rand(100)
+ new_weights, new_indexes = dkg_SIPS_no_noise._multinomial_resample(weights)
+ assert (new_weights == torch.zeros(100)).all()
+
+
+def test_resampling_dead_trajs_not_resampled_multinomial(dkg_SIPS_no_noise):
+ weights = torch.ones(100)
+ weights[0:50] = -100.0
+ new_weights, new_indexes = dkg_SIPS_no_noise._multinomial_resample(weights)
+ assert (new_weights == torch.zeros(100)).all()
+ assert torch.all(new_indexes >= 50)
+
+
+def test_resampling_new_weights_residual(dkg_SIPS_no_noise):
+ weights = torch.rand(100)
+ new_weights, new_indexes = dkg_SIPS_no_noise._residual_resample(weights)
+ assert (new_weights == torch.zeros(100)).all()
+
+
+def test_resampling_uniform_weights_residual(dkg_SIPS_no_noise):
+ weights = torch.ones(100)
+ new_weights, new_indexes = dkg_SIPS_no_noise._residual_resample(weights)
+ assert (new_weights == torch.zeros(100)).all()
+ assert (new_indexes == torch.arange(100)).all()
+
+
+def test_resampling_dead_trajs_not_resampled_residual(dkg_SIPS_no_noise):
+ weights = torch.zeros(100)
+ weights[0:50] = -100
+ new_weights, new_indexes = dkg_SIPS_no_noise._residual_resample(weights)
+ assert (new_weights == torch.zeros(100)).all()
+ assert torch.all(new_indexes >= 50)
+
+
+def test_goal_proposal(
+ dkg_astar_planner,
+ dkg_state_two,
+ dkg_SIPS_no_noise,
+):
+ # Move Agent so that gem1 (goal gem) is closer
+ agent = BoundedRationalAgent(dkg_astar_planner, dkg_state_two, r=1000, p=0.5)
+ agent.step(11)
+ dist_gem1 = manhattan_gem_heuristic(
+ agent.curr_node,
+ ("has", "gem1"),
+ )
+
+ dist_gem2 = manhattan_gem_heuristic(
+ agent.curr_node,
+ ("has", "gem2"),
+ )
+ assert dist_gem1 < dist_gem2
+
+ counts = {"gem1": 0, "gem2": 0, "gem3": 0}
+ for _test in range(1000):
+ alpha, new_agent = dkg_SIPS_no_noise._goal_rejuvenation(
+ agent,
+ dkg_state_two,
+ [("has", "gem1"), ("has", "gem2")],
+ )
+ counts[new_agent.curr_node.state.goal[1]] += 1
+ # Test that Rejuvenated goals are more commonly gem1 than gem2
+ assert counts["gem1"] > counts["gem2"]
+
+
+def test_problem_one_resample_and_rejuvenate(
+ dkg_state_one, dkg_stoch_astar_planner, dkg_astar_planner
+):
+ model = SIPS(dkg_stoch_astar_planner, DKGObservation())
+ (
+ plan,
+ solved,
+ ) = dkg_astar_planner.generate_plan(dkg_state_one)
+ observations = plan.states
+ infered_goal = model.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1")],
+ observations,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 1.0, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_problem_two_resample_and_rejuvenate(
+ dkg_state_two, dkg_stoch_astar_planner, dkg_astar_planner
+):
+ model = SIPS(dkg_stoch_astar_planner, DKGObservation())
+ (
+ plan,
+ solved,
+ ) = dkg_astar_planner.generate_plan(dkg_state_two)
+ observations = plan.states
+ infered_goal = model.infer(
+ 100,
+ plan.states[0],
+ [("has", "gem1"), ("has", "gem2")],
+ observations,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.5, abs_tol=0.2)
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.5, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_cgem_problem_one():
+ state = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-1.json"
+ )
+ domain = CGemDomain()
+ planner = StochasticAstarPlanner(domain, manhattan_gem_heuristic, 0.1)
+ plan, solved = planner.generate_plan(state)
+ model = SIPS(planner, r=8, p=0.95, noise_model=CGemObservation())
+ goals = [("has", "gem1"), ("has", "gem2")]
+ infered_goal = model.infer(
+ 600,
+ state,
+ goals,
+ plan.states,
+ resample_threshold=0.25,
+ rejuvenate=False,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem1")], 0.5, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem1")], 1.0, abs_tol=0.2
+ )
+
+
+def test_cgem_problem_two():
+
+ state = parse(
+ "beanmachine/facebook/goal_inference/continuous_gems/test_problems/problem-2.json"
+ )
+ domain = CGemDomain()
+ planner = StochasticAstarPlanner(domain, manhattan_gem_heuristic, 0.1)
+ state = dataclasses.replace(state, goal=("has", "gem2"))
+ plan, solved = planner.generate_plan(state)
+ model = SIPS(planner, r=8, p=0.95, noise_model=CGemObservation())
+ goals = [("has", "gem1"), ("has", "gem2")]
+ infered_goal = model.infer(
+ 600,
+ state,
+ goals,
+ plan.states,
+ resample_threshold=0.25,
+ rejuvenate=False,
+ goal_rejuvenation_prob=1.0,
+ )
+ assert math.isclose(infered_goal[0][("has", "gem2")], 0.5, abs_tol=0.2)
+ assert math.isclose(
+ get_last_inference_prediction(infered_goal)[("has", "gem2")], 1.0, abs_tol=0.2
+ )
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/astar.py b/src/beanmachine/ppl/experimental/goal_inference/planner/astar.py
new file mode 100644
index 0000000000..6ca5c8f6a7
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/astar.py
@@ -0,0 +1,80 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+from itertools import count
+
+from queue import PriorityQueue
+
+from typing import Callable, Dict, Tuple
+
+from beanmachine.facebook.goal_inference.environment import Domain, State
+from beanmachine.facebook.goal_inference.planner.planner import Planner, StateNode
+
+
+class AstarPlanner(Planner):
+
+ """
+ Obtains an A* solution to a problem given a heuristic.
+
+ Arguments:
+ domain: Domain that encodes the rules of the world
+ heuristic: Heuristic for A* Algorithm
+
+ Attributes:
+
+ domain: Domain that encodes the rules of the world
+ visited_nodes: Record of nodes visited during planning
+ heuristic: Heuristic for A* Algorithm
+ cost: Record of cost to reach visited States
+ q: Priority queue for A* algorithm
+ unique: StateNode Id to avoid collisions in Priority Queue (StateNodes cannot be compared)
+
+ """
+
+ def __init__(self, domain: Domain, heuristic: Callable):
+ super().__init__(domain)
+ self.heuristic: Callable = heuristic
+ self.cost: Dict[State, int] = {}
+ self.q: PriorityQueue[Tuple[int, int, StateNode]] = PriorityQueue()
+ self.unique: count[int] = count()
+
+ def is_empty(self) -> bool:
+ """Determines whether the priority queue is empty
+
+ Returns:
+ is_empty: Whether the astar datastructure is empty
+ """
+ return self.q.empty()
+
+ def reset(self) -> None:
+ """Clears the datatructures associated with this AstarPlanner"""
+ self.cost = {}
+ self.q = PriorityQueue()
+ self.visited_nodes = []
+
+ def get_next_node(self) -> StateNode:
+ """Get next StateNode to evaluate
+
+ Returns:
+ The next node to evaluate
+
+ """
+ curr_prioirity, curr_count, curr_node = self.q.get()
+ return curr_node
+
+ def add_node(self, new_node) -> None:
+ """Add a node to Astar datastructure
+
+ Arguments:
+ new_node: The node to be potentially explored
+ """
+ if new_node.parent_node is None:
+ self.cost[new_node.state] = 0
+ self.q.put((0, next(self.unique), new_node))
+ else:
+ new_cost = self.cost[new_node.parent_node.state] + 1
+ if new_node.state not in self.cost or new_cost < self.cost[new_node.state]:
+ self.cost[new_node.state] = new_cost
+ priority = new_cost + self.heuristic(new_node)
+ self.q.put((priority, next(self.unique), new_node))
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/astar_test.py b/src/beanmachine/ppl/experimental/goal_inference/planner/astar_test.py
new file mode 100644
index 0000000000..6033fc064d
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/astar_test.py
@@ -0,0 +1,310 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.planner.astar import AstarPlanner
+from beanmachine.facebook.goal_inference.utils import manhattan_gem_heuristic
+
+
+def test_astar_generate_plan_dkg_problem_1(dkg_domain, dkg_state_one):
+ astar_solver = AstarPlanner(dkg_domain, manhattan_gem_heuristic)
+ plan, solved = astar_solver.generate_plan(dkg_state_one)
+ assert solved
+ assert plan.actions == [
+ ["down"],
+ ["pickup", "key1"],
+ ["down"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["pickup", "gem1"],
+ ]
+
+
+def test_astar_generate_plan_dkg_problem_2(dkg_domain, dkg_state_two):
+ astar_solver = AstarPlanner(dkg_domain, manhattan_gem_heuristic)
+ plan, solved = astar_solver.generate_plan(dkg_state_two)
+ assert solved
+ assert plan.actions == [
+ ["down"],
+ ["down"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["pickup", "key1"],
+ ["down"],
+ ["down"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["pickup", "gem1"],
+ ]
+
+
+def test_astar_generate_plan_dkg_problem_3(dkg_domain, dkg_state_three):
+ astar_solver = AstarPlanner(dkg_domain, manhattan_gem_heuristic)
+ plan, solved = astar_solver.generate_plan(dkg_state_three)
+ assert solved
+ soln_one = plan.actions == [
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["left"],
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["pickup", "key1"],
+ ["right"],
+ ["right"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["down"],
+ ["pickup", "key2"],
+ ["right"],
+ ["unlock", "key2", "down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["pickup", "gem3"],
+ ]
+ soln_two = plan.actions == [
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["left"],
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["pickup", "key1"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["right"],
+ ["right"],
+ ["pickup", "gem3"],
+ ]
+ soln_three = plan.actions == [
+ ["right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["left"],
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["pickup", "key1"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["right"],
+ ["right"],
+ ["pickup", "gem3"],
+ ]
+ assert soln_one or soln_two or soln_three
+
+
+def test_astar_generate_plan_dkg_problem_4(dkg_domain, dkg_state_four):
+ astar_solver = AstarPlanner(dkg_domain, manhattan_gem_heuristic)
+ plan, solved = astar_solver.generate_plan(dkg_state_four)
+ assert solved
+ soln_one = plan.actions == [
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["down"],
+ ["down"],
+ ["pickup", "key1"],
+ ["up"],
+ ["up"],
+ ["pickup", "key2"],
+ ["right"],
+ ["right"],
+ ["unlock", "key2", "down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["left"],
+ ["left"],
+ ["unlock", "key1", "up"],
+ ["up"],
+ ["up"],
+ ["pickup", "gem3"],
+ ]
+
+ soln_two = plan.actions == [
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["down"],
+ ["down"],
+ ["pickup", "key1"],
+ ["up"],
+ ["up"],
+ ["pickup", "key2"],
+ ["right"],
+ ["right"],
+ ["unlock", "key1", "down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["left"],
+ ["left"],
+ ["unlock", "key2", "up"],
+ ["up"],
+ ["up"],
+ ["pickup", "gem3"],
+ ]
+
+ soln_three = plan.actions == [
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["pickup", "key2"],
+ ["down"],
+ ["down"],
+ ["pickup", "key1"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["unlock", "key2", "down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["left"],
+ ["left"],
+ ["unlock", "key1", "up"],
+ ["up"],
+ ["up"],
+ ["pickup", "gem3"],
+ ]
+
+ soln_four = plan.actions == [
+ ["left"],
+ ["left"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["right"],
+ ["pickup", "key2"],
+ ["down"],
+ ["down"],
+ ["pickup", "key1"],
+ ["up"],
+ ["up"],
+ ["right"],
+ ["right"],
+ ["unlock", "key1", "down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["down"],
+ ["left"],
+ ["left"],
+ ["unlock", "key2", "up"],
+ ["up"],
+ ["up"],
+ ["pickup", "gem3"],
+ ]
+ assert soln_one or soln_two or soln_three or soln_four
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/bfs.py b/src/beanmachine/ppl/experimental/goal_inference/planner/bfs.py
new file mode 100644
index 0000000000..a8889c58eb
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/bfs.py
@@ -0,0 +1,67 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+from collections import deque
+
+from typing import Deque, Set
+
+from beanmachine.facebook.goal_inference.environment import Domain, State
+from beanmachine.facebook.goal_inference.planner.planner import Planner, StateNode
+
+
+class BFSPlanner(Planner):
+
+ """
+ Obtains a Breadth First Search solution to a problem.
+
+ Arguments:
+ domain: Domain that encodes the rules of the world
+
+ Attributes:
+
+ domain: Domain that encodes the rules of the world
+ visited_nodes: Record of nodes visited during planning
+ queue: Maintains queue of StateNodes for BFS
+ visited: Maintains a record of visited states
+
+ """
+
+ def __init__(self, domain: Domain):
+ super().__init__(domain)
+ self.deque: Deque[StateNode] = deque()
+ self.visited: Set[State] = set()
+
+ def is_empty(self) -> bool:
+ """Evaluates to True if the bfs datastructure is empty
+
+ Returns:
+ is_empty: Whether the bfs datastructure is empty
+
+ """
+ return not bool(self.deque)
+
+ def reset(self) -> None:
+ """Clears the datatructures associated with this BFSPlanner"""
+ self.deque = deque()
+ self.visited_nodes = []
+
+ def get_next_node(self) -> StateNode:
+ """Get next StateNode to evaluate
+
+ Returns:
+ The next node to evaluate
+
+ """
+ return self.deque.popleft()
+
+ def add_node(self, new_node: StateNode) -> None:
+ """Add a node to BFS datastructure
+
+ Arguments:
+ new_nodes: The node to be potentially explored
+
+ """
+ if new_node.state not in self.visited:
+ self.visited.add(new_node.state)
+ self.deque.append(new_node)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/bfs_test.py b/src/beanmachine/ppl/experimental/goal_inference/planner/bfs_test.py
new file mode 100644
index 0000000000..fd289bb5a6
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/bfs_test.py
@@ -0,0 +1,29 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.planner.bfs import BFSPlanner
+
+
+def test_bfs_generate_plan_dkg_problem_1(dkg_domain, dkg_state_one):
+
+ bfs_solver = BFSPlanner(dkg_domain)
+ plan, solved = bfs_solver.generate_plan(dkg_state_one)
+ assert solved
+ assert plan.actions == [
+ ["down"],
+ ["pickup", "key1"],
+ ["down"],
+ ["unlock", "key1", "right"],
+ ["right"],
+ ["right"],
+ ["up"],
+ ["up"],
+ ["pickup", "gem1"],
+ ]
+
+
+def test_bfs_generate_plan_dkg_problem_2(dkg_domain, dkg_state_two):
+
+ bfs_solver = BFSPlanner(dkg_domain)
+ plan, solved = bfs_solver.generate_plan(dkg_state_two)
+ assert solved
+ assert len(plan.actions) == 14
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/planner.py b/src/beanmachine/ppl/experimental/goal_inference/planner/planner.py
new file mode 100644
index 0000000000..af18165894
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/planner.py
@@ -0,0 +1,190 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+import math
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+from beanmachine.facebook.goal_inference.environment import Domain, State
+
+
+@dataclass
+class StateNode:
+
+ """
+ Defines nodes for graph-based representation of relationship between states.
+
+ Arguments/Attributes:
+ state: Current State
+ parent_node: Parent to this node
+ executed: Previous operation to get to this point in format [action_name,*args]
+ """
+
+ state: State
+ parent_node: Optional[StateNode]
+ executed: List[str]
+
+
+@dataclass()
+class Plan:
+ """
+ Defines a sequence of actions in string form (e.g. ["unlock","key1","right"]) and (expected) states
+
+ Arguments/Attributes:
+ actions: A sequence of actions to perform
+ states: Expected states following actions. e.g. states[i+1] is predicted state after actions[i]
+ visited_nodes: Nodes visited during the planning process
+ budget: The search budget for creating this plan
+ """
+
+ states: List[State]
+ actions: List[List[str]]
+ visited_nodes: List[StateNode]
+ budget: int
+
+
+class Planner(ABC):
+ """A Planner finds sequences of actions to solve a problem
+
+ Arguments:
+ domain: The domain that determines the rules of the environment.
+
+ Attributes:
+ domain: The domain that determines the rules of the environment.
+ visited_nodes: A record of the nodes visited during planning.
+ """
+
+ def __init__(self, domain: Domain):
+ self.domain: Domain = domain
+ self.visited_nodes: List[StateNode] = []
+
+ def generate_plan(
+ self, initial_state: State, budget: float = math.inf
+ ) -> Tuple[Plan, bool]:
+ """Searches for a plan to solve the problem given budgetary constraints
+ Determines whether a solution has been reached
+
+ Arguments:
+ initial_state: The initial_state of the search
+ budget: The number of nodes that can be evaluated when formulating a plan
+
+ Returns:
+ plan: The Plan found by the search
+ solved: Whether the plan reached the goal
+
+ """
+ self.reset()
+ init_node = StateNode(initial_state, None, [])
+ self.add_node(init_node)
+ search_count = 0
+ curr_node = init_node
+ goal_achieved = self.domain.evaluate_goal(init_node.state)
+ while search_count < budget:
+ curr_node = self.get_next_node()
+ self.visited_nodes.append(curr_node)
+ search_count += 1
+ goal_achieved = self.domain.evaluate_goal(curr_node.state)
+ # Goal is achieved - end planning
+ if goal_achieved:
+ break
+ poss_actions = self.domain.get_possible_actions(curr_node.state)
+ for act in poss_actions:
+ next_state = self.domain.execute(curr_node.state, *act)
+ new_node = StateNode(next_state, executed=act, parent_node=curr_node)
+ self.add_node(new_node)
+ # Hit a dead end - end planning
+ if self.is_empty():
+ break
+
+ return (
+ # pyre-fixme[19]: Expected 4 positional arguments.
+ Plan(*get_execution_path(curr_node), self.visited_nodes, search_count),
+ goal_achieved,
+ )
+
+ @abstractmethod
+ def reset(self) -> None:
+ """Clears the datatructures associated with this Planner"""
+ pass
+
+ @abstractmethod
+ def is_empty(self) -> bool:
+ """Evaluates to True if the planning datastructure is empty
+
+ Returns:
+ is_empty: Whether the planning datastructure is empty
+ """
+ pass
+
+ @abstractmethod
+ def get_next_node(self) -> StateNode:
+ """Get next StateNode to evaluate
+
+ Returns:
+ The next node to evaluate
+
+ """
+ pass
+
+ @abstractmethod
+ def add_node(self, new_node: StateNode) -> None:
+ """Add a node to potentially be explored
+
+ Arguments:
+ new_node: The node to be potentially explored
+ """
+ pass
+
+
+def get_execution_path(
+ curr_node: Optional[StateNode],
+) -> Tuple[List[State], List[List[str]]]:
+ """
+ Determines All States/Actions to reach the current node.
+ Each action is in format [action_name,*args]
+ acts[i] is the transition between state[i] and state[i+1]
+
+ Arguments:
+ curr_node: The current node whose path is being analyzed
+
+ Returns:
+ states: States on path to current node
+ actions: Actions on path to current node
+ """
+ acts = []
+ states = []
+ while curr_node.parent_node is not None:
+ acts.append(curr_node.executed)
+ states.append(curr_node.state)
+ curr_node = curr_node.parent_node
+ states.append(curr_node.state)
+ acts.reverse()
+ states.reverse()
+ return states, acts
+
+
+def get_plan_from_actions(
+ domain: Domain, state: State, actions: List[List[str]]
+) -> Plan:
+ """Determines the plan that results from a series of actions
+
+ Arguments:
+ domain: The domain of the world
+ state: Initial State
+ actions: Series of actions that will be performed
+
+ Returns:
+ Plan: The plan that results from the actions
+
+ """
+ states = []
+ states.append(state)
+ curr_state = state
+ for act in actions:
+ next_state = domain.execute(curr_state, *act)
+ states.append(next_state)
+ curr_state = next_state
+ return Plan(states, actions, [], 0)
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/planners_test.py b/src/beanmachine/ppl/experimental/goal_inference/planner/planners_test.py
new file mode 100644
index 0000000000..0015394718
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/planners_test.py
@@ -0,0 +1,16 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_execution_path,
+ StateNode,
+)
+
+
+def test_get_execution_path(dkg_domain, dkg_state_one):
+
+ first_node = StateNode(dkg_state_one, None, [""])
+ second_state = dkg_domain.execute(dkg_state_one, "down")
+ second_node = StateNode(second_state, first_node, ["down"])
+ third_state = dkg_domain.execute(second_state, "pickup", "key1")
+ third_node = StateNode(third_state, second_node, ["pickup", "key1"])
+ assert get_execution_path(third_node)[1] == [["down"], ["pickup", "key1"]]
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/stoch_astar.py b/src/beanmachine/ppl/experimental/goal_inference/planner/stoch_astar.py
new file mode 100644
index 0000000000..50ccec5fb5
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/stoch_astar.py
@@ -0,0 +1,287 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Tuple
+
+import torch
+from beanmachine.facebook.goal_inference.agent.observation_model import (
+ DeterministicObservation,
+ ObservationModel,
+)
+
+from beanmachine.facebook.goal_inference.environment import Domain, State
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_execution_path,
+ Plan,
+ Planner,
+ StateNode,
+)
+
+
+class StochasticAstarPlanner(Planner):
+
+ """
+ Obtains a probabilistic A* solution to a problem given a heuristic.
+ The next node to explore is determined probabilistic sampling based on priorities
+ where priority = cost (to reach that node) + heuristic (estimating additional actions until goal)
+ and weights are proportional to exp(-priority/noise)
+
+ Arguments:
+ domain: Domain that encodes the rules of the world
+ heuristic: Heuristic for A* Algorithm
+ noise: Controls randomness of sampling process
+
+ Attributes:
+ domain: Domain that encodes the rules of the world
+ visited_nodes: Record of nodes visited during planning
+ heuristic: Heuristic for A* Algorithm
+ cost: Record of cost to reach visited States
+ weights: Proportional to probability of sampling a state
+ nodes: Current nodes that can be sampled
+ noise: Controls randomness of sampling process
+
+ """
+
+ def __init__(self, domain: Domain, heuristic: Callable, noise: float):
+ super().__init__(domain)
+ self.heuristic: Callable = heuristic
+ self.cost: Dict[State, int] = {}
+ self.weights: Dict[State, float] = {}
+ self.nodes: Dict[State, StateNode] = {}
+ self.noise: float = noise
+
+ def _sample(self) -> StateNode:
+ """Samples from nodes with probabilities proportional to weights
+
+ Returns:
+ node: Sampled StateNode
+ """
+ weight_tensor = torch.tensor(list(self.weights.values()))
+ sampled_index = torch.distributions.categorical.Categorical(
+ logits=weight_tensor
+ ).sample()
+ sampled_state = list(self.weights.keys())[sampled_index]
+ return self._sample_node(sampled_state)
+
+ def _sample_node(self, state: State) -> StateNode:
+ """Samples target node. Removes node and corresponding weight from planner
+
+ Arguments:
+ state: State being sampled
+ Returns:
+ state_node: StateNode corresponding to the sampled state
+ """
+ self.weights.pop(state)
+ return self.nodes.pop(state)
+
+ def is_empty(self) -> bool:
+ """Determines whether the prioirty queue is empty
+
+ Returns:
+ is_empty: Whether the astar datastructure is empty
+ """
+ return not self.nodes
+
+ def reset(self) -> None:
+ """Clears the datatructures associated with this StochasticAstarPlanner"""
+ self.cost = {}
+ self.weights = {}
+ self.nodes = {}
+ self.visited_nodes = []
+
+ def get_next_node(self) -> StateNode:
+ """Get next StateNode to evaluate
+
+ Returns:
+ The next node to evaluate
+ """
+ curr_node = self._sample()
+ return curr_node
+
+ def add_node(self, new_node: StateNode) -> None:
+ """Add a node to StochasticAstar datastructure
+
+ Arguments:
+ new_node: The node to be potentially explored
+ """
+ if new_node.parent_node is None:
+ self.cost[new_node.state] = 0
+ self.weights[new_node.state] = 0.0
+ self.nodes[new_node.state] = new_node
+ else:
+ new_cost = self.cost[new_node.parent_node.state] + 1
+ if new_node.state not in self.cost or new_cost < self.cost[new_node.state]:
+ self.cost[new_node.state] = new_cost
+ priority = new_cost + self.heuristic(new_node)
+ # Weight is proportional to exp[-priority/noise]
+ self.weights[new_node.state] = -priority / self.noise
+ self.nodes[new_node.state] = new_node
+
+
+class StochasticAstarProposalPlanner(StochasticAstarPlanner):
+
+ """
+ Proposes a new path using probabilistic A* algorithm.
+ The next node to explore is determined probabilistic sampling based on priorities
+ where priority = cost (to reach that node) + heuristic (estimating additional actions until goal)
+ and weights are proportional to exp(-priority/noise)*P(next_observation|next_state)
+
+ P(next_observation|next_state) is an additional bias to encourage paths near future observations
+
+ Arguments:
+ agent_planner: The planning algorithm for the BoundedRationalAgent
+
+ Attributes:
+ domain: Domain that encodes the rules of the world
+ visited_nodes: Record of nodes visited during planning
+ heuristic: Heuristic for A* Algorithm. If the agent_planner was not a StochasticA*Planner, the heuristic just returns 0.0 for any state
+ noise: Controls randomness of sampling process
+ cost: Record of cost to reach visited States
+ weights: Proportional to probability of sampling a state
+ nodes: Current nodes that can be sampled
+ noise_model: A model for P(observation|state)
+ observations: List of future observations
+ """
+
+ def __init__(self, agent_planner: Planner):
+ self.heuristic = null_heuristic
+ self.noise: float = 0.1
+ if isinstance(agent_planner, StochasticAstarPlanner):
+ self.heuristic: Callable = agent_planner.heuristic
+ self.noise: float = agent_planner.noise
+ super().__init__(agent_planner.domain, self.heuristic, self.noise)
+ self.observations: List[State] = []
+ self.noise_model: ObservationModel = DeterministicObservation()
+
+ def _sample(self) -> StateNode:
+ """Samples from nodes with probabilities proportional to weights
+
+ Returns:
+ node: Sampled StateNode
+ """
+ weight_tensor = self._get_next_state_weights()
+ sampled_index = torch.distributions.categorical.Categorical(
+ logits=weight_tensor
+ ).sample()
+ sampled_state = list(self.weights.keys())[sampled_index]
+ return self._sample_node(sampled_state)
+
+ def _get_next_state_weights(self) -> torch.Tensor:
+ """Defines the biasing of the proposal distribution.
+ Probability of a node being sampled is proportional to exp[-heuristic/noise] * P(next_observation|next_state)
+
+ Returns:
+ biased_weights: Unnormalized Log weights associeated with the probability of each node being sampled
+ """
+ biased_weights = torch.tensor(list(self.weights.values()))
+ biased_weights = torch.nan_to_num(biased_weights, nan=-float("inf"))
+ biased_weights = torch.nan_to_num(biased_weights)
+ return biased_weights
+
+ def add_node(self, new_node: StateNode) -> None:
+ """Add a node to StochasticAstarProposal datastructure
+
+ Arguments:
+ new_node: The node to be potentially explored
+ """
+ if new_node.parent_node is None:
+ self.cost[new_node.state] = 0
+ self.weights[new_node.state] = 0.0
+ self.nodes[new_node.state] = new_node
+ else:
+ new_cost = self.cost[new_node.parent_node.state] + 1
+ if new_node.state not in self.cost or new_cost < self.cost[new_node.state]:
+ self.cost[new_node.state] = new_cost
+ priority = new_cost + self.heuristic(new_node)
+ bias = 0.0
+ curr_path = get_execution_path(new_node)[0]
+ if len(curr_path) - 1 < len(self.observations):
+ bias = self.noise_model.get_log_prob(
+ curr_path[-1], self.observations[len(curr_path) - 1]
+ )
+ # Naive weight is proportional to exp[-priority/noise]
+ # Adjust priority based on P(next_observation|next_state)
+ self.weights[new_node.state] = -priority / self.noise + bias
+ self.nodes[new_node.state] = new_node
+
+ def propose(
+ self,
+ state: State,
+ observations: List[State],
+ budget: int,
+ noise_model: ObservationModel,
+ ) -> Tuple[Plan, bool]:
+ """Propose a plan using the biased proposal distribution
+
+ Arguments:
+ state: The starting state of the plan
+ observations: List of future observations
+ budget: Node search limit for the planning process
+ noise_model: A model for P(observation|state)
+
+ Returns:
+ plan: A new partial plan to reach the goal
+ solved: Whether the plan reached the goal
+ """
+ self.observations = observations
+ self.noise_model = noise_model
+ return self.generate_plan(state, budget)
+
+ def get_log_prob(
+ self, plan: Plan, observations: List[State], noise_model: ObservationModel
+ ) -> torch.Tensor:
+ """Get the log probability of a specific bounded-rational agent planning sequence
+
+ Arguments:
+ plan: The planning process to compute probability of
+ observations: List of future observations
+ noise_model: A model for P(observation|state)
+
+ Returns:
+ log_prob: Log probability of the plan
+ """
+ # Initialize planning
+ self.reset()
+ self.observations = observations
+ self.noise_model = noise_model
+ init_node = StateNode(plan.states[0], None, [])
+ self.add_node(init_node)
+ log_prob = torch.tensor(0.0)
+ # Follow the planning decisions and update the probability of the
+ # planning sequence with each decision
+ for planning_step in range(len(plan.visited_nodes)):
+ # Get the probability distribution at this stage of planning
+ current_distribution = self._get_next_state_weights()
+ current_distribution -= torch.logsumexp(current_distribution, dim=0)
+ curr_visited_state = plan.visited_nodes[planning_step].state
+ # Determine which node was sampled
+ for node_idx in range(len(self.nodes)):
+ curr_node_state = list(self.nodes.keys())[node_idx]
+ if curr_node_state == curr_visited_state:
+ log_prob += current_distribution[node_idx]
+ curr_node = self._sample_node(curr_node_state)
+ # Add next possible nodes to replicate planning process
+ poss_actions = self.domain.get_possible_actions(curr_node.state)
+ for act in poss_actions:
+ next_state = self.domain.execute(curr_node.state, *act)
+ new_node = StateNode(
+ next_state, executed=act, parent_node=curr_node
+ )
+ self.add_node(new_node)
+ break
+
+ return log_prob
+
+
+def null_heuristic(state: State) -> float:
+ """Default heuristic for StochasticAstarProposalPlanner
+ Returns 0 cost for all goals for all states
+
+ Arguments:
+ state: State to predict additional cost to goal
+
+ Returns:
+ cost: =0.0 in all cases
+ """
+ return 0.0
diff --git a/src/beanmachine/ppl/experimental/goal_inference/planner/stoch_astar_test.py b/src/beanmachine/ppl/experimental/goal_inference/planner/stoch_astar_test.py
new file mode 100644
index 0000000000..70681afeeb
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/planner/stoch_astar_test.py
@@ -0,0 +1,110 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import torch
+from beanmachine.facebook.goal_inference.agent.observation_model import (
+ DeterministicObservation,
+)
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_observation_model import (
+ DKGObservation,
+)
+
+from beanmachine.facebook.goal_inference.planner.planner import (
+ get_plan_from_actions,
+ StateNode,
+)
+
+from beanmachine.facebook.goal_inference.planner.stoch_astar import (
+ StochasticAstarPlanner,
+ StochasticAstarProposalPlanner,
+)
+from beanmachine.facebook.goal_inference.utils import manhattan_gem_heuristic
+
+
+def test_stoch_astar_generate_plan_dkg_problem_1(dkg_domain, dkg_state_one):
+ st_astar_solver = StochasticAstarPlanner(dkg_domain, manhattan_gem_heuristic, 0.5)
+ plan, solved = st_astar_solver.generate_plan(dkg_state_one)
+ assert solved
+ assert plan.actions[-1] == ["pickup", "gem1"]
+
+
+def test_stoch_astar_generate_plan_dkg_problem_2(dkg_domain, dkg_state_two):
+ st_astar_solver = StochasticAstarPlanner(dkg_domain, manhattan_gem_heuristic, 0.5)
+ plan, solved = st_astar_solver.generate_plan(dkg_state_two)
+ assert solved
+ assert plan.actions[-1] == ["pickup", "gem1"]
+
+
+def test_path_propose(dkg_domain, dkg_state_three, dkg_observation_set):
+ planner = StochasticAstarPlanner(dkg_domain, manhattan_gem_heuristic, 0.1)
+ proposal_planner = StochasticAstarProposalPlanner(planner)
+ new_plan, solved = proposal_planner.propose(
+ dkg_state_three, dkg_observation_set, 1000, DeterministicObservation()
+ )
+ for time_step in range(10):
+ assert new_plan.states[time_step] == dkg_observation_set[time_step]
+
+
+def test_get_log_prob(dkg_domain, dkg_state_three, dkg_observation_set):
+ noise_model = DKGObservation()
+ planner = StochasticAstarPlanner(dkg_domain, manhattan_gem_heuristic, 0.1)
+ proposal_planner = StochasticAstarProposalPlanner(planner)
+ new_actions = [
+ ["right"],
+ ["right"],
+ ["right"],
+ ]
+ new_plan = get_plan_from_actions(dkg_domain, dkg_state_three, new_actions)
+ new_plan.budget = 4
+ new_plan.visited_nodes = [
+ StateNode(new_plan.states[0], None, []),
+ StateNode(new_plan.states[1], None, []),
+ StateNode(new_plan.states[2], None, []),
+ StateNode(new_plan.states[3], None, []),
+ ]
+
+ computed_prob = torch.tensor(0.0)
+
+ # Step 1
+
+ # No Option Moves Right
+
+ # Step 2
+
+ # Options RR or RL
+
+ node_weights = torch.tensor([-5.0 / 0.1, -7.0 / 0.1])
+
+ # Bias
+
+ # state RR
+ # state RL
+ state_rr = dkg_domain.execute(new_plan.states[1], "right")
+ state_rl = dkg_domain.execute(new_plan.states[1], "left")
+ node_weights[0] += noise_model.get_log_prob(state_rr, dkg_observation_set[2])
+ node_weights[1] += noise_model.get_log_prob(state_rl, dkg_observation_set[2])
+
+ node_weights -= torch.logsumexp(node_weights, dim=0)
+ computed_prob += node_weights[0]
+
+ # Step 3
+
+ # Options RRR RRL RL
+
+ node_weights = torch.tensor([-4.0 / 0.1, -6.0 / 0.1, -7.0 / 0.1])
+
+ # Bias
+ state_rrr = dkg_domain.execute(new_plan.states[2], "right")
+ state_rrl = dkg_domain.execute(new_plan.states[2], "left")
+ state_rl = dkg_domain.execute(new_plan.states[1], "left")
+ node_weights[0] += noise_model.get_log_prob(state_rrr, dkg_observation_set[3])
+ node_weights[1] += noise_model.get_log_prob(state_rrl, dkg_observation_set[3])
+ node_weights[2] += noise_model.get_log_prob(state_rl, dkg_observation_set[2])
+
+ node_weights -= torch.logsumexp(node_weights, dim=0)
+ computed_prob += node_weights[0]
+
+ assert torch.isclose(
+ computed_prob,
+ proposal_planner.get_log_prob(new_plan, dkg_observation_set, noise_model),
+ atol=0.1,
+ )
diff --git a/src/beanmachine/ppl/experimental/goal_inference/plotting/utils.py b/src/beanmachine/ppl/experimental/goal_inference/plotting/utils.py
new file mode 100644
index 0000000000..53eed55c83
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/plotting/utils.py
@@ -0,0 +1,166 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+import tempfile
+
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+import matplotlib.pyplot as plt
+import numpy as np
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemState,
+)
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import DKGState
+from IPython.display import display, Image
+from matplotlib.animation import FuncAnimation
+
+
+def get_gem_inference_plot(
+ inference_data: List[Dict[str, int]], frame: int
+) -> Dict[str, List[float]]:
+ """Formats posterior P(g|obs) from inference for plotting
+ Applicable for doors, keys, and gems / continuous gems problems
+
+ Arguments:
+ inference_data: Computation of the posterior P(goal|observations) at each time step
+ frame: Time step to plot
+
+ Returns:
+ poster: P(goal|observations) for each time step until the current frame
+
+ """
+ curr_data = inference_data[: frame + 1]
+ posterior = {}
+ for goal_id in inference_data[0]:
+ posterior[goal_id[1]] = []
+
+ for time_step in range(len(curr_data)):
+ for goal_id in curr_data[time_step]:
+ posterior[goal_id[1]].append(curr_data[time_step][goal_id])
+
+ return posterior
+
+
+def get_gem_figure(
+ state: Union[DKGState, CGemState],
+ inference_data: Optional[List[Dict[str, int]]] = None,
+ is_doors_keys_gems: bool = False,
+) -> Tuple[plt.Figure, List[plt.Axes]]:
+ """Returns a figure with the current formatting
+ Applicable for doors, keys, and gems / continuous gems problems
+
+ Arguments:
+ state: State to get figure for
+ inference_data: Computation of the posterior P(goal|observations) at each time step
+ is_doors_keys_gems: Whether the problem is a doors, keys, and gems problem.
+
+ Returns:
+ fig: The figure object with the correct size/subplot settings
+ axes: A list of Matplotlib Axes objects for further modification
+ """
+
+ fig = plt.figure(figsize=(1, 1))
+
+ if inference_data is None:
+ fig = plt.figure(figsize=(10, 5))
+ ax1 = plt.subplot(1, 2, 1)
+ ax2 = plt.subplot(1, 2, 2)
+ ax3 = None
+ else:
+ fig = plt.figure(figsize=(7, 7))
+ ax1 = plt.subplot(2, 2, 1)
+ ax2 = plt.subplot(2, 2, 2)
+ ax3 = plt.subplot(2, 1, 2)
+
+ plt.sca(ax1)
+ plt.gca().set_title("Environment")
+
+ if is_doors_keys_gems:
+
+ plt.gca().set_xticks(np.arange(1, state.width + 1, 1))
+ plt.gca().set_yticks(np.arange(1, state.height + 1, 1))
+
+ plt.gca().set_xticks(np.arange(0.5, state.width + 1, 1), minor=True)
+ plt.gca().set_yticks(np.arange(0.5, state.height + 1, 1), minor=True)
+
+ plt.gca().grid(which="minor", color="k", linestyle="-", linewidth=2)
+ plt.gca().grid(which="major", visible=False)
+
+ else:
+
+ plt.gca().set_xlim(0.0, state.width)
+ plt.gca().set_ylim(0.0, state.height)
+
+ plt.sca(ax2)
+
+ plt.gca().set_title("Holding")
+ plt.gca().set_xticks([])
+ plt.gca().set_yticks(np.arange(1, 9, 1))
+
+ plt.gca().set_xticks(np.arange(0.5, 2.0, 1), minor=True)
+ plt.gca().set_yticks(np.arange(0.5, 9.0, 1), minor=True)
+
+ plt.gca().grid(which="minor", color="k", linestyle="-", linewidth=2)
+ plt.gca().grid(which="major", visible=False)
+
+ axes = [ax1, ax2]
+
+ if inference_data is not None:
+ plt.sca(ax3)
+ plt.gca().set_title("Inference")
+ plt.gca().set_xlabel("Time Step")
+ plt.gca().set_ylabel("Probability")
+ plt.gca().set_ylim(0.0, 1.0)
+ plt.gca().set_xlim(0.0, len(inference_data))
+ plt.gca().set_xticks(np.arange(0, len(inference_data), 5))
+ plt.gca().set_yticks([0.0, 0.25, 0.50, 0.75, 1.0])
+ axes.append(ax3)
+
+ return fig, axes
+
+
+def format_gem_data(data: np.ndarray) -> np.ndarray:
+ """Adjusts data matrix so it is the right orientation for imshow
+ Applicable for doors, keys, and gems / continuous gems problems
+
+ Arguments:
+ data: Input data array
+
+ Returns:
+ data: Modified data array
+ """
+ data = np.rot90(data, 1, (0, 1))
+ data = np.rot90(data, 2, (0, 1))
+ data = np.flip(data, axis=1)
+ data += 0.5
+ return data
+
+
+def create_gif(
+ fig: plt.Figure,
+ animation_function: Callable,
+ states: Union[List[DKGState], List[CGemState]],
+ file_path: Optional[str],
+):
+ """Creates a gif for a series of states
+ Applicable for doors, keys, and gems / continuous gems problems
+
+ Arguments:
+
+ fig: Base matplotlib figure
+ animation_function: Defines update of each frame of the gif
+ states: Series of states to plot
+ file_path: Optional location to save gif
+
+ """
+
+ anim_created = FuncAnimation(
+ fig, animation_function, frames=len(states), interval=200
+ )
+ if file_path is None:
+ with tempfile.TemporaryDirectory() as tmpdirname:
+ anim_created.save(tmpdirname + "/tmp.gif", fps=10)
+ display(Image(tmpdirname + "/tmp.gif", format="png"))
+ else:
+ anim_created.save(file_path, fps=10)
+ display(Image(filename=file_path, format="png"))
diff --git a/src/beanmachine/ppl/experimental/goal_inference/test_utils.py b/src/beanmachine/ppl/experimental/goal_inference/test_utils.py
new file mode 100644
index 0000000000..18793a16a2
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/test_utils.py
@@ -0,0 +1,10 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.utils import manhattan_distance
+
+
+def test_manhattan_distance():
+ assert manhattan_distance((1.0, 1.0), (1.0, 1.0)) == 0.0
+ assert manhattan_distance((1.0, 2.0), (1.0, 1.0)) == 1.0
+ assert manhattan_distance((1.0, 1.0), (2.0, 1.0)) == 1.0
+ assert manhattan_distance((1.0, 1.0), (2.0, 2.0)) == 2.0
diff --git a/src/beanmachine/ppl/experimental/goal_inference/utils.py b/src/beanmachine/ppl/experimental/goal_inference/utils.py
new file mode 100644
index 0000000000..b4e369f766
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/utils.py
@@ -0,0 +1,56 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from typing import Optional, Tuple, Union
+
+from beanmachine.facebook.goal_inference.continuous_gems.cgem_definitions import (
+ CGemStateNode,
+)
+
+from beanmachine.facebook.goal_inference.doors_keys_gems.dkg_definitions import (
+ DKGStateNode,
+)
+
+
+def manhattan_distance(
+ coordinates_one: Union[Tuple[float, float], Tuple[int, int]],
+ coordinates_two: Union[Tuple[float, float], Tuple[int, int]],
+) -> Union[int, float]:
+ """Computes the manhattan distance between two objects in 2D
+
+ Arguments:
+ coordinates_one: The position of object one
+ coordinates_two: The position of object two
+
+ Returns:
+ dist: The manhattan distance between the two objects
+
+ """
+ dist_x = coordinates_two[0] - coordinates_one[0]
+ dist_y = coordinates_two[1] - coordinates_one[1]
+ return abs(dist_x) + abs(dist_y)
+
+
+def manhattan_gem_heuristic(
+ curr_node: Union[DKGStateNode, CGemStateNode],
+ goal: Optional[Tuple[str, str]] = None,
+) -> Union[int, float]:
+ """
+ Defines a simple heuristic for solving gems problems with an A* solver.
+ Summary: Estimates additional cost as manhattan distance to goal
+ If a goal is not provided, the goal of the state is presumed
+
+ Arguments:
+ curr_node: The current node to analyze
+ goal: The targeted goal
+
+ Returns:
+ manhattan_dist: Manhattan distance of node to target goal
+ """
+ if goal is None:
+ goal = curr_node.state.goal
+ if goal[1] not in curr_node.state.at:
+ return 0
+ final_x, final_y = curr_node.state.at[goal[1]]
+ # Compute Manhattan distance to goal
+ manhattan_dist = abs(final_x - curr_node.state.x) + abs(final_y - curr_node.state.y)
+ return manhattan_dist
diff --git a/src/beanmachine/ppl/experimental/goal_inference/utils_test.py b/src/beanmachine/ppl/experimental/goal_inference/utils_test.py
new file mode 100644
index 0000000000..18793a16a2
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/goal_inference/utils_test.py
@@ -0,0 +1,10 @@
+# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+
+from beanmachine.facebook.goal_inference.utils import manhattan_distance
+
+
+def test_manhattan_distance():
+ assert manhattan_distance((1.0, 1.0), (1.0, 1.0)) == 0.0
+ assert manhattan_distance((1.0, 2.0), (1.0, 1.0)) == 1.0
+ assert manhattan_distance((1.0, 1.0), (2.0, 1.0)) == 1.0
+ assert manhattan_distance((1.0, 1.0), (2.0, 2.0)) == 2.0
diff --git a/src/beanmachine/ppl/experimental/timeseries/notebooks/GP_autoForecast_M3_month.ipynb b/src/beanmachine/ppl/experimental/timeseries/notebooks/GP_autoForecast_M3_month.ipynb
new file mode 100644
index 0000000000..c92e8722d6
--- /dev/null
+++ b/src/beanmachine/ppl/experimental/timeseries/notebooks/GP_autoForecast_M3_month.ipynb
@@ -0,0 +1,1817 @@
+{
+ "metadata": {
+ "bento_stylesheets": {
+ "bento/extensions/flow/main.css": true,
+ "bento/extensions/kernel_selector/main.css": true,
+ "bento/extensions/kernel_ui/main.css": true,
+ "bento/extensions/new_kernel/main.css": true,
+ "bento/extensions/system_usage/main.css": true,
+ "bento/extensions/theme/main.css": true
+ },
+ "kernelspec": {
+ "display_name": "bm_timeseries (local)",
+ "language": "python",
+ "name": "bm_timeseries_local",
+ "metadata": {
+ "is_prebuilt": false,
+ "kernel_name": "bm_timeseries_local"
+ }
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3"
+ },
+ "captumWidgetMessage": {},
+ "outputWidgetContext": {}
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2,
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "b70e96ce-5d06-4e59-8589-c7e336e07441",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "# Introduction\n",
+ "\n",
+ "In this tutorial, we implement kernels designed in Automatic forecasting using Gaussian Process [1] and test results with the M3 dataset.\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "4d49db74-87a3-4d8c-a986-cc9d442bc981",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "# Data loading and visualization\n",
+ "The data is available at the following path."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": false,
+ "originalKey": "3090a61c-ae03-4cc9-9690-1235a343088e",
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "import matplotlib\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import seaborn as sns\n",
+ "import torch\n",
+ "import gpytorch as gp\n",
+ "import random\n",
+ "\n",
+ "random.seed(0)\n",
+ "df = pd.read_csv('/mnt/persistent-public/zhencao/M3_monthly_TSTS.csv')\n",
+ "df"
+ ],
+ "execution_count": 89,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": " series_id category value timestamp\n0 M1 MICRO 2640.0 1990-01\n1 M1 MICRO 2640.0 1990-02\n2 M1 MICRO 2160.0 1990-03\n3 M1 MICRO 4200.0 1990-04\n4 M1 MICRO 3360.0 1990-05\n... ... ... ... ...\n167557 M1428 OTHER 1282.5 NaN\n167558 M1428 OTHER 1261.3 NaN\n167559 M1428 OTHER 1263.4 NaN\n167560 M1428 OTHER 1257.1 NaN\n167561 M1428 OTHER 1233.7 NaN\n\n[167562 rows x 4 columns]",
+ "text/html": "\n\n
\n \n \n | \n series_id | \n category | \n value | \n timestamp | \n
\n \n \n \n | 0 | \n M1 | \n MICRO | \n 2640.0 | \n 1990-01 | \n
\n \n | 1 | \n M1 | \n MICRO | \n 2640.0 | \n 1990-02 | \n
\n \n | 2 | \n M1 | \n MICRO | \n 2160.0 | \n 1990-03 | \n
\n \n | 3 | \n M1 | \n MICRO | \n 4200.0 | \n 1990-04 | \n
\n \n | 4 | \n M1 | \n MICRO | \n 3360.0 | \n 1990-05 | \n
\n \n | ... | \n ... | \n ... | \n ... | \n ... | \n
\n \n | 167557 | \n M1428 | \n OTHER | \n 1282.5 | \n NaN | \n
\n \n | 167558 | \n M1428 | \n OTHER | \n 1261.3 | \n NaN | \n
\n \n | 167559 | \n M1428 | \n OTHER | \n 1263.4 | \n NaN | \n
\n \n | 167560 | \n M1428 | \n OTHER | \n 1257.1 | \n NaN | \n
\n \n | 167561 | \n M1428 | \n OTHER | \n 1233.7 | \n NaN | \n
\n \n
\n
167562 rows × 4 columns
\n
\n\n
\n \n \n | \n series_id | \n category | \n value | \n timestamp | \n
\n \n \n \n | 612 | \n M10 | \n MICRO | \n 4120.0 | \n 1990-01 | \n
\n \n | 613 | \n M10 | \n MICRO | \n 5020.0 | \n 1990-02 | \n
\n \n | 614 | \n M10 | \n MICRO | \n 3840.0 | \n 1990-03 | \n
\n \n | 615 | \n M10 | \n MICRO | \n 5720.0 | \n 1990-04 | \n
\n \n | 616 | \n M10 | \n MICRO | \n 4960.0 | \n 1990-05 | \n
\n \n | ... | \n ... | \n ... | \n ... | \n ... | \n
\n \n | 675 | \n M10 | \n MICRO | \n 3820.0 | \n 1995-04 | \n
\n \n | 676 | \n M10 | \n MICRO | \n 4880.0 | \n 1995-05 | \n
\n \n | 677 | \n M10 | \n MICRO | \n 2800.0 | \n 1995-06 | \n
\n \n | 678 | \n M10 | \n MICRO | \n 3640.0 | \n 1995-07 | \n
\n \n | 679 | \n M10 | \n MICRO | \n 4100.0 | \n 1995-08 | \n
\n \n
\n
68 rows × 4 columns
\n
",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "bento_obj_id": "140506640048240",
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "91c197e9-f13a-4108-90a0-fbe6df9b0d70",
+ "showInput": false,
+ "customInput": null
+ },
+ "source": [
+ "## Plotting the auto-correlation\n",
+ "We plot the auto correlcation function below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "1827f3b2-21e8-4aaf-b2c8-f557143ff8ea",
+ "showInput": true,
+ "customInput": null,
+ "collapsed": false
+ },
+ "source": [
+ "from statsmodels.graphics.tsaplots import plot_acf\n",
+ "\n",
+ "acf = plot_acf(df['timestamp'])"
+ ],
+ "execution_count": 92,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "bento_obj_id": "140506663587264",
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "b7d43a5c-8d9a-43e4-b682-62cd3b07ce4f",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "## Data transformation\n",
+ "We prepare the training set and test set data with normalizaton."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "967e73a4-ede4-47fe-aabf-1e04386cd7bd",
+ "showInput": true,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": [],
+ "collapsed": false
+ },
+ "source": [
+ "from sts.data import df_to_tensor\n",
+ "\n",
+ "df_convert_fns = {\n",
+ " 'timestamp': lambda x: (x - x.iloc[0]).dt.days\n",
+ "}\n",
+ "\n",
+ "df['log_value'] = np.log(df['value'])\n",
+ "df = df[['timestamp','value','log_value']]\n",
+ "\n",
+ "data = df_to_tensor(df, normalize_cols=True, df_convert_fns=df_convert_fns)\n",
+ "num_trainset = len(df)-num_test\n",
+ "x_train = data[:num_trainset, ['timestamp']]\n",
+ "y_train = data[:num_trainset, 'log_value']\n",
+ "x_test = data[num_trainset:, ['timestamp']]\n",
+ "y_test = data[num_trainset:, 'value']\n",
+ ""
+ ],
+ "execution_count": 93,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ ":7: SettingWithCopyWarning:\n\n\nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "f4bbab2a-de59-4ca3-b1d1-22cfa176fea6",
+ "showInput": true,
+ "customInput": null,
+ "collapsed": false,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "from sts.gp.model import AdditiveSpectralMixtureTimeSeriesExactGPModel\n",
+ "from sts.gp.kernel import WhiteNoiseKernel\n",
+ "from gpytorch.kernels import LinearKernel, RBFKernel\n",
+ "\n",
+ "likelihood = gp.likelihoods.GaussianLikelihood()\n",
+ "model = AdditiveSpectralMixtureTimeSeriesExactGPModel(x_train, y_train, likelihood)\n",
+ "model.cov.add_seasonality(\n",
+ " time_axis=\"timestamp\", period_length=365.25, fix_period=True\n",
+ " )\n",
+ "model.cov.add_trend(\n",
+ " time_axis=\"timestamp\", kernel_cls=LinearKernel, name=\"LinearTrend\"\n",
+ ")\n",
+ "model.cov.add_trend(\n",
+ " time_axis=\"timestamp\",\n",
+ " kernel_cls=RBFKernel,\n",
+ " lengthscale=100,\n",
+ " fix_lengthscale=True,\n",
+ " name=\"RBFTrend\",\n",
+ ")\n",
+ "model.cov.add_spectral_mixture(\n",
+ " time_axis=\"timestamp\",\n",
+ " num_mixtures=2,\n",
+ " train_x=x_train.tensor,\n",
+ " train_y=y_train.tensor,\n",
+ " name=\"SM1\",\n",
+ ")\n",
+ "model.cov.add_spectral_mixture(\n",
+ " time_axis=\"timestamp\",\n",
+ " num_mixtures=2,\n",
+ " train_x=x_train.tensor,\n",
+ " train_y=y_train.tensor,\n",
+ " name=\"SM2\",\n",
+ ")\n",
+ ""
+ ],
+ "execution_count": 94,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "91e3e08a-9580-45e7-ae3d-7ea094d014e9",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "# Training loop\n",
+ "We train our model with our training set, and show the training time below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "7b25842b-cd70-4e8b-8420-e06490104b13",
+ "showInput": true,
+ "customInput": null,
+ "collapsed": false,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "learning_rate = 0.01\n",
+ "num_epochs = 3000\n",
+ "trainer = model.train_init(torch.optim.Adam(model.trainable_params, lr=learning_rate))\n",
+ "\n",
+ "def train():\n",
+ " for epoch in range(num_epochs):\n",
+ " loss = trainer(x_train, y_train)\n",
+ " if (epoch + 1) % 200 == 1:\n",
+ " print(f'epoch {epoch+1}/{num_epochs}, loss {loss}')\n",
+ "\n",
+ "%time train()"
+ ],
+ "execution_count": 95,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "/mnt/xarfuse/uid-353778/4490d57c-seed-nspid4026531836_cgpid99683980-ns-4026531840/gpytorch/utils/cholesky.py:44: NumericalWarning:\n\nA not p.d., added jitter of 1.0e-06 to the diagonal\n\n/mnt/xarfuse/uid-353778/4490d57c-seed-nspid4026531836_cgpid99683980-ns-4026531840/gpytorch/utils/cholesky.py:44: NumericalWarning:\n\nA not p.d., added jitter of 1.0e-05 to the diagonal\n\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 1/3000, loss 1.696009874343872\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 201/3000, loss 1.3974676132202148\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 401/3000, loss 1.2631440162658691\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 601/3000, loss 1.2498987913131714\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 801/3000, loss 1.247230887413025\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 1001/3000, loss 1.2462594509124756\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 1201/3000, loss 1.2457836866378784\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 1401/3000, loss 1.2451318502426147\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 1601/3000, loss 1.2099428176879883\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 1801/3000, loss 1.1965670585632324\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 2001/3000, loss 1.195930004119873\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 2201/3000, loss 1.195489764213562\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 2401/3000, loss 1.1951385736465454\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 2601/3000, loss 1.1948914527893066\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "epoch 2801/3000, loss 1.1947181224822998\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "CPU times: user 7min 44s, sys: 4min 58s, total: 12min 42s\nWall time: 35.3 s\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "a9316bc6-5cd5-4d0e-bfa4-7de704e5a5e2",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "# Predictions\n",
+ "We use our model to forecast the test set.\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "6bb0f25d-a30f-4953-9eae-70b80240e9a5",
+ "showInput": true,
+ "code_folding": [],
+ "hidden_ranges": [],
+ "collapsed": false
+ },
+ "source": [
+ "from sts.data import get_mvn_stats\n",
+ "from torch.distributions import ComposeTransform, ExpTransform\n",
+ "\n",
+ "transform = ComposeTransform([y_train.transforms['log_value'].inv, ExpTransform()])\n",
+ "train_mean, train_var, train_ci = get_mvn_stats(model.predict(x_train), transform)\n",
+ "test_mean, test_var, test_ci = get_mvn_stats(model.predict(x_test), transform)\n",
+ "\n",
+ "f, ax = plt.subplots(1, 1, figsize=(12, 5))\n",
+ "ax.plot(df['timestamp'][:num_trainset], train_mean, alpha=0.8, color='blue', linewidth=1, label='train')\n",
+ "ax.plot(df['timestamp'][num_trainset:], test_mean, alpha=0.8, color='green', linewidth=1, label='test')\n",
+ "ax.plot(df['timestamp'], df['value'], 'o', markersize=1, color='black', label='actual')\n",
+ "ax.fill_between(df['timestamp'], torch.cat([train_ci[0], test_ci[0]]), torch.cat([train_ci[1], test_ci[1]]), alpha=0.2, label='ci', color='gray')\n",
+ "ax.legend()\n",
+ ""
+ ],
+ "execution_count": 96,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": ""
+ },
+ "metadata": {
+ "bento_obj_id": "140506739301920"
+ },
+ "execution_count": 96
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "bento_obj_id": "140506678976624",
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "89198390-d8be-408c-b9e9-6945ab0ef2a3",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "The training set has tight credible intervals, while that of the test set is wider. This makes sense since the credible interval gets larger if we extrapolate from the data. But still, we would like to see better performance in the forecasting part.\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "aa090d07-f404-49f6-b950-81155f5cb732",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "# Kernel Decomposition\n",
+ "We decompose additive kernels to see how each kernel functions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "723c5448-ae4c-4239-afca-1da8daf35dec",
+ "showInput": true,
+ "customInput": null,
+ "collapsed": false,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "from sts.gp.graph import plot_components\n",
+ "\n",
+ "x_all = torch.cat([x_train.tensor, x_test.tensor])\n",
+ "components = model.decompose_timeseries(x_all)\n",
+ "fig, ax = plot_components(df['timestamp'], components[1], y=model.predict(x_all), transform=transform)"
+ ],
+ "execution_count": 97,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": "",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtQAAAHVCAYAAADRmWzIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXA0aX0n+G9mVemsUyqdr463u98+oemGtmnM3dOo7VXsLMgLdg+NjQ0xYXCwHNGsbWIHTzATHdjjwPbEGhxLYDdee7cxbFgdDGgXxOEGejqgj7eP91Wf7yG9kl4ddV+qI7Ny/3gri1KpKiuzDtVTyu8ngrBbmdKbVVnHN3/5e55H0jQNRERERETUHLnbB0BERERE1MsYqImIiIiIWsBATURERETUAgZqIiIiIqIWMFATEREREbWAgZqIiIiIqAXObh9AG3Rt3r/I/g5Gxia79c9TE3jOeg/PWe/hOes9PGe9h+esa6RaP2SFugVFtdjtQyCLeM56D89Z7+E56z08Z72H50wsDNRERERERC1goCYiIiIiagEDNRERERFRCxioiYiIiIhawEBNRERERNQCBmoiIiIiohYwUBMRERERtYCBmoiIiIioBQzUREREREQtYKAmIiIiImoBAzURERERUQsYqImIiIiIWsBATURERETUAgZqIiIiIqIWMFATEREREbWAgZqIiIiIqAUM1ERERERELWCgJiIiIiJqAQM1ERERUYtisRgSiUS3D4O6xNntAyAiIiLqdfl8HrLMOqVdMVATERERtUhRFBSLxW4fBnUJAzURERFRixRFgaqq3T4M6hIGaiIiIqIWFQoFKIrS7cOgLmGzDxEREVGLisUiK9Q2xkBNRERE1KJiscgeahtjoCYiIiJqESvU9sZATURERNQiBmp7Y6AmIiIiahEDtb0xUBMRERG1iIHa3hioiYiIiFpULBahaVpPDUzM5/NIp9PdPowTgYGaiIiIqEV6oO6luah3dnYQj8e7fRgnAgM1ERERUYv0ynQvBepwONxTxysyBmoiIiKiFukV6kKh0O1DMUVVVWSz2Z45XtExUBMRERG1QO+dlmUZ+Xy+24djSiwWA0rBmlrHQE1ERETUAr3dw+FwIJfLdftwTNnf34fL5WKgbhMGaiIiIqIWqKoKTdMgy3LPBOpUKgVJkqBpWrcP5URgoCYiIiJqgV6hliSpJyq+BwcH5daUXjjeXsBATURERNQCvUKNHpnlY3d3F06nE6i4GKDWMFATERERtaCyytsLFd94PA6HwwEwULeN08xOC4tLMwD+DMC/AeADcBbAp1dXlp8qbR8E8BcAPgDAC+A8gD9aXVn+kZntZvchIiIiEk2hUIAsX6tRih5QVVVFJpNBX18f0APH2ysaVqgXFpccAL4DYArArwAYA/BjAKsLi0vjpd2+AuA9AO4BEATwCIDvLiwu3Whyu9l9iIiIiISiKAokSQJ6oEIdiUQO/TcDdXuYqVDfBOAOAG9dXVnexrWQ/acAfgfAhxcWl/4OwIcAvH91ZXmt9DtfWlhcegDAxxYWlx4y2g7gwYXFpZFG+3Tm4RMRERG1prJCLXqgDoVCcLlc5f8W/Xh7hZkeaql639WVZQ3AHoBfBfCmUjB/sur3fgHgLSa2w+Q+RERERMLplQq1pmnl6fJ0+gqP1BozFeqXAawBeGhhcel3ACQAfBTA6wCkAehtH+Gq3wsBmDSxHSb3qSmyv4Oi2p3bFYpSQGhnuyv/NjWH56z38Jz1Hp6z3sNz1prI3h7SyQQkSUKhUMDu1iYcjs7O+9DMOcscHCAWCaHP1Vf+WV4pYHfrSnnWDzIWnJyu+fOGz97qyrK6sLj0PwH4awDPlUL0wwD+FYDL4FclAEaXPI22m9pnZMwwb3dUaGe77hNLYuI56z08Z72H56z38Jy1JpJIQSvNmpHL5eAPjqG/v7+j/2Yz5+zSpUvwjwTL7SkoHW9gbKLjx3vSmbocWV1ZvgDg31b+bGFx6SyApwHslH40BmCzYpfx0rZG22FyHyIiIiLhVA/sE7XtIx6PHwrTKLWBcGBi60zdj1hYXHr/wuLSrRX/PVcaqPijUqjOA/i1ql97K4DHTWyHyX2IiIiIhFMZSDVNQ6FQ6Orx1KIoCg4ODmpuE/UCoJeYbZj5CADPwuLSEoAigL8t9VV/a3VluVCa6eOLC4tLawDWS7NyzAP4yurKctxoO65VwBvuQ0RERCSiykAtyzJyuVxXj6eWcLh6mNo1et83tcZsx/zvlwYMvgbgEoAMgPtWV5b1M/CZ0lzVPwawD+A3StvXTW43uw8RERGRUCoDtcPhQD6fb+lvRaPRNh3ZL4XD4fJiLpVkWWagbgPpBEyV0rUHwEEcvYfnrPfwnPUenrPew3PWmmeffbbcNqFpGgKBAG644Yam/lYul8Mrr7yC22+/3XA/K+dM0zQ89dRTR/qnUWoFmZmZwalTp5o6XhuSav2ws3O6EBEREZ1wlRVqSZKgKErTf6tQKCAWi7XpyK5Jp9N1q9CsULcHAzURERFRC9o5y0c2m0WxWGxryN3d3T20OmKlVi8A6BoGaiIiIqIWtDtQy7KMRCLRhiO7JplM1mz3QClQc5aP1jFQExEREbWgejxaq4F6YGCgbQMTC4VC3enydAzUrWOgJiIiImpSsVg8UqFuZaGUQqEAWZYbhmCzQqEQJKnmOLqydkxQcQImuWgJAzURERFRk2qF51YqvvrvHhwctCWkhsPhuv3TunaslLi5uWlir5OLgZqIiIioSaqqHgm+rQzy039XUZSWF4jRNA2ZTKbhfq22fBSLRWSz2Zb+Rq9joCYiIiJqUr3qbrMhVQ/Usiy33EedSqVMhftWK+Gqqtp+6j0GaiIiIqIm1apQa5rWdJVaD+IulwvxeLylY9vZ2WnY7oE2VKgZqBmoiYiIiJpWK4w2G6hVVT1U8W51YGIqlao7XV6lVnuoVVVtabn1k4CBmoiIiKhJ+qwc1ZoJ1IqiHKp253K5psNuoVAw3dfcaoU6n8/bfuo9BmoiIiKiJhUKhSPT0jkcjqYG6RUKhUOBulgsIp1ON3VcZqbLq9TqVH9W/q2TiIGaiIiIqEmKohypUMuy3FQLhL5Kos7pdCISiTR1XJFIxFT/tK6VCnM+n2eg7vYBEBEREfUqRVGOhMlWArXD4Sj/t8PhQCqVsvx3zE6XV7l/K4GaFWoGaiIiIqKmqap6pEItSVJTPdTVFWo0OTAxnU5bmnVD07SWWj5amXf7pGCgJiJhqaqKXM7eI8eJSGz1KrvNVHxrVXrz+bzlKen29/cttXugxZaPWsuv2w0DNREJK5vNIhwJd/swiIjqqrcoSjMBtd7vJBIJS38nkUiYmi5P12yLiq7WXNx2w0BNRMIqFApIppob4U5EdBzaWaGu1TrR19dnacVEVVUt9U+j1KLSysIseqC2c6hmoCYiYeVyORRsvlgAEYmtnRXqWoFakiRLfdTNLFcuy3JLfdB6u4ed2z4YqIlIWPl8HqqNP6CJSHz1gnMz4bLe3zo4ODBd/Q2FQpb7p9tRoQYDNRGRmPL5PAe7EJHQjCrUVlogqpcdr6QoiumFYlKplOUp7GRZbkvLh50/qxmoiUhY125Basjlct0+FCKimupVla3O7Vy9SmIlWZYRi8Ua/o1sNtv04MJWwjBbPhioiUhgqqpCgtT00rtEdHwKhUJTy233unoh2GqgVhSl7t9yuVyIx+MN/8be3h6cTqfpf7NSs2FYr0yzQk1EJChVVeFwOpFMJrt9KETUwMHBganQd9IYVaitDPQ7ODgwnOrOzMDEeDx+aKVFK5oNw5WPn4GaiEhAf/mXf4l8LmfLqhdRr8lmsy314faqelVlSZIstV9ULzteLZfLGQbWYrHY0t28VgK1pmlNrw55UjBQE5GwHnnkEVy+fLmlBQeI6HjkcjnbBWq91aEWq4ul5HI5wwp1o8CcSCTa0gdtlV6hliSppdUWex0DNREJ6eDgALlcDlc2txioiXqAHQO1UYCUZdnSgOpay45XcjqdCIfrrxy7t7eHvr4+0/9etWYDtd77zQo1EZGA9MUJNrc2oSiKrSsfRL3AaFDdSdXOCnWjMOpwOAwr1M1Ml1ep2c/YQqEAWZYhSRJ7qImIRLO3twcA2NzchKZx6jwi0amqarsLX6PHa7UFwsy+9QYm5vP5lseaNBuG8/l8OVCzQk1EJJhQKISBgQFc2dyCJHHqPCLRGS1MclI1WnjK6rR5jeTz+ZptNaFQqOnZPXRG1fZGxyRJEmRZtt0FVSUGaiISUigUwq233orNzU04HA5OnUckODu2ZuntDvW0O1CjNPiwWiQSaXr+6UrNXBBVtnzY7fxXYqAmIiHt7+9jenoaLpcL0WiUU+cRCc6OFWpFUQz7ls0GTLPLlPf19SESiRz6maZpyGQypv4dI1YXotGpqlp+Dux2/isxUBORkPb39+Hz+TA7M4ONjQ3bzR5A1GvsGKjbVaE2Wna8kiRJR/qoU6lU2z4fmzl/XNjlGgZqIhJSKBSCz+fDTClQc+o8InHpM3zY7ZZ/uyrUVmZIOTg4OLRvq9Pl6YrFYlPnr/JYGKiJiAQTiUTg8/kwPT2FjY0NW/ZnEvUKPRDaLVA1qlCbHejXaNnxSoqiHGqBSyaTpn/XSLOzdFR+Lttt2sRKDNREJKRoNAq3241T09PY2NhAsVhkHzWRoPRAbbcqdbFYNKxQm30+Gi07XsnhcJTn6VcUpe5UelbJstxU60jlRZTdLqgqMVATkZCi0Sg8Hg9mZ2exsbEBWZaRSqW6fVhEVIO+bLbdqtSNHqumaaaqvo2WHa/kcrkQj8cBwHDlRKuaDdSsUF/DQE1EQorFYvB6vZidncXW1hYDNZHAKgOh3SrURsxWqBstO15Nv1sXDofb0j+NUstHqxVqOwdqU5MWLiwu3QLgvwB4KwAXgJcA/KfVleXvlrYPAvgLAB8A4AVwHsAfra4s/8jMdrP7EJF9xONx+P1++H0++P1+7O7uwuPxdPuwiKgGPVDbbaxDo0AtSRLy+TyGh4cN97Pau5zNZqGqRaTT6bb0T6PFCrV+DHa6O1Gt4VlYWFySAHwPQBLADQCCAP4vAI+WgjYAfAXAewDcU9r+CIDvLiwu3Whyu9l9iMgm9EA9NDSIubk5zvRBJDC7Lj/dKEDKsoxcLtfw71i9CNE0DdFYtK3TiTazMEv1oEs7B2ozFepxAHMA/u/VleU4roXsvwPwXwHcsbC4tAfgQwDev7qyvFb6nS8tLC49AOBjC4tLDxltB/DgwuLSSKN9OvPwiUhE+rRQQ0NDcA+7cerUKayvr+Puu+/u9qERUQ16ENMrsnZhJlCbeT4aTb9XzeVyYePKJvwjo6Z/xwyrgbh6QRo7t3w0rFCvrizvAngMwEcWFpeCC4tL/QD+AEAYwL8CeFMpmD9Z9au/APAWE9thch8isolIJAKv1wuHw4GBgX7Mzc3hypUrUBTFVtUvol6hB+pm2wZ6VTsDtRV6e43ZmUHMshqoq4/bzoHa7MLvvwXg/wWwD0ADECpVk3cXFpfuLe1TPdQ0BGCyVOE22g6T+9QU2d9BUe3OLQZFKSC0s92Vf5uaw3PWG155cQ1utxuZVBLS+CgmxoN44on/jmQ8hu0r6xgaHOz2IZIBvs96T6vnLBYOoVgsolgsYn/nKvpsMuVBIhppuI9WyCPkHqq7XVVVpOIxuFwuS//2wEA/UvGYpd9pJHeQtvQ6yGQySCXjKGSvDYxUVPXEv/eDk9M1f94wUC8sLvWVeqhfAvA/AEgB+DCA/7awuPRrBr8qlcJ3s9tN7TMyZpi3Oyq0s133iSUx8Zz1BvXc2rUBiSOjcLn68LrXvwFf+dv/A15/AP1DbgQnJrp9iGSA77Pe0+o5G9zchiRJ0DQNw16fbc7/0JWthoMCBwcHDZ+PbDaLIY8X/f39lv7tVDwGt89v6XcacTqdls5dNBqF27NXPvZCoWCbc1/NzDXkewDcCeAzqyvLe6sry5nVleW/BXAJwEcA7JT2G6v6vfHStkbbYXIfIrKJ/f19eL1eOJ3XrvlPnz6N/f19FItFJJPJbh8eEVWp7KHmLB+HNXo+rCw73mlWWz6qV4q02zzklazclKnulneWqsdPA8gDqK5WvxXA4ya2w+Q+RGQToVAIHo+n3B84NDSEyclJbG1t2WrAE1Ev0Fs9Kv/bDsyGx0b90VaWHe80q+dOn92llb9xUpjpof7vpSrxny0sLn0aQLo0I8fNAP5gdWU5Xpr144sLi0trANZLs3LMA/hKo+24NvCx4T5EZB+hUAg+n68cqN1ud3nFxDNnznT78IioQnWF1S6ByuzjbLSflWXHO62ZCnXl7CSsUBtYXVmOAfh1AKMAXikNTPw4gA+sriz/tLTbZwB8B8CPS9t/A8B9qyvL6ya3m92HiGxAb/nQ+/K8Xi9mZmawvr5uqxkEiHpBdaC2S8tH9ZRxRvsZsbLseKdZPXfVLR+w0QVVNVOzfKyuLD8P4H802J4D8OnS/yxvN7sPEdlDOBzGdddddy1QqwX09/djfn4er7zyClRVhaIo5f5qIuqufD5/qEppl0Bl9nHqwbvePNNWlx3vJE3TDI+1Wq3nwC7nv5oYl0RERBWi0Sg8Hk+5Qu10OnH69GlsbGxA0zRks9luHyIRlWSz2UNVSlaoa+9bj2hz61s5f9X7suWDiEgg0Wj00CwfAHDDDTdgfX0dsixzpg8igVS3LNglUJl9nJqmGYZmkS5ANE2zdDy1ngORHs9xYqAmIuHE43H4fL5DgfrUqVNIp9PIZrNIp9NdPT4i+qV8Pn9oUJ1dAnWtGS5qaRSoRapQW60wV+9rt2kTKzFQE5FwYrHYkUA9NDSE2dlZbG5uIpfLdfX4iOiXqgNhsVgUZl7lTlIUxVSvsSRJhoOpRQrUaLHlQ5Ik4R7PcWGgJiKhaJpWrlBXVn+8Xi9mZ2exvr7OuaipzA7BTXTVVUqrbQO9yuxgQlmW6477sNKHfRwahf9q1edelmVbnPtaGKiJSCgHBweQJAlut/vQz4eHh8tzUTNQk+7KlSvdPgTbq1WRtEOoUhTFVMuHLMt1P7MKhUJPB+paFWo7nPtaGKiJSCjhcBher/fIQgf9/f2Ym5vDlStXoKoq56MmLkUviFoByg6hymzLhyzLdT+vRAvUsiybbtmo1W/Nlg8iIkHUC9SSJOG6667D+vo6p84joBTaMplMtw/D9qoDVKNBeCdFsVg03UNd7/monnKw24yq6dVqXTSxQk1EJIhQKASv11vzS+bMmTPY2NiAw+FAKpXqyvGROFRV5YVVl9XqlzaqyJ4kVmbDqBcyRVp2HBYrzLX6vyVJss0sL9UYqIlIKHt7e/B4PDW/ZCYmJuBwOJBIJBioqbxqJnVPvVBlh3EOrUwvpxOtQm2lwlxvQCUDNRGRAEKh0JEp83T61HlXrlyxxRc2GdPDNEN199SqRNulQm2l97nea9RsH/ZxMhuI6z0mkXrCjxMDNREJJRwOw+PxwOVyHdnm9XoxMzPDqfMIKC2sYXVWAmqvWoPq7BKoW5mvWSfixaDZQF1vYRtWqImIBLC/vw+v14v+/v4j2wYHBzE3N8ep8wgotQdpmsbXQhfVClV2GZhmpRJbL2SexEDNCjURkQD0WT76+vqObHO5XJifn8fGxgaKxaItqmBU36c+9Sk8+eSTODg46Pah2Fa9QXV2qFJarVDXCpoiXniYPXeFQoEV6goM1EQklGg0Cp/PV7NCDQDXX399OVAzSNlbOBzG/v4+XwddlMvlaoYqEYNiu1mpxNabSlDE58lKoK7V/81ATUQkgEgkUndQIgDccMMN2NzchCzLnOnD5pLJJMLhMO9UdFG9QXV2CFVWw3D1/qqqChmorczyUevcs+WDiEgA8XgcXq+3bqAeGRmBz+dDKBRioLa5RCKBUCgkZB+qXdR77u0QqFutUIt6IWj23NUL3nY497UwUBORUGKxGHw+X93FDjweD2ZmZjgwkZBKpRiou6xeqBKx8tpOxWLRUnCUJAm5XO7Qz0Rbdlxn9tzVe/wiPqbjwEBNRMLQNA3xeBx+v7/u3Kxutxuzs7PY2NgQtsJDnZfP53FwcMBA3WV2rVJafXy1lvQWbVGXSmYeHwP1YWKeSSKypUwmA1mWMTw8XHef/v7+8tR5uVzOth/edhePxyHLMvb39xmou8jOFWornz0Oh+NIhfrg4ECoZccrmTl/dr2YqoeBmoiEoU+ZZ/Ql43A4cPr0aU6dZ3PxeByTk5NIJpPIZrO2/RLvNqPV8k7yxa7VC4Zai93UmyGl2zRNM/V+YqA+TLwzSUS2FQ6HDfundWfOnMHGxgZQum1K9hOLxeDxeDAyMoJQKMQLqy6oN7cyLISyXmW1Qo0aAVTEZcd1Zi4YjFo+TvLFVD0M1EQkjFAo1LBCDQCnT5/G3t4eisUiEonEsR0fiSMej8PtdjNQd5GiKIaB+iS3fTTTZlQrUIvI7LkzumA6yRdT9TBQE5Ew9GXHGwVqv9+P8fFx7OzsIJPJHNvxkTgikQiGh4cxMjKCSCTCxV26wChQ44T3USuKYrldo1cCda0BlNWM7k6AgZqIqLtCoRA8Hk/DQO3xeMozfXDqPHuKxWJwu90IBoMM1F2Sz+frtiyc9Ap1vVUCjdRa2EVEkiQ1vONj53afemqvnEBE1AXhcBgej6fusuO6oaEhBmqbi0QiGBoagtfrRSQSOTKDAnVeNpute/FrJpT1snZVqF0uV5uPrHWyLDesnje6GLBjoGaFmoiEsb+/D5/Ph76+PsP9+vr6ylPnibo4AnVWLBbD8PAwJiYmOHVelxjNo1xrVouTpNUKdaOWiW5ihbo5DNREJAy9Qj0wMGC4nyRJuP7667GxsQFVVVmltiG9h3p2dpaBuksKhYJhoD7J70tVVS1XqCtnBhG5EGDmYsjogoKzfBARdVkkEoHP54PT2bgbTZ86T9M0Tp1nQ/F4HB6PB3Nzc1wtsUuMnvOT3vLRbP+z/pzl83mhq7iNAnE+nze8mLLj+5GBmoiEEY1G4ff7TQXqubk5JBIJFAoFJJPJYzk+Ekc0GoXX68X111/PQN0lRqHypIeqZiqwmqaVn5NcLifsKokw0QNtdHdCkiRhB1x2EgM1EQkjFovB6/WaCtRerxczMzPY2tpCOp0+luMjcegV6tnZWSQSCWSzWVveZu4mOw9MayYwVs58IvKy4zDx+BoF6pN8MVUPAzURCSMWi5laKRFVU+fZsRpid4lEAl6vF0NDQwgEAgiHwye6xUBEjd53J/l92czFmyzL5dloRF12XGemQl2vh5oVaiKiLtI0DfF4HIFAwNT+AwMD5Zk+7PjhbXeJRAI+nw+yLGN0dJSrJXYBK9TWVAZqkZcdh4lzZ7SdFWoioi5Kp9NwOp0YGhoytb/T6cT8/Dw2NjZO9Bc31ZZMJuH1egEA4+PjCIfDHJx6jIrFIivUFlXOfCL6c9PoM9Xo+FmhJiLqonA4bLrdQ6dPncdAbS+apiGdTh8K1Fwt8XiZmUf5JL8vm61Q64Fa9Lsprdx9kGWZgZqIqFsikYjpAYm6M2fOYH193Za3F+0slUqhv7+/vACQXqHmaonHx8w8yic5UDc7AFYPmqIHzlYq1GZ+/yRioCYiIezv78Pj8VjqK5yengZKU6iRfcRiMbjd7vLdjKmpKfZQHzMzz/VJDlXNBmL9ORE9UDdanKXRubXjjDsM1EQkhFAoZHpRF53P58Ps7CwuX75syw9wu4rH44cC9fT0NOeiPmZm5lE+yYG6lQq1qqrCPzeNlg9nhfqoht9cC4tL7wTw/RqbXAD+z9WV5d9fWFwaBPAXAD4AwAvgPIA/Wl1Z/lHpbxhuN7sPEZ1coVAIHo8HLpfL9O8MDQ1henoaW1tbKBaLQs/rSu2jV6j1acfm5+e5/Pgxy2azDad9KxaLKBaLQk8P14zKJcStUlVV6GXHdfqc2fU+UxudVzsG6oav8tWV5Z+sriwPVP4PwPUAogC+XtrtKwDeA+AeAEEAjwD47sLi0o0mt5vdh4hOKD1Q9/f3m/6d/v5+eL1eJJNJ4W+hUvvE43EMDw+Xv+zn5+cRDof5GjhGRktPVzqJ56SVx6SqKvL5vPCBGgahuFH1GjZt+TB/b/WwrwL41urK8mMLi0sjAD4E4P2rK8trpe1fWlhcegDAxxYWlx4y2g7gwUZ/A8CDbXisRCQwPVDrA83MkGUZPp+PgdpmIpEIhoeHy6+VU6dOIRaLcdq8Y2RmHmW9ymnlrlMvaLVCbaa6322VqzpWs/sML/VYPqMLi0tLAN4M4HOlH72pFMyfrNr1FwDeYmK7mb9BRCdcOByG1+u1VKEGAL/fj1Qqxdv9NhKNRjE8PFwOaoODg/D5fAiHw3wdHBMzF7BGoayXtfKYisWi8MuO6+q9l8w8fjsGaksV6oXFJSeAPwPwn1ZXlmOlH4+X/m+4avcQgEkT2838jboi+zsoqt05cYpSQGhnuyv/NjWH50xcO1ev4tabb0I8vI9cOln+eaNzNtDnQjwWw+7WJnJ+3zEdLRnp9Ptsa3MDLqcT6UQMIVz7/B8JBHBl/RJ2NjcwMDDQsX/7pLJ6zqLhfaiKcbDK5fPYu7oFj9vdhiMURzqTQToRR8HC3TRdvlDAjqbi4CDb8kqJalFFKh4zsad1hUIBe1e3UDhIH9l2cJBFqsHjl2X5xH7XBiena/7casvH/1zqb/57E/tKAIzuCTTabmqfkTHDvN1RoZ3tuk8siYnnTFypdBrjk1OYODV76BZxo3M2O38aT/z8F3D7AwhOdu/zgH6p0++zXF6BPxDAxPQM3KWwNjk1hVQmC09gFD4fL6yssnrOhrZ3Gt7278vn4fGPIBgMtuEIxeGIRjHs3bN8Nw2l2VH6Bgfh7B9s+ThS8RjcPn/Lf6cWRVHg9gUQnJw6si0ej2PY42144Wq371qrLR+/C+CbqyvLmYqf7ZT+71jVvuOlbY22m/kbRHTCxeNxyyslAsDk5CRSqRTnILaR6nmoUVrcJRqNIpPJGP4utYeZ2/6VKwOeJGb6x+spFos98VklSVLd4ywUCsL3gHeD6WdkYXFpGMC/AfD/VW16GmfnjX4AACAASURBVEAewK9V/fytAB43sd3M3yCiEy4ajSIQCFj+oB4bG0M6nT6RX9xUWzQahcfjORSoJyYmEA6HOTDxGJjtjZZluSfCo1WtBEqHw9ETz4nRuTMzwwt7qI29HsAAgOcqf7i6shxfWFz6OwBfXFhcWgOwXpqVYx7AVxptN/M32v6oiUgomqYhkUjA77d++3JsbAypVOpEDn6i2mrdzZiYmMBzzz3HC6tjYGaWBzSocvayVirUvXKRIUlS3c9UBurarFxinSr93/0a2z4D4DsAflza/hsA7ltdWV43ud3sPkR0AqVSKbhcLgwOWu8r9Pl8SKfTDNQ2Eo/Hj1SoZ2dnsbe3x1k+joGiKKYD9Ul8X7ZSoZZluWeek3qh2OyUiXZjukK9urL8L6VBgrW25QB8uvQ/y9vN7kNEJ1M4HG6qfxqlafM4D7W91LqbMTc3x+XHj4nZQI0TWqksFostVajdPTLrSb1zp6qqqUB9ElfJNGKfR0rHLhqNdvsQqEdEIhF4vd6mAvXAwAAkScLBwUFHjo3Ek0wm4fV6D/1sfn6egfqY5HI500HppAbqVvRKyDQK1K38/knVG2eVelI4XD2tOFFt+iqJTmdzi7e63W4kEom2HxeJKZlMHpkaT18tMZfLde247IKB+uQ9plrqBWczj9/M8uQnDQM1dUwmk7FlHxVZt7+/33TLBwB4vV7EYp1Z4IDEks/noSgKhoaGDv18cHAQXq8XkUiE7T8dZmWlv5MYqk7iY6qFFWprGKipY7LZrO3eUNQcvUJduaCLFV6vF/F4vO3HReLRByRW382QJAnBYBD7+/s9MYtCL7Myy8VJvLixy/davcfJCnVtDNTUMXoliaiRcDiM4eFh9DWxlC8AeDwetnzYRCwWw/DwcM1ANzY2hlAoxKnzOsxKSD6JoeokPqZaWgnUsOFMHwzU1DGqqp7I6gS1n97y0Wgp23r8fj8SiYTtPsDtqF6FGlzc5dhY+Vw/id8BdgnU9c6d2XN6Es+9EQZq6phiscgKNZmiz/LRbIXa5/MhkUjY7gPcjvQKda0e3vHxcUQiEQbqDrPyuV4sFoW/0LUakO0SqDVNq3nuzDz+kzoHuREGauqIxx9/HI8++ih7GcmUUCgEv9/f9KDEkZERzkVtE9FoFMPDwzX77aemplihPgZWA6Xo78uNjQ1L31V2CdSoce6srJJpt4IaAzV1xNNPP41nnnmGvYxkSiwWg9/vb3raPAZq+4jFYhgaGqp5N2NmZgb7+/u2+yI/blaeX03ThH9fplIppFIp0/vbJVDXGlhoNlDLsmy79yEDNXVELBZDOp1moCZTYrFYS9Pm6cuP2+0D3I4ikUjdCrW+WqLoAa6XFYtFy8+v6OejWCyannbTbrNX1KpQm8GWD6I2iUajSKVSbPkgU/QKdbPL+Y6MjCCdTvP1ZgN6D3V/f/+RbVwtsfOsPre9UKHWNA2ZTMbUvnYK07XOHVs+6mvu/ipRA3qgFv2DlLpP0zQkEgkEAoGm/0YgEOAdEZswGpQ4MzODaDTK10EHFQoFS4MMZVkW/nyoqmo6/JkNlCeBJElHihSFQsFU4YMVaqI20QO1na7mqTnJZBJ9fX1NT5kHVqhtJRaLwePx1AzUQ0NDcLvdCIVCtgk9xy2fz1u6k1QrlIlGVVXk83lTAdBO32m1qsz5fN7UsvMM1ERtogdqu93yIevC4XBL/dMozUPNCrU9RKPRuoEaAFdL7LBcLmcqUOlkWRb6XOhtDcVi0VTbh50q1LXOndlADS7sQtQe+iIbXA6aGtHnoG4lUOuDEu1WEbGjeDxu+HoZHx9HKBQSOsT1smw2a+m9Knqg1gOyy+VCNBptuL+dKtQM1NYwUFNH6MtAM1BTI6FQqOVA7ff7OW1eixRFwc7OTrcPo6F4PA6fz1d3+9jYGBd36aBCoWCpQi36rX9FUaBpGhwOh6mp88z2EJ8Etdp1VFU1/fjtdPEBBmrqFH2QGQM1NRIKheouJW2W2+1GNpsVuhImunw+j2Qy2e3DaCiRSBgG6snJSUQiERwcHBzrcdlFM+FY5GClB2qU2lkasXpB0cskSao5D7VZrFATtUiftWFycpKBmhrSA3WtadDMkmUZw8PD5TsjZN3BwUFPVHWTyST8fn/d7VNTUwiFQj3xWHpRM+NiRK5QV/aE53K5hiFQURTbVKhR42LIysWRyBdSncBATW2XzWYhSRJGRkYYqKkhPVDXWvnOCq/Xa3pxBjoqnU4L/wVYLBaRSqXg8Xjq7nPq1CkOSuygZgK1yK+rykCtqmrDOxuKotimQo0aF0MM1PXZ51VBxyYej8Pj8cDj8SCRSAhdnaDua0eFGqVAzQp183qhoptKpTAwMGD4Wpmfn+fy4x3UzOe5yN8BlYHa6XQ2vCi3e4WaLR/1MVBT2+nzxPp8PgZqaigcDsPr9dZcStoKj8fDOyItKBQKwleU9M8Wowrh3NwcIpEIA3WHnLQe6sqeaKfT2fCi3MqgvJOglZYPBmqiFukrmfn9fgZqaigcDiMQCLQ0KBGlmT7Y8tG8J554QviBfPF4HG632zBQz87OIhKJcE7yDmh2GXGRA3X142k0MFHkx9IJ7KE2j4Ga2i4Wi8HtdiMQCHD5cWooGo3C5/O1JVAnk0nbfYi3yxe+8AWcO3eu24dhSP9sMZpicWhoCIODg4hEIrarkLXi1dcuIBwOG+7TbNVf5O+A6mPLZrOGrxu7fb5UPz9s+aiPgZraLhqNYnh4GKOjoz25ep3dPjC7LRaLwe/3tzzQh3dEmqeqKnZ3dxGPx4V+/cfjcQwNDTUcwDo2NsY+aotyuRxeeeUVrK2t1X3eKqeYs6KZ19Rx3S2pFRiNqtR2C4mV565YLLJCbYCBmtpOb/kYGxvruUCtaRpee+21bh+GrcRiMQQCgZb/zsjICO+INGlrawuFQgGxWEzo50+/WG/Ub68Has70YZ5aLKKvrw/pdBpPP/10zUV+CoVCU4HSaquIoihYX1+3/O80o/riQZIkw/nYRX5/dELl+ba67LrdLj4YqKntotEohoaGEAwGkU6ne+pLLZ/PY29vr9uHYRvFYrG8CFCr/H4/lx9v0sWLF4HSoikiV3X1z5ZGFerx8XFEIhFTC3VQqfKoXasmyrIMp9OJy5cv4/nnnz9UEKmcEcMKq4E6m80e2wDj6uNyuVyGYzHsVnWtrEpb/WwtFou2CtUM1NR2lS0fqVSqpyrUBwcHKBQKQoeKkySRSGBwcLDlKfMAlHv2ee6su3DhAlBqqRD5+dM/WxoF6snJSYTD4Z6YClAEqqoCVbnH5XIhl8vhmWeewebmJjRNQy6XM+xfb/hvmJRMJo/lwrhW0JckyfB1Y7dAXfkcWa1Qw2bPFwM1tV00GoXb7e7JW/CJRAIulwupVKrbh2ILkUgEXq+36S/pSiMjIz3XYiSKixcvor+/H8lkUujnz8ygRDBQW3YtUB8NSrIsw+Vy4cqVK3juueeQSCSOpUKdTqeBYwhj9QKi0evGThVXnX4eTtqiPu3GQE1tF4lE4PF4MDo62nOzLmQyGfT39yMSiXT7UGyhnYE6EAggk8n0VIuRKDY3N3HmzBkkk0mh2yT08RmNZoSZnZ1FKBQS+uJAJE888QSeOfts3e19fX1QFAXhcLipOZglSbIUxvTz1unXYr1jKhQKdV87vVQgahf9MefzeUsXVJqm9dT3f6sYqKnt4vE4vF4v/H4/Dg4OhP6CrqZP8p/JZLp9KLYQCoXaFqj9fn/PtRiJYmtrCzfffDNisZjQ79doNAqPx9Pw9TI3N8dZPix4+OGH8R/+9E/x+c9/vm4xQZIkDA0NNfX3JUmydKGrvwY7/TlsNGtJvbuUdgqIqLq7ULkIjll2er4YqKnt4vE4fD4fHA4H3G53Ty0H/bWvfQ3nzp3jreJjEg6H4fF4Wl4lERWDEhmirNve3saZM2eE76GOxWLwer0Nv9Tn5uYQDoeFfiwiiUQi+MynPolgMIj7778f3/72ty23Nrz00kv48pe/XPM5l2XZUqAuFApwOp3l1o9OqTfI0uVyIRqNHvm5pmm2a/movBhqpkJtp+ertZUUiGqIxWLw+XwAAK/X2zOr1xWLRXz/+99HJpPBjTfeCEVRWl5shIyFQiG43e62DEr0+Xw917Mvip2dHdxwww3HNhisWfrFeqO2g9nZWYTDYbb/mBSNRjE2Po7f/ncfxK//+q/joYcewsrKCj73uc9hfn6+7u9pmoZnnnkGX//613HhwgUkEgl84AMfwPj4+KH9ZFk2fedIHxTe39/f8bmo6wVqWZZr/tsivzc6pfJiSFEUSy0/bPkgalEikYDf7wdKgbpXKtTZbBbr6+tYW1sDSiPNqbNCoRA8Hk9bAzWrktak02mkUilcd911iMfjQoeGRCJRvlg3Mjw8XF4tkRqLRqPwejwAgFtuuQUPP/ww3vnOd+IjH/kIvva1rx25MCkWi3jsscfw0Y9+FA899BDuvfdePProo5ienq75eS/Lsun3ZeVKhZ1u3zKaBrDWXUq7TQOHqkCtqqqlQC3LstCfJ+3GQE1tl0wmy4Ha5/Md23yirbp48SJUVcX58+fhdDpr3vKj9mpnoHa5XOWFKci8S5cuYWxsDG63G6qqCj1+oPJivZFgMIi9vT1bfaE3Kx6Pw+f1lv/b6XTigx/8IP7pn/4J586dwwMPPIDnnnsOiqJgZWUF999/P7761a/igx/8IL71rW/hfe97H/r6+uD3++t+3ps9D6lUqtwj3+k7DEY9wbWmTzV6DIqi4OMf//iJC9yVLR9W30tWB6P2Ot7PprbK5/NQFAXDw8NAKVD3SsvH888/j1tvvRXb29vY2dlpegAOmRcOh3HDDTe0ZVAiAHg8np65gBPFxYsXMTExAZfLBZ/PJ/SFZDKZhLci+BmpXC2xXa+vkyqRSMBdqlBXmpqawl/91V/hhz/8If74j/8YmqZhfn4en/nMZ/CWt7zlSLXS6/XWff+ZvfWfSqXKrXb6yozNzCxihlFALBaLyGQyh15vRhXqWCyGJ598sm0rv4qi8u4CA7UxBmpqq3g8fmgUvl6xKBaLTc1fepxefvllnD59Gn6/H2tra5iamur2IZ144XAYd911V9t61XupZ18UFy5cwOTkJFwuF/x+v7BtErlcDqqqli/WG5mYmEA4HEY+n8fAwEDHj69XKYqCg4MDDNcpIEiShPe85z24++67sbOzgxtvvLHu3zJq8TMbqPP5fDlAq6qKQqHQcCGfZhkFRH1gYmWgNgqH+oXE7u7uiQrUqDh3VvuhJUmy1R0isRMO9ZzqhRdGRkaQSCR64k114cIFzM3N4bbbbsPa2hoKhQIHNXVYJBJBIBBoW6Bmhdq6y5cvY2pqSvhAXX2x3sj4+DjC4XDHB7b1Ov0zu9EKsR6PxzBMo0GLn9nvgOq+6U7OuGR0TA6H40j7mKIodQtDlYH6pNGfp2YCNSvUNSwsLn0EwB8DmAewDeB/X11Z/qvStkEAfwHgAwC8AM4D+KPVleUfmdludh8SX3WgDgQCWF9fh6qqbZkarZMuX76MN77xjRgYGMDf//3fA6VbzCMjI90+tBNLvz3arlu6fr+fFWqLNjc3ccstt8DlciEQCCAWiwl5R8nsKom6U6dOYW1tjYG6AX1ub6/Xi6mpKWxtbcHpdDZ1/n0+X1sq1PoFtsPhQCqVMt3mY1WjsFc9J3uhUKj7WaUH6r29vTYeoRj0NhergxJZoa5hYXHptwH8KYDfBeAD8L8A+NjC4tKvlnb5CoD3ALgHQBDAIwC+u7C4dKPJ7Wb3IcFVr2TWK8uPK4qCy5cvY35+HjMzM3j55Zchy7LQ/aQnQSwWMz3IzAyjQVFU2/b2NiYmJjA4OIjR0VHEYjEh36/xeNxSoJ6ZmcH+/j4X+mlAX9nW4XBgbm4Od911FwYGBpp63ox6qM28pgqFwqHgXatK3E6NjimXyx06Hlao2fJhxGyF+j8C+F9XV5Z/Xvrv75b+h4XFpREAHwLw/tWV5bXS9i8tLC49UArdDxltB/Bgo78B4MH2PmzqlHg8juHh4XLPWyAQKK9eZ7b3sRsSiQT29/cxOTkJTdPg9/uxubkp9DH3umKxeGhGmHbw+/3l5e5Fq7CK6urVqwgGgxgeHkYwGEQsFoOiKMLdUdIv1s0eFxd3MUfvE3Y6r12o9PX14fbbb0coFMLFixeBUrA1o9VBiQcHB4f2kySpYxdE+gqARo9NVdVr/eWl7wGjCnUsFsPIyMiJDNT6YMxisWhpgK8kSbaah7phoF5YXJoCcCsAx8Li0lMAbgZwEcBDqyvL3wTwptLfebLqV38B4C0mtsPkPtQDIpHIoUA9OjqKdDotfC/yuXPnMDExAUmSMDIygltvvRXnz583XNSAWhOPxzE4ONjWAWN6y4KiKB0byHSSaJqGnZ0djI+PY2BgAMFgEGtra0KG0OqL9UZmZmYQCoWEfCwi0T+zqy9UgsEgAoEALl26hP39fbhcroa3+1tt+aic4UPXqUBt5nXhdDrLF3Jo0PIQj8dx0003ndhA3ewc3CdtGkEjZko4c6X/+zEA/w7AJIC/B/DPC4tL7wKgL4kUrvq9UGnfRtthch/qAdFoFENDQ4cq1Ol0WvjbrufOncP8/DxkWcbU1BRuueWWcrAQ/WKgV0UikfIS9e2iLz9up9uMrdjd3UV/f385qI6NjSGZTAr5fo1Go5YCtV6h5vvXmL5aaa3Kv8PhwJkzZ3DHHXfA4XA0fF00CtSNQnXlHNS6Tl0QKYrSMOw5nc5DC3yZCdS91EOdz+fxsY99rGFbjaqqUFW1qXDMCnXtfb6wurL8aun//6+ldozfB/D9Or8nATB69httN7VPZH8HRbU7J0xRCgjtbHfl3xbV9uYV9Pe5EA+HkM+koCl5JBMJ7O9exYCz+7fg652zF55/DtNTU8imUygcpHHd6Xn88Ic/QCoew/qF1+D3N16djay5+OrLGB4aQjoeM3wfWXmf9TlkxGJR7F/d4jziJjzz5JMYGwsim04hur+LAZcDsWgUu1ub0Ao5E3+htk58Nm6uX0afy4lkNGz62FwuF7Y21jF/ilNg1rO5sY6Bvj7IsmR4zmYmx3Hh4iUkY9G6odIpXbvwScWPDgwuFArY2940nNEnvLd7JLQXCgXsbl1p+1ziqXQaqUQchQYXaJlUAkH/tUGRsUgI2YPas46EQ/t4w+tfh729PcPnqJ3UolrzuTbrv33nO3jqqadw+eIFzM/N1d1PVYvY295E2sTzVa2QPThxOSk4OV3z52YCdaj0f6tHZ10EMAVgp/TfYwA2K7aPl7Y12g6T+9Q0Mta9AnZoZ7vuE2tXuYKCwMgoxqdPob+/H9cVVGQODuD2+oV4ruqds63tq3jDG96AkbFxjE/P4O63/Br+t//webh9fsDpEuLYe4mqqpBl2fBLRcXzCIyMIDA2bvj8WnmfzZ6+DrnVH8ATGD1xc8F2QjiWwNTUNPyjQQQnp3HdmZuQOTjAoMfb0mu+E5+NebUInz+A8ekZ0xdLY2NjSGYOMDI+yZ76OrL5AgKjoxjoH2h4zrJKEVevXq0bbh19/Ugmk9c+N6vkcjkExiYMV0W9cnUXfYPFI7/nCYy2/wI5FILH5294x0NRFIxOTEGSJOyGo3D21Q7UqXQGc6evw+DgIBQNCLRxbEg9qXis5nNthqIo+MY3vwWPx4O8ohr+nUKhAN/oGIY8Vy236PX399vm+9PMJ8xrpVB9d9XPzwC4BOBpAHkAv1a1/a0AHjexHSb3oR4QjUYPjcT3+/09MQ+1PsNHZe/39PQ0Ll68yGm3mrC1tYWnn3760O3Savqt5nb2OgcCAWQyGd7mN+nixYvlRV1QCqCJRELIvmOr0+ahNBd1KBTi68FAKBSC1+s19bwODQ0ZfpYPDAygWCzWnDtaHwRYj6ZpR6apQ2lgWydm+shms6Yes6Io5cdj1PIQj8fh8/kwPj7eE33UP/jBDzA2Noa77rqr4WxWmqYhm802VXVny0eF1ZVldWFx6S8B/MeFxaWzAJ4H8O8BvBHAv19dWY4vLC79HYAvLiwurQFYL83KMQ/gK422l/6NhvtQb4jFYocWX3C73cjn8x2dnL9VhUIB6+vrmJ2dxeDgIFDqBdQHJt50003dPsSek8lkAAAvvPACxsfHcf311x+pEIZCIXg8HsOKlVV6D7WIPcAi2tjYwPT0dDlQj46OIh6PC3kBHIvFMD8/bzlQ68uPt/N1dpJEo1Hcdtttpp7XwcFBw4AkSRJ8Ph+SyWTNSqbRhVr1lHk6p9OJVCqFsbGxhsdnRS6XM3XXwuFwIJFIYHBw0PB9oQfqiYkJ7O7u4pZbbmnr8baTpmn4+te/jk984hN47LHHTAfqZu7ycFDiUX8G4MsA/p/SwMHfA/BvV1eWz5a2fwbAdwD8GMA+gN8AcN/qyvK6ye1m9yHBxWIx+Hy+8pWsJEnweDx1B6qIYHNzE8ViER6PBz7ftV5pv99fHphYKBQY0CzSp5fq7+9HOBzG008/fWTBlU5UqPVAzYqkOZubm5iY+OVteH1lUxEr1NV3v8yYnJxEJBIR+oK+26LRKHw+n6mw5HK5Gu5Xb+o8WZYN35f17gTKstyR86coiqmKq9PpLD+eehcTmqYhkUiUK9SiD0z82c9+BlmW8ba3vQ2BQMDUegsM1I2Zmod6dWVZA/BQ6X+1tucAfLr0P8vbze5D4ovH40d6V43mJhXBs88+i7nSgAy9T29gYAC33XYbvv3tb0OSJCSTSYyOjnb5SHtH5QWIPghpbW0NIyMjuPHGG+FwOBAOh+HxeNoaqH0+H1KpFAO1Sdvb2wgGg3C73UCp39Hlchm26nSLXgG0ctt5enoaL774Itu2DESjUdOrlTqdTlNT59X6vG80p3Qymax7sdSJ97PZuzCSJJUDfb1AnUqlMDAwAJfLVa5Qi0rTNDz88MP4vd/7PUiShEAggM3NzYa/Y7aiX81OLR8cpUFtlUgkjizUIXqgfvHFF3H69Gk4HI5yuJMkCW94wxuwsbEBVVW5YqIFmqbV/ALs7+9HIpHAU089hf39fYTDYQQCAcNR/1bpC7vYqSrSip2dHYyNjZVbnVB6DiORSFePq5ZaF+uNzM7OIhwO1+zNpWusPK+SJDV8v3q93pp3JBtVqDOZTN2/3Yk7hFbamhoFav1iD4DwgfqZZ55BNBrFvffeC5TGnZj5fsvn8031UNvps5iBugeEQiGhWyYq6be9Kvl8PqED6WuvvVYekFj5geHz+XD99dfjlVdeYYXLglwuh1dffbXmNofDAafTiddeew2bm5vw+XxtDdR6nyPPV2O5XA6xWAzBYPDQXQK/33+kPUcEtT5bGpmdnUUoFBKyJ1wU8Xjc0mqljVaqrFehbhSojS56CoVC24OZldeEoijI5/N1A7Xe6ohSoBa55ePhhx/Ghz/84UMTBzR6v8uy3PRFDSvUJJR0Oo39/f1uH0ZDiqLg4OAAHo/n0M/9fr/QFeqLFy8emuFDFwgEyn3U7ME079lnn8Xv/u7v4rOf/WzdSk1fXx+SySQCgUBb55fVe/ZFDISiuXz5MoLBIFwu16GQFAgEEA5Xr7HVfbXufjWir5ZopyqZFblcDoqiHPnMNtLoAtio5cMoxBqF7WKx2PYqtdWLLKM7X5UVapFn+XjxxRdx8eJFLC4uln9mpkItSVLTbTcM1CSUXC7XkWmD2i2RSNRcwlYP1CJ+qWmahsuXL2Nubu7ILABer5cDE5tw7tw5vPnNb8aNN96IBx54AN/85jdrfnk1cwvfjHq3nOmwS5cuYWJiouaFZDQaFeqLsFgsIp1Ow+v1Wvo9fbVEEQdZiiAajcLr9Vq6S9SoQm30/jMa1NcosLX7rpOV10RfXx/C4bCpQD0xMYH9/X0hv+8efvhhfOhDHzr0nh8ZGWnY4iXLctOfByI+D53CQN0D9Mqv6C9Mfcq86oEL+swBIt52zWQyuHr1Kqampo5Uafr6+nD77bfj/PnzkCSJIc2kV199FTfccAP+4A/+AF/96lfx/e9/Hx/96Efx2muvHdovkUh0JFB7PB6h74iI4uLFi5iYmDgSkEZHRxGLxYR6vyaTSQwODjYMc9U8Hg+cTiffu3VEIhF4vV5Lg836+/sNXxtGgbre7+XzecO/6XK5kEqlTB9jI2aWQa8kSVJ5KtBaKttmBgYGMDAw0NJdsu3t7bZf0F6+fBlnz57F0tLSoZ+bKXi1GqhFujjvJAbqHqAoSjlUiywejx+ag1oXCASQSqWE+oLWvfTSSxgZGYHL5ap52/PWW2/F/v4+stms0H3gIrl06RJmZ2cBANdffz2++tWv4r3vfS8+/vGP48tf/jKy2SyKxSJSqZTlnlgzRO/ZF8XFixcxNTV1pDo5NjaGeDwuVFU3Ho9bnjJPNzY2JnRPazdFo9HyRYdZw8PDhp/l9Vo+YFChblQwcjgchoHWKlVVLReostls3d+p7KFGG9o+PvWpT+EnP/lJ079fyz/8wz/gt3/7tw8NQEbpYmVgYMBwZh9Jkloq6FkN1L16AcxA3QO2t7fhcrkQCoVM7N09sVisZsvHyMgIUqmUUF/Quueffx7z8/OQZbnmQgQ+nw833XQTXnrpJfZRm6QvkqOTZRlLS0t45JFHsLm5ifvvvx8/+tGPMDQ01JHFNvTVOcnYlStXMDU1daTlQw/UIl0AVy8YZUUwGOyJMSjdoM/tbaXy32hxl2YCdTKZbHgM7Wy5UxTFckDUNM1UywdanOlDVVVcuXIFq6urTf1+LTs7O3jsscfwW7/1WzW3m+mjbnasSzMV6gsXLgh/R74WBmrB7e3t4X3vex8KhYLwIUEP1NVf0CMjI0in00IG6pdffhmnT5+G0+ms+YERCARw8803Y21tTfg7BKLY2Ng4FKh1wWAQX/ziF/HZz34Wf/3Xf225d9MskXv2QEUBYwAAIABJREFURbK1tYWxsbHy3Ou60dFRJJNJoaaa0z9bmnm9eDyetrYLnCThcNjy4koul8tw+rRmWj4ymUzDwNbOuaib+VuSJNVtjakO1K0s7rK7u4vBwUE8/vjjbSvi/OM//iPe+9731h2DYCZQ63PVN8PqZ3EqlerJ9ywDteA2NjaQy+Vw/vx54QNdLBbD0NBQ3UAt4qA+fcq8epVSj8eD2267DWtra1AURaiQIaJUKoVwOIzJycm6+7z97W/HN7/5Tfz5n/95W2f40AUCASSTSdv07TVre3sb4+PjGB4ePvTzsbEx4QJ1PB6vebFuxvDwcE9+OR+HZgO1Uc+1z+ezPCjRzHdDO78/mlmkxOVy1X2eqqcebGXqvCtXruCmm27Cbbfdhscff7ypv1EpEolgZWUFDzzwQN19zM5F3QyrFWpN0+BwOIS/I18LA7Xgrly5AgA4e/YsCoWCUF9y1SKRSM0vPZGXg7506VLNKfN0DocDd9xxB9bW1jgw0YSXX34ZExMTUBQFqqrWrUgNDQ3h5ptvtjzIzAz99SZSy4JoNE3Dzs7OoWXHdePj40gmk0JdANe7+2WGz+cTcuVHEUQiEbjdbkutV5IkGV4IG7V8GA1KbERV1bZ9h+RyubZezFf3UE9MTGBnZ6epv3XlyhXMzs5iYWEBP/jBD1o+tkceeQT33XcfgsFg3X3aEajPnTtX931mJVCrqgpJknryIpiBWnCbm5sYGRnB2bNnIcuykCuY6WKxWM2BQ36/H6lUSqgvaJTe5Hq/b/Vt70o33ngj0uk0kskk5zduYG1tDTMzM3A6nbjrrrswMjKCfD5f85afqqodCdQiD4IVRSQSgcPhqFmd1GflEekCuN7dLzP05ejpqHA43FRvutH7dmBgAKqq1iz+FIvFI58FZqbM07WroNTsMtr1tLPlY3NzEzMzM7jnnnvwxBNPtHRnOpVK4V/+5V/wO7/zO4b7tSNQ/83f/A1+/vOf19xmJVDri/hkMpmea9tjoBbclStX8O53vxvnzp2DJElCBzp9gEt1n6MeqEX6ggaA/f19ZDIZ+P1+w/ltvV4vbr31Vrz44ovCt91020svvYS5uTn09fXB4XDgzJkzuOOOO+BwOI6c/2Kx2JFBifogWAbq+vQp85xO55F+2NHRUeGmudTvfjXTQ+3z+Xryy/k46NPmWX1ejfaXJMnSXNS5XM5U4JJluW3rMSiK0tQy2vW0c1CiXqH2+/24/fbb8bOf/azp43r00Udx9913Y2ZmxnC/dqyOGg6Ha164SpJkafyUHqhVVe2J9TcqMVALbmtrCzfeeCMmJyfx8ssvt3XqoHaLRqMYHh6uWaEWsaf1ueeew8zMDBwOh2GFWh+YeP78ec700YA+ZV5lJXFoaAh33nkn5ubmUCgUyq+DTgXqQCCATCYj3B0RkeiBulbFV8QLYL3lo5nb9F6vF5lMRqgLBFHogbqdFWoYtH3oQamS2SKF0+ls252Gdr4W9NUmK79DWlncRQ/UAPCe97yn6dk+VFXFN7/5TXzwgx9suG87KtTtCtQHBwdwOBxwOp1CrthqhIFacFevXsXY2Bje+MY34uzZs8jn80LOlgGDhV2GhoaEnEf73LlzOH36NBwOh+EXxNDQEAcmmrS+vo6ZmZkjQVmSJExPT+Ouu+6C2+0uP4ed7KFmoK6v3qIuKAWXoaEhoe6G1WsnM8Pn8+Hg4EC4C3oRRKNR+P1+y+0P/f39DafOq1WhrhWok8mkqQq5JElt++xtZ6DWq9OVFe9mF3cpFovY2toqV5Tvuece/PznP2+qUvvTn/4UIyMjeP3rX99wXzOrJRrJ5/NIJBI1j9NqoM5ms5BlGQ6Ho+fGPjBQC253d7d86+fs2bPQNE3YVeD0D+fqW2n6LUDRjvuVV17B6dOn0dfXZ3j7T5Zl3HnnnVhbWwNKH6BU28bGBqampo7MHKFzuVy49dZbcdttt8HlcnVs2jxRB8GK4vLly5ienq57QeP3+4Uar9FKoPZ4PMhms6xQ1xCLxZparVQvktRj9HlffR7MTJmna9d7uhOBulozi7vs7+/D7XaXq91erxd33nknfvrTn1o+rm984xu4//77Te3basuH/llRq0Ity7Kl5zufz5dfD73WqsVALbi9vT2MjY3hzjvvxLPPPiv0bZBEIlF35TsRA/XFixcNp8yrdPr0aUiShHA4LFTlTiTZbBa7u7sYHx+vuepkJb/fjze/+c0dqVDrg9BYoa5vc3MTExMTR1ZN07Wjp7Kd9FkUmul7dbvd5dU5RRGJRPDyyy93+zAQj8cxMjJi+feGhoYMn896n/eSJB0JxVZCcrve0+0O1JVT5umamTqvst1Dt7CwYLnt49VXX8Xly5dx7733mtq/1ZYPfYq7drR8VO4r4p1tIwzUAlMUBbFYDKOjo5ifn4fb7cbly5eF7aOOx+N1qx1er1eoL2iU+n3n5uZMBWq/318emMg+6tpeffVVBINB9Pf3d6Q32iy9B5gVyfq2t7cxOjpa907CyMiIUBfu8XjccOCwEY/Hg4ODA6FeD+FwGNFoFK+88krXKnCapiEWi9UMg400uqtXr+VDluUjodhKSFYUpS0XRu1sm6yeMk/XTIV6c3PzSKB+17vehaeeespS//g///M/4/3vf7/pgkUgEEAsFmv6tRgKhepOdSdJkqX3XuW5cTqdPTUfNQO1wPb29uDz+TAwMIDh4WHceeedOHv2rLD9gIlEou6Hs8/n69jE8c3I5/PlpZfNfFH7/X7ccsstWFtb44C3OiqnzOtE5dksj8eDTCYj7FgDEVy9ehWTk5MYGBiouX10dBSRSESYzxmji/VG3G43Dg4OhGoBymQycLlciEQiePXVV7sSqjOZTLlf3qpGqyXWG5Qoy/Kh86BpmqXPUk3TWu6jLhaLbX1d17soabZCXT0jh8fjwZve9Cb85Cc/MX08P/zhD/Gbv/mbpv/dvr4+9PX1NT2rRjgcxtTUVN0eaivPd+XntsPh6Km1HxioBba1tYXR0VG4XC4Eg0G84Q1vKPdRizavarFYRCqVMlzaVKSWj4sXL8LtdmNwcNDUkqr9/f14/etfj7W1NTidTrzwwgtCVbxE8NJLL2F2drarYRqlD+GhoSGhXm8iKRQKCIfDGBsbqzuv88jICGKxmDCvcaOL9Ub0QC3KBZamaeW7XC6XC+FwuCuhOhqNNjUHNUohyWj8Q71p86pbPnK5nOXH3eodWkVR2vpc1+uhbmZxl1otHwBw3333mW77ePTRR/Gud73LcitPIBBoetxEOBzG/Px83VzSbKCGhVlgRMBALbCNjQ0Eg0E4nU54vd7yTB8i3gZJJpMYHBys+wXt9/sRj8eFGWDw7LPPYn5+HrIsm2pPkCQJb3rTm/Diiy+WR6qvra0J83hEcOHCBdMtNJ0mYs++KPTFovr7++uGqbGxMcTjcWFCqNH4jEZEq1BXh/u+vr6uVKqbnTJPZxSojSrUlY/dakW0HVPntfs1bTQo0WqFulbLBwC84x3vwDPPPNNw1gtFUfCtb33L9GDESq30UTcK1FZe19UX8YVCoWdCNQO1wDY3NzE6Ogqn0wlZlnHmzBmoqoqdnR3hKtTxeLzmlHk6ffW1Zipe4XC47V+Ga2trOH36NFwul+kpo6anp+H1erGxsQGHw4FMJoNXX321rcfVyy5fvoyZmZmmVrNrN4/Hw0Bdh9GUebpgMCjM4i76gMJmWhMgYAtQOBzG9773vUOtDnr7x3H2VOsV6mbvKBn9ntmFXcxOmadzOBwthyt94ZB2MapQW+mh1jStZssHSheFv/qrv4rHHnvM8G/867/+K6ampnDLLbeY/nd1fr+/pUA9NzfXcoW61t0Dh8Mh1HgOIwzUAtvc3EQwGCz3Obrd7nKV+uDgQKjqqD4Hdb0Px0AggHQ63dQXdCQSaXvP8oULF0zP8KHTF3jRp89zOp2IRCLY2Nho67H1qkZT5h0nn88n3CBYUVy6dAnj4+OGQSYYDCKVSgkx57o+ILHZSqrb7RYqUK+treE//+f/jAcffPDQAGeXy3WsAxX1lW2bDdTNVKhRVYHMZrOWz2urxZVcLtf0a6kWo0BtZXGXcDiM/v7+ujMkLSws4Pvf/77h37AyVV41fWBiM9pVoa4VqJ1OZ88URxioBba1tYVgMFie2ioYDJbno1ZVVajbILFYDENDQ3U/nFtZDroTi3ToU+ZZqabqS5DrgRqlL8GtrS3s7++39fh6jaIo5YFujabMOw6iTfsmkosXL2JqasrwtT8+Po5EIiFEoG5lDmpUzEghyuw8v/jFL3DPPffA5/Ph05/+9KHP8eMM1eFwGMPDw023aBkt7lJvlg9UVSub+VxvR6C2upCNkXqB2uriLvXaPXTveMc78Nxzz9UNly+99BKuXr2Kd7/73RaO/pdabfk4deoUVFWteU7NVqjz+XzN172oM5tVY6AW2Pb29qFArU/yrvdRi3QbRP/SMxrklEqlmqoSFQqFtn4ZappWbk+wUk11uVx45zvfie9973t46aWXyj/v6+vDa6+9ZmlVp2w2i3Pnzgl1UYTSRVwzX+QXLlyA3+/H4OBg3ZkjjpPes09Hra+vY3Jy0jBIBYNBJJNJIWazicfjLVVSUZo3WYRV1xRFwdmzZ3HnnXfiC1/4AqampvDJT37yUC/xcYXqSCQCj8fTdIvW4OBg3QKJ2YVdmg3UrTwvnQjU9QbMWpk6r167h25oaAh33303fvzjH9fc/o1vfAMf+MAHml4sq9lBiZqmIRwOY3R0FG63u2aV2uz50ldJrNbuDNApDNQC29vbQzAYLH/gORwOvO51r0M0GkU0GhVqOhm9Ql3vw1lv+WimulA5Kr4d4vE4IpEIxsfHLc9t+/rXvx5/8id/gs985jPY3t4u/7yvrw/nz59veJyKouCVV17B2bNnkUqlhBtcur+/39Rzvba2hlOnTsHhcHRk9UOrAoEAEomEUG1Rotjc3MT4+LjhxeTIyIgwgToWi2F4eLil3vzh4WEhAnUikcC5c+dwxx13wOFw4POf/zyuu+46fOITnzh0fHqo7uQYjXA43NKFitHiLoODg1AUpeYdDv13isViUwUWVVVbqlKrqtrUAkH11KtQw+LUefVm+Kh033334Qc/+MGRn4fDYTz22GN43/veZ/Koj2q25SOdTsPpdJZnzGo1UNe6E+VwOIRaubUeBmqB7e7uYmxs7NAHnsfjwR133IFnn31WqOpmoy89fTloq1/Q2WwWP/zhD9s6KPHcuXOYnp4ufwhYMTw8jHvuuQcf/vCH8clPfvJQFcbpdOLcuXM1vySKxSIuX76Mp556CrFYDH19fXC5XEJ8yVdSVbWpD64XX3wRc3NzQgxIROmWc7M9+yfd9vY2xsbGDAf5jY6OIh6PC/H8xeNxw4t1M9xutxDvtfX1dWxubuLmm28GSrNefO5zn8PrXvc6/OEf/uGhzxN9Sr1Lly515FjC4XDT0+ah1PJRLyhJklS37UMP1Llcrun5oFspsLSzl15VVaRSqbptblYr1I0C9dve9ja88MILR4Lv8vIy7r333qanlkQLLR+hUAijo6NA6X1WK1CbPc/17h44nc6eaOFjoBZUoVBAIpHA2NjYoavp0dHR8nzU+XxeiAoSKga41PtwbjZQP/nkk/jSl77U1g/BF154AadPn4bD4bBcnRkZGUE+n8f999+Pt7/97XjwwQfLVRhJkqBpGs6fP1/+otE0Ddvb23jqqaewu7sLl8t16DkSrTdMluWmWiVee+01zM7OChOoA4EAV0us4+rVqw17qL1eL3K5nDA91MPDwy21fIhSoX7yySdx8803H3oskiThwQcfxK/8yq/gY/8/e28e5NhZnws/R7ta+750q7fZPNM9Patt8AAOuUyCp1g8wfyRFAS+SmKbS2JyKXASSHIhFKQIJHZBSMJNKKpYvkuFwFSFeJJbQ8gNXvHM2NM94561F20t9aJdrdau+4f1KuruI+mco3OkI7WeqimXW6fVRzrnvO/z/t7n9zxPPrmN1CgUCoTDYQSDQd7PJRaLQa/Xc95RauWQ1KgxkTyTmUyGU6VYKpW25XLF55iQSqUwNDTU8DtkY53XSkONauX/oYcews9+9rPazwqFAv7pn/6JczMiAVdCTeQeqBJqOitENi4fje4Jsc2VdBgQapFidXUVJpNpl87RaDTi2LFjeP311yGRSESTPhiLxaDRaJoS6nQ6zbrSvLCwgHg8zmuF+tatWxgfH+dE/jQaTW0Seeqpp2Cz2fCnf/qntQFDIpEgm83i9u3bWF9fx9WrV2s2e3SDbj6fF40/LqqTDZedj+XlZVER6naaYPsZxAveYDA0JVIURUGv14tifCFysnakRGKoUFcqFVy9ehUzMzMoFArbigsUReGpp57CO97xDjzxxBPbpGAKhQI+n4/3xud2faglEgmncBcyVrK1zCOQSqWcE/3AM6FuFd3udDoZhbs0s8zbibNnz26Tffz7v/87xsfHsX//fhZnvhtcJR87CXU7ko9m1yafz4tigd8MA0ItUpCUxJ0DjlQqxfHjxxEIBJDNZkUx4YEhoebia7uwsIBSqcRrAyaxzONC/qRSaa3pTiKR4POf/zxisRieffbZ2jHE5ufevXugKIq2sra4uIgf/vCHoChKNM1zt27dwr/+678il8ux3hEglnlicPhAdXIQk1WaWLC0tFTzoG5VHTQajaLQLZLmuXYItV6v77p3fzabxdzcHGZmZlCpVDA8PLyLVH/sYx/Dr/zKr+Dxxx/fVtkkjc98bntHo1HWaXo7wYVQVyoVlMtlbG1tcWoOpCiqrZ1ZPgl1M/00WFSoE4lETSbTCg899BDm5+drz2Y7Vnn1IM87274TJoSaTYW6ESQSiSjGo2YYEGqRwufz1WLHd8JgMODIkSOYnZ0VzTZIPB5vWu1QqVSoVCqsz3d5eRmoNmjyhaWlJXg8Htb6aQK1Wl0bIBQKBb761a/ilVdewfe///3aMTKZjJawh0IhfP7zn8cTTzyBZ599FplMRjSDxM9//nN85zvfAarNU0xRKpUQCATgdDoZxbh3AkRiJKbqvxjAJNSFoB0bLT5BKtTteAcTL+puYn19HW+88QZmZmagVCoxOjqK8fHxXVW33/7t38ajjz6Kxx9/fFtVWqFQ4ObNm7wtDOLxOEwmU1vv0ew+auYF325jYa8QaqbhLkQ/zUQCo1KpcObMGfzsZz/D/M2biMViePvb38763OneVy6Xs67+d6pCLZfLRa+jHhBqkYKEutBVAOp11FyqiUIgHo83HViaNak0QyAQAKqND3w4NpDmwJGREdYOHwT79u1DpVKpnY9er8fXvvY1fP/736ftwEa1GvTVr34VH/rQh2C323HhwgUcO3YMN27c6PpET7CxsYGFhQXk83lWJN/r9UKr1UKr1YoidhxVQp3JZETTYyAWLC8vw+FwMKr2mkwmUVhztutDjWozdzsyAT5w7do1GAwGmEymWkOoy+XCvn37dt2nv/mbv4n3v//9+PjHP76NRMjlcty4cYMX16NEItE2oW4V7tKoQl0qldravudKxkulEudGSDowIdRMwl2Yyj0Izp49i0uXLuHHFy7ggx/8IG9BNVxkH5FIBFarFWhRoWYyf7e6rmKZKxthQKhFChI7TufpW6+jrlQqorDPa0WoUSWebB/WQCCAsbExRCIRXioLgWAQCoUCOp2Oc6KfXC7H0aNHty1knE4nnnnmGXz5y1/G66+/Xvt5Op3G3/3d3+GDH/wgKpUK/vEf/xEf+9jHoNVqcezYMczOztailbuNSCRSa6pkM3DdvHkTw8PDkMlkorDMQ3Uy56LZ73csLi629KAmsFgsnLaA+QZpeG7H6kwMhPry5cs1/XQ9kXU4HDh48OAuUv3Rj34UZ86cwSc+8Yna80hRFGQyGebm5tq6t8vlMlKpVNuEWqFQNLw/mkk+CoVCW4WgYrHIaT4olUodiR0nIOEurWR9TBw+6vHWt74Vd+7cwSu/eBXvf//7WZ1zM3CJH693+dBoNJzjx+lSEndCTEYMdBgQapGCVKjpSJ9MJsOpU6dw584dlMtlUVSRmpnbE7BtcqpUKgiFQrjvvvuwsbHBSyX+5s1bGB0dBUVRbVVT1Wo1pqamtj3chw4dwhe+8AX8wR/8AW7duoXvfve7OH/+PMLhML773e/i05/+dG3gAVCzPyyVSl2f7FGtohuNRszOzrKKtr958yY8Hk9bLgx8g2sTbL/D7/fD4XA0tcwjsNlsSCQSXd8BYzK2tIJOp2N1T/MNEuhC9NM7iazFYsHhw4dpGxUPHDiAT33qU9vchCiKwtzcHOciQyqVgkqlantHifhN06FZuMvm5mbbRQQuFW4mpI0NWhFqVHXUrRoTmTh81EOpVOLhhx/Gu/7bf+O1b4WLzIup5IMPQo3qAlusGBBqkSIcDsNmszUc8CwWC/bv38+6migUkslky2oH29UvqWaPjo4iGo3ysjK9dedOrSGxXXN/nU6HQ4cObTuvt7zlLXjqqafw4Q9/GHNzc/jmN7+Jz33uc3C73bt+f3p6upa4KIZFUSQSwVvf+lbMzs6ycvu4c+eOqDyoUa1Qp1KprpNBsSEYDDZcqO+E1WpFMpnk9B16fT7eiAufhLpbO0GpVArXr1/HsWPHoFAoaJ8Vo9FYW6ST746iKPzRH/0R9Ho9PvvZz9auhUQiQalUwvXr1zl9JmKZ165UQKPRNCT1jdJKJRIJ4vF4W2mFFEVxKkLk83leQ11auXyAYWMiW8kHAPzhH/4hfve/f4zV77QCl7REJpIPMNBRMyl+KBSKAaEegD1WV1dhtVobVv0sFktN9tHNiQLVByWVSrUcWNjGQS8sLMDpdMJqtSIWi/FimdOOwwcdzGYzJiYmtpHq97znPbh06RK+8pWvYHJysuHvarVaeDwe3L17t+sOBKhWqM+cOVPz0WY6sBJNulj006hWcNq11+pHhEIhVpIPLs485XIZa+sbCIVCbZzpf6EfCPXdu3cRiUQwOTlJK+Mj0Ov1NTkZISBSqRR/9md/hmw2iy9+8Yu1zyCVSpHL5eDz+VifT7uWeQTNChONJB+EULcjD5PJZJzGzEbR1lzBpELNpDGRreQDVTkJ3xI7thrqUqm0bVHRjFC3evay2SyjxY4YCoiNMCDUIsXa2hrsdnvDB8ZoNNYaE8vlcleJQyaTgVwubzpRoEo+2RBq4khgs9kQj8d5acRZ9noxNjbGK/lzOp0YGRnZRqpbEYB8Po9isYjp6emaxKLbiMVisFgssNvt8Hq9jLX5Xq8XbrdbNA4fBM22nPciSqVSbVxhsqC02+1IpVKsF7K5XA4ymRR+v5+Xvgcmu1+toNPpkM1mu+ZL/otf/AJTU1NA9b5sBtJfUa/3VSgU+MpXvgKv14tnnnmm9nOZTMZp7CC69HYLC1wJdbvElrwHWzRK4uMKppKPZhXqZDKJQqHQtoUhH2Ar+YjFYts87duRfGxtbTFa4OVyOdFK+QaEWkBUKhV4vV7Wv5fL5ZBKpWCxWBoOVnK5HKdPn8aNGzdAUdS2IIBOIx6PQ6fTtRyojEYjUqkU40nt3r17cLlccLlcvFWofT4fRkZGeCd/Ho8Hdru9pSylUCigXC5jfHwcJ0+exMzMDGZnZ1EoFLpuWh+LxWC1WlmRfBJIICbLPAKdTid6m6VOIhQKwWg0YmhoiFElyGq1IpVKsZZapdNpUHhT57u4uNjGGb9Z1cpkMpwdeQi0Wm3XKtSVSgWvvfYajh07hkKhUNsebwa1Wr2LVKvVajz77LO4cuUKvvWtb9WO5SLJ4YtQSySShiSoUVIiRVG8XAcupCqfz3ecULcKdwkEAhgZGeFVisIVbAl1vX4aTZISwaBCzWaxI9ZxfUCoBUQmk+HknxwOh2E2m1tWUd1uN9xuN+7cudNVyQBTWyu26XWLi4twu901Qt3uqnRrawtra+twuVxtT9B0mJychMlkoj1PQqQ9Hg9Onz4Nl8tVWxTNzs6CoqiuDxKJRAJ2ux1Hjx7F3NxcrYreDMFgEEqlEgaDoeUORadhMBhErbfrNBYXF2G32xk3j1osFk4V6mQyCalMBqlUivX19ba2aJPJJNRqddvET6vVdq1Cnc1mMTs7i5mZGchkMsb+9yqVCjMzM9vkH3q9Hl//+tfx3HPP4Qc/+AHAkVBHIhHebC4b3U/NCDUfpJZLT02pVOKVuPJRoeYi9xAKRqOR1TxER6jpuAhFUS2fvWax4/WQy+WiyW7YCUYCnLPnzi8DGAaw8xuZuXTxwp2z586rAXwFwAcB6AG8AeDpSxcv/Kz6+01fZ3pMryEWi3EawFdWVhp6UNfDZDLVZB+HDx9GpVLpyio3Ho9Do9G0nPTMZjM2NzcZfyc+nw8PP/wwRkdHEYvF2m4wu3nzJmw2GxQKhSDkj6IoHDp0CDdu3KhtX5FzdrvdGBkZ2TWRTE5OQi6XIxwOw2QyweFw8H5eTEDsiEwmE06dOoVvf/vbqFQqSCQS2wbMnai3zOPLC5UvNJrQ9yrqUxKZgGio2RKXb3/726AqZTz6ax+AQqHA3bt3cezYMU7nnEgkGO1+tQKpUHejSXVtbQ23b9/G9PQ01Go1qzFarVbXFrhkfLVarfjGN76B3/md34Fer8ev/uqvsj6naDQKjUbDizOPTCajvUeIA0gul9tF3PlwpigUCqznPD4XVJVKhVFTosPh6BlCbTabWZFVNoS61bPH9NmkKEq0Omo2o9TvXLp4QbXj353qa38D4F0A3gnACuB/A3ju7LnzBxi+zvSYnkIqlWKkHdoJv9/PmFAfP34cr7/+OorFYtf8GROJBKPtQ5PJxKpCHQwGYbfbYbPZeElJeuONN+AZGRHUL5miKExNTUEul6NYLMLhcOD06dMYHR2lJQUmk6k2YXZTRx2LxWrxzocOHUImk0EkvI6cAAAgAElEQVQ8Hm85uM7Pz4vOMo+AbRNsv4N4UDO9VqTnge349dOf/hTPfu3riMVitcmPqySNyMnafV5JU2I3tJeXL1+Gy+WCRqPh5H2v0WgwPT29bXx3u934+te/jmeeeQaLi4usiSIfce4Eje4nEuaVSqXa/ht0qFQqrHdP+FxQkej0VsUZUqFu5HJBJB9iQLuSD7VaTesxzoRQs7mHs9msKB2c2t53OXvuvBnAhwD8waWLF+YvXbyweenihb8EcBPAk61eZ/IevHzSLoD4nrJ96AOBACPJh0KhwP3331+zOevWDca0Qm0ymbC5ucmY+K+srMDlckGhUMBisWyL4eWCN/2SRwS3d5NIJJiZmcHp06cxPj7etHJrMpkwPT2Na9eudbVpKhqNwmAwQCqV1kj+9evXW5J8MVrmEZhMpgGhrgNJSWQqOSBe1WzlZEtLSzhx/Dj++q//GqiOU0tLS5x0s4lEAkNDQ21LE7pZoX711VdrgS7NdnuaQafT4ciRI9vGzsnJSczMzGBxcZH1QiESifBGqGUyWdNwFyGfQbZFCL5jx5m4z6jVaiiVyobfg5gq1MTlg6nl5U5CTVEUbbgLU8kHU5DdU7GBDaH+4Nlz52+ePXc+cfbc+Stnz51/T/XnJ6vSkcs7jn8VwFsYvM7kPXoO5XIZn/3sZ3H58mXW2xPNUhJ3YmxsDDqdDl6vt6uEWq1Wt6x8GY1GxoR6c3MTW1tbsFgskMvlsFqtbRPqO3fuYNTTGfInlUoZSSCUSiVOnjyJ2dlZVCqVrrm1kIqVXC6H2Wze1pjYbHBdWloSnWUeAdkREUMKpRhAQl3YNI+y9Y6PRCJIJpN4+tOfwksvvYTr168DVSLDxd6N9Ge0uwOi1WqRyWQ6PkaWSqVaoAtFUW1JHQwGwy7fe2LJxrZow5dtHqoLr0ZkSUjZlUwmYz1e8k2oW+mnCRwOR8PGRLahLkJCpVKBoijGC5X6lEQCOtkHE0LN5tooFApRZDfsBNPl6RyABQCPA0gB+H0A/3z23PkzAOzVY3Z+ug0ATgavg+ExtIiuh1EudWfCLBYL2Aiv0L6WTqfxyiuvwDM8jIB3GZUC8wFvceEeJsYnkN1MYSPcYqVYKuDI4cN49ZVX8MDJEyhsdZ6QBXxeKBUKJCLryKYbW61VCjmkkkmsh1YgQ/NrdvPWLdisVuS3MoishmDQ6xHw+7C2EuCsp7xz5zbe+pYHkN/KNLxu3cDEqAerq6tYD4ewoJDB04Xtv+WFu1CrVdhKJZFWK3HfwQP4u2/+LyRjUQSWl6BW0y/uFhcX8Miv/iqKuS3BvtNmz1kzKGRSxGMxrK0ERBOJ3k0E/H7otRpsJmIo5ZhNmDqtFgGvl/H3/+JLL2HY7cbQkBqP//Zv48+/9CX87Tf+GlKpFPfu3IZCSkHBghwHvMtQyOVIx2OgStzlGoVC4U3pyWoIQ4rO3QvJZArX5+bwkQ99CIXcFmLrzf2ImcBqNMDr80Eul8NkMGAlEEDQt4yCzcb4PdZWV6FSyBFZ/S+vcK7PWTadQjIWpS1UaIbUWA2FkE4I03AdCvihkjGfD5KxKG9jQTgYhFajYfTZLGYTfEtLGHFtpzOZTAbpdBoquYzTd1Qql3j/bg0GA4I+L1wuV8tj19ZWoVGptp2DWqXCejgEo+6/Fu7lSgURqQRqOf0CrlQqIRWPsVo4b6VTMOu74yxlde4OagNTQn3p4oX37fjRn509d/79VYJ9qcGvUQCascFWrzM6xmxryrcFxUZ4peEXe+ellxCPx7G2sQHlkKbhcbTvG4ni7e94GK6R0ZZVar3ZitP334/Lly9jSG9g9Xf4Qq5QhNFkgt090vSBKFFSbGYyjM4z+ovLcA8Pw2S1wep0Y8TjQXozA6OVmYcuHQKBIIbdwxidmGzb15ZPjBVKmJ6expLPj8kDB7tyDYsVCgaDEXb3MKxWK868/R34w898FsohDSCT055TpVJBMLiC/QcPwjM+ySjOmguaPWfNMDI6hjdu3oLRahedA0k3sLq2hol9++HyjDGuTFptNmzl84y//2V/EJP79kEqkeLRX/s1/Ov/+T+49LP/wGOPPYZyuYxYMl3zY2aCEijoDQbY3cOc9Mf1kEqlkKuGOvp83V54EdlcDoeOHIFer+flb1udbujNFiwuLmJ0fBwLS0tQqNnNMal0Gq7hkW2/w/U50xi2EN6I0O5SmS1W5ItFaA3tBfM0glKpZHzOpVIJQzovbzuUuWIRZouF0WdzD48gkU7vOjYYXsXIyAj0Jm4e1OlEnPfv1mKxIFcsMXrfeDyBkbGxbcfqDQaUQG37WaVSgdZgbHitstkshnR6Vjud+XweFodLFHaDBO1oqO8BcAEg+xg7l8f26mutXgfDY3oKr7zyCgwGA/x+P+tmQRK+wGS1plAocOLECdy4caNrZuekKbHVJG0wGBhHGZNQF/IdOJ1ORCIRzp8xk8lgc3MTJpNJMOLHFTu9n/mKbGaDaDS6zUbLZrNh3759uHXrVsOmovX19VrjkRglH0Ri1C1dupiQTqeRy+VgNptZbfOz7fqfn5/H5OQkClULrKeffhrf/OY3EYvFIJFIkEgkWDUXx2IxaDQaXqQJGo1GsAa5RnjllVdq1nftpj3Ww+FwYHx8HBaLBeFwmPW4GI/HeSsqcAl34QtspC719oN8gI3ko5F1npj00wRsGhN3aqjRRPLRTHrH9dp0Y65shpaE+uy58xNnz53/27Pnzu8cDaYA3AVwFUAewFt3vP4QgBcZvA6Gx/QUrl27hne9613w+XycCLXNZmM8iYyNjSEej3dNQ00cIlpJMVQqFeM46IWFBbjd7lo1we12IxaLcXYyCQaDsNlskMmkomugU6lUOH78OGZnZ2s2U53GxsYG9Hp9bTvUYrHg6NGjTQNeiGWeXC4XnWUe6gi1GLvBOw2fzweHw8H63rdYLIhGo4wnroWFBYyPj6NUKqFQKGD//v145JFHag2KSqUSCwsLjN+PaKj52KbXaDQdbWSqVCq4evUqjh07hkqlwvuumMvlwokTJxAOh1nf463sMNlAKpU2HPuFtq7M5XKM54RuEmqn00kbPy4m/TQBU0KdzWaRy+V29QU0S0tsBOKY0utg8gnCAN4L4Btnz503nz13Xnv23PnPATgA4K8vXbyQAPAtAH9+9tz5qerr/xPAGIC/afU63pSUtDyml1AqlXD9+nW8853vRCqVYmU9lc1msbm5yWqwc7vdyOfzXUvai8VijINS9Ho9owoVcSQg27xutxvxeJyztdzy8vKb9nuyxtWUboGiKNx///24desWyuVyV0zrSdc/IcYajQYzMzOYm5trGPU6Pz+PkRHhXVO4wmg0IpPJiDamtpMgOz5sianNZkMikWBM2BYWFuDxeOB2uWr30uOPP76tQbFQKCAYDDJ6Pz4r1I0meqGQy+UwOzuLo0ePQqFQCPKcnDx5EvF4nFXje6lUQiaTYUwGmaDRbqrQLh8SiYSxJWM+n+94qAuB3W6nJdR+v180lnkETAl1NBqlTXNu9Jw140DZbFaURRm2aEmoL128sFX1h9ZWK9I+AL8E4JcuXbxwu3rY/wDwLwD+A8A6gHcD+JVLFy94Gb7O9JieQCwWw+3btzE1NYXh4WFWVepQKASr1cpq8LVardBqtV1L2ovH44wHFqaEOhgMbnMkcLlciMfjnBcNXq/3TRlNBxuS2MDhcMDj8eDevXtdsQOKRCLbKtQUReGBBx7A3NwcyuUy7bbt7du3MTo6KkoPalSrY+l0umv+7GIC21AXApKWyEQ2k8vlalaXep0WBw4cQD6fh1arxVNPPYUvf/nLKJVKkMvlCAQCjEg68aHmgwhptVpB5Qc7EQqFsLi4iKmpKcZWhWwhk8lgsViwssK8mZDYnPLZqNvovYjMTyjI5XLG8oRsNtvx2HGCXpJ8ME1LpHP4QJP48WaEmk3suJjBtCnxFoD3N3k9V3X++H0urzM9pldw+fJl2O12qNVqDA8PIxAIYHNzk1FjFElJZDPxKZVK6HS6rvkyJhIJxtuZTG24gsFgzYMaVULdjuRjeXkZdrsdSrk4q6lER33t2jUcPXq043+f2GjVD2pjY2PQarUIhUJwOBy7Bs/FxUWcOHFCtA1/RqNxQKirIISardbdZrMx7nuYn5+HzWar+e4ajUYYDAZsbm7i3e9+Ny5cuIALFy7gscceg0QiweLiIg4ePNj0PePxOOPdr1ZoNNELhZdffrmWhMrXZ6CDy+VCKBRCqVRiVOUjO4p8VgTlcjntTpDQhBpVi1UmyOVyvH5mpj7UqEtL3JnsKEbJh9lsxuLiYsvj6PTTaCKtaib5YBo7Lnb0/pJAhLh8+TKmpqZQKpUwOTmJlZUVxs0wgUCAUUriTjCt/AqBZDLJmFAbDIaW55nL5RCPx7c1ZtrtdkSjUc4NZl6vFzabTXQNiQQajQbHjh3D7Ows8vl8x3W/0WgUZvP2TnOr1VpLcaTbUl5eXobb7eYlRlgIEEI90FC/ef/XS6iYwmazIZVKMdoZmp2dxfj4+LYk0gMHDqBUKu1qUJRKpdjY2GgpVWCz+9UKnZZ88BHowgQulwurq6uMF45k8cznzpJcLqclTEJLPlAlY0ykgIVCgdcqKJt7ky7cJZvN1uY5MYGp5CMSicBqte76ORcNdb+M0QNCLQCuXbuGqakpSKVSHDx4EH6/H9lsltHvMk1J3Am23fh8gg2hZpJe5/P5YLVaaybzqCaFNZIeMEEgEHhz12BImK3XdiGRSPDggw9idnYW5XK5424E8Xh816Sv0+lqjYnZbHbXgOjz+TA83L6dmVDQaDTI5/OMn71+Brn/2V4rIvlgQtZu3LiBiYmJbXI1uVyOkZER5PN57N+/H+9+97u3JSjeu3ev6XuyqQK2gl6v71iFuj7QRSaTCSb5AICRkRGsrq4yvs9jsdg2Rx8+oFKpaLf0hW5KRFVuQien2Am+3X7Y3ps7w10CgQDcbrfotMNMJR+NKtRcNNT94sQ0INQ8o1Ao4MaNGzXd3OHDh+H1ehk3RgUCAU7WbiQytNMgRIvp+ZpMppakeGFhAU6nc1sFhaKotuLHV1ZWdr2n2DA5OQmFQoHV1dWOp0DF4/FdFWqpVIrTp0/Xou3rq4nRaBSFQoHT4q9TIMl0ndTNihXk/ufi8sG0Qn3nzh1MTEzsuh+Gh4ehVCpRqVTwxBNP4MUXX8T169dBURTS6XTTahibxXorkLTETiCVSuH69euYmZmBWq0WdDt7dHQUq6urjBu2SaMnn02SGo2GtsootG0equMUk7/BN2lju3uyU0ctRrkHWFSo2WqoBxXqAVhjbW0Nfr8fBw4cgFqtxszMDAKBAONmOiL5YFvRMJvNXSHUROPIdCvNZDIhlUo1Xa02ciSwWq2MKhF0CIfDb0pIRJyYR6zqGkkshAKpiNNVW44ePYpIJIJ0Or2N5N+6dUvUlnkEOp2ua1IosaBcLmN1dRVOp5O1lMxisSCZTDIqCCwsLGB0dHTX4pqiKBw8eJC2QVGpVGJpaanhZJtMJnmrUOt0uo49V9euXYNcLue0K8AW+/btw9raGuPPFolEoNVqeSXUKpWK9hoODQ2hUCgI3seQyWRaWuLxSdqKxSKy2WytaZ4JSEw8gRgdPiCg5KOVD3U/YECoecaLL76IyclJoEpyR0dHkc/nEYvFGFnnrayscOrGN5lMSKfTHTc6Jz6xTM+XnGezasHi4iLcbveuSpfVasX6+jrrz7i5uYlcLger1SrqxgeDwYCZmZmOB7wkEgkMDQ3RVpptNhuOHDmCGzdubBskCaEWq2UegcFgYOwC0K8Ih8PQarXQarWs73+yo9Squlcul7G8vIzh4WHaqp1Wq4XVakWpVMIjjzwCtVqNH//4x0C1Z4LOUoxIGPjqe9DpdB2TfLz00ksd0U8DwMTEBNbW1lhpqNmM2Uwgl8tpiyok+EnoKnWpVGqpj+ezQp1IJBhlL9RjZ4VajA4fqOq9K5VKyx0PtpKPRvNZqVRibCssdgwINc+4cuVKLVqXNH54PB7G1nmrq6tv+iVzINRM7a34BElJZHq+ZrO5JaFeXl6G0+ncVdlxOp3Y2Nhg/RkDgQBsNpvoyV+9xIJpow0fIE1KdJVmQvJ3Vs1v3rwpass8gk5oOMWOxcVFznInhUIBpVLZssq/vLwMlUoFg8HQkADv27cPqJKsp59+Gn//93+PZDIJhUIBn8+3a1Illnl87YDo9Xpks9mOTN5Xr17FzMxMTXYkJCYnJ7G6usq4ykcsMvncWZLJZA3JZScaE+VyecvdS74JNdtm2Z0VarFKPiiKYlSl5ktDXSgURJd4yBUDQs0zSEOiQqGoTWBjY2Pw+/2MCNL6+jqcTifrbmSz2dyVmGVSoWZKVpmcp8/no90qdTqdNe0uG9Q8qEVO/lCVWJDt2041mUajUeh0Otrvh0Tbz87OolAo1L57EuAhZLMVH2DaYNPPIISaq++w0WhseS/Ozc1hdHQUMpms4XMmlUoxPj6OfD6PAwcO4OGHH8Y//MM/ANXJ1ufzbTue7e5XK2i1WmSzWcHHyFwuh7m5OczMzNTSYYWEzWZDPp9nXAUmFWo+fajRxIu6EzpqiUTStEJdqVRER6jFWqEGA9lHpVJBJBLZ1XcDDoSa7wTLbmJAqHlEPp/HG2+8genp6W1EY3x8HCsrKy0HlUwmg2w2S3uTtgITKYUQiMfjGBoaYkyoSRx0s2o98aDeKUHYC4TabrfXJBadaqYj0fGNmgtJimOhUKhVmohlHhsNYTdgNBoHFepqTwLXHRom3vGzs7O1ptpmIAvlSqWCJ598Es899xx8Ph/kcvmuCG22u1+toNVqsbW1JXiF2u/3IxgM4uDBgx2x6aQoCg6HA4FAgNHx5HnnO0ij0XXq1C5RJpNpOP+VSqWuxY4T1Es+8vk8NjY24HQ6eTsnPtGKUKdSKSiVStoMgqGhIdqFa6Pvn+/AnW6iPz6FSLC0tIRkMonh4eFtRGP//v3w+XwtK9QkJZHLBEIIdadjlgmhZnrOhFA3Os9SqVSr0u98TxI/ztYGbXl5uWbDJ3YYjcZtOupOgFSsGpEht9sNj8eDhYWFWqXS5/PB7XaL1jKPgEih9jJIhZoruTObzS3jnW/durXLMq8RDhw4UNMWf/jDH8bXvvY1oFplrA+UIIl+fEm1dDpdRwj1Cy+8gEOHDgHV+68TcLvduxYkjdCostgumqUldmpR2+jv8F0FjcfjrJtl68NdiOsO37sEfKHVzl4juQeqz7Fard7Vr1CpVGifvX6JHceAUPOL559/HocPH0apVNo2YB05cgQ+n68l2V1ZWYHFYuF0c7UiqkKBWDAxPedW6XUrKyswGo3QaDS7GqhI/DhbQk0kJGINdalHvcQil8t15Hq26vqvdx/Z2tpCKpVCOp2GzWYT/SKF3G/90vTCBT6fj7YngSmsVmtLycfCwgLGxsYYPWNqtRpOpxPFYhG//uu/jtu3b+PKlSu1sBeykEwkEtBoNLzZMnZK8kH005VKhTeHklYghJrJeBGPxwUh+s3CXTqx2yaXyxvaqvJNqLlUqOvDXcQs9wCDXItmhBosrfMGFeoBaHH16lVMT09DKpVum7xmZmbg9/tbWucRyzwuFRkmUgohQHSObAh1KpVqOPCT7Wm6ijeJH2dqQUjg9/trUfC9gAceeAC3b9/eJrEQEpFIpKGGGlVLLJLiuLW1tc3hQ+wDIZMm2H5HMBiEw+HgvPixWCyIxWJNCcni4iJGRkYYk4yxsTFIJBIolUr83u/9Hp555hmUSiUoFAosLCwAdbtffFXxiORD6HuBBLooFIqONUKzCXeh85znA43CXTpFqCmKaujiksvleB2ruBBq1IW7iNUyj6CVzKuRBzUBnY66UYW6UCiI2n2LDcQ9G/YQKpUK5ubmMDU1BaVSue3hdbvdoCiqpeWb3++H2WzmNPG1qvwKBZK6xZRQGwyGpoSahLrQTaIOhwPRaJS1ZyWxIhS7ywcBncRCSBBC3egaUhSFBx54AHNzcygWi5idne0JyzxUn4tm2sp+B9lebud6Wa1WJJPJhs9dJBJBJpNhtQskkUgwOTmJXC6Hs2fPQqlU4rnnngNFUUgmk0gmk7UKNV/bwSTYRchdn3K5XGtI7OSOGLHOY2ILSJeKygeGhoZon7NOSj6y2Szt9eWbULMNdSEgOmqxV6hbBcU18qAmYNOY2E9j84BQ84RsNov5+XkcOXJkVyVUKpXC4/G0rFIHg0GYTCZOlVRS+e20QToh1EwHK1K1aaRrJRVqum1ek8mEbDbLOpwhHA7D7XaLVq+2EzslFkKDEOpm38/Bgwdri8LZ2Vl4PJ6eIdR7uUIdi8VAURSMRiPnKhAh1I2+w3qHDzb3hMViqfWafPKTn8Tf/u3fIpPJQKlU1haTfBJqoqEWklDfvHkTRqMRBoNBcLu8ekxMTDBKS8zn8ygWi4I0E6vV6q7FjxNQFEVbhBBLhZoQarFa5hG0akpkIvlgWqHul1AXDAg1f7h+/TrkcjlMJhOtPm18fLxlY2IwGOSUkoi6wayTCXuoS0pkA71e33D1u7S01FDvSVEUzGYzq/hx0qhpNpt7ZltJpVLVdNSdaKKKRqMwGAxNJxybzYajR4/ixo0bWFxcxOjoqOj106irUHd650YsIJ7u7ThltKpQz87OYnx8HAqFgvUzRhoUp6encerUKXznO98BqgWKUCjEaverFYjkQ8gJfGlpCaOjoygWi4IHutRjcnIS6+vrLRcLxOFDiOJCo3CXTkk+UC3Y1Ce6EhQKBd4JNRd9PLHOE7vkQwhCjUGFegCmePHFFzE1NYVSqUS7cp2YmMDKykpTxwGuKYmokk29Xt/xVDguA0uz9LpWDVRs48f9fn9PhLrsxIMPPlgLeBE63S0ajbZsUtJoNDh69ChmZ2exsrICt9vd0QocVxgMhq4064oFxOGjnfvfZrMhlUo13F2bn5/H5OQkp+ZBtVpdS1D83d/9Xfzwhz9EOByGQqGoJTzyRYQ0Go3gko/6npJO9myQCnWrz0ZCnIQg1I3CXTodrkRXVOKbtLWjoQ4Gg1hdXYXb7eb1nPhEK0LNRUONBoR6UKEeYBdef/11TE9PQy6X01buDh482DLcJRwOw+FwcB7smlV+hQIXLVkzQt3Ig5qAxI8zBXH46BW5B8H+/fuhVCoRDocFv6axWKxlNU0ikeD+++/H3NxcTZMrdss8dLG3QCxYWlrivEgnsFgsTb/Du3fvYnx8nPOOxeTkJCqVCpxOJx577DF84xvfAKq7S3y6UZDQmVYR1e2A6L7VanVHd8S0Wi2USmVLe0NSoRaiwEBRFO0424no8Xrk8/ldzZlCEGquFerZ2VnRF3mEqFBTFLWLPPdT7DgGhJof1DckNqpKTE1NtYwfX1tbg8Ph4DwQNyOqQiGRSLDuGG8UtkEaqNxud0MC4HA4sL6+zvghXF5e5hTl3m1YrVZMT09jbm6OtasJW8RiMUbX8MSJEwgEAojH47Db7bzZmQkJQqj3aoV6YWEBDoejrQY5s9mMZDLZcOxi6/CxE6THJJ/P4yMf+QiuXLmCGzduYHNzk3d7N61WK2i1lNiIdmOx6XQ6W4a7kJ4XocgcHaHuRPR4PYj9Yj34JNSVSqUtDfXq6qqo5R6oazBt5BrTilBrNBpGhLqfUhIxINT8IJ1O486dOzh06FDDiWt6erppUyJpnGrHt5RJohnfSCaTrCe9Rh3Ea2trUKlU0Ol0DRcVLpcLkUiEMUHy+Xyw2Ww9Y5lHoNFocPz48ZqzhlCoVCqMbbRcLhcOHToEt9u9y8lGrNDr9Xu6Qu31etvyoEa1Qp1IJGifuWw2i3A43PaOBdmVGhoawpNPPolnnnkGqVSKM0lvBLqJnk/EYjGo1eqO6qcJXC5Xy3CXViFO7YKOUA8NDSGfz3fsGZTJZLvmFz7H0M3NTSiVSk5FGofDAQCibkhElfw2mqeLxWLLeZ9phbpQKAwI9QDb8corr9ScKRoRE1LRW11dpb2BQqEQLBZLWwOd2WzuqOSjUCggn8+z1tKaTCbaLUDSQNXsO3C5XKys80iFuhfkCfWgKAqnT5/G7OysoE0bmUxml296I+j1ekxPT8Pj8fREdRrVyVWlUglKosSMQCAAl8vVVgMpaeykKwbMz8/Xxr527gmKojA5OYl8Po/3vOc92NrawuLiIuuG51bQaDSCyg+Id3Y3+guGh4exurralLiSCrpQhJqOZFIU1XHZRyaT2TbP8jmGcrXMQ7VnQK/Xi55Qo0mBLhaLwWg0Nm0WpiPUEolk13Xop1AXDAg1P3j55ZcxPT0NVK2Z6EBRFEZHR+H1emkHvJWVFc6x4wSNiKpQSCQSTf2LG4HEQe9cWDTzoCZwOp2s0hIDgQCcTmdPOFLsxPHjx7G+vt5SF9kOYrEY9Ho9o2sok8nwgQ98AL/xG7/RUxIanU7X8Z0bsYD0JLRDoCQSCbRaLe13ODc3x9nhYyeMRiP0ej0oisInP/lJVCoV3ivUWq1W0Cj6eDzOaUzkA2NjYwiFQk37dEgqqlA9JSqVqute1KhWUUkzd6VS4ZVQc5V7EDgcDtFLPtAkLbGV3ANNKtR0hLpfYscxINT84Nq1a5iamoJKpWo6UI2Pj8Pv99N2IQcCAVgslrYGukZEVSiQyYPtOTdKryOEulmly+12Ix6PM9YVh0Khtl0OugWHw4HR0VEsLy8L9jdI1z9Tgnzo0CGcOnWqpyQ03egtEAMymQwymQxsNlvbVSCTyUQ7uV6/fh0TExO87VgcOHAAxWIRp0+fxve+9z3eo7t1Op3ghJrvqjpTEOu8VoSa6QKaCxqFu3TSOg87YshLpVLXY8fr8clPfhIPPPAAb+cjFBpVqDc2NpqGuqBB9Did5GNQoR5gG8rlMq5fv14j1M0wOTnZ0DrP7/fDYr4R6gkAACAASURBVLG01TxkMpk6GmJBLKLYklVynjsfLhLq0kx+QCrUTANPQqEQXC5XT66CdTodjEYjra8qX4hGo9DpdIwJkclkwtbWVk9Y5hEYDIaOu9+IAcThhg+yazKZaO/D27dv80qoFQoFnE4nisUi7rvvPt6fW51OJ6hXfztygHYxPj7eklATDbVQ42GjcJdONyZKJJIagee7B6VdQn3//fd3NEWTKxppqNupUO+8N0qlUs/kQzDBgFC3iY2NDQQCAUxOTrYkGYcOHWoY7kJSEnuNUHPR45lMJto4aK/X25JQs4kfJ2EUfDsFdApSqRRWq1XQ+HG2TUomkwnFYrEnJgSCRq4y/Q7iQc2HPMdsNtMS6oWFBXg8Hl6rsmNjY7XJl29pEV3ljE+0S7baARMv6lgsBoPBIBiJkcvltO/daQ01gFooFt9OEt1cNHUSjazzuBJq0PhQ95MHNQaEun08//zz2LdvXy3Frxmmpqbg9/tpNdQkJbHdpsTNzU3RE2piZbbzYQoGgzUHiUawWq1Ip9OMNNSBQAAOh6Mn5R4ENpsNsVhMsGtKKtRMvyPSfNYrTYmoTgx7lVDzdf/TLezK5TKWl5cxMjLC646FRCLB2NgYcrkc74Rar9cLSqiTySRrG1G+4PF4EIlEWlaohSwwyGSyhoS6089guVxGMpkUJHacbymSGCEEod65sBkQ6gG24Re/+AWmp6chlUpbVu2mpqYQCARoyeDKygrsdntbk18joioUSIgBWw210WjE5ubmtoUF8aB2uVxNJ1GpVAq9Xs+oUa9XQ13qMTw8jEgkItg1JU1KbIjL5ORkT+nejEajoLpZsYIQaj707larFfF4fNuEuLy8DK1WC4PBwPsCiziH8L0YJvHjQoGLjShfUCgUMBqNCIfDDY+JxWKCnp9EIqGVk3RaQ43q97G+vt6SUFcqFVY+9d3chegk2iHUJJV0Z0V6UKEeoCnqGxJbbaOZzWbodDqsrKzsWqmtrq7C6XS2pW0jRLVTIRakQs2FUO8M2yCTtdlsbvk9Wq1WRoTa6/WKPpGqFTweD+LxuGADDxdNpcvlEuRchAIh1P3kd8oEy8vLLSVUTGGxWJBMJrftlMzNzWFsbAxyuVyQBdaRI0eg1Wp5fU8hNdS5XA7lcrmrFp1utxsrKysNX2fqOd8O6MaSblSoKYpCOp1uSahnZ2fxW7/1W4zfNx6PDyrULQi1VCqFSqXa9awNKtQDNESpVMaNGzdw5MgRxlWg0dHRXYmJlUqlRqjbAV3lV0gQT1O2iwBCcOrPkwRQMKl0Wa1WrK6utjzO6/XCarX2lN53J+x2e9OUunZBuv57uYrfCsRVpp8ibpnA5/PB5XLxVqFOpVLbJsB6yzwhoNFoeH92dTodtra2BFlcJRIJQS3pmMDlciEUCtEWVUiIk9ChM43SEjtdoUbVRaKVk4TX68X8/DyjOQWDCjUjQo0Gso/6565cLvfdmDwg1G0gEAwgnU7D6XQy3kYbHx/f1ZhItqPbfUjpiKqQ4EqoDQYDNjc3t1nfke1pJpORw+HA2tpay0lxeXkZVqu150Jd6mG325FIJBj7brMFIdS9JOFgC7LQ7FRvgVhAehL4ILw2m63W5EswPz+PycnJnvJ41+l0yGazgtwLxEa0mx7tHo8H4XCYllBvbW1BIpEIPh7SjeFsK9R8Jui1cvghEpkXX3yR0fvtJULdyOWjlW0eGqSS1hPofktJxIBQt4eXX/kFDh8+XEuCYgI66zw+Ql3QJULdLCa8EejS6wihZlKhdjqd2NjYaLldRFLielnyYbPZkEgkGPtus0U0Gu377cu9SKgLhQIikQhcLhcviyWLxYJUKrWNqN29excej4d3WYaQIBpqISpjpELdzfFmfHwcq6urtDpxEuIk9OKZD0L91FNP4eWXX277XORyeUvNfCgUwgMPPIDnn3+e0XvuFUKt0WiQz+e3zT1bW1soFouMFmWtKtQDQj3ANrx+7Rqmp6chl8sZD6JHjhyBz+fbpi0KhUK8EGqlUgmZTNaxmOVEIsHZLkuv12/bTiKEmskWr8vlQiwWa0moV1ZWejbUhcBqtSKRSAi2SIpGo11zJegU9iKhDgaDMJvNvFWPCaGu3ylZWlrC6Oho14JMuECr1SKbzQpCqEnseDfHm4mJCaytrdHqxEmIk9DnJ5PJdhElNpKPbDaL119/HfPz822fC0VRLeeUUCiE8+fP47XXXmO0E7hXCDVFUbtkH0TuwaSIRkeo6587vt1XxID++jQdxo033sDU1BQrjSKddV4gEIDZbOZloNPr9R0LsSCeplxgMBi22XAtLS3B6XQyWvkSQt2MZFYqFYRCIbjd7p5+aA0GA7LZrGCNVLFYTHBNZbdBJEZCyWbEiOXlZV4Xk6QpkTxzGxsbyOfzsNlsPSX50Gq1tB74fIA0aXdT8jExMdEw3CUWi3Wkgq5Wq3d9v2wI9bVr11AqlXDv3j1ezqfV9QiHwzh06BAOHjyIq1evNj02n8+jUCj0tIyQDYxG4zY+sbGxwXi+aEWot7a2ejJwrRl6l2l0GYVCATdv3sLhw4dZPVxHjhxBKBTaNrmT2HE+GnD0er2gQSD1aMfgfmesqd/vh9vtZjQ5k/jxZgSJDN69LmegKApGo5GRqwkXxONxRnq4XgapUAuZkCc2LCwswOFw8EbuzGYzEolETfJBHD4UCkVPTYpCaqi52ojyCRLuQrd7Rwi10B7ySqVy1/er0WiQy+UYOVBdvXoV73jHO3D37l0Bz/JNlEolrK2tweFw4MyZM3jhhReaHk+q0/2U7tcMjSrUTEAXolS/czGoUA9Qw+3bt6FSqWAwGFhtmWu1WphMJvj9/trNxUdKIsFOoiok2jG437nyXVlZgdvtZkQASPx4M0Lt9/t7PtSFwGKxCBI/XigUkM1me2rLnguITeNeqlAvLS3x5kGN6rhVKBRqixJCqHsp4Ad1GmohrEVJhbqbCwy73Y5MJkPru04sMoW+ZiqVapfkg/QZMdFRX7lyBY899hjC4bDgzyxpylYqlXj729+OF154oamud6/IPQjaJdStmhL7bWEyINQccfnyZRw6eBAURbFuyhkbG4PX661tnwYCAdjtdl6qSY06c4VAO6lg9el1pHpos9kYPWB2u72l5MPv98Nms3V1+5UvWCwWrK+v8/6+pEmpny3zUJV87LR863csLS3Bbrfz1jBIdkrI7teNGzcwOTnZcwtWQqiFuBeIhrqbhFoikcButyMYDO56jVSohT6/RvHjTGQfm5ubuHfvHk6cOIHR0VEsLS0JeKZv6qeJXe3k5CRQ3d1phL0SO07QDqGmc/moX6z043g8INQcceXKFRw6dBAqlYr1ADUxMQG/319bfYdCId7IX6dilkulEra2ttqSfJDBlSQaMtVi2u12xOPxpoR6eXm550NdCJgG2bAFaVLqh0VHM6hUKkgkkj0VP+71ehlLqJjCZDLVdkru3r2LsbExXiPHOwGyDS3EZN4pwtoKLpcLwWBwV6U1EolAp9MJvoBuFD/OhFBfu3YNhw8fhkqlwv79+wWXfYRCoVpQFUVReNvb3tZU9jEg1O1XqMl92Y9N4gNCzRFXr17FoUOHOE1Y+/btQzAYrG3LhcNh3uyt6omqkEgmk9BoNJwJq8lkQjqdRqVSweLiIpxOJ+OBXqFQYGhoqKkMwuv1wmKx9EXziMPhQCQS4d1iqFNd/90GRVFwOBxNE+T6DcQyks/tfbPZXFvYLSwsYGRkpOcItUajQTabFcSGMh6PQ6vVdn0be3h4GOFweNeigRBqoQl/o/hxg8HQcvf0ypUrOH36NAB0hFCTuZegFaEeSD7aI9Soq1IPKtQDANUbIhqNYnJigtPDdeTIEfj9fmxubqJSqWBtba3tlEQCk8nUkZhlMnlwrXZYLBak02mUSqUaoWZD7KxWa1MZhM/ng81m6+mURAJSked7AOqUplIMGB4eRiAQ6PZpdATlchnhcBgjIyO8Nv2YzWZEIhFsbW1hfX0dIyMjvGm0OwWpVAqlUkmrMW4X8XhcFP0Io6OjCIVCu3bwSG5AJxrBGhHqVsWeq1ev1gj1gQMHeHP6aIR6yQcAnD59Gnfv3m24m9VO31Avgo5QM21ib+RDTXTUA0I9AFCteF27dg1KpZJxQmI96q3zEokEpFIpb6veTsUsE0LdToWaeAMvLS3BZrOxqibbbLamUbF+v7/nQ10ISPw43wNQp2y0xAC3241QKNSXg/hOrK2tYWhoiPfAFavVilgshvn5eQwPD0OlUvWk/l6j0QjSZ5JIJERRsSdOHzut86LRaMeqq1zix9PpNJaXlzE9PQ1UCfWdO3cELQ7VSz5QdSg5depUw1CZvVah3mke0K7LB+oix/stdhwAWI+GZ8+dPwPg5wC+cOnihc9Vf6YG8BUAHwSgB/AGgKcvXbzwMyavMz1GbJBIJJwkH/fdd1/NfH9lZQU2m423bTiz2VwjqkJu7bVLqInzAiHUR44cYUWo7XY71tbWGr4eDAbhcrn6Qh/scDgErVD3Iilii9HRUaytrSGfz/f95/V6vYIEGpGQodnZWYyOjvbszoZWqxWsQi2G6uXExAQ2NjZ22URGo1FOBSAukMlku8YrvV7ftI/htddew/T0dO2+JZVQNlVRttgp+UCd7OPd7373ruMTiUSteXEvoL5CXS6XEYlEGBsRNJJ8lMvlvkxJBNsKdZX0fhvAzm/pbwC8C8A7AVgB/G8Az509d/4Aw9eZHiMqqFQqTno5lUoFm80Gn8+HYDAIi8XCG/GrJ6pCgniutkOoSXOQz+dj3UBF4sfpPmelUkE4HIbb7e66npEP2Gw2JJNJ3nWfnWpSEgM8Hg/W1tb2hHUeSR3lezFJwl2uX7+OiYmJnt3ZEIpQJxKJjhHWZiBpiTvv9Xg83rHzoyvmGI3GpoT6ypUrOHXqVO3/KYrCgQMHBNNRk/AvOkL98ssv0xYw9lqF2mw215x9kskkhoaGGC+km0k+isXigFAD+BKAWwBeJz84e+68GcCHAPzBpYsX5i9dvLB56eKFvwRwE8CTrV5n8h68f2qeYDBw18sR6zy/3w+z2cybFpEQaqG3tonnKlcyRgh1oVBAIBDA8PAwKwLgcrkQjUZpP2c8HodUKhVFtYgPEELNNxncS4R6bGyMtmrXj1hcXITdbudd30zuw5s3b2J8fLxnG36FItTJZFIUhHpsbKy2G1OPToY4yeVy1vHj9Q2JBELqqInccqc0ym63w+Fw4Pr167S/0y/zChNotVrkcjnk83lWcg+0qFBns9m+C3UBG0J99tz5twH4MIAndrx0siodubzj568CeAuD15m8h+gglUphbmPwJNZ5S0tLvBPqzc3NppZyfKBdz1VC/NPpNGKxGJxOJ6tqMokfpyPU/eRBjSqRicfjglSo9Xp9Xw5sOzE+Po6NjQ3aSOZ+A/Gg5pvwWq1WpNNpLCwswOPx9GylrpG2sx2Uy2Wk02lRkC2S5FefmFupVDpaQWcbP55IJBAMBjE1NbXt50I6fdDJPQhIyMtO7DXbPOI/H4/HORFqYrxQj1Kp1LeEmlFp6uy580NVqcfvX7p4IXT23Pn6l+3V/+70MNsA4GTwOpP3aIjoehjlUnfE7WqVEhthblZcI2435m/exNCQGlqtDplkHJVC+4SpXMghlUxiNRTk5f0aIej3QSmXI76xxolUl3JbSCaTuDF7DWazGaV8jtV3qVEpEdnYQMjvg9G4fYB7Y+4aLBYzMunkrvcsFgucr1m3UCkUkEgksLEahkHDX9UxHArhyOH7RP998HHNNEo5VldXEV1fxYauNyurTHH3zh08/PA7kEnGUc7zt6shRRnRaBR+vx9WswmbiTjymd0VKIj8OVMq5IhubPB6fslkEmqVCtnNtCg+t91ux93bt3Dk4H4AQCqVglKpQH4r0/D8+LxmmVQSyVgMCsV/FTXkUgli0SjSid0NoS+98AKOHDmM7Ob2+2nY5cT/f/s27e+0i6WFe7BZrbTvffL4MXzlL/8K/99vfnjbz+PxOGQUBDkfLiiVS4Kfi0GvR9DvQ9Dvh0GvY/X3ZDIZNlbDtYJhvlDAWiiIVCqNrXSqLUlmoVDERnilK8Tc6nTT/pzpXu+XAMxfunjheyz+JgWgmUim1euMjjHb+LGb44KN8ErDL7YVTt1/P372f/8vdDodDh66D86RUV4qqpRcic1MBlq9kfO5MUG+WILRbIbdPcLpoTDZHMhkMliPxuByuWC22Vmd78HDR5BKpzGkN+z6vVgyDafTBYdreNdr7VyzbkKj0aAEitdzT6XTcLrcov8++LhmFofrTd2eRCb6z9suwqurmNy3Hy7PGK+NyZMHDmFpaQkGgwFO9zBcntGGx4r5ObNYbSiWy7ye32auAJ1eD4vdIYrPPTIygngyBYvDBYqisJnzwmAwNh1n+bxmap0BqxuRbX0xruERpNJpaA27q/g35m/iwQffsuu16ZljCAQCUGn4b56OJZIY8Xhoz+f0Aw8ikUgguZmB2/3md1IqlbC5uQnXiEc0Mrl0Ik57/nzCYrUiVyhic2sLDqeL1d/TarWAVFb7nUKhAIPZijIlRUXS3tiUz+dhdbpFVelueSZVqcdv0Eg9CMLV/9p2/Nxefa3V60zeo+8wPT2NQCBQ86Dm6wE1GAxIp9OCBBfUIx6PQ6fTcV5hSqVSaDQavPHGG5wcCRwOB2KxGO0Wvs/n65tQF4L6UA2+EI/HWW3h9TJIuAtdJHO/YWVlBcPDw7y7/FgsFmQymZ5uSER1kudbS59IJERlQenxeLCysoJCoQBUHT50Ol3HnFno4sebST7o9NOoNvA7HA4sLy/zfo7NJB9SqRRnzpzZJvtIpVJQq9WiIdOdAnH6YCv5AI2OmqIoFIvFvrUvZULtf6tqY3fj7LnzG2fPnd8AcAbA02fPnX8NwFUAeQBv3fF7DwF4kcHrYHhMX2H//v2IRCI1Y3m+3ChkMhlUKpXgaYmxWKztEAO9Xo/5+XnY7XbWASx2ux2xWKw2YdTD6/UK0pTVTZjN5qZBNlwQi8X2DKFG1Rmm39MS4/E4yuWyIM1nxC5rYmKiZy3zAECn0/GuoSZN2mIh1GNjYwiHw7XxsdOe83Tx4xqNBrlcbteYHYvFsLq6ivvuu4/2vYRqTNwZ6rITO1MT95rDBwEh1BsbG7wQ6lKptKcJ9ScB7AdwvO7fFQB/B+DcpYsXEgC+BeDPz547P3X23Hnt2XPn/yeAMQB/0+p1AGByTL9BLpfD5XIhEonwlpJIoNfrt6UbCQFSoW4HBoMBt2/fhsPhYF1NHhoagkwmow1o8Pl8cDgcopnc+IDNZuOVUJfLZSSTScaeov2AkZERhEIhwS0luwniQS1EQ65KpYJarcbY2FhPL1b1ej3vzant2ojyjfHx8VrWAepSEju1EKKLH6coirZKffXqVRw/frxh5Vco67xmFWoAeMtb3oLZ2dnavbJXCbXRaKxVqNku1Pdahbrl3sWlixdiALaxs7PnzucAJC9dvEDkGP8DwJcB/AcAHYBrAH7l0sULXoavMz2mrzA2NlZzWuATBoNhW4e3EOCj29loNOLVV19l7UFNYLVaacNdQqEQhoeH+2przmazIRLZ2bPLHclkEmq1mtP33qvweDwIh8PI5/M9TQibYWlpSTBCjeozOzIy0tPEQqvVYmtrC5VKhbedwXZtRPnG5OQkNjY2sLm5CZvNhmg0Co1G01HnI5lMtsvhwWAwIJFIbKt0NpJ7EOzfvx8//vGPeT+/VhVqrVaLw4cP49VXX8XDDz+85yzzCEwmE27dusVrhVro4LlugdPTf+nihV/a8f85AL9f/Ud3fNPXmR7Tb5icnITf7+d9ECYrSiHBhwWTyWRCsVhk7UFNQBc/Tsz6SSNJv8But9e28/lowiAxxP1iLcgE4+PjuHTpEnK5XF8TaiHlTn/8x3+MgwcP9nR/AiHU5XKZt0mdVKjFQhJIhZr00hDJRyfPTyqV0qYl7qxQX7lyBY8++mjD9xFC8rG1tYWtra2WO3RE9kEIdS8vJLmCbw11PxNq8bRH7kEcPHiQ15REApPJRCuFYIJCoYClpaWWKUaJRKJtuQBZ7XNNNKSLH49Go5DL5X1XSSBNmHxtlZEmpb1EqPdCuMvi4iJsNptghPcDH/gAVCpVT983Op0O2WwW5TJ/dqukQi0WkjAyMoL19fVaHgF53jtZQaf7W6RCTbCxsYFIJIIDBxoHIrtcLmxubjZNWWSLcDgMh8PRsjjx9re/HS+++CIqlYpoouU7DbPZjLW1NaTTadYLCrpwF6EzMrqJAaHuIh599FF84AMf4L2a1CritRlyuRy8Xi/eeOONhlpTvkIMTCYTLBbLrqQqpnA6nVhbW9tG/gOBAOx2u2i2XvmC3W5HMpnkjVATTeVeknzshXCX5eVlOJ1OwSrUKpUKUqmUN6lEN6DVapHNZnnV0rcbdMU3VCoVdDodwuE3VZkbGxvQ6XQdtRijG4N3VqivXr2KEydONP3eJBIJ9u3bx2uVupXcg2BsbAxKpRJ37tzZsxVqo9GIpaUlmEwm1ve3RqPZRagLhQKvi1kxYUCou4gDBw7gwQcf5L2aZDKZOEfrbm1tQalUIpPJ4Nq1a7Rx1+l0Gkqlsm0yZjKZ2tJ70sWP+/1+2O120TQH8QW73Y5EIkHrasIF0WhUVDZfnYDH48Ha2hpv36EY4fP5MDIyIljzmUwm62m5B3ZIPvgCWaCKaaHhcrkQCASAOlemTp5fMw01QSv9NAHfiYmhUKhpQ2I93va2t+H555/fs4TaZDJha2uLkyMUXYU6l8uJ6jnhEwNC3UUQayG+SY3ZbOZMqAOBQK1Du1Kp4Nq1a7vkI8Tho91tX7PZzMmDmsDpdCIej28j1F6vF1arlbUNn9hhs9mQTCZ58xcnhLrfKvnNYDabUaimTvYrgsGgIB7UBDKZrOedYYgPNd+Sj3Zdj/jG8PAwVlZWUKlUEIvFOk4GG8WP1z9/V69eZUSo+dZRt3L4qMfb3vY2vPjii3uWUOt0OkilUt4IdaFQEM1ODt8YEOouQ4jOa5PJhHQ6zWlL85FHHsEXvvAFZLNZUBQFuVyOmzdvIhQK1Y5JJBLQ6XRtLwQee+wxfOhDH+Jc8XK5XIjFYts0WV6vFxaLpe+azqxWKxKJxIBQt4F+D3fZ2tpCKpXi3YazHkqlEsPDw4K9fyeg0+mwtbXF606FGAl1fbhLJBJpu4mcLVQq1a45yGAw1CQfa2trSCQS2L9/f8v34ts6j6nkAwBOnjyJpaUlLC8v70lCLZFIYDQaORPqnZ7v/dqQiAGh7j7MZjPvpIYroSYDbz6fx+OPP15z0FAoFPB6vbh3716tOYMPz9WRkRHs37+fM6F2Op1IJBLbZCk+nw82m63vtME2mw3xeJw3Qr2xsQG9Xr+nCDWqi7B+DXfx+XwdkTv1+nYtkXzw6YXLh40o35iYmMDq6iry+Tzi8XjHdxaUSuUuyUe9hvrKlSs4efIkI133/v37sbi4yJvunY3kQy6X4/7778fCwoLornGnYDKZOIVF0VWo+bSrFBsGhLrLmJyc5P09jUYjNjc3WQ8+4XAYJpMJX/rSl/DLv/zL+MhHPoJr164B1UElEong+vXriEQivOlvSbIjFxDni3pC7ff74XK5+k4brNFoUCqVOEt5doL4n3eySUkMGBkZQTAY7MumGK/X23eBRkKASD74rFCL0aN4fHwc6+vryGQyiMfjgqRnNgNd/Hi9hpqpfhrVa2Y0GnnbXWIj+UDV7QN1zlR7DcRAgC3oCHUr+Hw+LCwssP5bYsDemk1FCCFWalwJ9crKCmw2GyiKwkc/+lH8yZ/8CT796U/jRz/6EVAlv9lsFrOzs1Cr1bxs2wwNDXGWvDgcDkSj0W1VW6E1pN0CRVEwm828hbt0Q1MpBoyOjmJ1dbUvGxMXFxfhcDj6bneGbwwNDSGXy/G22wOefPn5xsTEBNbX15FKpbC5udnx86OLH68n1Ez10wR8NSYWi0VEIhHY7XbGv3PmzBlIpdI9OWYCwPT0NCNpzk7QEepWQXY//vGP8Vd/9Ves/5YYMCDUfQgi+WBLGlZWVmCxWGrVuzNnzuBb3/oWfvCDH+CLX/xirZkgnU7zpr+1WCycFxU6na4WoY3qVlI4HMbIyEjb5yVGWCyWXUE2XBGJRPZktWVsbGxb4EU/YWlpSVAP6n6BRCKBWq3mNfwqmUyKjlCTe31jY6Mrseh08eNE8hEKhbC1tcVqh5avxsS1tTVYLBZW85fFYsGPfvSjvuvNYYqPf/zjrBY/BHSEutV87/f78eqrr9YsH3sJA0LdhzAajUin06wN1FdWVmqTAiHjo6Oj+Pa3v41IJIInn3wSGxsbNYN3PqrA7TQ4URQFq9WK9fV1oEoSlUql6JqD+ILFYsHGxgYv7xWLxURHADqBfg53IbHj/eZwIwQ0Gs2uxD6uyGazqFQqnP30hQLpMQmHw9Dr9V0J49lJWklT4pUrV3Dq1ClWxRS+CDWbhsR6MCnUlMvlvpSTcQUh1K2C4urh9/tx7Ngx/Mu//Iug5yYEBoS6D2E0GpFKpVgTar/fD7PZjMOHD8Ptdtd+X6vV4qtf/SoeeOCBmq660yEBjVBftfX7/XA4HH3baOdwOHgj1NFotOOaSjGA6Er7MdzF6/VieHh4oKFmAD4JdSKRgF6vF933LpVKYbfbcevWLV5cmbieQz00Gg2y2SxeeeUVnDp1itV78SX5YNOQyBaFQqEv5WRcoVAoIJFIGO8IlstlBINBfOxjH8NPfvKTnlucdJ8RDcA79Ho9MpkMa9IQDAZhsVigUCgwOjqKw4cPo1gsolKpQCKR4IknnsCnPvUpzM3NwWAwiKJT1+Fw1Ah1IBCAzWYT3cTGF6xWKy8aauLUwqXJpNdBIpl7RfJx+/Zt2nAlOgQCUL8hvgAAIABJREFUAQwPD/ftgpJPaLVa3hp8+XI9EgIulwu3bt2CVqsVLOynGXbeixRFQa/X44UXXmAtIfB4PLUmy3bAtiGRDSiKEkWhSUxg05i4vr4OrVaLkydPQqVS4bXXXhP8/PjE4Mr3ISQSCTQaza5AllYIBoOw2+21rUGj0YgTJ05AIpHULKbe+c534kc/+hEeeeQRQc6dLZxOZ03yQUJd+lVD6nA4kEgk2raO2traAkVRfSuNaYZeCneJx+OIRCK4c+dOy2OLxSLW1tb6tn+Ab+h0OtbuA42QSCREmzo6MjKCO3fudO38GsWPq9VqjI2NsX6viYmJth0guEo+mEAmk3Vl4SJm0MWPN4Lf74fH4wFFUXjf+96Hn/zkJ4KfH58YEOo+hdFoRDQaZfU7ZCusvvKsUChw/PhxGAyGmgTEZrOJRqfpdDoRiURQKpX6NiWRgMSPt+ufSxw+uqGp7DZIuIvYvagrlQoWFhagVCqxubnZskEnGAzCbDb37b3PN+gCJ7iCVKjF+DyNjY3h7t270Gg0Xdm5aBQ/fvr0aU47nHwEvAgp+WjHBrZfwaZCHQgE4PF4AADnzp3Df/7nf/K28O0EBoS6T2EwGFh3sYfDYbjd7l0/l0gkuO+++zA2NlYj1WKxpSNpicVisRbq0q8VArvdjmQy2TahjkajXWtSEgPcbjcCgUC3T6MpgsEgfD4f/u3f/g0KhQLLy8tNr7vX64XT6RzIPRhCiAq1GJ8n0jNA4qM7Dbr4cbPZzMkxAjzpqIWUfCgUilpmwABvgi2hJrtsJpMJp0+fxk9/+lOBz5A/DAh1n8JoNLIi1LlcDul0ummjmtvtxvT0NIrFoij006gj1IVCAX6/H06nU5QTGx+w2WxIJBKsm013gsSO9+vCoxWGh4exsrLCqvO8kygWi/D7/fiLv/gLfO5zn8P8/DwkEklTIrG0tAS73T6ojjGETqfjzeklHo9jaGhINEWGekxMTADVbfduLLboCPVnP/tZvOc97+H0fu06fZTLZayurgom+ZDL5TAajT3VmMi3J/tOsNkNIpIPgve9733453/+Z8HOjW8MCHWfwmg0stJQh0IhWK3Wljo7nU6HkydPCrbCZwtiDZXL5Wqr235tCiGEmmmTWiNEo1HodLo9S6jHx8cRDoc5T3pCE/F79+7h5z//OdbW1vCZz3wGX/jCF1CpVBCLxRo+04RQi826Tazgm1BrNBpREurx8XGgWhXuRhFEoVDsel5MJhNnck8INddnMBqNQq1WC+InXSqVMDQ0BI1G0zNzUD6fx4EDBwQ9XzYV6p2E+qGHHkIwGMTy8rJg58cneuOqD8AaJpOJlS3UysoKI0KN6ipcLJZrdrsd8XgcmUwGq6urtJKVfoHVaq0tHtoBqVDvVXnA6Ogo1tfXOVX6i8Uibty4Ich5AUA6nUYwGMSzzz6Lp59+Gu9973thtVrxne98B0qlEnfv3qW1kiKEeqChZgY+CXUikRBthXp0dBSo2ot2A3Tx4+3AZDJBoVBwDrgSUu5RLBZrCysxNqjuRD6fh8fjgc1mE3RXlymhrlQq2yQfqGrSz5071zPNiQNC3acwm82sbKFCoRDMZnPPJUGR+PFQKIShoaGWsaa9DHJN+apQ71VC3U64y+bmJjY2Nlg3/DLF3bt38b3vfQ/Hjx+vNW595jOfwfe//30sLy+jXC7TVmuWl5fhdrt7YiIXA7RaLW+EOhaLQavVikYGVw+TyQSVStW1VFS6+PF2sX//fs6yDyEdPlCVuAAQ/e5foVCA3W6vkVchxw2mhDoajUIul+9yn3rve9+L5557ru3eoU5gQKj7FGwr1MQloNcItclkwtbWFhYWFrZZ/vUjpFIpdDpd2+Eue71CPTY2xtnPlmzvLy4u8i79CIfDuH37Ni5cuIBPfOITwP9r797D5KjLfIF/q++X6unq68wkc8lccyGLcnGFVfC2DdoBtIUcPLhrjnLwqAu4qCgSL+uuSpaLgHh03ZV1dc/Kc1ToPRF6hVZXUZEFEhJIQgiBXGcyk7l098wkM9O3On9Q1fb09KWqu6svVe/neXx8mKqZVE1Nd7/11vt7X6HFoc/nww033ICvfvWr0Ol0mJycXHXs4up4rV5TuRwOR92G+8Tj8ZZtQckwDPr7+9HZ2dmUf7/Y+PFa1dLpQ8kOHwzD5AJTq9XaskNJ0uk0Ojo6Vox9V/JzU2rbvMJyD9Hg4CC6urrw9NNPK3SE9UMBtUq5XC4sLCxIflGfPHkSbre75e+sC+l0Orjdbuzbt0/VHT5EHo8n13e7WjMzM+jo6GibOr96EwdEVFM6c9ttt2Hv3r3IZDJ17RQitn2877778JGPfAQ+nw/JZBLDw8PQ6/XYunUrMpkMHn74YRiNRhw6dCgX0PM8j/Hx8aIfRqQ4lmWxtLRUl6CnlQNqAPjpT3+6InhqtHrf5NXS6UPplnnie2qrLkzMZrMwm83YsGHDiicHxRaP1ovUDHV+y7xCV155ZVssTtTmJ6oGcByHM2fOSH6R5E9JbDc+nw8vvviiqoe6iLxeL06fPl3Tz5iZmYHT6azbMbUbl8uFVCole/Q0z/N49NFHsWPHDkBYd1Cvx5BHjhzBr371K0xPT+Paa68Fz/Ow2+3o6urC6OgoMpkMvvCFL+Af/uEfMDk5icXFRZw6dQoQpotZLBZVlzvVW70D6lZ+PTV7IqoSGepqSz6UrKHOv3Go9QYrm83WvfMGz/NgGAabN29elUxxOByKlVTICahLDaa6/PLL8cwzz8geVtdoFFCrVDUBtd/vb8tHxn6/H/v27YPH41H9oiyfz1eXko9WDgCUxjAMurq6ZGeYjxw5AovFAp/Phx//+MdgGKbmqW0QyjqOHTuG+++/H5/73OdgMBiQSqUwOjoKCJPlfD4f+vv7ce2112LHjh0wGo04fvw4UqlUrge1msud6k2soa5HVi4ej7f0zUyzx6LX+zNlYGAAY2NjVQWcExMTitVQ5/+OTSZTTeedSqVgs9nqmjVOp9PYvHlz0eNS8nNTatu8UiUf4s+45JJL8B//8R8KHGH9UECtUi6XC2fOnJF816nkozCldXZ24tixY6qvoYYQUM/MzNT0M2ZnZ+Fyuep2TO2ou7tbdkD97LPPYnR0FJ/5zGfw4IMP5kaD17q47ZVXXsEPf/hDnH/++Tj//PORSqXQ1dW1oqf04OAgdDodPvzhD2N8fByPP/449Ho9Dh06hKNHj6Kzs1P15U71JNZQ1yNDPTc319KvJ7PZ3NQnd/UOqE0mE9auXYsjR47I/l4lFyUWfvbU0hOeYRicc845dVunkUwmsXnz5pLHZDKZFCsBlJqhLhdQQ+hJ3erdPiigVimO47CwsCC5jmtiYgJr165V/LiU0N3djWw2q4ksXWdnJ2KxWE1vtLOzs01/DNxsvb29soe7iAF1X18frrzySnzrW9+CyWTCoUOHqj6OmZkZ7N+/Hzt37swtRDQYDOjv71+xn06nw+joKHiexxe/+EXce++9mJubw9zcHPbv3w+fz0c9qGVgWRaLi4t1yQAmEommddGQwmQyKdrZopJi48drVU3Zx8LCAjKZjCJP58Qe1PnMZnPV522z2WA0GtHT01NzLXYymcTo6GjZ9wedTleXG59ir6d6lHwAwAUXXICFhQUcPHiw5uNUCgXUKsVxHObn5yW9GM+ePYulpaWW6S0tl/hh0dfX15Ktq+rJ7/cjkUjUFAgkEgnNB9R9fX04deqUrLrBPXv2YGRkBMvLy7j++uvxhz/8Afv378fi4mJVC0Wz2SxeffVV3Hfffbj++uvh9XqxvLyMoaGhotkip9MJj8eDTZs24bLLLsM999wDk8mE/fv3Uw9qmeoVUGezWZw9e7alM9QMwzS1lE+JBW/VBNTiU1glPiPEHtT5Ojo6qqpL5nk+91pes2ZNTUmiVCqF7u5uSe/3tZYFZbPZoqUdUgJq8TOt3I2pTqfDli1bWnpxIgXUKiUG1FKGV4hTEts1uyuWqrRrhl0OMaCudgFJKpXC4uIi3G533Y+tnYi9qOUMd3nppZcwNDSETZs2wWw248Ybb8Sdd94Jg8GQ6xEtx/Hjx/HEE09gdnYWW7duRTabBcdxZYOz4eFhMAyDj3/849i7dy+eeuopTE5OYu3atW25oLhZxBrqWrN/c3Nzik3eUwslAupqOn00qge1yOl0VnXeyWQy9/7MMAyGhoaqGkKVzWZhsVhWPe0qpdbP/3Q6XfQ9SEoNtVjuUelm58orr8Tjjz9e1e+jESigVimWZZFMJiUtBpA6drxVdXV1geM4TTzy9nq9mJubqzqgFlt8ab3eVuxFLbUXsTj2u6enBy6XC36/H5dddhkMBgN27tyJTCaD48ePS/pZYmb68OHDeOCBB3ILETOZDEZGRsp+r06nw8jICPR6PW6//XZ8/etfx7Fjx7B27dq2vSFuBrGGutaAml5PlRUbP16raoa7NKoHtchisVTV4YRhmBVlKRzHoaOjQ/YNeyaTwaZNmyRn5C0WS01rCnieL1qjbTabkU6ny77WyrXMy7dmzRqMjo7iySefrPo4lUQBtUoxDIOOjg5JE93Gx8fhdrvb9pHxhg0bcMkll7RlhxK5fD5fTePHxSmJWg+++vr6ZE1L3LVrF4aGhmCz2aDT6bBu3Tro9Xp89rOfxXe+8x0sLS1hYmKiYoC2sLCA559/HtPT0/jhD3+ICy+8EOeddx6SySR6enokXReO4+D1evGmN70JF154IY4fP049qGWyWq1IJpM1D3dJJBKw2+2afz2VU+/x4xDWkiSTSVkLtJVumVdYpqXT6aq60TKbzas+y0ZGRmQlUcTSMTlJslpb5+l0uqJPahiGqVj2Ual+Ol8r96SmgFrFnE6npDecdp2SKOrt7cVXvvKVtj1+OeoRUHd0dGg+o9bb24vTp09LHuP+7LPPYmRkJPd70+v1GBgYwODgIC699FJ897vfhV6vL/kYmud5HD16FC+++CJ4nsfx48exc+dO3HzzzeB5HmazWVbJ0tDQEBiGwS233IJQKNS26x+ahWEY2Gy2mvvaxuNxsCzbtk/3GkGJ8eMMw8iuo25khw9RNe+zxRJb4sJSKQFvOp2Gx+OBz+eT/e/WkqE2mUwln0ZUCqgrdfjI9853vhP79u2recCZEiigVjGn0ykpQy1OSWznDwWdTte2GXY5vF4v4vG45ECwkJih1npA7XK5kE6nkUgkJO2/e/fuVSvlfT4f7HY7PvGJT+Dxxx/Ha6+9hng8jvn5+RXfu7i4iOeffx6Tk5MwmUz49a9/jU984hO46aab4PV6c6vw5QQder0eQ0NDsFqt2L59e1u/dpuFZdmaA2oxQ62Fp2PVUmL8OKqoo1ay5KNUQG2322XVUadSqZJrKPr7+yu2tuN5Hnq9vmLpWDFms7mm1nkmk6lk2YiUgFpqhtpiseBd73pXS/akpoBaxVwul6QPjLGxsbZelAjhjUsLGWqr1QqDwVB1IBCLxcCyrOYDALnDXfbt24ehoaFVq9BHRkZgt9txww034M4774TRaMThw4fB8zx4nseJEyewZ88eZLNZLCws4Pbbb8cDDzyAHTt24H3vex8ymQy8Xm9V9f9utzt3Y6D1G6Rq2O122dMyC4kZaiUCRjVR4v3mwgsvlFVLq2TJR6nPTvH1KVU2my0ZUOt0OvT395ddkJdKpbBp06aqAmO9Xl/1dRKfspVagCql5ENO2dpVV12FvXv3VnWsSqKAWsU4jpP0gSFOSWznDwWXy6WZoMLtdlc9flzMUGs9oIawwGVsbKzifslkEkeOHMHw8PCq1lhWqxWdnZ246qqrMD8/j1/84hdYWlrCyZMnsXfvXpw8eTKXlf7ABz4Ar9eLH/3oR3jjG98ICB9EQ0NDVZ+DWFvZzMEd7crhcEjqj1tOIpGAzWaj11MFSny2XHrppTh+/Dhee+21ivsuLy9jbm5OkdKoYj2oRTabTdaTJ7FsohS/3w+r1Vq0rCKZTKK3t7emJ7XVPulKp9NwOBxVZajPnDmDs2fPyro2mzdvxt13313VsSqJAmoVc7vdkgLqdp6SKPJ4PG19QyCHx+OpKaCmDPXrent7JWWoDxw4gO7ubjgcjqJ/Y+vWrYPRaMStt96K+++/H5lMBidOnEA6ncbZs2exffv2XFb6U5/6VG4lfDKZxMDAQE1/t3q9Hhs3bmzp0detym63ryrPkSsej8Nms2nmvadaSrzfGAwGvPe978XDDz9ccd+JiQn4/X5FpgGWu6E1GAyynvxKeco6PDy8KkudzWbhcDgkl02UUu1T6kwmk1vsXuwGolxALS5IlHPjwTBMS86coIBaxcRe1JW085RELfL5fFUvyJiZmYHD4VBszGw76evrw8TERMVHss888wyGh4dLju3V6XQYGhrC5s2b8cY3vhH//M//DLPZjN/85jf4wAc+AI/HsyIrDSGYdjqd8Pv9NZ+H2+2uacyxVnV0dEhqK1pOIpGAw+FoyQ/3VqLUDXwoFMLPf/7zit1alCz3QIVAWOqT03Q6LWmKI8uycLvdK0orstksNmzYIPFoS6t2uqNOp4PFYina7QQVAmo5CxJbHaWpVMzlcmFiYqLsPuI4Vq0P+mgnPp9PVruofDMzMxgYGKj7MbWj/v5+7N+/H8lksuwH/nPPPYfR0dGyj1I9Hg9YlsXNN9+M6667DkePHsXhw4exY8eOFYF0NptFJpPBunXr2v6pULsTh7vUIhaL0XunBOL48XrfeHR1deHcc8/FE088gfe+970l91Oyw0exHtT5rFYrlpeXK557JpORPMF2eHgYu3btAoRylk2bNtXlpsXhcGBqakp2ptpgMOSe0hR7WmO32ytmqNWA0lQq5nK5sLCwULYVzqlTp+Dz+ahLQBvx+/2IxWJVfe/MzIykLIgWiNMSK7Ug3Lt3L4aHh8uOxYVQz+xyuXDjjTeip6cHDz300KqstNVqxQUXXEDBdAtwOBw1Z6jFwS6kPCWmJYquvvrqimUfje5BnY/jOEkDhAwGg+QnTQaDAWvWrMFSMpkbbFYPcruSiPKz8MUCe61kqCmgVjGO43DmzJmyL5Dx8XF4vV56ZNxGxIC6mkdzsVisbm++7U4c7lIuqOJ5HgcPHsTIyEjFThwWiwVdXV244oor8MlPfjL3mspms0in07mykHbupqMm9chQU0AtjZIB9cUXX4xYLIYDBw6U3EfJDHWlZJTD4ZD0Xm21WmVl8Ht6euB1u+r6xLHa1nlSAupS77NyWua1OknPCALB0J8A+DqAiwGYALwM4GvRSPjfhe1WAHcB2AqgA8B+AJ+NRsK/krJd6j5EHpfLlQuoS32Ij4+Pw+VyaaLlnFr4/f7c+HG5wdns7Cw9ohb09PTg9OnTZesvT5w4AZPJhM7OTkm/azHrLRJrpUdHR2khaIvp6OjAqVOnavoZiUSCnvhIoMT4cZFer8f73/9+PPLII9i0aVPRfZRceF/pdW0ymSouWs1ms7JbZzIMg/6+vrqW0eSXbkiVyWRWLMos9v2VFiVqJkMdCIZYAP8J4DCAAQA+AP8O4KeBYEj86/02gD8H8A4AXgAPAXgsEAyNSNwudR8iA8dxuRrpUtp9SqIWidMSqxkTG4vFJNfpqZ3L5UImkynb0/u5554ruyCxkLhAcXFxEZlMBqOjo3WrbyT1Va8MNXVYqUyJ8eP5rrrqKvzyl78sGbQ1owe1iGGYiu8fqVSqZaadyk3SpNPpFa8BOSUfS0tLiMfjdVmc3Qqk5PatAG4DsD0aCc9HI+FlAA8A0APYHAiG3AD+AsDnopHwgWgkfCYaCd8D4CUAH6u0Ha8H7RX3IfKJAXW5wGtsbAwej4ceQ7cRr9eLRCIhqS4vXzabRSKRaJk37mZjGAadnZ1le1HLDaghdN0YHh7GBRdcQDcvLYxl2YrdISqJx+P0xEcCJcaP5/N4PLjooovw2GOPrdqWyWQwNTWFzs7Ouv+75XpQ56vU6UOn07VML3m58xwYhlmRkLNYLKuSeKUC6rGxMaxZs0Y1bScrBtTRSHgqGgl/LxoJn8Xrwa8XwJcBnATwKwDnC6UjzxZ86zMALpKwHRL3ITKJAXW5yUri2HEKqNuHz+fD3NxcxcV0hebn52GxWDQxol2qtWvXlu1FvWvXLoyMjMiuO+/q6lLNh4RaiQF1taUIPM9jfn6+5GQ78kdKjR/PJy5OLLyeU1NTcDqdiiy8lzpUqaOjo2xiy2q1tkwrU7nlOXq9fkX8UKxevlRAraYFiZDbNi8QDC0LNdS7AASikfB0IBgSc/WFfbymAXQBqLQdEvcpanZqAtlM6S4WSkqnU5ieGG/Kvy1FemkRc3NzOD0+DiZTPJt57NhRvOn88zEzWVstYbto9WsmhS6bRiw2i8nxkyWvazHHjh+Hw+HA4sJ8W/0OlLxmfp8Xrx5+peTP3/fii7h261akFs9gekLeEwEta4fXGZ9OYWF+HqfHT1YV7OWy221wrlIofc0WzywACtVRA8D64SGk02n84Xe/w7nn/knu668dfgV+nw8LidKlXdVKplI4OxdHZrn8k47M8iISsRjMptWJK57n4XA4qvrdK3HNkktnkZidkVymptPrVhzD2bNnMZ+Iw5x3A8Nks5ifn191DV595RV0+qu7NqlUGtMT4025EfF2rSn6dVkBdTQSNgsZ6psBPBUIhspljxkA5V49lbZL2sftU2blrhTTE+Mlf7GtgOd58DwPnclU8jinpqYxODLS0udRT61+zaRw+7uwtLQMvcki61yOj0+A4zh0rlkLr8+n6DHWk5LXbHT9BkxMTMDl61wVVCUSCcTicWw85xx09/bT8A4Z2uF1tqa3D8lUCi5fZ1XZy4mJCTgcDvi617T8uUqh9DXjJqeqWvchx9atWxF5/HH82SWX5L6WmF/A2p4esM76dzdKJpPo7u2vGNRls1mMTRbv75xMJjE4MlrVkw4lrpmF7UAsMS+5zM1qta44BsfyMk6emlzx/TqjCWfOnFl1DU5PT2NwcKiqa5NMJuHtWtMymX1U0zYvGglPRyPhLwGYFOqbxckhhZ/QfmFbpe2QuA+RiWEYOJ3OklP1eJ7H5OQkTUlsMzqdDhzHyZ6WODs7C4fDIbtGTs36+vowNTVVtCxqz549GBwchM1mo2BahcSSj3J9+suJx+NgWZZ6+EvUiIW5W7Zswe9///sVffqV7vAhJaDT6XRl/05aqfWinNZ52Wx2VUMDo9G46vutVitSqdSqGyq1lXxI6fKxJRAMnQgEQ4WFQgyAtFD+kRRa6uX7MwC/l7AdEvchVXA6nZidnS26bX5+HgzDUF/iNuT1eitOwSwkBtTUceKP1q1bV3K4y3PPPYeRkRHq0a5SDocj142lGolEAizL0g2qRI143+no6MDb3/527Ny5M/c1JQNqOTdTpd5HzGZzS70nFwuIS0mlUqu63BSrl2cYpui0RDW1zIPEko+nhbrpBwLB0KcBLAL4XwCGATwSjYQTgWDoQQB3BIKhAwCOAfg0gH4A3660Ha9nvSvuQ6rDcVzJqXrj4+M0JbFNeTyeFf2OpZidnQXLsi315t1sPT09mJ6extmzZ1fdWD733HMYGhqitmgqJWaoqw2o4/E47HY7vZ4kUmr8eKGrr74a27dvx1/+5V9Cp9NhYmICb3vb2xT5t+Rce5vNhjNnzqwIVnmeb5nuHvlMJpPkJzfFjl+81oX7LSws5N5nU6kUpqenVTU1VkqXjxkAAaH84pBQ6nEdgFA0En5a2O0WAI8K/aqnALwbwGXRSPiYxO1S9yEycRyHRCJRdJs4JZF6ULcfv99fdUBN3Sf+qLe3t+RwlxdeeKGqDh+kPYgBtdz2kyIxQ02vJ2mUnJaY75xzzgHLsviv//ovQKh1V2pKopzuWMVGkKdSqZbsEiP1vHQ6XdEnNFJ6UY+Pj8Pv96vqhlTSmUQj4RcAXFFm+zKAvxb+J3u71H2IfC6XC3Nzc0W3jY+P01CXNuXz+UqW8pRCAfVqHMchk8mseoqTSqXw2muvYXR0lEo+VEoch1xtQB2Px2Gz2ej1JJEYUCsdQDEMg2uuuQYPP/wwLrroIsXGjkvtQS0qlsnleb4lA2qTyYSlpaWKTxNMJlPRfQwGw6rXVeH4cbXVT6OaRYmkvVQKqF0uFwUMbcjv95cs5SlldnaWxiQXYBgGXV1dq3pRHzx4EJ2dneA4jhYkqpQ4gKLUdL1KKEMtj5Ljxwtdfvnl2L17N1555RUYjUbZY72lkNqDWmQ0Gldlfk0mU0uWXLIsK+lpQqljl5KhPnnyJHp6emo80tZCAbXKlQuoaahL++rs7EQ8HpfVoWBmZoYC6iLWrl2LEydOrPhaNRMSSXsRF0qVGz1fjpihbqW2Xa1M6fHj+Ww2Gy6//HJ85zvfUbRGV+7T3cL3k1Z9OiwloOZ5vuT7Y7Ea7MKA+sSJExRQk/bicrkwPz9fdNvY2Bi8Xq+qapi0wuv1Yn5+Xtbj6tnZWaoHLqK3t3dVhnrXrl0YGhpSJLNFWketATX9fUin9PjxQldffTV++9vfKlY/zTCM7OyyxWLJZenT6XTLvh9LSSSk0+mS7f6kTEukkg/SdjiOw5kzZ4o+ahsbG0NnZ2dTjovUxufzIZFIyBqUMDs725L1es3W19eHycnJFRmV559/nhYkagDLsiWf4FUSj8dbqn9wq2vE+PF8w8PDeMMb3tD0HtT58hcmZjIZuN1uRY6tVkajseK1ymazNQXUamuZBwqo1c/lcmFhYaHo45uJiQka6tKmxIC62ECSUmZnZ+HxeBQ9rnbU39+Pqamp3Acdz/M4cOAA1q9fL2vREWk/Doej6hrqWCxGAbVMjX4aesstt+CKK0r2U6hJNbXPDocjl9wyGo0tW1LGMEzFUlCGYUr2YC/2u8nvQ51OpzExMYE1a9p/wmg+etavcmKGunB1Nc/zFFC3Ma//e7YNAAAc20lEQVTXi0QiUXQgSSnxeJwC6iLEgHp5eRlmsxljY2PQ6XRYs2YNLThTucLOA3IkEgnqUS6TXq9XfPx4vs2bNyv2s6u5OcifQmi1Wlt6wbPRaCybsCmXxS5WL8+yLMbGxgAAk5OTcLvdqhuKRBlqleM4rmiGOh6Pw2Qy0SK1NuX1ehGPx7G0tCRpf3HEMl3v1Xp6ejAzM4OzZ88CAHbv3o2RkZGWXTBE6qfwMbQc8XicXk8yqWm9TjWL+RmGyXWXafX6+0oZ+HLBsF6vX1UOk/9aU2P9NCigVj8xoC5cvEZTEtubyWSCxWLB1NSUpP1jsRicTicFiUUUDncRJyTS70r9Ojo6cjdSciUSCQqoZVJLQC23B3U+i8WCVCrV8k8LbTZb2U4flWKHwmud/zRIjS3zQAG1+nEcV7QbxPj4ODweD9WItjGPx4PJyUlJ+87OzqKjo0N1j9jqQRzuIg7KETt80AJO9au15IP+RuQxGo2Se1FXO3CnEeT2oM4nZqZbPUPtcDhKludkMpmK51+YwS/MUFNATdqOGFAXlgbQlMT25/P5ZAXUDoeDnkgUwTAMuru7c63z9u/fj40bN7b8Bx6pncPhqCpDnclksLi42LJdGlqVWO5QiZzF1s1S7Wcnx3EN7cldLavVWvLmJ51OV1w/UCxDTSUfpK2ZzWYYDIZVvVbFKYkUYLUvr9eLmZkZSfuKATUN8SluzZo1OHbsGObn5zE5OYmBgQHVPJ4mpbEsmyv1kWNubg42m63qLKVWFWunVojnebAsC47jGjZZUa5qelCLbDYb+vr66n5M9WYymcouyq50Q1Gp5IMCatKWnE7nqlpbcUoiBdTty+/3yw6oKUgsrq+vD+Pj43jhhRcwODhIgZJGVJuhTiQScDgcVEIlk5Tx48lkEkNDQ/B4PC1b9lFND2qRTqdTbNhMPZVrnWcwGComZ4xG44re/mKGOpvNYmxsjEo+SHtyOp25+lDR2NgYfD4fjc1tY36/H7FYTNK+09PTsNvt1AauhL6+PkxMTORGjlMplDZUm6GOx+Ow2+30xEemSqUO2WwWLpcLNputpYcqaSURVeo8pZy/1WpdEVDbbDYsLi5icnISDodDle+xFE1pAMdxq0o+Tp06RVMS25zP50M8Hpf0WPTYsWPgOI4C6hLEXtTPPPMMBgYGaLGZRogBtdzSgkQiAZZlNRNY1Uul8ePpdBpDQ0OAEHw36glAOp2W9TeglSd9pW4YpfzdF9bL63Q6WK1WvPzyy6rMToMCam1wuVxIJBIrvjY+Pq66KUVa4/f7MTc3V7EmMZvN4ujRo7SAqoy+vj5MTU1h79692LBhA03A0wgxoM7PpEkRj8fBsizdoMpUbvx4JpOB3+9fEazZbLaG1FFns1lZCyG18mSiWM17NpuVlF22WCyrrh3LsnjppZdUWT8NCqi1oTCg5nkep0+fVu0ftVaI0xIrTR7bvXs3fve73+Ed73hHw46t3fT29mJychKHDx/G+vXrKfOoEQ6Ho+qA2mazUUBdhVLZXZ7nsW7duhVfa1QdNcuyklvI1tKDut2wLLvq8yWVSkmaEFpqWuLBgwcpQ03aV2FAPTMzA6vVSlm4Nufz+SoG1NlsFt/4xjewZcuWtlgI0yw9PT04fvw4fD5fyw9cIPXDsiyWlpYktXLLJ5Z8UEAtX7HfWSqVQnd396ptjaijzmazsNvtWLduHZaXlyvuX0sP6nZT7Dx5npd0/qWmJR48eFC1yTwKqDXA5XJhfn4+99/ilESLxdLU4yK1EQPqch8Ce/bswWOPPYZt27bRAtQyOI6DzWbDyMgIvS40hGVZnD17tqoMtd1up9dUFYplqPV6fdGspdFoVPxpUSqVgsvlyr0HSKHGBXXFmEymVVlmg8EgqbadYZhVN0gsy2JmZoYCatK+OI5bMQ2MpiSqg9frRTweLxlQZ7NZ3H333diyZQs4jpP0mE6rGIZBV1cXRkZGaJy0hlQbUIsZaiJfYUCdTCbR29tb8ubEbrcrWkfNMEzuaa2ULHUtPajbjU6nW1UvXizILqVYL2oITwTViAJqDXC5XFhYWMi9KYlDXSgT194cDgdSqdSqBaeiF154AY8++ii2bdsGqPhNrF42bNiADRs20I2Hhog11HIn88ViMc089q+3wvHjJpOpbMcppeuojUZjLvCTkqWupQd1Oyq8eZBzM1EsoHY6naotN9XOX4WGiRlqsU5QHDuulZXKasUwDNxuN8bHx1dt43ked911F6644go4nc6i9YlkpYceegjnnXce3WhqiJihlhtQJxIJuvGqUn47teXlZQwMDJTNeCo9MbHw9d7f3182S62V7LQoP07geV5WK8PCgNput6u23AMUUGsDx3GYn5/PvYmNjY3B4/FQQK0CXq8Xp0+fXvX1F154AT/72c+wbdu2kvWJZCWz2Qyr1Sr5cSZpf+Lkvvw1JlLEYjHVZtmUJrZi43keNputYjtPJftRiwsS84mDZUrRSg9qkcViyZVEpdNpWX/3hU8jWJalgJq0N47jsLCwsCKg9vl8FDiogN/vXzVWnud53HnnnSuy01p6RFktk8kEv9/f7MMgDcQwDFiWXTX4qpJEIkG19lUSb2LEEeNSKFVHLS5ILNTf31/yqYXWElEOhyPXSSqbzcoKqAv7WL/97W/HNddco8hxtgJt3WpplBhQiy+K8fFxmpKoEl6vFzMzMyu+tm/fPvzsZz/DT37yE+j1ehrgIxHDMBgYGGj2YZAGs9vtVQXUVPJRHbE/sZxaWrfbjVgsVvdyi/wFifnENUaFi1W11INaZLPZcr8HhmFklcSJAbWY1R8cHFTsOFsBpa00QFyUKC7sOHXqFNauXdvswyJ14Pf7EYvFcv/N8zx27NiBLVu2wOl0Yu3atZSdJqQMlmUxNzcn63sSiURDeiSrkcFgkJWdhvAZpkSG2mQylVxbUixLraUe1CKz2Zz7DDEajbI+T8xmc0MmXbYK+qTVAKfTiYWFhdxEsKmpKQqoVaIwoN6/f/+K2unu7u6mHh8hrY5lWSwsLEjen+d5JBIJGgBUJZ1Oh40bN8rKdCpVR12un7Tb7S56jFrpQS3S6/W5DLPca1BsWqKaUUCtAQaDARaLBVNTU5iamoLD4aAFNSohDnfheX5Vdrqnp0dTb2aEVMPhcMgKqBcXF6HT6aiGugbVlBzWu446k8lUzDb39fWtyFJrqQd1PrFuXO65ay2gphpqjXA6nZiengaEulut3WWrVf748UOHDmHnzp348Y9/DKPRSKPGCZFAbJ0nVSKRgMPhoPaKDVbvOupUKlWxw4jH41lRtqC1HtQik8mE+fl52eUuDMNoqiuK9v4yNIrjOMzOzuZ6UFNArQ5erzcXUN9xxx257HRvb6+mMgOEVEtuhjoej4NlWcVauZHi6l1HrdPpJC0wzK+l1mJ2GkKpRyqVqmohrpYCau2cqcZxHId4PI65ubmStWGk/YgZ6n379uWy09T+jRDpHA6H7Aw1y7Kaa5/WbPWuozabzZKGXeVnqbUUHOZjWRaZTKaqRJy4CFULKEOtES6XC3NzczQlUWV8Ph/i8TjuueceBINByk4TIpPcgDoej8Nut2s2uGqmerask5NUEmuptfq5ybIsUGUPbi1N6KWAWiM4jkMikcD4+Dg8Hg99GKiE2+3G/Pw8IpEItm3bBpPJBJ/P1+zDIqRtsCyLxcVFyfuLGWotBQqtwu121yXbmclkZC3M93q9MBgMmutBLTKbzVW3CyyclqhmFFBrhJihHhsbo3IAFTEYDHA4HHjPe94DjuPQ399P2WlCZJAbUMfjcdhsNgqom8DtdtclOCs1IbGcwcFBzQ7zMRgMVbfaLTYgp5LFxcW2DMIpTakRLpcLJ0+exNjYGE1JVJnrrrsOl19+OSwWC7xeb7MPh5C2Um2GWovdHpqtXnXUer1edrZZ633Hq51pIE5LlHoDyvN8rvNOuy38pXcEjRCnJdKURPW544474HA40N/f3+xDIaTtVFNDLdaUksarR9lF/vQ/oiy5GepUKoWenh74/X6k02lFj63e6C9KI8Qa6tnZWaxZs6bZh0PqyGg0gmXZij1VCSGriRlqqR/6YoaaNEc96qipy1XjyB3uwvM8nE4nBgcH2+6mp72OllSN4zicOHECHR0dmq0DUyuz2Yxzzjmn2YdBSFuSG1BThrq5au1HnU6n6TOwgeQG1GazGUajETqdDsPDw23Vco8Cao3gOA7Hjh2jKYkqJHVAASFkNYfDgcXFRWQyGUn7x2IxWR0iSH2ZTKaaamszmYzsBYmkejqdTtYC3vz4xOVygeM4ya/NZpO0KDEQDHUC+HsA7wZgBbAfwO3RSPjXwnYrgLsAbAXQIWz/bDQS/pWU7VL3IdXjOA5nz56Fy+WigJoQQgTVZKgpw9lcNptNVt17Pp1OR5+BDWYwGCQ9VUilUqsWP46MjGDXrl0KHl39SM1Q/z8AnQDeKPz/bwA8GgiGxGLcbwP4cwDvAOAF8BCAxwLB0IjE7VL3IVUS78g9Ho9mx6cSQkghMaCWmgWLx+NwOp2KHxcpze12I5VKVfW9FouFWos2mNS5F5lMZtVaIIPBgIGBgbYo/ah4loFgSMwW3xWNhCeEr/09gNsAXBQIhn4N4C8AXBONhA8I33ZPIBj6IICPBYKhr5XbDuDTgWDIXWkfxX4DGsFxHCC8EVFATQghr2NZFmfOnJEcoM3NzVFA3WQulwuvvvpqVd9LCxIbz2AwSHp9GY3GotfH7/fj9OnTWFxcbOmFihUD6mgkPAfg+oIvDwr/Pw7gfOHnPFuwzzMALpKwHRL3ITXo6OgAwzBwu90t/QdJCCGNJGaoFxcXJdXWxuNxqsFtsmrrqFOpFN0MNYHUDHW5tUCjo6PYvXt3S8cvsge7CBnr7wN4LBoJPx0Ihq4TNs0U7DoNoAuAv8J2SNynqNmpCWQz8qbw1Es6ncL0xHhT/u1qsKwdbo5rq2Out3a7ZoSuWTtqt2vGMAzGThyDqcJndTqdxtLSEvQM2ur8pGi3a5ZeXsLS0pKs71lOJZFZ9rfVeZbTLtds6cw85mKzZYPhTCYDr9dT9nw6bFaMT5yC0WBEKpXG9MR4UwJsb1fx1sOyAupAMNQP4FEApwH89wq7MwDKVaFX2i5pH7evbLytqOmJ8ZK/2FbEcS70Dwy01THXW7tdM0LXrB212zVjWRZZ6Coe8+zsLOx2O9b09LbV+UnRbtcsDR2OHj0Ko9Eo+Xss6TTW9g+opoa6Xa5ZVmfAmaVk2XLT5eVlDI1ugN1uL7mPp7MbySyPdDqNVCoFb9ealspYSz6SQDD0JqEE4/cA3h2NhOeFTRPC//sKvsUvbKu0XcrPIHXw4IMP4txzz232YRBCSEux2+1IJBIV9xOHulCXiOZzu92yJvCBFiQ2jdVqrXitpIyDZxgG69evr3pBqtIkBdSBYGgzgJ8D+Ho0Ev5YNBLOP5tdAJIALi74tj8Tgu9K26X8DFIHb33rW6ndEyGEFHA4HJibm6u4Xzweh8PhoIXdLUBuHTXP87QgsUmkDHexWq2SbnasViu6u7tbMqiW0uVDD+AHAL4djYTvL9wejYQTgWDoQQB3BIKhAwCOCV05+oXvKbtdys9Q6uS1xmg05rp9EEIIeR3LslhYWKi4XyKRgN1ulzWogijH6/Xi1KlTkso+0uk0ff41SaWAOpvNypo+2t/fj6mpqTodXf1IqaG+WOjCsTkQDN1asO1fo5HwDQBuEQa//CcAB4A9AC6LRsLHhP0qbZe6D6mBwWCAx+Np9mEQQkhLkRpQi2PHKaBuDX19fZidnUUmk6mY3cxms9Tho0n0en3ZWudkMikrNmEYBuedd15L1U9DYtu83wmLA8vtswzgr4X/yd4udR9CCCGk3jo6OiRN3kskErDZbJLbgBFlMQyDDRs2YM+ePRXLcAwGQ00jy0ltyr1m9Ho9HA5H3X5es7RWeE8IIYQ0mMPhkJWhbrXMmJZZrVb09vZWnKRHCxKbq1wAbLFYVPGaav8zIIQQQmogDnepRAyoSWtZu3YtrFYreL54l12e56kzS5OVCqh5nq/Y3aNdUEBNCCFE01iWxfz8PNLpdNn9xLZ5pLUwDINNmzaV7PyQSqVoQWKTlQqo5dZPtzIKqAkhhGia0+lELBbD4cOHy+5HGerWZTKZsG7duqKlHzzPU8vYJjOZTEV7UTMMo5rFohRQE0II0bQPfvCDeOKJJ7B//37Mz8+X3I8y1K2tu7sbDodjVeBmNBppQWKTWa1WZDKZVV83mUwtucCwGhRQE0II0bSBgQF88IMfxDe/+U0cPny4ZC1uLBajTGeLW79+/aqAmga6NF+pgFot9dOggJoQQggBPvaxj+Ho0aP4xS9+gYmJiaL7JBIJCqhbnNFoxMDAQK70gxYktgaTybSqy4raatspoCaEEKJ5GzZswGc+8xncd999OHToUNFsWjweV1UAoFZ+vx9OpxOZTAbJZBIul6vZh6R5xaYlZrNZuN3uph1TvVFATQghRPMMBgO2bt2KjRs34gc/+AFee+21VfskEgnVLKBSu9HR0VzpjtyhIaT+DAbDql7Taqttp4CaEEIIAdDV1YXbbrsNjzzyCJ577rkV0xN5nkcikVBNiy+1MxgMGB4eBoRyA9J8er1+xX+rqX4aFFATQgghf/SWt7wF27Ztw7333ouXX3459/XFxUUYDAbKULcRj8eDc889t9mHQQT53TwymYzq1iNQQE0IIYQIrFYrbrrpJsRiMTz66KO5BYrxeBwOh4MWuLUZanPYOvID6nQ6rbqnPRRQE0IIIXkGBwdx22234YEHHsCBAweQyWRyQ12oBRsh1ckPqPV6vepuTimgJoQQQvLodDpcffXV+NM//VN873vfw5EjR3JDXdQyhIKQRjMajbmFolardVXXj3ZHATUhhBBSgOM4fP7zn8fPf/5zPPXUU5icnITdbl+1sIoQIo043CWbzaqy8woF1IQQQkgRb37zm/HRj34U99xzDw4ePAiWZSmgJqRKYkCdSqVUVz8NCqgJIYSQ4gwGA2688Uak02n827/9G2WoCamB2WwGz/PQ6XSqXCxKATUhhBBSQk9PD7Zv3479+/errm8uIY0kTku0Wq2rhryoAa2uIIQQQsoIhUL40Ic+hMHBwWYfCiFty2AwgGEY1d6YUkBNCCGElGG1WvHlL38Z09PTzT4UQtoWwzDIZDKqrJ8GBdSEEEJIZf39/apr80VIo5nNZtVNSBSpr4iFEEIIqTOdTod169Y1+zAIaWt9fX2q7eVOATUhhBBCCFFcZ2dnsw9BMRRQE0IIIYQQUgMKqAkhhBBCCKkBBdSEEEIIIYTUgAJqQgghhBBCakABNSGEEEIIITWggJoQQgghhJAaUEBNCCGEEEJIDSigJoQQQgghpAYUUBNCCCGEEFIDCqgJIYQQQgipAQXUhBBCCCGE1IACakIIIYQQQmpAATUhhBBCCCE1oICaEEIIIYSQGlBATQghhBBCSA0ooCaEEEIIIaQGFFATQgghhBBSAwqoCSGEEEIIqQHD83yzj4EQQgghhJC2RRlqQgghhBBCakABNSGEEEIIITWggJoQQgghhJAaUEBNCCGEEEJIDSigJoQQQgghpAYUUBNCCCGEEFIDQ7MPoNkCwdAAgO8DeBuAgWgkfFT4OgPgFgAfBdAH4DSAb0Yj4W/kfe9GAH8P4CIANgC/BXBTNBI+nLfPtQC+CGAYwLTwb305Gglnm3XO7a4B18wI4AsAbgfwtWgk/DfNOle1aMA1uxHAjQB6AUwC+BcAX6XXWfWUvGaBYMgM4G8BXAvAD2AKwE8AbI9GwsvNPO92pvTrLG9fE4BdABzRSHhdo89TTRR+nf0NgC8BSBb8s3dFI+EvNvpc1U7TGepAMBQC8DSAY0U2fwrAVwB8AkAHgA8B2B4Ihm4QvrcDQBTAAoD1ANYCOAXg8UAwZBH2eQeAfwVwFwAXgBCA/wlge8NPViUacM38AJ4BsBFAvOEnqEINuGYfB/B3wgdPB4C/AHArgJsafrIqofQ1A3A/gC0ALgfAArgGwP8AQDevVWrANcv3JSHIIzVo0DV7MhoJWwr+R8G0ArSeoXYDuFTIan2oYNt/A/CjaCT8K+G/nwwEQ98C8NcA/gnAW4Q/4E9HI+EYXv8D/ysAMQBXCtmWGwE8Fo2EfyD8jGcDwdAdAL4QCIa+Ho2EM409XVVQ+pp5hCzA9wPB0MnGn54qKX3NDAA+G42EnxR+xlOBYOiXAN4lBG5EPqWv2RMAvhuNhF8WfsazgWDoSQBvaOxpqorS1wzC1y8A8FcA7gHwkYaeofo05JqRxtB0hjoaCT+Y94ZeiCny+5kEsDEQDLHCduTvE42EFwEkALxJ+NKbATxb8DOeAeADMFi/M9EOpa9ZNBJ+KRoJf1+xE9CgBlyzB6KR8D+J24VHpesAjCtxPlrQgGv2SDQSfh5C+UcgGHoPgLcD+D9KnZPaNeDzTCz1+BcAnwdwXJET0ZBGXDMAPYFg6PFAMDQbCIaOBIKhO0s8dSA10nqGupxHhEzyTwA8CeBCIePMCFnM3ws1Td8Q7goZAJ8F4BACZgi1gTMFP3da+P8uAK80+JzUrh7XjDSWEtfsSwAGALy/weeiFXW7ZoFg6J8AXC8EAbdGI+EfNe+0VK1e1+zLQlD3XQDbmng+WlCPazYO4DXhuu0Rknz/V9jn400+P9XRdIa6grsB3AvgH4U3kM8BeFDYlopGwgkA7wHQCeBVAH8Q7tgPA0iV+bniXSXfgHPQGqWuGVFO3a5ZIBjSB4KhewF8EkAwGgm/1pxTUr26XbNoJHyDsJhqK4CvBoKhW5tzSqpX8zULBEMXCkHY9dFImD6/lFfzNYtGwv8YjYQvi0bCT0cj4aVoJPwbAF8DcH0gGKKEap3RL7SEaCScFrpz5Ir3A8HQJwEsC3eFiEbCu4XHlOJ2RlhUIz4KmyiSRfPnbSN1VKdrRhqoXtcsEAxZAfxUKKV6czQSpqc/Cqn36ywaCS8B+IVwM/R5YRE3qaNar5lQ6vF9AJ+LRsLFFtCROlPw8+wwACMAL8Uh9UUBdQmBYOgNAPqjkfDOvC9fJayYTQttn64B8OtoJDwmbH+rsMhAXETwBwAXF/zotwh/xJQ9q7M6XTPSQPW4ZoFgSC88HjUDuEjI3BCF1HrNhOv1AoA78xZsQ3h6l27w6WhCHV5nFwPYDOAOYWE9hNebLRAMTQN4bzQS/n0TTk216vTe+AUAe6OR8M/yfsZmoTPIZGPPSP0ooC5tPYAfBIKhdwP4nbCa+VIA78Trd4bLgWDodgDvCwRDHwbAAfgGgCeikfBTws+4D8BvAsHQ9QB+BOAC4bHN16k/riLqcc1IY9Xjmt0s1EyfH42Ezzb3dDSh5msWCIaeBvDlQDC0B8CLAM4TOkdQZwJl1HTNhOCtt+BnbhVau10s9BEn9VWP90Y3gG8HgqExAHuFgPtWAN+gsp3603RAHQiGXgbQn1dL/nIgGOIB/Gs0Er4hEAwNCn2kfQBeBhCKRsK/zfsR7wfwbaH3Y1LIkn1G3BiNhP8gDHb5OwD/W3hMc3c0Er6n8WerDkpfM+GO/gvCf5qFRSG34fXrSSujq6D0NRMCsXUAZgPB0Ip/m65ZdRpwzW4UHk3/u1ADOiF0+PjbBp+qaih5zYRhOycL/r0YgEw0Eqb2olVqwOvscwAWha/7hFKQO4XabFJnDM/TTQohhBBCCCHVoi4fhBBCCCGE1IACakIIIYQQQmpAATUhhBBCCCE1oICaEEIIIYSQGlBATQghhBBCSA0ooCaEEEIIIaQGFFATQgghhBBSAwqoCSGEEEIIqQEF1IQQQgghhNTg/wNBR7Dov/cZ1QAAAABJRU5ErkJggg==\n"
+ },
+ "metadata": {
+ "bento_obj_id": "140506664325952",
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "bento_obj_id": "140506869730368",
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "c208c2b1-d37b-48d9-944a-98136b2ec86e",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "# Evaluation\n",
+ "We measure mean absolute error (MAE), continuous-ranked probability score (CRPS), and log-likelihood (LL) using normalized values on both of the training set and the test set."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "9f54f0e1-82cf-4ca4-b60b-76d7ce56e567",
+ "showInput": true,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": [],
+ "collapsed": false
+ },
+ "source": [
+ "train_mean, train_var, train_ci = get_mvn_stats(model.predict(x_train))\n",
+ "test_mean, test_var, test_ci = get_mvn_stats(model.predict(x_test))\n",
+ ""
+ ],
+ "execution_count": 98,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "21572862-5c2a-4a6c-be91-a26a4b1f6d77",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "Here we compute MAE for both training data and test data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "0904849e-2165-454b-84a2-b0da1b15004e",
+ "showInput": true,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": [],
+ "collapsed": false
+ },
+ "source": [
+ "from sts.metrics import MAE\n",
+ "MAE_train = MAE(y_train.tensor, train_mean).item()\n",
+ "MAE_test = MAE(y_test.tensor, test_mean).item()\n",
+ "print(f'Mean absolute error for training set is: {MAE_train:.3f}')\n",
+ "print(f'Mean absolute error for test set is: {MAE_test:.3f}')"
+ ],
+ "execution_count": 99,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Mean absolute error for training set is: 0.002\nMean absolute error for test set is: 0.813\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "9cf3aa6f-3e5f-48d8-9d0a-8523e36148e1",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "Here we compute CRPS for both training data and test data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "c03acc57-9792-41ad-9902-1a222137644d",
+ "showInput": true,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": [],
+ "collapsed": false
+ },
+ "source": [
+ "from sts.crps import crps_gaussian\n",
+ "crps_train = crps_gaussian(y_train.tensor, train_mean, train_var.sqrt())\n",
+ "crps_test = crps_gaussian(y_test.tensor, test_mean, test_var.sqrt())\n",
+ "print(f'Continuous ranked probability score for training set is: {crps_train.mean().item():.3f}')\n",
+ "print(f'Continuous ranked probability score for test set is: {crps_test.mean().item():.3f}')"
+ ],
+ "execution_count": 100,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Continuous ranked probability score for training set is: 0.010\nContinuous ranked probability score for test set is: 0.596\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "originalKey": "9bddcd7a-e61b-41fa-9613-751e3d6df135",
+ "showInput": false,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "Here we compute log-likelihood for both training data and test data.\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "09d02e09-3af3-4950-aa1a-3275afac405c",
+ "showInput": true,
+ "customInput": null,
+ "collapsed": false,
+ "code_folding": [],
+ "hidden_ranges": []
+ },
+ "source": [
+ "from sts.metrics import log_likelihood_error\n",
+ "ll_train = log_likelihood_error(train_mean, y_train.tensor, train_var).item()\n",
+ "ll_test = log_likelihood_error(test_mean, y_test.tensor, test_var).item()\n",
+ "print(f'Log-likelihood for training set is: {ll_train:.3f}')\n",
+ "print(f'Log-likelihood for test set is: {ll_test:.3f}')"
+ ],
+ "execution_count": 101,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Log-likelihood for training set is: 2.231\nLog-likelihood for test set is: -1.517\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "originalKey": "38510b7b-d7a6-453e-87cf-efa1ede52d98",
+ "showInput": true,
+ "customInput": null,
+ "code_folding": [],
+ "hidden_ranges": [],
+ "collapsed": false
+ },
+ "source": [
+ "scores = [[MAE_train, crps_train.mean().item(), ll_train], [MAE_test, crps_test.mean().item(), ll_test]]\n",
+ "df_meature = pd.DataFrame(scores, columns = ['MAE', 'CPRS', 'LL'])\n",
+ "df_meature"
+ ],
+ "execution_count": 102,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": " MAE CPRS LL\n0 0.001731 0.010051 2.230578\n1 0.812689 0.596490 -1.516943",
+ "text/html": "\n\n
\n \n \n | \n MAE | \n CPRS | \n LL | \n
\n \n \n \n | 0 | \n 0.001731 | \n 0.010051 | \n 2.230578 | \n
\n \n | 1 | \n 0.812689 | \n 0.596490 | \n -1.516943 | \n
\n \n
\n
\n\n
\n \n \n | \n decimal | \n average | \n
\n \n \n \n | 0 | \n 1980.042 | \n 338.55 | \n
\n \n | 1 | \n 1980.125 | \n 339.27 | \n
\n \n | 2 | \n 1980.208 | \n 339.60 | \n
\n \n | 3 | \n 1980.292 | \n 340.00 | \n
\n \n | 4 | \n 1980.375 | \n 340.43 | \n
\n \n | ... | \n ... | \n ... | \n
\n \n | 489 | \n 2020.792 | \n 411.71 | \n
\n \n | 490 | \n 2020.875 | \n 413.25 | \n
\n \n | 491 | \n 2020.958 | \n 414.18 | \n
\n \n | 492 | \n 2021.042 | \n 414.95 | \n
\n \n | 493 | \n 2021.125 | \n 415.88 | \n
\n \n
\n
494 rows × 2 columns
\n