From f66184bb172682d0c605f6f6b84260afb338f8c9 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 21 May 2024 11:34:38 +0200 Subject: [PATCH 01/18] Add first version of refactored braitenberg env --- notebooks/refactored_braitenberg_env.py | 568 ++++++++++++++++++++++++ requirements.txt | 1 + 2 files changed, 569 insertions(+) create mode 100644 notebooks/refactored_braitenberg_env.py diff --git a/notebooks/refactored_braitenberg_env.py b/notebooks/refactored_braitenberg_env.py new file mode 100644 index 0000000..b003b15 --- /dev/null +++ b/notebooks/refactored_braitenberg_env.py @@ -0,0 +1,568 @@ +import time +import logging as lg +from enum import Enum +from functools import partial +from typing import Tuple + +import jax +import jax.numpy as jnp + +from jax import vmap, jit +from jax import random, ops, lax + +from flax import struct +from jax_md.rigid_body import RigidBody +from jax_md import space, rigid_body, partition, simulate, quantity + +from vivarium.utils import normal, render, render_history +from vivarium.simulator.braitenberg_physics import total_collision_energy +# TODO : Later use this line to directly import the braitenberg physics (collisions + motors ...) + + +SPACE_NDIMS = 2 + +### 1 Define dataclasses for our state ### + +class EntityType(Enum): + AGENT = 0 + OBJECT = 1 + + +# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState) +@struct.dataclass +class EntityState(simulate.NVEState): + entity_type: jnp.array + entity_idx: jnp.array + diameter: jnp.array + friction: jnp.array + exists: jnp.array + + @property + def velocity(self) -> jnp.array: + return self.momentum / self.mass + +@struct.dataclass +class AgentState: + ent_idx: jnp.array + prox: jnp.array + motor: jnp.array + proximity_map_dist: jnp.array + proximity_map_theta: jnp.array + behavior: 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 + color: jnp.array + +@struct.dataclass +class ObjectState: + ent_idx: jnp.array + color: jnp.array + +# TODO : Add obs field like in JaxMARL -> compute agents actions w a vmap on obs +@struct.dataclass +class State: + time: jnp.int32 + box_size: jnp.int32 + 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 + entities: EntityState + agents: AgentState + objects: ObjectState + + +### 2 Define functions that will be used in the step fn of the env ### + +def relative_position(displ, theta): + """ + Compute the relative distance and angle from a source agent to a target agent + :param displ: Displacement vector (jnp arrray with shape (2,) from source to target + :param theta: Orientation of the source agent (in the reference frame of the map) + :return: dist: distance from source to target. + relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) + """ + dist = jnp.linalg.norm(displ) + norm_displ = displ / dist + theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) + relative_theta = theta_displ - theta + return dist, relative_theta + +proximity_map = vmap(relative_position, (0, 0)) + +# TODO : SHould redo all these functions with the prox computation because very hard to understand without vmap etcc +def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): + """ + Compute the proximeter activations (left, right) induced by the presence of an entity + :param dist: distance from the agent to the entity + :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) + :param dist_max: Max distance of the proximiter (will return 0. above this distance) + :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) + :return: left and right proximeter activation in a jnp array with shape (2,) + """ + cos_dir = jnp.cos(relative_theta) + prox = 1. - (dist / dist_max) + in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) + at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) + left = in_view * at_left * prox + right = in_view * (1. - at_left) * prox + return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist + +sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) + +def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): + raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) + # Computes the maximum within the proximeter activations of agents on all their neigbhors. + proxs = ops.segment_max( + raw_proxs, + senders, + max_agents) + + return proxs + +# TODO : I think we should refactor this part of the code with a function using vmap +def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): + """ + Set agents' proximeter activations + :param state: full simulation State + :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), + where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. + :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). + target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). + :return: + """ + body = state.entities.position + mask = target_exists_mask[agents_neighs_idx[1, :]] + senders, receivers = agents_neighs_idx + Ra = body.center[senders] + Rb = body.center[receivers] + dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why + + # Create distance and angle maps between entities + 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) + + # TODO : refactor this function because a lot of redundancies in the arguments (state.agents) + prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], + state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) + + return prox, proximity_map_dist, proximity_map_theta + + +# TODO : Refactor the following part, way to hard to understand in one pass +"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" +"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" +linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY']) + +linear_behavior_matrices = { + linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]), + linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]), + linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]), + linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]), +} + +def linear_behavior(proxs, motors, matrix): + return matrix.dot(jnp.hstack((proxs, 1.))) + +def apply_motors(proxs, motors): + return motors + +def noop(proxs, motors): + return jnp.array([0., 0.]) + +behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh]) + for beh in linear_behavior_enum] \ + + [apply_motors, noop] + +behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)} +behavior_name_map['manual'] = len(behavior_bank) - 2 +behavior_name_map['noop'] = len(behavior_bank) - 1 + +lg.info(behavior_name_map) + +# TODO : seems useless and unused +reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()} + +def switch_fn(fn_list): + def switch(index, *operands): + return lax.switch(index, fn_list, *operands) + return switch + +multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0)) + +def sensorimotor(prox, behaviors, motor): + motor = multi_switch(behaviors, prox, motor) + return motor +"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" +"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" + +def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): + fwd = (wheel_diameter / 4.) * (left_spd + right_spd) + rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) + return fwd, rot + +def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): + left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter + right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter + return left, right + +def motor_command(wheel_activation, base_length, wheel_diameter): + fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) + return fwd, rot + +motor_command = vmap(motor_command, (0, 0, 0)) + + +def verlet_force_fn(displacement): + coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) + + def collision_force(state, neighbor, exists_mask): + return coll_force_fn( + state.entities.position.center, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + + def friction_force(state, exists_mask): + cur_vel = state.entities.momentum.center / state.entities.mass.center + # stack the mask to give it the same shape as cur_vel (that has 2 rows for forward and angular velocities) + mask = jnp.stack([exists_mask] * 2, axis=1) + cur_vel = jnp.where(mask, cur_vel, 0.) + return - jnp.tile(state.entities.friction, (SPACE_NDIMS, 1)).T * cur_vel + + def motor_force(state, exists_mask): + agent_idx = state.agents.ent_idx + + body = rigid_body.RigidBody( + center=state.entities.position.center[agent_idx], + orientation=state.entities.position.orientation[agent_idx] + ) + + n = normal(body.orientation) + + fwd, rot = motor_command( + state.agents.motor, + state.entities.diameter[agent_idx], + state.agents.wheel_diameter + ) + # `a_max` arg is deprecated in recent versions of jax, replaced by `max` + fwd = jnp.clip(fwd, a_max=state.agents.max_speed) + + cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] + cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) + cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] + + fwd_delta = fwd - cur_fwd_vel + rot_delta = rot - cur_rot_vel + + fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T + rot_force = rot_delta * state.agents.theta_mul + + center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) + orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) + + # apply mask to make non existing agents stand still + orientation = jnp.where(exists_mask, orientation, 0.) + # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, center, 0.) + + return rigid_body.RigidBody(center=center, + orientation=orientation) + + def force_fn(state, neighbor, exists_mask): + mf = motor_force(state, exists_mask) + cf = collision_force(state, neighbor, exists_mask) + ff = friction_force(state, exists_mask) + + center = cf + ff + mf.center + orientation = mf.orientation + return rigid_body.RigidBody(center=center, orientation=orientation) + + return force_fn + +## TODO : This should be a general function that only takes forces (why the force fn here) +## TODO : Only motor force should be defined here in this file, and import the collision and friction forces +# TODO (i.e, we should only redefine the "verlet force fn here, by adding the motor force to it") +def dynamics_fn(displacement, shift, force_fn=None): + force_fn = force_fn if force_fn else verlet_force_fn(displacement) + + def init_fn(state, key, kT=0.): + key, _ = random.split(key) + assert state.entities.momentum is None + assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) + + state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) + return state + + def mask_momentum(entity_state, exists_mask): + """ + Set the momentum values to zeros for non existing entities + :param entity_state: entity_state + :param exists_mask: bool array specifying which entities exist or not + :return: entity_state: new entities state state with masked momentum values + """ + orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, entity_state.momentum.center, 0) + momentum = rigid_body.RigidBody(center=center, orientation=orientation) + return entity_state.replace(momentum=momentum) + + def step_fn(state, neighbor): + exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others + dt_2 = state.dt / 2. + # Compute forces + force = force_fn(state, neighbor, exists_mask) + # Compute changes on entities + entity_state = simulate.momentum_step(state.entities, dt_2) + # TODO : why do we used dt and not dt/2 in the line below ? + entity_state = simulate.position_step(entity_state, shift, state.dt, neighbor=neighbor) + entity_state = entity_state.replace(force=force) + entity_state = simulate.momentum_step(entity_state, dt_2) + entity_state = mask_momentum(entity_state, exists_mask) + return entity_state + + return init_fn, step_fn + + +class BraitenbergEnv: + def __init__( + self, + box_size=100, + dt=0.1, + max_agents=10, + max_objects=2, + neighbor_radius=100., + collision_alpha=0.5, + collision_eps=0.1, + n_dims=2, + seed=0, + diameter=5.0, + friction=0.1, + mass_center=1.0, + mass_orientation=0.125, + existing_agents=10, + existing_objects=2, + behavior=behavior_name_map['AGGRESSION'], + 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, + agents_color=jnp.array([0.0, 0.0, 1.0]), + objects_color=jnp.array([1.0, 0.0, 0.0]) + ): + + # TODO : add docstrings + # general parameters + self.box_size = box_size + self.dt = dt + self.max_agents = max_agents + self.max_objects = max_objects + self.neighbor_radius = neighbor_radius + self.collision_alpha = collision_alpha + self.collision_eps = collision_eps + self.n_dims = n_dims + self.seed = seed + # entities parameters + self.diameter = diameter + self.friction = friction + self.mass_center = mass_center + self.mass_orientation = mass_orientation + self.existing_agents = existing_agents + self.existing_objects = existing_objects + # agents parameters + self.behavior = behavior + self.wheel_diameter = wheel_diameter + self.speed_mul = speed_mul + self.max_speed = max_speed + self.theta_mul = theta_mul + self.prox_dist_max = prox_dist_max + self.prox_cos_min = prox_cos_min + self.agents_color = agents_color + # objects parameters + self.objects_color = objects_color + # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? + + + # TODO : Split the initialization of entities, agents and objects w different functions ... + def init_state(self) -> State: + key = random.PRNGKey(self.seed) + key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) + + n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size + objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) + object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) + exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) + exists = jnp.concatenate((exists_agents, exists_objects), dtype=int) + # Entities idx of objects + start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects + objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) + + entity_state = 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), + entity_type=entity_types, + entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), + diameter=jnp.full((n_entities), self.diameter), + friction=jnp.full((n_entities), self.friction), + exists=exists + ) + + agents_state = AgentState( + # idx in the entities (ent_idx) state to map agents information in the different data structures + ent_idx=jnp.arange(self.max_agents, dtype=int), + prox=jnp.zeros((self.max_agents, 2)), + motor=jnp.zeros((self.max_agents, 2)), + behavior=jnp.full((self.max_agents), self.behavior), + wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), + speed_mul=jnp.full((self.max_agents), self.speed_mul), + max_speed=jnp.full((self.max_agents), self.max_speed), + theta_mul=jnp.full((self.max_agents), self.theta_mul), + proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), + proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), + proximity_map_dist=jnp.zeros((self.max_agents, 1)), + proximity_map_theta=jnp.zeros((self.max_agents, 1)), + color=jnp.tile(self.agents_color, (self.max_agents, 1)) + ) + + objects_state = ObjectState( + ent_idx=objects_ent_idx, + color=jnp.tile(self.objects_color, (self.max_objects, 1)) + ) + + lg.info('creating state') + state = State( + time=0, + box_size=self.box_size, + max_agents=self.max_agents, + max_objects=self.max_objects, + neighbor_radius=self.neighbor_radius, + collision_alpha=self.collision_alpha, + collision_eps=self.collision_eps, + dt=self.dt, + entities=entity_state, + agents=agents_state, + objects=objects_state + ) + + # Create jax_md attributes for environment physics + key, physics_key = random.split(key) + self.displacement, self.shift = space.periodic(self.box_size) + init_fn, apply_physics = dynamics_fn(self.displacement, self.shift) + self.init_fn = init_fn + self.apply_physics = jit(apply_physics) + self.neighbor_fn = partition.neighbor_list( + self.displacement, + self.box_size, + r_cutoff=self.neighbor_radius, + dr_threshold=10., + capacity_multiplier=1.5, + format=partition.Sparse + ) + + state = self.init_fn(state, physics_key) + positions = state.entities.position.center + lg.info('allocating neighbors') + neighbors, agents_neighs_idx = self.allocate_neighbors(state) + self.neighbors = neighbors + self.agents_neighs_idx = agents_neighs_idx + + return state + + + @partial(jit, static_argnums=(0,)) + def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: + # 1 : Compute agents proximeter and motor activations + exists_mask = jnp.where(state.entities.exists == 1, 1, 0) + # TODO : Big error bc here if recompilation the agents_neighs_idx will stay the same + # TODO Not rly clean, should maybe only return proximeters, or split the functions + prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=env.displacement) + motor = sensorimotor(prox, state.agents.behavior, state.agents.motor) + + agents = state.agents.replace( + prox=prox, + proximity_map_dist=proximity_dist_map, + proximity_map_theta=proximity_dist_theta, + motor=motor + ) + + state = state.replace(agents=agents) + # 2 : Move the entities by applying physics of the env (collision, friction and motor forces) + entities = env.apply_physics(state, neighbors) + + # 3 : Apply specific consequences in the env (e.g eating an object) + 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: + current_state = state + state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx) + + if self.neighbors.did_buffer_overflow: + print("overflow") + # reallocate neghbors and run the simulation from current_state + lg.warning('BUFFER OVERFLOW: rebuilding neighbors') + # TODO Check if need to give current_state or new state + neighbors, agents_neighs_idx = self.allocate_neighbors(state) + self.agents_neighs_idx = agents_neighs_idx + assert not neighbors.did_buffer_overflow + + self.neighbors = neighbors + return state + + def allocate_neighbors(self, state, position=None): + position = state.entities.position.center if position is None else position + neighbors = self.neighbor_fn.allocate(position) + mask = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value + agents_neighs_idx = neighbors.idx[:, mask] + return neighbors, agents_neighs_idx + + +if __name__ == "__main__": + env = BraitenbergEnv() + state = env.init_state() + n_steps = 10_000 + + hist = [] + + start = time.perf_counter() + for i in range(n_steps): + state = env.step(state) + hist.append(state) + end = time.perf_counter() + print(f"{end - start} s to run") + + # render_history(hist) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index ef50d69..5d96872 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,6 +3,7 @@ jax==0.4.23 jaxlib==0.4.23 jax-md==0.2.8 scipy==1.12.0 +flax # Interface panel==1.3.8 From 2b526df27a73f0ee3670708fce84500b1911184e Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 21 May 2024 11:56:11 +0200 Subject: [PATCH 02/18] Add utils file --- vivarium/utils.py | 114 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 vivarium/utils.py diff --git a/vivarium/utils.py b/vivarium/utils.py new file mode 100644 index 0000000..d9f3519 --- /dev/null +++ b/vivarium/utils.py @@ -0,0 +1,114 @@ +import time +from IPython.display import display, clear_output + +import jax.numpy as jnp +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.colors as colors + +from jax import vmap + +@vmap +def normal(theta): + return jnp.array([jnp.cos(theta), jnp.sin(theta)]) + +def _string_to_rgb(color_str): + return jnp.array(list(colors.to_rgb(color_str))) + +# Functions to render the current state +def render(state): + box_size = state.box_size + max_agents = state.max_agents + + plt.figure(figsize=(6, 6)) + plt.xlim(0, box_size) + plt.xlim(0, box_size) + + exists_agents, exists_objects = state.entities.exists[:max_agents], state.entities.exists[max_agents:] + exists_agents = jnp.where(exists_agents != 0) + exists_objects = jnp.where(exists_objects != 0) + + agents_pos = state.entities.position.center[:max_agents][exists_agents] + agents_theta = state.entities.position.orientation[:max_agents][exists_agents][exists_agents] + agents_diameter = state.entities.diameter[:max_agents][exists_agents][exists_agents] + objects_pos = state.entities.position.center[max_agents:][exists_objects] + object_diameter = state.entities.diameter[max_agents:][exists_objects] + + x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1] + agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.agents.color[exists_agents]] + x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1] + object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.objects.color[exists_objects]] + + n = normal(agents_theta) + + arrow_length = 3 + size_scale = 30 + dx = arrow_length * n[:, 0] + dy = arrow_length * n[:, 1] + plt.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01) + plt.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents') + plt.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects') + + plt.title('State') + plt.xlabel('X Position') + plt.ylabel('Y Position') + plt.legend() + + plt.show() + +# Function to render a state hystory +def render_history(state_history, pause=0.001, skip_frames=1): + box_size = state_history[0].box_size + max_agents = state_history[0].max_agents + print(box_size) + print(max_agents) + fig, ax = plt.subplots(figsize=(6, 6)) + ax.set_xlim(0, box_size) + ax.set_ylim(0, box_size) + + for t in range(0, len(state_history), skip_frames): + # Because weird saving at the moment, we don't save the state but all its sub-elements + entities = state_history[t].entities + agents = state_history[t].agents + objects = state_history[t].objects + + exists_agents, exists_objects = entities.exists[:max_agents], entities.exists[max_agents:] + exists_agents = jnp.where(exists_agents != 0) + exists_objects = jnp.where(exists_objects != 0) + + agents_pos = entities.position.center[:max_agents][exists_agents] + agents_theta = entities.position.orientation[:max_agents][exists_agents][exists_agents] + agents_diameter = entities.diameter[:max_agents][exists_agents][exists_agents] + objects_pos = entities.position.center[max_agents:][exists_objects] + object_diameter = entities.diameter[max_agents:][exists_objects] + + x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1] + agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in agents.color[exists_agents]] + x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1] + object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in objects.color[exists_objects]] + + n = normal(agents_theta) + + arrow_length = 3 + size_scale = 30 + dx = arrow_length * n[:, 0] + dy = arrow_length * n[:, 1] + + ax.clear() + ax.set_xlim(0, box_size) + ax.set_ylim(0, box_size) + + ax.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01) + ax.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents') + ax.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects') + + ax.set_title(f'Timestep: {t}') + ax.set_xlabel('X Position') + ax.set_ylabel('Y Position') + ax.legend() + + display(fig) + clear_output(wait=True) + time.sleep(pause) + + plt.close(fig) From 0062bfb2d74c69b854d9be782976b7fc7c6f9e90 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 21 May 2024 17:43:47 +0200 Subject: [PATCH 03/18] Update way of computing forces in environment + Add general physics engine file --- notebooks/refactored_braitenberg_env.py | 61 +----- vivarium/simulator/general_physics_engine.py | 199 +++++++++++++++++++ 2 files changed, 207 insertions(+), 53 deletions(-) create mode 100644 vivarium/simulator/general_physics_engine.py diff --git a/notebooks/refactored_braitenberg_env.py b/notebooks/refactored_braitenberg_env.py index b003b15..b02c197 100644 --- a/notebooks/refactored_braitenberg_env.py +++ b/notebooks/refactored_braitenberg_env.py @@ -15,7 +15,7 @@ from jax_md import space, rigid_body, partition, simulate, quantity from vivarium.utils import normal, render, render_history -from vivarium.simulator.braitenberg_physics import total_collision_energy +from vivarium.simulator.general_physics_engine import total_collision_energy, friction_force, dynamics_fn # TODO : Later use this line to directly import the braitenberg physics (collisions + motors ...) @@ -221,8 +221,9 @@ def motor_command(wheel_activation, base_length, wheel_diameter): motor_command = vmap(motor_command, (0, 0, 0)) +### Define the force in the environment -def verlet_force_fn(displacement): +def braintenberg_force_fn(displacement): coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) def collision_force(state, neighbor, exists_mask): @@ -235,13 +236,6 @@ def collision_force(state, neighbor, exists_mask): alpha=state.collision_alpha ) - def friction_force(state, exists_mask): - cur_vel = state.entities.momentum.center / state.entities.mass.center - # stack the mask to give it the same shape as cur_vel (that has 2 rows for forward and angular velocities) - mask = jnp.stack([exists_mask] * 2, axis=1) - cur_vel = jnp.where(mask, cur_vel, 0.) - return - jnp.tile(state.entities.friction, (SPACE_NDIMS, 1)).T * cur_vel - def motor_force(state, exists_mask): agent_idx = state.agents.ent_idx @@ -281,6 +275,7 @@ def motor_force(state, exists_mask): return rigid_body.RigidBody(center=center, orientation=orientation) + def force_fn(state, neighbor, exists_mask): mf = motor_force(state, exists_mask) @@ -293,49 +288,6 @@ def force_fn(state, neighbor, exists_mask): return force_fn -## TODO : This should be a general function that only takes forces (why the force fn here) -## TODO : Only motor force should be defined here in this file, and import the collision and friction forces -# TODO (i.e, we should only redefine the "verlet force fn here, by adding the motor force to it") -def dynamics_fn(displacement, shift, force_fn=None): - force_fn = force_fn if force_fn else verlet_force_fn(displacement) - - def init_fn(state, key, kT=0.): - key, _ = random.split(key) - assert state.entities.momentum is None - assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) - - state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) - return state - - def mask_momentum(entity_state, exists_mask): - """ - Set the momentum values to zeros for non existing entities - :param entity_state: entity_state - :param exists_mask: bool array specifying which entities exist or not - :return: entity_state: new entities state state with masked momentum values - """ - orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) - exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) - center = jnp.where(exists_mask, entity_state.momentum.center, 0) - momentum = rigid_body.RigidBody(center=center, orientation=orientation) - return entity_state.replace(momentum=momentum) - - def step_fn(state, neighbor): - exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others - dt_2 = state.dt / 2. - # Compute forces - force = force_fn(state, neighbor, exists_mask) - # Compute changes on entities - entity_state = simulate.momentum_step(state.entities, dt_2) - # TODO : why do we used dt and not dt/2 in the line below ? - entity_state = simulate.position_step(entity_state, shift, state.dt, neighbor=neighbor) - entity_state = entity_state.replace(force=force) - entity_state = simulate.momentum_step(entity_state, dt_2) - entity_state = mask_momentum(entity_state, exists_mask) - return entity_state - - return init_fn, step_fn - class BraitenbergEnv: def __init__( @@ -474,7 +426,7 @@ def init_state(self) -> State: # Create jax_md attributes for environment physics key, physics_key = random.split(key) self.displacement, self.shift = space.periodic(self.box_size) - init_fn, apply_physics = dynamics_fn(self.displacement, self.shift) + init_fn, apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) self.init_fn = init_fn self.apply_physics = jit(apply_physics) self.neighbor_fn = partition.neighbor_list( @@ -557,6 +509,7 @@ def allocate_neighbors(self, state, position=None): n_steps = 10_000 hist = [] + render(state) start = time.perf_counter() for i in range(n_steps): @@ -565,4 +518,6 @@ def allocate_neighbors(self, state, position=None): end = time.perf_counter() print(f"{end - start} s to run") + render(state) + # render_history(hist) \ No newline at end of file diff --git a/vivarium/simulator/general_physics_engine.py b/vivarium/simulator/general_physics_engine.py new file mode 100644 index 0000000..9deb311 --- /dev/null +++ b/vivarium/simulator/general_physics_engine.py @@ -0,0 +1,199 @@ +from functools import partial + +import jax +import jax.numpy as jnp + +from jax import ops, vmap, lax +from jax_md import space, rigid_body, util, simulate, energy, quantity +f32 = util.f32 + + +# Only work on 2D environments atm +SPACE_NDIMS = 2 + +# Helper functions for collisions + +def collision_energy(displacement_fn, r_a, r_b, l_a, l_b, epsilon, alpha, mask): + """Compute the collision energy between a pair of particles + + :param displacement_fn: displacement function of jax_md + :param r_a: position of particle a + :param r_b: position of particle b + :param l_a: diameter of particle a + :param l_b: diameter of particle b + :param epsilon: interaction energy scale + :param alpha: interaction stiffness + :param mask: set the energy to 0 if one of the particles is masked + :return: collision energy between both particles + """ + dist = jnp.linalg.norm(displacement_fn(r_a, r_b)) + sigma = (l_a + l_b) / 2 + e = energy.soft_sphere(dist, sigma=sigma, epsilon=epsilon, alpha=f32(alpha)) + return jnp.where(mask, e, 0.) + +collision_energy = vmap(collision_energy, (None, 0, 0, 0, 0, None, None, 0)) + + +def total_collision_energy(positions, diameter, neighbor, displacement, exists_mask, epsilon, alpha): + """Compute the collision energy between all neighboring pairs of particles in the system + + :param positions: positions of all the particles + :param diameter: diameters of all the particles + :param neighbor: neighbor array of the system + :param displacement: dipalcement function of jax_md + :param exists_mask: mask to specify which particles exist + :param epsilon: interaction energy scale between two particles + :param alpha: interaction stiffness between two particles + :return: sum of all collisions energies of the system + """ + diameter = lax.stop_gradient(diameter) + senders, receivers = neighbor.idx + + r_senders = positions[senders] + r_receivers = positions[receivers] + l_senders = diameter[senders] + l_receivers = diameter[receivers] + + # Set collision energy to zero if the sender or receiver is non existing + mask = exists_mask[senders] * exists_mask[receivers] + energies = collision_energy(displacement, + r_senders, + r_receivers, + l_senders, + l_receivers, + epsilon, + alpha, + mask) + return jnp.sum(energies) + +# Functions to compute the verlet force on the whole system + +def friction_force(state, exists_mask): + cur_vel = state.entities.momentum.center / state.entities.mass.center + # stack the mask to give it the same shape as cur_vel (that has 2 rows for forward and angular velocities) + mask = jnp.stack([exists_mask] * 2, axis=1) + cur_vel = jnp.where(mask, cur_vel, 0.) + return - jnp.tile(state.entities.friction, (SPACE_NDIMS, 1)).T * cur_vel + +def collision_force(state, neighbor, exists_mask, displacement): + coll_force_fn = quantity.force( + total_collision_energy( + positions=state.entities.position.center, + displacement=displacement, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + ) + + return coll_force_fn + + +def verlet_force_fn(displacement): + coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) + + def collision_force(state, neighbor, exists_mask): + return coll_force_fn( + state.entities.position.center, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + + def force_fn(state, neighbor, exists_mask): + cf = collision_force(state, neighbor, exists_mask) + ff = friction_force(state, exists_mask) + center = cf + ff + return rigid_body.RigidBody(center=center, orientation=0) + + return force_fn + + +def dynamics_fn(displacement, shift, force_fn=None): + force_fn = force_fn(displacement) if force_fn else verlet_force_fn(displacement) + + def init_fn(state, key, kT=0.): + key, _ = jax.random.split(key) + assert state.entities.momentum is None + assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) + + state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) + return state + + def mask_momentum(entity_state, exists_mask): + """ + Set the momentum values to zeros for non existing entities + :param entity_state: entity_state + :param exists_mask: bool array specifying which entities exist or not + :return: entity_state: new entities state state with masked momentum values + """ + orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, entity_state.momentum.center, 0) + momentum = rigid_body.RigidBody(center=center, orientation=orientation) + return entity_state.set(momentum=momentum) + + def step_fn(state, neighbor): + exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others + dt_2 = state.dt / 2. + # Compute forces + force = force_fn(state, neighbor, exists_mask) + # Compute changes on entities + entity_state = simulate.momentum_step(state.entities, dt_2) + # TODO : why do we used dt and not dt/2 in the line below ? + entity_state = simulate.position_step(entity_state, shift, dt_2, neighbor=neighbor) + entity_state = entity_state.replace(force=force) + entity_state = simulate.momentum_step(entity_state, dt_2) + entity_state = mask_momentum(entity_state, exists_mask) + return entity_state + + return init_fn, step_fn + + + +## TODO : This should be a general function that only takes forces (why the force fn here) +## TODO : Only motor force should be defined here in this file, and import the collision and friction forces +# TODO (i.e, we should only redefine the "verlet force fn here, by adding the motor force to it") +def dynamics_fn(displacement, shift, force_fn=None): + force_fn = force_fn(displacement) if force_fn else verlet_force_fn(displacement) + + def init_fn(state, key, kT=0.): + key, _ = jax.random.split(key) + assert state.entities.momentum is None + assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) + + state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) + return state + + def mask_momentum(entity_state, exists_mask): + """ + Set the momentum values to zeros for non existing entities + :param entity_state: entity_state + :param exists_mask: bool array specifying which entities exist or not + :return: entity_state: new entities state state with masked momentum values + """ + orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, entity_state.momentum.center, 0) + momentum = rigid_body.RigidBody(center=center, orientation=orientation) + return entity_state.replace(momentum=momentum) + + def step_fn(state, neighbor): + exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others + dt_2 = state.dt / 2. + # Compute forces + force = force_fn(state, neighbor, exists_mask) + # Compute changes on entities + entity_state = simulate.momentum_step(state.entities, dt_2) + # TODO : why do we used dt and not dt/2 in the line below ? + entity_state = simulate.position_step(entity_state, shift, state.dt, neighbor=neighbor) + entity_state = entity_state.replace(force=force) + entity_state = simulate.momentum_step(entity_state, dt_2) + entity_state = mask_momentum(entity_state, exists_mask) + return entity_state + + return init_fn, step_fn \ No newline at end of file From 41bffefd00213a2f792015f7082ecc1d583d701b Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 21 May 2024 17:44:30 +0200 Subject: [PATCH 04/18] Add first elements of tutorial on how to create an environment in a notebook --- notebooks/braintenberg_env_notebook.ipynb | 982 ++++++++++++++++++++++ 1 file changed, 982 insertions(+) create mode 100644 notebooks/braintenberg_env_notebook.ipynb diff --git a/notebooks/braintenberg_env_notebook.ipynb b/notebooks/braintenberg_env_notebook.ipynb new file mode 100644 index 0000000..e2de5e3 --- /dev/null +++ b/notebooks/braintenberg_env_notebook.ipynb @@ -0,0 +1,982 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Braitenberg environment notebook\n", + "\n", + "Use this notebook to showcase how to create an environment in vivarium ... w a realistic physics ... " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" + ] + } + ], + "source": [ + "import time\n", + "import logging as lg\n", + "from enum import Enum\n", + "from functools import partial\n", + "from typing import Tuple\n", + "\n", + "import jax\n", + "import flax\n", + "import jax.numpy as jnp\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 space, rigid_body, partition, simulate, quantity\n", + "\n", + "from vivarium.utils import normal, render, render_history\n", + "from vivarium.simulator.general_physics_engine import total_collision_energy, friction_force, dynamics_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create classes for the environment\n", + "\n", + "We use flax dataclasses to store all the information about our environment state (positions of all entities ..., features of agents and objects ...)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "class EntityType(Enum):\n", + " AGENT = 0\n", + " OBJECT = 1\n", + "\n", + "# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState)\n", + "@struct.dataclass\n", + "class EntityState(simulate.NVEState):\n", + " entity_type: jnp.array\n", + " entity_idx: jnp.array\n", + " diameter: jnp.array\n", + " friction: jnp.array\n", + " exists: jnp.array\n", + "\n", + " @property\n", + " def velocity(self) -> jnp.array:\n", + " return self.momentum / self.mass\n", + " \n", + "@struct.dataclass\n", + "class AgentState:\n", + " ent_idx: jnp.array\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", + " 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", + " color: jnp.array\n", + "\n", + "@struct.dataclass\n", + "class ObjectState:\n", + " ent_idx: jnp.array \n", + " color: jnp.array\n", + "\n", + "# TODO : Add obs field like in JaxMARL -> compute agents actions w a vmap on obs\n", + "@struct.dataclass\n", + "class State:\n", + " time: jnp.int32\n", + " box_size: jnp.int32\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", + " entities: EntityState\n", + " agents: AgentState\n", + " objects: ObjectState" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define helper functions to compute the proximeters of agents\n", + "\n", + "Bc we use braitenberg vehicles ... need to compute values of proximeters for them to detect their environment ... " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "### 2 Define functions that will be used in the step fn of the env ###\n", + "\n", + "def relative_position(displ, theta):\n", + " \"\"\"\n", + " Compute the relative distance and angle from a source agent to a target agent\n", + " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", + " :param theta: Orientation of the source agent (in the reference frame of the map)\n", + " :return: dist: distance from source to target.\n", + " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", + " \"\"\"\n", + " dist = jnp.linalg.norm(displ)\n", + " norm_displ = displ / dist\n", + " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", + " relative_theta = theta_displ - theta\n", + " return dist, relative_theta\n", + "\n", + "proximity_map = vmap(relative_position, (0, 0))\n", + "\n", + "# TODO : SHould redo all these functions with the prox computation because very hard to understand without vmap etcc\n", + "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", + " \"\"\"\n", + " Compute the proximeter activations (left, right) induced by the presence of an entity\n", + " :param dist: distance from the agent to the entity\n", + " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", + " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", + " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", + " :return: left and right proximeter activation in a jnp array with shape (2,)\n", + " \"\"\"\n", + " cos_dir = jnp.cos(relative_theta)\n", + " prox = 1. - (dist / dist_max)\n", + " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", + " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", + " left = in_view * at_left * prox\n", + " right = in_view * (1. - at_left) * prox\n", + " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", + "\n", + "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", + "\n", + "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", + " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", + " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", + " proxs = ops.segment_max(\n", + " raw_proxs,\n", + " senders, \n", + " max_agents)\n", + " \n", + " return proxs\n", + "\n", + "# TODO : I think we should refactor this part of the code with a function using vmap\n", + "def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):\n", + " \"\"\"\n", + " Set agents' proximeter activations\n", + " :param state: full simulation State\n", + " :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),\n", + " where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.\n", + " :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).\n", + " target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).\n", + " :return:\n", + " \"\"\"\n", + " body = state.entities.position\n", + " mask = target_exists_mask[agents_neighs_idx[1, :]] \n", + " senders, receivers = agents_neighs_idx\n", + " Ra = body.center[senders]\n", + " Rb = body.center[receivers]\n", + " dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", + "\n", + " # Create distance and angle maps between entities\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", + "\n", + " # TODO : refactor this function because a lot of redundancies in the arguments (state.agents)\n", + " prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],\n", + " state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)\n", + " \n", + " return prox, proximity_map_dist, proximity_map_theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create helper functions to compute motor activations of agents\n", + "\n", + "Now that we know how to compute proximters values, we want our agents to act accordingly to them ... see how to map sensors values to motor activations (e.g w behaviors of attraction / repulsion towards some objects, agents ...)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO : Refactor the following part\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY'])\n", + "\n", + "linear_behavior_matrices = {\n", + " linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]),\n", + " linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]),\n", + " linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]),\n", + " linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]),\n", + "}\n", + "\n", + "def linear_behavior(proxs, motors, matrix):\n", + " return matrix.dot(jnp.hstack((proxs, 1.)))\n", + "\n", + "def apply_motors(proxs, motors):\n", + " return motors\n", + "\n", + "def noop(proxs, motors):\n", + " return jnp.array([0., 0.])\n", + "\n", + "behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh])\n", + " for beh in linear_behavior_enum] \\\n", + " + [apply_motors, noop]\n", + "\n", + "behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)}\n", + "behavior_name_map['manual'] = len(behavior_bank) - 2\n", + "behavior_name_map['noop'] = len(behavior_bank) - 1\n", + "\n", + "lg.info(behavior_name_map)\n", + "\n", + "# TODO : seems useless and unused\n", + "reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()}\n", + "\n", + "def switch_fn(fn_list):\n", + " def switch(index, *operands):\n", + " return lax.switch(index, fn_list, *operands)\n", + " return switch\n", + "\n", + "multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0))\n", + "\n", + "def sensorimotor(prox, behaviors, motor):\n", + " motor = multi_switch(behaviors, prox, motor)\n", + " return motor\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "\n", + "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", + " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", + " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", + " return fwd, rot\n", + "\n", + "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", + " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", + " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", + " return left, right\n", + "\n", + "def motor_command(wheel_activation, base_length, wheel_diameter):\n", + " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", + " return fwd, rot\n", + "\n", + "motor_command = vmap(motor_command, (0, 0, 0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define a force function for the environment\n", + "\n", + "Bc we want a world with a realistic physics, we wanna define how forces are going to be applied to our entities (collision and friction) as well as the motor forces for the braitenberg vehicles ... " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def braintenberg_force_fn(displacement):\n", + " coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))\n", + "\n", + " def collision_force(state, neighbor, exists_mask):\n", + " return coll_force_fn(\n", + " state.entities.position.center,\n", + " neighbor=neighbor,\n", + " exists_mask=exists_mask,\n", + " diameter=state.entities.diameter,\n", + " epsilon=state.collision_eps,\n", + " alpha=state.collision_alpha\n", + " )\n", + "\n", + " def motor_force(state, exists_mask):\n", + " agent_idx = state.agents.ent_idx\n", + "\n", + " body = rigid_body.RigidBody(\n", + " center=state.entities.position.center[agent_idx],\n", + " orientation=state.entities.position.orientation[agent_idx]\n", + " )\n", + " \n", + " n = normal(body.orientation)\n", + "\n", + " fwd, rot = motor_command(\n", + " state.agents.motor,\n", + " state.entities.diameter[agent_idx],\n", + " state.agents.wheel_diameter\n", + " )\n", + " # `a_max` arg is deprecated in recent versions of jax, replaced by `max`\n", + " fwd = jnp.clip(fwd, a_max=state.agents.max_speed)\n", + "\n", + " cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]\n", + " cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)\n", + " cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]\n", + " \n", + " fwd_delta = fwd - cur_fwd_vel\n", + " rot_delta = rot - cur_rot_vel\n", + "\n", + " fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T\n", + " rot_force = rot_delta * state.agents.theta_mul\n", + "\n", + " center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)\n", + " orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)\n", + "\n", + " # apply mask to make non existing agents stand still\n", + " orientation = jnp.where(exists_mask, orientation, 0.)\n", + " # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center\n", + " exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)\n", + " center = jnp.where(exists_mask, center, 0.)\n", + "\n", + " return rigid_body.RigidBody(center=center,\n", + " orientation=orientation)\n", + " \n", + "\n", + " def force_fn(state, neighbor, exists_mask):\n", + " mf = motor_force(state, exists_mask)\n", + " cf = collision_force(state, neighbor, exists_mask)\n", + " ff = friction_force(state, exists_mask)\n", + " \n", + " center = cf + ff + mf.center\n", + " orientation = mf.orientation\n", + " return rigid_body.RigidBody(center=center, orientation=orientation)\n", + "\n", + " return force_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define the environment class with all those \n", + "\n", + "Now we have all the necessary elements to create our environment. We will use the classes and functions defined above in our Braitenberg environment ... \n", + "\n", + "Env needs two principal methods (+ tge __init__ to define the charasteristics of the env ... ): \n", + "- init_state: create an initial \n", + "- step\n", + "\n", + "+ functions to handle neighborhood ....\n", + "\n", + "#### TODO : Add the functions to update the spaces ... (I think there were things like that before)\n", + "#### TODO : Should write a render function as well (maybe take inspiration from EvoJax / JaxMALR ...)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "SPACE_NDIMS = 2\n", + "\n", + "class BraitenbergEnv:\n", + " def __init__(\n", + " self,\n", + " box_size=100,\n", + " dt=0.1,\n", + " max_agents=10,\n", + " max_objects=2,\n", + " neighbor_radius=100.,\n", + " collision_alpha=0.5,\n", + " collision_eps=0.1,\n", + " n_dims=2,\n", + " seed=0,\n", + " diameter=5.0,\n", + " friction=0.1,\n", + " mass_center=1.0,\n", + " mass_orientation=0.125,\n", + " existing_agents=10,\n", + " existing_objects=2,\n", + " behavior=behavior_name_map['AGGRESSION'],\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", + " agents_color=jnp.array([0.0, 0.0, 1.0]),\n", + " objects_color=jnp.array([1.0, 0.0, 0.0])\n", + " ):\n", + " \n", + " # TODO : add docstrings\n", + " # general parameters\n", + " self.box_size = box_size\n", + " self.dt = dt\n", + " self.max_agents = max_agents\n", + " self.max_objects = max_objects\n", + " self.neighbor_radius = neighbor_radius\n", + " self.collision_alpha = collision_alpha\n", + " self.collision_eps = collision_eps\n", + " self.n_dims = n_dims\n", + " self.seed = seed\n", + " # entities parameters\n", + " self.diameter = diameter\n", + " self.friction = friction\n", + " self.mass_center = mass_center\n", + " self.mass_orientation = mass_orientation\n", + " self.existing_agents = existing_agents\n", + " self.existing_objects = existing_objects\n", + " # agents parameters\n", + " self.behavior = behavior\n", + " self.wheel_diameter = wheel_diameter\n", + " self.speed_mul = speed_mul\n", + " self.max_speed = max_speed\n", + " self.theta_mul = theta_mul\n", + " self.prox_dist_max = prox_dist_max\n", + " self.prox_cos_min = prox_cos_min\n", + " self.agents_color = agents_color\n", + " # objects parameters\n", + " self.objects_color = objects_color\n", + " # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? \n", + "\n", + "\n", + " # TODO : Split the initialization of entities, agents and objects w different functions ...\n", + " def init_state(self) -> State:\n", + " key = random.PRNGKey(self.seed)\n", + " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", + "\n", + " n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size\n", + " objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value)\n", + " object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents))))\n", + " exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects))))\n", + " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", + " # Entities idx of objects\n", + " start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects \n", + " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", + "\n", + " entity_state = 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)),\n", + " entity_type=entity_types,\n", + " entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))),\n", + " diameter=jnp.full((n_entities), self.diameter),\n", + " friction=jnp.full((n_entities), self.friction),\n", + " exists=exists\n", + " )\n", + "\n", + " agents_state = AgentState(\n", + " # idx in the entities (ent_idx) state to map agents information in the different data structures\n", + " ent_idx=jnp.arange(self.max_agents, dtype=int), \n", + " prox=jnp.zeros((self.max_agents, 2)),\n", + " motor=jnp.zeros((self.max_agents, 2)),\n", + " behavior=jnp.full((self.max_agents), self.behavior),\n", + " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", + " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", + " max_speed=jnp.full((self.max_agents), self.max_speed),\n", + " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", + " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", + " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", + " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", + " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", + " color=jnp.tile(self.agents_color, (self.max_agents, 1))\n", + " )\n", + "\n", + " objects_state = ObjectState(\n", + " ent_idx=objects_ent_idx,\n", + " color=jnp.tile(self.objects_color, (self.max_objects, 1))\n", + " )\n", + "\n", + " lg.info('creating state')\n", + " state = State(\n", + " time=0,\n", + " box_size=self.box_size,\n", + " max_agents=self.max_agents,\n", + " max_objects=self.max_objects,\n", + " neighbor_radius=self.neighbor_radius,\n", + " collision_alpha=self.collision_alpha,\n", + " collision_eps=self.collision_eps,\n", + " dt=self.dt,\n", + " entities=entity_state,\n", + " agents=agents_state,\n", + " objects=objects_state\n", + " ) \n", + "\n", + " # Create jax_md attributes for environment physics\n", + " key, physics_key = random.split(key)\n", + " self.displacement, self.shift = space.periodic(self.box_size)\n", + " init_fn, apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n", + " self.init_fn = init_fn\n", + " self.apply_physics = jit(apply_physics)\n", + " self.neighbor_fn = partition.neighbor_list(\n", + " self.displacement, \n", + " self.box_size,\n", + " r_cutoff=self.neighbor_radius,\n", + " dr_threshold=10.,\n", + " capacity_multiplier=1.5,\n", + " format=partition.Sparse\n", + " )\n", + "\n", + " state = self.init_fn(state, physics_key)\n", + " positions = state.entities.position.center\n", + " lg.info('allocating neighbors')\n", + " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", + " self.neighbors = neighbors\n", + " self.agents_neighs_idx = agents_neighs_idx\n", + "\n", + " return state\n", + " \n", + "\n", + " @partial(jit, static_argnums=(0,))\n", + " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n", + " # 1 : Compute agents proximeter and motor activations\n", + " exists_mask = jnp.where(state.entities.exists == 1, 1, 0)\n", + " # TODO Not rly clean, should maybe only return proximeters, or split the functions \n", + " prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n", + " motor = sensorimotor(prox, state.agents.behavior, state.agents.motor)\n", + "\n", + " agents = state.agents.replace(\n", + " prox=prox, \n", + " proximity_map_dist=proximity_dist_map, \n", + " proximity_map_theta=proximity_dist_theta,\n", + " motor=motor\n", + " )\n", + "\n", + " state = state.replace(agents=agents)\n", + " # 2 : Move the entities by applying physics of the env (collision, friction and motor forces)\n", + " entities = self.apply_physics(state, neighbors)\n", + "\n", + " # 3 : Apply specific consequences in the env (e.g eating an object)\n", + " state = state.replace(\n", + " time=state.time+1,\n", + " entities=entities,\n", + " )\n", + "\n", + " neighbors = neighbors.update(state.entities.position.center)\n", + "\n", + " return state, neighbors\n", + " \n", + "\n", + " def step(self, state: State) -> State:\n", + " current_state = state\n", + " state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx)\n", + "\n", + " if self.neighbors.did_buffer_overflow:\n", + " print(\"overflow\")\n", + " # reallocate neighbors and run the simulation from current_state\n", + " lg.warning('BUFFER OVERFLOW: rebuilding neighbors')\n", + " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", + " self.agents_neighs_idx = agents_neighs_idx\n", + " assert not neighbors.did_buffer_overflow\n", + "\n", + " self.neighbors = neighbors\n", + " return state\n", + "\n", + " def allocate_neighbors(self, state, position=None):\n", + " position = state.entities.position.center if position is None else position\n", + " neighbors = self.neighbor_fn.allocate(position)\n", + " mask = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", + " agents_neighs_idx = neighbors.idx[:, mask]\n", + " return neighbors, agents_neighs_idx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initiate a state from the environment and render it" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'time': 0,\n", + " 'box_size': 100,\n", + " 'max_agents': 10,\n", + " 'max_objects': 2,\n", + " 'neighbor_radius': 100.0,\n", + " 'dt': 0.1,\n", + " 'collision_alpha': 0.5,\n", + " 'collision_eps': 0.1,\n", + " 'entities': {'position': RigidBody(center=Array([[ 3.7252188, 9.242689 ],\n", + " [ 4.939151 , 86.78386 ],\n", + " [93.74271 , 71.651375 ],\n", + " [89.61038 , 64.47968 ],\n", + " [51.115047 , 85.136246 ],\n", + " [34.26517 , 60.67195 ],\n", + " [58.65188 , 57.67032 ],\n", + " [92.67553 , 1.0239005],\n", + " [94.60478 , 54.836296 ],\n", + " [57.998978 , 75.63805 ],\n", + " [31.563496 , 91.39798 ],\n", + " [77.80601 , 22.647142 ]], dtype=float32), orientation=Array([5.8640995 , 3.5555892 , 3.3702946 , 2.5002196 , 6.139788 ,\n", + " 4.0296173 , 4.711335 , 3.085717 , 2.2339876 , 0.6937443 ,\n", + " 2.0312393 , 0.29639685], dtype=float32)),\n", + " 'momentum': RigidBody(center=Array([[ 0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., 0.],\n", + " [-0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., -0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [-0., 0.],\n", + " [-0., -0.]], dtype=float32), orientation=Array([-0., 0., 0., 0., -0., -0., 0., -0., 0., -0., -0., 0.], dtype=float32)),\n", + " 'force': RigidBody(center=Array([[0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.]], dtype=float32), orientation=Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", + " 'mass': RigidBody(center=Array([[1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.]], dtype=float32, weak_type=True), orientation=Array([0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125], dtype=float32, weak_type=True)),\n", + " 'entity_type': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], dtype=int32),\n", + " 'entity_idx': Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1], dtype=int32),\n", + " 'diameter': Array([5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.], dtype=float32, weak_type=True),\n", + " 'friction': Array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], dtype=float32, weak_type=True),\n", + " 'exists': Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)},\n", + " 'agents': {'ent_idx': Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),\n", + " 'prox': Array([[0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.]], dtype=float32),\n", + " 'motor': Array([[0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.]], dtype=float32),\n", + " 'proximity_map_dist': Array([[0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.]], dtype=float32),\n", + " 'proximity_map_theta': Array([[0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.]], dtype=float32),\n", + " 'behavior': Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32, weak_type=True),\n", + " 'wheel_diameter': Array([2., 2., 2., 2., 2., 2., 2., 2., 2., 2.], dtype=float32, weak_type=True),\n", + " 'speed_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", + " 'max_speed': Array([10., 10., 10., 10., 10., 10., 10., 10., 10., 10.], dtype=float32, weak_type=True),\n", + " 'theta_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", + " 'proxs_dist_max': Array([40., 40., 40., 40., 40., 40., 40., 40., 40., 40.], dtype=float32, weak_type=True),\n", + " 'proxs_cos_min': Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32, weak_type=True),\n", + " 'color': Array([[0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.]], dtype=float32)},\n", + " 'objects': {'ent_idx': Array([10, 11], dtype=int32),\n", + " 'color': Array([[1., 0., 0.],\n", + " [1., 0., 0.]], dtype=float32)}}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env = BraitenbergEnv() \n", + "state = env.init_state() \n", + "\n", + "dict_state = flax.serialization.to_state_dict(state)\n", + "dict_state " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run a simulation and visualize it " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulation ran in 1.1898761210031807 for 10000 timesteps\n" + ] + } + ], + "source": [ + "n_steps = 5_000\n", + "\n", + "hist = []\n", + "\n", + "start = time.perf_counter()\n", + "for i in range(n_steps):\n", + " state = env.step(state) \n", + " hist.append(state)\n", + "end = time.perf_counter()\n", + "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scale the size of the simulation\n", + "\n", + "Increase the box_size, n_agents and objects ... \n", + "\n", + "#### TODO : Check the rendering functions bc here agents are way too big (but matplotlib scatter area mechanism kinda sucks)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:BUFFER OVERFLOW: rebuilding neighbors\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "overflow\n", + "Simulation ran in 3.715958105000027 for 5000 timesteps\n" + ] + } + ], + "source": [ + "env = BraitenbergEnv(box_size=500,\n", + " max_agents=100,\n", + " max_objects=20,\n", + " existing_agents=90,\n", + " existing_objects=20,\n", + " prox_dist_max=100) \n", + " \n", + "state = env.init_state() \n", + "\n", + "n_steps = 5_000\n", + "\n", + "hist = []\n", + "\n", + "start = time.perf_counter()\n", + "for i in range(n_steps):\n", + " state = env.step(state) \n", + " hist.append(state)\n", + "end = time.perf_counter()\n", + "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulation ran in 2.861154723999789 for 5000 timesteps\n" + ] + } + ], + "source": [ + "env = BraitenbergEnv(box_size=500,\n", + " max_agents=100,\n", + " max_objects=20,\n", + " existing_agents=90,\n", + " existing_objects=20,\n", + " prox_dist_max=10) \n", + "\n", + "state = env.init_state() \n", + "\n", + "n_steps = 5_000\n", + "\n", + "start = time.perf_counter()\n", + "for i in range(n_steps):\n", + " state = env.step(state) \n", + "end = time.perf_counter()\n", + "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cool because neighbors rebuilding seems to work well but the recompilation time seems big (see other running time w agent with a low proximeter range (i.e they don't move and thus neighbor arrays are not computed again))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=10)" + ] + } + ], + "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 +} From a243106543606e9745d1576461bb0ea51f2d7cda Mon Sep 17 00:00:00 2001 From: corentinlger Date: Wed, 22 May 2024 19:23:40 +0200 Subject: [PATCH 05/18] Update braitenberg notebook and add new prey/predator braitenberg environment --- notebooks/braintenberg_env_notebook.ipynb | 33 +- notebooks/prey_predator_braitenberg.ipynb | 1397 +++++++++++++++++++++ 2 files changed, 1417 insertions(+), 13 deletions(-) create mode 100644 notebooks/prey_predator_braitenberg.ipynb diff --git a/notebooks/braintenberg_env_notebook.ipynb b/notebooks/braintenberg_env_notebook.ipynb index e2de5e3..8ed7ede 100644 --- a/notebooks/braintenberg_env_notebook.ipynb +++ b/notebooks/braintenberg_env_notebook.ipynb @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -625,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -758,7 +758,7 @@ " [1., 0., 0.]], dtype=float32)}}" ] }, - "execution_count": 15, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -773,7 +773,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -800,14 +800,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Simulation ran in 1.1898761210031807 for 10000 timesteps\n" + "Simulation ran in 1.9971963759999198 for 5000 timesteps\n" ] } ], @@ -826,12 +826,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -857,7 +857,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -872,7 +872,7 @@ "output_type": "stream", "text": [ "overflow\n", - "Simulation ran in 3.715958105000027 for 5000 timesteps\n" + "Simulation ran in 5.380792976000521 for 5000 timesteps\n" ] } ], @@ -900,14 +900,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Simulation ran in 2.861154723999789 for 5000 timesteps\n" + "Simulation ran in 3.337236932999076 for 5000 timesteps\n" ] } ], @@ -939,7 +939,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -956,6 +956,13 @@ "source": [ "render_history(hist, skip_frames=10)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fun patterns observed with a larger simulation and aggressive agents ! (care because the size of the agents isn't at scale so it is why it can look like they don't collide sometimes)" + ] } ], "metadata": { diff --git a/notebooks/prey_predator_braitenberg.ipynb b/notebooks/prey_predator_braitenberg.ipynb new file mode 100644 index 0000000..e524630 --- /dev/null +++ b/notebooks/prey_predator_braitenberg.ipynb @@ -0,0 +1,1397 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Braitenberg environment notebook\n", + "\n", + "Use this notebook to showcase how to create an environment in vivarium ... w a realistic physics ... " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" + ] + } + ], + "source": [ + "import time\n", + "import logging as lg\n", + "from enum import Enum\n", + "from functools import partial\n", + "from typing import Tuple\n", + "\n", + "import jax\n", + "import flax\n", + "import jax_md\n", + "import jax.numpy as jnp\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 space, rigid_body, partition, simulate, quantity\n", + "\n", + "from vivarium.utils import normal, render, render_history\n", + "from vivarium.simulator.general_physics_engine import total_collision_energy, friction_force, dynamics_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create classes for the environment\n", + "\n", + "We use flax dataclasses to store all the information about our environment state (positions of all entities ..., features of agents and objects ...)\n", + "\n", + "We add elements about agents types (prey / predator ...)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class EntityType(Enum):\n", + " AGENT = 0\n", + " OBJECT = 1\n", + "\n", + "class AgentType(Enum):\n", + " PREY = 0\n", + " PREDATOR = 1\n", + "\n", + "predator_color = jnp.array([1., 0., 0.])\n", + "prey_color = jnp.array([0., 0., 1.])\n", + "object_color = jnp.array([0., 1., 0.])\n", + "\n", + "# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState)\n", + "@struct.dataclass\n", + "class EntityState(simulate.NVEState):\n", + " entity_type: jnp.array\n", + " entity_idx: jnp.array\n", + " diameter: jnp.array\n", + " friction: jnp.array\n", + " exists: jnp.array\n", + "\n", + " @property\n", + " def velocity(self) -> jnp.array:\n", + " return self.momentum / self.mass\n", + " \n", + "@struct.dataclass\n", + "class AgentState:\n", + " ent_idx: jnp.array\n", + " agent_type: jnp.array\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", + " 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", + " color: jnp.array\n", + "\n", + "@struct.dataclass\n", + "class ObjectState:\n", + " ent_idx: jnp.array \n", + " color: jnp.array\n", + "\n", + "# TODO : Add obs field like in JaxMARL -> compute agents actions w a vmap on obs\n", + "@struct.dataclass\n", + "class State:\n", + " time: jnp.int32\n", + " box_size: jnp.int32\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", + " entities: EntityState\n", + " agents: AgentState\n", + " objects: ObjectState" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define helper functions to compute the proximeters of agents\n", + "\n", + "Bc we use braitenberg vehicles ... need to compute values of proximeters for them to detect their environment ... " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "### 2 Define functions that will be used in the step fn of the env ###\n", + "\n", + "def relative_position(displ, theta):\n", + " \"\"\"\n", + " Compute the relative distance and angle from a source agent to a target agent\n", + " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", + " :param theta: Orientation of the source agent (in the reference frame of the map)\n", + " :return: dist: distance from source to target.\n", + " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", + " \"\"\"\n", + " dist = jnp.linalg.norm(displ)\n", + " norm_displ = displ / dist\n", + " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", + " relative_theta = theta_displ - theta\n", + " return dist, relative_theta\n", + "\n", + "proximity_map = vmap(relative_position, (0, 0))\n", + "\n", + "# TODO : SHould redo all these functions with the prox computation because very hard to understand without vmap etcc\n", + "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", + " \"\"\"\n", + " Compute the proximeter activations (left, right) induced by the presence of an entity\n", + " :param dist: distance from the agent to the entity\n", + " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", + " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", + " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", + " :return: left and right proximeter activation in a jnp array with shape (2,)\n", + " \"\"\"\n", + " cos_dir = jnp.cos(relative_theta)\n", + " prox = 1. - (dist / dist_max)\n", + " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", + " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", + " left = in_view * at_left * prox\n", + " right = in_view * (1. - at_left) * prox\n", + " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", + "\n", + "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", + "\n", + "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", + " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", + " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", + " proxs = ops.segment_max(\n", + " raw_proxs,\n", + " senders, \n", + " max_agents)\n", + " \n", + " return proxs\n", + "\n", + "# TODO : I think we should refactor this part of the code with a function using vmap\n", + "def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):\n", + " \"\"\"\n", + " Set agents' proximeter activations\n", + " :param state: full simulation State\n", + " :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),\n", + " where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.\n", + " :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).\n", + " target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).\n", + " :return:\n", + " \"\"\"\n", + " body = state.entities.position\n", + " mask = target_exists_mask[agents_neighs_idx[1, :]] \n", + " senders, receivers = agents_neighs_idx\n", + " Ra = body.center[senders]\n", + " Rb = body.center[receivers]\n", + " dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", + "\n", + " # Create distance and angle maps between entities\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", + "\n", + " # TODO : refactor this function because a lot of redundancies in the arguments (state.agents)\n", + " prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],\n", + " state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)\n", + " \n", + " return prox, proximity_map_dist, proximity_map_theta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create helper functions to compute motor activations of agents\n", + "\n", + "Now that we know how to compute proximters values, we want our agents to act accordingly to them ... see how to map sensors values to motor activations (e.g w behaviors of attraction / repulsion towards some objects, agents ...)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO : Refactor the following part\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY'])\n", + "\n", + "linear_behavior_matrices = {\n", + " linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]),\n", + " linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]),\n", + " linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]),\n", + " linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]),\n", + "}\n", + "\n", + "def linear_behavior(proxs, motors, matrix):\n", + " return matrix.dot(jnp.hstack((proxs, 1.)))\n", + "\n", + "def apply_motors(proxs, motors):\n", + " return motors\n", + "\n", + "def noop(proxs, motors):\n", + " return jnp.array([0., 0.])\n", + "\n", + "behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh])\n", + " for beh in linear_behavior_enum] \\\n", + " + [apply_motors, noop]\n", + "\n", + "behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)}\n", + "behavior_name_map['manual'] = len(behavior_bank) - 2\n", + "behavior_name_map['noop'] = len(behavior_bank) - 1\n", + "\n", + "lg.info(behavior_name_map)\n", + "\n", + "# TODO : seems useless and unused\n", + "reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()}\n", + "\n", + "def switch_fn(fn_list):\n", + " def switch(index, *operands):\n", + " return lax.switch(index, fn_list, *operands)\n", + " return switch\n", + "\n", + "multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0))\n", + "\n", + "def sensorimotor(prox, behaviors, motor):\n", + " motor = multi_switch(behaviors, prox, motor)\n", + " return motor\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", + "\n", + "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", + " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", + " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", + " return fwd, rot\n", + "\n", + "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", + " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", + " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", + " return left, right\n", + "\n", + "def motor_command(wheel_activation, base_length, wheel_diameter):\n", + " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", + " return fwd, rot\n", + "\n", + "motor_command = vmap(motor_command, (0, 0, 0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define a force function for the environment\n", + "\n", + "Bc we want a world with a realistic physics, we wanna define how forces are going to be applied to our entities (collision and friction) as well as the motor forces for the braitenberg vehicles ... " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def braintenberg_force_fn(displacement):\n", + " coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))\n", + "\n", + " def collision_force(state, neighbor, exists_mask):\n", + " return coll_force_fn(\n", + " state.entities.position.center,\n", + " neighbor=neighbor,\n", + " exists_mask=exists_mask,\n", + " diameter=state.entities.diameter,\n", + " epsilon=state.collision_eps,\n", + " alpha=state.collision_alpha\n", + " )\n", + "\n", + " def motor_force(state, exists_mask):\n", + " agent_idx = state.agents.ent_idx\n", + "\n", + " body = rigid_body.RigidBody(\n", + " center=state.entities.position.center[agent_idx],\n", + " orientation=state.entities.position.orientation[agent_idx]\n", + " )\n", + " \n", + " n = normal(body.orientation)\n", + "\n", + " fwd, rot = motor_command(\n", + " state.agents.motor,\n", + " state.entities.diameter[agent_idx],\n", + " state.agents.wheel_diameter\n", + " )\n", + " # `a_max` arg is deprecated in recent versions of jax, replaced by `max`\n", + " fwd = jnp.clip(fwd, a_max=state.agents.max_speed)\n", + "\n", + " cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]\n", + " cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)\n", + " cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]\n", + " \n", + " fwd_delta = fwd - cur_fwd_vel\n", + " rot_delta = rot - cur_rot_vel\n", + "\n", + " fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T\n", + " rot_force = rot_delta * state.agents.theta_mul\n", + "\n", + " center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)\n", + " orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)\n", + "\n", + " # apply mask to make non existing agents stand still\n", + " orientation = jnp.where(exists_mask, orientation, 0.)\n", + " # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center\n", + " exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)\n", + " center = jnp.where(exists_mask, center, 0.)\n", + "\n", + " return rigid_body.RigidBody(center=center,\n", + " orientation=orientation)\n", + " \n", + "\n", + " def force_fn(state, neighbor, exists_mask):\n", + " mf = motor_force(state, exists_mask)\n", + " cf = collision_force(state, neighbor, exists_mask)\n", + " ff = friction_force(state, exists_mask)\n", + " \n", + " center = cf + ff + mf.center\n", + " orientation = mf.orientation\n", + " return rigid_body.RigidBody(center=center, orientation=orientation)\n", + "\n", + " return force_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define the environment class with all those \n", + "\n", + "Now we have all the necessary elements to create our environment. We will use the classes and functions defined above in our Braitenberg environment ... \n", + "\n", + "Env needs two principal methods (+ tge __init__ to define the charasteristics of the env ... ): \n", + "- init_state: create an initial \n", + "- step\n", + "\n", + "+ functions to handle neighborhood ....\n", + "\n", + "#### TODO : Add the functions to update the spaces ... (I think there were things like that before)\n", + "#### TODO : Should write a render function as well (maybe take inspiration from EvoJax / JaxMALR ...)\n", + "\n", + "\n", + "Added in the _step function a part to make predator agents eat prey agents if they come too close" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "SPACE_NDIMS = 2\n", + "\n", + "class BraitenbergEnv:\n", + " def __init__(\n", + " self,\n", + " box_size=200,\n", + " dt=0.1,\n", + " max_agents=50,\n", + " max_objects=10,\n", + " neighbor_radius=100.,\n", + " collision_alpha=0.5,\n", + " collision_eps=0.1,\n", + " n_dims=2,\n", + " seed=0,\n", + " diameter=5.0,\n", + " friction=0.1,\n", + " mass_center=1.0,\n", + " mass_orientation=0.125,\n", + " existing_agents=50,\n", + " n_preys=25,\n", + " n_predators=25,\n", + " pred_eating_range=15,\n", + " existing_objects=0,\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", + " prey_color=jnp.array([0.0, 0.0, 1.0]),\n", + " predator_color=jnp.array([1.0, 0.0, 0.0]),\n", + " objects_color=jnp.array([0.0, 1.0, 0.0])\n", + " ):\n", + " \n", + " # TODO : add docstrings\n", + " # general parameters\n", + " self.box_size = box_size\n", + " self.dt = dt\n", + " self.max_agents = max_agents\n", + " self.max_objects = max_objects\n", + " self.neighbor_radius = neighbor_radius\n", + " self.collision_alpha = collision_alpha\n", + " self.collision_eps = collision_eps\n", + " self.n_dims = n_dims\n", + " self.seed = seed\n", + " # entities parameters\n", + " self.diameter = diameter\n", + " self.friction = friction\n", + " self.mass_center = mass_center\n", + " self.mass_orientation = mass_orientation\n", + " self.existing_agents = existing_agents\n", + " self.existing_objects = existing_objects\n", + " # agents parameters\n", + " self.n_preys = n_preys\n", + " self.n_predators = n_predators\n", + " self.wheel_diameter = wheel_diameter\n", + " self.speed_mul = speed_mul\n", + " self.max_speed = max_speed\n", + " self.theta_mul = theta_mul\n", + " self.prox_dist_max = prox_dist_max\n", + " self.prox_cos_min = prox_cos_min\n", + " self.prey_color = prey_color\n", + " self.predator_color = predator_color\n", + " self.pred_eating_range = pred_eating_range\n", + " # objects parameters\n", + " self.objects_color = objects_color\n", + " # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? \n", + "\n", + "\n", + " # TODO : Split the initialization of entities, agents and objects w different functions ...\n", + " def init_state(self) -> State:\n", + " key = random.PRNGKey(self.seed)\n", + " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", + "\n", + " n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size\n", + " objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value)\n", + " object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents))))\n", + " exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects))))\n", + " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", + " # Entities idx of objects\n", + " start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects \n", + " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", + "\n", + " entity_state = 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)),\n", + " entity_type=entity_types,\n", + " entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))),\n", + " diameter=jnp.full((n_entities), self.diameter),\n", + " friction=jnp.full((n_entities), self.friction),\n", + " exists=exists\n", + " )\n", + "\n", + " # Added agent types for prey and predators\n", + " agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value)))\n", + " agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0)\n", + " behaviors = jnp.hstack((jnp.full(self.n_preys, behavior_name_map['FEAR']), jnp.full(self.n_predators, behavior_name_map['AGGRESSION'])))\n", + "\n", + " agents_state = AgentState(\n", + " # idx in the entities (ent_idx) state to map agents information in the different data structures\n", + " ent_idx=jnp.arange(self.max_agents, dtype=int),\n", + " agent_type=agent_types, \n", + " prox=jnp.zeros((self.max_agents, 2)),\n", + " motor=jnp.zeros((self.max_agents, 2)),\n", + " behavior=behaviors,\n", + " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", + " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", + " max_speed=jnp.full((self.max_agents), self.max_speed),\n", + " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", + " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", + " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", + " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", + " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", + " color=agents_colors\n", + " )\n", + "\n", + " objects_state = ObjectState(\n", + " ent_idx=objects_ent_idx,\n", + " color=jnp.tile(self.objects_color, (self.max_objects, 1))\n", + " )\n", + "\n", + " lg.info('creating state')\n", + " state = State(\n", + " time=0,\n", + " box_size=self.box_size,\n", + " max_agents=self.max_agents,\n", + " max_objects=self.max_objects,\n", + " neighbor_radius=self.neighbor_radius,\n", + " collision_alpha=self.collision_alpha,\n", + " collision_eps=self.collision_eps,\n", + " dt=self.dt,\n", + " entities=entity_state,\n", + " agents=agents_state,\n", + " objects=objects_state\n", + " ) \n", + "\n", + " # Create jax_md attributes for environment physics\n", + " key, physics_key = random.split(key)\n", + " self.displacement, self.shift = space.periodic(self.box_size)\n", + " init_fn, apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n", + " self.init_fn = init_fn\n", + " self.apply_physics = jit(apply_physics)\n", + " self.neighbor_fn = partition.neighbor_list(\n", + " self.displacement, \n", + " self.box_size,\n", + " r_cutoff=self.neighbor_radius,\n", + " dr_threshold=10.,\n", + " capacity_multiplier=1.5,\n", + " format=partition.Sparse\n", + " )\n", + "\n", + " state = self.init_fn(state, physics_key)\n", + " positions = state.entities.position.center\n", + " lg.info('allocating neighbors')\n", + " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", + " self.neighbors = neighbors\n", + " self.agents_neighs_idx = agents_neighs_idx\n", + "\n", + " self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n", + " self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n", + " self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n", + "\n", + " return state\n", + " \n", + "\n", + " @partial(jit, static_argnums=(0,))\n", + " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n", + " # 1 : Compute agents proximeter and motor activations\n", + " exists_mask = jnp.where(state.entities.exists == 1, 1, 0)\n", + " # TODO Not rly clean, should maybe only return proximeters, or split the functions \n", + " prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n", + " motor = sensorimotor(prox, state.agents.behavior, state.agents.motor)\n", + "\n", + " agents = state.agents.replace(\n", + " prox=prox, \n", + " proximity_map_dist=proximity_dist_map, \n", + " proximity_map_theta=proximity_dist_theta,\n", + " motor=motor\n", + " )\n", + "\n", + " state = state.replace(agents=agents)\n", + " # 2 : Move the entities by applying physics of the env (collision, friction and motor forces)\n", + " entities = self.apply_physics(state, neighbors)\n", + "\n", + " # 3 : Apply specific consequences in the env (e.g predators eat preys here)\n", + " state = state.replace(\n", + " time=state.time+1,\n", + " entities=entities,\n", + " )\n", + "\n", + " # TODO : Improve the name of the functions and see how to integrate neighborhoods in fns\n", + " R = state.entities.position.center\n", + " exist = state.entities.exists\n", + " prey_idx = self.prey_idx\n", + " pred_idx = self.pred_idx\n", + "\n", + " agents_ent_idx = state.agents.ent_idx\n", + " predator_exist = exist[agents_ent_idx][pred_idx]\n", + "\n", + " def distance(point1, point2, displ):\n", + " diff = displ(point1, point2)\n", + " squared_diff = jnp.sum(jnp.square(diff))\n", + " return jnp.sqrt(squared_diff)\n", + "\n", + " # Could maybe create this as a method in the class, or above idk\n", + " distance = partial(distance, displ=self.displacement)\n", + " distance_to_all_preds = jit(vmap(distance, in_axes=(None, 0)))\n", + "\n", + " # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above \n", + " def can_be_eaten(R_prey, R_predators, predator_exist):\n", + " dist_to_preds = distance_to_all_preds(R_prey, R_predators)\n", + " in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0)\n", + " # Could also return which agent ate the other one (e.g to increase their energy) \n", + " will_be_eaten_by = in_range * predator_exist\n", + " eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0)\n", + "\n", + " return eaten_or_not\n", + "\n", + " can_all_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None))\n", + "\n", + " # See which preys can be eaten by predators and update the exists array accordingly\n", + " can_be_eaten_idx = can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist)\n", + " exist_prey = exist[agents_ent_idx[prey_idx]]\n", + " new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey)\n", + " exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey)\n", + "\n", + " # Update the state\n", + " entities = state.entities.replace(exists=exist)\n", + " state = state.replace(entities=entities)\n", + "\n", + " # Compute the new neighbors\n", + " neighbors = neighbors.update(state.entities.position.center)\n", + "\n", + " return state, neighbors\n", + " \n", + "\n", + " def step(self, state: State) -> State:\n", + " current_state = state\n", + " state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx)\n", + "\n", + " if self.neighbors.did_buffer_overflow:\n", + " print(\"overflow\")\n", + " # reallocate neighbors and run the simulation from current_state\n", + " lg.warning('BUFFER OVERFLOW: rebuilding neighbors')\n", + " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", + " self.agents_neighs_idx = agents_neighs_idx\n", + " assert not neighbors.did_buffer_overflow\n", + "\n", + " self.neighbors = neighbors\n", + " return state\n", + "\n", + " def allocate_neighbors(self, state, position=None):\n", + " position = state.entities.position.center if position is None else position\n", + " neighbors = self.neighbor_fn.allocate(position)\n", + " mask = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", + " agents_neighs_idx = neighbors.idx[:, mask]\n", + " return neighbors, agents_neighs_idx" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initiate a state from the environment and render it" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'time': 0,\n", + " 'box_size': 200,\n", + " 'max_agents': 50,\n", + " 'max_objects': 10,\n", + " 'neighbor_radius': 100.0,\n", + " 'dt': 0.1,\n", + " 'collision_alpha': 0.5,\n", + " 'collision_eps': 0.1,\n", + " 'entities': {'position': RigidBody(center=Array([[ 38.128494 , 10.72216 ],\n", + " [188.62827 , 15.473008 ],\n", + " [137.63512 , 139.9108 ],\n", + " [ 12.2510195, 109.30286 ],\n", + " [111.62963 , 169.92522 ],\n", + " [ 59.689022 , 141.29376 ],\n", + " [184.63835 , 188.77783 ],\n", + " [ 86.62457 , 188.40268 ],\n", + " [102.70498 , 121.01295 ],\n", + " [ 97.27762 , 118.294 ],\n", + " [ 95.37985 , 145.33739 ],\n", + " [197.64905 , 197.61378 ],\n", + " [182.52403 , 125.79477 ],\n", + " [133.30867 , 107.42421 ],\n", + " [119.64154 , 153.33914 ],\n", + " [ 62.279438 , 53.706192 ],\n", + " [148.1706 , 111.157845 ],\n", + " [139.92258 , 130.43387 ],\n", + " [122.68515 , 76.240585 ],\n", + " [ 80.25191 , 182.03455 ],\n", + " [ 48.71185 , 196.26427 ],\n", + " [ 13.737249 , 79.90112 ],\n", + " [ 14.034843 , 102.85857 ],\n", + " [ 25.438738 , 136.74767 ],\n", + " [107.97717 , 95.58396 ],\n", + " [ 54.119514 , 105.528595 ],\n", + " [ 36.534023 , 116.46688 ],\n", + " [138.342 , 185.01718 ],\n", + " [100.57411 , 132.57613 ],\n", + " [153.72917 , 75.5013 ],\n", + " [ 32.760715 , 4.9206734],\n", + " [181.20894 , 27.841686 ],\n", + " [ 81.363174 , 109.49633 ],\n", + " [134.48424 , 177.27881 ],\n", + " [174.30241 , 134.59552 ],\n", + " [ 7.496667 , 189.53946 ],\n", + " [ 28.946949 , 183.13513 ],\n", + " [190.89255 , 78.80938 ],\n", + " [131.64198 , 152.88654 ],\n", + " [109.41062 , 174.99223 ],\n", + " [126.72467 , 198.56648 ],\n", + " [134.22041 , 163.78674 ],\n", + " [179.58687 , 84.63037 ],\n", + " [199.02728 , 190.06226 ],\n", + " [ 36.093403 , 170.46954 ],\n", + " [130.75116 , 22.477745 ],\n", + " [146.79582 , 53.330017 ],\n", + " [198.88518 , 66.81149 ],\n", + " [116.24823 , 103.07367 ],\n", + " [141.93188 , 127.34044 ],\n", + " [ 97.97359 , 42.79132 ],\n", + " [175.16243 , 140.7605 ],\n", + " [102.140686 , 147.21289 ],\n", + " [ 47.92311 , 188.1773 ],\n", + " [ 8.467627 , 120.6624 ],\n", + " [140.87296 , 115.579605 ],\n", + " [182.76451 , 188.26413 ],\n", + " [ 73.043945 , 126.24099 ],\n", + " [158.9183 , 141.14896 ],\n", + " [ 46.763206 , 160.65369 ]], dtype=float32), orientation=Array([2.1340947 , 4.698772 , 5.9882007 , 0.47786725, 5.809877 ,\n", + " 2.3037682 , 3.335812 , 5.9231067 , 5.081875 , 5.660715 ,\n", + " 0.04470266, 6.2243633 , 6.282406 , 5.7481685 , 6.0861025 ,\n", + " 0.17691487, 3.184819 , 2.2409737 , 4.6186943 , 3.1103423 ,\n", + " 3.330661 , 5.318963 , 1.6345007 , 3.04697 , 3.710415 ,\n", + " 2.7937512 , 1.1411581 , 1.3474666 , 4.740075 , 6.123318 ,\n", + " 2.7340894 , 0.6933593 , 0.01654497, 1.8102928 , 3.7663627 ,\n", + " 5.801127 , 4.98985 , 1.0743866 , 1.1902215 , 2.3457549 ,\n", + " 3.6510615 , 1.2870609 , 5.917576 , 0.29385844, 3.179579 ,\n", + " 1.0541174 , 3.7426205 , 4.5608673 , 2.2428179 , 2.666849 ,\n", + " 4.398739 , 1.6034698 , 0.07834687, 0.2900205 , 3.638261 ,\n", + " 4.461154 , 3.6862442 , 0.9001913 , 4.320826 , 4.5112166 ], dtype=float32)),\n", + " 'momentum': RigidBody(center=Array([[ 0., 0.],\n", + " [-0., -0.],\n", + " [ 0., -0.],\n", + " [-0., -0.],\n", + " [-0., 0.],\n", + " [-0., -0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [ 0., -0.],\n", + " [-0., -0.],\n", + " [-0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., -0.],\n", + " [-0., -0.],\n", + " [-0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., 0.],\n", + " [-0., 0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [ 0., 0.],\n", + " [-0., -0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [-0., 0.],\n", + " [ 0., 0.],\n", + " [ 0., -0.],\n", + " [-0., 0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [ 0., 0.],\n", + " [-0., 0.],\n", + " [-0., 0.],\n", + " [ 0., 0.],\n", + " [-0., 0.],\n", + " [-0., 0.],\n", + " [ 0., 0.],\n", + " [ 0., 0.],\n", + " [-0., 0.],\n", + " [-0., -0.],\n", + " [-0., 0.],\n", + " [-0., 0.],\n", + " [-0., -0.],\n", + " [ 0., 0.],\n", + " [-0., 0.],\n", + " [ 0., 0.],\n", + " [-0., -0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [ 0., 0.],\n", + " [ 0., 0.],\n", + " [-0., 0.],\n", + " [ 0., -0.],\n", + " [ 0., -0.],\n", + " [ 0., 0.],\n", + " [ 0., -0.],\n", + " [-0., 0.],\n", + " [-0., -0.]], dtype=float32), orientation=Array([-0., 0., 0., -0., 0., 0., -0., -0., -0., 0., -0., 0., 0.,\n", + " 0., -0., 0., 0., 0., 0., -0., 0., 0., -0., -0., -0., -0.,\n", + " 0., -0., -0., 0., 0., -0., 0., 0., -0., -0., -0., 0., 0.,\n", + " 0., -0., 0., -0., -0., 0., 0., -0., 0., 0., 0., 0., 0.,\n", + " -0., -0., 0., 0., -0., 0., 0., 0.], dtype=float32)),\n", + " 'force': RigidBody(center=Array([[0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.]], dtype=float32), orientation=Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", + " 'mass': RigidBody(center=Array([[1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.]], dtype=float32, weak_type=True), orientation=Array([0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", + " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125], dtype=float32, weak_type=True)),\n", + " 'entity_type': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32),\n", + " 'entity_idx': Array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 0,\n", + " 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),\n", + " 'diameter': Array([5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", + " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", + " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", + " 5., 5., 5., 5., 5., 5., 5., 5., 5.], dtype=float32, weak_type=True),\n", + " 'friction': Array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", + " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", + " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", + " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", + " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], dtype=float32, weak_type=True),\n", + " 'exists': Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32)},\n", + " 'agents': {'ent_idx': Array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49], dtype=int32),\n", + " 'agent_type': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1], dtype=int32, weak_type=True),\n", + " 'prox': Array([[0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.]], dtype=float32),\n", + " 'motor': Array([[0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.]], dtype=float32),\n", + " 'proximity_map_dist': Array([[0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.]], dtype=float32),\n", + " 'proximity_map_theta': Array([[0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.]], dtype=float32),\n", + " 'behavior': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1], dtype=int32, weak_type=True),\n", + " 'wheel_diameter': Array([2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,\n", + " 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,\n", + " 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.], dtype=float32, weak_type=True),\n", + " 'speed_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", + " 'max_speed': Array([10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.,\n", + " 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.,\n", + " 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.,\n", + " 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.], dtype=float32, weak_type=True),\n", + " 'theta_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", + " 'proxs_dist_max': Array([40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.,\n", + " 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.,\n", + " 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.,\n", + " 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.], dtype=float32, weak_type=True),\n", + " 'proxs_cos_min': Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32, weak_type=True),\n", + " 'color': Array([[0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [0., 0., 1.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.],\n", + " [1., 0., 0.]], dtype=float32)},\n", + " 'objects': {'ent_idx': Array([50, 51, 52, 53, 54, 55, 56, 57, 58, 59], dtype=int32),\n", + " 'color': Array([[0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.]], dtype=float32)}}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "env = BraitenbergEnv(pred_eating_range=5) \n", + "state = env.init_state() \n", + "\n", + "dict_state = flax.serialization.to_state_dict(state)\n", + "dict_state " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run a simulation and visualize it " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulation ran in 2.0204294820032374 for 1000 timesteps\n" + ] + } + ], + "source": [ + "n_steps = 1000\n", + "\n", + "hist = []\n", + "\n", + "start = time.perf_counter()\n", + "for i in range(n_steps):\n", + " state = env.step(state) \n", + " hist.append(state)\n", + "end = time.perf_counter()\n", + "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=5)" + ] + } + ], + "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 +} From c17a78b24a2aeccf6b0a68a549302834e17f059d Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 3 Jun 2024 15:16:22 +0200 Subject: [PATCH 06/18] Delete new notebooks on refactored envs and associated files --- notebooks/braintenberg_env_notebook.ipynb | 989 ------------- notebooks/prey_predator_braitenberg.ipynb | 1397 ------------------ notebooks/refactored_braitenberg_env.py | 523 ------- vivarium/simulator/general_physics_engine.py | 199 --- vivarium/utils.py | 114 -- 5 files changed, 3222 deletions(-) delete mode 100644 notebooks/braintenberg_env_notebook.ipynb delete mode 100644 notebooks/prey_predator_braitenberg.ipynb delete mode 100644 notebooks/refactored_braitenberg_env.py delete mode 100644 vivarium/simulator/general_physics_engine.py delete mode 100644 vivarium/utils.py diff --git a/notebooks/braintenberg_env_notebook.ipynb b/notebooks/braintenberg_env_notebook.ipynb deleted file mode 100644 index 8ed7ede..0000000 --- a/notebooks/braintenberg_env_notebook.ipynb +++ /dev/null @@ -1,989 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Braitenberg environment notebook\n", - "\n", - "Use this notebook to showcase how to create an environment in vivarium ... w a realistic physics ... " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" - ] - } - ], - "source": [ - "import time\n", - "import logging as lg\n", - "from enum import Enum\n", - "from functools import partial\n", - "from typing import Tuple\n", - "\n", - "import jax\n", - "import flax\n", - "import jax.numpy as jnp\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 space, rigid_body, partition, simulate, quantity\n", - "\n", - "from vivarium.utils import normal, render, render_history\n", - "from vivarium.simulator.general_physics_engine import total_collision_energy, friction_force, dynamics_fn" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create classes for the environment\n", - "\n", - "We use flax dataclasses to store all the information about our environment state (positions of all entities ..., features of agents and objects ...)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "class EntityType(Enum):\n", - " AGENT = 0\n", - " OBJECT = 1\n", - "\n", - "# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState)\n", - "@struct.dataclass\n", - "class EntityState(simulate.NVEState):\n", - " entity_type: jnp.array\n", - " entity_idx: jnp.array\n", - " diameter: jnp.array\n", - " friction: jnp.array\n", - " exists: jnp.array\n", - "\n", - " @property\n", - " def velocity(self) -> jnp.array:\n", - " return self.momentum / self.mass\n", - " \n", - "@struct.dataclass\n", - "class AgentState:\n", - " ent_idx: jnp.array\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", - " 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", - " color: jnp.array\n", - "\n", - "@struct.dataclass\n", - "class ObjectState:\n", - " ent_idx: jnp.array \n", - " color: jnp.array\n", - "\n", - "# TODO : Add obs field like in JaxMARL -> compute agents actions w a vmap on obs\n", - "@struct.dataclass\n", - "class State:\n", - " time: jnp.int32\n", - " box_size: jnp.int32\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", - " entities: EntityState\n", - " agents: AgentState\n", - " objects: ObjectState" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define helper functions to compute the proximeters of agents\n", - "\n", - "Bc we use braitenberg vehicles ... need to compute values of proximeters for them to detect their environment ... " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "### 2 Define functions that will be used in the step fn of the env ###\n", - "\n", - "def relative_position(displ, theta):\n", - " \"\"\"\n", - " Compute the relative distance and angle from a source agent to a target agent\n", - " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", - " :param theta: Orientation of the source agent (in the reference frame of the map)\n", - " :return: dist: distance from source to target.\n", - " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", - " \"\"\"\n", - " dist = jnp.linalg.norm(displ)\n", - " norm_displ = displ / dist\n", - " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", - " relative_theta = theta_displ - theta\n", - " return dist, relative_theta\n", - "\n", - "proximity_map = vmap(relative_position, (0, 0))\n", - "\n", - "# TODO : SHould redo all these functions with the prox computation because very hard to understand without vmap etcc\n", - "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", - " \"\"\"\n", - " Compute the proximeter activations (left, right) induced by the presence of an entity\n", - " :param dist: distance from the agent to the entity\n", - " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", - " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", - " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", - " :return: left and right proximeter activation in a jnp array with shape (2,)\n", - " \"\"\"\n", - " cos_dir = jnp.cos(relative_theta)\n", - " prox = 1. - (dist / dist_max)\n", - " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", - " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", - " left = in_view * at_left * prox\n", - " right = in_view * (1. - at_left) * prox\n", - " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", - "\n", - "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", - "\n", - "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", - " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", - " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", - " proxs = ops.segment_max(\n", - " raw_proxs,\n", - " senders, \n", - " max_agents)\n", - " \n", - " return proxs\n", - "\n", - "# TODO : I think we should refactor this part of the code with a function using vmap\n", - "def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):\n", - " \"\"\"\n", - " Set agents' proximeter activations\n", - " :param state: full simulation State\n", - " :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),\n", - " where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.\n", - " :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).\n", - " target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).\n", - " :return:\n", - " \"\"\"\n", - " body = state.entities.position\n", - " mask = target_exists_mask[agents_neighs_idx[1, :]] \n", - " senders, receivers = agents_neighs_idx\n", - " Ra = body.center[senders]\n", - " Rb = body.center[receivers]\n", - " dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", - "\n", - " # Create distance and angle maps between entities\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", - "\n", - " # TODO : refactor this function because a lot of redundancies in the arguments (state.agents)\n", - " prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],\n", - " state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)\n", - " \n", - " return prox, proximity_map_dist, proximity_map_theta" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create helper functions to compute motor activations of agents\n", - "\n", - "Now that we know how to compute proximters values, we want our agents to act accordingly to them ... see how to map sensors values to motor activations (e.g w behaviors of attraction / repulsion towards some objects, agents ...)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO : Refactor the following part\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY'])\n", - "\n", - "linear_behavior_matrices = {\n", - " linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]),\n", - " linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]),\n", - " linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]),\n", - " linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]),\n", - "}\n", - "\n", - "def linear_behavior(proxs, motors, matrix):\n", - " return matrix.dot(jnp.hstack((proxs, 1.)))\n", - "\n", - "def apply_motors(proxs, motors):\n", - " return motors\n", - "\n", - "def noop(proxs, motors):\n", - " return jnp.array([0., 0.])\n", - "\n", - "behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh])\n", - " for beh in linear_behavior_enum] \\\n", - " + [apply_motors, noop]\n", - "\n", - "behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)}\n", - "behavior_name_map['manual'] = len(behavior_bank) - 2\n", - "behavior_name_map['noop'] = len(behavior_bank) - 1\n", - "\n", - "lg.info(behavior_name_map)\n", - "\n", - "# TODO : seems useless and unused\n", - "reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()}\n", - "\n", - "def switch_fn(fn_list):\n", - " def switch(index, *operands):\n", - " return lax.switch(index, fn_list, *operands)\n", - " return switch\n", - "\n", - "multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0))\n", - "\n", - "def sensorimotor(prox, behaviors, motor):\n", - " motor = multi_switch(behaviors, prox, motor)\n", - " return motor\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "\n", - "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", - " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", - " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", - " return fwd, rot\n", - "\n", - "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", - " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", - " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", - " return left, right\n", - "\n", - "def motor_command(wheel_activation, base_length, wheel_diameter):\n", - " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", - " return fwd, rot\n", - "\n", - "motor_command = vmap(motor_command, (0, 0, 0))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define a force function for the environment\n", - "\n", - "Bc we want a world with a realistic physics, we wanna define how forces are going to be applied to our entities (collision and friction) as well as the motor forces for the braitenberg vehicles ... " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def braintenberg_force_fn(displacement):\n", - " coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))\n", - "\n", - " def collision_force(state, neighbor, exists_mask):\n", - " return coll_force_fn(\n", - " state.entities.position.center,\n", - " neighbor=neighbor,\n", - " exists_mask=exists_mask,\n", - " diameter=state.entities.diameter,\n", - " epsilon=state.collision_eps,\n", - " alpha=state.collision_alpha\n", - " )\n", - "\n", - " def motor_force(state, exists_mask):\n", - " agent_idx = state.agents.ent_idx\n", - "\n", - " body = rigid_body.RigidBody(\n", - " center=state.entities.position.center[agent_idx],\n", - " orientation=state.entities.position.orientation[agent_idx]\n", - " )\n", - " \n", - " n = normal(body.orientation)\n", - "\n", - " fwd, rot = motor_command(\n", - " state.agents.motor,\n", - " state.entities.diameter[agent_idx],\n", - " state.agents.wheel_diameter\n", - " )\n", - " # `a_max` arg is deprecated in recent versions of jax, replaced by `max`\n", - " fwd = jnp.clip(fwd, a_max=state.agents.max_speed)\n", - "\n", - " cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]\n", - " cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)\n", - " cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]\n", - " \n", - " fwd_delta = fwd - cur_fwd_vel\n", - " rot_delta = rot - cur_rot_vel\n", - "\n", - " fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T\n", - " rot_force = rot_delta * state.agents.theta_mul\n", - "\n", - " center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)\n", - " orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)\n", - "\n", - " # apply mask to make non existing agents stand still\n", - " orientation = jnp.where(exists_mask, orientation, 0.)\n", - " # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center\n", - " exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)\n", - " center = jnp.where(exists_mask, center, 0.)\n", - "\n", - " return rigid_body.RigidBody(center=center,\n", - " orientation=orientation)\n", - " \n", - "\n", - " def force_fn(state, neighbor, exists_mask):\n", - " mf = motor_force(state, exists_mask)\n", - " cf = collision_force(state, neighbor, exists_mask)\n", - " ff = friction_force(state, exists_mask)\n", - " \n", - " center = cf + ff + mf.center\n", - " orientation = mf.orientation\n", - " return rigid_body.RigidBody(center=center, orientation=orientation)\n", - "\n", - " return force_fn" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define the environment class with all those \n", - "\n", - "Now we have all the necessary elements to create our environment. We will use the classes and functions defined above in our Braitenberg environment ... \n", - "\n", - "Env needs two principal methods (+ tge __init__ to define the charasteristics of the env ... ): \n", - "- init_state: create an initial \n", - "- step\n", - "\n", - "+ functions to handle neighborhood ....\n", - "\n", - "#### TODO : Add the functions to update the spaces ... (I think there were things like that before)\n", - "#### TODO : Should write a render function as well (maybe take inspiration from EvoJax / JaxMALR ...)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "SPACE_NDIMS = 2\n", - "\n", - "class BraitenbergEnv:\n", - " def __init__(\n", - " self,\n", - " box_size=100,\n", - " dt=0.1,\n", - " max_agents=10,\n", - " max_objects=2,\n", - " neighbor_radius=100.,\n", - " collision_alpha=0.5,\n", - " collision_eps=0.1,\n", - " n_dims=2,\n", - " seed=0,\n", - " diameter=5.0,\n", - " friction=0.1,\n", - " mass_center=1.0,\n", - " mass_orientation=0.125,\n", - " existing_agents=10,\n", - " existing_objects=2,\n", - " behavior=behavior_name_map['AGGRESSION'],\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", - " agents_color=jnp.array([0.0, 0.0, 1.0]),\n", - " objects_color=jnp.array([1.0, 0.0, 0.0])\n", - " ):\n", - " \n", - " # TODO : add docstrings\n", - " # general parameters\n", - " self.box_size = box_size\n", - " self.dt = dt\n", - " self.max_agents = max_agents\n", - " self.max_objects = max_objects\n", - " self.neighbor_radius = neighbor_radius\n", - " self.collision_alpha = collision_alpha\n", - " self.collision_eps = collision_eps\n", - " self.n_dims = n_dims\n", - " self.seed = seed\n", - " # entities parameters\n", - " self.diameter = diameter\n", - " self.friction = friction\n", - " self.mass_center = mass_center\n", - " self.mass_orientation = mass_orientation\n", - " self.existing_agents = existing_agents\n", - " self.existing_objects = existing_objects\n", - " # agents parameters\n", - " self.behavior = behavior\n", - " self.wheel_diameter = wheel_diameter\n", - " self.speed_mul = speed_mul\n", - " self.max_speed = max_speed\n", - " self.theta_mul = theta_mul\n", - " self.prox_dist_max = prox_dist_max\n", - " self.prox_cos_min = prox_cos_min\n", - " self.agents_color = agents_color\n", - " # objects parameters\n", - " self.objects_color = objects_color\n", - " # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? \n", - "\n", - "\n", - " # TODO : Split the initialization of entities, agents and objects w different functions ...\n", - " def init_state(self) -> State:\n", - " key = random.PRNGKey(self.seed)\n", - " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", - "\n", - " n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size\n", - " objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value)\n", - " object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents))))\n", - " exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects))))\n", - " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", - " # Entities idx of objects\n", - " start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects \n", - " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", - "\n", - " entity_state = 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)),\n", - " entity_type=entity_types,\n", - " entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))),\n", - " diameter=jnp.full((n_entities), self.diameter),\n", - " friction=jnp.full((n_entities), self.friction),\n", - " exists=exists\n", - " )\n", - "\n", - " agents_state = AgentState(\n", - " # idx in the entities (ent_idx) state to map agents information in the different data structures\n", - " ent_idx=jnp.arange(self.max_agents, dtype=int), \n", - " prox=jnp.zeros((self.max_agents, 2)),\n", - " motor=jnp.zeros((self.max_agents, 2)),\n", - " behavior=jnp.full((self.max_agents), self.behavior),\n", - " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", - " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", - " max_speed=jnp.full((self.max_agents), self.max_speed),\n", - " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", - " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", - " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", - " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", - " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", - " color=jnp.tile(self.agents_color, (self.max_agents, 1))\n", - " )\n", - "\n", - " objects_state = ObjectState(\n", - " ent_idx=objects_ent_idx,\n", - " color=jnp.tile(self.objects_color, (self.max_objects, 1))\n", - " )\n", - "\n", - " lg.info('creating state')\n", - " state = State(\n", - " time=0,\n", - " box_size=self.box_size,\n", - " max_agents=self.max_agents,\n", - " max_objects=self.max_objects,\n", - " neighbor_radius=self.neighbor_radius,\n", - " collision_alpha=self.collision_alpha,\n", - " collision_eps=self.collision_eps,\n", - " dt=self.dt,\n", - " entities=entity_state,\n", - " agents=agents_state,\n", - " objects=objects_state\n", - " ) \n", - "\n", - " # Create jax_md attributes for environment physics\n", - " key, physics_key = random.split(key)\n", - " self.displacement, self.shift = space.periodic(self.box_size)\n", - " init_fn, apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n", - " self.init_fn = init_fn\n", - " self.apply_physics = jit(apply_physics)\n", - " self.neighbor_fn = partition.neighbor_list(\n", - " self.displacement, \n", - " self.box_size,\n", - " r_cutoff=self.neighbor_radius,\n", - " dr_threshold=10.,\n", - " capacity_multiplier=1.5,\n", - " format=partition.Sparse\n", - " )\n", - "\n", - " state = self.init_fn(state, physics_key)\n", - " positions = state.entities.position.center\n", - " lg.info('allocating neighbors')\n", - " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", - " self.neighbors = neighbors\n", - " self.agents_neighs_idx = agents_neighs_idx\n", - "\n", - " return state\n", - " \n", - "\n", - " @partial(jit, static_argnums=(0,))\n", - " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n", - " # 1 : Compute agents proximeter and motor activations\n", - " exists_mask = jnp.where(state.entities.exists == 1, 1, 0)\n", - " # TODO Not rly clean, should maybe only return proximeters, or split the functions \n", - " prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n", - " motor = sensorimotor(prox, state.agents.behavior, state.agents.motor)\n", - "\n", - " agents = state.agents.replace(\n", - " prox=prox, \n", - " proximity_map_dist=proximity_dist_map, \n", - " proximity_map_theta=proximity_dist_theta,\n", - " motor=motor\n", - " )\n", - "\n", - " state = state.replace(agents=agents)\n", - " # 2 : Move the entities by applying physics of the env (collision, friction and motor forces)\n", - " entities = self.apply_physics(state, neighbors)\n", - "\n", - " # 3 : Apply specific consequences in the env (e.g eating an object)\n", - " state = state.replace(\n", - " time=state.time+1,\n", - " entities=entities,\n", - " )\n", - "\n", - " neighbors = neighbors.update(state.entities.position.center)\n", - "\n", - " return state, neighbors\n", - " \n", - "\n", - " def step(self, state: State) -> State:\n", - " current_state = state\n", - " state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx)\n", - "\n", - " if self.neighbors.did_buffer_overflow:\n", - " print(\"overflow\")\n", - " # reallocate neighbors and run the simulation from current_state\n", - " lg.warning('BUFFER OVERFLOW: rebuilding neighbors')\n", - " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", - " self.agents_neighs_idx = agents_neighs_idx\n", - " assert not neighbors.did_buffer_overflow\n", - "\n", - " self.neighbors = neighbors\n", - " return state\n", - "\n", - " def allocate_neighbors(self, state, position=None):\n", - " position = state.entities.position.center if position is None else position\n", - " neighbors = self.neighbor_fn.allocate(position)\n", - " mask = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", - " agents_neighs_idx = neighbors.idx[:, mask]\n", - " return neighbors, agents_neighs_idx" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initiate a state from the environment and render it" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'time': 0,\n", - " 'box_size': 100,\n", - " 'max_agents': 10,\n", - " 'max_objects': 2,\n", - " 'neighbor_radius': 100.0,\n", - " 'dt': 0.1,\n", - " 'collision_alpha': 0.5,\n", - " 'collision_eps': 0.1,\n", - " 'entities': {'position': RigidBody(center=Array([[ 3.7252188, 9.242689 ],\n", - " [ 4.939151 , 86.78386 ],\n", - " [93.74271 , 71.651375 ],\n", - " [89.61038 , 64.47968 ],\n", - " [51.115047 , 85.136246 ],\n", - " [34.26517 , 60.67195 ],\n", - " [58.65188 , 57.67032 ],\n", - " [92.67553 , 1.0239005],\n", - " [94.60478 , 54.836296 ],\n", - " [57.998978 , 75.63805 ],\n", - " [31.563496 , 91.39798 ],\n", - " [77.80601 , 22.647142 ]], dtype=float32), orientation=Array([5.8640995 , 3.5555892 , 3.3702946 , 2.5002196 , 6.139788 ,\n", - " 4.0296173 , 4.711335 , 3.085717 , 2.2339876 , 0.6937443 ,\n", - " 2.0312393 , 0.29639685], dtype=float32)),\n", - " 'momentum': RigidBody(center=Array([[ 0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., 0.],\n", - " [-0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., -0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [-0., 0.],\n", - " [-0., -0.]], dtype=float32), orientation=Array([-0., 0., 0., 0., -0., -0., 0., -0., 0., -0., -0., 0.], dtype=float32)),\n", - " 'force': RigidBody(center=Array([[0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.]], dtype=float32), orientation=Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'mass': RigidBody(center=Array([[1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.]], dtype=float32, weak_type=True), orientation=Array([0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125], dtype=float32, weak_type=True)),\n", - " 'entity_type': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], dtype=int32),\n", - " 'entity_idx': Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1], dtype=int32),\n", - " 'diameter': Array([5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.], dtype=float32, weak_type=True),\n", - " 'friction': Array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], dtype=float32, weak_type=True),\n", - " 'exists': Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)},\n", - " 'agents': {'ent_idx': Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),\n", - " 'prox': Array([[0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.]], dtype=float32),\n", - " 'motor': Array([[0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.]], dtype=float32),\n", - " 'proximity_map_dist': Array([[0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.]], dtype=float32),\n", - " 'proximity_map_theta': Array([[0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.]], dtype=float32),\n", - " 'behavior': Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32, weak_type=True),\n", - " 'wheel_diameter': Array([2., 2., 2., 2., 2., 2., 2., 2., 2., 2.], dtype=float32, weak_type=True),\n", - " 'speed_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", - " 'max_speed': Array([10., 10., 10., 10., 10., 10., 10., 10., 10., 10.], dtype=float32, weak_type=True),\n", - " 'theta_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", - " 'proxs_dist_max': Array([40., 40., 40., 40., 40., 40., 40., 40., 40., 40.], dtype=float32, weak_type=True),\n", - " 'proxs_cos_min': Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32, weak_type=True),\n", - " 'color': Array([[0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.]], dtype=float32)},\n", - " 'objects': {'ent_idx': Array([10, 11], dtype=int32),\n", - " 'color': Array([[1., 0., 0.],\n", - " [1., 0., 0.]], dtype=float32)}}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "env = BraitenbergEnv() \n", - "state = env.init_state() \n", - "\n", - "dict_state = flax.serialization.to_state_dict(state)\n", - "dict_state " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "render(state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run a simulation and visualize it " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulation ran in 1.9971963759999198 for 5000 timesteps\n" - ] - } - ], - "source": [ - "n_steps = 5_000\n", - "\n", - "hist = []\n", - "\n", - "start = time.perf_counter()\n", - "for i in range(n_steps):\n", - " state = env.step(state) \n", - " hist.append(state)\n", - "end = time.perf_counter()\n", - "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "render_history(hist, skip_frames=10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Scale the size of the simulation\n", - "\n", - "Increase the box_size, n_agents and objects ... \n", - "\n", - "#### TODO : Check the rendering functions bc here agents are way too big (but matplotlib scatter area mechanism kinda sucks)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:BUFFER OVERFLOW: rebuilding neighbors\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "overflow\n", - "Simulation ran in 5.380792976000521 for 5000 timesteps\n" - ] - } - ], - "source": [ - "env = BraitenbergEnv(box_size=500,\n", - " max_agents=100,\n", - " max_objects=20,\n", - " existing_agents=90,\n", - " existing_objects=20,\n", - " prox_dist_max=100) \n", - " \n", - "state = env.init_state() \n", - "\n", - "n_steps = 5_000\n", - "\n", - "hist = []\n", - "\n", - "start = time.perf_counter()\n", - "for i in range(n_steps):\n", - " state = env.step(state) \n", - " hist.append(state)\n", - "end = time.perf_counter()\n", - "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulation ran in 3.337236932999076 for 5000 timesteps\n" - ] - } - ], - "source": [ - "env = BraitenbergEnv(box_size=500,\n", - " max_agents=100,\n", - " max_objects=20,\n", - " existing_agents=90,\n", - " existing_objects=20,\n", - " prox_dist_max=10) \n", - "\n", - "state = env.init_state() \n", - "\n", - "n_steps = 5_000\n", - "\n", - "start = time.perf_counter()\n", - "for i in range(n_steps):\n", - " state = env.step(state) \n", - "end = time.perf_counter()\n", - "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Cool because neighbors rebuilding seems to work well but the recompilation time seems big (see other running time w agent with a low proximeter range (i.e they don't move and thus neighbor arrays are not computed again))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "render_history(hist, skip_frames=10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fun patterns observed with a larger simulation and aggressive agents ! (care because the size of the agents isn't at scale so it is why it can look like they don't collide sometimes)" - ] - } - ], - "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 -} diff --git a/notebooks/prey_predator_braitenberg.ipynb b/notebooks/prey_predator_braitenberg.ipynb deleted file mode 100644 index e524630..0000000 --- a/notebooks/prey_predator_braitenberg.ipynb +++ /dev/null @@ -1,1397 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Braitenberg environment notebook\n", - "\n", - "Use this notebook to showcase how to create an environment in vivarium ... w a realistic physics ... " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" - ] - } - ], - "source": [ - "import time\n", - "import logging as lg\n", - "from enum import Enum\n", - "from functools import partial\n", - "from typing import Tuple\n", - "\n", - "import jax\n", - "import flax\n", - "import jax_md\n", - "import jax.numpy as jnp\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 space, rigid_body, partition, simulate, quantity\n", - "\n", - "from vivarium.utils import normal, render, render_history\n", - "from vivarium.simulator.general_physics_engine import total_collision_energy, friction_force, dynamics_fn" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create classes for the environment\n", - "\n", - "We use flax dataclasses to store all the information about our environment state (positions of all entities ..., features of agents and objects ...)\n", - "\n", - "We add elements about agents types (prey / predator ...)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "class EntityType(Enum):\n", - " AGENT = 0\n", - " OBJECT = 1\n", - "\n", - "class AgentType(Enum):\n", - " PREY = 0\n", - " PREDATOR = 1\n", - "\n", - "predator_color = jnp.array([1., 0., 0.])\n", - "prey_color = jnp.array([0., 0., 1.])\n", - "object_color = jnp.array([0., 1., 0.])\n", - "\n", - "# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState)\n", - "@struct.dataclass\n", - "class EntityState(simulate.NVEState):\n", - " entity_type: jnp.array\n", - " entity_idx: jnp.array\n", - " diameter: jnp.array\n", - " friction: jnp.array\n", - " exists: jnp.array\n", - "\n", - " @property\n", - " def velocity(self) -> jnp.array:\n", - " return self.momentum / self.mass\n", - " \n", - "@struct.dataclass\n", - "class AgentState:\n", - " ent_idx: jnp.array\n", - " agent_type: jnp.array\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", - " 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", - " color: jnp.array\n", - "\n", - "@struct.dataclass\n", - "class ObjectState:\n", - " ent_idx: jnp.array \n", - " color: jnp.array\n", - "\n", - "# TODO : Add obs field like in JaxMARL -> compute agents actions w a vmap on obs\n", - "@struct.dataclass\n", - "class State:\n", - " time: jnp.int32\n", - " box_size: jnp.int32\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", - " entities: EntityState\n", - " agents: AgentState\n", - " objects: ObjectState" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define helper functions to compute the proximeters of agents\n", - "\n", - "Bc we use braitenberg vehicles ... need to compute values of proximeters for them to detect their environment ... " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "### 2 Define functions that will be used in the step fn of the env ###\n", - "\n", - "def relative_position(displ, theta):\n", - " \"\"\"\n", - " Compute the relative distance and angle from a source agent to a target agent\n", - " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", - " :param theta: Orientation of the source agent (in the reference frame of the map)\n", - " :return: dist: distance from source to target.\n", - " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", - " \"\"\"\n", - " dist = jnp.linalg.norm(displ)\n", - " norm_displ = displ / dist\n", - " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", - " relative_theta = theta_displ - theta\n", - " return dist, relative_theta\n", - "\n", - "proximity_map = vmap(relative_position, (0, 0))\n", - "\n", - "# TODO : SHould redo all these functions with the prox computation because very hard to understand without vmap etcc\n", - "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", - " \"\"\"\n", - " Compute the proximeter activations (left, right) induced by the presence of an entity\n", - " :param dist: distance from the agent to the entity\n", - " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", - " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", - " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", - " :return: left and right proximeter activation in a jnp array with shape (2,)\n", - " \"\"\"\n", - " cos_dir = jnp.cos(relative_theta)\n", - " prox = 1. - (dist / dist_max)\n", - " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", - " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", - " left = in_view * at_left * prox\n", - " right = in_view * (1. - at_left) * prox\n", - " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", - "\n", - "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", - "\n", - "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", - " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", - " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", - " proxs = ops.segment_max(\n", - " raw_proxs,\n", - " senders, \n", - " max_agents)\n", - " \n", - " return proxs\n", - "\n", - "# TODO : I think we should refactor this part of the code with a function using vmap\n", - "def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):\n", - " \"\"\"\n", - " Set agents' proximeter activations\n", - " :param state: full simulation State\n", - " :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),\n", - " where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.\n", - " :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).\n", - " target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).\n", - " :return:\n", - " \"\"\"\n", - " body = state.entities.position\n", - " mask = target_exists_mask[agents_neighs_idx[1, :]] \n", - " senders, receivers = agents_neighs_idx\n", - " Ra = body.center[senders]\n", - " Rb = body.center[receivers]\n", - " dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", - "\n", - " # Create distance and angle maps between entities\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", - "\n", - " # TODO : refactor this function because a lot of redundancies in the arguments (state.agents)\n", - " prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],\n", - " state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)\n", - " \n", - " return prox, proximity_map_dist, proximity_map_theta" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create helper functions to compute motor activations of agents\n", - "\n", - "Now that we know how to compute proximters values, we want our agents to act accordingly to them ... see how to map sensors values to motor activations (e.g w behaviors of attraction / repulsion towards some objects, agents ...)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO : Refactor the following part\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY'])\n", - "\n", - "linear_behavior_matrices = {\n", - " linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]),\n", - " linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]),\n", - " linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]),\n", - " linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]),\n", - "}\n", - "\n", - "def linear_behavior(proxs, motors, matrix):\n", - " return matrix.dot(jnp.hstack((proxs, 1.)))\n", - "\n", - "def apply_motors(proxs, motors):\n", - " return motors\n", - "\n", - "def noop(proxs, motors):\n", - " return jnp.array([0., 0.])\n", - "\n", - "behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh])\n", - " for beh in linear_behavior_enum] \\\n", - " + [apply_motors, noop]\n", - "\n", - "behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)}\n", - "behavior_name_map['manual'] = len(behavior_bank) - 2\n", - "behavior_name_map['noop'] = len(behavior_bank) - 1\n", - "\n", - "lg.info(behavior_name_map)\n", - "\n", - "# TODO : seems useless and unused\n", - "reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()}\n", - "\n", - "def switch_fn(fn_list):\n", - " def switch(index, *operands):\n", - " return lax.switch(index, fn_list, *operands)\n", - " return switch\n", - "\n", - "multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0))\n", - "\n", - "def sensorimotor(prox, behaviors, motor):\n", - " motor = multi_switch(behaviors, prox, motor)\n", - " return motor\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n", - "\n", - "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", - " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", - " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", - " return fwd, rot\n", - "\n", - "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", - " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", - " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", - " return left, right\n", - "\n", - "def motor_command(wheel_activation, base_length, wheel_diameter):\n", - " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", - " return fwd, rot\n", - "\n", - "motor_command = vmap(motor_command, (0, 0, 0))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define a force function for the environment\n", - "\n", - "Bc we want a world with a realistic physics, we wanna define how forces are going to be applied to our entities (collision and friction) as well as the motor forces for the braitenberg vehicles ... " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def braintenberg_force_fn(displacement):\n", - " coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))\n", - "\n", - " def collision_force(state, neighbor, exists_mask):\n", - " return coll_force_fn(\n", - " state.entities.position.center,\n", - " neighbor=neighbor,\n", - " exists_mask=exists_mask,\n", - " diameter=state.entities.diameter,\n", - " epsilon=state.collision_eps,\n", - " alpha=state.collision_alpha\n", - " )\n", - "\n", - " def motor_force(state, exists_mask):\n", - " agent_idx = state.agents.ent_idx\n", - "\n", - " body = rigid_body.RigidBody(\n", - " center=state.entities.position.center[agent_idx],\n", - " orientation=state.entities.position.orientation[agent_idx]\n", - " )\n", - " \n", - " n = normal(body.orientation)\n", - "\n", - " fwd, rot = motor_command(\n", - " state.agents.motor,\n", - " state.entities.diameter[agent_idx],\n", - " state.agents.wheel_diameter\n", - " )\n", - " # `a_max` arg is deprecated in recent versions of jax, replaced by `max`\n", - " fwd = jnp.clip(fwd, a_max=state.agents.max_speed)\n", - "\n", - " cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]\n", - " cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)\n", - " cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]\n", - " \n", - " fwd_delta = fwd - cur_fwd_vel\n", - " rot_delta = rot - cur_rot_vel\n", - "\n", - " fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T\n", - " rot_force = rot_delta * state.agents.theta_mul\n", - "\n", - " center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)\n", - " orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)\n", - "\n", - " # apply mask to make non existing agents stand still\n", - " orientation = jnp.where(exists_mask, orientation, 0.)\n", - " # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center\n", - " exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)\n", - " center = jnp.where(exists_mask, center, 0.)\n", - "\n", - " return rigid_body.RigidBody(center=center,\n", - " orientation=orientation)\n", - " \n", - "\n", - " def force_fn(state, neighbor, exists_mask):\n", - " mf = motor_force(state, exists_mask)\n", - " cf = collision_force(state, neighbor, exists_mask)\n", - " ff = friction_force(state, exists_mask)\n", - " \n", - " center = cf + ff + mf.center\n", - " orientation = mf.orientation\n", - " return rigid_body.RigidBody(center=center, orientation=orientation)\n", - "\n", - " return force_fn" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define the environment class with all those \n", - "\n", - "Now we have all the necessary elements to create our environment. We will use the classes and functions defined above in our Braitenberg environment ... \n", - "\n", - "Env needs two principal methods (+ tge __init__ to define the charasteristics of the env ... ): \n", - "- init_state: create an initial \n", - "- step\n", - "\n", - "+ functions to handle neighborhood ....\n", - "\n", - "#### TODO : Add the functions to update the spaces ... (I think there were things like that before)\n", - "#### TODO : Should write a render function as well (maybe take inspiration from EvoJax / JaxMALR ...)\n", - "\n", - "\n", - "Added in the _step function a part to make predator agents eat prey agents if they come too close" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "SPACE_NDIMS = 2\n", - "\n", - "class BraitenbergEnv:\n", - " def __init__(\n", - " self,\n", - " box_size=200,\n", - " dt=0.1,\n", - " max_agents=50,\n", - " max_objects=10,\n", - " neighbor_radius=100.,\n", - " collision_alpha=0.5,\n", - " collision_eps=0.1,\n", - " n_dims=2,\n", - " seed=0,\n", - " diameter=5.0,\n", - " friction=0.1,\n", - " mass_center=1.0,\n", - " mass_orientation=0.125,\n", - " existing_agents=50,\n", - " n_preys=25,\n", - " n_predators=25,\n", - " pred_eating_range=15,\n", - " existing_objects=0,\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", - " prey_color=jnp.array([0.0, 0.0, 1.0]),\n", - " predator_color=jnp.array([1.0, 0.0, 0.0]),\n", - " objects_color=jnp.array([0.0, 1.0, 0.0])\n", - " ):\n", - " \n", - " # TODO : add docstrings\n", - " # general parameters\n", - " self.box_size = box_size\n", - " self.dt = dt\n", - " self.max_agents = max_agents\n", - " self.max_objects = max_objects\n", - " self.neighbor_radius = neighbor_radius\n", - " self.collision_alpha = collision_alpha\n", - " self.collision_eps = collision_eps\n", - " self.n_dims = n_dims\n", - " self.seed = seed\n", - " # entities parameters\n", - " self.diameter = diameter\n", - " self.friction = friction\n", - " self.mass_center = mass_center\n", - " self.mass_orientation = mass_orientation\n", - " self.existing_agents = existing_agents\n", - " self.existing_objects = existing_objects\n", - " # agents parameters\n", - " self.n_preys = n_preys\n", - " self.n_predators = n_predators\n", - " self.wheel_diameter = wheel_diameter\n", - " self.speed_mul = speed_mul\n", - " self.max_speed = max_speed\n", - " self.theta_mul = theta_mul\n", - " self.prox_dist_max = prox_dist_max\n", - " self.prox_cos_min = prox_cos_min\n", - " self.prey_color = prey_color\n", - " self.predator_color = predator_color\n", - " self.pred_eating_range = pred_eating_range\n", - " # objects parameters\n", - " self.objects_color = objects_color\n", - " # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? \n", - "\n", - "\n", - " # TODO : Split the initialization of entities, agents and objects w different functions ...\n", - " def init_state(self) -> State:\n", - " key = random.PRNGKey(self.seed)\n", - " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", - "\n", - " n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size\n", - " objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value)\n", - " object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents))))\n", - " exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects))))\n", - " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", - " # Entities idx of objects\n", - " start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects \n", - " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", - "\n", - " entity_state = 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)),\n", - " entity_type=entity_types,\n", - " entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))),\n", - " diameter=jnp.full((n_entities), self.diameter),\n", - " friction=jnp.full((n_entities), self.friction),\n", - " exists=exists\n", - " )\n", - "\n", - " # Added agent types for prey and predators\n", - " agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value)))\n", - " agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0)\n", - " behaviors = jnp.hstack((jnp.full(self.n_preys, behavior_name_map['FEAR']), jnp.full(self.n_predators, behavior_name_map['AGGRESSION'])))\n", - "\n", - " agents_state = AgentState(\n", - " # idx in the entities (ent_idx) state to map agents information in the different data structures\n", - " ent_idx=jnp.arange(self.max_agents, dtype=int),\n", - " agent_type=agent_types, \n", - " prox=jnp.zeros((self.max_agents, 2)),\n", - " motor=jnp.zeros((self.max_agents, 2)),\n", - " behavior=behaviors,\n", - " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", - " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", - " max_speed=jnp.full((self.max_agents), self.max_speed),\n", - " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", - " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", - " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", - " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", - " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", - " color=agents_colors\n", - " )\n", - "\n", - " objects_state = ObjectState(\n", - " ent_idx=objects_ent_idx,\n", - " color=jnp.tile(self.objects_color, (self.max_objects, 1))\n", - " )\n", - "\n", - " lg.info('creating state')\n", - " state = State(\n", - " time=0,\n", - " box_size=self.box_size,\n", - " max_agents=self.max_agents,\n", - " max_objects=self.max_objects,\n", - " neighbor_radius=self.neighbor_radius,\n", - " collision_alpha=self.collision_alpha,\n", - " collision_eps=self.collision_eps,\n", - " dt=self.dt,\n", - " entities=entity_state,\n", - " agents=agents_state,\n", - " objects=objects_state\n", - " ) \n", - "\n", - " # Create jax_md attributes for environment physics\n", - " key, physics_key = random.split(key)\n", - " self.displacement, self.shift = space.periodic(self.box_size)\n", - " init_fn, apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n", - " self.init_fn = init_fn\n", - " self.apply_physics = jit(apply_physics)\n", - " self.neighbor_fn = partition.neighbor_list(\n", - " self.displacement, \n", - " self.box_size,\n", - " r_cutoff=self.neighbor_radius,\n", - " dr_threshold=10.,\n", - " capacity_multiplier=1.5,\n", - " format=partition.Sparse\n", - " )\n", - "\n", - " state = self.init_fn(state, physics_key)\n", - " positions = state.entities.position.center\n", - " lg.info('allocating neighbors')\n", - " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", - " self.neighbors = neighbors\n", - " self.agents_neighs_idx = agents_neighs_idx\n", - "\n", - " self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n", - " self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n", - " self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n", - "\n", - " return state\n", - " \n", - "\n", - " @partial(jit, static_argnums=(0,))\n", - " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n", - " # 1 : Compute agents proximeter and motor activations\n", - " exists_mask = jnp.where(state.entities.exists == 1, 1, 0)\n", - " # TODO Not rly clean, should maybe only return proximeters, or split the functions \n", - " prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n", - " motor = sensorimotor(prox, state.agents.behavior, state.agents.motor)\n", - "\n", - " agents = state.agents.replace(\n", - " prox=prox, \n", - " proximity_map_dist=proximity_dist_map, \n", - " proximity_map_theta=proximity_dist_theta,\n", - " motor=motor\n", - " )\n", - "\n", - " state = state.replace(agents=agents)\n", - " # 2 : Move the entities by applying physics of the env (collision, friction and motor forces)\n", - " entities = self.apply_physics(state, neighbors)\n", - "\n", - " # 3 : Apply specific consequences in the env (e.g predators eat preys here)\n", - " state = state.replace(\n", - " time=state.time+1,\n", - " entities=entities,\n", - " )\n", - "\n", - " # TODO : Improve the name of the functions and see how to integrate neighborhoods in fns\n", - " R = state.entities.position.center\n", - " exist = state.entities.exists\n", - " prey_idx = self.prey_idx\n", - " pred_idx = self.pred_idx\n", - "\n", - " agents_ent_idx = state.agents.ent_idx\n", - " predator_exist = exist[agents_ent_idx][pred_idx]\n", - "\n", - " def distance(point1, point2, displ):\n", - " diff = displ(point1, point2)\n", - " squared_diff = jnp.sum(jnp.square(diff))\n", - " return jnp.sqrt(squared_diff)\n", - "\n", - " # Could maybe create this as a method in the class, or above idk\n", - " distance = partial(distance, displ=self.displacement)\n", - " distance_to_all_preds = jit(vmap(distance, in_axes=(None, 0)))\n", - "\n", - " # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above \n", - " def can_be_eaten(R_prey, R_predators, predator_exist):\n", - " dist_to_preds = distance_to_all_preds(R_prey, R_predators)\n", - " in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0)\n", - " # Could also return which agent ate the other one (e.g to increase their energy) \n", - " will_be_eaten_by = in_range * predator_exist\n", - " eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0)\n", - "\n", - " return eaten_or_not\n", - "\n", - " can_all_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None))\n", - "\n", - " # See which preys can be eaten by predators and update the exists array accordingly\n", - " can_be_eaten_idx = can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist)\n", - " exist_prey = exist[agents_ent_idx[prey_idx]]\n", - " new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey)\n", - " exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey)\n", - "\n", - " # Update the state\n", - " entities = state.entities.replace(exists=exist)\n", - " state = state.replace(entities=entities)\n", - "\n", - " # Compute the new neighbors\n", - " neighbors = neighbors.update(state.entities.position.center)\n", - "\n", - " return state, neighbors\n", - " \n", - "\n", - " def step(self, state: State) -> State:\n", - " current_state = state\n", - " state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx)\n", - "\n", - " if self.neighbors.did_buffer_overflow:\n", - " print(\"overflow\")\n", - " # reallocate neighbors and run the simulation from current_state\n", - " lg.warning('BUFFER OVERFLOW: rebuilding neighbors')\n", - " neighbors, agents_neighs_idx = self.allocate_neighbors(state)\n", - " self.agents_neighs_idx = agents_neighs_idx\n", - " assert not neighbors.did_buffer_overflow\n", - "\n", - " self.neighbors = neighbors\n", - " return state\n", - "\n", - " def allocate_neighbors(self, state, position=None):\n", - " position = state.entities.position.center if position is None else position\n", - " neighbors = self.neighbor_fn.allocate(position)\n", - " mask = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", - " agents_neighs_idx = neighbors.idx[:, mask]\n", - " return neighbors, agents_neighs_idx" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initiate a state from the environment and render it" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'time': 0,\n", - " 'box_size': 200,\n", - " 'max_agents': 50,\n", - " 'max_objects': 10,\n", - " 'neighbor_radius': 100.0,\n", - " 'dt': 0.1,\n", - " 'collision_alpha': 0.5,\n", - " 'collision_eps': 0.1,\n", - " 'entities': {'position': RigidBody(center=Array([[ 38.128494 , 10.72216 ],\n", - " [188.62827 , 15.473008 ],\n", - " [137.63512 , 139.9108 ],\n", - " [ 12.2510195, 109.30286 ],\n", - " [111.62963 , 169.92522 ],\n", - " [ 59.689022 , 141.29376 ],\n", - " [184.63835 , 188.77783 ],\n", - " [ 86.62457 , 188.40268 ],\n", - " [102.70498 , 121.01295 ],\n", - " [ 97.27762 , 118.294 ],\n", - " [ 95.37985 , 145.33739 ],\n", - " [197.64905 , 197.61378 ],\n", - " [182.52403 , 125.79477 ],\n", - " [133.30867 , 107.42421 ],\n", - " [119.64154 , 153.33914 ],\n", - " [ 62.279438 , 53.706192 ],\n", - " [148.1706 , 111.157845 ],\n", - " [139.92258 , 130.43387 ],\n", - " [122.68515 , 76.240585 ],\n", - " [ 80.25191 , 182.03455 ],\n", - " [ 48.71185 , 196.26427 ],\n", - " [ 13.737249 , 79.90112 ],\n", - " [ 14.034843 , 102.85857 ],\n", - " [ 25.438738 , 136.74767 ],\n", - " [107.97717 , 95.58396 ],\n", - " [ 54.119514 , 105.528595 ],\n", - " [ 36.534023 , 116.46688 ],\n", - " [138.342 , 185.01718 ],\n", - " [100.57411 , 132.57613 ],\n", - " [153.72917 , 75.5013 ],\n", - " [ 32.760715 , 4.9206734],\n", - " [181.20894 , 27.841686 ],\n", - " [ 81.363174 , 109.49633 ],\n", - " [134.48424 , 177.27881 ],\n", - " [174.30241 , 134.59552 ],\n", - " [ 7.496667 , 189.53946 ],\n", - " [ 28.946949 , 183.13513 ],\n", - " [190.89255 , 78.80938 ],\n", - " [131.64198 , 152.88654 ],\n", - " [109.41062 , 174.99223 ],\n", - " [126.72467 , 198.56648 ],\n", - " [134.22041 , 163.78674 ],\n", - " [179.58687 , 84.63037 ],\n", - " [199.02728 , 190.06226 ],\n", - " [ 36.093403 , 170.46954 ],\n", - " [130.75116 , 22.477745 ],\n", - " [146.79582 , 53.330017 ],\n", - " [198.88518 , 66.81149 ],\n", - " [116.24823 , 103.07367 ],\n", - " [141.93188 , 127.34044 ],\n", - " [ 97.97359 , 42.79132 ],\n", - " [175.16243 , 140.7605 ],\n", - " [102.140686 , 147.21289 ],\n", - " [ 47.92311 , 188.1773 ],\n", - " [ 8.467627 , 120.6624 ],\n", - " [140.87296 , 115.579605 ],\n", - " [182.76451 , 188.26413 ],\n", - " [ 73.043945 , 126.24099 ],\n", - " [158.9183 , 141.14896 ],\n", - " [ 46.763206 , 160.65369 ]], dtype=float32), orientation=Array([2.1340947 , 4.698772 , 5.9882007 , 0.47786725, 5.809877 ,\n", - " 2.3037682 , 3.335812 , 5.9231067 , 5.081875 , 5.660715 ,\n", - " 0.04470266, 6.2243633 , 6.282406 , 5.7481685 , 6.0861025 ,\n", - " 0.17691487, 3.184819 , 2.2409737 , 4.6186943 , 3.1103423 ,\n", - " 3.330661 , 5.318963 , 1.6345007 , 3.04697 , 3.710415 ,\n", - " 2.7937512 , 1.1411581 , 1.3474666 , 4.740075 , 6.123318 ,\n", - " 2.7340894 , 0.6933593 , 0.01654497, 1.8102928 , 3.7663627 ,\n", - " 5.801127 , 4.98985 , 1.0743866 , 1.1902215 , 2.3457549 ,\n", - " 3.6510615 , 1.2870609 , 5.917576 , 0.29385844, 3.179579 ,\n", - " 1.0541174 , 3.7426205 , 4.5608673 , 2.2428179 , 2.666849 ,\n", - " 4.398739 , 1.6034698 , 0.07834687, 0.2900205 , 3.638261 ,\n", - " 4.461154 , 3.6862442 , 0.9001913 , 4.320826 , 4.5112166 ], dtype=float32)),\n", - " 'momentum': RigidBody(center=Array([[ 0., 0.],\n", - " [-0., -0.],\n", - " [ 0., -0.],\n", - " [-0., -0.],\n", - " [-0., 0.],\n", - " [-0., -0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [ 0., -0.],\n", - " [-0., -0.],\n", - " [-0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., -0.],\n", - " [-0., -0.],\n", - " [-0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., 0.],\n", - " [-0., 0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [ 0., 0.],\n", - " [-0., -0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [-0., 0.],\n", - " [ 0., 0.],\n", - " [ 0., -0.],\n", - " [-0., 0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [ 0., 0.],\n", - " [-0., 0.],\n", - " [-0., 0.],\n", - " [ 0., 0.],\n", - " [-0., 0.],\n", - " [-0., 0.],\n", - " [ 0., 0.],\n", - " [ 0., 0.],\n", - " [-0., 0.],\n", - " [-0., -0.],\n", - " [-0., 0.],\n", - " [-0., 0.],\n", - " [-0., -0.],\n", - " [ 0., 0.],\n", - " [-0., 0.],\n", - " [ 0., 0.],\n", - " [-0., -0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [ 0., 0.],\n", - " [ 0., 0.],\n", - " [-0., 0.],\n", - " [ 0., -0.],\n", - " [ 0., -0.],\n", - " [ 0., 0.],\n", - " [ 0., -0.],\n", - " [-0., 0.],\n", - " [-0., -0.]], dtype=float32), orientation=Array([-0., 0., 0., -0., 0., 0., -0., -0., -0., 0., -0., 0., 0.,\n", - " 0., -0., 0., 0., 0., 0., -0., 0., 0., -0., -0., -0., -0.,\n", - " 0., -0., -0., 0., 0., -0., 0., 0., -0., -0., -0., 0., 0.,\n", - " 0., -0., 0., -0., -0., 0., 0., -0., 0., 0., 0., 0., 0.,\n", - " -0., -0., 0., 0., -0., 0., 0., 0.], dtype=float32)),\n", - " 'force': RigidBody(center=Array([[0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.]], dtype=float32), orientation=Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'mass': RigidBody(center=Array([[1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.],\n", - " [1.]], dtype=float32, weak_type=True), orientation=Array([0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125,\n", - " 0.125, 0.125, 0.125, 0.125, 0.125, 0.125], dtype=float32, weak_type=True)),\n", - " 'entity_type': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32),\n", - " 'entity_idx': Array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", - " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 0,\n", - " 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),\n", - " 'diameter': Array([5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5.], dtype=float32, weak_type=True),\n", - " 'friction': Array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", - " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", - " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", - " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,\n", - " 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1], dtype=float32, weak_type=True),\n", - " 'exists': Array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32)},\n", - " 'agents': {'ent_idx': Array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", - " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49], dtype=int32),\n", - " 'agent_type': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1], dtype=int32, weak_type=True),\n", - " 'prox': Array([[0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.]], dtype=float32),\n", - " 'motor': Array([[0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.]], dtype=float32),\n", - " 'proximity_map_dist': Array([[0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.]], dtype=float32),\n", - " 'proximity_map_theta': Array([[0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [0.]], dtype=float32),\n", - " 'behavior': Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1], dtype=int32, weak_type=True),\n", - " 'wheel_diameter': Array([2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,\n", - " 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,\n", - " 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.], dtype=float32, weak_type=True),\n", - " 'speed_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", - " 'max_speed': Array([10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.,\n", - " 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.,\n", - " 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.,\n", - " 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.], dtype=float32, weak_type=True),\n", - " 'theta_mul': Array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32, weak_type=True),\n", - " 'proxs_dist_max': Array([40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.,\n", - " 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.,\n", - " 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.,\n", - " 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40.], dtype=float32, weak_type=True),\n", - " 'proxs_cos_min': Array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", - " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32, weak_type=True),\n", - " 'color': Array([[0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [0., 0., 1.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.],\n", - " [1., 0., 0.]], dtype=float32)},\n", - " 'objects': {'ent_idx': Array([50, 51, 52, 53, 54, 55, 56, 57, 58, 59], dtype=int32),\n", - " 'color': Array([[0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.],\n", - " [0., 1., 0.]], dtype=float32)}}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "env = BraitenbergEnv(pred_eating_range=5) \n", - "state = env.init_state() \n", - "\n", - "dict_state = flax.serialization.to_state_dict(state)\n", - "dict_state " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "render(state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run a simulation and visualize it " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulation ran in 2.0204294820032374 for 1000 timesteps\n" - ] - } - ], - "source": [ - "n_steps = 1000\n", - "\n", - "hist = []\n", - "\n", - "start = time.perf_counter()\n", - "for i in range(n_steps):\n", - " state = env.step(state) \n", - " hist.append(state)\n", - "end = time.perf_counter()\n", - "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "render_history(hist, skip_frames=5)" - ] - } - ], - "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 -} diff --git a/notebooks/refactored_braitenberg_env.py b/notebooks/refactored_braitenberg_env.py deleted file mode 100644 index b02c197..0000000 --- a/notebooks/refactored_braitenberg_env.py +++ /dev/null @@ -1,523 +0,0 @@ -import time -import logging as lg -from enum import Enum -from functools import partial -from typing import Tuple - -import jax -import jax.numpy as jnp - -from jax import vmap, jit -from jax import random, ops, lax - -from flax import struct -from jax_md.rigid_body import RigidBody -from jax_md import space, rigid_body, partition, simulate, quantity - -from vivarium.utils import normal, render, render_history -from vivarium.simulator.general_physics_engine import total_collision_energy, friction_force, dynamics_fn -# TODO : Later use this line to directly import the braitenberg physics (collisions + motors ...) - - -SPACE_NDIMS = 2 - -### 1 Define dataclasses for our state ### - -class EntityType(Enum): - AGENT = 0 - OBJECT = 1 - - -# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState) -@struct.dataclass -class EntityState(simulate.NVEState): - entity_type: jnp.array - entity_idx: jnp.array - diameter: jnp.array - friction: jnp.array - exists: jnp.array - - @property - def velocity(self) -> jnp.array: - return self.momentum / self.mass - -@struct.dataclass -class AgentState: - ent_idx: jnp.array - prox: jnp.array - motor: jnp.array - proximity_map_dist: jnp.array - proximity_map_theta: jnp.array - behavior: 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 - color: jnp.array - -@struct.dataclass -class ObjectState: - ent_idx: jnp.array - color: jnp.array - -# TODO : Add obs field like in JaxMARL -> compute agents actions w a vmap on obs -@struct.dataclass -class State: - time: jnp.int32 - box_size: jnp.int32 - 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 - entities: EntityState - agents: AgentState - objects: ObjectState - - -### 2 Define functions that will be used in the step fn of the env ### - -def relative_position(displ, theta): - """ - Compute the relative distance and angle from a source agent to a target agent - :param displ: Displacement vector (jnp arrray with shape (2,) from source to target - :param theta: Orientation of the source agent (in the reference frame of the map) - :return: dist: distance from source to target. - relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) - """ - dist = jnp.linalg.norm(displ) - norm_displ = displ / dist - theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) - relative_theta = theta_displ - theta - return dist, relative_theta - -proximity_map = vmap(relative_position, (0, 0)) - -# TODO : SHould redo all these functions with the prox computation because very hard to understand without vmap etcc -def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): - """ - Compute the proximeter activations (left, right) induced by the presence of an entity - :param dist: distance from the agent to the entity - :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) - :param dist_max: Max distance of the proximiter (will return 0. above this distance) - :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) - :return: left and right proximeter activation in a jnp array with shape (2,) - """ - cos_dir = jnp.cos(relative_theta) - prox = 1. - (dist / dist_max) - in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) - at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) - left = in_view * at_left * prox - right = in_view * (1. - at_left) * prox - return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist - -sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) - -def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): - raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) - # Computes the maximum within the proximeter activations of agents on all their neigbhors. - proxs = ops.segment_max( - raw_proxs, - senders, - max_agents) - - return proxs - -# TODO : I think we should refactor this part of the code with a function using vmap -def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): - """ - Set agents' proximeter activations - :param state: full simulation State - :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), - where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. - :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). - target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). - :return: - """ - body = state.entities.position - mask = target_exists_mask[agents_neighs_idx[1, :]] - senders, receivers = agents_neighs_idx - Ra = body.center[senders] - Rb = body.center[receivers] - dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why - - # Create distance and angle maps between entities - 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) - - # TODO : refactor this function because a lot of redundancies in the arguments (state.agents) - prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], - state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) - - return prox, proximity_map_dist, proximity_map_theta - - -# TODO : Refactor the following part, way to hard to understand in one pass -"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" -"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" -linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY']) - -linear_behavior_matrices = { - linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]), - linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]), - linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]), - linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]), -} - -def linear_behavior(proxs, motors, matrix): - return matrix.dot(jnp.hstack((proxs, 1.))) - -def apply_motors(proxs, motors): - return motors - -def noop(proxs, motors): - return jnp.array([0., 0.]) - -behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh]) - for beh in linear_behavior_enum] \ - + [apply_motors, noop] - -behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)} -behavior_name_map['manual'] = len(behavior_bank) - 2 -behavior_name_map['noop'] = len(behavior_bank) - 1 - -lg.info(behavior_name_map) - -# TODO : seems useless and unused -reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()} - -def switch_fn(fn_list): - def switch(index, *operands): - return lax.switch(index, fn_list, *operands) - return switch - -multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0)) - -def sensorimotor(prox, behaviors, motor): - motor = multi_switch(behaviors, prox, motor) - return motor -"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" -"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" - -def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): - fwd = (wheel_diameter / 4.) * (left_spd + right_spd) - rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) - return fwd, rot - -def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): - left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter - right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter - return left, right - -def motor_command(wheel_activation, base_length, wheel_diameter): - fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) - return fwd, rot - -motor_command = vmap(motor_command, (0, 0, 0)) - -### Define the force in the environment - -def braintenberg_force_fn(displacement): - coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) - - def collision_force(state, neighbor, exists_mask): - return coll_force_fn( - state.entities.position.center, - neighbor=neighbor, - exists_mask=exists_mask, - diameter=state.entities.diameter, - epsilon=state.collision_eps, - alpha=state.collision_alpha - ) - - def motor_force(state, exists_mask): - agent_idx = state.agents.ent_idx - - body = rigid_body.RigidBody( - center=state.entities.position.center[agent_idx], - orientation=state.entities.position.orientation[agent_idx] - ) - - n = normal(body.orientation) - - fwd, rot = motor_command( - state.agents.motor, - state.entities.diameter[agent_idx], - state.agents.wheel_diameter - ) - # `a_max` arg is deprecated in recent versions of jax, replaced by `max` - fwd = jnp.clip(fwd, a_max=state.agents.max_speed) - - cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] - cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) - cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] - - fwd_delta = fwd - cur_fwd_vel - rot_delta = rot - cur_rot_vel - - fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T - rot_force = rot_delta * state.agents.theta_mul - - center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) - orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) - - # apply mask to make non existing agents stand still - orientation = jnp.where(exists_mask, orientation, 0.) - # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center - exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) - center = jnp.where(exists_mask, center, 0.) - - return rigid_body.RigidBody(center=center, - orientation=orientation) - - - def force_fn(state, neighbor, exists_mask): - mf = motor_force(state, exists_mask) - cf = collision_force(state, neighbor, exists_mask) - ff = friction_force(state, exists_mask) - - center = cf + ff + mf.center - orientation = mf.orientation - return rigid_body.RigidBody(center=center, orientation=orientation) - - return force_fn - - -class BraitenbergEnv: - def __init__( - self, - box_size=100, - dt=0.1, - max_agents=10, - max_objects=2, - neighbor_radius=100., - collision_alpha=0.5, - collision_eps=0.1, - n_dims=2, - seed=0, - diameter=5.0, - friction=0.1, - mass_center=1.0, - mass_orientation=0.125, - existing_agents=10, - existing_objects=2, - behavior=behavior_name_map['AGGRESSION'], - 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, - agents_color=jnp.array([0.0, 0.0, 1.0]), - objects_color=jnp.array([1.0, 0.0, 0.0]) - ): - - # TODO : add docstrings - # general parameters - self.box_size = box_size - self.dt = dt - self.max_agents = max_agents - self.max_objects = max_objects - self.neighbor_radius = neighbor_radius - self.collision_alpha = collision_alpha - self.collision_eps = collision_eps - self.n_dims = n_dims - self.seed = seed - # entities parameters - self.diameter = diameter - self.friction = friction - self.mass_center = mass_center - self.mass_orientation = mass_orientation - self.existing_agents = existing_agents - self.existing_objects = existing_objects - # agents parameters - self.behavior = behavior - self.wheel_diameter = wheel_diameter - self.speed_mul = speed_mul - self.max_speed = max_speed - self.theta_mul = theta_mul - self.prox_dist_max = prox_dist_max - self.prox_cos_min = prox_cos_min - self.agents_color = agents_color - # objects parameters - self.objects_color = objects_color - # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? - - - # TODO : Split the initialization of entities, agents and objects w different functions ... - def init_state(self) -> State: - key = random.PRNGKey(self.seed) - key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) - - n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size - objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) - object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) - exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) - exists = jnp.concatenate((exists_agents, exists_objects), dtype=int) - # Entities idx of objects - start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects - objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) - - entity_state = 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), - entity_type=entity_types, - entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), - diameter=jnp.full((n_entities), self.diameter), - friction=jnp.full((n_entities), self.friction), - exists=exists - ) - - agents_state = AgentState( - # idx in the entities (ent_idx) state to map agents information in the different data structures - ent_idx=jnp.arange(self.max_agents, dtype=int), - prox=jnp.zeros((self.max_agents, 2)), - motor=jnp.zeros((self.max_agents, 2)), - behavior=jnp.full((self.max_agents), self.behavior), - wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), - speed_mul=jnp.full((self.max_agents), self.speed_mul), - max_speed=jnp.full((self.max_agents), self.max_speed), - theta_mul=jnp.full((self.max_agents), self.theta_mul), - proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), - proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), - proximity_map_dist=jnp.zeros((self.max_agents, 1)), - proximity_map_theta=jnp.zeros((self.max_agents, 1)), - color=jnp.tile(self.agents_color, (self.max_agents, 1)) - ) - - objects_state = ObjectState( - ent_idx=objects_ent_idx, - color=jnp.tile(self.objects_color, (self.max_objects, 1)) - ) - - lg.info('creating state') - state = State( - time=0, - box_size=self.box_size, - max_agents=self.max_agents, - max_objects=self.max_objects, - neighbor_radius=self.neighbor_radius, - collision_alpha=self.collision_alpha, - collision_eps=self.collision_eps, - dt=self.dt, - entities=entity_state, - agents=agents_state, - objects=objects_state - ) - - # Create jax_md attributes for environment physics - key, physics_key = random.split(key) - self.displacement, self.shift = space.periodic(self.box_size) - init_fn, apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) - self.init_fn = init_fn - self.apply_physics = jit(apply_physics) - self.neighbor_fn = partition.neighbor_list( - self.displacement, - self.box_size, - r_cutoff=self.neighbor_radius, - dr_threshold=10., - capacity_multiplier=1.5, - format=partition.Sparse - ) - - state = self.init_fn(state, physics_key) - positions = state.entities.position.center - lg.info('allocating neighbors') - neighbors, agents_neighs_idx = self.allocate_neighbors(state) - self.neighbors = neighbors - self.agents_neighs_idx = agents_neighs_idx - - return state - - - @partial(jit, static_argnums=(0,)) - def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: - # 1 : Compute agents proximeter and motor activations - exists_mask = jnp.where(state.entities.exists == 1, 1, 0) - # TODO : Big error bc here if recompilation the agents_neighs_idx will stay the same - # TODO Not rly clean, should maybe only return proximeters, or split the functions - prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=env.displacement) - motor = sensorimotor(prox, state.agents.behavior, state.agents.motor) - - agents = state.agents.replace( - prox=prox, - proximity_map_dist=proximity_dist_map, - proximity_map_theta=proximity_dist_theta, - motor=motor - ) - - state = state.replace(agents=agents) - # 2 : Move the entities by applying physics of the env (collision, friction and motor forces) - entities = env.apply_physics(state, neighbors) - - # 3 : Apply specific consequences in the env (e.g eating an object) - 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: - current_state = state - state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx) - - if self.neighbors.did_buffer_overflow: - print("overflow") - # reallocate neghbors and run the simulation from current_state - lg.warning('BUFFER OVERFLOW: rebuilding neighbors') - # TODO Check if need to give current_state or new state - neighbors, agents_neighs_idx = self.allocate_neighbors(state) - self.agents_neighs_idx = agents_neighs_idx - assert not neighbors.did_buffer_overflow - - self.neighbors = neighbors - return state - - def allocate_neighbors(self, state, position=None): - position = state.entities.position.center if position is None else position - neighbors = self.neighbor_fn.allocate(position) - mask = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value - agents_neighs_idx = neighbors.idx[:, mask] - return neighbors, agents_neighs_idx - - -if __name__ == "__main__": - env = BraitenbergEnv() - state = env.init_state() - n_steps = 10_000 - - hist = [] - render(state) - - start = time.perf_counter() - for i in range(n_steps): - state = env.step(state) - hist.append(state) - end = time.perf_counter() - print(f"{end - start} s to run") - - render(state) - - # render_history(hist) \ No newline at end of file diff --git a/vivarium/simulator/general_physics_engine.py b/vivarium/simulator/general_physics_engine.py deleted file mode 100644 index 9deb311..0000000 --- a/vivarium/simulator/general_physics_engine.py +++ /dev/null @@ -1,199 +0,0 @@ -from functools import partial - -import jax -import jax.numpy as jnp - -from jax import ops, vmap, lax -from jax_md import space, rigid_body, util, simulate, energy, quantity -f32 = util.f32 - - -# Only work on 2D environments atm -SPACE_NDIMS = 2 - -# Helper functions for collisions - -def collision_energy(displacement_fn, r_a, r_b, l_a, l_b, epsilon, alpha, mask): - """Compute the collision energy between a pair of particles - - :param displacement_fn: displacement function of jax_md - :param r_a: position of particle a - :param r_b: position of particle b - :param l_a: diameter of particle a - :param l_b: diameter of particle b - :param epsilon: interaction energy scale - :param alpha: interaction stiffness - :param mask: set the energy to 0 if one of the particles is masked - :return: collision energy between both particles - """ - dist = jnp.linalg.norm(displacement_fn(r_a, r_b)) - sigma = (l_a + l_b) / 2 - e = energy.soft_sphere(dist, sigma=sigma, epsilon=epsilon, alpha=f32(alpha)) - return jnp.where(mask, e, 0.) - -collision_energy = vmap(collision_energy, (None, 0, 0, 0, 0, None, None, 0)) - - -def total_collision_energy(positions, diameter, neighbor, displacement, exists_mask, epsilon, alpha): - """Compute the collision energy between all neighboring pairs of particles in the system - - :param positions: positions of all the particles - :param diameter: diameters of all the particles - :param neighbor: neighbor array of the system - :param displacement: dipalcement function of jax_md - :param exists_mask: mask to specify which particles exist - :param epsilon: interaction energy scale between two particles - :param alpha: interaction stiffness between two particles - :return: sum of all collisions energies of the system - """ - diameter = lax.stop_gradient(diameter) - senders, receivers = neighbor.idx - - r_senders = positions[senders] - r_receivers = positions[receivers] - l_senders = diameter[senders] - l_receivers = diameter[receivers] - - # Set collision energy to zero if the sender or receiver is non existing - mask = exists_mask[senders] * exists_mask[receivers] - energies = collision_energy(displacement, - r_senders, - r_receivers, - l_senders, - l_receivers, - epsilon, - alpha, - mask) - return jnp.sum(energies) - -# Functions to compute the verlet force on the whole system - -def friction_force(state, exists_mask): - cur_vel = state.entities.momentum.center / state.entities.mass.center - # stack the mask to give it the same shape as cur_vel (that has 2 rows for forward and angular velocities) - mask = jnp.stack([exists_mask] * 2, axis=1) - cur_vel = jnp.where(mask, cur_vel, 0.) - return - jnp.tile(state.entities.friction, (SPACE_NDIMS, 1)).T * cur_vel - -def collision_force(state, neighbor, exists_mask, displacement): - coll_force_fn = quantity.force( - total_collision_energy( - positions=state.entities.position.center, - displacement=displacement, - neighbor=neighbor, - exists_mask=exists_mask, - diameter=state.entities.diameter, - epsilon=state.collision_eps, - alpha=state.collision_alpha - ) - ) - - return coll_force_fn - - -def verlet_force_fn(displacement): - coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) - - def collision_force(state, neighbor, exists_mask): - return coll_force_fn( - state.entities.position.center, - neighbor=neighbor, - exists_mask=exists_mask, - diameter=state.entities.diameter, - epsilon=state.collision_eps, - alpha=state.collision_alpha - ) - - def force_fn(state, neighbor, exists_mask): - cf = collision_force(state, neighbor, exists_mask) - ff = friction_force(state, exists_mask) - center = cf + ff - return rigid_body.RigidBody(center=center, orientation=0) - - return force_fn - - -def dynamics_fn(displacement, shift, force_fn=None): - force_fn = force_fn(displacement) if force_fn else verlet_force_fn(displacement) - - def init_fn(state, key, kT=0.): - key, _ = jax.random.split(key) - assert state.entities.momentum is None - assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) - - state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) - return state - - def mask_momentum(entity_state, exists_mask): - """ - Set the momentum values to zeros for non existing entities - :param entity_state: entity_state - :param exists_mask: bool array specifying which entities exist or not - :return: entity_state: new entities state state with masked momentum values - """ - orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) - exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) - center = jnp.where(exists_mask, entity_state.momentum.center, 0) - momentum = rigid_body.RigidBody(center=center, orientation=orientation) - return entity_state.set(momentum=momentum) - - def step_fn(state, neighbor): - exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others - dt_2 = state.dt / 2. - # Compute forces - force = force_fn(state, neighbor, exists_mask) - # Compute changes on entities - entity_state = simulate.momentum_step(state.entities, dt_2) - # TODO : why do we used dt and not dt/2 in the line below ? - entity_state = simulate.position_step(entity_state, shift, dt_2, neighbor=neighbor) - entity_state = entity_state.replace(force=force) - entity_state = simulate.momentum_step(entity_state, dt_2) - entity_state = mask_momentum(entity_state, exists_mask) - return entity_state - - return init_fn, step_fn - - - -## TODO : This should be a general function that only takes forces (why the force fn here) -## TODO : Only motor force should be defined here in this file, and import the collision and friction forces -# TODO (i.e, we should only redefine the "verlet force fn here, by adding the motor force to it") -def dynamics_fn(displacement, shift, force_fn=None): - force_fn = force_fn(displacement) if force_fn else verlet_force_fn(displacement) - - def init_fn(state, key, kT=0.): - key, _ = jax.random.split(key) - assert state.entities.momentum is None - assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) - - state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) - return state - - def mask_momentum(entity_state, exists_mask): - """ - Set the momentum values to zeros for non existing entities - :param entity_state: entity_state - :param exists_mask: bool array specifying which entities exist or not - :return: entity_state: new entities state state with masked momentum values - """ - orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) - exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) - center = jnp.where(exists_mask, entity_state.momentum.center, 0) - momentum = rigid_body.RigidBody(center=center, orientation=orientation) - return entity_state.replace(momentum=momentum) - - def step_fn(state, neighbor): - exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others - dt_2 = state.dt / 2. - # Compute forces - force = force_fn(state, neighbor, exists_mask) - # Compute changes on entities - entity_state = simulate.momentum_step(state.entities, dt_2) - # TODO : why do we used dt and not dt/2 in the line below ? - entity_state = simulate.position_step(entity_state, shift, state.dt, neighbor=neighbor) - entity_state = entity_state.replace(force=force) - entity_state = simulate.momentum_step(entity_state, dt_2) - entity_state = mask_momentum(entity_state, exists_mask) - return entity_state - - return init_fn, step_fn \ No newline at end of file diff --git a/vivarium/utils.py b/vivarium/utils.py deleted file mode 100644 index d9f3519..0000000 --- a/vivarium/utils.py +++ /dev/null @@ -1,114 +0,0 @@ -import time -from IPython.display import display, clear_output - -import jax.numpy as jnp -import numpy as np -import matplotlib.pyplot as plt -import matplotlib.colors as colors - -from jax import vmap - -@vmap -def normal(theta): - return jnp.array([jnp.cos(theta), jnp.sin(theta)]) - -def _string_to_rgb(color_str): - return jnp.array(list(colors.to_rgb(color_str))) - -# Functions to render the current state -def render(state): - box_size = state.box_size - max_agents = state.max_agents - - plt.figure(figsize=(6, 6)) - plt.xlim(0, box_size) - plt.xlim(0, box_size) - - exists_agents, exists_objects = state.entities.exists[:max_agents], state.entities.exists[max_agents:] - exists_agents = jnp.where(exists_agents != 0) - exists_objects = jnp.where(exists_objects != 0) - - agents_pos = state.entities.position.center[:max_agents][exists_agents] - agents_theta = state.entities.position.orientation[:max_agents][exists_agents][exists_agents] - agents_diameter = state.entities.diameter[:max_agents][exists_agents][exists_agents] - objects_pos = state.entities.position.center[max_agents:][exists_objects] - object_diameter = state.entities.diameter[max_agents:][exists_objects] - - x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1] - agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.agents.color[exists_agents]] - x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1] - object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.objects.color[exists_objects]] - - n = normal(agents_theta) - - arrow_length = 3 - size_scale = 30 - dx = arrow_length * n[:, 0] - dy = arrow_length * n[:, 1] - plt.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01) - plt.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents') - plt.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects') - - plt.title('State') - plt.xlabel('X Position') - plt.ylabel('Y Position') - plt.legend() - - plt.show() - -# Function to render a state hystory -def render_history(state_history, pause=0.001, skip_frames=1): - box_size = state_history[0].box_size - max_agents = state_history[0].max_agents - print(box_size) - print(max_agents) - fig, ax = plt.subplots(figsize=(6, 6)) - ax.set_xlim(0, box_size) - ax.set_ylim(0, box_size) - - for t in range(0, len(state_history), skip_frames): - # Because weird saving at the moment, we don't save the state but all its sub-elements - entities = state_history[t].entities - agents = state_history[t].agents - objects = state_history[t].objects - - exists_agents, exists_objects = entities.exists[:max_agents], entities.exists[max_agents:] - exists_agents = jnp.where(exists_agents != 0) - exists_objects = jnp.where(exists_objects != 0) - - agents_pos = entities.position.center[:max_agents][exists_agents] - agents_theta = entities.position.orientation[:max_agents][exists_agents][exists_agents] - agents_diameter = entities.diameter[:max_agents][exists_agents][exists_agents] - objects_pos = entities.position.center[max_agents:][exists_objects] - object_diameter = entities.diameter[max_agents:][exists_objects] - - x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1] - agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in agents.color[exists_agents]] - x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1] - object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in objects.color[exists_objects]] - - n = normal(agents_theta) - - arrow_length = 3 - size_scale = 30 - dx = arrow_length * n[:, 0] - dy = arrow_length * n[:, 1] - - ax.clear() - ax.set_xlim(0, box_size) - ax.set_ylim(0, box_size) - - ax.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01) - ax.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents') - ax.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects') - - ax.set_title(f'Timestep: {t}') - ax.set_xlabel('X Position') - ax.set_ylabel('Y Position') - ax.legend() - - display(fig) - clear_output(wait=True) - time.sleep(pause) - - plt.close(fig) From ca3dcaace1d6429339c85bd6683ec657a35ff39f Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 3 Jun 2024 15:50:03 +0200 Subject: [PATCH 07/18] Add simple and prey_predator braitenberg envs in experimental directory --- .../experimental/environments/base_env.py | 84 +++ .../environments/braitenberg/prey_predator.py | 213 ++++++++ .../environments/braitenberg/simple.py | 506 ++++++++++++++++++ .../environments/braitenberg/utils.py | 112 ++++ .../environments/particle_lenia/simple.py | 1 + .../environments/physics_engine.py | 150 ++++++ .../notebooks/prey_predator_braitenberg.ipynb | 400 ++++++++++++++ .../notebooks/simple_braitenberg.ipynb | 225 ++++++++ 8 files changed, 1691 insertions(+) create mode 100644 vivarium/experimental/environments/base_env.py create mode 100644 vivarium/experimental/environments/braitenberg/prey_predator.py create mode 100644 vivarium/experimental/environments/braitenberg/simple.py create mode 100644 vivarium/experimental/environments/braitenberg/utils.py create mode 100644 vivarium/experimental/environments/particle_lenia/simple.py create mode 100644 vivarium/experimental/environments/physics_engine.py create mode 100644 vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb create mode 100644 vivarium/experimental/notebooks/simple_braitenberg.ipynb diff --git a/vivarium/experimental/environments/base_env.py b/vivarium/experimental/environments/base_env.py new file mode 100644 index 0000000..58e245c --- /dev/null +++ b/vivarium/experimental/environments/base_env.py @@ -0,0 +1,84 @@ +import logging as lg +from enum import Enum +from functools import partial +from typing import Tuple + +import jax.numpy as jnp + +from jax import jit +from flax import struct +from jax_md import simulate + + +# TODO : The best is surely to only define BaseState because some envs might not use EntityState / ObjectState or AgentState +class EntityType(Enum): + AGENT = 0 + OBJECT = 1 + +# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState) +@struct.dataclass +class BaseEntityState(simulate.NVEState): + entity_type: jnp.array + entity_idx: jnp.array + diameter: jnp.array + friction: jnp.array + exists: jnp.array + + @property + def velocity(self) -> jnp.array: + return self.momentum / self.mass + +@struct.dataclass +class BaseAgentState: + ent_idx: jnp.array + color: jnp.array + +@struct.dataclass +class BaseObjectState: + ent_idx: jnp.array + color: jnp.array + +@struct.dataclass +class BaseState: + time: jnp.int32 + box_size: jnp.int32 + 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 + entities: BaseEntityState + agents: BaseAgentState + objects: BaseObjectState + + +class BaseEnv: + def __init__(self): + raise(NotImplementedError) + + def init_state(self) -> BaseState: + raise(NotImplementedError) + + @partial(jit, static_argnums=(0,)) + def _step(self, state: BaseState, neighbors: jnp.array) -> Tuple[BaseState, jnp.array]: + raise(NotImplementedError) + + def step(self, state: BaseState) -> BaseState: + current_state = state + state, neighbors = self._step(current_state, self.neighbors) + + if self.neighbors.did_buffer_overflow: + # reallocate neighbors and run the simulation from current_state + lg.warning('BUFFER OVERFLOW: rebuilding neighbors') + neighbors = self.allocate_neighbors(state) + assert not neighbors.did_buffer_overflow + + self.neighbors = neighbors + return state + + def allocate_neighbors(self, state, position=None): + position = state.entities.position.center if position is None else position + neighbors = self.neighbor_fn.allocate(position) + return neighbors + \ No newline at end of file diff --git a/vivarium/experimental/environments/braitenberg/prey_predator.py b/vivarium/experimental/environments/braitenberg/prey_predator.py new file mode 100644 index 0000000..24984e2 --- /dev/null +++ b/vivarium/experimental/environments/braitenberg/prey_predator.py @@ -0,0 +1,213 @@ +from enum import Enum +from functools import partial +from typing import Tuple + +import jax.numpy as jnp + +from jax import vmap, jit +from jax import random +from flax import struct + +from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType +from vivarium.experimental.environments.braitenberg.simple import sensorimotor, compute_prox, behavior_name_map +from vivarium.experimental.environments.base_env import BaseEntityState, BaseObjectState + +### Define the classes and constants of the environment (most of them inherit from the simple braitenbeg one) ### + +class AgentType(Enum): + PREY = 0 + PREDATOR = 1 + +predator_color = jnp.array([1., 0., 0.]) +prey_color = jnp.array([0., 0., 1.]) +object_color = jnp.array([0., 1., 0.]) + +@struct.dataclass +class EntityState(BaseEntityState): + pass + +@struct.dataclass +class AgentState(AgentState): + agent_type: jnp.array + +@struct.dataclass +class ObjectState(BaseObjectState): + pass + +@struct.dataclass +class State(State): + pass + +### Define the new env class inheriting from simple one (only need to update __init__, init_state and _step) + +class PreyPredBraitenbergEnv(BraitenbergEnv): + def __init__( + self, + box_size=200, + dt=0.1, + max_agents=50, + max_objects=10, + neighbor_radius=100., + collision_alpha=0.5, + collision_eps=0.1, + n_dims=2, + seed=0, + diameter=5.0, + friction=0.1, + mass_center=1.0, + mass_orientation=0.125, + existing_agents=50, + existing_objects=0, + 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, + objects_color=jnp.array([0.0, 1.0, 0.0]), + # New prey_predators args, should maybe add warnings to avoid incompatible values (e.g less agents than prey + pred) + n_preys=25, + n_predators=25, + pred_eating_range=10, + prey_color=jnp.array([0.0, 0.0, 1.0]), + predator_color=jnp.array([1.0, 0.0, 0.0]), + ): + super().__init__( + box_size=box_size, + dt=dt, + max_agents=max_agents, + max_objects=max_objects, + 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=existing_agents, + existing_objects=existing_objects, + 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_color=objects_color + ) + # Add specific attributes about prey / predator environment + self.n_preys = n_preys + self.n_predators = n_predators + self.prey_color = prey_color + self.predator_color = predator_color + self.pred_eating_range = pred_eating_range + + def init_state(self) -> State: + key = random.PRNGKey(self.seed) + key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) + + entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) + objects = self.init_objects() + + # Added agent types for prey and predators + agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value))) + agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0) + behaviors = jnp.hstack((jnp.full(self.n_preys, behavior_name_map['FEAR']), jnp.full(self.n_predators, behavior_name_map['AGGRESSION']))) + + agents = AgentState( + # idx in the entities (ent_idx) state to map agents information in the different data structures + ent_idx=jnp.arange(self.max_agents, dtype=int), + agent_type=agent_types, + prox=jnp.zeros((self.max_agents, 2)), + motor=jnp.zeros((self.max_agents, 2)), + behavior=behaviors, + wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), + speed_mul=jnp.full((self.max_agents), self.speed_mul), + max_speed=jnp.full((self.max_agents), self.max_speed), + theta_mul=jnp.full((self.max_agents), self.theta_mul), + proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), + proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), + proximity_map_dist=jnp.zeros((self.max_agents, 1)), + proximity_map_theta=jnp.zeros((self.max_agents, 1)), + color=agents_colors + ) + + state = self.init_complete_state(entities, agents, objects) + + # Create jax_md attributes for environment physics + state = self.init_physics(key, state) + + self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value) + self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value) + self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value) + + return state + + def can_all_be_eaten(self, R_prey, R_predators, predator_exist): + # Could maybe create this as a method in the class, or above idk + distance_to_all_preds = vmap(self.distance, in_axes=(None, 0)) + + # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above + def can_be_eaten(R_prey, R_predators, predator_exist): + dist_to_preds = distance_to_all_preds(R_prey, R_predators) + in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0) + # Could also return which agent ate the other one (e.g to increase their energy) + will_be_eaten_by = in_range * predator_exist + eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0) + + return eaten_or_not + + can_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None)) + + return can_be_eaten(R_prey, R_predators, predator_exist) + + def eat_preys(self, state): + # See which preys can be eaten by predators and update the exists array accordingly + R = state.entities.position.center + exist = state.entities.exists + prey_idx = self.prey_idx + pred_idx = self.pred_idx + + agents_ent_idx = state.agents.ent_idx + predator_exist = exist[agents_ent_idx][pred_idx] + + can_be_eaten_idx = self.can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist) + exist_prey = exist[agents_ent_idx[prey_idx]] + new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey) + exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey) + return exist + + @partial(jit, static_argnums=(0,)) + def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: + # 1 Compute which agents are being eaten + exist = self.eat_preys(state) + entities = state.entities.replace(exists=exist) + + # 2 Compute the proximeter of agents + exists_mask = jnp.where(entities.exists == 1, 1, 0) + prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement) + motor = sensorimotor(prox, state.agents.behavior, state.agents.motor) + agents = state.agents.replace( + prox=prox, + proximity_map_dist=proximity_dist_map, + proximity_map_theta=proximity_dist_theta, + motor=motor + ) + + # 3 Update the state with the new agent and entities states + state = state.replace( + agents=agents, + entities=entities + ) + + # 4 Apply physics forces to the environment state + entities = self.apply_physics(state, neighbors) + state = state.replace( + time=state.time+1, + entities=entities, + ) + + # 5 Update the neighbors according to the new positions + neighbors = neighbors.update(state.entities.position.center) + return state, neighbors diff --git a/vivarium/experimental/environments/braitenberg/simple.py b/vivarium/experimental/environments/braitenberg/simple.py new file mode 100644 index 0000000..63e3c73 --- /dev/null +++ b/vivarium/experimental/environments/braitenberg/simple.py @@ -0,0 +1,506 @@ +import logging as lg +from enum import Enum +from functools import partial +from typing import Tuple + +import jax.numpy as jnp + +from jax import vmap, jit +from jax import random, ops, lax + +from flax import struct +from jax_md.rigid_body import RigidBody +from jax_md import space, rigid_body, partition, quantity + +from vivarium.experimental.environments.braitenberg.utils import normal +from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv +from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn + +### Define the constants and the classes of the environment to store its state ### + +SPACE_NDIMS = 2 + +# TODO : Should maybe just let the user define its own class and just have a base class State with time ... +class EntityType(Enum): + AGENT = 0 + OBJECT = 1 + +@struct.dataclass +class EntityState(BaseEntityState): + pass + +@struct.dataclass +class AgentState(BaseAgentState): + prox: jnp.array + motor: jnp.array + proximity_map_dist: jnp.array + proximity_map_theta: jnp.array + behavior: 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(BaseObjectState): + pass + +@struct.dataclass +class State(BaseState): + time: jnp.int32 + box_size: jnp.int32 + 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 + entities: EntityState + agents: AgentState + objects: ObjectState + +### Define helper functions used to step from one state to the next one ### + + +#--- 1 Functions to compute the proximeter of braitenberg agents ---# + +def relative_position(displ, theta): + """ + Compute the relative distance and angle from a source agent to a target agent + :param displ: Displacement vector (jnp arrray with shape (2,) from source to target + :param theta: Orientation of the source agent (in the reference frame of the map) + :return: dist: distance from source to target. + relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) + """ + dist = jnp.linalg.norm(displ) + norm_displ = displ / dist + theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) + relative_theta = theta_displ - theta + return dist, relative_theta + +proximity_map = vmap(relative_position, (0, 0)) + +# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority) +def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): + """ + Compute the proximeter activations (left, right) induced by the presence of an entity + :param dist: distance from the agent to the entity + :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) + :param dist_max: Max distance of the proximiter (will return 0. above this distance) + :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) + :return: left and right proximeter activation in a jnp array with shape (2,) + """ + cos_dir = jnp.cos(relative_theta) + prox = 1. - (dist / dist_max) + in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) + at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) + left = in_view * at_left * prox + right = in_view * (1. - at_left) * prox + return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist + +sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) + +def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): + raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) + # Computes the maximum within the proximeter activations of agents on all their neigbhors. + proxs = ops.segment_max( + raw_proxs, + senders, + max_agents) + + return proxs + +# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) +def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): + """ + Set agents' proximeter activations + :param state: full simulation State + :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), + where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. + :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). + target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). + :return: + """ + body = state.entities.position + mask = target_exists_mask[agents_neighs_idx[1, :]] + senders, receivers = agents_neighs_idx + Ra = body.center[senders] + Rb = body.center[receivers] + dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why + + # Create distance and angle maps between entities + 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) + + # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) + prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], + state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) + + # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) + return prox, proximity_map_dist, proximity_map_theta + + +#--- 2 Functions to compute the motor activations of braitenberg agents ---# + +# TODO : I think we could also refactor this part of the code to make it clearer (part between """""""") +"""""""" +linear_behavior_enum = Enum('matrices', ['FEAR', 'AGGRESSION', 'LOVE', 'SHY']) + +linear_behavior_matrices = { + linear_behavior_enum.FEAR: jnp.array([[1., 0., 0.], [0., 1., 0.]]), + linear_behavior_enum.AGGRESSION: jnp.array([[0., 1., 0.], [1., 0., 0.]]), + linear_behavior_enum.LOVE: jnp.array([[-1., 0., 1.], [0., -1., 1.]]), + linear_behavior_enum.SHY: jnp.array([[0., -1., 1.], [-1., 0., 1.]]), +} + +def linear_behavior(proxs, motors, matrix): + return matrix.dot(jnp.hstack((proxs, 1.))) + +def apply_motors(proxs, motors): + return motors + +def noop(proxs, motors): + return jnp.array([0., 0.]) + +behavior_bank = [partial(linear_behavior, matrix=linear_behavior_matrices[beh]) + for beh in linear_behavior_enum] \ + + [apply_motors, noop] + +behavior_name_map = {beh.name: i for i, beh in enumerate(linear_behavior_enum)} +behavior_name_map['manual'] = len(behavior_bank) - 2 +behavior_name_map['noop'] = len(behavior_bank) - 1 + +lg.info(behavior_name_map) + +# TODO : Check but seems unused +reversed_behavior_name_map = {i: name for name, i in behavior_name_map.items()} + +def switch_fn(fn_list): + def switch(index, *operands): + return lax.switch(index, fn_list, *operands) + return switch + +multi_switch = vmap(switch_fn(behavior_bank), (0, 0, 0)) + +def sensorimotor(prox, behaviors, motor): + motor = multi_switch(behaviors, prox, motor) + return motor +"""""" + +def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): + fwd = (wheel_diameter / 4.) * (left_spd + right_spd) + rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) + return fwd, rot + +def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): + left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter + right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter + return left, right + +def motor_command(wheel_activation, base_length, wheel_diameter): + fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) + return fwd, rot + +motor_command = vmap(motor_command, (0, 0, 0)) + + +#--- 3 Functions to compute the different forces in the environment ---# + +# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces +def braintenberg_force_fn(displacement): + coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) + + def collision_force(state, neighbor, exists_mask): + return coll_force_fn( + state.entities.position.center, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + + def motor_force(state, exists_mask): + agent_idx = state.agents.ent_idx + + body = rigid_body.RigidBody( + center=state.entities.position.center[agent_idx], + orientation=state.entities.position.orientation[agent_idx] + ) + + n = normal(body.orientation) + + fwd, rot = motor_command( + state.agents.motor, + state.entities.diameter[agent_idx], + state.agents.wheel_diameter + ) + # `a_max` arg is deprecated in recent versions of jax, replaced by `max` + fwd = jnp.clip(fwd, a_max=state.agents.max_speed) + + cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] + cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) + cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] + + fwd_delta = fwd - cur_fwd_vel + rot_delta = rot - cur_rot_vel + + fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T + rot_force = rot_delta * state.agents.theta_mul + + center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) + orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) + + # apply mask to make non existing agents stand still + orientation = jnp.where(exists_mask, orientation, 0.) + # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, center, 0.) + + return rigid_body.RigidBody(center=center, + orientation=orientation) + + def force_fn(state, neighbor, exists_mask): + mf = motor_force(state, exists_mask) + cf = collision_force(state, neighbor, exists_mask) + ff = friction_force(state, exists_mask) + + center = cf + ff + mf.center + orientation = mf.orientation + return rigid_body.RigidBody(center=center, orientation=orientation) + + return force_fn + + +#--- 4 Define the environment class with its different functions (init_state, _step ...) ---# + +class BraitenbergEnv(BaseEnv): + def __init__( + self, + box_size=100, + dt=0.1, + max_agents=10, + max_objects=2, + neighbor_radius=100., + collision_alpha=0.5, + collision_eps=0.1, + n_dims=2, + seed=0, + diameter=5.0, + friction=0.1, + mass_center=1.0, + mass_orientation=0.125, + existing_agents=10, + existing_objects=2, + behavior=behavior_name_map['AGGRESSION'], + 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, + agents_color=jnp.array([0.0, 0.0, 1.0]), + objects_color=jnp.array([1.0, 0.0, 0.0]) + ): + + # TODO : add docstrings + # general parameters + self.box_size = box_size + self.dt = dt + self.max_agents = max_agents + self.max_objects = max_objects + self.neighbor_radius = neighbor_radius + self.collision_alpha = collision_alpha + self.collision_eps = collision_eps + self.n_dims = n_dims + self.seed = seed + # entities parameters + self.diameter = diameter + self.friction = friction + self.mass_center = mass_center + self.mass_orientation = mass_orientation + self.existing_agents = existing_agents + self.existing_objects = existing_objects + # agents parameters + self.behavior = behavior + self.wheel_diameter = wheel_diameter + self.speed_mul = speed_mul + self.max_speed = max_speed + self.theta_mul = theta_mul + self.prox_dist_max = prox_dist_max + self.prox_cos_min = prox_cos_min + self.agents_color = agents_color + # objects parameters + self.objects_color = objects_color + # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? + # Or can also directly initialize the state ... and jax_md attributes in this function too ... + + def init_state(self) -> State: + key = random.PRNGKey(self.seed) + key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) + + entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) + agents = self.init_agents() + objects = self.init_objects() + state = self.init_complete_state(entities, agents, objects) + + # Create jax_md attributes for environment physics + # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes) + state = self.init_env_physics(key, state) + + return state + + def distance(self, point1, point2): + diff = self.displacement(point1, point2) + squared_diff = jnp.sum(jnp.square(diff)) + return jnp.sqrt(squared_diff) + + # TODO See how to clean the function to remove the agents_neighs_idx + @partial(jit, static_argnums=(0,)) + def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: + # 1 : Compute agents proximeter + exists_mask = jnp.where(state.entities.exists == 1, 1, 0) + prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement) + + # 2 : Compute motor activations according to new proximeter values + motor = sensorimotor(prox, state.agents.behavior, state.agents.motor) + agents = state.agents.replace( + prox=prox, + proximity_map_dist=proximity_dist_map, + proximity_map_theta=proximity_dist_theta, + motor=motor + ) + + # 3 : Update the state with new agents proximeter and motor values + state = state.replace(agents=agents) + + # 4 : Move the entities by applying forces on them (collision, friction and motor forces for agents) + entities = self.apply_physics(state, neighbors) + state = state.replace(time=state.time+1, entities=entities) + + # 5 : Update neighbors + neighbors = neighbors.update(state.entities.position.center) + return state, neighbors + + def step(self, state: State) -> State: + current_state = state + state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx) + + if self.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') + neighbors = self.allocate_neighbors(state) + assert not neighbors.did_buffer_overflow + + self.neighbors = neighbors + return state + + # TODO See how we deal with agents_neighs_idx + def allocate_neighbors(self, state, position=None): + position = state.entities.position.center if position is None else position + neighbors = self.neighbor_fn.allocate(position) + + # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here) + ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value + self.agents_neighs_idx = neighbors.idx[:, ag_idx] + + return neighbors + + def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): + n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size + objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) + object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) + exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) + exists = jnp.concatenate((exists_agents, exists_objects), 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), + entity_type=entity_types, + entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), + diameter=jnp.full((n_entities), self.diameter), + friction=jnp.full((n_entities), self.friction), + exists=exists + ) + + def init_agents(self): + return AgentState( + # idx in the entities (ent_idx) state to map agents information in the different data structures + ent_idx=jnp.arange(self.max_agents, dtype=int), + prox=jnp.zeros((self.max_agents, 2)), + motor=jnp.zeros((self.max_agents, 2)), + behavior=jnp.full((self.max_agents), self.behavior), + wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), + speed_mul=jnp.full((self.max_agents), self.speed_mul), + max_speed=jnp.full((self.max_agents), self.max_speed), + theta_mul=jnp.full((self.max_agents), self.theta_mul), + proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), + proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), + proximity_map_dist=jnp.zeros((self.max_agents, 1)), + proximity_map_theta=jnp.zeros((self.max_agents, 1)), + color=jnp.tile(self.agents_color, (self.max_agents, 1)) + ) + + def init_objects(self): + # Entities idx of objects + start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects + objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) + + return ObjectState( + ent_idx=objects_ent_idx, + color=jnp.tile(self.objects_color, (self.max_objects, 1)) + ) + + def init_complete_state(self, entities, agents, objects): + lg.info('Initializing state') + return State( + time=0, + box_size=self.box_size, + max_agents=self.max_agents, + max_objects=self.max_objects, + neighbor_radius=self.neighbor_radius, + collision_alpha=self.collision_alpha, + collision_eps=self.collision_eps, + dt=self.dt, + entities=entities, + agents=agents, + objects=objects + ) + + def init_env_physics(self, key, state): + lg.info("Initializing environment's physics features") + key, physics_key = random.split(key) + self.displacement, self.shift = space.periodic(self.box_size) + self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) + self.neighbor_fn = partition.neighbor_list( + self.displacement, + self.box_size, + r_cutoff=self.neighbor_radius, + dr_threshold=10., + capacity_multiplier=1.5, + format=partition.Sparse + ) + + state = self.init_fn(state, physics_key) + lg.info("Allocating neighbors") + neighbors = self.allocate_neighbors(state) + self.neighbors = neighbors + + return state diff --git a/vivarium/experimental/environments/braitenberg/utils.py b/vivarium/experimental/environments/braitenberg/utils.py new file mode 100644 index 0000000..8f540e9 --- /dev/null +++ b/vivarium/experimental/environments/braitenberg/utils.py @@ -0,0 +1,112 @@ +import time +from IPython.display import display, clear_output + +import jax.numpy as jnp +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.colors as colors + +from jax import vmap + +@vmap +def normal(theta): + return jnp.array([jnp.cos(theta), jnp.sin(theta)]) + +def _string_to_rgb(color_str): + return jnp.array(list(colors.to_rgb(color_str))) + +# Functions to render the current state +def render(state): + box_size = state.box_size + max_agents = state.max_agents + + plt.figure(figsize=(6, 6)) + plt.xlim(0, box_size) + plt.xlim(0, box_size) + + exists_agents, exists_objects = state.entities.exists[:max_agents], state.entities.exists[max_agents:] + exists_agents = jnp.where(exists_agents != 0) + exists_objects = jnp.where(exists_objects != 0) + + agents_pos = state.entities.position.center[:max_agents][exists_agents] + agents_theta = state.entities.position.orientation[:max_agents][exists_agents][exists_agents] + agents_diameter = state.entities.diameter[:max_agents][exists_agents][exists_agents] + objects_pos = state.entities.position.center[max_agents:][exists_objects] + object_diameter = state.entities.diameter[max_agents:][exists_objects] + + x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1] + agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.agents.color[exists_agents]] + x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1] + object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.objects.color[exists_objects]] + + n = normal(agents_theta) + + arrow_length = 3 + size_scale = 30 + dx = arrow_length * n[:, 0] + dy = arrow_length * n[:, 1] + plt.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01) + plt.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents') + plt.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects') + + plt.title('State') + plt.xlabel('X Position') + plt.ylabel('Y Position') + plt.legend() + + plt.show() + +# Function to render a state hystory +def render_history(state_history, pause=0.001, skip_frames=1): + box_size = state_history[0].box_size + max_agents = state_history[0].max_agents + fig, ax = plt.subplots(figsize=(6, 6)) + ax.set_xlim(0, box_size) + ax.set_ylim(0, box_size) + + for t in range(0, len(state_history), skip_frames): + # Because weird saving at the moment, we don't save the state but all its sub-elements + entities = state_history[t].entities + agents = state_history[t].agents + objects = state_history[t].objects + + exists_agents, exists_objects = entities.exists[:max_agents], entities.exists[max_agents:] + exists_agents = jnp.where(exists_agents != 0) + exists_objects = jnp.where(exists_objects != 0) + + agents_pos = entities.position.center[:max_agents][exists_agents] + agents_theta = entities.position.orientation[:max_agents][exists_agents][exists_agents] + agents_diameter = entities.diameter[:max_agents][exists_agents][exists_agents] + objects_pos = entities.position.center[max_agents:][exists_objects] + object_diameter = entities.diameter[max_agents:][exists_objects] + + x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1] + agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in agents.color[exists_agents]] + x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1] + object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in objects.color[exists_objects]] + + n = normal(agents_theta) + + arrow_length = 3 + size_scale = 30 + dx = arrow_length * n[:, 0] + dy = arrow_length * n[:, 1] + + ax.clear() + ax.set_xlim(0, box_size) + ax.set_ylim(0, box_size) + + ax.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01) + ax.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents') + ax.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects') + + ax.set_title(f'Timestep: {t}') + ax.set_xlabel('X Position') + ax.set_ylabel('Y Position') + ax.legend() + + display(fig) + clear_output(wait=True) + time.sleep(pause) + + plt.close(fig) diff --git a/vivarium/experimental/environments/particle_lenia/simple.py b/vivarium/experimental/environments/particle_lenia/simple.py new file mode 100644 index 0000000..f87f5c1 --- /dev/null +++ b/vivarium/experimental/environments/particle_lenia/simple.py @@ -0,0 +1 @@ +# TODO \ No newline at end of file diff --git a/vivarium/experimental/environments/physics_engine.py b/vivarium/experimental/environments/physics_engine.py new file mode 100644 index 0000000..6613d51 --- /dev/null +++ b/vivarium/experimental/environments/physics_engine.py @@ -0,0 +1,150 @@ +from functools import partial + +import jax +import jax.numpy as jnp + +from jax import vmap, lax +from jax_md import rigid_body, util, simulate, energy, quantity +f32 = util.f32 + + +SPACE_NDIMS = 2 + +# Helper functions for collisions +def collision_energy(displacement_fn, r_a, r_b, l_a, l_b, epsilon, alpha, mask): + """Compute the collision energy between a pair of particles + + :param displacement_fn: displacement function of jax_md + :param r_a: position of particle a + :param r_b: position of particle b + :param l_a: diameter of particle a + :param l_b: diameter of particle b + :param epsilon: interaction energy scale + :param alpha: interaction stiffness + :param mask: set the energy to 0 if one of the particles is masked + :return: collision energy between both particles + """ + dist = jnp.linalg.norm(displacement_fn(r_a, r_b)) + sigma = (l_a + l_b) / 2 + e = energy.soft_sphere(dist, sigma=sigma, epsilon=epsilon, alpha=f32(alpha)) + return jnp.where(mask, e, 0.) + +collision_energy = vmap(collision_energy, (None, 0, 0, 0, 0, None, None, 0)) + +def total_collision_energy(positions, diameter, neighbor, displacement, exists_mask, epsilon, alpha): + """Compute the collision energy between all neighboring pairs of particles in the system + + :param positions: positions of all the particles + :param diameter: diameters of all the particles + :param neighbor: neighbor array of the system + :param displacement: dipalcement function of jax_md + :param exists_mask: mask to specify which particles exist + :param epsilon: interaction energy scale between two particles + :param alpha: interaction stiffness between two particles + :return: sum of all collisions energies of the system + """ + diameter = lax.stop_gradient(diameter) + senders, receivers = neighbor.idx + + r_senders = positions[senders] + r_receivers = positions[receivers] + l_senders = diameter[senders] + l_receivers = diameter[receivers] + + # Set collision energy to zero if the sender or receiver is non existing + mask = exists_mask[senders] * exists_mask[receivers] + energies = collision_energy(displacement, + r_senders, + r_receivers, + l_senders, + l_receivers, + epsilon, + alpha, + mask) + return jnp.sum(energies) + +# Functions to compute the verlet force on the whole system +def friction_force(state, exists_mask): + cur_vel = state.entities.momentum.center / state.entities.mass.center + # stack the mask to give it the same shape as cur_vel (that has 2 rows for forward and angular velocities) + mask = jnp.stack([exists_mask] * 2, axis=1) + cur_vel = jnp.where(mask, cur_vel, 0.) + return - jnp.tile(state.entities.friction, (SPACE_NDIMS, 1)).T * cur_vel + +def collision_force(state, neighbor, exists_mask, displacement): + coll_force_fn = quantity.force( + total_collision_energy( + positions=state.entities.position.center, + displacement=displacement, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + ) + + return coll_force_fn + + +def verlet_force_fn(displacement): + coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) + + def collision_force(state, neighbor, exists_mask): + return coll_force_fn( + state.entities.position.center, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + + def force_fn(state, neighbor, exists_mask): + cf = collision_force(state, neighbor, exists_mask) + ff = friction_force(state, exists_mask) + center = cf + ff + return rigid_body.RigidBody(center=center, orientation=0) + + return force_fn + + +def dynamics_fn(displacement, shift, force_fn=None): + force_fn = force_fn(displacement) if force_fn else verlet_force_fn(displacement) + + def init_fn(state, key, kT=0.): + key, _ = jax.random.split(key) + assert state.entities.momentum is None + assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation) + + state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT)) + return state + + def mask_momentum(entity_state, exists_mask): + """ + Set the momentum values to zeros for non existing entities + :param entity_state: entity_state + :param exists_mask: bool array specifying which entities exist or not + :return: entity_state: new entities state state with masked momentum values + """ + orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0) + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, entity_state.momentum.center, 0) + momentum = rigid_body.RigidBody(center=center, orientation=orientation) + return entity_state.set(momentum=momentum) + + def step_fn(state, neighbor): + exists_mask = (state.entities.exists == 1) # Only existing entities have effect on others + dt_2 = state.dt / 2. + # Compute forces + force = force_fn(state, neighbor, exists_mask) + # Compute changes on entities + entity_state = simulate.momentum_step(state.entities, dt_2) + # TODO : why do we used dt and not dt/2 in the line below ? + entity_state = simulate.position_step(entity_state, shift, dt_2, neighbor=neighbor) + entity_state = entity_state.replace(force=force) + entity_state = simulate.momentum_step(entity_state, dt_2) + entity_state = mask_momentum(entity_state, exists_mask) + return entity_state + + return init_fn, step_fn diff --git a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb new file mode 100644 index 0000000..19411e2 --- /dev/null +++ b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb @@ -0,0 +1,400 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prey predator braitenberg notebook\n", + "\n", + "Use this notebook to showcase how to build on top of an existing environment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-06-03 15:47:34.147139: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + ] + } + ], + "source": [ + "from enum import Enum\n", + "from functools import partial\n", + "from typing import Tuple\n", + "\n", + "import jax.numpy as jnp\n", + "\n", + "from jax import vmap, jit\n", + "from jax import random\n", + "from flax import struct\n", + "\n", + "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType\n", + "from vivarium.experimental.environments.braitenberg.simple import sensorimotor, compute_prox, behavior_name_map\n", + "from vivarium.experimental.environments.base_env import BaseEntityState, BaseObjectState" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the states classes of prey predator env " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "### Define the classes and constants of the environment (most of them inherit from the simple braitenbeg one) ###\n", + "\n", + "class AgentType(Enum):\n", + " PREY = 0\n", + " PREDATOR = 1\n", + "\n", + "predator_color = jnp.array([1., 0., 0.])\n", + "prey_color = jnp.array([0., 0., 1.])\n", + "object_color = jnp.array([0., 1., 0.])\n", + "\n", + "@struct.dataclass\n", + "class EntityState(BaseEntityState):\n", + " pass\n", + " \n", + "@struct.dataclass\n", + "class AgentState(AgentState):\n", + " agent_type: jnp.array\n", + "\n", + "@struct.dataclass\n", + "class ObjectState(BaseObjectState):\n", + " pass\n", + "\n", + "@struct.dataclass\n", + "class State(State):\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define prey predator env class \n", + "\n", + "(inheriting from simple Braitenberg env)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "### Define the new env class inheriting from simple one (only need to update __init__, init_state and _step)\n", + "\n", + "class PreyPredBraitenbergEnv(BraitenbergEnv):\n", + " def __init__(\n", + " self,\n", + " box_size=200,\n", + " dt=0.1,\n", + " max_agents=50,\n", + " max_objects=10,\n", + " neighbor_radius=100.,\n", + " collision_alpha=0.5,\n", + " collision_eps=0.1,\n", + " n_dims=2,\n", + " seed=0,\n", + " diameter=5.0,\n", + " friction=0.1,\n", + " mass_center=1.0,\n", + " mass_orientation=0.125,\n", + " existing_agents=50,\n", + " existing_objects=10,\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", + " objects_color=jnp.array([0.0, 1.0, 0.0]),\n", + " # New prey_predators args, should maybe add warnings to avoid incompatible values (e.g less agents than prey + pred)\n", + " n_preys=25,\n", + " n_predators=25,\n", + " pred_eating_range=10,\n", + " prey_color=jnp.array([0.0, 0.0, 1.0]),\n", + " predator_color=jnp.array([1.0, 0.0, 0.0]),\n", + " ):\n", + " super().__init__(\n", + " box_size=box_size,\n", + " dt=dt,\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", + " 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=existing_agents,\n", + " existing_objects=existing_objects,\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", + " objects_color=objects_color\n", + " )\n", + " # Add specific attributes about prey / predator environment\n", + " self.n_preys = n_preys\n", + " self.n_predators = n_predators\n", + " self.prey_color = prey_color\n", + " self.predator_color = predator_color\n", + " self.pred_eating_range = pred_eating_range\n", + "\n", + " def init_state(self) -> State:\n", + " key = random.PRNGKey(self.seed)\n", + " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", + "\n", + " entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations)\n", + " objects = self.init_objects()\n", + "\n", + " # Added agent types for prey and predators\n", + " agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value)))\n", + " agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0)\n", + " behaviors = jnp.hstack((jnp.full(self.n_preys, behavior_name_map['FEAR']), jnp.full(self.n_predators, behavior_name_map['AGGRESSION'])))\n", + "\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(self.max_agents, dtype=int),\n", + " agent_type=agent_types, \n", + " prox=jnp.zeros((self.max_agents, 2)),\n", + " motor=jnp.zeros((self.max_agents, 2)),\n", + " behavior=behaviors,\n", + " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", + " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", + " max_speed=jnp.full((self.max_agents), self.max_speed),\n", + " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", + " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", + " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", + " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", + " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", + " color=agents_colors\n", + " )\n", + "\n", + " state = self.init_complete_state(entities, agents, objects)\n", + " # Create jax_md attributes for environment physics\n", + " state = self.init_env_physics(key, state)\n", + "\n", + " self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n", + " self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n", + " self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n", + "\n", + " return state\n", + " \n", + " def can_all_be_eaten(self, R_prey, R_predators, predator_exist):\n", + " # Could maybe create this as a method in the class, or above idk\n", + " distance_to_all_preds = vmap(self.distance, in_axes=(None, 0))\n", + "\n", + " # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above \n", + " def can_be_eaten(R_prey, R_predators, predator_exist):\n", + " dist_to_preds = distance_to_all_preds(R_prey, R_predators)\n", + " in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0)\n", + " # Could also return which agent ate the other one (e.g to increase their energy) \n", + " will_be_eaten_by = in_range * predator_exist\n", + " eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0)\n", + "\n", + " return eaten_or_not\n", + " \n", + " can_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None))\n", + " \n", + " return can_be_eaten(R_prey, R_predators, predator_exist)\n", + " \n", + " def eat_preys(self, state):\n", + " # See which preys can be eaten by predators and update the exists array accordingly\n", + " R = state.entities.position.center\n", + " exist = state.entities.exists\n", + " prey_idx = self.prey_idx\n", + " pred_idx = self.pred_idx\n", + "\n", + " agents_ent_idx = state.agents.ent_idx\n", + " predator_exist = exist[agents_ent_idx][pred_idx]\n", + " can_be_eaten_idx = self.can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist)\n", + "\n", + " # Kill the agents that are being eaten\n", + " exist_prey = exist[agents_ent_idx[prey_idx]]\n", + " new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey)\n", + " exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey)\n", + "\n", + " return exist\n", + "\n", + " @partial(jit, static_argnums=(0,))\n", + " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n", + " # 1 Compute which agents are being eaten\n", + " exist = self.eat_preys(state)\n", + " entities = state.entities.replace(exists=exist)\n", + "\n", + " # 2 Compute the proximeter of agents\n", + " exists_mask = jnp.where(entities.exists == 1, 1, 0)\n", + " prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n", + " motor = sensorimotor(prox, state.agents.behavior, state.agents.motor)\n", + " agents = state.agents.replace(\n", + " prox=prox, \n", + " proximity_map_dist=proximity_dist_map, \n", + " proximity_map_theta=proximity_dist_theta,\n", + " motor=motor\n", + " )\n", + "\n", + " # 3 Update the state with the new agent and entities states\n", + " state = state.replace(\n", + " agents=agents,\n", + " entities=entities\n", + " )\n", + "\n", + " # 4 Apply physics forces to the environment state\n", + " entities = self.apply_physics(state, neighbors)\n", + " state = state.replace(\n", + " time=state.time+1,\n", + " entities=entities,\n", + " )\n", + "\n", + " # 5 Update the neighbors according to the new positions\n", + " neighbors = neighbors.update(state.entities.position.center)\n", + " return state, neighbors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create env and render its state" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from vivarium.experimental.environments.braitenberg.utils import render, render_history" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "env = PreyPredBraitenbergEnv()\n", + "state = env.init_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Prey agents: blue\n", + "- Predator agents: red\n", + "- Objects: green" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run a simulation on a few timesteps" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "n_steps = 2000\n", + "\n", + "hist = []\n", + "for i in range(n_steps):\n", + " state = env.step(state)\n", + " hist.append(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=10)\n", + "\n", + "# The rendering function is quite laggy, I'll change it later (but at the moment it works to test the environments rapidly)" + ] + } + ], + "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 +} diff --git a/vivarium/experimental/notebooks/simple_braitenberg.ipynb b/vivarium/experimental/notebooks/simple_braitenberg.ipynb new file mode 100644 index 0000000..22751fc --- /dev/null +++ b/vivarium/experimental/notebooks/simple_braitenberg.ipynb @@ -0,0 +1,225 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-06-03 15:31:30.391184: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv\n", + "from vivarium.experimental.environments.braitenberg.utils import render, render_history" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "env = BraitenbergEnv()\n", + "state = env.init_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "n_steps = 1000\n", + "hist = []\n", + "\n", + "for i in range(n_steps):\n", + " state = env.step(state)\n", + " hist.append(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render_history(hist, skip_frames=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scale the size of the simulation\n", + "\n", + "Launch a simulation with a bigger box size, as well as more agents and objects." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:NEIGHBORS BUFFER OVERFLOW at step 3846: rebuilding neighbors\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulation ran in 13.888845541001501 for 20000 timesteps\n" + ] + } + ], + "source": [ + "env = BraitenbergEnv(\n", + " box_size=1000,\n", + " max_agents=100,\n", + " max_objects=50,\n", + " existing_agents=90,\n", + " existing_objects=30,\n", + " prox_dist_max=100\n", + ") \n", + " \n", + "state = env.init_state() \n", + "\n", + "n_steps = 20_000\n", + "\n", + "hist = []\n", + "\n", + "start = time.perf_counter()\n", + "for i in range(n_steps):\n", + " state = env.step(state) \n", + " hist.append(state)\n", + "end = time.perf_counter()\n", + "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "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": [ + "## Test neighbors rebuilding time\n", + "\n", + "In the last run we see that there is a rebuilding of neighbors. To test (really roughly) how long it took, we just reduce the prox_dist_max of agents (set it to 10 which is really small). This way the original neighbor lists are the same, and because most of the agents will remain static and there won't be neighbor buffer overflow. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulation ran in 12.980394261001493 for 20000 timesteps\n" + ] + } + ], + "source": [ + "env = BraitenbergEnv(box_size=1000,\n", + " max_agents=100,\n", + " max_objects=50,\n", + " existing_agents=90,\n", + " existing_objects=30,\n", + " prox_dist_max=10) \n", + " \n", + "state = env.init_state() \n", + "\n", + "hist = []\n", + "\n", + "start = time.perf_counter()\n", + "for i in range(n_steps):\n", + " state = env.step(state) \n", + " hist.append(state)\n", + "end = time.perf_counter()\n", + "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + ] + } + ], + "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 +} From ef91d33b357792878e76ca21b73790d708a87fae Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 4 Jun 2024 19:30:39 +0200 Subject: [PATCH 08/18] Add first steps of sensorimotor functions refactoring --- .../braitenberg/refactor_sensors.py | 512 ++++++++++++++++++ 1 file changed, 512 insertions(+) create mode 100644 vivarium/experimental/environments/braitenberg/refactor_sensors.py diff --git a/vivarium/experimental/environments/braitenberg/refactor_sensors.py b/vivarium/experimental/environments/braitenberg/refactor_sensors.py new file mode 100644 index 0000000..51e73dc --- /dev/null +++ b/vivarium/experimental/environments/braitenberg/refactor_sensors.py @@ -0,0 +1,512 @@ +import logging as lg +from enum import Enum +from functools import partial +from typing import Tuple + +import numpy as np +import jax.numpy as jnp + +from jax import vmap, jit +from jax import random, ops, lax + +from flax import struct +from jax_md.rigid_body import RigidBody +from jax_md import space, rigid_body, partition, quantity + +from vivarium.experimental.environments.braitenberg.utils import normal +from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv +from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn + +### Define the constants and the classes of the environment to store its state ### + +SPACE_NDIMS = 2 + +# TODO : Should maybe just let the user define its own class and just have a base class State with time ... +class EntityType(Enum): + AGENT = 0 + OBJECT = 1 + +@struct.dataclass +class EntityState(BaseEntityState): + pass + +@struct.dataclass +class AgentState(BaseAgentState): + prox: jnp.array + motor: jnp.array + proximity_map_dist: jnp.array + proximity_map_theta: jnp.array + behavior: jnp.array + params: 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(BaseObjectState): + pass + +@struct.dataclass +class State(BaseState): + time: jnp.int32 + box_size: jnp.int32 + 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 + entities: EntityState + agents: AgentState + objects: ObjectState + +### Define helper functions used to step from one state to the next one ### + + +#--- 1 Functions to compute the proximeter of braitenberg agents ---# + +def relative_position(displ, theta): + """ + Compute the relative distance and angle from a source agent to a target agent + :param displ: Displacement vector (jnp arrray with shape (2,) from source to target + :param theta: Orientation of the source agent (in the reference frame of the map) + :return: dist: distance from source to target. + relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) + """ + dist = jnp.linalg.norm(displ) + norm_displ = displ / dist + theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) + relative_theta = theta_displ - theta + return dist, relative_theta + +proximity_map = vmap(relative_position, (0, 0)) + +# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority) +def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): + """ + Compute the proximeter activations (left, right) induced by the presence of an entity + :param dist: distance from the agent to the entity + :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) + :param dist_max: Max distance of the proximiter (will return 0. above this distance) + :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) + :return: left and right proximeter activation in a jnp array with shape (2,) + """ + cos_dir = jnp.cos(relative_theta) + prox = 1. - (dist / dist_max) + in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) + at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) + left = in_view * at_left * prox + right = in_view * (1. - at_left) * prox + return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist + +sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) + +def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): + raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) + # Computes the maximum within the proximeter activations of agents on all their neigbhors. + proxs = ops.segment_max( + raw_proxs, + senders, + max_agents) + + return proxs + +# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) +def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): + """ + Set agents' proximeter activations + :param state: full simulation State + :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), + where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. + :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). + target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). + :return: + """ + body = state.entities.position + mask = target_exists_mask[agents_neighs_idx[1, :]] + senders, receivers = agents_neighs_idx + Ra = body.center[senders] + Rb = body.center[receivers] + dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why + + # Create distance and angle maps between entities + 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) + + # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) + prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], + state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) + + # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) + return prox, proximity_map_dist, proximity_map_theta + + +#--- 2 Functions to compute the motor activations of braitenberg agents ---# + +# TODO : See how we'll handle this on client side +class Behaviors(Enum): + FEAR = 0 + AGGRESSION = 1 + LOVE = 2 + SHY = 3 + NOOP = 4 + MANUAL = 5 + +# TODO : Could find a better name than params ? Or can be good enough +behavior_params = { + Behaviors.FEAR.value: jnp.array( + [[1., 0., 0.], + [0., 1., 0.]]), + Behaviors.AGGRESSION.value: jnp.array( + [[0., 1., 0.], + [1., 0., 0.]]), + Behaviors.LOVE.value: jnp.array( + [[-1., 0., 1.], + [0., -1., 1.]]), + Behaviors.SHY.value: jnp.array( + [[0., -1., 1.], + [-1., 0., 1.]]), + Behaviors.NOOP.value: jnp.array( + [[0., 0., 0.], + [0., 0., 0.]]), +} + +def behavior_to_params(behavior): + return behavior_params[behavior] + +def compute_motor(proxs, params): + """Compute motor values according to proximeter values and "params" + + :param proxs: _description_ + :param params: _description_ + :return: _description_ + """ + return params.dot(jnp.hstack((proxs, 1.))) + +sensorimotor = vmap(compute_motor, in_axes=(0, 0)) + +def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): + fwd = (wheel_diameter / 4.) * (left_spd + right_spd) + rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) + return fwd, rot + +def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): + left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter + right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter + return left, right + +def motor_command(wheel_activation, base_length, wheel_diameter): + fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) + return fwd, rot + +motor_command = vmap(motor_command, (0, 0, 0)) + + +#--- 3 Functions to compute the different forces in the environment ---# + +# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces +def braintenberg_force_fn(displacement): + coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) + + def collision_force(state, neighbor, exists_mask): + return coll_force_fn( + state.entities.position.center, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + + def motor_force(state, exists_mask): + agent_idx = state.agents.ent_idx + + body = rigid_body.RigidBody( + center=state.entities.position.center[agent_idx], + orientation=state.entities.position.orientation[agent_idx] + ) + + n = normal(body.orientation) + + fwd, rot = motor_command( + state.agents.motor, + state.entities.diameter[agent_idx], + state.agents.wheel_diameter + ) + # `a_max` arg is deprecated in recent versions of jax, replaced by `max` + fwd = jnp.clip(fwd, a_max=state.agents.max_speed) + + cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] + cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) + cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] + + fwd_delta = fwd - cur_fwd_vel + rot_delta = rot - cur_rot_vel + + fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T + rot_force = rot_delta * state.agents.theta_mul + + center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) + orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) + + # apply mask to make non existing agents stand still + orientation = jnp.where(exists_mask, orientation, 0.) + # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, center, 0.) + + return rigid_body.RigidBody(center=center, + orientation=orientation) + + def force_fn(state, neighbor, exists_mask): + mf = motor_force(state, exists_mask) + cf = collision_force(state, neighbor, exists_mask) + ff = friction_force(state, exists_mask) + + center = cf + ff + mf.center + orientation = mf.orientation + return rigid_body.RigidBody(center=center, orientation=orientation) + + return force_fn + + +#--- 4 Define the environment class with its different functions (init_state, _step ...) ---# + +class BraitenbergEnv(BaseEnv): + def __init__( + self, + box_size=100, + dt=0.1, + max_agents=10, + max_objects=2, + neighbor_radius=100., + collision_alpha=0.5, + collision_eps=0.1, + n_dims=2, + seed=0, + diameter=5.0, + friction=0.1, + mass_center=1.0, + mass_orientation=0.125, + existing_agents=10, + existing_objects=2, + behaviors=Behaviors.AGGRESSION.value, + 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, + agents_color=jnp.array([0.0, 0.0, 1.0]), + objects_color=jnp.array([1.0, 0.0, 0.0]) + ): + + # TODO : add docstrings + # general parameters + self.box_size = box_size + self.dt = dt + self.max_agents = max_agents + self.max_objects = max_objects + self.neighbor_radius = neighbor_radius + self.collision_alpha = collision_alpha + self.collision_eps = collision_eps + self.n_dims = n_dims + self.seed = seed + # entities parameters + self.diameter = diameter + self.friction = friction + self.mass_center = mass_center + self.mass_orientation = mass_orientation + self.existing_agents = existing_agents + self.existing_objects = existing_objects + # agents parameters + self.behaviors = behaviors + self.wheel_diameter = wheel_diameter + self.speed_mul = speed_mul + self.max_speed = max_speed + self.theta_mul = theta_mul + self.prox_dist_max = prox_dist_max + self.prox_cos_min = prox_cos_min + self.agents_color = agents_color + # objects parameters + self.objects_color = objects_color + # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? + # Or can also directly initialize the state ... and jax_md attributes in this function too ... + + def init_state(self) -> State: + key = random.PRNGKey(self.seed) + key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) + + entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) + agents = self.init_agents() + objects = self.init_objects() + state = self.init_complete_state(entities, agents, objects) + + # Create jax_md attributes for environment physics + # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes) + state = self.init_env_physics(key, state) + + return state + + def distance(self, point1, point2): + diff = self.displacement(point1, point2) + squared_diff = jnp.sum(jnp.square(diff)) + return jnp.sqrt(squared_diff) + + # TODO See how to clean the function to remove the agents_neighs_idx + @partial(jit, static_argnums=(0,)) + def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: + # 1 : Compute agents proximeter + exists_mask = jnp.where(state.entities.exists == 1, 1, 0) + prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement) + + # 2 : Compute motor activations according to new proximeter values + motor = sensorimotor(prox, state.agents.params) + agents = state.agents.replace( + prox=prox, + proximity_map_dist=proximity_dist_map, + proximity_map_theta=proximity_dist_theta, + motor=motor + ) + + # 3 : Update the state with new agents proximeter and motor values + state = state.replace(agents=agents) + + # 4 : Move the entities by applying forces on them (collision, friction and motor forces for agents) + entities = self.apply_physics(state, neighbors) + state = state.replace(time=state.time+1, entities=entities) + + # 5 : Update neighbors + neighbors = neighbors.update(state.entities.position.center) + return state, neighbors + + def step(self, state: State) -> State: + current_state = state + state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx) + + if self.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') + neighbors = self.allocate_neighbors(state) + assert not neighbors.did_buffer_overflow + + self.neighbors = neighbors + return state + + # TODO See how we deal with agents_neighs_idx + def allocate_neighbors(self, state, position=None): + position = state.entities.position.center if position is None else position + neighbors = self.neighbor_fn.allocate(position) + + # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here) + ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value + self.agents_neighs_idx = neighbors.idx[:, ag_idx] + + return neighbors + + # TODO : Modify these functions so can give either 1 param and apply it to every entity or give custom ones + def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): + n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size + objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) + object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) + exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) + exists = jnp.concatenate((exists_agents, exists_objects), 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), + entity_type=entity_types, + entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), + diameter=jnp.full((n_entities), self.diameter), + friction=jnp.full((n_entities), self.friction), + exists=exists + ) + + def init_agents(self): + # TODO : Change that so can define custom behaviors (e.g w a list) + # Use numpy cuz jnp elements cannot be keys of a dict + behaviors = np.full((self.max_agents), self.behaviors) + # Cannot use a vmap fn because of dictionary, cannot have jax elements as a key because its unhashable + params = jnp.array([behavior_to_params(behavior) for behavior in behaviors]) + return AgentState( + # idx in the entities (ent_idx) state to map agents information in the different data structures + ent_idx=jnp.arange(self.max_agents, dtype=int), + prox=jnp.zeros((self.max_agents, 2)), + motor=jnp.zeros((self.max_agents, 2)), + behavior=behaviors, + params=params, + wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), + speed_mul=jnp.full((self.max_agents), self.speed_mul), + max_speed=jnp.full((self.max_agents), self.max_speed), + theta_mul=jnp.full((self.max_agents), self.theta_mul), + proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), + proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), + proximity_map_dist=jnp.zeros((self.max_agents, 1)), + proximity_map_theta=jnp.zeros((self.max_agents, 1)), + color=jnp.tile(self.agents_color, (self.max_agents, 1)) + ) + + def init_objects(self): + # Entities idx of objects + start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects + objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) + + return ObjectState( + ent_idx=objects_ent_idx, + color=jnp.tile(self.objects_color, (self.max_objects, 1)) + ) + + def init_complete_state(self, entities, agents, objects): + lg.info('Initializing state') + return State( + time=0, + box_size=self.box_size, + max_agents=self.max_agents, + max_objects=self.max_objects, + neighbor_radius=self.neighbor_radius, + collision_alpha=self.collision_alpha, + collision_eps=self.collision_eps, + dt=self.dt, + entities=entities, + agents=agents, + objects=objects + ) + + def init_env_physics(self, key, state): + lg.info("Initializing environment's physics features") + key, physics_key = random.split(key) + self.displacement, self.shift = space.periodic(self.box_size) + self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) + self.neighbor_fn = partition.neighbor_list( + self.displacement, + self.box_size, + r_cutoff=self.neighbor_radius, + dr_threshold=10., + capacity_multiplier=1.5, + format=partition.Sparse + ) + + state = self.init_fn(state, physics_key) + lg.info("Allocating neighbors") + neighbors = self.allocate_neighbors(state) + self.neighbors = neighbors + + return state From 79f6d170390ff4182b91b91eb2828e08113abfcb Mon Sep 17 00:00:00 2001 From: corentinlger Date: Wed, 12 Jun 2024 17:07:11 +0200 Subject: [PATCH 09/18] Add first draft version of selective sensors braitenberg env --- .../braitenberg/selective_sensors.py | 626 ++++++++++++++++++ 1 file changed, 626 insertions(+) create mode 100644 vivarium/experimental/environments/braitenberg/selective_sensors.py diff --git a/vivarium/experimental/environments/braitenberg/selective_sensors.py b/vivarium/experimental/environments/braitenberg/selective_sensors.py new file mode 100644 index 0000000..6949c32 --- /dev/null +++ b/vivarium/experimental/environments/braitenberg/selective_sensors.py @@ -0,0 +1,626 @@ +# TODO : Remove that (just comes from a jax_md error where gpu isn't detected anymore) +import os +os.environ["JAX_PLATFORMS"] = "cpu" + +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 + +from jax import vmap, jit +from jax import random, ops, lax + +from flax import struct +from jax_md.rigid_body import RigidBody +from jax_md import space, rigid_body, partition, quantity + +from vivarium.experimental.environments.braitenberg.utils import normal +from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv +from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn + +### Define the constants and the classes of the environment to store its state ### + +SPACE_NDIMS = 2 + +# TODO : Should maybe just let the user define its own class and just have a base class State with time ... +class EntityType(Enum): + AGENT = 0 + OBJECT = 1 + +# TODO : See if really usefull +# @struct.dataclass +# class BehaviorMap: +# params: jnp.array +# sensed: jnp.array + +@struct.dataclass +class EntityState(BaseEntityState): + pass + +@struct.dataclass +class AgentState(BaseAgentState): + prox: jnp.array + motor: jnp.array + proximity_map_dist: jnp.array + proximity_map_theta: jnp.array + behavior: jnp.array + params: 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(BaseObjectState): + pass + +@struct.dataclass +class State(BaseState): + time: jnp.int32 + box_size: jnp.int32 + 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 + entities: EntityState + agents: AgentState + objects: ObjectState + +### Define helper functions used to step from one state to the next one ### + + +#--- 2 Functions to compute the motor activations of braitenberg agents ---# + +# TODO : See how we'll handle this on client side +class Behaviors(Enum): + FEAR = 0 + AGGRESSION = 1 + LOVE = 2 + SHY = 3 + NOOP = 4 + MANUAL = 5 + +# TODO : Could find a better name than params ? Or can be good enough +behavior_params = { + Behaviors.FEAR.value: jnp.array( + [[1., 0., 0.], + [0., 1., 0.]]), + Behaviors.AGGRESSION.value: jnp.array( + [[0., 1., 0.], + [1., 0., 0.]]), + Behaviors.LOVE.value: jnp.array( + [[-1., 0., 1.], + [0., -1., 1.]]), + Behaviors.SHY.value: jnp.array( + [[0., -1., 1.], + [-1., 0., 1.]]), + Behaviors.NOOP.value: jnp.array( + [[0., 0., 0.], + [0., 0., 0.]]), +} + +def behavior_to_params(behavior): + return behavior_params[behavior] + +def compute_motor(proxs, params): + """Compute motor values according to proximeter values and "params" + + :param proxs: _description_ + :param params: _description_ + :return: _description_ + """ + return params.dot(jnp.hstack((proxs, 1.))) + +sensorimotor = vmap(compute_motor, in_axes=(0, 0)) + +def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): + fwd = (wheel_diameter / 4.) * (left_spd + right_spd) + rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) + return fwd, rot + +def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): + left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter + right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter + return left, right + +def motor_command(wheel_activation, base_length, wheel_diameter): + fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) + return fwd, rot + +motor_command = vmap(motor_command, (0, 0, 0)) + + +#--- 3 Functions to compute the different forces in the environment ---# + +# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces +def braintenberg_force_fn(displacement): + coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) + + def collision_force(state, neighbor, exists_mask): + return coll_force_fn( + state.entities.position.center, + neighbor=neighbor, + exists_mask=exists_mask, + diameter=state.entities.diameter, + epsilon=state.collision_eps, + alpha=state.collision_alpha + ) + + def motor_force(state, exists_mask): + agent_idx = state.agents.ent_idx + + body = rigid_body.RigidBody( + center=state.entities.position.center[agent_idx], + orientation=state.entities.position.orientation[agent_idx] + ) + + n = normal(body.orientation) + + fwd, rot = motor_command( + state.agents.motor, + state.entities.diameter[agent_idx], + state.agents.wheel_diameter + ) + # `a_max` arg is deprecated in recent versions of jax, replaced by `max` + fwd = jnp.clip(fwd, a_max=state.agents.max_speed) + + cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] + cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) + cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] + + fwd_delta = fwd - cur_fwd_vel + rot_delta = rot - cur_rot_vel + + fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T + rot_force = rot_delta * state.agents.theta_mul + + center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) + orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) + + # apply mask to make non existing agents stand still + orientation = jnp.where(exists_mask, orientation, 0.) + # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center + exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) + center = jnp.where(exists_mask, center, 0.) + + return rigid_body.RigidBody(center=center, + orientation=orientation) + + def force_fn(state, neighbor, exists_mask): + mf = motor_force(state, exists_mask) + cf = collision_force(state, neighbor, exists_mask) + ff = friction_force(state, exists_mask) + + center = cf + ff + mf.center + orientation = mf.orientation + return rigid_body.RigidBody(center=center, orientation=orientation) + + return force_fn + + +#--- 1 Functions to compute the proximeter of braitenberg agents ---# + +def relative_position(displ, theta): + """ + Compute the relative distance and angle from a source agent to a target agent + :param displ: Displacement vector (jnp arrray with shape (2,) from source to target + :param theta: Orientation of the source agent (in the reference frame of the map) + :return: dist: distance from source to target. + relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) + """ + dist = jnp.linalg.norm(displ) + norm_displ = displ / dist + theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) + relative_theta = theta_displ - theta + return dist, relative_theta + +proximity_map = vmap(relative_position, (0, 0)) + +# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here +def get_relative_displacement(state, agents_neighs_idx, displacement_fn): + 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 + +# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority) +def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): + """ + Compute the proximeter activations (left, right) induced by the presence of an entity + :param dist: distance from the agent to the entity + :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) + :param dist_max: Max distance of the proximiter (will return 0. above this distance) + :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) + :return: left and right proximeter activation in a jnp array with shape (2,) + """ + cos_dir = jnp.cos(relative_theta) + prox = 1. - (dist / dist_max) + in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) + at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) + left = in_view * at_left * prox + right = in_view * (1. - at_left) * prox + return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist + +sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) + +def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): + jax.debug.print("Before sensor_fn") + jax.debug.print("dist.shape = {x}", x=dist.shape) + jax.debug.print("relative_theta.shape = {x}", x=relative_theta.shape) + jax.debug.print("dist_max.shape = {x}", x=dist_max.shape) + jax.debug.print("cos_min.shape = {x}", x=cos_min.shape) + jax.debug.print("raw_proxs.target_exists = {x}", x=target_exists.shape) + + raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) + jax.debug.print("raw_proxs.shape = {x}", x=raw_proxs.shape) + + # Computes the maximum within the proximeter activations of agents on all their neigbhors. + proxs = ops.segment_max( + raw_proxs, + senders, + max_agents) + + return proxs + + +# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) +def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): + """ + Set agents' proximeter activations + :param state: full simulation State + :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), + where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. + :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). + target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). + :return: + """ + body = state.entities.position + senders, receivers = agents_neighs_idx + Ra = body.center[senders] + Rb = body.center[receivers] + dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why + + # Create distance and angle maps between entities + 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) + + # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) + mask = target_exists_mask[agents_neighs_idx[1, :]] + prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], + state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) + + # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) + return prox, proximity_map_dist, proximity_map_theta + +### New functions for selective sensors #### + +def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx): + mask = jnp.where(state.entities.entity_type[ent_target_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_target_idx): + return agent_raw_proxs + +# TODO : Use a fori_loop on this later +def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities): + for ent_type_id, sensed in enumerate(sensed_entities): + agent_raw_proxs = jax.lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx) + proxs = jnp.max(agent_raw_proxs, axis=0) + + return proxs + +### TODO 1 : +def compute_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_idx): + behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed) + behavior_motors = compute_motor(behavior_prox, params) + return behavior_prox, behavior_motors + +compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, None, None)) + +def compute_agent_proxs_motors(state, agent_idx, params, sensed, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers): + ent_ag_idx = ag_idx_dense_senders[agent_idx] + ent_target_idx = ag_idx_dense_receivers[agent_idx] + agent_raw_proxs = raw_proxs[ent_ag_idx] + + agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_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, None, None, None)) + + +class SelectiveSensorsBraitenbergEnv(BaseEnv): + def __init__( + self, + box_size=100, + dt=0.1, + max_agents=10, + max_objects=2, + neighbor_radius=100., + collision_alpha=0.5, + collision_eps=0.1, + n_dims=2, + seed=0, + diameter=5.0, + friction=0.1, + mass_center=1.0, + mass_orientation=0.125, + existing_agents=10, + existing_objects=2, + behaviors=Behaviors.AGGRESSION.value, + 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, + agents_color=jnp.array([0.0, 0.0, 1.0]), + objects_color=jnp.array([1.0, 0.0, 0.0]) + ): + + # TODO : add docstrings + # general parameters + self.box_size = box_size + self.dt = dt + self.max_agents = max_agents + self.max_objects = max_objects + self.neighbor_radius = neighbor_radius + self.collision_alpha = collision_alpha + self.collision_eps = collision_eps + self.n_dims = n_dims + self.seed = seed + # entities parameters + self.diameter = diameter + self.friction = friction + self.mass_center = mass_center + self.mass_orientation = mass_orientation + self.existing_agents = existing_agents + self.existing_objects = existing_objects + # agents parameters + self.behaviors = behaviors + self.wheel_diameter = wheel_diameter + self.speed_mul = speed_mul + self.max_speed = max_speed + self.theta_mul = theta_mul + self.prox_dist_max = prox_dist_max + self.prox_cos_min = prox_cos_min + self.agents_color = agents_color + # objects parameters + self.objects_color = objects_color + # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? + # Or can also directly initialize the state ... and jax_md attributes in this function too ... + + def init_state(self) -> State: + key = random.PRNGKey(self.seed) + key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) + + entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) + agents = self.init_agents() + objects = self.init_objects() + state = self.init_complete_state(entities, agents, objects) + + # Create jax_md attributes for environment physics + # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes) + state = self.init_env_physics(key, state) + + return state + + def distance(self, point1, point2): + diff = self.displacement(point1, point2) + squared_diff = jnp.sum(jnp.square(diff)) + return jnp.sqrt(squared_diff) + + # TODO See how to clean the function to remove the agents_neighs_idx + @partial(jit, static_argnums=(0,)) + def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]: + + ### Hardcoded behaviors for agents at the moment (aggr towards objects and fear towards agents) + params_1 = behavior_to_params(Behaviors.AGGRESSION.value) + params_2 = behavior_to_params(Behaviors.FEAR.value) + sensed_1 = jnp.array([0, 1]) + sensed_2 = jnp.array([1, 0]) + params = jnp.array([params_1, params_2]) + sensed = jnp.array([sensed_1, sensed_2]) + + # Do like if we had batches of params and sensed entities for all agents + batch_params = jnp.tile(params[None], (self.max_agents, 1, 1 ,1)) + batch_sensed = jnp.tile(sensed[None], (self.max_agents, 1, 1)) + ### + + 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] + targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]] + raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask) + + # TODO : 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 = compute_all_agents_proxs_motors( + state, + state.agents.ent_idx, + batch_params, + batch_sensed, + raw_proxs, + ag_idx_dense_senders, + ag_idx_dense_receivers, + ) + + # print(f"{agent_proxs = }") + # print(f"{mean_agent_motors = }") + + # TODO : Relou de rajouter les proximeters non ? En vrai non juste un array de proximeters pour chaque agent + 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: + current_state = state + state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense) + + if self.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') + neighbors = self.allocate_neighbors(state) + assert not neighbors.did_buffer_overflow + + self.neighbors = neighbors + return state + + # TODO See how we deal with agents_neighs_idx + def allocate_neighbors(self, state, position=None): + position = state.entities.position.center if position is None else position + neighbors = self.neighbor_fn.allocate(position) + + # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here) + ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value + self.agents_neighs_idx = neighbors.idx[:, ag_idx] + agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(self.max_agents)]) + # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)]) + agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders] + # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)]) + self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers + return neighbors + + # TODO : Modify these functions so can give either 1 param and apply it to every entity or give custom ones + def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): + n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size + objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) + object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) + exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) + exists = jnp.concatenate((exists_agents, exists_objects), 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), + entity_type=entity_types, + entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), + diameter=jnp.full((n_entities), self.diameter), + friction=jnp.full((n_entities), self.friction), + exists=exists + ) + + def init_agents(self): + # TODO : Change that so can define custom behaviors (e.g w a list) + # Use numpy cuz jnp elements cannot be keys of a dict + behaviors = np.full((self.max_agents), self.behaviors) + # Cannot use a vmap fn because of dictionary, cannot have jax elements as a key because its unhashable + params = jnp.array([behavior_to_params(behavior) for behavior in behaviors]) + return AgentState( + # idx in the entities (ent_idx) state to map agents information in the different data structures + ent_idx=jnp.arange(self.max_agents, dtype=int), + prox=jnp.zeros((self.max_agents, 2)), + motor=jnp.zeros((self.max_agents, 2)), + behavior=behaviors, + params=params, + wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), + speed_mul=jnp.full((self.max_agents), self.speed_mul), + max_speed=jnp.full((self.max_agents), self.max_speed), + theta_mul=jnp.full((self.max_agents), self.theta_mul), + proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), + proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), + proximity_map_dist=jnp.zeros((self.max_agents, 1)), + proximity_map_theta=jnp.zeros((self.max_agents, 1)), + color=jnp.tile(self.agents_color, (self.max_agents, 1)) + ) + + def init_objects(self): + # Entities idx of objects + start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects + objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) + + return ObjectState( + ent_idx=objects_ent_idx, + color=jnp.tile(self.objects_color, (self.max_objects, 1)) + ) + + def init_complete_state(self, entities, agents, objects): + lg.info('Initializing state') + return State( + time=0, + box_size=self.box_size, + max_agents=self.max_agents, + max_objects=self.max_objects, + neighbor_radius=self.neighbor_radius, + collision_alpha=self.collision_alpha, + collision_eps=self.collision_eps, + dt=self.dt, + entities=entities, + agents=agents, + objects=objects + ) + + def init_env_physics(self, key, state): + lg.info("Initializing environment's physics features") + key, physics_key = random.split(key) + self.displacement, self.shift = space.periodic(self.box_size) + self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) + self.neighbor_fn = partition.neighbor_list( + self.displacement, + self.box_size, + r_cutoff=self.neighbor_radius, + dr_threshold=10., + capacity_multiplier=1.5, + format=partition.Sparse + ) + + state = self.init_fn(state, physics_key) + lg.info("Allocating neighbors") + neighbors = self.allocate_neighbors(state) + self.neighbors = neighbors + + return state + + +env = SelectiveSensorsBraitenbergEnv() +state = env.init_state() +state = env.step(state) +state = env.step(state) +state = env.step(state) +state = env.step(state) \ No newline at end of file From d7914c66f882ba0a69e281bb3e242a48a5d4cfb3 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 17 Jun 2024 17:14:23 +0200 Subject: [PATCH 10/18] Refactor simple braitenberg env and add utils file for all environments --- .../environments/braitenberg/simple.py | 98 ++++++++----------- vivarium/experimental/environments/utils.py | 37 +++++++ 2 files changed, 79 insertions(+), 56 deletions(-) create mode 100644 vivarium/experimental/environments/utils.py diff --git a/vivarium/experimental/environments/braitenberg/simple.py b/vivarium/experimental/environments/braitenberg/simple.py index 63e3c73..fa1ed29 100644 --- a/vivarium/experimental/environments/braitenberg/simple.py +++ b/vivarium/experimental/environments/braitenberg/simple.py @@ -1,4 +1,5 @@ import logging as lg + from enum import Enum from functools import partial from typing import Tuple @@ -10,27 +11,38 @@ from flax import struct from jax_md.rigid_body import RigidBody +from jax_md import simulate from jax_md import space, rigid_body, partition, quantity -from vivarium.experimental.environments.braitenberg.utils import normal -from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv +from vivarium.experimental.environments.utils import normal, distance, relative_position +from vivarium.experimental.environments.base_env import BaseState, BaseEnv from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn ### Define the constants and the classes of the environment to store its state ### SPACE_NDIMS = 2 -# TODO : Should maybe just let the user define its own class and just have a base class State with time ... +# TODO : The best is surely to only define BaseState because some envs might not use EntityState / ObjectState or AgentState class EntityType(Enum): AGENT = 0 OBJECT = 1 +# Already incorporates position, momentum, force, mass and velocity @struct.dataclass -class EntityState(BaseEntityState): - pass +class EntityState(simulate.NVEState): + entity_type: jnp.array + entity_idx: jnp.array + diameter: jnp.array + friction: jnp.array + exists: jnp.array @struct.dataclass -class AgentState(BaseAgentState): +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 @@ -44,13 +56,11 @@ class AgentState(BaseAgentState): proxs_cos_min: jnp.array @struct.dataclass -class ObjectState(BaseObjectState): +class ObjectState(ParticleState): pass @struct.dataclass class State(BaseState): - time: jnp.int32 - box_size: jnp.int32 max_agents: jnp.int32 max_objects: jnp.int32 neighbor_radius: jnp.float32 @@ -61,28 +71,15 @@ class State(BaseState): agents: AgentState objects: ObjectState + ### Define helper functions used to step from one state to the next one ### #--- 1 Functions to compute the proximeter of braitenberg agents ---# -def relative_position(displ, theta): - """ - Compute the relative distance and angle from a source agent to a target agent - :param displ: Displacement vector (jnp arrray with shape (2,) from source to target - :param theta: Orientation of the source agent (in the reference frame of the map) - :return: dist: distance from source to target. - relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) - """ - dist = jnp.linalg.norm(displ) - norm_displ = displ / dist - theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) - relative_theta = theta_displ - theta - return dist, relative_theta proximity_map = vmap(relative_position, (0, 0)) -# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority) def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): """ Compute the proximeter activations (left, right) induced by the presence of an entity @@ -107,12 +104,11 @@ def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_ # Computes the maximum within the proximeter activations of agents on all their neigbhors. proxs = ops.segment_max( raw_proxs, - senders, + senders, max_agents) return proxs -# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): """ Set agents' proximeter activations @@ -137,11 +133,9 @@ def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): 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) - # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) - # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) return prox, proximity_map_dist, proximity_map_theta @@ -295,8 +289,8 @@ def __init__( friction=0.1, mass_center=1.0, mass_orientation=0.125, - existing_agents=10, - existing_objects=2, + existing_agents=None, + existing_objects=None, behavior=behavior_name_map['AGGRESSION'], wheel_diameter=2.0, speed_mul=1.0, @@ -308,7 +302,6 @@ def __init__( objects_color=jnp.array([1.0, 0.0, 0.0]) ): - # TODO : add docstrings # general parameters self.box_size = box_size self.dt = dt @@ -324,8 +317,9 @@ def __init__( self.friction = friction self.mass_center = mass_center self.mass_orientation = mass_orientation - self.existing_agents = existing_agents - self.existing_objects = existing_objects + # Set existing objects and agents to max values if not specified + self.existing_agents = existing_agents if existing_agents else max_agents + self.existing_objects = existing_objects if existing_objects else max_objects # agents parameters self.behavior = behavior self.wheel_diameter = wheel_diameter @@ -337,30 +331,25 @@ def __init__( self.agents_color = agents_color # objects parameters self.objects_color = objects_color - # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? - # Or can also directly initialize the state ... and jax_md attributes in this function too ... def init_state(self) -> State: key = random.PRNGKey(self.seed) key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) - entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) - agents = self.init_agents() - objects = self.init_objects() - state = self.init_complete_state(entities, agents, objects) + entities = self._init_entities(key_agents_pos, key_objects_pos, key_orientations) + agents = self._init_agents() + objects = self._init_objects() + state = self._init_complete_state(entities, agents, objects) # Create jax_md attributes for environment physics # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes) - state = self.init_env_physics(key, state) + state = self._init_env_physics(key, state) return state def distance(self, point1, point2): - diff = self.displacement(point1, point2) - squared_diff = jnp.sum(jnp.square(diff)) - return jnp.sqrt(squared_diff) + return distance(self.displacement, point1, point2) - # TODO See how to clean the function to remove the agents_neighs_idx @partial(jit, static_argnums=(0,)) def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: # 1 : Compute agents proximeter @@ -394,24 +383,22 @@ def step(self, state: State) -> State: if self.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') - neighbors = self.allocate_neighbors(state) + neighbors, self.agents_neighs_idx = self.allocate_neighbors(state) assert not neighbors.did_buffer_overflow self.neighbors = neighbors return state - # TODO See how we deal with agents_neighs_idx def allocate_neighbors(self, state, position=None): - position = state.entities.position.center if position is None else position - neighbors = self.neighbor_fn.allocate(position) + neighbors = super().allocate_neighbors(state, position) # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here) ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value - self.agents_neighs_idx = neighbors.idx[:, ag_idx] + agents_neighs_idx = neighbors.idx[:, ag_idx] - return neighbors + return neighbors, agents_neighs_idx - def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): + def _init_entities(self, key_agents_pos, key_objects_pos, key_orientations): n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size @@ -440,7 +427,7 @@ def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): exists=exists ) - def init_agents(self): + def _init_agents(self): return AgentState( # idx in the entities (ent_idx) state to map agents information in the different data structures ent_idx=jnp.arange(self.max_agents, dtype=int), @@ -458,7 +445,7 @@ def init_agents(self): color=jnp.tile(self.agents_color, (self.max_agents, 1)) ) - def init_objects(self): + def _init_objects(self): # Entities idx of objects start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) @@ -468,7 +455,7 @@ def init_objects(self): color=jnp.tile(self.objects_color, (self.max_objects, 1)) ) - def init_complete_state(self, entities, agents, objects): + def _init_complete_state(self, entities, agents, objects): lg.info('Initializing state') return State( time=0, @@ -484,7 +471,7 @@ def init_complete_state(self, entities, agents, objects): objects=objects ) - def init_env_physics(self, key, state): + def _init_env_physics(self, key, state): lg.info("Initializing environment's physics features") key, physics_key = random.split(key) self.displacement, self.shift = space.periodic(self.box_size) @@ -500,7 +487,6 @@ def init_env_physics(self, key, state): state = self.init_fn(state, physics_key) lg.info("Allocating neighbors") - neighbors = self.allocate_neighbors(state) - self.neighbors = neighbors + self.neighbors, self.agents_neighs_idx = self.allocate_neighbors(state) return state diff --git a/vivarium/experimental/environments/utils.py b/vivarium/experimental/environments/utils.py new file mode 100644 index 0000000..466c4e7 --- /dev/null +++ b/vivarium/experimental/environments/utils.py @@ -0,0 +1,37 @@ +import jax.numpy as jnp +from jax import vmap + +@vmap +def normal(theta): + """Returns the cos and the sin of an angle + + :param theta: angle in radians + :return: cos and sin + """ + return jnp.array([jnp.cos(theta), jnp.sin(theta)]) + +def distance(displacement_fn, point1, point2): + """Returns the distance between two points + + :param displacement_fn: displacement function (typically a jax_md.space function) + :param point1: point 1 + :param point2: point 2 + :return: distance between the two points + """ + diff = displacement_fn(point1, point2) + squared_diff = jnp.sum(jnp.square(diff)) + return jnp.sqrt(squared_diff) + +def relative_position(displ, theta): + """ + Compute the relative distance and angle from a source particle to a target particle + :param displ: Displacement vector (jnp arrray with shape (2,) from source to target + :param theta: Orientation of the source particle (in the reference frame of the map) + :return: dist: distance from source to target. + relative_theta: relative angle of the target in the reference frame of the source particle (front direction at angle 0) + """ + dist = jnp.linalg.norm(displ) + norm_displ = displ / dist + theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) + relative_theta = theta_displ - theta + return dist, relative_theta \ No newline at end of file From 141625f670adf7da2c08f1d9f3be18a1ff167d02 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 17 Jun 2024 17:15:29 +0200 Subject: [PATCH 11/18] Update base env by removing intermediate state classes --- .../experimental/environments/base_env.py | 42 +------------------ 1 file changed, 2 insertions(+), 40 deletions(-) diff --git a/vivarium/experimental/environments/base_env.py b/vivarium/experimental/environments/base_env.py index 58e245c..bdb3687 100644 --- a/vivarium/experimental/environments/base_env.py +++ b/vivarium/experimental/environments/base_env.py @@ -1,5 +1,5 @@ import logging as lg -from enum import Enum + from functools import partial from typing import Tuple @@ -7,51 +7,13 @@ from jax import jit from flax import struct -from jax_md import simulate - - -# TODO : The best is surely to only define BaseState because some envs might not use EntityState / ObjectState or AgentState -class EntityType(Enum): - AGENT = 0 - OBJECT = 1 - -# No need to define position, momentum, force, and mass (i.e already in jax_md.simulate.NVEState) -@struct.dataclass -class BaseEntityState(simulate.NVEState): - entity_type: jnp.array - entity_idx: jnp.array - diameter: jnp.array - friction: jnp.array - exists: jnp.array - @property - def velocity(self) -> jnp.array: - return self.momentum / self.mass - -@struct.dataclass -class BaseAgentState: - ent_idx: jnp.array - color: jnp.array - -@struct.dataclass -class BaseObjectState: - ent_idx: jnp.array - color: jnp.array @struct.dataclass class BaseState: time: jnp.int32 box_size: jnp.int32 - 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 - entities: BaseEntityState - agents: BaseAgentState - objects: BaseObjectState - + class BaseEnv: def __init__(self): From ddac5db9075fc77014fa3a9020c985b8ff359bfd Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 17 Jun 2024 17:16:36 +0200 Subject: [PATCH 12/18] Remove duplicate code and add markdown comments --- .../notebooks/prey_predator_braitenberg.ipynb | 172 +++++++----------- 1 file changed, 68 insertions(+), 104 deletions(-) diff --git a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb index 19411e2..1d50e84 100644 --- a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb +++ b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb @@ -6,14 +6,16 @@ "source": [ "# Prey predator braitenberg notebook\n", "\n", - "Use this notebook to showcase how to build on top of an existing environment" + "This notebook showcases how to add new features on top on a pre-existing vivarium environment. Here, we will focus on implementing a prey predator braitenberg environment." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Imports" + "## Imports\n", + "\n", + "Start by import standard jax functions as well as elements (Classes, functions ...) from the environment you want to build features on." ] }, { @@ -25,7 +27,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-06-03 15:47:34.147139: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + "2024-06-17 16:55:41.332298: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" ] } ], @@ -37,19 +39,19 @@ "import jax.numpy as jnp\n", "\n", "from jax import vmap, jit\n", - "from jax import random\n", "from flax import struct\n", "\n", "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType\n", - "from vivarium.experimental.environments.braitenberg.simple import sensorimotor, compute_prox, behavior_name_map\n", - "from vivarium.experimental.environments.base_env import BaseEntityState, BaseObjectState" + "from vivarium.experimental.environments.braitenberg.simple import sensorimotor, compute_prox, behavior_name_map" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Define the states classes of prey predator env " + "### Define the states classes of prey predator env \n", + "\n", + "Redefine the classes and constants of the environment (most of them inherit from the simple braitenbeg one). We will just add a new field agent_type (prey or predator) for all of our agents." ] }, { @@ -58,31 +60,14 @@ "metadata": {}, "outputs": [], "source": [ - "### Define the classes and constants of the environment (most of them inherit from the simple braitenbeg one) ###\n", "\n", "class AgentType(Enum):\n", " PREY = 0\n", " PREDATOR = 1\n", "\n", - "predator_color = jnp.array([1., 0., 0.])\n", - "prey_color = jnp.array([0., 0., 1.])\n", - "object_color = jnp.array([0., 1., 0.])\n", - "\n", - "@struct.dataclass\n", - "class EntityState(BaseEntityState):\n", - " pass\n", - " \n", "@struct.dataclass\n", "class AgentState(AgentState):\n", - " agent_type: jnp.array\n", - "\n", - "@struct.dataclass\n", - "class ObjectState(BaseObjectState):\n", - " pass\n", - "\n", - "@struct.dataclass\n", - "class State(State):\n", - " pass" + " agent_type: jnp.array" ] }, { @@ -91,7 +76,13 @@ "source": [ "### Define prey predator env class \n", "\n", - "(inheriting from simple Braitenberg env)" + "Our environment inherits from the simple Braitenberg env, so we will only have to overwrite a few methods and create some new ones to create our prey predator environment. \n", + "\n", + "First, we need to overwrite the \\_\\_init__() function to allow specifying new parameters about preys and predators (their number and their colors here).\n", + "\n", + "Then, we also have to overwrite the _init_agents() function because we have a new AgentState class. We also add a small modification to init_state() to add indexes of prey and predators agents as attributes of the class.\n", + "\n", + "Finally, we just have to write functions to implement our new desired features (here the predators will kill the preys next to them), and add them in the _step() function !" ] }, { @@ -100,65 +91,20 @@ "metadata": {}, "outputs": [], "source": [ - "\n", - "### Define the new env class inheriting from simple one (only need to update __init__, init_state and _step)\n", - "\n", "class PreyPredBraitenbergEnv(BraitenbergEnv):\n", " def __init__(\n", " self,\n", - " box_size=200,\n", - " dt=0.1,\n", - " max_agents=50,\n", - " max_objects=10,\n", - " neighbor_radius=100.,\n", - " collision_alpha=0.5,\n", - " collision_eps=0.1,\n", - " n_dims=2,\n", - " seed=0,\n", - " diameter=5.0,\n", - " friction=0.1,\n", - " mass_center=1.0,\n", - " mass_orientation=0.125,\n", - " existing_agents=50,\n", - " existing_objects=10,\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", - " objects_color=jnp.array([0.0, 1.0, 0.0]),\n", " # New prey_predators args, should maybe add warnings to avoid incompatible values (e.g less agents than prey + pred)\n", " n_preys=25,\n", " n_predators=25,\n", " pred_eating_range=10,\n", " prey_color=jnp.array([0.0, 0.0, 1.0]),\n", " predator_color=jnp.array([1.0, 0.0, 0.0]),\n", - " ):\n", - " super().__init__(\n", - " box_size=box_size,\n", - " dt=dt,\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", - " 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=existing_agents,\n", - " existing_objects=existing_objects,\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", - " objects_color=objects_color\n", - " )\n", + " **kwargs\n", + " ): \n", + " # Initialize the attributes of old class with max_agents = n_preys + n_predators\n", + " max_agents = n_preys + n_predators \n", + " super().__init__(max_agents=max_agents, **kwargs)\n", " # Add specific attributes about prey / predator environment\n", " self.n_preys = n_preys\n", " self.n_predators = n_predators\n", @@ -166,13 +112,7 @@ " self.predator_color = predator_color\n", " self.pred_eating_range = pred_eating_range\n", "\n", - " def init_state(self) -> State:\n", - " key = random.PRNGKey(self.seed)\n", - " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", - "\n", - " entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations)\n", - " objects = self.init_objects()\n", - "\n", + " def _init_agents(self):\n", " # Added agent types for prey and predators\n", " agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value)))\n", " agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0)\n", @@ -196,16 +136,19 @@ " color=agents_colors\n", " )\n", "\n", - " state = self.init_complete_state(entities, agents, objects)\n", - " # Create jax_md attributes for environment physics\n", - " state = self.init_env_physics(key, state)\n", + " return agents\n", "\n", + " def init_state(self) -> State:\n", + " state = super().init_state()\n", + "\n", + " # Add idx utils to simplify conversions between entities and agent states\n", " self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n", " self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n", " self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n", "\n", " return state\n", " \n", + " # Add a function to detect if a prey will be eaten by a predator in the current step\n", " def can_all_be_eaten(self, R_prey, R_predators, predator_exist):\n", " # Could maybe create this as a method in the class, or above idk\n", " distance_to_all_preds = vmap(self.distance, in_axes=(None, 0))\n", @@ -217,13 +160,13 @@ " # Could also return which agent ate the other one (e.g to increase their energy) \n", " will_be_eaten_by = in_range * predator_exist\n", " eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0)\n", - "\n", " return eaten_or_not\n", " \n", " can_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None))\n", " \n", " return can_be_eaten(R_prey, R_predators, predator_exist)\n", " \n", + " # Add functions so predators eat preys\n", " def eat_preys(self, state):\n", " # See which preys can be eaten by predators and update the exists array accordingly\n", " R = state.entities.position.center\n", @@ -242,6 +185,7 @@ "\n", " return exist\n", "\n", + " # Add the eat_preys function in the _step loop\n", " @partial(jit, static_argnums=(0,))\n", " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n", " # 1 Compute which agents are being eaten\n", @@ -281,7 +225,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Create env and render its state" + "### Create env and render its state\n", + "\n", + "We define the colors in our environment this way: \n", + "\n", + "- Prey agents: blue\n", + "- Predator agents: red\n", + "- Objects: green" ] }, { @@ -290,7 +240,7 @@ "metadata": {}, "outputs": [], "source": [ - "from vivarium.experimental.environments.braitenberg.utils import render, render_history" + "from vivarium.experimental.environments.braitenberg.render import render, render_history" ] }, { @@ -299,7 +249,25 @@ "metadata": {}, "outputs": [], "source": [ - "env = PreyPredBraitenbergEnv()\n", + "BOX_SIZE = 200\n", + "\n", + "N_PRED = 25\n", + "N_PREY = 25\n", + "MAX_OBJ = 25\n", + "\n", + "PRED_COLOR = jnp.array([1., 0., 0.])\n", + "PREY_COLOR = jnp.array([0., 0., 1.])\n", + "OBJ_COLOR = jnp.array([0., 1., 0.])\n", + "\n", + "env = PreyPredBraitenbergEnv(\n", + " box_size=BOX_SIZE,\n", + " max_objects=MAX_OBJ,\n", + " predator_color=PRED_COLOR,\n", + " prey_color=PREY_COLOR,\n", + " objects_color=OBJ_COLOR,\n", + " n_predators=N_PRED,\n", + " n_preys=N_PREY\n", + ")\n", "state = env.init_state()" ] }, @@ -310,7 +278,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -323,15 +291,6 @@ "render(state)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- Prey agents: blue\n", - "- Predator agents: red\n", - "- Objects: green" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -360,7 +319,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -370,9 +329,14 @@ } ], "source": [ - "render_history(hist, skip_frames=10)\n", - "\n", - "# The rendering function is quite laggy, I'll change it later (but at the moment it works to test the environments rapidly)" + "render_history(hist, skip_frames=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The rendering function is quite laggy, but we can see that prey agents are now being eaten by predator ones ! " ] } ], From ec6c0f8602a8b93005cad21f2c5faff0e245e527 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 17 Jun 2024 17:26:03 +0200 Subject: [PATCH 13/18] Remove uncessary files --- ...actor_sensors.py => behaviors_refactor.py} | 21 +- .../environments/braitenberg/prey_predator.py | 213 ------ .../braitenberg/{utils.py => render.py} | 5 +- .../braitenberg/selective_sensors.py | 626 ------------------ 4 files changed, 15 insertions(+), 850 deletions(-) rename vivarium/experimental/environments/braitenberg/{refactor_sensors.py => behaviors_refactor.py} (97%) delete mode 100644 vivarium/experimental/environments/braitenberg/prey_predator.py rename vivarium/experimental/environments/braitenberg/{utils.py => render.py} (97%) delete mode 100644 vivarium/experimental/environments/braitenberg/selective_sensors.py diff --git a/vivarium/experimental/environments/braitenberg/refactor_sensors.py b/vivarium/experimental/environments/braitenberg/behaviors_refactor.py similarity index 97% rename from vivarium/experimental/environments/braitenberg/refactor_sensors.py rename to vivarium/experimental/environments/braitenberg/behaviors_refactor.py index 51e73dc..883d5fe 100644 --- a/vivarium/experimental/environments/braitenberg/refactor_sensors.py +++ b/vivarium/experimental/environments/braitenberg/behaviors_refactor.py @@ -1,8 +1,13 @@ +# TODO : Added these lines for testing purposes (there was a bug from a jax_md error where gpu isn't detected anymore) +import os +os.environ["JAX_PLATFORMS"] = "cpu" + 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 @@ -13,7 +18,7 @@ from jax_md.rigid_body import RigidBody from jax_md import space, rigid_body, partition, quantity -from vivarium.experimental.environments.braitenberg.utils import normal +from vivarium.experimental.environments.braitenberg.render import normal from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn @@ -106,6 +111,7 @@ def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) + # Computes the maximum within the proximeter activations of agents on all their neigbhors. proxs = ops.segment_max( raw_proxs, @@ -114,6 +120,7 @@ def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_ return proxs + # TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): """ @@ -126,7 +133,6 @@ def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): :return: """ body = state.entities.position - mask = target_exists_mask[agents_neighs_idx[1, :]] senders, receivers = agents_neighs_idx Ra = body.center[senders] Rb = body.center[receivers] @@ -140,6 +146,7 @@ def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta) # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) + mask = target_exists_mask[agents_neighs_idx[1, :]] prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) @@ -181,11 +188,11 @@ def behavior_to_params(behavior): return behavior_params[behavior] def compute_motor(proxs, params): - """Compute motor values according to proximeter values and "params" + """Compute motor values according to proximeter values and params - :param proxs: _description_ - :param params: _description_ - :return: _description_ + :param proxs: proximeter values + :param params: linear mapping between proxs and motor values + :return: motor activations """ return params.dot(jnp.hstack((proxs, 1.))) @@ -360,7 +367,7 @@ def distance(self, point1, point2): return jnp.sqrt(squared_diff) # TODO See how to clean the function to remove the agents_neighs_idx - @partial(jit, static_argnums=(0,)) + # @partial(jit, static_argnums=(0,)) def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: # 1 : Compute agents proximeter exists_mask = jnp.where(state.entities.exists == 1, 1, 0) diff --git a/vivarium/experimental/environments/braitenberg/prey_predator.py b/vivarium/experimental/environments/braitenberg/prey_predator.py deleted file mode 100644 index 24984e2..0000000 --- a/vivarium/experimental/environments/braitenberg/prey_predator.py +++ /dev/null @@ -1,213 +0,0 @@ -from enum import Enum -from functools import partial -from typing import Tuple - -import jax.numpy as jnp - -from jax import vmap, jit -from jax import random -from flax import struct - -from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType -from vivarium.experimental.environments.braitenberg.simple import sensorimotor, compute_prox, behavior_name_map -from vivarium.experimental.environments.base_env import BaseEntityState, BaseObjectState - -### Define the classes and constants of the environment (most of them inherit from the simple braitenbeg one) ### - -class AgentType(Enum): - PREY = 0 - PREDATOR = 1 - -predator_color = jnp.array([1., 0., 0.]) -prey_color = jnp.array([0., 0., 1.]) -object_color = jnp.array([0., 1., 0.]) - -@struct.dataclass -class EntityState(BaseEntityState): - pass - -@struct.dataclass -class AgentState(AgentState): - agent_type: jnp.array - -@struct.dataclass -class ObjectState(BaseObjectState): - pass - -@struct.dataclass -class State(State): - pass - -### Define the new env class inheriting from simple one (only need to update __init__, init_state and _step) - -class PreyPredBraitenbergEnv(BraitenbergEnv): - def __init__( - self, - box_size=200, - dt=0.1, - max_agents=50, - max_objects=10, - neighbor_radius=100., - collision_alpha=0.5, - collision_eps=0.1, - n_dims=2, - seed=0, - diameter=5.0, - friction=0.1, - mass_center=1.0, - mass_orientation=0.125, - existing_agents=50, - existing_objects=0, - 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, - objects_color=jnp.array([0.0, 1.0, 0.0]), - # New prey_predators args, should maybe add warnings to avoid incompatible values (e.g less agents than prey + pred) - n_preys=25, - n_predators=25, - pred_eating_range=10, - prey_color=jnp.array([0.0, 0.0, 1.0]), - predator_color=jnp.array([1.0, 0.0, 0.0]), - ): - super().__init__( - box_size=box_size, - dt=dt, - max_agents=max_agents, - max_objects=max_objects, - 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=existing_agents, - existing_objects=existing_objects, - 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_color=objects_color - ) - # Add specific attributes about prey / predator environment - self.n_preys = n_preys - self.n_predators = n_predators - self.prey_color = prey_color - self.predator_color = predator_color - self.pred_eating_range = pred_eating_range - - def init_state(self) -> State: - key = random.PRNGKey(self.seed) - key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) - - entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) - objects = self.init_objects() - - # Added agent types for prey and predators - agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value))) - agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0) - behaviors = jnp.hstack((jnp.full(self.n_preys, behavior_name_map['FEAR']), jnp.full(self.n_predators, behavior_name_map['AGGRESSION']))) - - agents = AgentState( - # idx in the entities (ent_idx) state to map agents information in the different data structures - ent_idx=jnp.arange(self.max_agents, dtype=int), - agent_type=agent_types, - prox=jnp.zeros((self.max_agents, 2)), - motor=jnp.zeros((self.max_agents, 2)), - behavior=behaviors, - wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), - speed_mul=jnp.full((self.max_agents), self.speed_mul), - max_speed=jnp.full((self.max_agents), self.max_speed), - theta_mul=jnp.full((self.max_agents), self.theta_mul), - proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), - proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), - proximity_map_dist=jnp.zeros((self.max_agents, 1)), - proximity_map_theta=jnp.zeros((self.max_agents, 1)), - color=agents_colors - ) - - state = self.init_complete_state(entities, agents, objects) - - # Create jax_md attributes for environment physics - state = self.init_physics(key, state) - - self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value) - self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value) - self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value) - - return state - - def can_all_be_eaten(self, R_prey, R_predators, predator_exist): - # Could maybe create this as a method in the class, or above idk - distance_to_all_preds = vmap(self.distance, in_axes=(None, 0)) - - # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above - def can_be_eaten(R_prey, R_predators, predator_exist): - dist_to_preds = distance_to_all_preds(R_prey, R_predators) - in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0) - # Could also return which agent ate the other one (e.g to increase their energy) - will_be_eaten_by = in_range * predator_exist - eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0) - - return eaten_or_not - - can_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None)) - - return can_be_eaten(R_prey, R_predators, predator_exist) - - def eat_preys(self, state): - # See which preys can be eaten by predators and update the exists array accordingly - R = state.entities.position.center - exist = state.entities.exists - prey_idx = self.prey_idx - pred_idx = self.pred_idx - - agents_ent_idx = state.agents.ent_idx - predator_exist = exist[agents_ent_idx][pred_idx] - - can_be_eaten_idx = self.can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist) - exist_prey = exist[agents_ent_idx[prey_idx]] - new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey) - exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey) - return exist - - @partial(jit, static_argnums=(0,)) - def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: - # 1 Compute which agents are being eaten - exist = self.eat_preys(state) - entities = state.entities.replace(exists=exist) - - # 2 Compute the proximeter of agents - exists_mask = jnp.where(entities.exists == 1, 1, 0) - prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement) - motor = sensorimotor(prox, state.agents.behavior, state.agents.motor) - agents = state.agents.replace( - prox=prox, - proximity_map_dist=proximity_dist_map, - proximity_map_theta=proximity_dist_theta, - motor=motor - ) - - # 3 Update the state with the new agent and entities states - state = state.replace( - agents=agents, - entities=entities - ) - - # 4 Apply physics forces to the environment state - entities = self.apply_physics(state, neighbors) - state = state.replace( - time=state.time+1, - entities=entities, - ) - - # 5 Update the neighbors according to the new positions - neighbors = neighbors.update(state.entities.position.center) - return state, neighbors diff --git a/vivarium/experimental/environments/braitenberg/utils.py b/vivarium/experimental/environments/braitenberg/render.py similarity index 97% rename from vivarium/experimental/environments/braitenberg/utils.py rename to vivarium/experimental/environments/braitenberg/render.py index 8f540e9..a3c8e64 100644 --- a/vivarium/experimental/environments/braitenberg/utils.py +++ b/vivarium/experimental/environments/braitenberg/render.py @@ -6,11 +6,8 @@ import matplotlib.pyplot as plt import matplotlib.colors as colors -from jax import vmap +from vivarium.experimental.environments.utils import normal -@vmap -def normal(theta): - return jnp.array([jnp.cos(theta), jnp.sin(theta)]) def _string_to_rgb(color_str): return jnp.array(list(colors.to_rgb(color_str))) diff --git a/vivarium/experimental/environments/braitenberg/selective_sensors.py b/vivarium/experimental/environments/braitenberg/selective_sensors.py deleted file mode 100644 index 6949c32..0000000 --- a/vivarium/experimental/environments/braitenberg/selective_sensors.py +++ /dev/null @@ -1,626 +0,0 @@ -# TODO : Remove that (just comes from a jax_md error where gpu isn't detected anymore) -import os -os.environ["JAX_PLATFORMS"] = "cpu" - -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 - -from jax import vmap, jit -from jax import random, ops, lax - -from flax import struct -from jax_md.rigid_body import RigidBody -from jax_md import space, rigid_body, partition, quantity - -from vivarium.experimental.environments.braitenberg.utils import normal -from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv -from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn - -### Define the constants and the classes of the environment to store its state ### - -SPACE_NDIMS = 2 - -# TODO : Should maybe just let the user define its own class and just have a base class State with time ... -class EntityType(Enum): - AGENT = 0 - OBJECT = 1 - -# TODO : See if really usefull -# @struct.dataclass -# class BehaviorMap: -# params: jnp.array -# sensed: jnp.array - -@struct.dataclass -class EntityState(BaseEntityState): - pass - -@struct.dataclass -class AgentState(BaseAgentState): - prox: jnp.array - motor: jnp.array - proximity_map_dist: jnp.array - proximity_map_theta: jnp.array - behavior: jnp.array - params: 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(BaseObjectState): - pass - -@struct.dataclass -class State(BaseState): - time: jnp.int32 - box_size: jnp.int32 - 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 - entities: EntityState - agents: AgentState - objects: ObjectState - -### Define helper functions used to step from one state to the next one ### - - -#--- 2 Functions to compute the motor activations of braitenberg agents ---# - -# TODO : See how we'll handle this on client side -class Behaviors(Enum): - FEAR = 0 - AGGRESSION = 1 - LOVE = 2 - SHY = 3 - NOOP = 4 - MANUAL = 5 - -# TODO : Could find a better name than params ? Or can be good enough -behavior_params = { - Behaviors.FEAR.value: jnp.array( - [[1., 0., 0.], - [0., 1., 0.]]), - Behaviors.AGGRESSION.value: jnp.array( - [[0., 1., 0.], - [1., 0., 0.]]), - Behaviors.LOVE.value: jnp.array( - [[-1., 0., 1.], - [0., -1., 1.]]), - Behaviors.SHY.value: jnp.array( - [[0., -1., 1.], - [-1., 0., 1.]]), - Behaviors.NOOP.value: jnp.array( - [[0., 0., 0.], - [0., 0., 0.]]), -} - -def behavior_to_params(behavior): - return behavior_params[behavior] - -def compute_motor(proxs, params): - """Compute motor values according to proximeter values and "params" - - :param proxs: _description_ - :param params: _description_ - :return: _description_ - """ - return params.dot(jnp.hstack((proxs, 1.))) - -sensorimotor = vmap(compute_motor, in_axes=(0, 0)) - -def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): - fwd = (wheel_diameter / 4.) * (left_spd + right_spd) - rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) - return fwd, rot - -def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): - left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter - right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter - return left, right - -def motor_command(wheel_activation, base_length, wheel_diameter): - fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) - return fwd, rot - -motor_command = vmap(motor_command, (0, 0, 0)) - - -#--- 3 Functions to compute the different forces in the environment ---# - -# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces -def braintenberg_force_fn(displacement): - coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) - - def collision_force(state, neighbor, exists_mask): - return coll_force_fn( - state.entities.position.center, - neighbor=neighbor, - exists_mask=exists_mask, - diameter=state.entities.diameter, - epsilon=state.collision_eps, - alpha=state.collision_alpha - ) - - def motor_force(state, exists_mask): - agent_idx = state.agents.ent_idx - - body = rigid_body.RigidBody( - center=state.entities.position.center[agent_idx], - orientation=state.entities.position.orientation[agent_idx] - ) - - n = normal(body.orientation) - - fwd, rot = motor_command( - state.agents.motor, - state.entities.diameter[agent_idx], - state.agents.wheel_diameter - ) - # `a_max` arg is deprecated in recent versions of jax, replaced by `max` - fwd = jnp.clip(fwd, a_max=state.agents.max_speed) - - cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] - cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) - cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] - - fwd_delta = fwd - cur_fwd_vel - rot_delta = rot - cur_rot_vel - - fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T - rot_force = rot_delta * state.agents.theta_mul - - center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) - orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) - - # apply mask to make non existing agents stand still - orientation = jnp.where(exists_mask, orientation, 0.) - # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center - exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) - center = jnp.where(exists_mask, center, 0.) - - return rigid_body.RigidBody(center=center, - orientation=orientation) - - def force_fn(state, neighbor, exists_mask): - mf = motor_force(state, exists_mask) - cf = collision_force(state, neighbor, exists_mask) - ff = friction_force(state, exists_mask) - - center = cf + ff + mf.center - orientation = mf.orientation - return rigid_body.RigidBody(center=center, orientation=orientation) - - return force_fn - - -#--- 1 Functions to compute the proximeter of braitenberg agents ---# - -def relative_position(displ, theta): - """ - Compute the relative distance and angle from a source agent to a target agent - :param displ: Displacement vector (jnp arrray with shape (2,) from source to target - :param theta: Orientation of the source agent (in the reference frame of the map) - :return: dist: distance from source to target. - relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) - """ - dist = jnp.linalg.norm(displ) - norm_displ = displ / dist - theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) - relative_theta = theta_displ - theta - return dist, relative_theta - -proximity_map = vmap(relative_position, (0, 0)) - -# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here -def get_relative_displacement(state, agents_neighs_idx, displacement_fn): - 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 - -# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority) -def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): - """ - Compute the proximeter activations (left, right) induced by the presence of an entity - :param dist: distance from the agent to the entity - :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) - :param dist_max: Max distance of the proximiter (will return 0. above this distance) - :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) - :return: left and right proximeter activation in a jnp array with shape (2,) - """ - cos_dir = jnp.cos(relative_theta) - prox = 1. - (dist / dist_max) - in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) - at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) - left = in_view * at_left * prox - right = in_view * (1. - at_left) * prox - return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist - -sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) - -def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): - jax.debug.print("Before sensor_fn") - jax.debug.print("dist.shape = {x}", x=dist.shape) - jax.debug.print("relative_theta.shape = {x}", x=relative_theta.shape) - jax.debug.print("dist_max.shape = {x}", x=dist_max.shape) - jax.debug.print("cos_min.shape = {x}", x=cos_min.shape) - jax.debug.print("raw_proxs.target_exists = {x}", x=target_exists.shape) - - raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) - jax.debug.print("raw_proxs.shape = {x}", x=raw_proxs.shape) - - # Computes the maximum within the proximeter activations of agents on all their neigbhors. - proxs = ops.segment_max( - raw_proxs, - senders, - max_agents) - - return proxs - - -# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) -def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): - """ - Set agents' proximeter activations - :param state: full simulation State - :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), - where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. - :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). - target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). - :return: - """ - body = state.entities.position - senders, receivers = agents_neighs_idx - Ra = body.center[senders] - Rb = body.center[receivers] - dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why - - # Create distance and angle maps between entities - 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) - - # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) - mask = target_exists_mask[agents_neighs_idx[1, :]] - prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], - state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) - - # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) - return prox, proximity_map_dist, proximity_map_theta - -### New functions for selective sensors #### - -def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx): - mask = jnp.where(state.entities.entity_type[ent_target_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_target_idx): - return agent_raw_proxs - -# TODO : Use a fori_loop on this later -def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities): - for ent_type_id, sensed in enumerate(sensed_entities): - agent_raw_proxs = jax.lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx) - proxs = jnp.max(agent_raw_proxs, axis=0) - - return proxs - -### TODO 1 : -def compute_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_idx): - behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed) - behavior_motors = compute_motor(behavior_prox, params) - return behavior_prox, behavior_motors - -compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, None, None)) - -def compute_agent_proxs_motors(state, agent_idx, params, sensed, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers): - ent_ag_idx = ag_idx_dense_senders[agent_idx] - ent_target_idx = ag_idx_dense_receivers[agent_idx] - agent_raw_proxs = raw_proxs[ent_ag_idx] - - agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_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, None, None, None)) - - -class SelectiveSensorsBraitenbergEnv(BaseEnv): - def __init__( - self, - box_size=100, - dt=0.1, - max_agents=10, - max_objects=2, - neighbor_radius=100., - collision_alpha=0.5, - collision_eps=0.1, - n_dims=2, - seed=0, - diameter=5.0, - friction=0.1, - mass_center=1.0, - mass_orientation=0.125, - existing_agents=10, - existing_objects=2, - behaviors=Behaviors.AGGRESSION.value, - 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, - agents_color=jnp.array([0.0, 0.0, 1.0]), - objects_color=jnp.array([1.0, 0.0, 0.0]) - ): - - # TODO : add docstrings - # general parameters - self.box_size = box_size - self.dt = dt - self.max_agents = max_agents - self.max_objects = max_objects - self.neighbor_radius = neighbor_radius - self.collision_alpha = collision_alpha - self.collision_eps = collision_eps - self.n_dims = n_dims - self.seed = seed - # entities parameters - self.diameter = diameter - self.friction = friction - self.mass_center = mass_center - self.mass_orientation = mass_orientation - self.existing_agents = existing_agents - self.existing_objects = existing_objects - # agents parameters - self.behaviors = behaviors - self.wheel_diameter = wheel_diameter - self.speed_mul = speed_mul - self.max_speed = max_speed - self.theta_mul = theta_mul - self.prox_dist_max = prox_dist_max - self.prox_cos_min = prox_cos_min - self.agents_color = agents_color - # objects parameters - self.objects_color = objects_color - # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? - # Or can also directly initialize the state ... and jax_md attributes in this function too ... - - def init_state(self) -> State: - key = random.PRNGKey(self.seed) - key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) - - entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) - agents = self.init_agents() - objects = self.init_objects() - state = self.init_complete_state(entities, agents, objects) - - # Create jax_md attributes for environment physics - # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes) - state = self.init_env_physics(key, state) - - return state - - def distance(self, point1, point2): - diff = self.displacement(point1, point2) - squared_diff = jnp.sum(jnp.square(diff)) - return jnp.sqrt(squared_diff) - - # TODO See how to clean the function to remove the agents_neighs_idx - @partial(jit, static_argnums=(0,)) - def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]: - - ### Hardcoded behaviors for agents at the moment (aggr towards objects and fear towards agents) - params_1 = behavior_to_params(Behaviors.AGGRESSION.value) - params_2 = behavior_to_params(Behaviors.FEAR.value) - sensed_1 = jnp.array([0, 1]) - sensed_2 = jnp.array([1, 0]) - params = jnp.array([params_1, params_2]) - sensed = jnp.array([sensed_1, sensed_2]) - - # Do like if we had batches of params and sensed entities for all agents - batch_params = jnp.tile(params[None], (self.max_agents, 1, 1 ,1)) - batch_sensed = jnp.tile(sensed[None], (self.max_agents, 1, 1)) - ### - - 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] - targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]] - raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask) - - # TODO : 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 = compute_all_agents_proxs_motors( - state, - state.agents.ent_idx, - batch_params, - batch_sensed, - raw_proxs, - ag_idx_dense_senders, - ag_idx_dense_receivers, - ) - - # print(f"{agent_proxs = }") - # print(f"{mean_agent_motors = }") - - # TODO : Relou de rajouter les proximeters non ? En vrai non juste un array de proximeters pour chaque agent - 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: - current_state = state - state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense) - - if self.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') - neighbors = self.allocate_neighbors(state) - assert not neighbors.did_buffer_overflow - - self.neighbors = neighbors - return state - - # TODO See how we deal with agents_neighs_idx - def allocate_neighbors(self, state, position=None): - position = state.entities.position.center if position is None else position - neighbors = self.neighbor_fn.allocate(position) - - # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here) - ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value - self.agents_neighs_idx = neighbors.idx[:, ag_idx] - agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(self.max_agents)]) - # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)]) - agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders] - # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)]) - self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers - return neighbors - - # TODO : Modify these functions so can give either 1 param and apply it to every entity or give custom ones - def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): - n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size - objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) - object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) - exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) - exists = jnp.concatenate((exists_agents, exists_objects), 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), - entity_type=entity_types, - entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), - diameter=jnp.full((n_entities), self.diameter), - friction=jnp.full((n_entities), self.friction), - exists=exists - ) - - def init_agents(self): - # TODO : Change that so can define custom behaviors (e.g w a list) - # Use numpy cuz jnp elements cannot be keys of a dict - behaviors = np.full((self.max_agents), self.behaviors) - # Cannot use a vmap fn because of dictionary, cannot have jax elements as a key because its unhashable - params = jnp.array([behavior_to_params(behavior) for behavior in behaviors]) - return AgentState( - # idx in the entities (ent_idx) state to map agents information in the different data structures - ent_idx=jnp.arange(self.max_agents, dtype=int), - prox=jnp.zeros((self.max_agents, 2)), - motor=jnp.zeros((self.max_agents, 2)), - behavior=behaviors, - params=params, - wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), - speed_mul=jnp.full((self.max_agents), self.speed_mul), - max_speed=jnp.full((self.max_agents), self.max_speed), - theta_mul=jnp.full((self.max_agents), self.theta_mul), - proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), - proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), - proximity_map_dist=jnp.zeros((self.max_agents, 1)), - proximity_map_theta=jnp.zeros((self.max_agents, 1)), - color=jnp.tile(self.agents_color, (self.max_agents, 1)) - ) - - def init_objects(self): - # Entities idx of objects - start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects - objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) - - return ObjectState( - ent_idx=objects_ent_idx, - color=jnp.tile(self.objects_color, (self.max_objects, 1)) - ) - - def init_complete_state(self, entities, agents, objects): - lg.info('Initializing state') - return State( - time=0, - box_size=self.box_size, - max_agents=self.max_agents, - max_objects=self.max_objects, - neighbor_radius=self.neighbor_radius, - collision_alpha=self.collision_alpha, - collision_eps=self.collision_eps, - dt=self.dt, - entities=entities, - agents=agents, - objects=objects - ) - - def init_env_physics(self, key, state): - lg.info("Initializing environment's physics features") - key, physics_key = random.split(key) - self.displacement, self.shift = space.periodic(self.box_size) - self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) - self.neighbor_fn = partition.neighbor_list( - self.displacement, - self.box_size, - r_cutoff=self.neighbor_radius, - dr_threshold=10., - capacity_multiplier=1.5, - format=partition.Sparse - ) - - state = self.init_fn(state, physics_key) - lg.info("Allocating neighbors") - neighbors = self.allocate_neighbors(state) - self.neighbors = neighbors - - return state - - -env = SelectiveSensorsBraitenbergEnv() -state = env.init_state() -state = env.step(state) -state = env.step(state) -state = env.step(state) -state = env.step(state) \ No newline at end of file From cc54cb81e2407c4d49ff6aafa95508ed2b1de78e Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 17 Jun 2024 18:45:45 +0200 Subject: [PATCH 14/18] Update simple braitenberg notebook --- .../notebooks/simple_braitenberg.ipynb | 57 ++++++++++++------- 1 file changed, 38 insertions(+), 19 deletions(-) diff --git a/vivarium/experimental/notebooks/simple_braitenberg.ipynb b/vivarium/experimental/notebooks/simple_braitenberg.ipynb index 22751fc..0e5e979 100644 --- a/vivarium/experimental/notebooks/simple_braitenberg.ipynb +++ b/vivarium/experimental/notebooks/simple_braitenberg.ipynb @@ -9,7 +9,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-06-03 15:31:30.391184: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + "2024-06-17 17:54:26.548867: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" ] } ], @@ -17,7 +17,14 @@ "import time\n", "\n", "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv\n", - "from vivarium.experimental.environments.braitenberg.utils import render, render_history" + "from vivarium.experimental.environments.braitenberg.render import render, render_history" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Init and launch a simulation" ] }, { @@ -95,7 +102,25 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "env = BraitenbergEnv(\n", + " box_size=1000,\n", + " max_agents=100,\n", + " max_objects=50,\n", + " existing_agents=90,\n", + " existing_objects=30,\n", + " prox_dist_max=100\n", + ") \n", + " \n", + "state = env.init_state() " + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -109,21 +134,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Simulation ran in 13.888845541001501 for 20000 timesteps\n" + "Simulation ran in 18.6945350269998 for 20000 timesteps\n" ] } ], "source": [ - "env = BraitenbergEnv(\n", - " box_size=1000,\n", - " max_agents=100,\n", - " max_objects=50,\n", - " existing_agents=90,\n", - " existing_objects=30,\n", - " prox_dist_max=100\n", - ") \n", - " \n", - "state = env.init_state() \n", "\n", "n_steps = 20_000\n", "\n", @@ -134,12 +149,14 @@ " state = env.step(state) \n", " hist.append(state)\n", "end = time.perf_counter()\n", - "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + "\n", + "w_rebuilding_time = end - start\n", + "print(f\"Simulation ran in {w_rebuilding_time} for {n_steps} timesteps\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -169,14 +186,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Simulation ran in 12.980394261001493 for 20000 timesteps\n" + "Simulation ran in 17.63896679500067 for 20000 timesteps\n" ] } ], @@ -197,7 +214,9 @@ " state = env.step(state) \n", " hist.append(state)\n", "end = time.perf_counter()\n", - "print(f\"Simulation ran in {end - start} for {n_steps} timesteps\")" + "\n", + "wo_rebuilding_time = end - start\n", + "print(f\"Simulation ran in {wo_rebuilding_time} for {n_steps} timesteps\")" ] } ], From 5939559b375b739fccdadd7ffe1928f01df77976 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Thu, 4 Jul 2024 12:11:05 +0200 Subject: [PATCH 15/18] Add selective sensors environment with old env interface --- .../notebooks/selective_sensors.ipynb | 963 ++++++++++++++++++ 1 file changed, 963 insertions(+) create mode 100644 vivarium/experimental/notebooks/selective_sensors.ipynb diff --git a/vivarium/experimental/notebooks/selective_sensors.ipynb b/vivarium/experimental/notebooks/selective_sensors.ipynb new file mode 100644 index 0000000..e6302b0 --- /dev/null +++ b/vivarium/experimental/notebooks/selective_sensors.ipynb @@ -0,0 +1,963 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO : Remove that (just comes from a jax_md error where gpu isn't detected anymore)\n", + "import os\n", + "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", + "\n", + "import logging as lg\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", + "\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\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", + "\n", + "### Define the constants and the classes of the environment to store its state ###\n", + "\n", + "SPACE_NDIMS = 2\n", + "\n", + "# TODO : Should maybe just let the user define its own class and just have a base class State with time ... \n", + "class EntityType(Enum):\n", + " AGENT = 0\n", + " OBJECT = 1\n", + "\n", + "class EntitySensedType(Enum):\n", + " PREY = 0\n", + " PRED = 1\n", + " RESSOURCE = 2\n", + " POISON = 3\n", + "\n", + "@struct.dataclass\n", + "class EntityState(simulate.NVEState):\n", + " entity_type: jnp.array\n", + " entity_idx: jnp.array\n", + " diameter: jnp.array\n", + " friction: jnp.array\n", + " exists: jnp.array\n", + " ent_sensed_type: 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", + " time: jnp.int32\n", + " box_size: jnp.int32\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", + " entities: EntityState\n", + " agents: AgentState\n", + " objects: ObjectState \n", + "\n", + "### Define helper functions used to step from one state to the next one ###\n", + "\n", + "\n", + "#--- 2 Functions to compute the motor activations of braitenberg agents ---#\n", + "\n", + "# TODO : See how we'll handle this on client side\n", + "class Behaviors(Enum):\n", + " FEAR = 0\n", + " AGGRESSION = 1\n", + " LOVE = 2\n", + " SHY = 3\n", + " NOOP = 4\n", + " MANUAL = 5\n", + "\n", + "# TODO : Could find a better name than params ? Or can be good enough\n", + "behavior_params = {\n", + " Behaviors.FEAR.value: jnp.array(\n", + " [[1., 0., 0.], \n", + " [0., 1., 0.]]),\n", + " Behaviors.AGGRESSION.value: jnp.array(\n", + " [[0., 1., 0.], \n", + " [1., 0., 0.]]),\n", + " Behaviors.LOVE.value: jnp.array(\n", + " [[-1., 0., 1.], \n", + " [0., -1., 1.]]),\n", + " Behaviors.SHY.value: jnp.array(\n", + " [[0., -1., 1.], \n", + " [-1., 0., 1.]]),\n", + " Behaviors.NOOP.value: jnp.array(\n", + " [[0., 0., 0.], \n", + " [0., 0., 0.]]),\n", + "}\n", + "\n", + "def behavior_to_params(behavior):\n", + " return behavior_params[behavior]\n", + "\n", + "def compute_motor(proxs, params):\n", + " \"\"\"Compute motor values according to proximeter values and \"params\"\n", + "\n", + " :param proxs: _description_\n", + " :param params: _description_\n", + " :return: _description_\n", + " \"\"\"\n", + " return params.dot(jnp.hstack((proxs, 1.)))\n", + "\n", + "sensorimotor = vmap(compute_motor, in_axes=(0, 0))\n", + "\n", + "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", + " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", + " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", + " return fwd, rot\n", + "\n", + "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", + " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", + " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", + " return left, right\n", + "\n", + "def motor_command(wheel_activation, base_length, wheel_diameter):\n", + " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", + " return fwd, rot\n", + "\n", + "motor_command = vmap(motor_command, (0, 0, 0))\n", + "\n", + "\n", + "#--- 3 Functions to compute the different forces in the environment ---#\n", + "\n", + "# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces\n", + "def braintenberg_force_fn(displacement):\n", + " coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))\n", + "\n", + " def collision_force(state, neighbor, exists_mask):\n", + " return coll_force_fn(\n", + " state.entities.position.center,\n", + " neighbor=neighbor,\n", + " exists_mask=exists_mask,\n", + " diameter=state.entities.diameter,\n", + " epsilon=state.collision_eps,\n", + " alpha=state.collision_alpha\n", + " )\n", + "\n", + " def motor_force(state, exists_mask):\n", + " agent_idx = state.agents.ent_idx\n", + "\n", + " body = rigid_body.RigidBody(\n", + " center=state.entities.position.center[agent_idx],\n", + " orientation=state.entities.position.orientation[agent_idx]\n", + " )\n", + " \n", + " n = normal(body.orientation)\n", + "\n", + " fwd, rot = motor_command(\n", + " state.agents.motor,\n", + " state.entities.diameter[agent_idx],\n", + " state.agents.wheel_diameter\n", + " )\n", + " # `a_max` arg is deprecated in recent versions of jax, replaced by `max`\n", + " fwd = jnp.clip(fwd, a_max=state.agents.max_speed)\n", + "\n", + " cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]\n", + " cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)\n", + " cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]\n", + " \n", + " fwd_delta = fwd - cur_fwd_vel\n", + " rot_delta = rot - cur_rot_vel\n", + "\n", + " fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T\n", + " rot_force = rot_delta * state.agents.theta_mul\n", + "\n", + " center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)\n", + " orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)\n", + "\n", + " # apply mask to make non existing agents stand still\n", + " orientation = jnp.where(exists_mask, orientation, 0.)\n", + " # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center\n", + " exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)\n", + " center = jnp.where(exists_mask, center, 0.)\n", + "\n", + " return rigid_body.RigidBody(center=center,\n", + " orientation=orientation)\n", + " \n", + " def force_fn(state, neighbor, exists_mask):\n", + " mf = motor_force(state, exists_mask)\n", + " cf = collision_force(state, neighbor, exists_mask)\n", + " ff = friction_force(state, exists_mask)\n", + " \n", + " center = cf + ff + mf.center\n", + " orientation = mf.orientation\n", + " return rigid_body.RigidBody(center=center, orientation=orientation)\n", + "\n", + " return force_fn\n", + "\n", + "\n", + "#--- 1 Functions to compute the proximeter of braitenberg agents ---#\n", + "\n", + "def relative_position(displ, theta):\n", + " \"\"\"\n", + " Compute the relative distance and angle from a source agent to a target agent\n", + " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", + " :param theta: Orientation of the source agent (in the reference frame of the map)\n", + " :return: dist: distance from source to target.\n", + " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", + " \"\"\"\n", + " dist = jnp.linalg.norm(displ)\n", + " norm_displ = displ / dist\n", + " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", + " relative_theta = theta_displ - theta\n", + " return dist, relative_theta\n", + "\n", + "proximity_map = vmap(relative_position, (0, 0))\n", + "\n", + "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n", + "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\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\n", + "\n", + "# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority)\n", + "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", + " \"\"\"\n", + " Compute the proximeter activations (left, right) induced by the presence of an entity\n", + " :param dist: distance from the agent to the entity\n", + " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", + " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", + " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", + " :return: left and right proximeter activation in a jnp array with shape (2,)\n", + " \"\"\"\n", + " cos_dir = jnp.cos(relative_theta)\n", + " prox = 1. - (dist / dist_max)\n", + " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", + " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", + " left = in_view * at_left * prox\n", + " right = in_view * (1. - at_left) * prox\n", + " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", + "\n", + "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", + "\n", + "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", + " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", + "\n", + " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", + " proxs = ops.segment_max(\n", + " raw_proxs,\n", + " senders, \n", + " max_agents)\n", + " \n", + " return proxs\n", + "\n", + "# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority)\n", + "def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):\n", + " \"\"\"\n", + " Set agents' proximeter activations\n", + " :param state: full simulation State\n", + " :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),\n", + " where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.\n", + " :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).\n", + " target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).\n", + " :return:\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)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", + "\n", + " # Create distance and angle maps between entities\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", + "\n", + " # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents)\n", + " mask = target_exists_mask[agents_neighs_idx[1, :]] \n", + " prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],\n", + " state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)\n", + " \n", + " # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) \n", + " return prox, proximity_map_dist, proximity_map_theta\n", + "\n", + "### New functions for selective sensors ####\n", + "\n", + "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n", + " ### Put ent_sensed_type instead of entity_type ###\n", + " mask = jnp.where(state.entities.ent_sensed_type[ent_target_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_target_idx):\n", + " return agent_raw_proxs\n", + "\n", + "# TODO : Use a fori_loop on this later\n", + "def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities):\n", + " for ent_type_id, sensed in enumerate(sensed_entities):\n", + " agent_raw_proxs = jax.lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx)\n", + " proxs = jnp.max(agent_raw_proxs, axis=0)\n", + "\n", + " return proxs\n", + "\n", + "### TODO 1 : \n", + "def compute_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_idx):\n", + " behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed)\n", + " behavior_motors = compute_motor(behavior_prox, params)\n", + " return behavior_prox, behavior_motors\n", + "\n", + "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, None, None))\n", + "\n", + "def compute_agent_proxs_motors(state, agent_idx, params, sensed, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n", + " ent_ag_idx = ag_idx_dense_senders[agent_idx]\n", + " ent_target_idx = ag_idx_dense_receivers[agent_idx]\n", + " agent_raw_proxs = raw_proxs[ent_ag_idx]\n", + "\n", + " agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_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, None, None, None))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "class SelectiveSensorsBraitenbergEnv(BaseEnv):\n", + " def __init__(\n", + " self,\n", + " box_size=100,\n", + " dt=0.1,\n", + " max_agents=10,\n", + " max_objects=2,\n", + " neighbor_radius=100.,\n", + " collision_alpha=0.5,\n", + " collision_eps=0.1,\n", + " n_dims=2,\n", + " seed=0,\n", + " diameter=5.0,\n", + " friction=0.1,\n", + " mass_center=1.0,\n", + " mass_orientation=0.125,\n", + " existing_agents=10,\n", + " existing_objects=2,\n", + " behaviors=Behaviors.AGGRESSION.value,\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", + " agents_color=jnp.array([0.0, 0.0, 1.0]),\n", + " objects_color=jnp.array([1.0, 0.0, 0.0])\n", + " ):\n", + " \n", + " # TODO : add docstrings\n", + " # general parameters\n", + " self.box_size = box_size\n", + " self.dt = dt\n", + " self.max_agents = max_agents\n", + " self.max_objects = max_objects\n", + " self.neighbor_radius = neighbor_radius\n", + " self.collision_alpha = collision_alpha\n", + " self.collision_eps = collision_eps\n", + " self.n_dims = n_dims\n", + " self.seed = seed\n", + " # entities parameters\n", + " self.diameter = diameter\n", + " self.friction = friction\n", + " self.mass_center = mass_center\n", + " self.mass_orientation = mass_orientation\n", + " self.existing_agents = existing_agents\n", + " self.existing_objects = existing_objects\n", + " # agents parameters\n", + " self.behaviors = behaviors\n", + " self.wheel_diameter = wheel_diameter\n", + " self.speed_mul = speed_mul\n", + " self.max_speed = max_speed\n", + " self.theta_mul = theta_mul\n", + " self.prox_dist_max = prox_dist_max\n", + " self.prox_cos_min = prox_cos_min\n", + " self.agents_color = agents_color\n", + " # objects parameters\n", + " self.objects_color = objects_color\n", + " # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? \n", + " # Or can also directly initialize the state ... and jax_md attributes in this function too ...\n", + "\n", + " def init_state(self) -> State:\n", + " key = random.PRNGKey(self.seed)\n", + " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", + "\n", + " entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations)\n", + " agents = self.init_agents()\n", + " objects = self.init_objects()\n", + " state = self.init_complete_state(entities, agents, objects)\n", + "\n", + " # Create jax_md attributes for environment physics\n", + " # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes)\n", + " state = self.init_env_physics(key, state)\n", + "\n", + " return state\n", + " \n", + " def distance(self, point1, point2):\n", + " diff = self.displacement(point1, point2)\n", + " squared_diff = jnp.sum(jnp.square(diff))\n", + " return jnp.sqrt(squared_diff)\n", + " \n", + " # TODO See how to clean the function to remove the agents_neighs_idx\n", + " @partial(jit, static_argnums=(0,))\n", + " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]:\n", + "\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", + " targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n", + " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask)\n", + "\n", + " # TODO : 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 = compute_all_agents_proxs_motors(\n", + " state,\n", + " state.agents.ent_idx,\n", + " state.agents.params,\n", + " state.agents.sensed,\n", + " raw_proxs,\n", + " ag_idx_dense_senders,\n", + " ag_idx_dense_receivers,\n", + " )\n", + "\n", + " # TODO : Relou de rajouter les proximeters non ? En vrai non juste un array de proximeters pour chaque agent\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", + " return state, neighbors\n", + " \n", + " def step(self, state: State) -> State:\n", + " current_state = state\n", + " state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense)\n", + "\n", + " if self.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", + " neighbors = self.allocate_neighbors(state)\n", + " assert not neighbors.did_buffer_overflow\n", + "\n", + " self.neighbors = neighbors\n", + " return state\n", + "\n", + " # TODO See how we deal with agents_neighs_idx\n", + " def allocate_neighbors(self, state, position=None):\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 (not the cleanest to attribute it to with self here)\n", + " ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", + " self.agents_neighs_idx = neighbors.idx[:, ag_idx]\n", + " agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n", + " # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n", + " agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders]\n", + " # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)])\n", + " self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n", + " return neighbors\n", + " \n", + " # TODO : Modify these functions so can give either 1 param and apply it to every entity or give custom ones\n", + " def init_entities(self, key_agents_pos, key_objects_pos, key_orientations):\n", + " n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size\n", + " objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value)\n", + " object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents))))\n", + " exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects))))\n", + " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", + "\n", + " ### TODO : Actually find a way to init this later\n", + " ent_sensed_types = jnp.zeros(n_entities)\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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)),\n", + " entity_type=entity_types,\n", + " ent_sensed_type=ent_sensed_types,\n", + " entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))),\n", + " diameter=jnp.full((n_entities), self.diameter),\n", + " friction=jnp.full((n_entities), self.friction),\n", + " exists=exists\n", + " )\n", + " \n", + " def init_agents(self):\n", + " # TODO : Change that so can define custom behaviors (e.g w a list)\n", + " # Use numpy cuz jnp elements cannot be keys of a dict\n", + " behaviors = np.full((self.max_agents), self.behaviors)\n", + " # Cannot use a vmap fn because of dictionary, cannot have jax elements as a key because its unhashable\n", + " params = jnp.array([behavior_to_params(behavior) for behavior in behaviors])\n", + "\n", + " ### TODO : Change that later\n", + " sensed = jnp.zeros(self.max_agents)\n", + "\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(self.max_agents, dtype=int), \n", + " prox=jnp.zeros((self.max_agents, 2)),\n", + " motor=jnp.zeros((self.max_agents, 2)),\n", + " behavior=behaviors,\n", + " params=params,\n", + " sensed=sensed,\n", + " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", + " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", + " max_speed=jnp.full((self.max_agents), self.max_speed),\n", + " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", + " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", + " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", + " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", + " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", + " color=jnp.tile(self.agents_color, (self.max_agents, 1))\n", + " )\n", + "\n", + " def init_objects(self):\n", + " # Entities idx of objects\n", + " start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects \n", + " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", + "\n", + " return ObjectState(\n", + " ent_idx=objects_ent_idx,\n", + " color=jnp.tile(self.objects_color, (self.max_objects, 1))\n", + " )\n", + " \n", + " def init_complete_state(self, entities, agents, objects):\n", + " lg.info('Initializing state')\n", + " return State(\n", + " time=0,\n", + " box_size=self.box_size,\n", + " max_agents=self.max_agents,\n", + " max_objects=self.max_objects,\n", + " neighbor_radius=self.neighbor_radius,\n", + " collision_alpha=self.collision_alpha,\n", + " collision_eps=self.collision_eps,\n", + " dt=self.dt,\n", + " entities=entities,\n", + " agents=agents,\n", + " objects=objects\n", + " ) \n", + " \n", + " def init_env_physics(self, key, state):\n", + " lg.info(\"Initializing environment's physics features\")\n", + " key, physics_key = random.split(key)\n", + " self.displacement, self.shift = space.periodic(self.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", + " self.box_size,\n", + " r_cutoff=self.neighbor_radius,\n", + " dr_threshold=10.,\n", + " capacity_multiplier=1.5,\n", + " format=partition.Sparse\n", + " )\n", + "\n", + " state = self.init_fn(state, physics_key)\n", + " lg.info(\"Allocating neighbors\")\n", + " neighbors = self.allocate_neighbors(state)\n", + " self.neighbors = neighbors\n", + "\n", + " return state\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "env = SelectiveSensorsBraitenbergEnv(\n", + " max_agents=10,\n", + " max_objects=10,\n", + " existing_agents=10,\n", + " existing_objects=10\n", + ")\n", + "\n", + "state = env.init_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "n_preys = 5\n", + "n_preds = 5\n", + "n_ress = 5\n", + "n_pois = 5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets define an env with 5 preys, 5 predators, 5 ressources and 5 agents" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "prey: 0\n", + "pred: 1\n", + "ressource: 2\n", + "poison: 3\n" + ] + } + ], + "source": [ + "print(f\"prey: {EntitySensedType.PREY.value}\")\n", + "print(f\"pred: {EntitySensedType.PRED.value}\")\n", + "print(f\"ressource: {EntitySensedType.RESSOURCE.value}\")\n", + "print(f\"poison: {EntitySensedType.POISON.value}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "sensed_ent_types = jnp.concatenate([\n", + " jnp.full(n_preys, EntitySensedType.PREY.value),\n", + " jnp.full(n_preds, EntitySensedType.PRED.value),\n", + " jnp.full(n_ress, EntitySensedType.RESSOURCE.value),\n", + " jnp.full(n_pois, EntitySensedType.POISON.value),\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3], dtype=int32, weak_type=True)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "entities = state.entities.replace(ent_sensed_type=sensed_ent_types)\n", + "entities.ent_sensed_type" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now lets give to prey agents a behavior of love towards ressources and preys, and fear towards predators and poison.\n", + "Let's also give a behavior of aggression to predators towards preys, and a behavior of fear towards poison. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5, 2, 2, 3) (5, 2, 4)\n" + ] + } + ], + "source": [ + "# Prey behaviors\n", + "love = behavior_to_params(Behaviors.LOVE.value)\n", + "fear = behavior_to_params(Behaviors.FEAR.value)\n", + "sensed_love = jnp.array([1, 0, 1, 0])\n", + "sensed_fear = jnp.array([0, 1, 0, 1])\n", + "prey_params = jnp.array([love, fear])\n", + "prey_sensed = jnp.array([sensed_love, sensed_fear])\n", + "\n", + "# Do like if we had batches of params and sensed entities for all agents\n", + "prey_batch_params = jnp.tile(prey_params[None], (n_preys, 1, 1 ,1))\n", + "prey_batch_sensed = jnp.tile(prey_sensed[None], (n_preys, 1, 1))\n", + "print(prey_batch_params.shape, prey_batch_sensed.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5, 2, 2, 3) (5, 2, 4)\n" + ] + } + ], + "source": [ + "# Pred behaviors\n", + "aggr = behavior_to_params(Behaviors.AGGRESSION.value)\n", + "fear = behavior_to_params(Behaviors.FEAR.value)\n", + "sensed_aggr = jnp.array([1, 0, 0, 0])\n", + "sensed_fear = jnp.array([0, 0, 0, 1])\n", + "pred_params = jnp.array([aggr, fear])\n", + "pred_sensed = jnp.array([sensed_aggr, sensed_fear])\n", + "\n", + "# Do like if we had batches of params and sensed entities for all agents\n", + "pred_batch_params = jnp.tile(pred_params[None], (n_preys, 1, 1 ,1))\n", + "pred_batch_sensed = jnp.tile(pred_sensed[None], (n_preys, 1, 1))\n", + "print(pred_batch_params.shape, pred_batch_sensed.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 2, 2, 3) (10, 2, 4)\n" + ] + } + ], + "source": [ + "params = jnp.concatenate([prey_batch_params, pred_batch_params], axis=0)\n", + "sensed = jnp.concatenate([prey_batch_sensed, pred_batch_sensed], axis=0)\n", + "print(params.shape, sensed.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally lets give some colors to all entities: Blue for preys, red for preds, green for ressources and purple for poison" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "prey_color = jnp.array([0., 0., 1.])\n", + "pred_color = jnp.array([1., 0., 0.])\n", + "\n", + "prey_color=jnp.tile(prey_color, (n_preys, 1))\n", + "pred_color=jnp.tile(pred_color, (n_preds, 1))\n", + "\n", + "agent_colors = jnp.concatenate([\n", + " prey_color,\n", + " pred_color\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "agents = state.agents.replace(\n", + " params=params,\n", + " sensed=sensed,\n", + " color=agent_colors\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "res_color = jnp.array([0., 1., 0.])\n", + "pois_color = jnp.array([1., 0., 1.])\n", + "\n", + "res_color=jnp.tile(res_color, (n_preys, 1))\n", + "pois_color=jnp.tile(pois_color, (n_preds, 1))\n", + "\n", + "objects_colors = jnp.concatenate([\n", + " res_color,\n", + " pois_color\n", + "])\n", + "\n", + "objects = state.objects.replace(color=objects_colors)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "state = state.replace(\n", + " entities=entities,\n", + " agents=agents,\n", + " objects=objects)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from vivarium.experimental.environments.braitenberg.render import render, render_history" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "n_steps = 10000\n", + "hist = []\n", + "\n", + "for i in range(n_steps):\n", + " state = env.step(state)\n", + " hist.append(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "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 +} From 185d403e64c49a7e065214c6ec52908abf48d359 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Mon, 8 Jul 2024 18:35:45 +0200 Subject: [PATCH 16/18] Add manual mode in selective sensors and add some documentation --- .../notebooks/selective_sensors.ipynb | 1011 ++++++++--------- 1 file changed, 497 insertions(+), 514 deletions(-) diff --git a/vivarium/experimental/notebooks/selective_sensors.ipynb b/vivarium/experimental/notebooks/selective_sensors.ipynb index e6302b0..24759de 100644 --- a/vivarium/experimental/notebooks/selective_sensors.ipynb +++ b/vivarium/experimental/notebooks/selective_sensors.ipynb @@ -2,20 +2,16 @@ "cells": [ { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "# TODO : Remove that (just comes from a jax_md error where gpu isn't detected anymore)\n", - "import os\n", - "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", - "\n", "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", "\n", @@ -27,15 +23,28 @@ "from jax_md import simulate \n", "from jax_md import space, rigid_body, partition, quantity\n", "\n", - "from vivarium.experimental.environments.utils import normal\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.physics_engine import total_collision_energy, friction_force, dynamics_fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add entity sensed type as a field in entities + sensed in agents" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ "\n", "### Define the constants and the classes of the environment to store its state ###\n", - "\n", "SPACE_NDIMS = 2\n", "\n", - "# TODO : Should maybe just let the user define its own class and just have a base class State with time ... \n", "class EntityType(Enum):\n", " AGENT = 0\n", " OBJECT = 1\n", @@ -46,20 +55,21 @@ " RESSOURCE = 2\n", " POISON = 3\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_sensed_type: jnp.array\n", " entity_idx: jnp.array\n", " diameter: jnp.array\n", " friction: jnp.array\n", " exists: jnp.array\n", - " ent_sensed_type: jnp.array\n", - "\n", + " \n", "@struct.dataclass\n", "class ParticleState:\n", " ent_idx: jnp.array\n", " color: jnp.array\n", - " \n", + "\n", "@struct.dataclass\n", "class AgentState(ParticleState):\n", " prox: jnp.array\n", @@ -82,8 +92,6 @@ "\n", "@struct.dataclass\n", "class State(BaseState):\n", - " time: jnp.int32\n", - " box_size: jnp.int32\n", " max_agents: jnp.int32\n", " max_objects: jnp.int32\n", " neighbor_radius: jnp.float32\n", @@ -92,14 +100,112 @@ " collision_eps: jnp.float32\n", " entities: EntityState\n", " agents: AgentState\n", - " objects: ObjectState \n", + " objects: ObjectState " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rewrote relative position + get_relative_displacement" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ "\n", "### Define helper functions used to step from one state to the next one ###\n", + "def relative_position(displ, theta):\n", + " \"\"\"\n", + " Compute the relative distance and angle from a source agent to a target agent\n", + " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", + " :param theta: Orientation of the source agent (in the reference frame of the map)\n", + " :return: dist: distance from source to target.\n", + " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", + " \"\"\"\n", + " dist = jnp.linalg.norm(displ)\n", + " norm_displ = displ / dist\n", + " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", + " relative_theta = theta_displ - theta\n", + " return dist, relative_theta\n", + "\n", + "proximity_map = vmap(relative_position, (0, 0))\n", "\n", + "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n", + "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\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", - "#--- 2 Functions to compute the motor activations of braitenberg agents ---#\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\n", "\n", - "# TODO : See how we'll handle this on client side\n", + "#--- 1 Functions to compute the proximeter of braitenberg agents ---#\n", + "proximity_map = vmap(relative_position, (0, 0))\n", + "\n", + "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", + " \"\"\"\n", + " Compute the proximeter activations (left, right) induced by the presence of an entity\n", + " :param dist: distance from the agent to the entity\n", + " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", + " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", + " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", + " :return: left and right proximeter activation in a jnp array with shape (2,)\n", + " \"\"\"\n", + " cos_dir = jnp.cos(relative_theta)\n", + " prox = 1. - (dist / dist_max)\n", + " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", + " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", + " left = in_view * at_left * prox\n", + " right = in_view * (1. - at_left) * prox\n", + " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", + "\n", + "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", + "\n", + "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", + " \"\"\"Return the sensor values of all agents\n", + "\n", + " :param dist: relative distances between agents and targets\n", + " :param relative_theta: relative angles between agents and targets\n", + " :param dist_max: maximum range of proximeters\n", + " :param cos_min: cosinus of proximeters angles\n", + " :param max_agents: number of agents\n", + " :param senders: indexes of agents sensing the environment\n", + " :param target_exists: mask to indicate which sensed entities exist or not \n", + " :return: proximeter activations\n", + " \"\"\"\n", + " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", + " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", + " proxs = ops.segment_max(\n", + " raw_proxs,\n", + " senders, \n", + " max_agents)\n", + " \n", + " return proxs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just put the behavior and compute motor functions and classes from simple braitenberg, 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 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ "class Behaviors(Enum):\n", " FEAR = 0\n", " AGGRESSION = 1\n", @@ -108,7 +214,6 @@ " NOOP = 4\n", " MANUAL = 5\n", "\n", - "# TODO : Could find a better name than params ? Or can be good enough\n", "behavior_params = {\n", " Behaviors.FEAR.value: jnp.array(\n", " [[1., 0., 0.], \n", @@ -128,37 +233,169 @@ "}\n", "\n", "def behavior_to_params(behavior):\n", + " \"\"\"Return the params associated to a behavior.\n", + "\n", + " :param behavior: behavior id (int)\n", + " :return: params\n", + " \"\"\"\n", " return behavior_params[behavior]\n", "\n", - "def compute_motor(proxs, params):\n", - " \"\"\"Compute motor values according to proximeter values and \"params\"\n", + "def linear_behavior(proxs, params):\n", + " \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n", "\n", - " :param proxs: _description_\n", - " :param params: _description_\n", - " :return: _description_\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", - "sensorimotor = vmap(compute_motor, in_axes=(0, 0))\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\n", "\n", "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", + " \"\"\"Return the forward and angular speeds according the the speeds of left and right wheels\n", + "\n", + " :param left_spd: left wheel speed\n", + " :param right_spd: right wheel speed\n", + " :param base_length: distance between two wheels (diameter of the agent)\n", + " :param wheel_diameter: diameter of wheels\n", + " :return: forward and angular speeds\n", + " \"\"\"\n", " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", " return fwd, rot\n", "\n", "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", + " \"\"\"Return the left and right wheels speeds according to the forward and angular speeds\n", + "\n", + " :param fwd: forward speed\n", + " :param rot: angular speed\n", + " :param base_length: distance between wheels (diameter of agent)\n", + " :param wheel_diameter: diameter of wheels\n", + " :return: left wheel speed, right wheel speed\n", + " \"\"\"\n", " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", " return left, right\n", "\n", "def motor_command(wheel_activation, base_length, wheel_diameter):\n", + " \"\"\"Return the forward and angular speed according to wheels speeds\n", + "\n", + " :param wheel_activation: wheels speeds\n", + " :param base_length: distance between wheels\n", + " :param wheel_diameter: wheel diameters\n", + " :return: forward and angular speeds\n", + " \"\"\"\n", " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", " return fwd, rot\n", "\n", - "motor_command = vmap(motor_command, (0, 0, 0))\n", + "motor_command = vmap(motor_command, (0, 0, 0))" + ] + }, + { + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n", + " mask = jnp.where(state.entities.ent_sensed_type[ent_target_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_target_idx):\n", + " return agent_raw_proxs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n", "\n", - "#--- 3 Functions to compute the different forces in the environment ---#\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", + "- --> vmaped version 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", + " --> vmaped version: computes this for all agents (vmap over params, sensed and agent_raw_proxs) \n", + "\n", + "TODO --> Should surely also vmap on behaviors and motors for an agent (here only use the params)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO : Use a fori_loop on this later\n", + "def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities):\n", + " for ent_type_id, sensed in enumerate(sensed_entities):\n", + " # need the lax.cond because you don't want to change the proxs if you perceive the entity\n", + " # but you want to mask the raw proxs if you don't detect it\n", + " agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx)\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_target_idx):\n", + " behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_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", + " behavior = jnp.expand_dims(behavior, axis=1)\n", + " ent_ag_idx = ag_idx_dense_senders[agent_idx]\n", + " ent_target_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_target_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": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ "\n", "# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces\n", "def braintenberg_force_fn(displacement):\n", @@ -223,237 +460,42 @@ " orientation = mf.orientation\n", " return rigid_body.RigidBody(center=center, orientation=orientation)\n", "\n", - " return force_fn\n", - "\n", - "\n", - "#--- 1 Functions to compute the proximeter of braitenberg agents ---#\n", - "\n", - "def relative_position(displ, theta):\n", - " \"\"\"\n", - " Compute the relative distance and angle from a source agent to a target agent\n", - " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", - " :param theta: Orientation of the source agent (in the reference frame of the map)\n", - " :return: dist: distance from source to target.\n", - " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", - " \"\"\"\n", - " dist = jnp.linalg.norm(displ)\n", - " norm_displ = displ / dist\n", - " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", - " relative_theta = theta_displ - theta\n", - " return dist, relative_theta\n", - "\n", - "proximity_map = vmap(relative_position, (0, 0))\n", - "\n", - "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n", - "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\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\n", - "\n", - "# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority)\n", - "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", - " \"\"\"\n", - " Compute the proximeter activations (left, right) induced by the presence of an entity\n", - " :param dist: distance from the agent to the entity\n", - " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", - " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", - " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", - " :return: left and right proximeter activation in a jnp array with shape (2,)\n", - " \"\"\"\n", - " cos_dir = jnp.cos(relative_theta)\n", - " prox = 1. - (dist / dist_max)\n", - " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", - " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", - " left = in_view * at_left * prox\n", - " right = in_view * (1. - at_left) * prox\n", - " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", - "\n", - "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", - "\n", - "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", - " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", - "\n", - " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", - " proxs = ops.segment_max(\n", - " raw_proxs,\n", - " senders, \n", - " max_agents)\n", - " \n", - " return proxs\n", - "\n", - "# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority)\n", - "def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):\n", - " \"\"\"\n", - " Set agents' proximeter activations\n", - " :param state: full simulation State\n", - " :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),\n", - " where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.\n", - " :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).\n", - " target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).\n", - " :return:\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)(Ra, Rb) # Looks like it should be opposite, but don't understand why\n", - "\n", - " # Create distance and angle maps between entities\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", - "\n", - " # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents)\n", - " mask = target_exists_mask[agents_neighs_idx[1, :]] \n", - " prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],\n", - " state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)\n", - " \n", - " # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) \n", - " return prox, proximity_map_dist, proximity_map_theta\n", - "\n", - "### New functions for selective sensors ####\n", - "\n", - "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n", - " ### Put ent_sensed_type instead of entity_type ###\n", - " mask = jnp.where(state.entities.ent_sensed_type[ent_target_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_target_idx):\n", - " return agent_raw_proxs\n", - "\n", - "# TODO : Use a fori_loop on this later\n", - "def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities):\n", - " for ent_type_id, sensed in enumerate(sensed_entities):\n", - " agent_raw_proxs = jax.lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx)\n", - " proxs = jnp.max(agent_raw_proxs, axis=0)\n", - "\n", - " return proxs\n", - "\n", - "### TODO 1 : \n", - "def compute_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_idx):\n", - " behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed)\n", - " behavior_motors = compute_motor(behavior_prox, params)\n", - " return behavior_prox, behavior_motors\n", - "\n", - "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, None, None))\n", - "\n", - "def compute_agent_proxs_motors(state, agent_idx, params, sensed, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n", - " ent_ag_idx = ag_idx_dense_senders[agent_idx]\n", - " ent_target_idx = ag_idx_dense_receivers[agent_idx]\n", - " agent_raw_proxs = raw_proxs[ent_ag_idx]\n", - "\n", - " agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, agent_raw_proxs, ent_target_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, None, None, None))\n" + " return force_fn" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "class SelectiveSensorsBraitenbergEnv(BaseEnv):\n", - " def __init__(\n", - " self,\n", - " box_size=100,\n", - " dt=0.1,\n", - " max_agents=10,\n", - " max_objects=2,\n", - " neighbor_radius=100.,\n", - " collision_alpha=0.5,\n", - " collision_eps=0.1,\n", - " n_dims=2,\n", - " seed=0,\n", - " diameter=5.0,\n", - " friction=0.1,\n", - " mass_center=1.0,\n", - " mass_orientation=0.125,\n", - " existing_agents=10,\n", - " existing_objects=2,\n", - " behaviors=Behaviors.AGGRESSION.value,\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", - " agents_color=jnp.array([0.0, 0.0, 1.0]),\n", - " objects_color=jnp.array([1.0, 0.0, 0.0])\n", - " ):\n", - " \n", - " # TODO : add docstrings\n", - " # general parameters\n", - " self.box_size = box_size\n", - " self.dt = dt\n", - " self.max_agents = max_agents\n", - " self.max_objects = max_objects\n", - " self.neighbor_radius = neighbor_radius\n", - " self.collision_alpha = collision_alpha\n", - " self.collision_eps = collision_eps\n", - " self.n_dims = n_dims\n", + "\n", + "#--- 4 Define the environment class with its different functions (step ...) ---#\n", + "class SelectiveSensorsEnv(BaseEnv):\n", + " def __init__(self, state, seed=42):\n", " self.seed = seed\n", - " # entities parameters\n", - " self.diameter = diameter\n", - " self.friction = friction\n", - " self.mass_center = mass_center\n", - " self.mass_orientation = mass_orientation\n", - " self.existing_agents = existing_agents\n", - " self.existing_objects = existing_objects\n", - " # agents parameters\n", - " self.behaviors = behaviors\n", - " self.wheel_diameter = wheel_diameter\n", - " self.speed_mul = speed_mul\n", - " self.max_speed = max_speed\n", - " self.theta_mul = theta_mul\n", - " self.prox_dist_max = prox_dist_max\n", - " self.prox_cos_min = prox_cos_min\n", - " self.agents_color = agents_color\n", - " # objects parameters\n", - " self.objects_color = objects_color\n", - " # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? \n", - " # Or can also directly initialize the state ... and jax_md attributes in this function too ...\n", - "\n", - " def init_state(self) -> State:\n", - " key = random.PRNGKey(self.seed)\n", - " key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n", - "\n", - " entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations)\n", - " agents = self.init_agents()\n", - " objects = self.init_objects()\n", - " state = self.init_complete_state(entities, agents, objects)\n", - "\n", - " # Create jax_md attributes for environment physics\n", - " # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes)\n", - " state = self.init_env_physics(key, state)\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", + "\n", + " self.neighbors = self.allocate_neighbors(state)\n", + " # self.neighbors, self.agents_neighs_idx = self.allocate_neighbors(state)\n", "\n", - " return state\n", - " \n", " def distance(self, point1, point2):\n", - " diff = self.displacement(point1, point2)\n", - " squared_diff = jnp.sum(jnp.square(diff))\n", - " return jnp.sqrt(squared_diff)\n", + " return distance(self.displacement, point1, point2)\n", " \n", - " # TODO See how to clean the function to remove the agents_neighs_idx\n", + " ### Add ag_idx_dense !!! \n", " @partial(jit, static_argnums=(0,))\n", " def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]:\n", - "\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", @@ -462,6 +504,7 @@ " targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n", " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask)\n", "\n", + " # 2: Use dense idx for neighborhoods to vmap all of this\n", " # TODO : 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", @@ -470,12 +513,13 @@ " 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", - " # TODO : Relou de rajouter les proximeters non ? En vrai non juste un array de proximeters pour chaque agent\n", " agents = state.agents.replace(\n", " prox=agent_proxs, \n", " proximity_map_dist=proximity_dist_map, \n", @@ -488,9 +532,13 @@ " 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", + " if state.entities.momentum is None:\n", + " state = self.init_fn(state, self.init_key)\n", + " \n", " current_state = state\n", " state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense)\n", "\n", @@ -502,8 +550,7 @@ "\n", " self.neighbors = neighbors\n", " return state\n", - "\n", - " # TODO See how we deal with agents_neighs_idx\n", + " \n", " def allocate_neighbors(self, state, position=None):\n", " position = state.entities.position.center if position is None else position\n", " neighbors = self.neighbor_fn.allocate(position)\n", @@ -511,235 +558,114 @@ " # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here)\n", " ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n", " self.agents_neighs_idx = neighbors.idx[:, ag_idx]\n", - " agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n", + " agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)])\n", " # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n", " agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders]\n", " # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)])\n", " self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n", - " return neighbors\n", - " \n", - " # TODO : Modify these functions so can give either 1 param and apply it to every entity or give custom ones\n", - " def init_entities(self, key_agents_pos, key_objects_pos, key_orientations):\n", - " n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size\n", - " objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value)\n", - " object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents))))\n", - " exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects))))\n", - " exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n", - "\n", - " ### TODO : Actually find a way to init this later\n", - " ent_sensed_types = jnp.zeros(n_entities)\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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)),\n", - " entity_type=entity_types,\n", - " ent_sensed_type=ent_sensed_types,\n", - " entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))),\n", - " diameter=jnp.full((n_entities), self.diameter),\n", - " friction=jnp.full((n_entities), self.friction),\n", - " exists=exists\n", - " )\n", - " \n", - " def init_agents(self):\n", - " # TODO : Change that so can define custom behaviors (e.g w a list)\n", - " # Use numpy cuz jnp elements cannot be keys of a dict\n", - " behaviors = np.full((self.max_agents), self.behaviors)\n", - " # Cannot use a vmap fn because of dictionary, cannot have jax elements as a key because its unhashable\n", - " params = jnp.array([behavior_to_params(behavior) for behavior in behaviors])\n", - "\n", - " ### TODO : Change that later\n", - " sensed = jnp.zeros(self.max_agents)\n", - "\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(self.max_agents, dtype=int), \n", - " prox=jnp.zeros((self.max_agents, 2)),\n", - " motor=jnp.zeros((self.max_agents, 2)),\n", - " behavior=behaviors,\n", - " params=params,\n", - " sensed=sensed,\n", - " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", - " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", - " max_speed=jnp.full((self.max_agents), self.max_speed),\n", - " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", - " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", - " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", - " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", - " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", - " color=jnp.tile(self.agents_color, (self.max_agents, 1))\n", - " )\n", - "\n", - " def init_objects(self):\n", - " # Entities idx of objects\n", - " start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects \n", - " objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n", - "\n", - " return ObjectState(\n", - " ent_idx=objects_ent_idx,\n", - " color=jnp.tile(self.objects_color, (self.max_objects, 1))\n", - " )\n", - " \n", - " def init_complete_state(self, entities, agents, objects):\n", - " lg.info('Initializing state')\n", - " return State(\n", - " time=0,\n", - " box_size=self.box_size,\n", - " max_agents=self.max_agents,\n", - " max_objects=self.max_objects,\n", - " neighbor_radius=self.neighbor_radius,\n", - " collision_alpha=self.collision_alpha,\n", - " collision_eps=self.collision_eps,\n", - " dt=self.dt,\n", - " entities=entities,\n", - " agents=agents,\n", - " objects=objects\n", - " ) \n", - " \n", - " def init_env_physics(self, key, state):\n", - " lg.info(\"Initializing environment's physics features\")\n", - " key, physics_key = random.split(key)\n", - " self.displacement, self.shift = space.periodic(self.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", - " self.box_size,\n", - " r_cutoff=self.neighbor_radius,\n", - " dr_threshold=10.,\n", - " capacity_multiplier=1.5,\n", - " format=partition.Sparse\n", - " )\n", - "\n", - " state = self.init_fn(state, physics_key)\n", - " lg.info(\"Allocating neighbors\")\n", - " neighbors = self.allocate_neighbors(state)\n", - " self.neighbors = neighbors\n", - "\n", - " return state\n" + " return neighbors" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "env = SelectiveSensorsBraitenbergEnv(\n", - " max_agents=10,\n", - " max_objects=10,\n", - " existing_agents=10,\n", - " existing_objects=10\n", - ")\n", - "\n", - "state = env.init_state()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ + "seed = 0\n", + "max_agents = 10\n", + "max_objects = 10\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", + "behavior = Behaviors.AGGRESSION.value\n", + "behaviors=Behaviors.AGGRESSION.value\n", + "existing_agents = None\n", + "existing_objects = None\n", + "\n", "n_preys = 5\n", "n_preds = 5\n", "n_ress = 5\n", - "n_pois = 5" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Lets define an env with 5 preys, 5 predators, 5 ressources and 5 agents" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "prey: 0\n", - "pred: 1\n", - "ressource: 2\n", - "poison: 3\n" - ] - } - ], - "source": [ - "print(f\"prey: {EntitySensedType.PREY.value}\")\n", - "print(f\"pred: {EntitySensedType.PRED.value}\")\n", - "print(f\"ressource: {EntitySensedType.RESSOURCE.value}\")\n", - "print(f\"poison: {EntitySensedType.POISON.value}\")" + "n_pois = 5\n", + "\n", + "key = random.PRNGKey(seed)\n", + "key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ + "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", + "### TODO : Actually find a way to init this later\n", "sensed_ent_types = jnp.concatenate([\n", " jnp.full(n_preys, EntitySensedType.PREY.value),\n", " jnp.full(n_preds, EntitySensedType.PRED.value),\n", " jnp.full(n_ress, EntitySensedType.RESSOURCE.value),\n", " jnp.full(n_pois, EntitySensedType.POISON.value),\n", - "])" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3], dtype=int32, weak_type=True)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "entities = state.entities.replace(ent_sensed_type=sensed_ent_types)\n", - "entities.ent_sensed_type" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now lets give to prey agents a behavior of love towards ressources and preys, and fear towards predators and poison.\n", - "Let's also give a behavior of aggression to predators towards preys, and a behavior of fear towards poison. " + "])\n", + "\n", + "ent_sensed_types = jnp.zeros(n_entities)\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_sensed_type=sensed_ent_types,\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": "code", - "execution_count": 19, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(5, 2, 2, 3) (5, 2, 4)\n" + "(5, 2, 2, 3) (5, 2, 4)\n", + "(5, 2, 2, 3) (5, 2, 4)\n", + "(10, 2, 2, 3) (10, 2, 4) (10, 2)\n" ] } ], @@ -755,23 +681,11 @@ "# Do like if we had batches of params and sensed entities for all agents\n", "prey_batch_params = jnp.tile(prey_params[None], (n_preys, 1, 1 ,1))\n", "prey_batch_sensed = jnp.tile(prey_sensed[None], (n_preys, 1, 1))\n", - "print(prey_batch_params.shape, prey_batch_sensed.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5, 2, 2, 3) (5, 2, 4)\n" - ] - } - ], - "source": [ + "print(prey_batch_params.shape, prey_batch_sensed.shape)\n", + "\n", + "prey_behaviors = jnp.array([Behaviors.LOVE.value, Behaviors.FEAR.value])\n", + "prey_batch_behaviors = jnp.tile(prey_behaviors[None], (n_preys, 1))\n", + "\n", "# Pred behaviors\n", "aggr = behavior_to_params(Behaviors.AGGRESSION.value)\n", "fear = behavior_to_params(Behaviors.FEAR.value)\n", @@ -783,41 +697,18 @@ "# Do like if we had batches of params and sensed entities for all agents\n", "pred_batch_params = jnp.tile(pred_params[None], (n_preys, 1, 1 ,1))\n", "pred_batch_sensed = jnp.tile(pred_sensed[None], (n_preys, 1, 1))\n", - "print(pred_batch_params.shape, pred_batch_sensed.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(10, 2, 2, 3) (10, 2, 4)\n" - ] - } - ], - "source": [ + "print(pred_batch_params.shape, pred_batch_sensed.shape)\n", + "\n", + "pred_behaviors = jnp.array([Behaviors.AGGRESSION.value, Behaviors.FEAR.value])\n", + "pred_batch_behaviors = jnp.tile(pred_behaviors[None], (n_preds, 1))\n", + "\n", + "\n", "params = jnp.concatenate([prey_batch_params, pred_batch_params], axis=0)\n", "sensed = jnp.concatenate([prey_batch_sensed, pred_batch_sensed], axis=0)\n", - "print(params.shape, sensed.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally lets give some colors to all entities: Blue for preys, red for preds, green for ressources and purple for poison" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ + "behaviors = jnp.concatenate([prey_batch_behaviors, pred_batch_behaviors], axis=0)\n", + "print(params.shape, sensed.shape, behaviors.shape)\n", + "\n", + "\n", "prey_color = jnp.array([0., 0., 1.])\n", "pred_color = jnp.array([1., 0., 0.])\n", "\n", @@ -827,28 +718,39 @@ "agent_colors = jnp.concatenate([\n", " prey_color,\n", " pred_color\n", - "])" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "agents = state.agents.replace(\n", + "])\n", + "\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", - " color=agent_colors\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=jnp.tile(agent_colors, (max_agents, 1))\n", + ")\n" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ + "\n", + "# Entities idx of objects\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", "res_color = jnp.array([0., 1., 0.])\n", "pois_color = jnp.array([1., 0., 1.])\n", "\n", @@ -860,24 +762,36 @@ " pois_color\n", "])\n", "\n", - "objects = state.objects.replace(color=objects_colors)" + "objects = ObjectState(\n", + " ent_idx=objects_ent_idx,\n", + " color=jnp.tile(objects_colors, (max_objects, 1))\n", + ")" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ - "state = state.replace(\n", + "state = State(\n", + " time=0,\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", + " dt=dt,\n", " entities=entities,\n", " agents=agents,\n", - " objects=objects)" + " objects=objects\n", + ") " ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -886,12 +800,12 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiEAAAIjCAYAAADV38uMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABaF0lEQVR4nO3dd3wUdf7H8ddmUyEkoSYggaCA9CIIAjY0isghCKIip4CIjSLgz352EcF2BygIJyAKdin2g1BOepMggoAcTSAgJYm0lN35/TGwEgiyZTazSd7PPOaBmfLdTybCvvc73/mOwzAMAxEREZEiFmZ3ASIiIlI6KYSIiIiILRRCRERExBYKISIiImILhRARERGxhUKIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkTEZz/99BO33HILNWvWJDo6mgsuuIDrrruOMWPGePZ5+eWXmTlzpt+vsWHDBp577jm2b98eeMEiEpIcenaMiPhiyZIltG/fnho1atC7d2+SkpLYtWsXy5YtY+vWrfz6668AxMbGcssttzBlyhS/Xuezzz6jR48ezJ8/n6uvvtq6H0BEQka43QWISPEyfPhw4uPjWblyJQkJCQW27d+/356iRKRY0uUYEfHJ1q1badiw4VkBBKBKlSoAOBwOjh49ynvvvYfD4cDhcNCnTx8AduzYwYMPPsjFF19MTEwMFStWpEePHgUuu0yZMoUePXoA0L59e08bCxYs8Ozz7bffcsUVV1C2bFnKlStHp06d+Pnnn4P1Y4tIEKgnRER8UrNmTZYuXcr69etp1KhRofu8//773HPPPbRq1Yp7770XgIsuugiAlStXsmTJEm6//XaqV6/O9u3bGTduHFdffTUbNmygTJkyXHnllQwePJjRo0fz5JNPUr9+fQDPn++//z69e/emQ4cOjBw5kmPHjjFu3Dguv/xyfvzxR1JSUoJ/IkQkYBoTIiI+mTNnDh07dgSgVatWXHHFFVx77bW0b9+eiIgIz37nGhNy/PhxYmJiCqxbtmwZbdq0YerUqdx5553AuceEHDlyhOTkZHr06MGECRM86/ft28fFF1/MrbfeWmC9iIQuXY4REZ9cd911LF26lJtuuon09HRGjRpFhw4duOCCC5g9e/Z5jz89gOTl5XHw4EFq165NQkICa9asOe/xc+bMITMzk549e3LgwAHP4nQ6ad26NfPnzw/o5xORoqPLMSLis0svvZQvvviC3Nxc0tPTmTFjBm+++Sa33HILa9eupUGDBuc89vjx44wYMYLJkyeze/duTu+MzcrKOu9rb9myBYBrrrmm0O1xcXE+/jQiYheFEBHxW2RkJJdeeimXXnopdevWpW/fvnz66ac8++yz5zxm0KBBTJ48mSFDhtCmTRvi4+NxOBzcfvvtuN3u877mqX3ef/99kpKSztoeHq5/1kSKC/1tFRFLtGzZEoC9e/cC5h0yhfnss8/o3bs3r7/+umfdiRMnyMzMLLDfuY4/NcC1SpUqpKamBlq2iNhIY0JExCfz58+nsPHs33zzDQAXX3wxAGXLlj0rWAA4nc6zjh8zZgwul6vAurJlywKc1UaHDh2Ii4vj5ZdfJi8v76z2f//9d69/FhGxl3pCRMQngwYN4tixY9x8883Uq1eP3NxclixZwscff0xKSgp9+/YFoEWLFsydO5c33niDatWqUatWLVq3bs3f/vY33n//feLj42nQoAFLly5l7ty5VKxYscDrNGvWDKfTyciRI8nKyiIqKoprrrmGKlWqMG7cOO68804uueQSbr/9dipXrszOnTv5+uuvadeuHWPHjrXj1IiIrwwRER98++23xt13323Uq1fPiI2NNSIjI43atWsbgwYNMvbt2+fZ75dffjGuvPJKIyYmxgCM3r17G4ZhGIcPHzb69u1rVKpUyYiNjTU6dOhg/PLLL0bNmjU9+5wyceJE48ILLzScTqcBGPPnz/dsmz9/vtGhQwcjPj7eiI6ONi666CKjT58+xqpVq4rgLIiIFTRPiIiIiNhCY0JERETEFgohIiIiYguFEBEREbGFQoiIiIjYQiFEREREbKEQIiIiIrYo8ZOVud1u9uzZQ7ly5c45DbSIiIiczTAM/vjjD6pVq0ZYmPX9FiU+hOzZs4fk5GS7yxARESm2du3aRfXq1S1vt8SHkHLlygHmCdQjvkVERLyXnZ1NcnKy573UaiU+hJy6BBMXF6cQIiIi4odgDWfQwFQRERGxhUKIiIiI2EIhRERERGxR4seEeMMwDPLz83G5XHaXUmo5nU7Cw8N1G7WISClS6kNIbm4ue/fu5dixY3aXUuqVKVOGqlWrEhkZaXcpIiJSBEp1CHG73Wzbtg2n00m1atWIjIzUJ3EbGIZBbm4uv//+O9u2baNOnTpBmRRHRERCS6kOIbm5ubjdbpKTkylTpozd5ZRqMTExREREsGPHDnJzc4mOjra7JBERCbJSHUJOCeRT944d8OGHsHs3nDgB8fHQogV06wZRURYWWQqo90NEpHRRCPHTf/4Do0fDN99AWJi5GAY4HJCXB+XLw/33w4ABcMEFdldb/OxgB7/xG8c4RgIJ1KUu8cTbXZaIiDU2AouBw0AEkAh0BBJsrMkGCiE+crng4YfhX/+C8HAzeLhc5nK6w4dh1CgYNw6+/hratrWn3uLEjZujHKUnPZnJzALbooiiF70YwAAu4RJ7ChQRCUQeMAsYA/z35DonYABuIBq4E3gQaGZDfTZQ/7cPDAMefNDsAQHIz//r/V0uyM6Ga66B5cuDX19xdoQjbGITBzhAOulnbc8hh6lMpQUtuIEbyCLLhipFRPy0H2gH9MDsATnFhRlAAE4Ak4HmwFOY4aSEUwjxwcSJMGGCGUa85XabYeXGG83ekZLG4XAwc+bMgNrIIotNbMKF2Z3k9vyNLCgfM/XNZS5tacshDgX0uiIiReIA0Ab48eT3fzUl1akPty8DAyjxQUQhxEtuN7z8sn/HulxmAJkyxdKSSoRjHGMrWzF8+JvmwsUmNnETN5FHXhCrExEJkAF0AXbwZ8Dw1jjgLcsrCikKIV6aM8e8EyYQo0ebYcYK3333HZdffjkJCQlUrFiRv/3tb2zdutWzfcmSJTRr1ozo6GhatmzJzJkzcTgcrF271rPP+vXr6dixI7GxsSQmJnLnnXdy4MABz/arr76awYMH8+ijj1KhQgWSkpJ47rnnPNtTUlIAuPnmm3E4HJ7v09PTad++PeXKlSMuLo4WLVqwatWqQn+O3ew+Z8/HX3HhYjGLzxo7IiISUuYBS/jr3o+/8jyU5M9aCiFeGj/eHIjqL8OA7dth/nxr6jl69CjDhg1j1apVpKWlERYWxs0334zb7SY7O5vOnTvTuHFj1qxZw4svvshjjz1W4PjMzEyuueYamjdvzqpVq/juu+/Yt28ft956a4H93nvvPcqWLcvy5csZNWoUL7zwAnPmzAFg5cqVAEyePJm9e/d6vu/VqxfVq1dn5cqVrF69mscff5yIiIizfoYccgIa2+HEyRjG+H28iEjQjSWwW0AOQEn+rKW7Y7y0bt35B6Kej8MBGzfCtdcGXk/37t0LfD9p0iQqV67Mhg0bWLRoEQ6Hg4kTJxIdHU2DBg3YvXs3/fv39+w/duxYmjdvzsunXWOaNGkSycnJbN68mbp16wLQpEkTnn32WQDq1KnD2LFjSUtL47rrrqNy5coAJCQkkJSU5Gln586dPPLII9SrV89zXGEOcKDQ9d5y4eIHfuBnfqYhDQNqS0TEcnuA2eBHZ++fnJh30/SwpKKQo54QL/3xR+BtOJ3m3TJW2LJlCz179uTCCy8kLi7Ocylk586dbNq0iSZNmhSYdbRVq1YFjk9PT2f+/PnExsZ6llOh4fTLOk2aNClwXNWqVdm/f/9f1jZs2DDuueceUlNTeeWVVwq0dzor7nAJI4w00gJuR0TEcj8SWAAB8zJO4VezSwSFEC9ZMau72w2xsYG3A9C5c2cOHTrExIkTWb58OctP3gOcm5vr1fFHjhyhc+fOrF27tsCyZcsWrrzySs9+Z15GcTgcuM8zsOW5557j559/plOnTsybN48GDRowY8aMs/bL93mU1tmcOHWXjIiEJqtmEjiO74NaiwldjvFS7dqwa1dgA0vdbjjZYRGQgwcPsmnTJiZOnMgVV1wBwKJFizzbL774Yj744ANycnKIOjl3/KnxGqdccsklfP7556SkpBAewGCXiIgIXGfO1AbUrVuXunXrMnToUHr27MnkyZO5+eabC+zjIPCHBRoYOHEG3I6IiOWsegSW8+RSAqknxEv9+wd+Z0ulSnDDDYHXUr58eSpWrMiECRP49ddfmTdvHsOGDfNsv+OOO3C73dx7771s3LiR77//ntdeew3A85TgAQMGcOjQIXr27MnKlSvZunUr33//PX379i00VJxLSkoKaWlpZGRkcPjwYY4fP87AgQNZsGABO3bsYPHixaxcuZL69eufdWy4BRnYhYtKVAq4HRERy1WzqJ1EsOAzW0hSCPHSzTdDxYr+H+90wgMPQGRk4LWEhYXx0UcfsXr1aho1asTQoUN59dVXPdvj4uL48ssvWbt2Lc2aNeOpp57imWeeAfCME6lWrRqLFy/G5XJx/fXX07hxY4YMGUJCQoJPD5J7/fXXmTNnDsnJyTRv3hyn08nBgwe56667qFu3LrfeeisdO3bk+eefP+vY8pQP8EyYvSmd6RxwOyIilmsFpATYhhPoG3gpocphGL7M/1n8ZGdnEx8fT1ZWFnFxcQW2nThxgm3btlGrVi2vHh3/4ovw7LO+zZgK5l0xERGwdStUr+7bsVaZNm0affv2JSsri5iYGHuKOEM++aST/udEZSfgwLYD3F/rfnZEn39SlnDC6UQnzRUiIqHrDeAR/B+g6gC2AzWsKsg3f/UeagX1hPjgiSfguuvMJ+Z66+TVDz76qGgDyNSpU1m0aBHbtm1j5syZPPbYY9x6660hE0DADBEVqOD38fnkM4ABFlYkImKxPkAk/l1OcQKdsS2AFAWFEB+Eh8MXX5jjOhyOPwPGX+3vdMK0aeblnKKUkZHB3//+d+rXr8/QoUPp0aMHEyZMKNoivHABFxDB2ROZnU8YYfSiF6mkBqEqERGLVAA+8OM4J+ZYkPHWlhNqFEJ8VLYszJoF//oXXHihue7Mm0ucTrO3pHNnWLIEevYs+jofffRRtm/f7rnk9Oabb1LGivuMLRZJJHWpSzjhXt8t48BBRzoyiUmW3GEjIhJU3YF3Md9xvXnXDQeqAvNP/lmC6RZdP4SHw6BBMHCgOQ37++/Db7/B0aPm4NWWLeGee+CCC+yutHiIIYb61Gcr5qRmhd01cypsRBDBYAYzghGW3F0jIlIk+gI1gSeB5ZjvvmfO/RGG2QNyOzAKSKLE07/iAXA44JprzEUCE0UUF3IheeRxC7cwmtEc57hnewopDGIQvekd0DgSERHbXAMsA9ZiPiF3HnAYc8xIInAHZlgpRbMOKIRISIkkkud4jpd5mWyyOcYxEkgghhhdehGRkqEZ8I7dRYQGhZAArWc905jGHvZwghPEE08LWnAHd1COcnaXV2yFEUbCyS8RESmZFEL8YGDwOZ/zT/7JYhYTTjjGya8wwvg3/2YYw+hLX4YwhNrUtrtkERGRkKO7Y3yURx796EcPerCMZYA5X4ULF27c5JOPgcExjvEO79CUpsxhjs1Vi4iIhB6FEB8YGPSlL1OYApjPLfkr+eRzghPcyI0sYEHwCzxpwYIFOBwOMjMzA9pHREQkmBRCfDCa0Uxj2p/TjHvBffLrJm7id34PYnW+adu2LXv37iU+Pt6S9hRqRETEVwohXnLhYhSj/DrWjZujHGUSkyyuyn+RkZEkJSV5nqorIiJS1BRCvPQN37CHPX4f78bNWMae9xKOt3Jychg8eDBVqlQhOjqayy+/nJUrVxbYZ/HixTRp0oTo6Gguu+wy1q9f79lWWM/FokWLuOKKK4iJiSE5OZnBgwdz9OjRAq/52GOPkZycTFRUFLVr1+bdd99l+/bttG/fHoDy5cvjcDjo06cPAJ999hmNGzcmJiaGihUrkpqaWqBNEREpvRRCvPQO7+DEGVAbv/Ebc5lrST2PPvoon3/+Oe+99x5r1qyhdu3adOjQgUOHDnn2eeSRR3j99ddZuXIllStXpnPnzuTl5RXa3tatW7nhhhvo3r0769at4+OPP2bRokUMHDjQs89dd93Fhx9+yOjRo9m4cSPvvPMOsbGxJCcn8/nnnwOwadMm9u7dy7/+9S/27t1Lz549ufvuu9m4cSMLFiygW7dulPAHN4uIiLeMEi4rK8sAjKysrLO2HT9+3NiwYYNx/Pjx87ZTy6hlEOBXmBFmjDZGB/wzHTlyxIiIiDCmTZvmWZebm2tUq1bNGDVqlDF//nwDMD766CPP9oMHDxoxMTHGxx9/bBiG4dnn8OHDhmEYRr9+/Yx77723wOv88MMPRlhYmHH8+HFj06ZNBmDMmTOn0JrObM8wDGP16tUGYGzfvt2rn8uX34eIiATfX72HWkE9IV46wpGA2wgjjD/4I+B2tm7dSl5eHu3atfOsi4iIoFWrVmzcuNGzrk2bNp7/rlChAhdffHGB7adLT09nypQpxMbGepYOHTrgdrvZtm0ba9euxel0ctVVV3ldZ9OmTbn22mtp3LgxPXr0YOLEiRw+fNiPn1hEREoihRAvlaVswG24cYfsLKpHjhzhvvvuY+3atZ4lPT2dLVu2cNFFFxETE+Nzm06nkzlz5vDtt9/SoEEDxowZw8UXX8y2bduC8BOIiEhxoxDipXrUC3hMiBs3F3FRwLVcdNFFREZGsnjxYs+6vLw8Vq5cSYMGDTzrli1b5vnvw4cPs3nzZurXr19om5dccgkbNmygdu3aZy2RkZE0btwYt9vNwoULCz0+MjISAJer4MBbh8NBu3bteP755/nxxx+JjIxkxowZfv/sIiJSciiEeOle7g34zpYkkrie6wOupWzZsjzwwAM88sgjfPfdd2zYsIH+/ftz7Ngx+vXr59nvhRdeIC0tjfXr19OnTx8qVapE165dC23zscceY8mSJQwcOJC1a9eyZcsWZs2a5RmYmpKSQu/evbn77ruZOXMm27ZtY8GCBXzyyScA1KxZE4fDwVdffcXvv//OkSNHWL58OS+//DKrVq1i586dfPHFF/z+++/nDEIiIlLKBGWkSQixamBqnpFnJBqJAQ1KfdF40bKf6/jx48agQYOMSpUqGVFRUUa7du2MFStWGIbx5yDRL7/80mjYsKERGRlptGrVykhPT/ccX9hA0hUrVhjXXXedERsba5QtW9Zo0qSJMXz48AKvOXToUKNq1apGZGSkUbt2bWPSpEme7S+88IKRlJRkOBwOo3fv3saGDRuMDh06GJUrVzaioqKMunXrGmPGjPnLn0kDU0VEQkewB6Y6DKNk3y+ZnZ1NfHw8WVlZxMXFFdh24sQJtm3bRq1atYiOjj5vWy/nvco/wh/DcPh2ysIII5potrKVJJJ8OjZYvv/+ezp27MiJEyc8l1Ls5uvvQ0REguuv3kOtoMsxXnC7Yds2SE1/mKszu+Lw4aYiB+aMpF/wRcgEkH379jFr1izq1KkTMgFERERKH4WQ83C7YcsWOHjQ7NF46X8fknqoB8B5w0g44UQRxUxm0oEORVGuV2688Ubmzp3LW2+9ZXcpIiJSioXbXUCo27ED/jhtao9II4qXtk2nbXZHPqryLzaV/RGnOxy3w4XhMAgznBgYhBvh3JJ7B09F/x8NaWjfD1CI1atX212CiE+OHYMyZeyuQkSsphDyF44fN3tAzhRGGH872Ju/HezNz2VW8m3FDzgQsYcTYcco5ypP/WMt6HSgN5XCKtCgCaBnxIn4zTBgwwZo2dLuSkTEagohcM5nmfz+Ozgc5j+C59Lw2KU0PHZpodvyXJCZCeXLW1BkKVDCx0iLn+bPhwsvtLsKEQmGUj0mJCIiAoBjx46dtc3lggMH/jqAeGP//sCOL01O/R5O/V5EAL76CmrWtLsKEQmGUt0T4nQ6SUhIYP/JpFCmTBkcDvPaydGj5qDUQP3xh3lZx6FLMudkGAbHjh1j//79JCQk4HQGNjOtFD9uN8ybB+PHw7p1kJ1tjgFJTjY/EOTlgW7kEil5SnUIAUhKMm+b3X9Gl8WxY2ZPiBX+9z8IK9V9Tt5JSEjw/D6kdDAMmDwZhg83/56Eh0N+/p/bt28397ngAhg8GJ54wtxHREqGUj1Z2elcLhd5eXme7xcsgPvvt6aGdev0Ke58IiIi1ANSyrjd8NBDMHasd/s7HHD99fD551A28OdJiogXgj1ZmT5TnOR0Ogu8CVasaN6eG6iYGAjC702k2Hv8ce8DCJg9InPmwK23wqxZ6hERKQl0keAcLrnE7AIORHg43HabNfWIlCTz5sGrr/p+nNsN334Lb79tfU0iUvQUQs7B6YSBAwMby5GfDw8+aF1NIiXF6NGB9WT885/WDBwXEXsphPyFu+82w4g/nE5o3hwuLXwKEZFS67ffYPbsggNQfWEY5rOc5s2zti4RKXoKIX+hShXzE5uvHA5zIOq771pfk0hx9+GHgd+yHh4O779vTT0iYh+FkPO4/3546SXv93c6ITra/KTXvHnw6hIprnbv9r+H8ZT8fNi1y5p6RMQ+CiFeeOop81PXqSks/uof0CZNYPFiSE0tmtpEipvjx61p5+hRa9oREfsohHjp7383P3nNmAFXXVUwiJQpA1WrwqJFsGaNekBE/kp8vDXtVKxoTTsiYh/dae+D8HDo2tVcDMP8JBYebl5++eADTc0u4o0WLcxp2APhdJrtiEjxpp4QPzkcEBtrBhCAW26BTZvsrUmkOLj5ZqhQIbA23G7o39+aekTEPgohFomOhrp17a5CJPRFRsIDD/g/ODU8HP72N6hRw9q6RKToKYRYqFEjuysQKR4efBDKlfMviBgGPPmk9TWJSNFTCLGQVQPuREq6atXg66/NXg1vg8ipMVeTJsFllwWvNhEpOgohImKLtm1h4ULzAY/nezyC02kGlo8/hrvuKpr6RCT4FEJExDatW8Ovv8KoUVCzprkuLMwMHKeCSfny8NhjsGWL+QRdESk5HIZhGHYXEUzZ2dnEx8eTlZVFXFyc3eWIyDm43ebzYDZsgOxsKFsWUlLgxhshKsru6kRKp2C/h2qeEBEJCWFh5kzDmm1YpPTQ5RgRERGxhXpCJHTkALuBLKAMUBXQFTQRkRJLPSFiv83AMKAycBFwCVAPqADcBvwXKNEjl0RESieFELHPEeAW4GJgNPDHGdtdwBfAVUBjYEuRViciIkGmECL2yAQuB2ae/N51jv3yT/75C9AK+DGoVYmISBFSCJGilwd0AdZz7vBxJhdmT8n1wK4g1SUiIkVKIUSK3qeY4zy8DSCnuDB7UF6wuiAREbGDQogUvTH4/39ePvABZhgREZFiTSFEilY6sAxwB9BGDjDVmnJERMQ+toYQl8vF008/Ta1atYiJieGiiy7ixRdf5PSZ5A3D4JlnnqFq1arExMSQmprKli26TaLY+hbw4/HtBRjAlxbUIiIitrI1hIwcOZJx48YxduxYNm7cyMiRIxk1ahRjxozx7DNq1ChGjx7N+PHjWb58OWXLlqVDhw6cOHHCxsrFbwex5v+6/Ra0ISIitrJ1xtQlS5bQpUsXOnXqBEBKSgoffvghK1asAMxekH/+85/84x//oEuXLgBMnTqVxMREZs6cye23335Wmzk5OeTk5Hi+z87OLoKfRERERHxla09I27ZtSUtLY/PmzQCkp6ezaNEiOnbsCMC2bdvIyMgg9bQnWsXHx9O6dWuWLl1aaJsjRowgPj7esyQnJwf/BxHvVSSw8SAADqCKBbWIiIitbA0hjz/+OLfffjv16tUjIiKC5s2bM2TIEHr16gVARkYGAImJiQWOS0xM9Gw70xNPPEFWVpZn2bVLk0qElBvx/dbcwtxkQRsiImIrWy/HfPLJJ0ybNo3p06fTsGFD1q5dy5AhQ6hWrRq9e/f2q82oqCiioqIsrlQs0wRoAyzH/x6RKOAuyyoSERGb2BpCHnnkEU9vCEDjxo3ZsWMHI0aMoHfv3iQlJQGwb98+qlat6jlu3759NGvWzI6SxQqDgMKvpp1fOGYAibeuHBERsYetl2OOHTtGWFjBEpxOJ263+RG5Vq1aJCUlkZaW5tmenZ3N8uXLadOmTZHWKha6BfOhdL7equvEfLLu05ZXJCIiNrC1J6Rz584MHz6cGjVq0LBhQ3788UfeeOMN7r77bgAcDgdDhgzhpZdeok6dOtSqVYunn36aatWq0bVrVztLl0BEALOA9sA6vBsjEg6UA74HqgevNBERKTq2hpAxY8bw9NNP8+CDD7J//36qVavGfffdxzPPPOPZ59FHH+Xo0aPce++9ZGZmcvnll/Pdd98RHR1tY+USsHjgB+Bu4BPMXo7Cwkg45lTt9YEvgNpFVaCIiASbwzh9etISKDs7m/j4eLKysoiLi7O7HCnMVmA8MBHIOm19ONADGAC0xbw1V0REikyw30Nt7QkRAeAi4FVgOLAXM4iUAZKAWBvrEhGRoFIIkdARCdS0uwgRESkqeoquiMjpDAOOHQN3oFP7isj5KISIiGRnw9tvQ8OGEB4OZcuaf1avDi+8AHv32l2hSImkECIipVd+Pjz+OCQlwcCBsHHjnz0ghgG7d5shJDkZevaEzExbyxUpaRRCRKR0OnECOneGUaPg+HEzdBR2s6DLZS6ffgqXXaZeERELKYSISOnjdkPv3vCf/xQePArjcsHWrXD99fDHH8GtT6SUUAgRkdJn5kz45BPfB5/m55uXbEaNCkpZIqWNQoiIlD5jxoDT14cXneRywbhxkJtrbU0ipZBCiIiULr/8AgsWmGHCXwcPwowZlpUkUlophIhI6fLFF/73gpwSFmYOVBWRgCiEiEjpsn+/GSIC4XZDRoY19YiUYgohImK7XHL5mI+5nuupTW0u4ALqU59e9OIHfsDAwuds5uVZ086+fbBzp/d314jIWfTsGBGxTR55jGAEoxnNQQ4SRhhuzDtW9rCHX/mV6UynHvV4mqe5gzsCf9Hy5a0LDuPHQ2ws1K9vLhddBBER1rQtUgoohIiILf7gD7rSlfnM9/R0nAogp+STD8AmNtGLXqSTziu8ggOH/y981VUwfLj/x4N5Oeeee+CxxwJrR6SU0+UYESlyeeTRjW4sZKFXl1pO7TOKUbzAC4G9+LXXQq1a4AggyDid0K9fYHWIiEKIiBS9N3mTNNJw4fttss/xHEtZ6v+Lh4XBoEH+Hx8eDrfdBpUq+d+GiAAKISJSxFy4GM1ovwebhhPOWMYGVkS/fmZvSLiPV6TDwiAqCp56KrDXFxFAIUREitg3fMNudvt9fD75fMIn7Ge//0XExcGcOeYgVW+DiNNp7jt7NtSr5/9ri4iHQoiIFKmpTMVJYJOFuXHzCZ8EVsiFF8KqVXDxxeb355rA7NScIuXLw8KFcM01gb2uiHgohIhIkdrJTr/GgpzOiTOg3hSPGjUgPR2+/tp8Om5hg1WbN4f33jPnBLnsssBfU8QPhmE+vDknx+5KrKVbdEWkSB3jmCXtHOe4Je3gdMKNN5rLzp3ms2WysqBsWUhJgQYNrHkdER/l5ppPGRgzBpYt+/Ohz7GxcMcd8OCD0LSpvTUGSiFERIpUecoH3IaBQQIJgRdzpho1zEXEZu+8A08+CYcOmTnZfdoUOkeOwKRJMGGC2Tk3aZI5V15xpMsxIlKkWtKS8AA//+STT3OaW1SRSOgwDHjkEbj/fjOAQOEPfM435/Fj5Upo3RqWBnDXup0UQkSkSN3P/Z6ZUP2VRBKd6GRRRSKhY+RIeO017/d3ueDoUbjhBvNKYnGjECIiRaoudbmGa/y+QyaMMAYwIODeFCkGsoBfgNXAr8AJe8sJtm3bzEswvnK7zSAyYID1NQWb/haLSJF7mqeZz3yfj3PiJJ547uXeIFQlIcEA/gu8BXwBBW6kigX6AfcDNk3V4sLFalazn/3kkUd5ynMJlxBHXMBtv/OOeUd4YZdfzluXC+bNg82boW7dgEspMuoJEZEidzVXM45xPh3jxEkkkXzHd1ShSpAqE1ttARoDVwMz4Kw7uY9ghpP6QBcgu+hK+53fGclIUkihNa3pTGe60Y32tCeRRO7nftJJ97v9EyfMEOJPADklPNx8sHNxohAiIra4j/uYwhScJ7/OxXHyK4EE/st/uZRLi7BKKTJrgVbAppPfn2vY0Kn1XwNtgUPBLQvg3/ybC7iAJ3mS3/jtrO0nOMG7vEszmnEHd3DCj+tG//0vZGYGVmd+Pnz4YWBtFDWFEBGxTW96s4lNDGUo8cQDZo9HBBGEnfznKYUUXud1trCFlrS0s1wJlt+A64E/OHf4OJMLc7zI34DcINWF+eTm/vQnjzzcuM+536nB1h/zMR3o4FUQMQw4fNi8hLJ4sTX1HiqCUGYlh2EY/j1FqpjIzs4mPj6erKws4uICv2YnIsFxnON8yZfsZCdHOUo88TSmMe1p7wkkUkLdD7yL9wHkTO8Bd1lXzikf8zG3c7vPx4URxq3cyocU3i1hGLB3L2zcaP554IA5nuPLLwOt2JxTJC+v8Ml//RHs91CFEBERsU8WkIT/d76EAc2BVZZVBJgDUFNIKfTyi7fWsMbr+Wxmz4YuXfx+KY/y5a3tDQn2e6g+XoiIiH2mAoE8D8WNeQvvamvKOeU7vgsogIQT7tPg6zZtvH+g8zlfMxyuvTawNoqaQoiIiNjnGwvacALfWtDOacYyNqCnPeeTz/u8TyaZXu1fuTLcdltgQSQ/HwYO9P94OyiEiIiIfX7HnBskEGFYfpfMAhYE/LTnE5xglQ/XiQYM+HM6dl85HOb8IFde6d/xdlEIEREROU0uuX7dZluYwxz2et/LLjPHhYT5+c782mvWDUgtKgohIiJinypAoG+cbqCiBbWcFMhlmDNFEOH1vg4HTJ8OrVr5HkRGj4bOnX0sLgQohIiIiH3+ZkEbLrDyeYanHg9ghcpU9mn/MmUgLQ1uvtn8/lxjRBwOc4mKgg8+KH5jQU5RCBEREfv8HYgO4PgwoDXQzJJqPG7n9oAfkphIIq1p7fNxZcrAZ5/BmjXQty9EF3J+UlLgjTfMeUZ69QqoTFtpnhAREbHXg8BE/J+s7H3MMGOhdNJpFkCyCSOM53iOp3k64FqysiA93ZxdNTISEhOhWTP/x474QpOVBUghREQkxO0BWmDeKePLDSlOoB0wF3wYeuG1NrRhJSv9ukvGiZNd7KIqVa0vrAhpsjIRESnZqgH/AeLB6ysgTqAJMIugBBCAiUwkmmi/HhvwT/5Z7ANIUVAIERER+zXGnHq98cnvzxVGnJh303QDfgASgldSIxrxNV8TQ4xPd8w8x3MMpJiOFC1iCiEiIhIaamFOv74UuJ2zezjigYeBX4FPgLLBL+kqrmIpS7mESwAKHax6KqAkksh7vMezPBv8wkoIjQkREZHQdBTYDxzB7PFIBCLtK+dHfuRt3uZjPuYP/gDMUHI5lzOYwXSmc8B31IQaDUwNkEKIiIhYLZdc8sijDGVwBDzbWugK9ntoyYpsIiIiRSDy5JcERmNCRERExBYKISIiImILhRARERGxhUKIiIiI2EIhRERERGyhECIiImKjEyegZE+WcW66RVdERMRCe/bApEnw88/mE3BjYyElBfr2hfr1C+67fTscPQoNG9pRqf0UQkRERCywbBm89hrMmAEOh9m74XZDWJi5vPoqXHEFPPwwdOkCa9bAihVw//12V24fhRAREZEA/fvfcN99Zthwuwtuc7v/XLdkCfzwA3TvDmXKwJQpRV5qSNGYEBERkQBMngz9+5tBIz//r/d1ucw/P/8cypUzQ0tpVsp/fBEREf/99JMZQPzx9tvwySfW1lPcKISIiIj4afRoc/yHP8LCYNQoa+spbjQmRMQuLuAbYCWQCUQD1YBbT/4pIiEtMxM++OD8l2DOxe2G1avNpUULS0srNhRCRIraAWAC8BawB4g4bZsLeBi4GRgIXF3UxYmItz78EHJyAmsjPBzefbf0hhBdjhEpSj8CDYCnMQMIQN5pi/vkMgtoDzxy8nsRCTlbt5ohIhD5+bB5szX1FEfqCREpKunA5UAO5w8Wp7p3XwOOYvaa+HndWUSC48gRa9rJyrKmneJIPSEiReEPoANmAHH5eOw4YKLlFYlIgGJjrWknIcGadoojhRCRovABsB/fA8gpw9FlGZEQU7eu/4NSTwkPh3r1rKmnOFIIEQk2AxgdYBs7gf9YUIuIWOb22yE6OrA28vPhnnusqac4UggRCbalwC+YYcRf4cDb1pQjItaIi4M+ffwfnBoWBpddBk2bWlpWsaIQIhJs6y1oIx9zYKuIhJRBg8w//ZmwzO2GRx+1tp7iRiFEJNiyAKcF7WRb0IaIWKp+fXjvPfOJub56/HG4+WbraypOFEJEgq0s1gwqLWtBGyJiuTvuMGdODQ8//6UZ58kPJE8/DS+/HPzaQp3mCRGx2v79MGMG7N1rTqeYcQkYPQJrMwxIsaI4EQmGXr2gYUN4801zJlWXyxzz4XabfxqG+d/XXw9Dh8J119ldcWhwGIY/nUjFR3Z2NvHx8WRlZREXFxdwewYGDs0aJYVZuhTGjjUfi+ly/fmRyBUG7l1A5cDanwz0CbBGEQm6gwfNSzQbNpgTkcXGQkoK3HUX1Kpld3W+sfo99EzqCTmPE5zgEz7hLd5iAxs4ylGiiaYmNbmXe+lDH8pT3u4yxU5uN/zjHzBihBk8Tk0ckJd32k5vA0/h91+5OOC2wMoUkaJRsSIMG2Z3FcWDxoScgxs3L/IiSSTRm96sYhVHOIKBwXGOs4lNPMzDVKUq93EfRzlqd8liB8Mwh8ePGGF+f86ZiyZgzlTmx+CQMOABIMavCkVEQpZCSCFyyeUWbuFZniULc1J/9xlvHsbJrxxyeJd3uYIrOMABO8oVO02YAG97M4HHHqDXyf/2IYg4gbbA8z5XJiIS8hRCzmBgcA/3MItZGF7OLuXCxTrW0YlOHOd4kCuUkOFywYsv+nDA50BvzBDixVzPYUA74Csgyo/6RERCnELIGWYzm/d5/6yej/Nx4WIVq3id14NUmYScb76B3bt9POgD4Arge8wwcsbDZE7NJ1IN83kxc4D4gKoUEQlZCiFnGMtYnH7OLOXGzVu8Rb43n3Kl+Hv77T9v+vfJMuBvwIXAKGh1BJoClwHdgFmYz4p5HIi0qlgRkdCjEHKaLWxhLnNx+f2oU8ggg6/4ysKqJGStWWNekvHbDuBJGDQT1mI+Y+YT4CasmWFVRCTE2R5Cdu/ezd///ncqVqxITEwMjRs3ZtWqVZ7thmHwzDPPULVqVWJiYkhNTWXLli1BqeVTPvW7F+QUJ04+4iOLKpKQ9scfgbfhcJgTCUjoKdlTKImEBFtDyOHDh2nXrh0RERF8++23bNiwgddff53y5f+cd2PUqFGMHj2a8ePHs3z5csqWLUuHDh04ceKE5fVkkEFYgKfEhYs97LGoIglpgT7DG8w3uiVLYNWqM+YVEdvt3Wt3BSIlnq2TlY0cOZLk5GQmT57sWVfrtOnkDMPgn//8J//4xz/o0qULAFOnTiUxMZGZM2dy++23W1pPHta8CeSQY0k7EuKSkyEzM/BPzHXqwPr15uWdOnWgQQOoUsW/x3KKdX7+GapVs7sKkRLN1p6Q2bNn07JlS3r06EGVKlVo3rw5EydO9Gzftm0bGRkZpKametbFx8fTunVrli5dWmibOTk5ZGdnF1i8lUCC3z/L6SpRyZJ2JMT16xd4G1WrmrOt9ukD994L7dtDYqICSCjYsEGXZESCzNYQ8r///Y9x48ZRp04dvv/+ex544AEGDx7Me++9B0BGRgYAiYmJBY5LTEz0bDvTiBEjiI+P9yzJycle19OOdgH3hoQRRjvaBdSGFBN33QVRAUzgERYGAwac/7GbYg+3G375xe4qrHcMmA68BDwBvAzMBIs6gkV8YusD7CIjI2nZsiVLlizxrBs8eDArV65k6dKlLFmyhHbt2rFnzx6qVq3q2efWW2/F4XDw8ccfn9VmTk4OOTl/Xg7Jzs4mOTnZq4fvuHBRk5rsxte5H/4UTji72U0VqvjdhhQjDz5ozprq610yDgdERMCOHZCUFJzaxD+5ufD55/Dcc+bvJy/PDJvJyXDPPdC3L1Qqhr2dW4BxwL+BPzAvxjsAA3PuvCqYjwe4F3OeGhGC/wA7W3tCqlatSoMGDQqsq1+/Pjt37gQg6eQ/zvv27Suwz759+zzbzhQVFUVcXFyBxVtOnAxkoN+DU8MJpwc9FEBKk5EjzTEc/swXMm2aAkgoMQx49VXzEtkdd8Cvv0JOjtkjcvw4bN4Mjz9ujhO5++7idVfTB0ADYDRmAAEzeOTx5+S9+4EXgbrAvKIuUEorW0NIu3bt2LRpU4F1mzdvpmbNmoA5SDUpKYm0tDTP9uzsbJYvX06bNm2CUtO93EtVqvp8q64DB+GE8yRPBqUuCVHlysGcOdCokXdBxOk0l0mT4JZbgl+feCc/37y89uijcOiQuc5dyKzJbrfZMzJ1KrRtC+e4LBxSJgF3YoaN83XYuYHjQAdgbpDrEsHmEDJ06FCWLVvGyy+/zK+//sr06dOZMGECAwYMAMDhcDBkyBBeeuklZs+ezU8//cRdd91FtWrV6Nq1a1BqqkAF5jCHcpTzOoiEEYYTJ1/wBY1oFJS6JIQlJsKiRfB//wfxJ+dYDzvjr9apgHLllTBvnjkQVULDqSchT5vm/TEul9kzcv311swXEyxLgP4+HuM+uXQBtltdkMgZDJt9+eWXRqNGjYyoqCijXr16xoQJEwpsd7vdxtNPP20kJiYaUVFRxrXXXmts2rTJ6/azsrIMwMjKyvKprs3GZqOWUcvAwHAaToNCvhwnv+KMOGO+Md+n9qWEOn7cMKZONYzrrzeMhg0N46KLDOPSSw1jyBDD+OUXu6uTwqSlGYYZRXxfnE7DePxxu3+Cc+tsGIbTMAz8WJyGYQwr+pIltPj7HuotWwemFoVABtXkkssMZjCGMSxm8VnbL+ZiBjOYO7mTcpSzqmQRKUpdu8LXX5uXZPyRkGBelgnkTqlg2AmkgJcPAy9cHLAXKGNFQVIcBXtgqu4N/AuRRHLbya+NJ7+yyCKWWGpSk0u5FAeaz0Gk2PrtN5g9O7D5QDIz4bPPoFcvy8qyxL8xL7gH8nijbMznGfWxoiCRsymEeKn+yS8RKUE+/9y8XTqQEBIWBtOnh14IWUtgAQQgAlgXeCki52L7A+xERGyzb59/t1efzu2GPSH4vKhDFrRhAMXoTmQpfhRCRKT0ys0NrXasFGtBGw4gxoJ2RM5BIURESq+EBGueD1OxYuBtWK0GgV9wdwPVLahF5BwUQkSk9Grb1v+7Yk5xOuGKK6ypx0p38edsqP5yAyE21EVKFg1MFZHSq317qF0btm71v0fE7TafgBxq2gH1gV/w7zbdcKAT4P0zQKWo5OebzzXKzDSfQZWYaC7FkHpCRKT0cjhg8GD/j3c6oVMnOPmoiZDiAIbi/zwh+UAAp0aCYO9eeOEFqF7dDM8tW0LTpuYzqK64Aj75JDTHJ/0FhRARKd369IGUFAj3sWPY4TBvz3322WBUZY1+wG349y/9k8A11pYjfnK54OGHzSc5P/+8eVfXmZYuhdtuMwPK3OLz4B+FEBEp3U49hDAhwfsgEhZmhpAPPzQ/jYaqMOA9oLuX+5+ae/Fh4KWgVCS+ys+HHj3gzTfNMFLYgxXB3AZw8CDccIPZK1IMKISIiFx0EaxcCRdeaH5/rrlDHA5ziYmBr76C7t6+u9soCvgI+CfmHTNw9mjAU983AKYBr4Emgw4RgwbBzJnej1lyu82lVy/473+DWpoVFEJERMC8JLN+vTkF++WXF75PrVrmJ9LffoOOHYu0vICEAQ8B24BvMZ+Q2wSoBTQHegKLgZ+AO2yqUc72008wfrzvg6YNwwwigwZZcwt6EOkBdiIihdm82QwlWVlQpgzUqAGXXWb2hIgUhQcfhIkTA7uNfPlyaNXK78P1ADsRETvUrWsuInbIzoYpUwILIOHhMHYsTJ1qWVlW0+UYERGRULNkCRw/Hlgb+fnm2KUQphAiIiISag4etKadrKyQHheiECIiIlJShfgYJoUQERGRUFOpkjXtxMeHdBDxa2BqWloaaWlp7N+/H/cZE6dMmjTJksJERERKrXbtoGxZOHrU/zbCw6FLF+tqCgKfe0Kef/55rr/+etLS0jhw4ACHDx8usIiIiEiAYmPh7rt9f5zA6fLzYeBA62oKAp/nCalatSqjRo3izjvvDFZNltI8ISIiUixt3AgNGvh3bFgYNGsGq1cHVEKw30N97gnJzc2lbdu2lhciIiIip6lfH4YO9X1Mh8Nh9qC89VZw6rKQzyHknnvuYfr06cGoRURERE736qtw++3e7x8WZgaQTz81Z/gNcT5fbDpx4gQTJkxg7ty5NGnShIiIiALb33jjDcuKExERKdWcTpg0CRYvhr17z/0kXafT3FatGkyfDldcUfS1+sHnELJu3TqaNWsGwPr16wtsc4TwbUAiIiLF0r//DR9/DHXqmFO5jxkDO3b8ud3hgOuuMweh3nDDuZ8CHYL0ADsREZFQtXcvrFhR8FZbtxv274fDhyEy0pxTJD4+KC8f0g+w++233wCoXr26JcWIiIjIaQ4fPnuuj7AwSEoyl2LO54GpbrebF154gfj4eGrWrEnNmjVJSEjgxRdfPGviMhEREfGTYZh3yJRgPveEPPXUU7z77ru88sortGvXDoBFixbx3HPPceLECYYPH255kSIiIqVOKRhn6fOYkGrVqjF+/HhuuummAutnzZrFgw8+yO7duy0tMFAaEyIiIuKfkJus7NChQ9SrV++s9fXq1ePQoUOWFCUiIiIln88hpGnTpowdO/as9WPHjqVp06aWFCUiIiIln89jQkaNGkWnTp2YO3cubdq0AWDp0qXs2rWLb775xvICRUREpGTyuSfkqquuYvPmzdx8881kZmaSmZlJt27d2LRpE1cUkxnaRERExH6arExEREQKFRKTla1bt45GjRoRFhbGunXr/nLfJk2aWFKYiIiIlGxehZBmzZqRkZFBlSpVaNasGQ6Hg8I6UBwOBy6Xy/IiRUREpOTxKoRs27aNypUre/5bREREJFBehZCaNWt6/nvHjh20bduW8PCCh+bn57NkyZIC+4qIiIici893x7Rv377QScmysrJo3769JUWJiIhIyedzCDEMA0ch89kfPHiQsmXLWlKUiIiIlHxeT1bWrVs3wBx82qdPH6KiojzbXC4X69ato23bttZXKCIiIiWS1yEkPj4eMHtCypUrR0xMjGdbZGQkl112Gf3797e+QhERESmRvA4hkydPBiAlJYX/+7//06UXERERCYhmTBUREZFChcSMqZdccglpaWmUL1+e5s2bFzow9ZQ1a9ZYVpyIiIiUXF6FkC5dungGonbt2jWY9YiIiEgpocsxIiIiUqhgv4f6PE/Irl27+O233zzfr1ixgiFDhjBhwgRLCxMREZGSzecQcscddzB//nwAMjIySE1NZcWKFTz11FO88MILlhcoIiIiJZPPIWT9+vW0atUKgE8++YTGjRuzZMkSpk2bxpQpU6yuT0REREoon0NIXl6eZ5Dq3LlzuemmmwCoV68ee/futbY6ERERKbF8DiENGzZk/Pjx/PDDD8yZM4cbbrgBgD179lCxYkXLCxQREZGSyecQMnLkSN555x2uvvpqevbsSdOmTQGYPXu25zKNiIiIyPn4dYuuy+UiOzub8uXLe9Zt376dMmXKUKVKFUsLDJRu0RUREfFPSMyYeian00l+fj6LFi0C4OKLLyYlJcXKukRERKSE8/lyzNGjR7n77rupWrUqV155JVdeeSXVqlWjX79+HDt2LBg1ioiISAnkcwgZNmwYCxcu5MsvvyQzM5PMzExmzZrFwoULefjhh4NRo4iIiJRAPo8JqVSpEp999hlXX311gfXz58/n1ltv5ffff7eyvoBpTIiIiIh/Qm7a9mPHjpGYmHjW+ipVquhyjIiIiHjN5xDSpk0bnn32WU6cOOFZd/z4cZ5//nnatGljaXEiIiJScvl8d8w///lPOnToQPXq1T1zhKSnpxMdHc33339veYEiIiJSMvk1T8ixY8eYPn06GzduBKB+/fr06tWLmJgYywsMlMaEiIiI+Cek5glZtmwZX375Jbm5uVxzzTXcc889lhckIiIipYPXIeSzzz7jtttuIyYmhoiICN544w1GjhzJ//3f/wWzPhERESmhvB6YOmLECPr3709WVhaHDx/mpZde4uWXXw5mbSIiIlKCeT0mJDY2lrVr11K7dm0AcnNzKVu2LLt37w6558WcTmNCRERE/BMy84QcO3asQAGRkZFER0dz5MgRy4sSERGRks+ngan//ve/iY2N9Xyfn5/PlClTqFSpkmfd4MGDratORERESiyvL8ekpKTgcDj+ujGHg//973+WFGYVXY4RERHxT8jcort9+3bLX1xERERKL5+nbRcRERGxgkKIiIiI2EIhRERERGzhdQjZs2dPMOsQERGRUsbrENKwYUOmT58ezFpERESkFPE6hAwfPpz77ruPHj16cOjQoWDWJCIiIqWA1yHkwQcfZN26dRw8eJAGDRrw5ZdfBrMuERERKeF8mjG1Vq1azJs3j7Fjx9KtWzfq169PeHjBJtasWWNpgSIiIlIy+Xx3zI4dO/jiiy8oX748Xbp0OWvx1yuvvILD4WDIkCGedSdOnGDAgAFUrFiR2NhYunfvzr59+/x+DREREQkdPvWETJw4kYcffpjU1FR+/vlnKleubEkRK1eu5J133qFJkyYF1g8dOpSvv/6aTz/9lPj4eAYOHEi3bt1YvHixJa8rIiIi9vE6hNxwww2sWLGCsWPHctddd1lWwJEjR+jVqxcTJ07kpZde8qzPysri3XffZfr06VxzzTUATJ48mfr167Ns2TIuu+wyy2oQERGRouf15RiXy8W6dessDSAAAwYMoFOnTqSmphZYv3r1avLy8gqsr1evHjVq1GDp0qXnbC8nJ4fs7OwCi4iIiIQer3tC5syZY/mLf/TRR6xZs4aVK1eetS0jI4PIyEgSEhIKrE9MTCQjI+OcbY4YMYLnn3/e6lJFRETEYrZN275r1y4eeughpk2bRnR0tGXtPvHEE2RlZXmWXbt2Wda2iIiIWMe2ELJ69Wr279/PJZdcQnh4OOHh4SxcuJDRo0cTHh5OYmIiubm5ZGZmFjhu3759JCUlnbPdqKgo4uLiCiwiIiISeny6O8ZK1157LT/99FOBdX379qVevXo89thjJCcnExERQVpaGt27dwdg06ZN7Ny5kzZt2thRsoiIiFjIthBSrlw5GjVqVGBd2bJlqVixomd9v379GDZsGBUqVCAuLo5BgwbRpk0b3RkjIiJSAtgWQrzx5ptvEhYWRvfu3cnJyaFDhw68/fbbdpclIiIiFnAYhmHYXUQwZWdnEx8fT1ZWlsaHiIiI+CDY76G2DUwVERGR0k0hRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQERERsYVCiIiIiNhCIURERERsoRAiIiIitlAIEREREVsohIiIiIgtFEJERETEFgohIiIiYguFEBEREbGFQoiIiIjYQiFEREREbKEQIiIiIrZQCBERERFbKISIiIiILRRCRERExBYKISIiImILhRARERGxhUKIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQERERsYVCiIiIiNhCIURERERsoRAiIiIitlAIEREREVsohIiIiIgtFEJERETEFgohIiIiYguFEBEREbGFQoiIiIjYQiFEREREbKEQIiIiIrZQCBERERFbKISIiIiILRRCRERExBYKISIiImILhRARERGxhUKIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQERERsYVCiIiIiNhCIURERERsoRAiIiIitlAIEREREVsohIiIiIgtFEJERETEFgohIiIiYguFEBEREbGFQoiIiIjYQiFEREREbKEQIiIiIrYIt7sAESn5drGLdNLJIotooqlOdS7lUsL0OUikVFMIEZGgcOPmP/yHsYzlG77BwCiw/UIuZBCD6E1vylPepipFxE76GCIiltvHPlrRio505Du+OyuAAGxjG8MYRnWqM5vZNlQpInZTCBERS+1lL61oRTrpALhwFbqfcfLrOMfpSlemMa0oyxSREKAQIiKWySGHG7iBPewhn3yvjjkVRvrQh0UsCnKFIhJKFEJExDKf8inrWOd1ADmdgcE/+EcQqhKRUKUQIiKWGcMYv+94ceFiIQvZyEaLqxKRUKUQIiKWWMtaVrACN26/2wgnnPGMt7AqEQllCiEiYolFLMKBI6A28slnHvMsqkhEQp1CiIhY4jCHceK0pB0RKR0UQkTEEhFEhFQ7IhL6FEJExBKJJPp1V8zpHDioSlWLKhKRUGdrCBkxYgSXXnop5cqVo0qVKnTt2pVNmzYV2OfEiRMMGDCAihUrEhsbS/fu3dm3b59NFYvIuXSmsyW9GD3paUE1IlIc2BpCFi5cyIABA1i2bBlz5swhLy+P66+/nqNHj3r2GTp0KF9++SWffvopCxcuZM+ePXTr1s3GqkWkMJWoxG3cRngAj6SKIoq7uMvCqkQklDkMwzj7oQ42+f3336lSpQoLFy7kyiuvJCsri8qVKzN9+nRuueUWAH755Rfq16/P0qVLueyyy87bZnZ2NvHx8WRlZREXFxfsH0GkVFvOci7j/H8vC+PEST/68Q7vWFyViPgr2O+hITUmJCsrC4AKFSoAsHr1avLy8khNTfXsU69ePWrUqMHSpUsLbSMnJ4fs7OwCi4gUjda05mEe9vm4cMKpQQ2GMzwIVYlIqAqZEOJ2uxkyZAjt2rWjUaNGAGRkZBAZGUlCQkKBfRMTE8nIyCi0nREjRhAfH+9ZkpOTg126iJxmFKPoRz+v9w8nnGpUYy5zqUSlIFYmIqEmZELIgAEDWL9+PR999FFA7TzxxBNkZWV5ll27dllUoYh4I4wwJjKRN3iDCpi9moXNH+LESRhh3MRNrGQlF3JhUZcqIjYLiRAycOBAvvrqK+bPn0/16tU965OSksjNzSUzM7PA/vv27SMpKanQtqKiooiLiyuwiEjRcuBgKEPZwx6mM53WtCaGGMDs+ahOdZ7iKXawg8/5nCpUsbliEbGD/8PYLWAYBoMGDWLGjBksWLCAWrVqFdjeokULIiIiSEtLo3v37gBs2rSJnTt30qZNGztKFhEfRBFFz5NfYE7L7sQZ8PTuIlIy2BpCBgwYwPTp05k1axblypXzjPOIj48nJiaG+Ph4+vXrx7Bhw6hQoQJxcXEMGjSINm3aeHVnjIiElkBu3xWRksfWW3QdjsI/DU2ePJk+ffoA5mRlDz/8MB9++CE5OTl06NCBt99++5yXY86kW3RFRET8E+z30JCaJyQYFEJERET8U6rmCREREZHSQyFEREREbKEQIiIiIrZQCBERERFbKISIiIiILRRCRERExBYKISIiImILhRARERGxhUKIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQERERsYVCiIiIiNhCIURERERsoRAiIiIitlAIEREREVsohIiIiIgtFEJERETEFgohIiIiYguFEBEREbGFQoiIiIjYQiFEREREbKEQIiIiIrZQCBERERFbKISIiIiILRRCRERExBYKISIiImILhRARERGxRbjdBYSyjAz44gvzz5wcSEiANm3gqqvA4Th7/8xMKFsWIiKKulIREZHiRyGkEIsWwdix8Pnn4HJB+Mmz5Hab39epA4MGQZ8+UK6cuW35cnO/Fi1sK1tERKRY0eWY07jd8MgjcMUVZgDJzwfDgLw8c3G5zP1+/RUeegiaNIEtW2DMGNi+XQFERETEFwohJxkGPPAAvPaa+X1+/l/vaxiwaxc0agS//w633VY0dYqIiJQUCiEnvf02TJjg2zEulxlWpk+H3Nzg1CUiIlJSKYRgBomXXvLvWLcbtm41B7CKiIiI9xRCgK++Mu+A8ZfTCaNHW1ePiIhIaaAQArz1lhkk/OVywdKlsH69dTWJiIiUdAohwI8//nnnSyB++inwNkREREoLhRDgyJHA23A4ICsr8HZERERKC4UQIDo68DYMA8qUCbwdERGR0kIhBKhRo/Bp2H1VvXrgbYiIiJQWCiFAv36Bt3HBBeYzZURERMQ7CiFA794QGen/8WFhMHBgYHfYiIiIlDYKIZhPx+3d278Q4XCYT829+27LyxIRESnRFEJOeu01qF//zyfm+uKjj6BKFetrEhERKckUQk4qVw7mzoWGDb3rEXE6zcDy/vvQtWvQyxMRESlxFEJOk5gIixbB//2feYkGzPEepzsVUNq3hwULoFevoqxQRESk5HAYhmHYXUQwZWdnEx8fT1ZWFnFxcV4fd+IEfPYZTJsGu3dDTg6ULw+XXw733w+1awexaBERkRDg73uotxRCREREpFDBfg/V5RgRERGxhUKIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQERERsYVCiIiIiNhCIURERERsoRAiIiIitlAIEREREVsohIiIiIgtFEJERETEFgohIiIiYguFEBEREbFFuN0FiIiIyEmbNsEPP8DhwxARAVWqwI03QkKC3ZUFhUKIiIiInfLzYfZsGD0aFi401zmdYBjgdkNUFPz97zBgADRvbm+tFtPlGBEREbscOACXXw7du8OiRX+ud7nMAAKQkwPvvQeXXAKPP/7n+hJAPSEiIiJ2OHQI2rSB7dvN712uc++bn2/+OXKkealm/HhwOIJeYrCpJ0RERKSoGQZ07Qrbtv0ZMLw1YYJ56aYEUAgREREpagsXmgNQ/6r346+88IJ5maaYUwgREREpam+9BeEBjIg4dAi++MK6emyiECIiIlKUMjJgxgzfL8OcLiwMxoyxriabKISIiIgUpbVr/b8Mc4rbDatXW1KOnRRCREREilJWljXt5OYW+3EhxSKEvPXWW6SkpBAdHU3r1q1ZsWKF3SWJiIj4JzramnbCwsxZVYuxkA8hH3/8McOGDePZZ59lzZo1NG3alA4dOrB//367SxMREfFdtWrWtFO5shlEirGQr/6NN96gf//+9O3blwYNGjB+/HjKlCnDpEmT7C5NRETEdy1bwkUXBTbZmNMJffpYVpJdQjqE5Obmsnr1alJTUz3rwsLCSE1NZenSpYUek5OTQ3Z2doFFREQkZDgcMGhQYG243XDffdbUY6OQDiEHDhzA5XKRmJhYYH1iYiIZGRmFHjNixAji4+M9S3JyclGUKiIi4r3evSEmxr/ekPBw6NgRatWyvq4iFtIhxB9PPPEEWVlZnmXXrl12lyQiIlJQQgJMm+b7cU6nORZk4kTLS7JDSIeQSpUq4XQ62bdvX4H1+/btIykpqdBjoqKiiIuLK7CIiIiEnK5dYcoUM1h4O8A0KQnmzbNucKvNQjqEREZG0qJFC9LS0jzr3G43aWlptGnTxsbKRERELHDXXTB3LrRubX5f2FTuYWHm+iZN4B//gHr1irbGIArpEAIwbNgwJk6cyHvvvcfGjRt54IEHOHr0KH379rW7NBERkcBdfTUsWQLp6dCvH9SuDRUrQtWq0KwZjBgBe/bAjz/C+vXFfoKy0zkMwzDsLuJ8xo4dy6uvvkpGRgbNmjVj9OjRtD6VGs8jOzub+Ph4srKydGlGRESKt4MHYdEi6NKlSF4u2O+hxSKEBEIhRERESpQdO8yxIVFRQX+pYL+HBvAcYRERESlyNWtCCek/CPkxISIiInKGQGZbDSEKISIiImILhRARERGxhUKIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC1K/GRlpyaEzc7OtrkSERGR4uXUe2ewJlcv8SHk4MGDACQnJ9tciYiISPF08OBB4uPjLW+3xIeQChUqALBz586gnEA5W3Z2NsnJyezatUvP6ykiOudFT+e86OmcF72srCxq1KjheS+1WokPIWFh5rCX+Ph4/U9bxOLi4nTOi5jOedHTOS96OudF79R7qeXtBqVVERERkfNQCBERERFblPgQEhUVxbPPPktUVJTdpZQaOudFT+e86OmcFz2d86IX7HPuMIJ1342IiIjIXyjxPSEiIiISmhRCRERExBYKISIiImILhRARERGxRYkOIW+99RYpKSlER0fTunVrVqxYYXdJJcaIESO49NJLKVeuHFWqVKFr165s2rSpwD4nTpxgwIABVKxYkdjYWLp3786+fftsqrjkeeWVV3A4HAwZMsSzTufcert37+bvf/87FStWJCYmhsaNG7Nq1SrPdsMweOaZZ6hatSoxMTGkpqayZcsWGysu3lwuF08//TS1atUiJiaGiy66iBdffLHAs0t0zgPz3//+l86dO1OtWjUcDgczZ84ssN2b83vo0CF69epFXFwcCQkJ9OvXjyNHjvhejFFCffTRR0ZkZKQxadIk4+effzb69+9vJCQkGPv27bO7tBKhQ4cOxuTJk43169cba9euNW688UajRo0axpEjRzz73H///UZycrKRlpZmrFq1yrjsssuMtm3b2lh1ybFixQojJSXFaNKkifHQQw951uucW+vQoUNGzZo1jT59+hjLly83/ve//xnff/+98euvv3r2eeWVV4z4+Hhj5syZRnp6unHTTTcZtWrVMo4fP25j5cXX8OHDjYoVKxpfffWVsW3bNuPTTz81YmNjjX/961+efXTOA/PNN98YTz31lPHFF18YgDFjxowC2705vzfccIPRtGlTY9myZcYPP/xg1K5d2+jZs6fPtZTYENKqVStjwIABnu9dLpdRrVo1Y8SIETZWVXLt37/fAIyFCxcahmEYmZmZRkREhPHpp5969tm4caMBGEuXLrWrzBLhjz/+MOrUqWPMmTPHuOqqqzwhROfceo899phx+eWXn3O72+02kpKSjFdffdWzLjMz04iKijI+/PDDoiixxOnUqZNx9913F1jXrVs3o1evXoZh6Jxb7cwQ4s353bBhgwEYK1eu9Ozz7bffGg6Hw9i9e7dPr18iL8fk5uayevVqUlNTPevCwsJITU1l6dKlNlZWcmVlZQF/PjBw9erV5OXlFfgd1KtXjxo1auh3EKABAwbQqVOnAucWdM6DYfbs2bRs2ZIePXpQpUoVmjdvzsSJEz3bt23bRkZGRoFzHh8fT+vWrXXO/dS2bVvS0tLYvHkzAOnp6SxatIiOHTsCOufB5s35Xbp0KQkJCbRs2dKzT2pqKmFhYSxfvtyn1yuRD7A7cOAALpeLxMTEAusTExP55ZdfbKqq5HK73QwZMoR27drRqFEjADIyMoiMjCQhIaHAvomJiWRkZNhQZcnw0UcfsWbNGlauXHnWNp1z6/3vf/9j3LhxDBs2jCeffJKVK1cyePBgIiMj6d27t+e8FvZvjc65fx5//HGys7OpV68eTqcTl8vF8OHD6dWrF4DOeZB5c34zMjKoUqVKge3h4eFUqFDB599BiQwhUrQGDBjA+vXrWbRokd2llGi7du3ioYceYs6cOURHR9tdTqngdrtp2bIlL7/8MgDNmzdn/fr1jB8/nt69e9tcXcn0ySefMG3aNKZPn07Dhg1Zu3YtQ4YMoVq1ajrnJVCJvBxTqVIlnE7nWXcF7Nu3j6SkJJuqKpkGDhzIV199xfz586levbpnfVJSErm5uWRmZhbYX78D/61evZr9+/dzySWXEB4eTnh4OAsXLmT06NGEh4eTmJioc26xqlWr0qBBgwLr6tevz86dOwE851X/1ljnkUce4fHHH+f222+ncePG3HnnnQwdOpQRI0YAOufB5s35TUpKYv/+/QW25+fnc+jQIZ9/ByUyhERGRtKiRQvS0tI869xuN2lpabRp08bGykoOwzAYOHAgM2bMYN68edSqVavA9hYtWhAREVHgd7Bp0yZ27typ34Gfrr32Wn766SfWrl3rWVq2bEmvXr08/61zbq127dqddev55s2bqVmzJgC1atUiKSmpwDnPzs5m+fLlOud+OnbsGGFhBd+anE4nbrcb0DkPNm/Ob5s2bcjMzGT16tWefebNm4fb7aZ169a+vWBAw2pD2EcffWRERUUZU6ZMMTZs2GDce++9RkJCgpGRkWF3aSXCAw88YMTHxxsLFiww9u7d61mOHTvm2ef+++83atSoYcybN89YtWqV0aZNG6NNmzY2Vl3ynH53jGHonFttxYoVRnh4uDF8+HBjy5YtxrRp04wyZcoYH3zwgWefV155xUhISDBmzZplrFu3zujSpYtuFw1A7969jQsuuMBzi+4XX3xhVKpUyXj00Uc9++icB+aPP/4wfvzxR+PHH380AOONN94wfvzxR2PHjh2GYXh3fm+44QajefPmxvLly41FixYZderU0S26ZxozZoxRo0YNIzIy0mjVqpWxbNkyu0sqMYBCl8mTJ3v2OX78uPHggw8a5cuXN8qUKWPcfPPNxt69e+0rugQ6M4TonFvvyy+/NBo1amRERUUZ9erVMyZMmFBgu9vtNp5++mkjMTHRiIqKMq699lpj06ZNNlVb/GVnZxsPPfSQUaNGDSM6Otq48MILjaeeesrIycnx7KNzHpj58+cX+u937969DcPw7vwePHjQ6NmzpxEbG2vExcUZffv2Nf744w+fa3EYxmnT0ImIiIgUkRI5JkRERERCn0KIiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQEQkpU6ZMISEh4bz7ORwOZs6cGfR6RCR4FEJESimXy0Xbtm3p1q1bgfVZWVkkJyfz1FNPnfPYq6++GofDgcPhIDo6mgYNGvD2229bUtdtt93G5s2bPd8/99xzNGvW7Kz99u7dS8eOHS15TRGxh0KISCnldDqZMmUK3333HdOmTfOsHzRoEBUqVODZZ5/9y+P79+/P3r172bBhA7feeisDBgzgww8/DLiumJgYqlSpct79kpKSiIqKCvj1RMQ+CiEipVjdunV55ZVXGDRoEHv37mXWrFl89NFHTJ06lcjIyL88tkyZMiQlJXHhhRfy3HPPUadOHWbPng3Azp076dKlC7GxscTFxXHrrbeyb98+z7Hp6em0b9+ecuXKERcXR4sWLVi1ahVQ8HLMlClTeP7550lPT/f0vEyZMgU4+3LMTz/9xDXXXENMTAwVK1bk3nvv5ciRI57tffr0oWvXrrz22mtUrVqVihUrMmDAAPLy8iw4kyLij3C7CxARew0aNIgZM2Zw55138tNPP/HMM8/QtGlTn9uJiYkhNzcXt9vtCSALFy4kPz+fAQMGcNttt7FgwQIAevXqRfPmzRk3bhxOp5O1a9cSERFxVpu33XYb69ev57vvvmPu3LkAxMfHn7Xf0aNH6dChA23atGHlypXs37+fe+65h4EDB3pCC8D8+fOpWrUq8+fP59dff+W2226jWbNm9O/f3+efV0QCpxAiUso5HA7GjRtH/fr1ady4MY8//rhPx7tcLj788EPWrVvHvffeS1paGj/99BPbtm0jOTkZgKlTp9KwYUNWrlzJpZdeys6dO3nkkUeoV68eAHXq1Cm07ZiYGGJjYwkPDycpKemcNUyfPp0TJ04wdepUypYtC8DYsWPp3LkzI0eOJDExEYDy5cszduxYnE4n9erVo1OnTqSlpSmEiNhEl2NEhEmTJlGmTBm2bdvGb7/95tUxb7/9NrGxscTExNC/f3+GDh3KAw88wMaNG0lOTvYEEIAGDRqQkJDAxo0bARg2bBj33HMPqampvPLKK2zdujWg+jdu3EjTpk09AQSgXbt2uN1uNm3a5FnXsGFDnE6n5/uqVauyf//+gF5bRPynECJSyi1ZsoQ333yTr776ilatWtGvXz8Mwzjvcb169WLt2rVs27aNo0eP8sYbbxAW5t0/Kc899xw///wznTp1Yt68eTRo0IAZM2YE+qOc15mXfBwOB263O+ivKyKFUwgRKcWOHTtGnz59eOCBB2jfvj3vvvsuK1asYPz48ec9Nj4+ntq1a3PBBRcUCB/169dn165d7Nq1y7Nuw4YNZGZm0qBBA8+6unXrMnToUP7zn//QrVs3Jk+eXOjrREZG4nK5/rKW+vXrk56eztGjRz3rFi9eTFhYGBdffPF5fxYRsYdCiEgp9sQTT2AYBq+88goAKSkpvPbaazz66KNs377drzZTU1Np3LgxvXr1Ys2aNaxYsYK77rqLq666ipYtW3L8+HEGDhzIggUL2LFjB4sXL2blypXUr1+/0PZSUlLYtm0ba9eu5cCBA+Tk5Jy1T69evYiOjqZ3796sX7+e+fPnM2jQIO68807PeBARCT0KISKl1MKFC3nrrbeYPHkyZcqU8ay/7777aNu2rdeXZc7kcDiYNWsW5cuX58orryQ1NZULL7yQjz/+GDDnJzl48CB33XUXdevW5dZbb6Vjx448//zzhbbXvXt3brjhBtq3b0/lypULnYukTJkyfP/99xw6dIhLL72UW265hWuvvZaxY8f6XL+IFB2H4c+/MiIiIiIBUk+IiIiI2EIhRERERGyhECIiIiK2UAgRERERWyiEiIiIiC0UQkRERMQWCiEiIiJiC4UQERERsYVCiIiIiNhCIURERERsoRAiIiIitvh/jkSzyE95As4AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -906,11 +820,20 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "env = SelectiveSensorsEnv(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ - "n_steps = 10000\n", + "n_steps = 10_000\n", "hist = []\n", "\n", "for i in range(n_steps):\n", @@ -918,14 +841,74 @@ " hist.append(state)" ] }, + { + "cell_type": "code", + "execution_count": 29, + "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 behaviors" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "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": 31, "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": 32, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 090c732f93b2f6e223765f28d5a8584b6980b96a Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 9 Jul 2024 15:54:23 +0200 Subject: [PATCH 17/18] Clean selective sensors imports and add notebook documentation --- .../notebooks/selective_sensors.ipynb | 360 ++++++------------ 1 file changed, 114 insertions(+), 246 deletions(-) diff --git a/vivarium/experimental/notebooks/selective_sensors.ipynb b/vivarium/experimental/notebooks/selective_sensors.ipynb index 24759de..aee523f 100644 --- a/vivarium/experimental/notebooks/selective_sensors.ipynb +++ b/vivarium/experimental/notebooks/selective_sensors.ipynb @@ -1,10 +1,25 @@ { "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": 3, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-07-09 15:48:58.727097: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + ] + } + ], "source": [ "import logging as lg\n", "\n", @@ -25,19 +40,30 @@ "\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" + "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": "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" + "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, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -107,33 +133,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Rewrote relative position + get_relative_displacement" + "Define get_relative_displacement" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "\n", - "### Define helper functions used to step from one state to the next one ###\n", - "def relative_position(displ, theta):\n", - " \"\"\"\n", - " Compute the relative distance and angle from a source agent to a target agent\n", - " :param displ: Displacement vector (jnp arrray with shape (2,) from source to target\n", - " :param theta: Orientation of the source agent (in the reference frame of the map)\n", - " :return: dist: distance from source to target.\n", - " relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0)\n", - " \"\"\"\n", - " dist = jnp.linalg.norm(displ)\n", - " norm_displ = displ / dist\n", - " theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))\n", - " relative_theta = theta_displ - theta\n", - " return dist, relative_theta\n", - "\n", - "proximity_map = vmap(relative_position, (0, 0))\n", - "\n", "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n", "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n", " body = state.entities.position\n", @@ -147,108 +155,22 @@ " 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\n", - "\n", - "#--- 1 Functions to compute the proximeter of braitenberg agents ---#\n", - "proximity_map = vmap(relative_position, (0, 0))\n", - "\n", - "def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):\n", - " \"\"\"\n", - " Compute the proximeter activations (left, right) induced by the presence of an entity\n", - " :param dist: distance from the agent to the entity\n", - " :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)\n", - " :param dist_max: Max distance of the proximiter (will return 0. above this distance)\n", - " :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)\n", - " :return: left and right proximeter activation in a jnp array with shape (2,)\n", - " \"\"\"\n", - " cos_dir = jnp.cos(relative_theta)\n", - " prox = 1. - (dist / dist_max)\n", - " in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)\n", - " at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)\n", - " left = in_view * at_left * prox\n", - " right = in_view * (1. - at_left) * prox\n", - " return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist\n", - "\n", - "sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))\n", - "\n", - "def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):\n", - " \"\"\"Return the sensor values of all agents\n", - "\n", - " :param dist: relative distances between agents and targets\n", - " :param relative_theta: relative angles between agents and targets\n", - " :param dist_max: maximum range of proximeters\n", - " :param cos_min: cosinus of proximeters angles\n", - " :param max_agents: number of agents\n", - " :param senders: indexes of agents sensing the environment\n", - " :param target_exists: mask to indicate which sensed entities exist or not \n", - " :return: proximeter activations\n", - " \"\"\"\n", - " raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)\n", - " # Computes the maximum within the proximeter activations of agents on all their neigbhors.\n", - " proxs = ops.segment_max(\n", - " raw_proxs,\n", - " senders, \n", - " max_agents)\n", - " \n", - " return proxs" + " return dist, theta, proximity_map_dist, proximity_map_theta\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Just put the behavior and compute motor functions and classes from simple braitenberg, 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 " + "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, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "class Behaviors(Enum):\n", - " FEAR = 0\n", - " AGGRESSION = 1\n", - " LOVE = 2\n", - " SHY = 3\n", - " NOOP = 4\n", - " MANUAL = 5\n", - "\n", - "behavior_params = {\n", - " Behaviors.FEAR.value: jnp.array(\n", - " [[1., 0., 0.], \n", - " [0., 1., 0.]]),\n", - " Behaviors.AGGRESSION.value: jnp.array(\n", - " [[0., 1., 0.], \n", - " [1., 0., 0.]]),\n", - " Behaviors.LOVE.value: jnp.array(\n", - " [[-1., 0., 1.], \n", - " [0., -1., 1.]]),\n", - " Behaviors.SHY.value: jnp.array(\n", - " [[0., -1., 1.], \n", - " [-1., 0., 1.]]),\n", - " Behaviors.NOOP.value: jnp.array(\n", - " [[0., 0., 0.], \n", - " [0., 0., 0.]]),\n", - "}\n", - "\n", - "def behavior_to_params(behavior):\n", - " \"\"\"Return the params associated to a behavior.\n", - "\n", - " :param behavior: behavior id (int)\n", - " :return: params\n", - " \"\"\"\n", - " return behavior_params[behavior]\n", - "\n", - "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", @@ -262,46 +184,7 @@ " 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\n", - "\n", - "def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):\n", - " \"\"\"Return the forward and angular speeds according the the speeds of left and right wheels\n", - "\n", - " :param left_spd: left wheel speed\n", - " :param right_spd: right wheel speed\n", - " :param base_length: distance between two wheels (diameter of the agent)\n", - " :param wheel_diameter: diameter of wheels\n", - " :return: forward and angular speeds\n", - " \"\"\"\n", - " fwd = (wheel_diameter / 4.) * (left_spd + right_spd)\n", - " rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)\n", - " return fwd, rot\n", - "\n", - "def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):\n", - " \"\"\"Return the left and right wheels speeds according to the forward and angular speeds\n", - "\n", - " :param fwd: forward speed\n", - " :param rot: angular speed\n", - " :param base_length: distance between wheels (diameter of agent)\n", - " :param wheel_diameter: diameter of wheels\n", - " :return: left wheel speed, right wheel speed\n", - " \"\"\"\n", - " left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter\n", - " right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter\n", - " return left, right\n", - "\n", - "def motor_command(wheel_activation, base_length, wheel_diameter):\n", - " \"\"\"Return the forward and angular speed according to wheels speeds\n", - "\n", - " :param wheel_activation: wheels speeds\n", - " :param base_length: distance between wheels\n", - " :param wheel_diameter: wheel diameters\n", - " :return: forward and angular speeds\n", - " \"\"\"\n", - " fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)\n", - " return fwd, rot\n", - "\n", - "motor_command = vmap(motor_command, (0, 0, 0))" + " return motor_values" ] }, { @@ -311,12 +194,14 @@ "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)" + "- 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": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -338,16 +223,14 @@ "\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", - "- --> vmaped version computes this for all the behaviors of an agent\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", - " --> vmaped version: computes this for all agents (vmap over params, sensed and agent_raw_proxs) \n", - "\n", - "TODO --> Should surely also vmap on behaviors and motors for an agent (here only use the params)" + "- #vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -391,81 +274,15 @@ ] }, { - "cell_type": "code", - "execution_count": 9, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "\n", - "# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces\n", - "def braintenberg_force_fn(displacement):\n", - " coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))\n", - "\n", - " def collision_force(state, neighbor, exists_mask):\n", - " return coll_force_fn(\n", - " state.entities.position.center,\n", - " neighbor=neighbor,\n", - " exists_mask=exists_mask,\n", - " diameter=state.entities.diameter,\n", - " epsilon=state.collision_eps,\n", - " alpha=state.collision_alpha\n", - " )\n", - "\n", - " def motor_force(state, exists_mask):\n", - " agent_idx = state.agents.ent_idx\n", - "\n", - " body = rigid_body.RigidBody(\n", - " center=state.entities.position.center[agent_idx],\n", - " orientation=state.entities.position.orientation[agent_idx]\n", - " )\n", - " \n", - " n = normal(body.orientation)\n", - "\n", - " fwd, rot = motor_command(\n", - " state.agents.motor,\n", - " state.entities.diameter[agent_idx],\n", - " state.agents.wheel_diameter\n", - " )\n", - " # `a_max` arg is deprecated in recent versions of jax, replaced by `max`\n", - " fwd = jnp.clip(fwd, a_max=state.agents.max_speed)\n", - "\n", - " cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]\n", - " cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)\n", - " cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]\n", - " \n", - " fwd_delta = fwd - cur_fwd_vel\n", - " rot_delta = rot - cur_rot_vel\n", - "\n", - " fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T\n", - " rot_force = rot_delta * state.agents.theta_mul\n", - "\n", - " center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)\n", - " orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)\n", - "\n", - " # apply mask to make non existing agents stand still\n", - " orientation = jnp.where(exists_mask, orientation, 0.)\n", - " # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center\n", - " exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)\n", - " center = jnp.where(exists_mask, center, 0.)\n", - "\n", - " return rigid_body.RigidBody(center=center,\n", - " orientation=orientation)\n", - " \n", - " def force_fn(state, neighbor, exists_mask):\n", - " mf = motor_force(state, exists_mask)\n", - " cf = collision_force(state, neighbor, exists_mask)\n", - " ff = friction_force(state, exists_mask)\n", - " \n", - " center = cf + ff + mf.center\n", - " orientation = mf.orientation\n", - " return rigid_body.RigidBody(center=center, orientation=orientation)\n", - "\n", - " return force_fn" + "## Create the main environment class" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -566,9 +383,16 @@ " return neighbors" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the state" + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -605,9 +429,16 @@ "key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Entities" + ] + }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -654,9 +485,16 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agents" + ] + }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -740,9 +578,16 @@ ")\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Objects" + ] + }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -768,9 +613,16 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State" + ] + }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -789,9 +641,16 @@ ") " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test the simulation" + ] + }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -800,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -820,16 +679,23 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "env = SelectiveSensorsEnv(state)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Autonomous behaviors" + ] + }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -843,12 +709,12 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -865,12 +731,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Test manual behaviors" + "### Test manual behavior for an agent\n", + "\n", + "Need to set all of its behaviors to manual." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -889,7 +757,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -903,12 +771,12 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From b00d65989cbfe3f5983c49fc0353001a97c3fde8 Mon Sep 17 00:00:00 2001 From: corentinlger Date: Tue, 9 Jul 2024 16:04:44 +0200 Subject: [PATCH 18/18] Revert changes on non selective sensors environments --- .../braitenberg/behaviors_refactor.py | 519 ------------------ .../notebooks/prey_predator_braitenberg.ipynb | 154 ------ 2 files changed, 673 deletions(-) delete mode 100644 vivarium/experimental/environments/braitenberg/behaviors_refactor.py diff --git a/vivarium/experimental/environments/braitenberg/behaviors_refactor.py b/vivarium/experimental/environments/braitenberg/behaviors_refactor.py deleted file mode 100644 index 883d5fe..0000000 --- a/vivarium/experimental/environments/braitenberg/behaviors_refactor.py +++ /dev/null @@ -1,519 +0,0 @@ -# TODO : Added these lines for testing purposes (there was a bug from a jax_md error where gpu isn't detected anymore) -import os -os.environ["JAX_PLATFORMS"] = "cpu" - -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 - -from jax import vmap, jit -from jax import random, ops, lax - -from flax import struct -from jax_md.rigid_body import RigidBody -from jax_md import space, rigid_body, partition, quantity - -from vivarium.experimental.environments.braitenberg.render import normal -from vivarium.experimental.environments.base_env import BaseState, BaseEntityState, BaseAgentState, BaseObjectState, BaseEnv -from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn - -### Define the constants and the classes of the environment to store its state ### - -SPACE_NDIMS = 2 - -# TODO : Should maybe just let the user define its own class and just have a base class State with time ... -class EntityType(Enum): - AGENT = 0 - OBJECT = 1 - -@struct.dataclass -class EntityState(BaseEntityState): - pass - -@struct.dataclass -class AgentState(BaseAgentState): - prox: jnp.array - motor: jnp.array - proximity_map_dist: jnp.array - proximity_map_theta: jnp.array - behavior: jnp.array - params: 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(BaseObjectState): - pass - -@struct.dataclass -class State(BaseState): - time: jnp.int32 - box_size: jnp.int32 - 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 - entities: EntityState - agents: AgentState - objects: ObjectState - -### Define helper functions used to step from one state to the next one ### - - -#--- 1 Functions to compute the proximeter of braitenberg agents ---# - -def relative_position(displ, theta): - """ - Compute the relative distance and angle from a source agent to a target agent - :param displ: Displacement vector (jnp arrray with shape (2,) from source to target - :param theta: Orientation of the source agent (in the reference frame of the map) - :return: dist: distance from source to target. - relative_theta: relative angle of the target in the reference frame of the source agent (front direction at angle 0) - """ - dist = jnp.linalg.norm(displ) - norm_displ = displ / dist - theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1])) - relative_theta = theta_displ - theta - return dist, relative_theta - -proximity_map = vmap(relative_position, (0, 0)) - -# TODO : Could potentially refactor these functions with vmaps to make them easier (not a priority) -def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists): - """ - Compute the proximeter activations (left, right) induced by the presence of an entity - :param dist: distance from the agent to the entity - :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0) - :param dist_max: Max distance of the proximiter (will return 0. above this distance) - :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total) - :return: left and right proximeter activation in a jnp array with shape (2,) - """ - cos_dir = jnp.cos(relative_theta) - prox = 1. - (dist / dist_max) - in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min) - at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0) - left = in_view * at_left * prox - right = in_view * (1. - at_left) * prox - return jnp.array([left, right]) * target_exists # i.e. 0 if target does not exist - -sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0)) - -def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists): - raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists) - - # Computes the maximum within the proximeter activations of agents on all their neigbhors. - proxs = ops.segment_max( - raw_proxs, - senders, - max_agents) - - return proxs - - -# TODO : Could potentially refactor this part of the code with a function using vmap (not a priority) -def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement): - """ - Set agents' proximeter activations - :param state: full simulation State - :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs), - where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes. - :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,). - target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist). - :return: - """ - body = state.entities.position - senders, receivers = agents_neighs_idx - Ra = body.center[senders] - Rb = body.center[receivers] - dR = - space.map_bond(displacement)(Ra, Rb) # Looks like it should be opposite, but don't understand why - - # Create distance and angle maps between entities - 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) - - # TODO : Could refactor this function bc there's a lot of redundancies in the arguments (state.agents) - mask = target_exists_mask[agents_neighs_idx[1, :]] - prox = sensor(dist, theta, state.agents.proxs_dist_max[senders], - state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask) - - # TODO Could refactor this to have a cleaner split of functions (instead of returning 3 args here) - return prox, proximity_map_dist, proximity_map_theta - - -#--- 2 Functions to compute the motor activations of braitenberg agents ---# - -# TODO : See how we'll handle this on client side -class Behaviors(Enum): - FEAR = 0 - AGGRESSION = 1 - LOVE = 2 - SHY = 3 - NOOP = 4 - MANUAL = 5 - -# TODO : Could find a better name than params ? Or can be good enough -behavior_params = { - Behaviors.FEAR.value: jnp.array( - [[1., 0., 0.], - [0., 1., 0.]]), - Behaviors.AGGRESSION.value: jnp.array( - [[0., 1., 0.], - [1., 0., 0.]]), - Behaviors.LOVE.value: jnp.array( - [[-1., 0., 1.], - [0., -1., 1.]]), - Behaviors.SHY.value: jnp.array( - [[0., -1., 1.], - [-1., 0., 1.]]), - Behaviors.NOOP.value: jnp.array( - [[0., 0., 0.], - [0., 0., 0.]]), -} - -def behavior_to_params(behavior): - return behavior_params[behavior] - -def compute_motor(proxs, params): - """Compute motor values according to proximeter values and params - - :param proxs: proximeter values - :param params: linear mapping between proxs and motor values - :return: motor activations - """ - return params.dot(jnp.hstack((proxs, 1.))) - -sensorimotor = vmap(compute_motor, in_axes=(0, 0)) - -def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter): - fwd = (wheel_diameter / 4.) * (left_spd + right_spd) - rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd) - return fwd, rot - -def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter): - left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter - right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter - return left, right - -def motor_command(wheel_activation, base_length, wheel_diameter): - fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter) - return fwd, rot - -motor_command = vmap(motor_command, (0, 0, 0)) - - -#--- 3 Functions to compute the different forces in the environment ---# - -# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces -def braintenberg_force_fn(displacement): - coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement)) - - def collision_force(state, neighbor, exists_mask): - return coll_force_fn( - state.entities.position.center, - neighbor=neighbor, - exists_mask=exists_mask, - diameter=state.entities.diameter, - epsilon=state.collision_eps, - alpha=state.collision_alpha - ) - - def motor_force(state, exists_mask): - agent_idx = state.agents.ent_idx - - body = rigid_body.RigidBody( - center=state.entities.position.center[agent_idx], - orientation=state.entities.position.orientation[agent_idx] - ) - - n = normal(body.orientation) - - fwd, rot = motor_command( - state.agents.motor, - state.entities.diameter[agent_idx], - state.agents.wheel_diameter - ) - # `a_max` arg is deprecated in recent versions of jax, replaced by `max` - fwd = jnp.clip(fwd, a_max=state.agents.max_speed) - - cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx] - cur_fwd_vel = vmap(jnp.dot)(cur_vel, n) - cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx] - - fwd_delta = fwd - cur_fwd_vel - rot_delta = rot - cur_rot_vel - - fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T - rot_force = rot_delta * state.agents.theta_mul - - center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force) - orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force) - - # apply mask to make non existing agents stand still - orientation = jnp.where(exists_mask, orientation, 0.) - # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center - exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1) - center = jnp.where(exists_mask, center, 0.) - - return rigid_body.RigidBody(center=center, - orientation=orientation) - - def force_fn(state, neighbor, exists_mask): - mf = motor_force(state, exists_mask) - cf = collision_force(state, neighbor, exists_mask) - ff = friction_force(state, exists_mask) - - center = cf + ff + mf.center - orientation = mf.orientation - return rigid_body.RigidBody(center=center, orientation=orientation) - - return force_fn - - -#--- 4 Define the environment class with its different functions (init_state, _step ...) ---# - -class BraitenbergEnv(BaseEnv): - def __init__( - self, - box_size=100, - dt=0.1, - max_agents=10, - max_objects=2, - neighbor_radius=100., - collision_alpha=0.5, - collision_eps=0.1, - n_dims=2, - seed=0, - diameter=5.0, - friction=0.1, - mass_center=1.0, - mass_orientation=0.125, - existing_agents=10, - existing_objects=2, - behaviors=Behaviors.AGGRESSION.value, - 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, - agents_color=jnp.array([0.0, 0.0, 1.0]), - objects_color=jnp.array([1.0, 0.0, 0.0]) - ): - - # TODO : add docstrings - # general parameters - self.box_size = box_size - self.dt = dt - self.max_agents = max_agents - self.max_objects = max_objects - self.neighbor_radius = neighbor_radius - self.collision_alpha = collision_alpha - self.collision_eps = collision_eps - self.n_dims = n_dims - self.seed = seed - # entities parameters - self.diameter = diameter - self.friction = friction - self.mass_center = mass_center - self.mass_orientation = mass_orientation - self.existing_agents = existing_agents - self.existing_objects = existing_objects - # agents parameters - self.behaviors = behaviors - self.wheel_diameter = wheel_diameter - self.speed_mul = speed_mul - self.max_speed = max_speed - self.theta_mul = theta_mul - self.prox_dist_max = prox_dist_max - self.prox_cos_min = prox_cos_min - self.agents_color = agents_color - # objects parameters - self.objects_color = objects_color - # TODO : other parameters are defined when init_state is called, maybe coud / should set them to None here ? - # Or can also directly initialize the state ... and jax_md attributes in this function too ... - - def init_state(self) -> State: - key = random.PRNGKey(self.seed) - key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4) - - entities = self.init_entities(key_agents_pos, key_objects_pos, key_orientations) - agents = self.init_agents() - objects = self.init_objects() - state = self.init_complete_state(entities, agents, objects) - - # Create jax_md attributes for environment physics - # TODO : Might not be optimal to just use this function here (harder to understand what's in the class attributes) - state = self.init_env_physics(key, state) - - return state - - def distance(self, point1, point2): - diff = self.displacement(point1, point2) - squared_diff = jnp.sum(jnp.square(diff)) - return jnp.sqrt(squared_diff) - - # TODO See how to clean the function to remove the agents_neighs_idx - # @partial(jit, static_argnums=(0,)) - def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]: - # 1 : Compute agents proximeter - exists_mask = jnp.where(state.entities.exists == 1, 1, 0) - prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement) - - # 2 : Compute motor activations according to new proximeter values - motor = sensorimotor(prox, state.agents.params) - agents = state.agents.replace( - prox=prox, - proximity_map_dist=proximity_dist_map, - proximity_map_theta=proximity_dist_theta, - motor=motor - ) - - # 3 : Update the state with new agents proximeter and motor values - state = state.replace(agents=agents) - - # 4 : Move the entities by applying forces on them (collision, friction and motor forces for agents) - entities = self.apply_physics(state, neighbors) - state = state.replace(time=state.time+1, entities=entities) - - # 5 : Update neighbors - neighbors = neighbors.update(state.entities.position.center) - return state, neighbors - - def step(self, state: State) -> State: - current_state = state - state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx) - - if self.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') - neighbors = self.allocate_neighbors(state) - assert not neighbors.did_buffer_overflow - - self.neighbors = neighbors - return state - - # TODO See how we deal with agents_neighs_idx - def allocate_neighbors(self, state, position=None): - position = state.entities.position.center if position is None else position - neighbors = self.neighbor_fn.allocate(position) - - # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here) - ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value - self.agents_neighs_idx = neighbors.idx[:, ag_idx] - - return neighbors - - # TODO : Modify these functions so can give either 1 param and apply it to every entity or give custom ones - def init_entities(self, key_agents_pos, key_objects_pos, key_orientations): - n_entities = self.max_agents + self.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, (self.max_agents, self.n_dims)) * self.box_size - objects_positions = random.uniform(key_objects_pos, (self.max_objects, self.n_dims)) * self.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(self.max_agents, EntityType.AGENT.value) - object_entities = jnp.full(self.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((self.existing_agents)), jnp.zeros((self.max_agents - self.existing_agents)))) - exists_objects = jnp.concatenate((jnp.ones((self.existing_objects)), jnp.zeros((self.max_objects - self.existing_objects)))) - exists = jnp.concatenate((exists_agents, exists_objects), 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), self.mass_center), orientation=jnp.full((n_entities), self.mass_orientation)), - entity_type=entity_types, - entity_idx = jnp.array(list(range(self.max_agents)) + list(range(self.max_objects))), - diameter=jnp.full((n_entities), self.diameter), - friction=jnp.full((n_entities), self.friction), - exists=exists - ) - - def init_agents(self): - # TODO : Change that so can define custom behaviors (e.g w a list) - # Use numpy cuz jnp elements cannot be keys of a dict - behaviors = np.full((self.max_agents), self.behaviors) - # Cannot use a vmap fn because of dictionary, cannot have jax elements as a key because its unhashable - params = jnp.array([behavior_to_params(behavior) for behavior in behaviors]) - return AgentState( - # idx in the entities (ent_idx) state to map agents information in the different data structures - ent_idx=jnp.arange(self.max_agents, dtype=int), - prox=jnp.zeros((self.max_agents, 2)), - motor=jnp.zeros((self.max_agents, 2)), - behavior=behaviors, - params=params, - wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter), - speed_mul=jnp.full((self.max_agents), self.speed_mul), - max_speed=jnp.full((self.max_agents), self.max_speed), - theta_mul=jnp.full((self.max_agents), self.theta_mul), - proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max), - proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min), - proximity_map_dist=jnp.zeros((self.max_agents, 1)), - proximity_map_theta=jnp.zeros((self.max_agents, 1)), - color=jnp.tile(self.agents_color, (self.max_agents, 1)) - ) - - def init_objects(self): - # Entities idx of objects - start_idx, stop_idx = self.max_agents, self.max_agents + self.max_objects - objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int) - - return ObjectState( - ent_idx=objects_ent_idx, - color=jnp.tile(self.objects_color, (self.max_objects, 1)) - ) - - def init_complete_state(self, entities, agents, objects): - lg.info('Initializing state') - return State( - time=0, - box_size=self.box_size, - max_agents=self.max_agents, - max_objects=self.max_objects, - neighbor_radius=self.neighbor_radius, - collision_alpha=self.collision_alpha, - collision_eps=self.collision_eps, - dt=self.dt, - entities=entities, - agents=agents, - objects=objects - ) - - def init_env_physics(self, key, state): - lg.info("Initializing environment's physics features") - key, physics_key = random.split(key) - self.displacement, self.shift = space.periodic(self.box_size) - self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn) - self.neighbor_fn = partition.neighbor_list( - self.displacement, - self.box_size, - r_cutoff=self.neighbor_radius, - dr_threshold=10., - capacity_multiplier=1.5, - format=partition.Sparse - ) - - state = self.init_fn(state, physics_key) - lg.info("Allocating neighbors") - neighbors = self.allocate_neighbors(state) - self.neighbors = neighbors - - return state diff --git a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb index fbe21d4..5ce035c 100644 --- a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb +++ b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb @@ -6,11 +6,7 @@ "source": [ "# Prey predator braitenberg notebook\n", "\n", -<<<<<<< HEAD - "This notebook showcases how to add new features on top on a pre-existing vivarium environment. Here, we will focus on implementing a prey predator braitenberg environment." -======= "This notebook showcases how to add new features on top on a pre-existing vivarium environment. Here, we will focus on implementing a prey predator braitenberg environment !" ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] }, { @@ -19,11 +15,7 @@ "source": [ "## Imports\n", "\n", -<<<<<<< HEAD - "Start by import standard jax functions as well as elements (Classes, functions ...) from the environment you want to build features on." -======= "First, let's import Classes and functions from the environment you want to build features on, as well as standard jax elements to build new features in our environment." ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] }, { @@ -35,11 +27,7 @@ "name": "stderr", "output_type": "stream", "text": [ -<<<<<<< HEAD - "2024-06-17 16:55:41.332298: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" -======= "2024-07-04 11:03:15.059320: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] } ], @@ -48,22 +36,14 @@ "from functools import partial\n", "from typing import Tuple\n", "\n", -<<<<<<< HEAD -======= "import numpy as np\n", ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "import jax.numpy as jnp\n", "\n", "from jax import vmap, jit\n", "from flax import struct\n", "\n", -<<<<<<< HEAD - "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType\n", - "from vivarium.experimental.environments.braitenberg.simple import sensorimotor, compute_prox, behavior_name_map" -======= "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType, init_complete_state, init_entities, init_objects\n", "from vivarium.experimental.environments.braitenberg.simple import compute_motor, compute_prox, behavior_to_params, Behaviors" ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] }, { @@ -72,11 +52,7 @@ "source": [ "### Define the states classes of prey predator env \n", "\n", -<<<<<<< HEAD - "Redefine the classes and constants of the environment (most of them inherit from the simple braitenbeg one). We will just add a new field agent_type (prey or predator) for all of our agents." -======= "Define the new classes and constants of the environment. We will just add a new field agent_type (prey or predator) for all of our agents, so whe can differenciate them when we run the simulation." ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] }, { @@ -85,10 +61,6 @@ "metadata": {}, "outputs": [], "source": [ -<<<<<<< HEAD - "\n", -======= ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "class AgentType(Enum):\n", " PREY = 0\n", " PREDATOR = 1\n", @@ -102,21 +74,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ -<<<<<<< HEAD - "### Define prey predator env class \n", - "\n", - "Our environment inherits from the simple Braitenberg env, so we will only have to overwrite a few methods and create some new ones to create our prey predator environment. \n", - "\n", - "First, we need to overwrite the \\_\\_init__() function to allow specifying new parameters about preys and predators (their number and their colors here).\n", - "\n", - "Then, we also have to overwrite the _init_agents() function because we have a new AgentState class. We also add a small modification to init_state() to add indexes of prey and predators agents as attributes of the class.\n", - "\n", - "Finally, we just have to write functions to implement our new desired features (here the predators will kill the preys next to them), and add them in the _step() function !" -======= "### Create the new state\n", "\n", "First we'll create a new state for the prey predator environment. It will be pretty similar to the one of the simple braitenberg env, but we will just add a new field agent_type to our agents. Additionally, we'll use different colors and behaviors for the prey and predators." ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] }, { @@ -125,58 +85,6 @@ "metadata": {}, "outputs": [], "source": [ -<<<<<<< HEAD - "class PreyPredBraitenbergEnv(BraitenbergEnv):\n", - " def __init__(\n", - " self,\n", - " # New prey_predators args, should maybe add warnings to avoid incompatible values (e.g less agents than prey + pred)\n", - " n_preys=25,\n", - " n_predators=25,\n", - " pred_eating_range=10,\n", - " prey_color=jnp.array([0.0, 0.0, 1.0]),\n", - " predator_color=jnp.array([1.0, 0.0, 0.0]),\n", - " **kwargs\n", - " ): \n", - " # Initialize the attributes of old class with max_agents = n_preys + n_predators\n", - " max_agents = n_preys + n_predators \n", - " super().__init__(max_agents=max_agents, **kwargs)\n", - " # Add specific attributes about prey / predator environment\n", - " self.n_preys = n_preys\n", - " self.n_predators = n_predators\n", - " self.prey_color = prey_color\n", - " self.predator_color = predator_color\n", - " self.pred_eating_range = pred_eating_range\n", - "\n", - " def _init_agents(self):\n", - " # Added agent types for prey and predators\n", - " agent_types = jnp.hstack((jnp.full(self.n_preys, AgentType.PREY.value), jnp.full(self.n_predators, AgentType.PREDATOR.value)))\n", - " agents_colors = jnp.concatenate((jnp.tile(self.prey_color, (self.n_preys, 1)), jnp.tile(self.predator_color, (self.n_predators, 1))), axis=0)\n", - " behaviors = jnp.hstack((jnp.full(self.n_preys, behavior_name_map['FEAR']), jnp.full(self.n_predators, behavior_name_map['AGGRESSION'])))\n", - "\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(self.max_agents, dtype=int),\n", - " agent_type=agent_types, \n", - " prox=jnp.zeros((self.max_agents, 2)),\n", - " motor=jnp.zeros((self.max_agents, 2)),\n", - " behavior=behaviors,\n", - " wheel_diameter=jnp.full((self.max_agents), self.wheel_diameter),\n", - " speed_mul=jnp.full((self.max_agents), self.speed_mul),\n", - " max_speed=jnp.full((self.max_agents), self.max_speed),\n", - " theta_mul=jnp.full((self.max_agents), self.theta_mul),\n", - " proxs_dist_max=jnp.full((self.max_agents), self.prox_dist_max),\n", - " proxs_cos_min=jnp.full((self.max_agents), self.prox_cos_min),\n", - " proximity_map_dist=jnp.zeros((self.max_agents, 1)),\n", - " proximity_map_theta=jnp.zeros((self.max_agents, 1)),\n", - " color=agents_colors\n", - " )\n", - "\n", - " return agents\n", - "\n", - " def init_state(self) -> State:\n", - " state = super().init_state()\n", - "\n", -======= "# parameter values\n", "n_preys = 25\n", "n_predators = 25\n", @@ -271,19 +179,12 @@ " pred_eating_range\n", " ): \n", " super().__init__(state=state)\n", ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 " # Add idx utils to simplify conversions between entities and agent states\n", " self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n", " self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n", " self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n", -<<<<<<< HEAD - "\n", - " return state\n", - " \n", -======= " self.pred_eating_range = pred_eating_range\n", "\n", ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 " # Add a function to detect if a prey will be eaten by a predator in the current step\n", " def can_all_be_eaten(self, R_prey, R_predators, predator_exist):\n", " # Could maybe create this as a method in the class, or above idk\n", @@ -331,11 +232,7 @@ " # 2 Compute the proximeter of agents\n", " exists_mask = jnp.where(entities.exists == 1, 1, 0)\n", " prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n", -<<<<<<< HEAD - " motor = sensorimotor(prox, state.agents.behavior, state.agents.motor)\n", -======= " motor = compute_motor(prox, state.agents.params, state.agents.behavior, state.agents.motor)\n", ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 " agents = state.agents.replace(\n", " prox=prox, \n", " proximity_map_dist=proximity_dist_map, \n", @@ -376,11 +273,7 @@ }, { "cell_type": "code", -<<<<<<< HEAD - "execution_count": 4, -======= "execution_count": 6, ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "metadata": {}, "outputs": [], "source": [ @@ -389,32 +282,6 @@ }, { "cell_type": "code", -<<<<<<< HEAD - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "BOX_SIZE = 200\n", - "\n", - "N_PRED = 25\n", - "N_PREY = 25\n", - "MAX_OBJ = 25\n", - "\n", - "PRED_COLOR = jnp.array([1., 0., 0.])\n", - "PREY_COLOR = jnp.array([0., 0., 1.])\n", - "OBJ_COLOR = jnp.array([0., 1., 0.])\n", - "\n", - "env = PreyPredBraitenbergEnv(\n", - " box_size=BOX_SIZE,\n", - " max_objects=MAX_OBJ,\n", - " predator_color=PRED_COLOR,\n", - " prey_color=PREY_COLOR,\n", - " objects_color=OBJ_COLOR,\n", - " n_predators=N_PRED,\n", - " n_preys=N_PREY\n", - ")\n", - "state = env.init_state()" -======= "execution_count": 7, "metadata": {}, "outputs": [], @@ -423,25 +290,16 @@ " state=state,\n", " pred_eating_range=pred_eating_range\n", ")" ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 ] }, { "cell_type": "code", -<<<<<<< HEAD - "execution_count": 6, -======= "execution_count": 8, ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "metadata": {}, "outputs": [ { "data": { -<<<<<<< HEAD - "image/png": "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", -======= "image/png": "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", ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "text/plain": [ "
" ] @@ -463,11 +321,7 @@ }, { "cell_type": "code", -<<<<<<< HEAD - "execution_count": 7, -======= "execution_count": 9, ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "metadata": {}, "outputs": [], "source": [ @@ -481,20 +335,12 @@ }, { "cell_type": "code", -<<<<<<< HEAD - "execution_count": 8, -======= "execution_count": 10, ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "metadata": {}, "outputs": [ { "data": { -<<<<<<< HEAD - "image/png": "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", -======= "image/png": "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", ->>>>>>> 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 "text/plain": [ "
" ]