tbp.monty.frameworks.models.salience#

tbp.monty.frameworks.models.salience.strategies

tbp.monty.frameworks.models.salience.motor_policy#

exception GoalCollocatedWithSensor[source]#

Bases: RuntimeError

Raised when a goal is collocated with a sensor.

class LookAtGoal(agent_id: AgentID, sensor_id: SensorID) → None[source]#

Bases: MotorPolicy

A policy that looks at a target.

This class assumes a system similar to a 2-DOF gimbal in which the “outer” part can yaw left/right about the y-axis and the “inner” part can pitch up/down about the x-axis. This setup is typical of our distant agent in which the agent turns left/right and sensor mounted to it looks up/down.

Note that this code only uses TurnLeft and LookUp. Turning right or looking down are performed using negative degrees with TurnLeft and LookUp, respectively.

__init__(agent_id: AgentID, sensor_id: SensorID) → None[source]#

Initialize the look at policy.

Parameters:

agent_id (NewType()(AgentID, str)) – The agent ID
sensor_id (NewType()(SensorID, str)) – The sensor ID

fixme_provide_motor_system(motor_system: ExperimentMotorSystem) → None[source]#

Provide access to the Motor System during initialization.

This is part of the work to remove reset() in favor or Hydra instantiation. It is used to provide a reference to the Motor System so the SurfacePolicy and its subclasses can override the motor_only_step property.

TODO: This whole mechanism is a hack for the benefit of SurfacePolicy et. al. What we should be doing is supporting more complex actions, like “follow surface in this direction,” whose details are left to the simulator.

Parameters:: motor_system (ExperimentMotorSystem) – The associated Motor System.
Return type:: None

load_state_dict(memento: Mapping[str, Any]) → None[source]#

Load the internal object state from a previously snapshot memento.

Parameters:: memento (Mapping[str, Any]) – State dict to load.
Return type:: None

reset() → None[source]#

Reset the internal state of this Motor Policy.

Return type:: None

state_dict() → Mapping[str, Any][source]#

Snapshot a memento representing the internal state of this object.

Return type:: Mapping[str, Any]
Returns:: State dict for logging and saving.

tbp.monty.frameworks.models.salience.on_object_observation#

class OnObjectObservation(center_location: np.ndarray | None, locations: np.ndarray, salience: np.ndarray) → None[source]#

Bases: object

__init__(center_location: np.ndarray | None, locations: np.ndarray, salience: np.ndarray) → None#

center_location: np.ndarray | None#

locations: np.ndarray#

salience: np.ndarray#

on_object_observation(observation: SensorObservation, salience_map: numpy.ndarray) → OnObjectObservation[source]#

Convert all raw observation data into image format.

This function reformats the arrays in a raw observations dictionary so that they’re all indexable by image row and column indices. It also splits the semantic_3d array into 3D locations and an on-object/surface indicator array.

Parameters:

observation (SensorObservation) – A sensor observation.
salience_map (ndarray) – A salience map.

Return type:

OnObjectObservation

Returns:

The grid/matrix formatted (unraveled) on-object salience and location data, along with the location corresponding to the central pixel.

tbp.monty.frameworks.models.salience.return_inhibitor#

class DecayField(kernel_factory: DecayKernelFactory | None = None)[source]#

Bases: object

Manages a collection of decay kernels.

__init__(kernel_factory: DecayKernelFactory | None = None)[source]#

add(location: numpy.ndarray) → None[source]#

Add a kernel to the field.

Return type:: None

compute_weights(points: numpy.ndarray) → numpy.ndarray[source]#

Return type:: ndarray

reset() → None[source]#

Return type:: None

step() → None[source]#

Step each kernel to increment its counter, and keep only non-expired ones.

Return type:: None

class DecayKernel(location: np.ndarray, tau_t: float = 10.0, tau_s: float = 0.01, spatial_cutoff: float | None = 0.02, w_t_min: float = 0.1)[source]#

Bases: object

Decay kernel represents a previously visited location.

Returns the product of time- and space-dependent exponentials.

__init__(location: np.ndarray, tau_t: float = 10.0, tau_s: float = 0.01, spatial_cutoff: float | None = 0.02, w_t_min: float = 0.1)[source]#

step() → bool[source]#

Increment the step counter, and check if the kernel is expired.

Return type:: bool
Returns:: True if the kernel is expired, False otherwise.

w_s(points: numpy.ndarray) → numpy.ndarray[source]#

Compute the distance-dependent weight.

The weight is computed as exp(-z / lam), where z is the distance between the kernel’s center and the given point(s), and lam is equal to tau_s / log(2).