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

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(motor_system: ExperimentMotorSystem) → None[source]#

Reset the internal state of this Motor Policy.

Parameters:: motor_system (ExperimentMotorSystem) – The associated Motor System.
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).