diff --git a/vivarium/experimental/environments/braitenberg/selective_sensing.py b/vivarium/experimental/environments/braitenberg/selective_sensing.py new file mode 100644 index 0000000..94e73b7 --- /dev/null +++ b/vivarium/experimental/environments/braitenberg/selective_sensing.py @@ -0,0 +1,916 @@ +import logging as lg + +from enum import Enum +from functools import partial +from typing import Tuple + +import jax +import numpy as np +import jax.numpy as jnp +import matplotlib.colors as mcolors + +from jax import vmap, jit +from jax import random, lax + +from flax import struct +from jax_md.rigid_body import RigidBody +from jax_md import simulate +from jax_md import space, partition + +from vivarium.experimental.environments.utils import distance +from vivarium.experimental.environments.base_env import BaseState, BaseEnv +from vivarium.experimental.environments.physics_engine import dynamics_fn +from vivarium.experimental.environments.braitenberg.simple import proximity_map, sensor_fn +from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params, linear_behavior +from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn + + +### Define the constants and the classes of the environment to store its state ### +SPACE_NDIMS = 2 + +class EntityType(Enum): + AGENT = 0 + OBJECT = 1 + +# Already incorporates position, momentum, force, mass and velocity +@struct.dataclass +class EntityState(simulate.NVEState): + entity_type: jnp.array + ent_subtype: jnp.array + entity_idx: jnp.array + diameter: jnp.array + friction: jnp.array + exists: jnp.array + +@struct.dataclass +class ParticleState: + ent_idx: jnp.array + color: jnp.array + +@struct.dataclass +class AgentState(ParticleState): + prox: jnp.array + motor: jnp.array + proximity_map_dist: jnp.array + proximity_map_theta: jnp.array + behavior: jnp.array + params: jnp.array + sensed: jnp.array + wheel_diameter: jnp.array + speed_mul: jnp.array + max_speed: jnp.array + theta_mul: jnp.array + proxs_dist_max: jnp.array + proxs_cos_min: jnp.array + +@struct.dataclass +class ObjectState(ParticleState): + pass + +@struct.dataclass +class State(BaseState): + max_agents: jnp.int32 + max_objects: jnp.int32 + neighbor_radius: jnp.float32 + dt: jnp.float32 # Give a more explicit name + collision_alpha: jnp.float32 + collision_eps: jnp.float32 + ent_sub_types: dict + entities: EntityState + agents: AgentState + objects: ObjectState + +@struct.dataclass +class Neighbors: + neighbors: jnp.array + agents_neighs_idx: jnp.array + agents_idx_dense: jnp.array + + +# TODO : Should refactor the function to split the returns +def get_relative_displacement(state, agents_neighs_idx, displacement_fn): + """Get all infos relative to distance and orientation between all agents and their neighbors + + :param state: state + :param agents_neighs_idx: idx all agents neighbors + :param displacement_fn: jax md function enabling to know the distance between points + :return: distance array, angles array, distance map for all agents, angles map for all agents + """ + body = state.entities.position + senders, receivers = agents_neighs_idx + Ra = body.center[senders] + Rb = body.center[receivers] + dR = - space.map_bond(displacement_fn)(Ra, Rb) # Looks like it should be opposite, but don't understand why + + dist, theta = proximity_map(dR, body.orientation[senders]) + proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0])) + proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist) + proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0])) + proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta) + return dist, theta, proximity_map_dist, proximity_map_theta + +# def linear_behavior(proxs, params): +# """Compute the activation of motors with a linear combination of proximeters and parameters + +# :param proxs: proximeter values of an agent +# :param params: parameters of an agent (mapping proxs to motor values) +# :return: motor values +# """ +# return params.dot(jnp.hstack((proxs, 1.))) + +def compute_motor(proxs, params, behaviors, motors): + """Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params. + + :param proxs: proximeters of all agents + :param params: parameters mapping proximeters to new motor values + :param behaviors: array of behaviors + :param motors: current motor values + :return: new motor values + """ + manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0) + manual_mask = manual + linear_motor_values = linear_behavior(proxs, params) + motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask + return motor_values + +### 1 : Functions for selective sensing with occlusion + +def update_mask(mask, left_n_right_types, ent_type): + """Update a mask of + + :param mask: mask that will be applied on sensors of agents + :param left_n_right_types: types of left adn right sensed entities + :param ent_type: entity subtype (e.g 1 for predators) + :return: mask + """ + cur = jnp.where(left_n_right_types == ent_type, 0, 1) + mask *= cur + return mask + +def keep_mask(mask, left_n_right_types, ent_type): + """Return the mask unchanged + + :param mask: mask + :param left_n_right_types: left_n_right_types + :param ent_type: ent_type + :return: mask + """ + return mask + +def mask_proxs_occlusion(proxs, left_n_right_types, ent_sensed_arr): + """Mask the proximeters of agents with occlusion + + :param proxs: proxiemters of agents without occlusion (shape = (2,)) + :param e_sensed_types: types of both entities sensed at left and right (shape=(2,)) + :param ent_sensed_arr: mask of sensed subtypes by the agent (e.g jnp.array([0, 1, 0, 1]) if sense only entities of subtype 1 and 4) + :return: updated proximeters according to sensed_subtypes + """ + mask = jnp.array([1, 1]) + # Iterate on the array of sensed entities mask + for ent_type, sensed in enumerate(ent_sensed_arr): + # If an entity is sensed, update the mask, else keep it as it is + mask = jax.lax.cond(sensed, update_mask, keep_mask, mask, left_n_right_types, ent_type) + # Update the mask with 0s where the mask is, else keep the prox value + proxs = jnp.where(mask, 0, proxs) + return proxs + +# Example : +# ent_sensed_arr = jnp.array([0, 1, 0, 0, 1]) +# proxs = jnp.array([0.8, 0.2]) +# e_sensed_types = jnp.array([4, 4]) # Modify these values to check it works +# print(mask_proxs_occlusion(proxs, e_sensed_types, ent_sensed_arr)) + +def compute_behavior_motors(state, params, sensed_mask, behavior, motor, agent_proxs, sensed_ent_idx): + """Compute the motor values for a specific behavior + + :param state: state + :param params: behavior params params + :param sensed_mask: sensed_mask for this behavior + :param behavior: behavior + :param motor: motor values + :param agent_proxs: agent proximeters (unmasked) + :param sensed_ent_idx: idx of left and right entities sensed + :return: right motor values for this behavior + """ + left_n_right_types = state.entities.ent_subtype[sensed_ent_idx] + behavior_proxs = mask_proxs_occlusion(agent_proxs, left_n_right_types, sensed_mask) + motors = compute_motor(behavior_proxs, params, behaviors=behavior, motors=motor) + return motors + +# See for the vectorizing idx because already in a vmaped function here +compute_all_behavior_motors = vmap(compute_behavior_motors, in_axes=(None, 0, 0, 0, None, None, None)) + + +def compute_occlusion_proxs_motors(state, agent_idx, params, sensed, behaviors, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers): + """_summary_ + + :param state: state + :param agent_idx: agent idx in entities + :param params: params arrays for all agent's behaviors + :param sensed: sensed mask arrays for all agent's behaviors + :param behaviors: agent behaviors array + :param motor: agent motors + :param raw_proxs: raw_proximeters for all agents (shape=(n_agents * (n_entities - 1), 2)) + :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1)) + :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1)) + :return: _description_ + """ + behavior = jnp.expand_dims(behaviors, axis=1) + # Compute the neighbors idx of the agent and get its raw proximeters (of shape (n_entities -1 , 2)) + ent_ag_neighs_idx = ag_idx_dense_senders[agent_idx] + agent_raw_proxs = raw_proxs[ent_ag_neighs_idx] + + # Get the max and arg max of these proximeters on axis 0, gives results of shape (2,) + agent_proxs = jnp.max(agent_raw_proxs, axis=0) + argmax = jnp.argmax(agent_raw_proxs, axis=0) + # Get the real entity idx of the left and right sensed entities from dense neighborhoods + sensed_ent_idx = ag_idx_dense_receivers[agent_idx][argmax] + + # Compute the motor values for all behaviors and do a mean on it + motor_values = compute_all_behavior_motors(state, params, sensed, behavior, motor, agent_proxs, sensed_ent_idx) + motors = jnp.mean(motor_values, axis=0) + + return agent_proxs, motors + +compute_all_agents_proxs_motors_occl = vmap(compute_occlusion_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None)) + + +### 2 : Functions for selective sensing without occlusion + +def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx): + """Mask the raw proximeters of agents for a specific entity type + + :param state: state + :param agent_raw_proxs: raw_proximeters of agent (shape=(n_entities - 1), 2) + :param ent_type_id: entity subtype id (e.g 0 for PREYS) + :param ent_neighbors_idx: idx of agent neighbors in entities arrays + :return: updated agent raw proximeters + """ + mask = jnp.where(state.entities.ent_subtype[ent_neighbors_idx] == ent_type_id, 0, 1) + mask = jnp.expand_dims(mask, 1) + mask = jnp.broadcast_to(mask, agent_raw_proxs.shape) + return agent_raw_proxs * mask + +def dont_change(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx): + """Leave the agent raw_proximeters unchanged + + :param state: state + :param agent_raw_proxs: agent_raw_proxs + :param ent_type_id: ent_type_id + :param ent_neighbors_idx: ent_neighbors_idx + :return: agent_raw_proxs + """ + return agent_raw_proxs + +def compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed_entities): + """Compute the proximeters for a specific behavior + + :param state: state + :param agent_raw_proxs: agent raw proximeters + :param ent_neighbors_idx: idx of agent neighbors + :param sensed_entities: array of sensed entities + :return: updated proximeters + """ + # iterate over all the types in sensed_entities and return if they are sensed or not + for ent_type_id, sensed in enumerate(sensed_entities): + # change the proxs if you don't perceive the entity, else leave them unchanged + agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_neighbors_idx) + # Compute the final proxs with a max on the updated raw_proxs + proxs = jnp.max(agent_raw_proxs, axis=0) + return proxs + +def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx): + """Return the proximeters and the motors for a specific behavior + + :param state: state + :param params: params of the behavior + :param sensed: sensed mask of the behavior + :param behavior: behavior + :param motor: motor values + :param agent_raw_proxs: agent_raw_proxs + :param ent_neighbors_idx: ent_neighbors_idx + :return: behavior proximeters, behavior motors + """ + behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed) + behavior_motors = compute_motor(behavior_prox, params, behavior, motor) + return behavior_prox, behavior_motors + +# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same) +compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None)) + +def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers): + """Compute the agent proximeters and motors for all behaviors + + :param state: state + :param agent_idx: idx of the agent in entities + :param params: array of params for all behaviors + :param sensed: array of sensed mask for all behaviors + :param behavior: array of behaviors + :param motor: motor values + :param raw_proxs: raw_proximeters of all agents + :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1)) + :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1)) + :return: array of agent_proximeters, mean of behavior motors + """ + behavior = jnp.expand_dims(behavior, axis=1) + ent_ag_idx = ag_idx_dense_senders[agent_idx] + ent_neighbors_idx = ag_idx_dense_receivers[agent_idx] + agent_raw_proxs = raw_proxs[ent_ag_idx] + + # vmap on params, sensed, behaviors and motorss (vmap on all agents) + agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx) + mean_agent_motors = jnp.mean(agent_motors, axis=0) + + return agent_proxs, mean_agent_motors + +compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None)) + + + + +class SelectiveSensorsEnv(BaseEnv): + def __init__(self, state, occlusion=True, seed=42): + """Init the selective sensors braitenberg env + + :param state: simulation state already complete + :param occlusion: wether to use sensors with occlusion or not, defaults to True + :param seed: random seed, defaults to 42 + """ + self.seed = seed + self.occlusion = occlusion + self.compute_all_agents_proxs_motors = self.choose_agent_prox_motor_function() + self.init_key = random.PRNGKey(seed) + self.displacement, self.shift = space.periodic(state.box_size) + self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) + # Do a warning at the moment if neighbor radius is < box_size + if state.neighbor_radius < state.box_size: + lg.warn("Neighbor radius < Box size, there might be problems for neighbors arrays computations") + self.neighbor_fn = partition.neighbor_list( + self.displacement, + state.box_size, + r_cutoff=state.neighbor_radius, + dr_threshold=10., + capacity_multiplier=1.5, + format=partition.Sparse + ) + self.neighbors_storage = self.allocate_neighbors(state) + + def distance(self, point1, point2): + """Returns the distance between two points + + :param point1: point1 coordinates + :param point2: point1 coordinates + :return: distance between two points + """ + return distance(self.displacement, point1, point2) + + # At the moment doesn't work because the _step function isn't recompiled + def choose_agent_prox_motor_function(self): + """Returns the function to compute the proximeters and the motors with or without occlusion + + :return: compute_all_agents_proxs_motors function + """ + if self.occlusion: + prox_motor_function = compute_all_agents_proxs_motors_occl + else: + prox_motor_function = compute_all_agents_proxs_motors + return prox_motor_function + + @partial(jit, static_argnums=(0,)) + def _step(self, state: State, neighbors_storage: Neighbors) -> Tuple[State, jnp.array]: + """Do 1 jitted step in the environment and return the updated state + + :param state: current state + :param neighbors_storage: class storing all neighbors information + :return: new sttae + """ + + # Retrieve different neighbors format + neighbors = neighbors_storage.neighbors + agents_neighs_idx = neighbors_storage.agents_neighs_idx + ag_idx_dense = neighbors_storage.agents_idx_dense + # Differences : compute raw proxs for all agents first + dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement) + senders, receivers = agents_neighs_idx + + dist_max = state.agents.proxs_dist_max[senders] + cos_min = state.agents.proxs_cos_min[senders] + target_exist_mask = state.entities.exists[agents_neighs_idx[1, :]] + raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exist_mask) + + # Could even just pass ag_idx_dense in the fn and do this inside + ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense + + agent_proxs, mean_agent_motors = self.compute_all_agents_proxs_motors( + state, + state.agents.ent_idx, + state.agents.params, + state.agents.sensed, + state.agents.behavior, + state.agents.motor, + raw_proxs, + ag_idx_dense_senders, + ag_idx_dense_receivers, + ) + + agents = state.agents.replace( + prox=agent_proxs, + proximity_map_dist=proximity_dist_map, + proximity_map_theta=proximity_dist_theta, + motor=mean_agent_motors + ) + + # Last block unchanged + state = state.replace(agents=agents) + entities = self.apply_physics(state, neighbors) + state = state.replace(time=state.time+1, entities=entities) + neighbors = neighbors.update(state.entities.position.center) + + return state, neighbors + + def step(self, state: State) -> State: + """Do 1 step in the environment and return the updated state. This function also handles the neighbors mechanism and hence isn't jitted + + :param state: current state + :return: next state + """ + # Because momentum is initialized to None, need to initialize it with init_fn from jax_md + if state.entities.momentum is None: + state = self.init_fn(state, self.init_key) + + # Compute next state + current_state = state + state, neighbors = self._step(current_state, self.neighbors_storage) + + # Check if neighbors buffer overflowed + if neighbors.did_buffer_overflow: + # reallocate neighbors and run the simulation from current_state + lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors') + self.neighbors_storage = self.allocate_neighbors(state) + assert not neighbors.did_buffer_overflow + + return state + + def allocate_neighbors(self, state, position=None): + """Allocate the neighbors according to the state + + :param state: state + :param position: position of entities in the state, defaults to None + :return: Neighbors object with neighbors (sparse representation), idx of agent's neighbors, neighbors (dense representation) + """ + # get the sparse representation of neighbors (shape=(n_neighbors_pairs, 2)) + position = state.entities.position.center if position is None else position + neighbors = self.neighbor_fn.allocate(position) + + # Also update the neighbor idx of agents + ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value + agents_neighs_idx = neighbors.idx[:, ag_idx] + + # Give the idx of the agents in sparse representation, under a dense representation (used to get the raw proxs in compute motors function) + agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)]) + # Note: jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() ~ jnp.where(agents_idx[0, :] == idx) + + # Give the idx of the agent neighbors in dense representation + agents_idx_dense_receivers = agents_neighs_idx[1, :][agents_idx_dense_senders] + agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers + + neighbor_storage = Neighbors(neighbors=neighbors, agents_neighs_idx=agents_neighs_idx, agents_idx_dense=agents_idx_dense) + return neighbor_storage + + +### Default values +seed = 0 +n_dims = 2 +box_size = 100 +diameter = 5.0 +friction = 0.1 +mass_center = 1.0 +mass_orientation = 0.125 +# Set neighbor radius to box_size to ensure good conversion from sparse to dense neighbors +neighbor_radius = box_size +collision_alpha = 0.5 +collision_eps = 0.1 +dt = 0.1 +wheel_diameter = 2.0 +speed_mul = 1.0 +max_speed = 10.0 +theta_mul = 1.0 +prox_dist_max = 40.0 +prox_cos_min = 0.0 +existing_agents = None +existing_objects = None + +entities_sbutypes = ['PREYS', 'PREDS', 'RESSOURCES', 'POISON'] + +preys_data = { + 'type': 'AGENT', + 'num': 5, + 'color': 'blue', + 'selective_behaviors': { + 'love': {'beh': 'LOVE', 'sensed': ['PREYS', 'RESSOURCES']}, + 'fear': {'beh': 'FEAR', 'sensed': ['PREDS', 'POISON']} + }} + +preds_data = { + 'type': 'AGENT', + 'num': 5, + 'color': 'red', + 'selective_behaviors': { + 'aggr': {'beh': 'AGGRESSION','sensed': ['PREYS']}, + 'fear': {'beh': 'FEAR','sensed': ['POISON'] + } + }} + +ressources_data = { + 'type': 'OBJECT', + 'num': 5, + 'color': 'green'} + +poison_data = { + 'type': 'OBJECT', + 'num': 5, + 'color': 'purple'} + +entities_data = { + 'EntitySubTypes': entities_sbutypes, + 'Entities': { + 'PREYS': preys_data, + 'PREDS': preds_data, + 'RESSOURCES': ressources_data, + 'POISON': poison_data + }} + +### Helper functions to generate the state + +# Helper function to transform a color string into rgb with matplotlib colors +def _string_to_rgb(color_str): + return jnp.array(list(mcolors.to_rgb(color_str))) + +# Helper functions to define behaviors of agents in selecting sensing case +def define_behavior_map(behavior, sensed_mask): + """Create a dict with behavior value, params and sensed mask for a given behavior + + :param behavior: behavior value + :param sensed_mask: list of sensed mask + :return: params associated to the behavior + """ + params = behavior_to_params(behavior) + sensed_mask = jnp.array([sensed_mask]) + + behavior_map = { + 'behavior': behavior, + 'params': params, + 'sensed_mask': sensed_mask + } + return behavior_map + +def stack_behaviors(behaviors_dict_list): + """Return a dict with the stacked information from different behaviors, params and sensed mask + + :param behaviors_dict_list: list of dicts containing behavior, params and sensed mask for 1 behavior + :return: stacked_behavior_map + """ + # init variables + n_behaviors = len(behaviors_dict_list) + sensed_length = behaviors_dict_list[0]['sensed_mask'].shape[1] + + params = np.zeros((n_behaviors, 2, 3)) # (2, 3) = params.shape + sensed_mask = np.zeros((n_behaviors, sensed_length)) + behaviors = np.zeros((n_behaviors,)) + + # iterate in the list of behaviors and update params and mask + for i in range(n_behaviors): + assert behaviors_dict_list[i]['sensed_mask'].shape[1] == sensed_length + params[i] = behaviors_dict_list[i]['params'] + sensed_mask[i] = behaviors_dict_list[i]['sensed_mask'] + behaviors[i] = behaviors_dict_list[i]['behavior'] + + stacked_behavior_map = { + 'behaviors': behaviors, + 'params': params, + 'sensed_mask': sensed_mask + } + + return stacked_behavior_map + +def get_agents_params_and_sensed_arr(agents_stacked_behaviors_list): + """Generate the behaviors, params and sensed arrays in jax from a list of stacked behaviors + + :param agents_stacked_behaviors_list: list of stacked behaviors + :return: params, sensed, behaviors + """ + n_agents = len(agents_stacked_behaviors_list) + params_shape = agents_stacked_behaviors_list[0]['params'].shape + sensed_shape = agents_stacked_behaviors_list[0]['sensed_mask'].shape + behaviors_shape = agents_stacked_behaviors_list[0]['behaviors'].shape + # Init arrays w right shapes + params = np.zeros((n_agents, *params_shape)) + sensed = np.zeros((n_agents, *sensed_shape)) + behaviors = np.zeros((n_agents, *behaviors_shape)) + + for i in range(n_agents): + assert agents_stacked_behaviors_list[i]['params'].shape == params_shape + assert agents_stacked_behaviors_list[i]['sensed_mask'].shape == sensed_shape + assert agents_stacked_behaviors_list[i]['behaviors'].shape == behaviors_shape + params[i] = agents_stacked_behaviors_list[i]['params'] + sensed[i] = agents_stacked_behaviors_list[i]['sensed_mask'] + behaviors[i] = agents_stacked_behaviors_list[i]['behaviors'] + + params = jnp.array(params) + sensed = jnp.array(sensed) + behaviors = jnp.array(behaviors) + + return params, sensed, behaviors + +def init_entities( + max_agents, + max_objects, + ent_sub_types, + n_dims=n_dims, + box_size=box_size, + existing_agents=None, + existing_objects=None, + mass_center=mass_center, + mass_orientation=mass_orientation, + diameter=diameter, + friction=friction, + key_agents_pos=random.PRNGKey(seed), + key_objects_pos=random.PRNGKey(seed+1), + key_orientations=random.PRNGKey(seed+2) +): + """Init the sub entities state""" + existing_agents = max_agents if not existing_agents else existing_agents + existing_objects = max_objects if not existing_objects else existing_objects + + n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects + # Assign random positions to each entity in the environment + agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size + objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size + positions = jnp.concatenate((agents_positions, objects_positions)) + # Assign random orientations between 0 and 2*pi to each entity + orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi + # Assign types to the entities + agents_entities = jnp.full(max_agents, EntityType.AGENT.value) + object_entities = jnp.full(max_objects, EntityType.OBJECT.value) + entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int) + # Define arrays with existing entities + exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents)))) + exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects)))) + exists = jnp.concatenate((exists_agents, exists_objects), dtype=int) + + # Works because dictionaries are ordered in Python + ent_subtypes = np.zeros(n_entities) + cur_idx = 0 + for subtype_id, n_subtype in ent_sub_types.values(): + ent_subtypes[cur_idx:cur_idx+n_subtype] = subtype_id + cur_idx += n_subtype + ent_subtypes = jnp.array(ent_subtypes, dtype=int) + + return EntityState( + position=RigidBody(center=positions, orientation=orientations), + momentum=None, + force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)), + mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)), + entity_type=entity_types, + ent_subtype=ent_subtypes, + entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))), + diameter=jnp.full((n_entities), diameter), + friction=jnp.full((n_entities), friction), + exists=exists + ) + +def init_agents( + max_agents, + params, + sensed, + behaviors, + agents_color, + wheel_diameter=wheel_diameter, + speed_mul=speed_mul, + max_speed=max_speed, + theta_mul=theta_mul, + prox_dist_max=prox_dist_max, + prox_cos_min=prox_cos_min +): + """Init the sub agents state""" + return AgentState( + # idx in the entities (ent_idx) state to map agents information in the different data structures + ent_idx=jnp.arange(max_agents, dtype=int), + prox=jnp.zeros((max_agents, 2)), + motor=jnp.zeros((max_agents, 2)), + behavior=behaviors, + params=params, + sensed=sensed, + wheel_diameter=jnp.full((max_agents), wheel_diameter), + speed_mul=jnp.full((max_agents), speed_mul), + max_speed=jnp.full((max_agents), max_speed), + theta_mul=jnp.full((max_agents), theta_mul), + proxs_dist_max=jnp.full((max_agents), prox_dist_max), + proxs_cos_min=jnp.full((max_agents), prox_cos_min), + proximity_map_dist=jnp.zeros((max_agents, 1)), + proximity_map_theta=jnp.zeros((max_agents, 1)), + color=agents_color + ) + +def init_objects( + max_agents, + max_objects, + objects_color +): + """Init the sub objects state""" + start_idx, stop_idx = max_agents, max_agents + max_objects + objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) + + return ObjectState( + ent_idx=objects_ent_idx, + color=objects_color + ) + + +def init_complete_state( + entities, + agents, + objects, + max_agents, + max_objects, + total_ent_sub_types, + box_size=box_size, + neighbor_radius=neighbor_radius, + collision_alpha=collision_alpha, + collision_eps=collision_eps, + dt=dt, +): + """Init the complete state""" + return State( + time=0, + dt=dt, + box_size=box_size, + max_agents=max_agents, + max_objects=max_objects, + neighbor_radius=neighbor_radius, + collision_alpha=collision_alpha, + collision_eps=collision_eps, + entities=entities, + agents=agents, + objects=objects, + ent_sub_types=total_ent_sub_types + ) + + +def init_state( + entities_data, + box_size=box_size, + dt=dt, + neighbor_radius=neighbor_radius, + collision_alpha=collision_alpha, + collision_eps=collision_eps, + n_dims=n_dims, + seed=seed, + diameter=diameter, + friction=friction, + mass_center=mass_center, + mass_orientation=mass_orientation, + existing_agents=None, + existing_objects=None, + wheel_diameter=wheel_diameter, + speed_mul=speed_mul, + max_speed=max_speed, + theta_mul=theta_mul, + prox_dist_max=prox_dist_max, + prox_cos_min=prox_cos_min, +) -> State: + key = random.PRNGKey(seed) + key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) + + # create an enum for entities subtypes + ent_sub_types = entities_data['EntitySubTypes'] + ent_sub_types_enum = Enum('ent_sub_types_enum', {ent_sub_types[i]: i for i in range(len(ent_sub_types))}) + ent_data = entities_data['Entities'] + + # create max agents and max objects + max_agents = 0 + max_objects = 0 + + # create agent and objects dictionaries + agents_data = {} + objects_data = {} + + # iterate over the entities subtypes + for ent_sub_type in ent_sub_types: + # get their data in the ent_data + data = ent_data[ent_sub_type] + color_str = data['color'] + color = _string_to_rgb(color_str) + n = data['num'] + + # Check if the entity is an agent or an object + if data['type'] == 'AGENT': + max_agents += n + behavior_list = [] + # create a behavior list for all behaviors of the agent + for beh_name, behavior_data in data['selective_behaviors'].items(): + beh_name = behavior_data['beh'] + behavior_id = Behaviors[beh_name].value + # Init an empty mask + sensed_mask = np.zeros((len(ent_sub_types, ))) + for sensed_type in behavior_data['sensed']: + # Iteratively update it with specific sensed values + sensed_id = ent_sub_types_enum[sensed_type].value + sensed_mask[sensed_id] = 1 + beh = define_behavior_map(behavior_id, sensed_mask) + behavior_list.append(beh) + # stack the elements of the behavior list and update the agents_data dictionary + stacked_behaviors = stack_behaviors(behavior_list) + agents_data[ent_sub_type] = {'n': n, 'color': color, 'stacked_behs': stacked_behaviors} + + # only updated object counters and color if entity is an object + elif data['type'] == 'OBJECT': + max_objects += n + objects_data[ent_sub_type] = {'n': n, 'color': color} + + # Create the params, sensed, behaviors and colors arrays + + # init empty lists + colors = [] + agents_stacked_behaviors_list = [] + total_ent_sub_types = {} + for agent_type, data in agents_data.items(): + n = data['n'] + stacked_behavior = data['stacked_behs'] + n_stacked_behavior = list([stacked_behavior] * n) + tiled_color = list(np.tile(data['color'], (n, 1))) + # update the lists with behaviors and color elements + agents_stacked_behaviors_list = agents_stacked_behaviors_list + n_stacked_behavior + colors = colors + tiled_color + total_ent_sub_types[agent_type] = (ent_sub_types_enum[agent_type].value, n) + + # create the final jnp arrays + agents_colors = jnp.concatenate(jnp.array([colors]), axis=0) + params, sensed, behaviors = get_agents_params_and_sensed_arr(agents_stacked_behaviors_list) + + # do the same for objects colors + colors = [] + for objecy_type, data in objects_data.items(): + n = data['n'] + tiled_color = list(np.tile(data['color'], (n, 1))) + colors = colors + tiled_color + total_ent_sub_types[objecy_type] = (ent_sub_types_enum[objecy_type].value, n) + + objects_colors = jnp.concatenate(jnp.array([colors]), axis=0) + # print(total_ent_sub_types) + + # Init sub states and total state + entities = init_entities( + max_agents=max_agents, + max_objects=max_objects, + ent_sub_types=total_ent_sub_types, + n_dims=n_dims, + box_size=box_size, + existing_agents=existing_agents, + existing_objects=existing_objects, + mass_center=mass_center, + mass_orientation=mass_orientation, + diameter=diameter, + friction=friction, + key_agents_pos=key_agents_pos, + key_objects_pos=key_objects_pos, + key_orientations=key_orientations + ) + + agents = init_agents( + max_agents=max_agents, + params=params, + sensed=sensed, + behaviors=behaviors, + agents_color=agents_colors, + wheel_diameter=wheel_diameter, + speed_mul=speed_mul, + max_speed=max_speed, + theta_mul=theta_mul, + prox_dist_max=prox_dist_max, + prox_cos_min=prox_cos_min + ) + + objects = init_objects( + max_agents=max_agents, + max_objects=max_objects, + objects_color=objects_colors + ) + + state = init_complete_state( + entities=entities, + agents=agents, + objects=objects, + max_agents=max_agents, + max_objects=max_objects, + total_ent_sub_types=total_ent_sub_types, + box_size=box_size, + neighbor_radius=neighbor_radius, + collision_alpha=collision_alpha, + collision_eps=collision_eps, + dt=dt + ) + + return state + +state = init_state(entities_data=entities_data) \ No newline at end of file diff --git a/vivarium/experimental/notebooks/braitenberg_selective_sensing.ipynb b/vivarium/experimental/notebooks/braitenberg_selective_sensing.ipynb index 4b6853a..d801f22 100644 --- a/vivarium/experimental/notebooks/braitenberg_selective_sensing.ipynb +++ b/vivarium/experimental/notebooks/braitenberg_selective_sensing.ipynb @@ -1,845 +1,37 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Quick tutorial to explain how to create a environment with braitenberg vehicles equiped with selective sensors (still a draft so comments of the notebook won't be complete yet)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import logging as lg\n", - "\n", - "from enum import Enum\n", - "from functools import partial\n", - "from typing import Tuple\n", - "\n", - "import jax\n", - "import numpy as np\n", - "import jax.numpy as jnp\n", - "import matplotlib.colors as mcolors\n", - "\n", - "from jax import vmap, jit\n", - "from jax import random, ops, lax\n", - "\n", - "from flax import struct\n", - "from jax_md.rigid_body import RigidBody\n", - "from jax_md import simulate \n", - "from jax_md import space, rigid_body, partition, quantity\n", - "\n", - "from vivarium.experimental.environments.utils import normal, distance \n", - "from vivarium.experimental.environments.base_env import BaseState, BaseEnv\n", - "from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn\n", - "from vivarium.experimental.environments.braitenberg.simple import relative_position, proximity_map, sensor_fn, sensor\n", - "from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params, linear_behavior\n", - "from vivarium.experimental.environments.braitenberg.simple import lr_2_fwd_rot, fwd_rot_2_lr, motor_command\n", - "from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Used for jax.debug.breakpoint in a jupyter notebook\n", - "class FakeStdin:\n", - " def readline(self):\n", - " return input()\n", - " \n", - "# Usage : \n", - "# jax.debug.breakpoint(backend=\"cli\", stdin=FakeStdin())\n", - "\n", - "# See this issue : https://github.com/google/jax/issues/11880" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create the classes and helper functions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Add entity sensed type as a field in entities + sensed in agents. The agents sense the \"sensed type\" of the entities. In our case, there will be preys, predators, ressources and poison." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "### Define the constants and the classes of the environment to store its state ###\n", - "SPACE_NDIMS = 2\n", - "\n", - "class EntityType(Enum):\n", - " AGENT = 0\n", - " OBJECT = 1\n", - "\n", - "# Already incorporates position, momentum, force, mass and velocity\n", - "@struct.dataclass\n", - "class EntityState(simulate.NVEState):\n", - " entity_type: jnp.array\n", - " ent_subtype: jnp.array\n", - " entity_idx: jnp.array\n", - " diameter: jnp.array\n", - " friction: jnp.array\n", - " exists: jnp.array\n", - " \n", - "@struct.dataclass\n", - "class ParticleState:\n", - " ent_idx: jnp.array\n", - " color: jnp.array\n", - "\n", - "@struct.dataclass\n", - "class AgentState(ParticleState):\n", - " prox: jnp.array\n", - " motor: jnp.array\n", - " proximity_map_dist: jnp.array\n", - " proximity_map_theta: jnp.array\n", - " behavior: jnp.array\n", - " params: jnp.array\n", - " sensed: jnp.array\n", - " wheel_diameter: jnp.array\n", - " speed_mul: jnp.array\n", - " max_speed: jnp.array\n", - " theta_mul: jnp.array \n", - " proxs_dist_max: jnp.array\n", - " proxs_cos_min: jnp.array\n", - "\n", - "@struct.dataclass\n", - "class ObjectState(ParticleState):\n", - " pass\n", - "\n", - "@struct.dataclass\n", - "class State(BaseState):\n", - " max_agents: jnp.int32\n", - " max_objects: jnp.int32\n", - " neighbor_radius: jnp.float32\n", - " dt: jnp.float32 # Give a more explicit name\n", - " collision_alpha: jnp.float32\n", - " collision_eps: jnp.float32\n", - " ent_sub_types: dict\n", - " entities: EntityState\n", - " agents: AgentState\n", - " objects: ObjectState " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define get_relative_displacement" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO : Should refactor the function to split the returns\n", - "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n", - " \"\"\"Get all infos relative to distance and orientation between all agents and their neighbors\n", - "\n", - " :param state: state\n", - " :param agents_neighs_idx: idx all agents neighbors\n", - " :param displacement_fn: jax md function enabling to know the distance between points\n", - " :return: distance array, angles array, distance map for all agents, angles map for all agents\n", - " \"\"\"\n", - " body = state.entities.position\n", - " senders, receivers = agents_neighs_idx\n", - " Ra = body.center[senders]\n", - " Rb = body.center[receivers]\n", - " dR = - space.map_bond(displacement_fn)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", - "\n", - " dist, theta = proximity_map(dR, body.orientation[senders])\n", - " proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n", - " proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)\n", - " proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n", - " proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)\n", - " return dist, theta, proximity_map_dist, proximity_map_theta" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "to compute motors, only use linear behaviors (don't vmap it) because we vmap the functions to compute agents proxiemters and motors at a higher level \n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def linear_behavior(proxs, params):\n", - " \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n", - "\n", - " :param proxs: proximeter values of an agent\n", - " :param params: parameters of an agent (mapping proxs to motor values)\n", - " :return: motor values\n", - " \"\"\"\n", - " return params.dot(jnp.hstack((proxs, 1.)))\n", - "\n", - "def compute_motor(proxs, params, behaviors, motors):\n", - " \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n", - "\n", - " :param proxs: proximeters of all agents\n", - " :param params: parameters mapping proximeters to new motor values\n", - " :param behaviors: array of behaviors\n", - " :param motors: current motor values\n", - " :return: new motor values\n", - " \"\"\"\n", - " manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n", - " manual_mask = manual\n", - " linear_motor_values = linear_behavior(proxs, params)\n", - " motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n", - " return motor_values" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1 : Add functions to compute the proximeters and motors of agents with occlusion\n", - "\n", - "Logic for computing sensors and motors: \n", - "\n", - "- We get the raw proxs\n", - "- We get the ent types of the two detected entities (left and right)\n", - "- For each behavior, we updated the proxs according to the detected and the sensed entities (e.g sensed entities = [0, 1, 0 , 0] : only sense ent of type 1)\n", - "- We then compute the motor values for each behavior and do a mean of them " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create functions to update the two proximeter of an agent for a specific behavior \n", - "\n", - "- We already have the two closest proximeters in this case\n", - "- We want to compute the value of motors associated to a behavior for these proxs\n", - "- We can sense different type of entities \n", - "- The two proximeters are each associated to a specific entity type\n", - "- So if the specific entity type is detected, the proximeter value is kept \n", - "- Else it is set to 0 so it won't have effect on the motor values \n", - "- To do so we use a mask (mask of 1's, if an entity is detected we set it to 0 with a multiplication)\n", - "- So if the mask is already set to 0 (i.e the ent is detected), the masked value will still be 0 even if you multiply it by 1\n", - "- Then we update the proximeter values with a jnp.where" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def update_mask(mask, left_n_right_types, ent_type):\n", - " \"\"\"Update a mask of \n", - "\n", - " :param mask: mask that will be applied on sensors of agents\n", - " :param left_n_right_types: types of left adn right sensed entities\n", - " :param ent_type: entity subtype (e.g 1 for predators)\n", - " :return: mask\n", - " \"\"\"\n", - " cur = jnp.where(left_n_right_types == ent_type, 0, 1)\n", - " mask *= cur\n", - " return mask\n", - "\n", - "def keep_mask(mask, left_n_right_types, ent_type):\n", - " \"\"\"Return the mask unchanged\n", - "\n", - " :param mask: mask\n", - " :param left_n_right_types: left_n_right_types\n", - " :param ent_type: ent_type\n", - " :return: mask\n", - " \"\"\"\n", - " return mask\n", - "\n", - "def mask_proxs_occlusion(proxs, left_n_right_types, ent_sensed_arr):\n", - " \"\"\"Mask the proximeters of agents with occlusion\n", - "\n", - " :param proxs: proxiemters of agents without occlusion (shape = (2,))\n", - " :param e_sensed_types: types of both entities sensed at left and right (shape=(2,))\n", - " :param ent_sensed_arr: mask of sensed subtypes by the agent (e.g jnp.array([0, 1, 0, 1]) if sense only entities of subtype 1 and 4)\n", - " :return: updated proximeters according to sensed_subtypes\n", - " \"\"\"\n", - " mask = jnp.array([1, 1])\n", - " # Iterate on the array of sensed entities mask\n", - " for ent_type, sensed in enumerate(ent_sensed_arr):\n", - " # If an entity is sensed, update the mask, else keep it as it is\n", - " mask = jax.lax.cond(sensed, update_mask, keep_mask, mask, left_n_right_types, ent_type)\n", - " # Update the mask with 0s where the mask is, else keep the prox value\n", - " proxs = jnp.where(mask, 0, proxs)\n", - " return proxs\n", - "\n", - "# Example :\n", - "# ent_sensed_arr = jnp.array([0, 1, 0, 0, 1])\n", - "# proxs = jnp.array([0.8, 0.2])\n", - "# e_sensed_types = jnp.array([4, 4]) # Modify these values to check it works\n", - "# print(mask_proxs_occlusion(proxs, e_sensed_types, ent_sensed_arr))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a function to compute the motor values for a specific behavior \n", - "\n", - "- Convert the idx of the detected entitites (associated to the values of the two proximeters) into their types\n", - "- Mask their sensors with the function presented above \n", - "- Compute the motors with the updated sensors" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_behavior_motors(state, params, sensed_mask, behavior, motor, agent_proxs, sensed_ent_idx):\n", - " \"\"\"_summary_\n", - "\n", - " :param state: state\n", - " :param params: behavior params params\n", - " :param sensed_mask: sensed_mask for this behavior\n", - " :param behavior: behavior\n", - " :param motor: motor values\n", - " :param agent_proxs: agent proximeters (unmasked)\n", - " :param sensed_ent_idx: idx of left and right entities sensed \n", - " :return: right motor values for this behavior \n", - " \"\"\"\n", - " left_n_right_types = state.entities.ent_subtype[sensed_ent_idx]\n", - " behavior_proxs = mask_proxs_occlusion(agent_proxs, left_n_right_types, sensed_mask)\n", - " motors = compute_motor(behavior_proxs, params, behaviors=behavior, motors=motor)\n", - " return motors\n", - "\n", - "# See for the vectorizing idx because already in a vmaped function here\n", - "compute_all_behavior_motors = vmap(compute_behavior_motors, in_axes=(None, 0, 0, 0, None, None, None))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def linear_behavior(proxs, params):\n", - " \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n", - "\n", - " :param proxs: proximeter values of an agent\n", - " :param params: parameters of an agent (mapping proxs to motor values)\n", - " :return: motor values\n", - " \"\"\"\n", - " return params.dot(jnp.hstack((proxs, 1.)))\n", - "\n", - "def compute_motor(proxs, params, behaviors, motors):\n", - " \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n", - "\n", - " :param proxs: proximeters of all agents\n", - " :param params: parameters mapping proximeters to new motor values\n", - " :param behaviors: array of behaviors\n", - " :param motors: current motor values\n", - " :return: new motor values\n", - " \"\"\"\n", - " manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n", - " manual_mask = manual\n", - " linear_motor_values = linear_behavior(proxs, params)\n", - " motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n", - " return motor_values" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a function to compute the motor values each agent" - ] - }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "def compute_occlusion_proxs_motors(state, agent_idx, params, sensed, behaviors, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n", - " \"\"\"_summary_\n", - "\n", - " :param state: state\n", - " :param agent_idx: agent idx in entities\n", - " :param params: params arrays for all agent's behaviors\n", - " :param sensed: sensed mask arrays for all agent's behaviors\n", - " :param behaviors: agent behaviors array\n", - " :param motor: agent motors\n", - " :param raw_proxs: raw_proximeters for all agents (shape=(n_agents * (n_entities - 1), 2))\n", - " :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1))\n", - " :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1))\n", - " :return: _description_\n", - " \"\"\"\n", - " behavior = jnp.expand_dims(behaviors, axis=1) \n", - " # Compute the neighbors idx of the agent and get its raw proximeters (of shape (n_entities -1 , 2))\n", - " ent_ag_neighs_idx = ag_idx_dense_senders[agent_idx]\n", - " agent_raw_proxs = raw_proxs[ent_ag_neighs_idx]\n", + "import time\n", "\n", - " # Get the max and arg max of these proximeters on axis 0, gives results of shape (2,)\n", - " agent_proxs = jnp.max(agent_raw_proxs, axis=0)\n", - " argmax = jnp.argmax(agent_raw_proxs, axis=0)\n", - " # Get the real entity idx of the left and right sensed entities from dense neighborhoods\n", - " sensed_ent_idx = ag_idx_dense_receivers[agent_idx][argmax]\n", - " \n", - " # Compute the motor values for all behaviors and do a mean on it\n", - " motor_values = compute_all_behavior_motors(state, params, sensed, behavior, motor, agent_proxs, sensed_ent_idx)\n", - " motors = jnp.mean(motor_values, axis=0)\n", - "\n", - " return agent_proxs, motors\n", - "\n", - "compute_all_agents_proxs_motors_occl = vmap(compute_occlusion_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2 : Add functions to compute the proximeters and motors of agents without occlusion" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Add Mask sensors and don't change functions\n", - "\n", - "- mask_sensors: mask sensors according to sensed entity type for an agent\n", - "- don't change: return agent raw_proxs (surely return either the masked or the same prox array according to a sensed e type)\n", - "\n", - "Then for each agent, we iterate on all of his behaviors. For each behavior, we iterate on each possible sensed entity type. If the entity is sensed, we keep the raw proximeters of the agent as they are currently. If it is not, we mask the proximeters of the specific (non sensed) entity type." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx):\n", - " \"\"\"Mask the raw proximeters of agents for a specific entity type \n", - "\n", - " :param state: state\n", - " :param agent_raw_proxs: raw_proximeters of agent (shape=(n_entities - 1), 2)\n", - " :param ent_type_id: entity subtype id (e.g 0 for PREYS)\n", - " :param ent_neighbors_idx: idx of agent neighbors in entities arrays\n", - " :return: updated agent raw proximeters\n", - " \"\"\"\n", - " mask = jnp.where(state.entities.ent_subtype[ent_neighbors_idx] == ent_type_id, 0, 1)\n", - " mask = jnp.expand_dims(mask, 1)\n", - " mask = jnp.broadcast_to(mask, agent_raw_proxs.shape)\n", - " return agent_raw_proxs * mask\n", - "\n", - "def dont_change(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx):\n", - " \"\"\"Leave the agent raw_proximeters unchanged\n", - "\n", - " :param state: state\n", - " :param agent_raw_proxs: agent_raw_proxs\n", - " :param ent_type_id: ent_type_id\n", - " :param ent_neighbors_idx: ent_neighbors_idx\n", - " :return: agent_raw_proxs\n", - " \"\"\"\n", - " return agent_raw_proxs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n", - "\n", - "- compute_behavior_prox: compute the proxs for one behavior (enumerate through all the sensed entities on this particular behavior)\n", - "- compute_behavior_proxs_motors: use fn above to compute the proxs and compute the motor values according to the behavior\n", - "- -vmap compute_all_behavior_proxs_motors: computes this for all the behaviors of an agent\n", - "- compute_agent_proxs_motors: compute the proximeters and motor values of an agent for all its behaviors. Just return mean motor value\n", - "- -vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed_entities):\n", - " \"\"\"Compute the proximeters for a specific behavior\n", - "\n", - " :param state: state\n", - " :param agent_raw_proxs: agent raw proximeters\n", - " :param ent_neighbors_idx: idx of agent neighbors\n", - " :param sensed_entities: array of sensed entities\n", - " :return: updated proximeters\n", - " \"\"\"\n", - " # iterate over all the types in sensed_entities and return if they are sensed or not\n", - " for ent_type_id, sensed in enumerate(sensed_entities):\n", - " # change the proxs if you don't perceive the entity, else leave them unchanged\n", - " agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_neighbors_idx)\n", - " # Compute the final proxs with a max on the updated raw_proxs\n", - " proxs = jnp.max(agent_raw_proxs, axis=0)\n", - " return proxs\n", - "\n", - "def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx):\n", - " \"\"\"Return the proximeters and the motors for a specific behavior\n", - "\n", - " :param state: state\n", - " :param params: params of the behavior\n", - " :param sensed: sensed mask of the behavior\n", - " :param behavior: behavior\n", - " :param motor: motor values\n", - " :param agent_raw_proxs: agent_raw_proxs\n", - " :param ent_neighbors_idx: ent_neighbors_idx\n", - " :return: behavior proximeters, behavior motors\n", - " \"\"\"\n", - " behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed)\n", - " behavior_motors = compute_motor(behavior_prox, params, behavior, motor)\n", - " return behavior_prox, behavior_motors\n", - "\n", - "# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same)\n", - "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None))\n", - "\n", - "def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n", - " \"\"\"Compute the agent proximeters and motors for all behaviors\n", - "\n", - " :param state: state\n", - " :param agent_idx: idx of the agent in entities\n", - " :param params: array of params for all behaviors\n", - " :param sensed: array of sensed mask for all behaviors\n", - " :param behavior: array of behaviors\n", - " :param motor: motor values\n", - " :param raw_proxs: raw_proximeters of all agents\n", - " :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1))\n", - " :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1))\n", - " :return: array of agent_proximeters, mean of behavior motors\n", - " \"\"\"\n", - " behavior = jnp.expand_dims(behavior, axis=1)\n", - " ent_ag_idx = ag_idx_dense_senders[agent_idx]\n", - " ent_neighbors_idx = ag_idx_dense_receivers[agent_idx]\n", - " agent_raw_proxs = raw_proxs[ent_ag_idx]\n", - "\n", - " # vmap on params, sensed, behaviors and motorss (vmap on all agents)\n", - " agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx)\n", - " mean_agent_motors = jnp.mean(agent_motors, axis=0)\n", - "\n", - " return agent_proxs, mean_agent_motors\n", - "\n", - "compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Add classical braitenberg force fn" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create the main environment class" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "@struct.dataclass\n", - "class Neighbors:\n", - " neighbors: jnp.array\n", - " agents_neighs_idx: jnp.array\n", - " agents_idx_dense: jnp.array\n", - "\n", - "\n", - "#--- 4 Define the environment class with its different functions (step ...) ---#\n", - "class SelectiveSensorsEnv(BaseEnv):\n", - " def __init__(self, state, occlusion=True, seed=42):\n", - " \"\"\"Init the selective sensors braitenberg env \n", - "\n", - " :param state: simulation state already complete\n", - " :param occlusion: wether to use sensors with occlusion or not, defaults to True\n", - " :param seed: random seed, defaults to 42\n", - " \"\"\"\n", - " self.seed = seed\n", - " self.occlusion = occlusion\n", - " self.compute_all_agents_proxs_motors = self.choose_agent_prox_motor_function()\n", - " self.init_key = random.PRNGKey(seed)\n", - " self.displacement, self.shift = space.periodic(state.box_size)\n", - " self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n", - " self.neighbor_fn = partition.neighbor_list(\n", - " self.displacement, \n", - " state.box_size,\n", - " r_cutoff=state.neighbor_radius,\n", - " dr_threshold=10.,\n", - " capacity_multiplier=1.5,\n", - " format=partition.Sparse\n", - " )\n", - " self.neighbors_storage = self.allocate_neighbors(state)\n", - "\n", - " def distance(self, point1, point2):\n", - " \"\"\"Returns the distance between two points\n", - "\n", - " :param point1: point1 coordinates\n", - " :param point2: point1 coordinates\n", - " :return: distance between two points\n", - " \"\"\"\n", - " return distance(self.displacement, point1, point2)\n", - " \n", - " # At the moment doesn't work because the _step function isn't recompiled \n", - " def choose_agent_prox_motor_function(self):\n", - " \"\"\"Returns the function to compute the proximeters and the motors with or without occlusion\n", - "\n", - " :return: compute_all_agents_proxs_motors function\n", - " \"\"\"\n", - " if self.occlusion:\n", - " prox_motor_function = compute_all_agents_proxs_motors_occl\n", - " else:\n", - " prox_motor_function = compute_all_agents_proxs_motors\n", - " return prox_motor_function\n", - " \n", - " @partial(jit, static_argnums=(0,))\n", - " def _step(self, state: State, neighbors_storage: Neighbors) -> Tuple[State, jnp.array]:\n", - " \"\"\"Do 1 jitted step in the environment and return the updated state\n", - "\n", - " :param state: current state\n", - " :param neighbors_storage: class storing all neighbors information\n", - " :return: new sttae\n", - " \"\"\"\n", - "\n", - " # Retrieve different neighbors format\n", - " neighbors = neighbors_storage.neighbors\n", - " agents_neighs_idx = neighbors_storage.agents_neighs_idx\n", - " ag_idx_dense = neighbors_storage.agents_idx_dense\n", - " # Differences : compute raw proxs for all agents first \n", - " dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement)\n", - " senders, receivers = agents_neighs_idx\n", - "\n", - " dist_max = state.agents.proxs_dist_max[senders]\n", - " cos_min = state.agents.proxs_cos_min[senders]\n", - " target_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n", - " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exist_mask)\n", - "\n", - " # Could even just pass ag_idx_dense in the fn and do this inside\n", - " ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense\n", - "\n", - " agent_proxs, mean_agent_motors = self.compute_all_agents_proxs_motors(\n", - " state,\n", - " state.agents.ent_idx,\n", - " state.agents.params,\n", - " state.agents.sensed,\n", - " state.agents.behavior,\n", - " state.agents.motor,\n", - " raw_proxs,\n", - " ag_idx_dense_senders,\n", - " ag_idx_dense_receivers,\n", - " )\n", - "\n", - " agents = state.agents.replace(\n", - " prox=agent_proxs, \n", - " proximity_map_dist=proximity_dist_map, \n", - " proximity_map_theta=proximity_dist_theta,\n", - " motor=mean_agent_motors\n", - " )\n", - "\n", - " # Last block unchanged\n", - " state = state.replace(agents=agents)\n", - " entities = self.apply_physics(state, neighbors)\n", - " state = state.replace(time=state.time+1, entities=entities)\n", - " neighbors = neighbors.update(state.entities.position.center)\n", - "\n", - " return state, neighbors\n", - " \n", - " def step(self, state: State) -> State:\n", - " \"\"\"Do 1 step in the environment and return the updated state. This function also handles the neighbors mechanism and hence isn't jitted\n", - "\n", - " :param state: current state\n", - " :return: next state\n", - " \"\"\"\n", - " # Because momentum is initialized to None, need to initialize it with init_fn from jax_md\n", - " if state.entities.momentum is None:\n", - " state = self.init_fn(state, self.init_key)\n", - " \n", - " # Compute next state\n", - " current_state = state\n", - " state, neighbors = self._step(current_state, self.neighbors_storage)\n", - "\n", - " # Check if neighbors buffer overflowed\n", - " if neighbors.did_buffer_overflow:\n", - " # reallocate neighbors and run the simulation from current_state\n", - " lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')\n", - " self.neighbors_storage = self.allocate_neighbors(state)\n", - " assert not neighbors.did_buffer_overflow\n", - "\n", - " return state\n", - "\n", - " def allocate_neighbors(self, state, position=None):\n", - " \"\"\"Allocate the neighbors according to the state\n", - "\n", - " :param state: state\n", - " :param position: position of entities in the state, defaults to None\n", - " :return: Neighbors object with neighbors (sparse representation), idx of agent's neighbors, neighbors (dense representation) \n", - " \"\"\"\n", - " # get the sparse representation of neighbors (shape=(n_neighbors_pairs, 2))\n", - " position = state.entities.position.center if position is None else position\n", - " neighbors = self.neighbor_fn.allocate(position)\n", - "\n", - " # Also update the neighbor idx of agents\n", - " ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", - " agents_neighs_idx = neighbors.idx[:, ag_idx]\n", - "\n", - " # Give the idx of the agents in sparse representation, under a dense representation (used to get the raw proxs in compute motors function)\n", - " agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)]) \n", - " # Note: jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() ~ jnp.where(agents_idx[0, :] == idx)\n", - " \n", - " # Give the idx of the agent neighbors in dense representation\n", - " agents_idx_dense_receivers = agents_neighs_idx[1, :][agents_idx_dense_senders]\n", - " agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n", - "\n", - " neighbor_storage = Neighbors(neighbors=neighbors, agents_neighs_idx=agents_neighs_idx, agents_idx_dense=agents_idx_dense)\n", - " return neighbor_storage\n", - " \n" + "from vivarium.experimental.environments.braitenberg.selective_sensing import SelectiveSensorsEnv, init_state\n", + "from vivarium.experimental.environments.braitenberg.render import render, render_history" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Create the state\n", + "## Init and launch a simulation\n", "\n", - "First define helper functions to create agents selctive sensing behaviors" + "We define an environment with 4 types of entities, preys and predators as agents, and ressources and poison as objects. The data of each entity type are defined in a dictionary specifying their type, their number and their color, as well as their behaviors if they are agents. Then all this data is aggregated in an entities data dictionary passed to a function to init the state of the simulation." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "# Helper function to transform a color string into rgb with matplotlib colors\n", - "def _string_to_rgb(color_str):\n", - " return jnp.array(list(mcolors.to_rgb(color_str)))\n", - "\n", - "# Helper functions to define behaviors of agents in selecting sensing case\n", - "def define_behavior_map(behavior, sensed_mask):\n", - " params = behavior_to_params(behavior)\n", - " sensed_mask = jnp.array([sensed_mask])\n", - "\n", - " behavior_map = {\n", - " 'behavior': behavior,\n", - " 'params': params,\n", - " 'sensed_mask': sensed_mask\n", - " }\n", - " return behavior_map\n", - "\n", - "def stack_behaviors(behaviors_dict_list):\n", - " # init variables\n", - " n_behaviors = len(behaviors_dict_list)\n", - " sensed_length = behaviors_dict_list[0]['sensed_mask'].shape[1]\n", - "\n", - " params = np.zeros((n_behaviors, 2, 3)) # (2, 3) = params.shape\n", - " sensed_mask = np.zeros((n_behaviors, sensed_length))\n", - " behaviors = np.zeros((n_behaviors,))\n", - "\n", - " # iterate in the list of behaviors and update params and mask\n", - " for i in range(n_behaviors):\n", - " assert behaviors_dict_list[i]['sensed_mask'].shape[1] == sensed_length\n", - " params[i] = behaviors_dict_list[i]['params']\n", - " sensed_mask[i] = behaviors_dict_list[i]['sensed_mask']\n", - " behaviors[i] = behaviors_dict_list[i]['behavior']\n", - "\n", - " stacked_behavior_map = {\n", - " 'behaviors': behaviors,\n", - " 'params': params,\n", - " 'sensed_mask': sensed_mask\n", - " }\n", - "\n", - " return stacked_behavior_map\n", - "\n", - "def get_agents_params_and_sensed_arr(agents_stacked_behaviors_list):\n", - " n_agents = len(agents_stacked_behaviors_list)\n", - " params_shape = agents_stacked_behaviors_list[0]['params'].shape\n", - " sensed_shape = agents_stacked_behaviors_list[0]['sensed_mask'].shape\n", - " behaviors_shape = agents_stacked_behaviors_list[0]['behaviors'].shape\n", - " # Init arrays w right shapes\n", - " params = np.zeros((n_agents, *params_shape))\n", - " sensed = np.zeros((n_agents, *sensed_shape))\n", - " behaviors = np.zeros((n_agents, *behaviors_shape))\n", - "\n", - " for i in range(n_agents):\n", - " assert agents_stacked_behaviors_list[i]['params'].shape == params_shape\n", - " assert agents_stacked_behaviors_list[i]['sensed_mask'].shape == sensed_shape\n", - " assert agents_stacked_behaviors_list[i]['behaviors'].shape == behaviors_shape\n", - " params[i] = agents_stacked_behaviors_list[i]['params']\n", - " sensed[i] = agents_stacked_behaviors_list[i]['sensed_mask']\n", - " behaviors[i] = agents_stacked_behaviors_list[i]['behaviors']\n", - "\n", - " params = jnp.array(params)\n", - " sensed = jnp.array(sensed)\n", - " behaviors = jnp.array(behaviors)\n", - "\n", - " return params, sensed, behaviors" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "seed = 0\n", - "n_dims = 2\n", - "box_size = 100\n", - "diameter = 5.0\n", - "friction = 0.1\n", - "mass_center = 1.0\n", - "mass_orientation = 0.125\n", - "neighbor_radius = 100.0\n", - "collision_alpha = 0.5\n", - "collision_eps = 0.1\n", - "dt = 0.1\n", - "wheel_diameter = 2.0\n", - "speed_mul = 1.0\n", - "max_speed = 10.0\n", - "theta_mul = 1.0\n", - "prox_dist_max = 40.0\n", - "prox_cos_min = 0.0\n", - "existing_agents = None\n", - "existing_objects = None\n", - "\n", - "entities_sbutypes = ['PREYS', 'PREDS', 'RESSOURCES', 'POISON']\n", - "n_preys, preys_color = 5, 'blue'\n", - "n_preds, preds_color = 5, 'red'\n", - "n_ressources, ressources_color = 5, 'green'\n", - "n_poison, poison_color = 5, 'purple'\n", + "entities_subtypes = ['PREYS', 'PREDS', 'RESSOURCES', 'POISON']\n", "\n", "preys_data = {\n", " 'type': 'AGENT',\n", - " 'num': n_preys,\n", + " 'num': 5,\n", " 'color': 'blue',\n", " 'selective_behaviors': {\n", " 'love': {'beh': 'LOVE', 'sensed': ['PREYS', 'RESSOURCES']},\n", @@ -867,7 +59,7 @@ " 'color': 'purple'}\n", "\n", "entities_data = {\n", - " 'EntitySubTypes': entities_sbutypes,\n", + " 'EntitySubTypes': entities_subtypes,\n", " 'Entities': {\n", " 'PREYS': preys_data,\n", " 'PREDS': preds_data,\n", @@ -876,387 +68,96 @@ " }}" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Entities\n", - "\n", - "Compared to simple Braitenberg env, just need to add a field ent_subtypes." - ] - }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "def init_entities(\n", - " max_agents,\n", - " max_objects,\n", - " ent_sub_types,\n", - " n_dims=n_dims,\n", - " box_size=box_size,\n", - " existing_agents=None,\n", - " existing_objects=None,\n", - " mass_center=mass_center,\n", - " mass_orientation=mass_orientation,\n", - " diameter=diameter,\n", - " friction=friction,\n", - " key_agents_pos=random.PRNGKey(seed),\n", - " key_objects_pos=random.PRNGKey(seed+1),\n", - " key_orientations=random.PRNGKey(seed+2)\n", - "):\n", - " \"\"\"Init the sub entities state\"\"\"\n", - " existing_agents = max_agents if not existing_agents else existing_agents\n", - " existing_objects = max_objects if not existing_objects else existing_objects\n", - "\n", - " n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects \n", - " # Assign random positions to each entity in the environment\n", - " agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size\n", - " objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size\n", - " positions = jnp.concatenate((agents_positions, objects_positions))\n", - " # Assign random orientations between 0 and 2*pi to each entity\n", - " orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi\n", - " # Assign types to the entities\n", - " agents_entities = jnp.full(max_agents, EntityType.AGENT.value)\n", - " object_entities = jnp.full(max_objects, EntityType.OBJECT.value)\n", - " entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)\n", - " # Define arrays with existing entities\n", - " exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))\n", - " exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))\n", - " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", - "\n", - " # Works because dictionaries are ordered in Python\n", - " ent_subtypes = np.zeros(n_entities)\n", - " cur_idx = 0\n", - " for subtype_id, n_subtype in ent_sub_types.values():\n", - " ent_subtypes[cur_idx:cur_idx+n_subtype] = subtype_id\n", - " cur_idx += n_subtype\n", - " ent_subtypes = jnp.array(ent_subtypes, dtype=int) \n", - "\n", - " return EntityState(\n", - " position=RigidBody(center=positions, orientation=orientations),\n", - " momentum=None,\n", - " force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),\n", - " mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),\n", - " entity_type=entity_types,\n", - " ent_subtype=ent_subtypes,\n", - " entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),\n", - " diameter=jnp.full((n_entities), diameter),\n", - " friction=jnp.full((n_entities), friction),\n", - " exists=exists\n", - " )\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Agents\n", - "\n", - "Now this section becomes pretty different. We need to have several behaviors for each agent. \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "def init_agents(\n", - " max_agents,\n", - " params,\n", - " sensed,\n", - " behaviors,\n", - " agents_color,\n", - " wheel_diameter=wheel_diameter,\n", - " speed_mul=speed_mul,\n", - " max_speed=max_speed,\n", - " theta_mul=theta_mul,\n", - " prox_dist_max=prox_dist_max,\n", - " prox_cos_min=prox_cos_min\n", - "):\n", - " \"\"\"Init the sub agents state\"\"\"\n", - " return AgentState(\n", - " # idx in the entities (ent_idx) state to map agents information in the different data structures\n", - " ent_idx=jnp.arange(max_agents, dtype=int), \n", - " prox=jnp.zeros((max_agents, 2)),\n", - " motor=jnp.zeros((max_agents, 2)),\n", - " behavior=behaviors,\n", - " params=params,\n", - " sensed=sensed,\n", - " wheel_diameter=jnp.full((max_agents), wheel_diameter),\n", - " speed_mul=jnp.full((max_agents), speed_mul),\n", - " max_speed=jnp.full((max_agents), max_speed),\n", - " theta_mul=jnp.full((max_agents), theta_mul),\n", - " proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n", - " proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n", - " proximity_map_dist=jnp.zeros((max_agents, 1)),\n", - " proximity_map_theta=jnp.zeros((max_agents, 1)),\n", - " color=agents_color\n", - " )" + "state = init_state(entities_data)\n", + "env = SelectiveSensorsEnv(state, occlusion=True)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "def init_objects(\n", - " max_agents,\n", - " max_objects,\n", - " objects_color\n", - "):\n", - " \"\"\"Init the sub objects state\"\"\"\n", - " start_idx, stop_idx = max_agents, max_agents + max_objects \n", - " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", + "n_steps = 5_000\n", + "hist = []\n", "\n", - " return ObjectState(\n", - " ent_idx=objects_ent_idx,\n", - " color=objects_color\n", - " )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "def init_complete_state(\n", - " entities,\n", - " agents,\n", - " objects,\n", - " max_agents,\n", - " max_objects,\n", - " total_ent_sub_types,\n", - " box_size=box_size,\n", - " neighbor_radius=neighbor_radius,\n", - " collision_alpha=collision_alpha,\n", - " collision_eps=collision_eps,\n", - " dt=dt,\n", - "):\n", - " \"\"\"Init the complete state\"\"\"\n", - " return State(\n", - " time=0,\n", - " dt=dt,\n", - " box_size=box_size,\n", - " max_agents=max_agents,\n", - " max_objects=max_objects,\n", - " neighbor_radius=neighbor_radius,\n", - " collision_alpha=collision_alpha,\n", - " collision_eps=collision_eps,\n", - " entities=entities,\n", - " agents=agents,\n", - " objects=objects,\n", - " ent_sub_types=total_ent_sub_types\n", - " ) " + "for i in range(n_steps):\n", + " state = env.step(state)\n", + " hist.append(state)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "\n", - "def init_state(\n", - " entities_data,\n", - " box_size=box_size,\n", - " dt=dt,\n", - " neighbor_radius=neighbor_radius,\n", - " collision_alpha=collision_alpha,\n", - " collision_eps=collision_eps,\n", - " n_dims=n_dims,\n", - " seed=seed,\n", - " diameter=diameter,\n", - " friction=friction,\n", - " mass_center=mass_center,\n", - " mass_orientation=mass_orientation,\n", - " existing_agents=None,\n", - " existing_objects=None,\n", - " wheel_diameter=wheel_diameter,\n", - " speed_mul=speed_mul,\n", - " max_speed=max_speed,\n", - " theta_mul=theta_mul,\n", - " prox_dist_max=prox_dist_max,\n", - " prox_cos_min=prox_cos_min,\n", - ") -> State:\n", - " key = random.PRNGKey(seed)\n", - " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", - " \n", - " # create an enum for entities subtypes\n", - " ent_sub_types = entities_data['EntitySubTypes']\n", - " ent_sub_types_enum = Enum('ent_sub_types_enum', {ent_sub_types[i]: i for i in range(len(ent_sub_types))}) \n", - " ent_data = entities_data['Entities']\n", - "\n", - " # create max agents and max objects\n", - " max_agents = 0\n", - " max_objects = 0 \n", - "\n", - " # create agent and objects dictionaries \n", - " agents_data = {}\n", - " objects_data = {}\n", - "\n", - " # iterate over the entities subtypes\n", - " for ent_sub_type in ent_sub_types:\n", - " # get their data in the ent_data\n", - " data = ent_data[ent_sub_type]\n", - " color_str = data['color']\n", - " color = _string_to_rgb(color_str)\n", - " n = data['num']\n", - "\n", - " # Check if the entity is an agent or an object\n", - " if data['type'] == 'AGENT':\n", - " max_agents += n\n", - " behavior_list = []\n", - " # create a behavior list for all behaviors of the agent\n", - " for beh_name, behavior_data in data['selective_behaviors'].items():\n", - " beh_name = behavior_data['beh']\n", - " behavior_id = Behaviors[beh_name].value\n", - " # Init an empty mask\n", - " sensed_mask = np.zeros((len(ent_sub_types, )))\n", - " for sensed_type in behavior_data['sensed']:\n", - " # Iteratively update it with specific sensed values\n", - " sensed_id = ent_sub_types_enum[sensed_type].value\n", - " sensed_mask[sensed_id] = 1\n", - " beh = define_behavior_map(behavior_id, sensed_mask)\n", - " behavior_list.append(beh)\n", - " # stack the elements of the behavior list and update the agents_data dictionary\n", - " stacked_behaviors = stack_behaviors(behavior_list)\n", - " agents_data[ent_sub_type] = {'n': n, 'color': color, 'stacked_behs': stacked_behaviors}\n", - "\n", - " # only updated object counters and color if entity is an object\n", - " elif data['type'] == 'OBJECT':\n", - " max_objects += n\n", - " objects_data[ent_sub_type] = {'n': n, 'color': color}\n", - "\n", - " # Create the params, sensed, behaviors and colors arrays \n", - "\n", - " # init empty lists\n", - " colors = []\n", - " agents_stacked_behaviors_list = []\n", - " total_ent_sub_types = {}\n", - " for agent_type, data in agents_data.items():\n", - " n = data['n']\n", - " stacked_behavior = data['stacked_behs']\n", - " n_stacked_behavior = list([stacked_behavior] * n)\n", - " tiled_color = list(np.tile(data['color'], (n, 1)))\n", - " # update the lists with behaviors and color elements\n", - " agents_stacked_behaviors_list = agents_stacked_behaviors_list + n_stacked_behavior\n", - " colors = colors + tiled_color\n", - " total_ent_sub_types[agent_type] = (ent_sub_types_enum[agent_type].value, n)\n", - "\n", - " # create the final jnp arrays\n", - " agents_colors = jnp.concatenate(jnp.array([colors]), axis=0)\n", - " params, sensed, behaviors = get_agents_params_and_sensed_arr(agents_stacked_behaviors_list)\n", - "\n", - " # do the same for objects colors\n", - " colors = []\n", - " for objecy_type, data in objects_data.items():\n", - " n = data['n']\n", - " tiled_color = list(np.tile(data['color'], (n, 1)))\n", - " colors = colors + tiled_color\n", - " total_ent_sub_types[objecy_type] = (ent_sub_types_enum[objecy_type].value, n)\n", - "\n", - " objects_colors = jnp.concatenate(jnp.array([colors]), axis=0)\n", - " # print(total_ent_sub_types)\n", - "\n", - " # Init sub states and total state\n", - " entities = init_entities(max_agents=max_agents, max_objects=max_objects, ent_sub_types=total_ent_sub_types)\n", - " agents = init_agents(max_agents=max_agents, behaviors=behaviors, params=params, sensed=sensed, agents_color=agents_colors)\n", - " objects = init_objects(max_agents=max_agents, max_objects=max_objects, objects_color=objects_colors)\n", - " state = init_complete_state(entities=entities, agents=agents, objects=objects, max_agents=max_agents, max_objects=max_objects, total_ent_sub_types=total_ent_sub_types)\n", - " return state\n", - "\n", - "state = init_state(entities_data=entities_data)" + "render_history(hist, skip_frames=50)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Recap of the state\n", - "\n", - "### Agents\n", - "\n", - "Preys:\n", - "- Love: other preys and ressources\n", - "- Fear: predators and poison\n", - "- Color: Blue\n", - "\n", - "Predators:\n", - "- Aggression: preys\n", - "- Fear: Poison\n", - "- Color: Red\n", - "\n", - "### Objects\n", - "\n", - "Ressources\n", - "- Color: green\n", + "## Add new types of entities\n", "\n", - "Poison\n", - "- Color: purple" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Test the simulation" + "Add a new entity type, for example we'll add a 'dumb' agents that is aggressive towards every entity he encounters (even other dumbs)." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "from vivarium.experimental.environments.braitenberg.render import render, render_history" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "render(state)" + "# Define data for new entity\n", + "new_subtypes = ['DUMB']\n", + "\n", + "dumb_data = {\n", + " 'type': 'AGENT',\n", + " 'num': 5,\n", + " 'color': 'gray',\n", + " 'selective_behaviors': {\n", + " 'aggr': {'beh': 'AGGRESSION','sensed': ['PREYS', 'PREDS', 'RESSOURCES', 'POISON', 'DUMB']},\n", + " 'fear': {'beh': 'FEAR','sensed': []\n", + " }\n", + " }}\n", + "\n", + "# Update the entities data\n", + "entities_data['EntitySubTypes'] += new_subtypes\n", + "entities_data['Entities']['DUMB'] = dumb_data" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ + "state = init_state(entities_data)\n", "env = SelectiveSensorsEnv(state, occlusion=True)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -1270,12 +171,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1292,51 +193,76 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Test manual behavior for an agent\n", + "## Scale the size of the simulation\n", "\n", - "Need to set all of its behaviors to manual." + "Launch a simulation with a bigger box size, as well as more agents and objects. Increase the box_size and the max distance of proximeters." ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "ag_idx = 9\n", - "manual_behaviors = jnp.array([Behaviors.MANUAL.value, Behaviors.MANUAL.value,])\n", - "manual_color = jnp.array([0., 0., 0.])\n", - "manual_motors = jnp.array([1., 1.])\n", - "\n", - "behaviors = state.agents.behavior.at[ag_idx].set(manual_behaviors)\n", - "colors = state.agents.color.at[ag_idx].set(manual_color)\n", - "motors = state.agents.motor.at[ag_idx].set(manual_motors)\n", + "box_size = 1000\n", + "prox_dist_max = 100\n", "\n", - "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n", - "state = state.replace(agents=agents)" + "for ent_type, data in entities_data['Entities'].items():\n", + " data['num'] = 25" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "hist = []\n", + "# set the neighbor radius to the box_size to ensure the agents all have neighbors arrays of same shape\n", + "state = init_state(entities_data=entities_data, box_size=box_size, neighbor_radius=box_size, prox_dist_max=prox_dist_max)\n", + "env = SelectiveSensorsEnv(state, occlusion=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0\n", + "step 5000\n", + "step 10000\n", + "step 15000\n", + "Simulation ran in 41.65424467300181 for 20000 timesteps\n" + ] + } + ], + "source": [ + "n_steps = 20_000\n", "\n", + "hist = []\n", + "start = time.perf_counter()\n", "for i in range(n_steps):\n", - " state = env.step(state)\n", - " hist.append(state)" + " if i % 5000 == 0:\n", + " print(f\"step {i}\")\n", + " state = env.step(state) \n", + " hist.append(state)\n", + "end = time.perf_counter()\n", + "\n", + "time = end - start\n", + "print(f\"Simulation ran in {time} for {n_steps} timesteps\")" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1346,7 +272,15 @@ } ], "source": [ - "render_history(hist, skip_frames=50)" + "render_history(hist, skip_frames=100)\n", + "# (Need to update the rendering of the env because the sizes aren't accurate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Blue agents (preys) move way more because they have a love behavior attached to them. So by default they will have their motors set to 1 except if they find an entity they love, or an entity they fear (because they also have a fear behavior attached). On the contrary, the predators only move if they see an agent in their visual field." ] } ], diff --git a/vivarium/experimental/notebooks/braitenberg_selective_sensing_developper.ipynb b/vivarium/experimental/notebooks/braitenberg_selective_sensing_developper.ipynb new file mode 100644 index 0000000..cac5983 --- /dev/null +++ b/vivarium/experimental/notebooks/braitenberg_selective_sensing_developper.ipynb @@ -0,0 +1,1309 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tutorial to explain how to create a environment with braitenberg vehicles equiped with selective sensors" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import logging as lg\n", + "\n", + "from enum import Enum\n", + "from functools import partial\n", + "from typing import Tuple\n", + "\n", + "import jax\n", + "import numpy as np\n", + "import jax.numpy as jnp\n", + "import matplotlib.colors as mcolors\n", + "\n", + "from jax import vmap, jit\n", + "from jax import random, lax\n", + "\n", + "from flax import struct\n", + "from jax_md.rigid_body import RigidBody\n", + "from jax_md import simulate \n", + "from jax_md import space, partition\n", + "\n", + "from vivarium.experimental.environments.utils import distance \n", + "from vivarium.experimental.environments.base_env import BaseState, BaseEnv\n", + "from vivarium.experimental.environments.physics_engine import dynamics_fn\n", + "from vivarium.experimental.environments.braitenberg.simple import proximity_map, sensor_fn\n", + "from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params\n", + "from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Used for jax.debug.breakpoint in a jupyter notebook\n", + "class FakeStdin:\n", + " def readline(self):\n", + " return input()\n", + " \n", + "# Usage : \n", + "# jax.debug.breakpoint(backend=\"cli\", stdin=FakeStdin())\n", + "\n", + "# See this issue : https://github.com/google/jax/issues/11880" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the classes and helper functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add entity sensed type as a field in entities + sensed in agents. The agents sense the \"sensed type\" of the entities. In our case, there will be preys, predators, ressources and poison." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "### Define the constants and the classes of the environment to store its state ###\n", + "SPACE_NDIMS = 2\n", + "\n", + "class EntityType(Enum):\n", + " AGENT = 0\n", + " OBJECT = 1\n", + "\n", + "# Already incorporates position, momentum, force, mass and velocity\n", + "@struct.dataclass\n", + "class EntityState(simulate.NVEState):\n", + " entity_type: jnp.array\n", + " ent_subtype: jnp.array\n", + " entity_idx: jnp.array\n", + " diameter: jnp.array\n", + " friction: jnp.array\n", + " exists: jnp.array\n", + " \n", + "@struct.dataclass\n", + "class ParticleState:\n", + " ent_idx: jnp.array\n", + " color: jnp.array\n", + "\n", + "@struct.dataclass\n", + "class AgentState(ParticleState):\n", + " prox: jnp.array\n", + " motor: jnp.array\n", + " proximity_map_dist: jnp.array\n", + " proximity_map_theta: jnp.array\n", + " behavior: jnp.array\n", + " params: jnp.array\n", + " sensed: jnp.array\n", + " wheel_diameter: jnp.array\n", + " speed_mul: jnp.array\n", + " max_speed: jnp.array\n", + " theta_mul: jnp.array \n", + " proxs_dist_max: jnp.array\n", + " proxs_cos_min: jnp.array\n", + "\n", + "@struct.dataclass\n", + "class ObjectState(ParticleState):\n", + " pass\n", + "\n", + "@struct.dataclass\n", + "class State(BaseState):\n", + " max_agents: jnp.int32\n", + " max_objects: jnp.int32\n", + " neighbor_radius: jnp.float32\n", + " dt: jnp.float32 # Give a more explicit name\n", + " collision_alpha: jnp.float32\n", + " collision_eps: jnp.float32\n", + " ent_sub_types: dict\n", + " entities: EntityState\n", + " agents: AgentState\n", + " objects: ObjectState " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define get_relative_displacement" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n", + " \"\"\"Get all infos relative to distance and orientation between all agents and their neighbors\n", + "\n", + " :param state: state\n", + " :param agents_neighs_idx: idx all agents neighbors\n", + " :param displacement_fn: jax md function enabling to know the distance between points\n", + " :return: distance array, angles array, distance map for all agents, angles map for all agents\n", + " \"\"\"\n", + " body = state.entities.position\n", + " senders, receivers = agents_neighs_idx\n", + " Ra = body.center[senders]\n", + " Rb = body.center[receivers]\n", + " dR = - space.map_bond(displacement_fn)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", + "\n", + " dist, theta = proximity_map(dR, body.orientation[senders])\n", + " proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n", + " proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)\n", + " proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n", + " proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)\n", + " return dist, theta, proximity_map_dist, proximity_map_theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "to compute motors, only use linear behaviors (don't vmap it) because we vmap the functions to compute agents proxiemters and motors at a higher level \n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_behavior(proxs, params):\n", + " \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n", + "\n", + " :param proxs: proximeter values of an agent\n", + " :param params: parameters of an agent (mapping proxs to motor values)\n", + " :return: motor values\n", + " \"\"\"\n", + " return params.dot(jnp.hstack((proxs, 1.)))\n", + "\n", + "def compute_motor(proxs, params, behaviors, motors):\n", + " \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n", + "\n", + " :param proxs: proximeters of all agents\n", + " :param params: parameters mapping proximeters to new motor values\n", + " :param behaviors: array of behaviors\n", + " :param motors: current motor values\n", + " :return: new motor values\n", + " \"\"\"\n", + " manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n", + " manual_mask = manual\n", + " linear_motor_values = linear_behavior(proxs, params)\n", + " motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n", + " return motor_values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1 : Add functions to compute the proximeters and motors of agents with occlusion\n", + "\n", + "Logic for computing sensors and motors: \n", + "\n", + "- We get the raw proxs\n", + "- We get the ent types of the two detected entities (left and right)\n", + "- For each behavior, we updated the proxs according to the detected and the sensed entities (e.g sensed entities = [0, 1, 0 , 0] : only sense ent of type 1)\n", + "- We then compute the motor values for each behavior and do a mean of them " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create functions to update the two proximeter of an agent for a specific behavior \n", + "\n", + "- We already have the two closest proximeters in this case\n", + "- We want to compute the value of motors associated to a behavior for these proxs\n", + "- We can sense different type of entities \n", + "- The two proximeters are each associated to a specific entity type\n", + "- So if the specific entity type is detected, the proximeter value is kept \n", + "- Else it is set to 0 so it won't have effect on the motor values \n", + "- To do so we use a mask (mask of 1's, if an entity is detected we set it to 0 with a multiplication)\n", + "- So if the mask is already set to 0 (i.e the ent is detected), the masked value will still be 0 even if you multiply it by 1\n", + "- Then we update the proximeter values with a jnp.where" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def update_mask(mask, left_n_right_types, ent_type):\n", + " \"\"\"Update a mask of \n", + "\n", + " :param mask: mask that will be applied on sensors of agents\n", + " :param left_n_right_types: types of left adn right sensed entities\n", + " :param ent_type: entity subtype (e.g 1 for predators)\n", + " :return: mask\n", + " \"\"\"\n", + " cur = jnp.where(left_n_right_types == ent_type, 0, 1)\n", + " mask *= cur\n", + " return mask\n", + "\n", + "def keep_mask(mask, left_n_right_types, ent_type):\n", + " \"\"\"Return the mask unchanged\n", + "\n", + " :param mask: mask\n", + " :param left_n_right_types: left_n_right_types\n", + " :param ent_type: ent_type\n", + " :return: mask\n", + " \"\"\"\n", + " return mask\n", + "\n", + "def mask_proxs_occlusion(proxs, left_n_right_types, ent_sensed_arr):\n", + " \"\"\"Mask the proximeters of agents with occlusion\n", + "\n", + " :param proxs: proxiemters of agents without occlusion (shape = (2,))\n", + " :param e_sensed_types: types of both entities sensed at left and right (shape=(2,))\n", + " :param ent_sensed_arr: mask of sensed subtypes by the agent (e.g jnp.array([0, 1, 0, 1]) if sense only entities of subtype 1 and 4)\n", + " :return: updated proximeters according to sensed_subtypes\n", + " \"\"\"\n", + " mask = jnp.array([1, 1])\n", + " # Iterate on the array of sensed entities mask\n", + " for ent_type, sensed in enumerate(ent_sensed_arr):\n", + " # If an entity is sensed, update the mask, else keep it as it is\n", + " mask = jax.lax.cond(sensed, update_mask, keep_mask, mask, left_n_right_types, ent_type)\n", + " # Update the mask with 0s where the mask is, else keep the prox value\n", + " proxs = jnp.where(mask, 0, proxs)\n", + " return proxs\n", + "\n", + "# Example :\n", + "# ent_sensed_arr = jnp.array([0, 1, 0, 0, 1])\n", + "# proxs = jnp.array([0.8, 0.2])\n", + "# e_sensed_types = jnp.array([4, 4]) # Modify these values to check it works\n", + "# print(mask_proxs_occlusion(proxs, e_sensed_types, ent_sensed_arr))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a function to compute the motor values for a specific behavior \n", + "\n", + "- Convert the idx of the detected entitites (associated to the values of the two proximeters) into their types\n", + "- Mask their sensors with the function presented above \n", + "- Compute the motors with the updated sensors" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_behavior_motors(state, params, sensed_mask, behavior, motor, agent_proxs, sensed_ent_idx):\n", + " \"\"\"_summary_\n", + "\n", + " :param state: state\n", + " :param params: behavior params params\n", + " :param sensed_mask: sensed_mask for this behavior\n", + " :param behavior: behavior\n", + " :param motor: motor values\n", + " :param agent_proxs: agent proximeters (unmasked)\n", + " :param sensed_ent_idx: idx of left and right entities sensed \n", + " :return: right motor values for this behavior \n", + " \"\"\"\n", + " left_n_right_types = state.entities.ent_subtype[sensed_ent_idx]\n", + " behavior_proxs = mask_proxs_occlusion(agent_proxs, left_n_right_types, sensed_mask)\n", + " motors = compute_motor(behavior_proxs, params, behaviors=behavior, motors=motor)\n", + " return motors\n", + "\n", + "# See for the vectorizing idx because already in a vmaped function here\n", + "compute_all_behavior_motors = vmap(compute_behavior_motors, in_axes=(None, 0, 0, 0, None, None, None))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_behavior(proxs, params):\n", + " \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n", + "\n", + " :param proxs: proximeter values of an agent\n", + " :param params: parameters of an agent (mapping proxs to motor values)\n", + " :return: motor values\n", + " \"\"\"\n", + " return params.dot(jnp.hstack((proxs, 1.)))\n", + "\n", + "def compute_motor(proxs, params, behaviors, motors):\n", + " \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n", + "\n", + " :param proxs: proximeters of all agents\n", + " :param params: parameters mapping proximeters to new motor values\n", + " :param behaviors: array of behaviors\n", + " :param motors: current motor values\n", + " :return: new motor values\n", + " \"\"\"\n", + " manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n", + " manual_mask = manual\n", + " linear_motor_values = linear_behavior(proxs, params)\n", + " motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n", + " return motor_values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a function to compute the motor values each agent" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_occlusion_proxs_motors(state, agent_idx, params, sensed, behaviors, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n", + " \"\"\"_summary_\n", + "\n", + " :param state: state\n", + " :param agent_idx: agent idx in entities\n", + " :param params: params arrays for all agent's behaviors\n", + " :param sensed: sensed mask arrays for all agent's behaviors\n", + " :param behaviors: agent behaviors array\n", + " :param motor: agent motors\n", + " :param raw_proxs: raw_proximeters for all agents (shape=(n_agents * (n_entities - 1), 2))\n", + " :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1))\n", + " :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1))\n", + " :return: _description_\n", + " \"\"\"\n", + " behavior = jnp.expand_dims(behaviors, axis=1) \n", + " # Compute the neighbors idx of the agent and get its raw proximeters (of shape (n_entities -1 , 2))\n", + " ent_ag_neighs_idx = ag_idx_dense_senders[agent_idx]\n", + " agent_raw_proxs = raw_proxs[ent_ag_neighs_idx]\n", + "\n", + " # Get the max and arg max of these proximeters on axis 0, gives results of shape (2,)\n", + " agent_proxs = jnp.max(agent_raw_proxs, axis=0)\n", + " argmax = jnp.argmax(agent_raw_proxs, axis=0)\n", + " # Get the real entity idx of the left and right sensed entities from dense neighborhoods\n", + " sensed_ent_idx = ag_idx_dense_receivers[agent_idx][argmax]\n", + " \n", + " # Compute the motor values for all behaviors and do a mean on it\n", + " motor_values = compute_all_behavior_motors(state, params, sensed, behavior, motor, agent_proxs, sensed_ent_idx)\n", + " motors = jnp.mean(motor_values, axis=0)\n", + "\n", + " return agent_proxs, motors\n", + "\n", + "compute_all_agents_proxs_motors_occl = vmap(compute_occlusion_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2 : Add functions to compute the proximeters and motors of agents without occlusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add Mask sensors and don't change functions\n", + "\n", + "- mask_sensors: mask sensors according to sensed entity type for an agent\n", + "- don't change: return agent raw_proxs (surely return either the masked or the same prox array according to a sensed e type)\n", + "\n", + "Then for each agent, we iterate on all of his behaviors. For each behavior, we iterate on each possible sensed entity type. If the entity is sensed, we keep the raw proximeters of the agent as they are currently. If it is not, we mask the proximeters of the specific (non sensed) entity type." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx):\n", + " \"\"\"Mask the raw proximeters of agents for a specific entity type \n", + "\n", + " :param state: state\n", + " :param agent_raw_proxs: raw_proximeters of agent (shape=(n_entities - 1), 2)\n", + " :param ent_type_id: entity subtype id (e.g 0 for PREYS)\n", + " :param ent_neighbors_idx: idx of agent neighbors in entities arrays\n", + " :return: updated agent raw proximeters\n", + " \"\"\"\n", + " mask = jnp.where(state.entities.ent_subtype[ent_neighbors_idx] == ent_type_id, 0, 1)\n", + " mask = jnp.expand_dims(mask, 1)\n", + " mask = jnp.broadcast_to(mask, agent_raw_proxs.shape)\n", + " return agent_raw_proxs * mask\n", + "\n", + "def dont_change(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx):\n", + " \"\"\"Leave the agent raw_proximeters unchanged\n", + "\n", + " :param state: state\n", + " :param agent_raw_proxs: agent_raw_proxs\n", + " :param ent_type_id: ent_type_id\n", + " :param ent_neighbors_idx: ent_neighbors_idx\n", + " :return: agent_raw_proxs\n", + " \"\"\"\n", + " return agent_raw_proxs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n", + "\n", + "- compute_behavior_prox: compute the proxs for one behavior (enumerate through all the sensed entities on this particular behavior)\n", + "- compute_behavior_proxs_motors: use fn above to compute the proxs and compute the motor values according to the behavior\n", + "- -vmap compute_all_behavior_proxs_motors: computes this for all the behaviors of an agent\n", + "- compute_agent_proxs_motors: compute the proximeters and motor values of an agent for all its behaviors. Just return mean motor value\n", + "- -vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed_entities):\n", + " \"\"\"Compute the proximeters for a specific behavior\n", + "\n", + " :param state: state\n", + " :param agent_raw_proxs: agent raw proximeters\n", + " :param ent_neighbors_idx: idx of agent neighbors\n", + " :param sensed_entities: array of sensed entities\n", + " :return: updated proximeters\n", + " \"\"\"\n", + " # iterate over all the types in sensed_entities and return if they are sensed or not\n", + " for ent_type_id, sensed in enumerate(sensed_entities):\n", + " # change the proxs if you don't perceive the entity, else leave them unchanged\n", + " agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_neighbors_idx)\n", + " # Compute the final proxs with a max on the updated raw_proxs\n", + " proxs = jnp.max(agent_raw_proxs, axis=0)\n", + " return proxs\n", + "\n", + "def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx):\n", + " \"\"\"Return the proximeters and the motors for a specific behavior\n", + "\n", + " :param state: state\n", + " :param params: params of the behavior\n", + " :param sensed: sensed mask of the behavior\n", + " :param behavior: behavior\n", + " :param motor: motor values\n", + " :param agent_raw_proxs: agent_raw_proxs\n", + " :param ent_neighbors_idx: ent_neighbors_idx\n", + " :return: behavior proximeters, behavior motors\n", + " \"\"\"\n", + " behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed)\n", + " behavior_motors = compute_motor(behavior_prox, params, behavior, motor)\n", + " return behavior_prox, behavior_motors\n", + "\n", + "# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same)\n", + "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None))\n", + "\n", + "def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n", + " \"\"\"Compute the agent proximeters and motors for all behaviors\n", + "\n", + " :param state: state\n", + " :param agent_idx: idx of the agent in entities\n", + " :param params: array of params for all behaviors\n", + " :param sensed: array of sensed mask for all behaviors\n", + " :param behavior: array of behaviors\n", + " :param motor: motor values\n", + " :param raw_proxs: raw_proximeters of all agents\n", + " :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1))\n", + " :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1))\n", + " :return: array of agent_proximeters, mean of behavior motors\n", + " \"\"\"\n", + " behavior = jnp.expand_dims(behavior, axis=1)\n", + " ent_ag_idx = ag_idx_dense_senders[agent_idx]\n", + " ent_neighbors_idx = ag_idx_dense_receivers[agent_idx]\n", + " agent_raw_proxs = raw_proxs[ent_ag_idx]\n", + "\n", + " # vmap on params, sensed, behaviors and motorss (vmap on all agents)\n", + " agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx)\n", + " mean_agent_motors = jnp.mean(agent_motors, axis=0)\n", + "\n", + " return agent_proxs, mean_agent_motors\n", + "\n", + "compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add classical braitenberg force fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the main environment class" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "@struct.dataclass\n", + "class Neighbors:\n", + " neighbors: jnp.array\n", + " agents_neighs_idx: jnp.array\n", + " agents_idx_dense: jnp.array\n", + "\n", + "\n", + "#--- 4 Define the environment class with its different functions (step ...) ---#\n", + "class SelectiveSensorsEnv(BaseEnv):\n", + " def __init__(self, state, occlusion=True, seed=42):\n", + " \"\"\"Init the selective sensors braitenberg env \n", + "\n", + " :param state: simulation state already complete\n", + " :param occlusion: wether to use sensors with occlusion or not, defaults to True\n", + " :param seed: random seed, defaults to 42\n", + " \"\"\"\n", + " self.seed = seed\n", + " self.occlusion = occlusion\n", + " self.compute_all_agents_proxs_motors = self.choose_agent_prox_motor_function()\n", + " self.init_key = random.PRNGKey(seed)\n", + " self.displacement, self.shift = space.periodic(state.box_size)\n", + " self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n", + " self.neighbor_fn = partition.neighbor_list(\n", + " self.displacement, \n", + " state.box_size,\n", + " r_cutoff=state.neighbor_radius,\n", + " dr_threshold=10.,\n", + " capacity_multiplier=1.5,\n", + " format=partition.Sparse\n", + " )\n", + " self.neighbors_storage = self.allocate_neighbors(state)\n", + "\n", + " def distance(self, point1, point2):\n", + " \"\"\"Returns the distance between two points\n", + "\n", + " :param point1: point1 coordinates\n", + " :param point2: point1 coordinates\n", + " :return: distance between two points\n", + " \"\"\"\n", + " return distance(self.displacement, point1, point2)\n", + " \n", + " # At the moment doesn't work because the _step function isn't recompiled \n", + " def choose_agent_prox_motor_function(self):\n", + " \"\"\"Returns the function to compute the proximeters and the motors with or without occlusion\n", + "\n", + " :return: compute_all_agents_proxs_motors function\n", + " \"\"\"\n", + " if self.occlusion:\n", + " prox_motor_function = compute_all_agents_proxs_motors_occl\n", + " else:\n", + " prox_motor_function = compute_all_agents_proxs_motors\n", + " return prox_motor_function\n", + " \n", + " @partial(jit, static_argnums=(0,))\n", + " def _step(self, state: State, neighbors_storage: Neighbors) -> Tuple[State, jnp.array]:\n", + " \"\"\"Do 1 jitted step in the environment and return the updated state\n", + "\n", + " :param state: current state\n", + " :param neighbors_storage: class storing all neighbors information\n", + " :return: new sttae\n", + " \"\"\"\n", + "\n", + " # Retrieve different neighbors format\n", + " neighbors = neighbors_storage.neighbors\n", + " agents_neighs_idx = neighbors_storage.agents_neighs_idx\n", + " ag_idx_dense = neighbors_storage.agents_idx_dense\n", + " # Differences : compute raw proxs for all agents first \n", + " dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement)\n", + " senders, receivers = agents_neighs_idx\n", + "\n", + " dist_max = state.agents.proxs_dist_max[senders]\n", + " cos_min = state.agents.proxs_cos_min[senders]\n", + " target_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n", + " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exist_mask)\n", + "\n", + " # Could even just pass ag_idx_dense in the fn and do this inside\n", + " ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense\n", + "\n", + " agent_proxs, mean_agent_motors = self.compute_all_agents_proxs_motors(\n", + " state,\n", + " state.agents.ent_idx,\n", + " state.agents.params,\n", + " state.agents.sensed,\n", + " state.agents.behavior,\n", + " state.agents.motor,\n", + " raw_proxs,\n", + " ag_idx_dense_senders,\n", + " ag_idx_dense_receivers,\n", + " )\n", + "\n", + " agents = state.agents.replace(\n", + " prox=agent_proxs, \n", + " proximity_map_dist=proximity_dist_map, \n", + " proximity_map_theta=proximity_dist_theta,\n", + " motor=mean_agent_motors\n", + " )\n", + "\n", + " # Last block unchanged\n", + " state = state.replace(agents=agents)\n", + " entities = self.apply_physics(state, neighbors)\n", + " state = state.replace(time=state.time+1, entities=entities)\n", + " neighbors = neighbors.update(state.entities.position.center)\n", + "\n", + " return state, neighbors\n", + " \n", + " def step(self, state: State) -> State:\n", + " \"\"\"Do 1 step in the environment and return the updated state. This function also handles the neighbors mechanism and hence isn't jitted\n", + "\n", + " :param state: current state\n", + " :return: next state\n", + " \"\"\"\n", + " # Because momentum is initialized to None, need to initialize it with init_fn from jax_md\n", + " if state.entities.momentum is None:\n", + " state = self.init_fn(state, self.init_key)\n", + " \n", + " # Compute next state\n", + " current_state = state\n", + " state, neighbors = self._step(current_state, self.neighbors_storage)\n", + "\n", + " # Check if neighbors buffer overflowed\n", + " if neighbors.did_buffer_overflow:\n", + " # reallocate neighbors and run the simulation from current_state\n", + " lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')\n", + " self.neighbors_storage = self.allocate_neighbors(state)\n", + " assert not neighbors.did_buffer_overflow\n", + "\n", + " return state\n", + "\n", + " def allocate_neighbors(self, state, position=None):\n", + " \"\"\"Allocate the neighbors according to the state\n", + "\n", + " :param state: state\n", + " :param position: position of entities in the state, defaults to None\n", + " :return: Neighbors object with neighbors (sparse representation), idx of agent's neighbors, neighbors (dense representation) \n", + " \"\"\"\n", + " # get the sparse representation of neighbors (shape=(n_neighbors_pairs, 2))\n", + " position = state.entities.position.center if position is None else position\n", + " neighbors = self.neighbor_fn.allocate(position)\n", + "\n", + " # Also update the neighbor idx of agents\n", + " ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", + " agents_neighs_idx = neighbors.idx[:, ag_idx]\n", + "\n", + " # Give the idx of the agents in sparse representation, under a dense representation (used to get the raw proxs in compute motors function)\n", + " agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)]) \n", + " # Note: jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() ~ jnp.where(agents_idx[0, :] == idx)\n", + " \n", + " # Give the idx of the agent neighbors in dense representation\n", + " agents_idx_dense_receivers = agents_neighs_idx[1, :][agents_idx_dense_senders]\n", + " agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n", + "\n", + " neighbor_storage = Neighbors(neighbors=neighbors, agents_neighs_idx=agents_neighs_idx, agents_idx_dense=agents_idx_dense)\n", + " return neighbor_storage\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the state\n", + "\n", + "First define helper functions to create agents selctive sensing behaviors" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Helper function to transform a color string into rgb with matplotlib colors\n", + "def _string_to_rgb(color_str):\n", + " return jnp.array(list(mcolors.to_rgb(color_str)))\n", + "\n", + "# Helper functions to define behaviors of agents in selecting sensing case\n", + "def define_behavior_map(behavior, sensed_mask):\n", + " params = behavior_to_params(behavior)\n", + " sensed_mask = jnp.array([sensed_mask])\n", + "\n", + " behavior_map = {\n", + " 'behavior': behavior,\n", + " 'params': params,\n", + " 'sensed_mask': sensed_mask\n", + " }\n", + " return behavior_map\n", + "\n", + "def stack_behaviors(behaviors_dict_list):\n", + " # init variables\n", + " n_behaviors = len(behaviors_dict_list)\n", + " sensed_length = behaviors_dict_list[0]['sensed_mask'].shape[1]\n", + "\n", + " params = np.zeros((n_behaviors, 2, 3)) # (2, 3) = params.shape\n", + " sensed_mask = np.zeros((n_behaviors, sensed_length))\n", + " behaviors = np.zeros((n_behaviors,))\n", + "\n", + " # iterate in the list of behaviors and update params and mask\n", + " for i in range(n_behaviors):\n", + " assert behaviors_dict_list[i]['sensed_mask'].shape[1] == sensed_length\n", + " params[i] = behaviors_dict_list[i]['params']\n", + " sensed_mask[i] = behaviors_dict_list[i]['sensed_mask']\n", + " behaviors[i] = behaviors_dict_list[i]['behavior']\n", + "\n", + " stacked_behavior_map = {\n", + " 'behaviors': behaviors,\n", + " 'params': params,\n", + " 'sensed_mask': sensed_mask\n", + " }\n", + "\n", + " return stacked_behavior_map\n", + "\n", + "def get_agents_params_and_sensed_arr(agents_stacked_behaviors_list):\n", + " n_agents = len(agents_stacked_behaviors_list)\n", + " params_shape = agents_stacked_behaviors_list[0]['params'].shape\n", + " sensed_shape = agents_stacked_behaviors_list[0]['sensed_mask'].shape\n", + " behaviors_shape = agents_stacked_behaviors_list[0]['behaviors'].shape\n", + " # Init arrays w right shapes\n", + " params = np.zeros((n_agents, *params_shape))\n", + " sensed = np.zeros((n_agents, *sensed_shape))\n", + " behaviors = np.zeros((n_agents, *behaviors_shape))\n", + "\n", + " for i in range(n_agents):\n", + " assert agents_stacked_behaviors_list[i]['params'].shape == params_shape\n", + " assert agents_stacked_behaviors_list[i]['sensed_mask'].shape == sensed_shape\n", + " assert agents_stacked_behaviors_list[i]['behaviors'].shape == behaviors_shape\n", + " params[i] = agents_stacked_behaviors_list[i]['params']\n", + " sensed[i] = agents_stacked_behaviors_list[i]['sensed_mask']\n", + " behaviors[i] = agents_stacked_behaviors_list[i]['behaviors']\n", + "\n", + " params = jnp.array(params)\n", + " sensed = jnp.array(sensed)\n", + " behaviors = jnp.array(behaviors)\n", + "\n", + " return params, sensed, behaviors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "seed = 0\n", + "n_dims = 2\n", + "box_size = 100\n", + "diameter = 5.0\n", + "friction = 0.1\n", + "mass_center = 1.0\n", + "mass_orientation = 0.125\n", + "neighbor_radius = 100.0\n", + "collision_alpha = 0.5\n", + "collision_eps = 0.1\n", + "dt = 0.1\n", + "wheel_diameter = 2.0\n", + "speed_mul = 1.0\n", + "max_speed = 10.0\n", + "theta_mul = 1.0\n", + "prox_dist_max = 40.0\n", + "prox_cos_min = 0.0\n", + "existing_agents = None\n", + "existing_objects = None\n", + "\n", + "entities_sbutypes = ['PREYS', 'PREDS', 'RESSOURCES', 'POISON']\n", + "\n", + "preys_data = {\n", + " 'type': 'AGENT',\n", + " 'num': 5,\n", + " 'color': 'blue',\n", + " 'selective_behaviors': {\n", + " 'love': {'beh': 'LOVE', 'sensed': ['PREYS', 'RESSOURCES']},\n", + " 'fear': {'beh': 'FEAR', 'sensed': ['PREDS', 'POISON']}\n", + " }}\n", + "\n", + "preds_data = {\n", + " 'type': 'AGENT',\n", + " 'num': 5,\n", + " 'color': 'red',\n", + " 'selective_behaviors': {\n", + " 'aggr': {'beh': 'AGGRESSION','sensed': ['PREYS']},\n", + " 'fear': {'beh': 'FEAR','sensed': ['POISON']\n", + " }\n", + " }}\n", + "\n", + "ressources_data = {\n", + " 'type': 'OBJECT',\n", + " 'num': 5,\n", + " 'color': 'green'}\n", + "\n", + "poison_data = {\n", + " 'type': 'OBJECT',\n", + " 'num': 5,\n", + " 'color': 'purple'}\n", + "\n", + "entities_data = {\n", + " 'EntitySubTypes': entities_sbutypes,\n", + " 'Entities': {\n", + " 'PREYS': preys_data,\n", + " 'PREDS': preds_data,\n", + " 'RESSOURCES': ressources_data,\n", + " 'POISON': poison_data\n", + " }}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pre-process the simulation data" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "key = random.PRNGKey(seed)\n", + "key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", + "\n", + "# create an enum for entities subtypes\n", + "ent_sub_types = entities_data['EntitySubTypes']\n", + "ent_sub_types_enum = Enum('ent_sub_types_enum', {ent_sub_types[i]: i for i in range(len(ent_sub_types))}) \n", + "ent_data = entities_data['Entities']\n", + "\n", + "# create max agents and max objects\n", + "max_agents = 0\n", + "max_objects = 0 \n", + "\n", + "# create agent and objects dictionaries \n", + "agents_data = {}\n", + "objects_data = {}\n", + "\n", + "# iterate over the entities subtypes\n", + "for ent_sub_type in ent_sub_types:\n", + " # get their data in the ent_data\n", + " data = ent_data[ent_sub_type]\n", + " color_str = data['color']\n", + " color = _string_to_rgb(color_str)\n", + " n = data['num']\n", + "\n", + " # Check if the entity is an agent or an object\n", + " if data['type'] == 'AGENT':\n", + " max_agents += n\n", + " behavior_list = []\n", + " # create a behavior list for all behaviors of the agent\n", + " for beh_name, behavior_data in data['selective_behaviors'].items():\n", + " beh_name = behavior_data['beh']\n", + " behavior_id = Behaviors[beh_name].value\n", + " # Init an empty mask\n", + " sensed_mask = np.zeros((len(ent_sub_types, )))\n", + " for sensed_type in behavior_data['sensed']:\n", + " # Iteratively update it with specific sensed values\n", + " sensed_id = ent_sub_types_enum[sensed_type].value\n", + " sensed_mask[sensed_id] = 1\n", + " beh = define_behavior_map(behavior_id, sensed_mask)\n", + " behavior_list.append(beh)\n", + " # stack the elements of the behavior list and update the agents_data dictionary\n", + " stacked_behaviors = stack_behaviors(behavior_list)\n", + " agents_data[ent_sub_type] = {'n': n, 'color': color, 'stacked_behs': stacked_behaviors}\n", + "\n", + " # only updated object counters and color if entity is an object\n", + " elif data['type'] == 'OBJECT':\n", + " max_objects += n\n", + " objects_data[ent_sub_type] = {'n': n, 'color': color}\n", + "\n", + "# Create the params, sensed, behaviors and colors arrays \n", + "\n", + "# init empty lists\n", + "colors = []\n", + "agents_stacked_behaviors_list = []\n", + "total_ent_sub_types = {}\n", + "for agent_type, data in agents_data.items():\n", + " n = data['n']\n", + " stacked_behavior = data['stacked_behs']\n", + " n_stacked_behavior = list([stacked_behavior] * n)\n", + " tiled_color = list(np.tile(data['color'], (n, 1)))\n", + " # update the lists with behaviors and color elements\n", + " agents_stacked_behaviors_list = agents_stacked_behaviors_list + n_stacked_behavior\n", + " colors = colors + tiled_color\n", + " total_ent_sub_types[agent_type] = (ent_sub_types_enum[agent_type].value, n)\n", + "\n", + "# create the final jnp arrays\n", + "agents_colors = jnp.concatenate(jnp.array([colors]), axis=0)\n", + "params, sensed, behaviors = get_agents_params_and_sensed_arr(agents_stacked_behaviors_list)\n", + "\n", + "# do the same for objects colors\n", + "colors = []\n", + "for objecy_type, data in objects_data.items():\n", + " n = data['n']\n", + " tiled_color = list(np.tile(data['color'], (n, 1)))\n", + " colors = colors + tiled_color\n", + " total_ent_sub_types[objecy_type] = (ent_sub_types_enum[objecy_type].value, n)\n", + "\n", + "objects_colors = jnp.concatenate(jnp.array([colors]), axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Entities\n", + "\n", + "Compared to simple Braitenberg env, just need to add a field ent_subtypes." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"Init the sub entities state\"\"\"\n", + "existing_agents = max_agents if not existing_agents else existing_agents\n", + "existing_objects = max_objects if not existing_objects else existing_objects\n", + "\n", + "n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects \n", + "# Assign random positions to each entity in the environment\n", + "agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size\n", + "objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size\n", + "positions = jnp.concatenate((agents_positions, objects_positions))\n", + "# Assign random orientations between 0 and 2*pi to each entity\n", + "orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi\n", + "# Assign types to the entities\n", + "agents_entities = jnp.full(max_agents, EntityType.AGENT.value)\n", + "object_entities = jnp.full(max_objects, EntityType.OBJECT.value)\n", + "entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)\n", + "# Define arrays with existing entities\n", + "exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))\n", + "exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))\n", + "exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", + "\n", + "# Works because dictionaries are ordered in Python\n", + "ent_subtypes = np.zeros(n_entities)\n", + "cur_idx = 0\n", + "for subtype_id, n_subtype in total_ent_sub_types.values():\n", + " ent_subtypes[cur_idx:cur_idx+n_subtype] = subtype_id\n", + " cur_idx += n_subtype\n", + "ent_subtypes = jnp.array(ent_subtypes, dtype=int) \n", + "\n", + "entities = EntityState(\n", + " position=RigidBody(center=positions, orientation=orientations),\n", + " momentum=None,\n", + " force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),\n", + " mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),\n", + " entity_type=entity_types,\n", + " ent_subtype=ent_subtypes,\n", + " entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),\n", + " diameter=jnp.full((n_entities), diameter),\n", + " friction=jnp.full((n_entities), friction),\n", + " exists=exists\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agents\n", + "\n", + "Now this section becomes pretty different. We need to have several behaviors for each agent. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"Init the sub agents state\"\"\"\n", + "agents = AgentState(\n", + " # idx in the entities (ent_idx) state to map agents information in the different data structures\n", + " ent_idx=jnp.arange(max_agents, dtype=int), \n", + " prox=jnp.zeros((max_agents, 2)),\n", + " motor=jnp.zeros((max_agents, 2)),\n", + " behavior=behaviors,\n", + " params=params,\n", + " sensed=sensed,\n", + " wheel_diameter=jnp.full((max_agents), wheel_diameter),\n", + " speed_mul=jnp.full((max_agents), speed_mul),\n", + " max_speed=jnp.full((max_agents), max_speed),\n", + " theta_mul=jnp.full((max_agents), theta_mul),\n", + " proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n", + " proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n", + " proximity_map_dist=jnp.zeros((max_agents, 1)),\n", + " proximity_map_theta=jnp.zeros((max_agents, 1)),\n", + " color=agents_colors\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Objects\n", + "\n", + "Same init.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\"\"\"Init the sub objects state\"\"\"\n", + "start_idx, stop_idx = max_agents, max_agents + max_objects \n", + "objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", + "\n", + "objects = ObjectState(\n", + " ent_idx=objects_ent_idx,\n", + " color=objects_colors\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Complete state\n", + "\n", + "Just add an ent_sub_types field." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "\"\"\"Init the complete state\"\"\"\n", + "state = State(\n", + " time=0,\n", + " dt=dt,\n", + " box_size=box_size,\n", + " max_agents=max_agents,\n", + " max_objects=max_objects,\n", + " neighbor_radius=neighbor_radius,\n", + " collision_alpha=collision_alpha,\n", + " collision_eps=collision_eps,\n", + " entities=entities,\n", + " agents=agents,\n", + " objects=objects,\n", + " ent_sub_types=total_ent_sub_types\n", + ") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Recap of the state\n", + "\n", + "### Agents\n", + "\n", + "Preys:\n", + "- Love: other preys and ressources\n", + "- Fear: predators and poison\n", + "- Color: Blue\n", + "\n", + "Predators:\n", + "- Aggression: preys\n", + "- Fear: Poison\n", + "- Color: Red\n", + "\n", + "### Objects\n", + "\n", + "Ressources\n", + "- Color: green\n", + "\n", + "Poison\n", + "- Color: purple" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from vivarium.experimental.environments.braitenberg.render import render, render_history" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "env = SelectiveSensorsEnv(state, occlusion=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "n_steps = 5_000\n", + "hist = []\n", + "\n", + "for i in range(n_steps):\n", + " state = env.step(state)\n", + " hist.append(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test manual behavior for an agent\n", + "\n", + "Need to set all of its behaviors to manual." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "ag_idx = 9\n", + "manual_behaviors = jnp.array([Behaviors.MANUAL.value, Behaviors.MANUAL.value,])\n", + "manual_color = jnp.array([0., 0., 0.])\n", + "manual_motors = jnp.array([1., 1.])\n", + "\n", + "behaviors = state.agents.behavior.at[ag_idx].set(manual_behaviors)\n", + "colors = state.agents.color.at[ag_idx].set(manual_color)\n", + "motors = state.agents.motor.at[ag_idx].set(manual_motors)\n", + "\n", + "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n", + "state = state.replace(agents=agents)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "hist = []\n", + "\n", + "for i in range(n_steps):\n", + " state = env.step(state)\n", + " hist.append(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=50)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}