gym-examples 2.0.29__py3-none-any.whl → 2.0.31__py3-none-any.whl

gym_examples/__init__.py

@@ -6,4 +6,4 @@ register(
      max_episode_steps=50,
 )
 
-__version__ = "2.0.29"
+__version__ = "2.0.31"

gym_examples/envs/wsn_env.py

@@ -22,7 +22,7 @@ initial_energy = 1  # initial energy of each sensor (in joules)
 lower_bound = 0  # lower bound of the sensor positions
 upper_bound = 100  # upper bound of the sensor positions
 base_station_position = np.array([(upper_bound - lower_bound)/2, (upper_bound - lower_bound)/2]) # position of the base station
-
+initial_number_of_packets = 1  # initial number of packets to transmit
 
 
 # Define the final reward function using an attention mechanism
@@ -74,7 +74,7 @@ class WSNRoutingEnv(gym.Env):
         # Initialize remaining energy of each sensor to initial_energy joule
         self.remaining_energy = np.ones(self.n_sensors) * initial_energy
         self.consumption_energy = np.zeros(self.n_sensors)
-        self.number_of_packets = np.ones(self.n_sensors, dtype=int)  # Number of packets to transmit
+        self.number_of_packets = np.ones(self.n_sensors, dtype=int) * initial_number_of_packets # number of packets to transmit
         self.episode_count += 1
         return self._get_obs()
 
@@ -95,31 +95,27 @@ class WSNRoutingEnv(gym.Env):
             if (action == i):
                 continue  # Skip if sensor tries to transmit data to itself
 
-            neighbors_i = self.eligible_receivers(i)
-            keys_neighbors_i = list(neighbors_i.keys())
-            if len(neighbors_i) == 0 or action not in keys_neighbors_i:
-                continue
-
-            remaining_energy_before = copy.deepcopy(self.remaining_energy)
             if action == self.n_sensors:
-                rewards[i] = self.compute_individual_rewards(i, action, neighbors_i, remaining_energy_before)
-                dones[i] = True
                 # Calculate the energy consumption and remaining for transmitting data to the base station
-                self.update_sensor_energies(i, neighbors_i[action]['transmission_energy'])        
+                transmission_energy = self.transmission_energy(self.number_of_packets[i], self.distance_to_base[i])
+                self.update_sensor_energies(i, transmission_energy) 
+                rewards[i] = self.compute_individual_rewards(i, action)
+                dones[i] = True       
             else:
-                self.update_sensor_energies(i, neighbors_i[action]['transmission_energy'])  
-                self.update_sensor_energies(action, neighbors_i[action]['reception_energy'])   
-                # Update the number of packets of the sensor action
-                self.number_of_packets[action] += self.number_of_packets[i]
-                self.distance_to_base[action] = np.linalg.norm(self.sensor_positions[action] - base_station_position)
+                distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
+                transmission_energy = self.transmission_energy(self.number_of_packets[i], distance)
+                reception_energy = self.reception_energy(self.number_of_packets[i])
+                self.update_sensor_energies(i, transmission_energy)  
+                self.update_sensor_energies(action, reception_energy)   
                 # Compute individual rewards
-                rewards[i] = self.compute_individual_rewards(i, action, neighbors_i, remaining_energy_before)
+                rewards[i] = self.compute_individual_rewards(i, action)
+                # Update the number of packets
+                self.number_of_packets[action] += self.number_of_packets[i]
             self.number_of_packets[i] = 0 # Reset the number of packets of the sensor i
             # Calculate final reward
             # rewards_individual = torch.tensor(rewards[i], dtype=torch.double)                
             # final_reward = net(rewards_individual)
-            # final_reward = sum(rewards[i])
-            final_reward = np.mean(rewards[i])
+            final_reward = np.sum(rewards[i])
             rewards[i] = final_reward
 
         for i in range(self.n_sensors):
@@ -129,6 +125,8 @@ class WSNRoutingEnv(gym.Env):
         # Integrate the mobility of the sensors
         self.integrate_mobility() 
 
+        self.distance_to_base = np.linalg.norm(self.sensor_positions - base_station_position, axis=1)
+
         return self._get_obs(), rewards, dones, {}
 
     def _get_obs(self):
@@ -155,13 +153,13 @@ class WSNRoutingEnv(gym.Env):
         self.consumption_energy[i] += delta_energy
         self.remaining_energy[i] -= delta_energy
 
-    def transmission_energy(self, i, distance):
+    def transmission_energy(self, number_of_packets, distance):
         # energy consumption for transmitting data on a distance        
-        return self.number_of_packets[i] * info_amount * (Eelec + Eamp * distance**2)
+        return number_of_packets * info_amount * (Eelec + Eamp * distance**2)
     
-    def reception_energy(self, i):
+    def reception_energy(self, number_of_packets):
         # energy consumption for receiving data
-        return self.number_of_packets[i] * info_amount * Eelec
+        return number_of_packets * info_amount * Eelec
     
     def compute_angle_vectors(self, i, action):
         '''
@@ -176,101 +174,83 @@ class WSNRoutingEnv(gym.Env):
             
             return np.arccos(np.clip(cosine_angle, -1, 1))
 
-    def compute_reward_angle(self, i, action, neighbors_i):
+    def compute_reward_angle(self, i, action):
         '''
         Compute the reward based on the angle between the vectors formed by (i, action) and (i, base station)
         '''
-        if len(neighbors_i) == 1:
-            return 1
-        else:
-            # Calculate the angle in radians between the vectors formed by (i, action) and (i, base station)
-            angle = self.compute_angle_vectors(i, action)
-            # Normalize the angle
-            total_angles_without_direction = np.sum([abs(self.compute_angle_vectors(i, x)) for x in neighbors_i])
-            normalized_angle = abs(angle) / total_angles_without_direction
+        # Calculate the angle in radians between the vectors formed by (i, action) and (i, base station)
+        angle = self.compute_angle_vectors(i, action)
+        # Normalize the angle
+        normalized_angle = abs(angle) / np.pi
 
-            return 1 - normalized_angle
+        return 1 - normalized_angle
     
-    def compute_reward_distance(self, action, neighbors_i):
+    def compute_reward_distance(self, i, action):
         '''
         Compute the reward based on the distance to the next hop
         '''
-        if len(neighbors_i) == 1:
-            return 1
+        if action == self.n_sensors:
+            distance = np.linalg.norm(self.sensor_positions[i] - base_station_position)
         else:
-            total_distances = np.sum([neighbors_i[x]['distance'] for x in neighbors_i]) 
-            # Normalize the distance to the next hop
-            normalized_distance_to_next_hop = neighbors_i[action]['distance'] / total_distances
+            distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
+        # Normalize the distance to the next hop
+        normalized_distance_to_next_hop = distance / self.coverage_radius
 
-            return 1 - normalized_distance_to_next_hop
+        return 1 - normalized_distance_to_next_hop
 
-    def compute_reward_consumption_energy(self, action, neighbor_i):
+    def compute_reward_consumption_energy(self, i, action):
         '''
         Compute the reward based on the total energy consumption (transmission, reception)
         '''
-        if len(neighbor_i) == 1:
-            return 1
+        # Calculate the total energy consumption (transmission, reception)
+        if action == self.n_sensors:
+            total_energy = self.transmission_energy(self.number_of_packets[i], self.distance_to_base[i])
         else:
-            # Calculate the total energy consumption (transmission, reception)
-            total_energy = neighbor_i[action]['transmission_energy'] + neighbor_i[action]['reception_energy']
-
-            # Normalize the total energy consumption
-            total_transmission_energies = np.sum([neighbor_i[x]['transmission_energy'] for x in neighbor_i])
-            total_reception_energies = np.sum([neighbor_i[x]['reception_energy'] for x in neighbor_i])
-            total_energies = total_transmission_energies + total_reception_energies
-            normalized_total_energy = total_energy / total_energies
-
-            return 1 - normalized_total_energy
+            distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[action])
+            transmission_energy = self.transmission_energy(self.number_of_packets[i], distance)
+            reception_energy = self.reception_energy(self.number_of_packets[i])
+            total_energy = transmission_energy + reception_energy
+
+        # Normalize the total energy consumption
+        max_transmission_energy = self.transmission_energy(self.n_sensors * initial_number_of_packets, self.coverage_radius)
+        max_reception_energy = self.reception_energy(self.n_sensors * initial_number_of_packets)
+        max_total_energy = max_transmission_energy + max_reception_energy
+        normalized_total_energy = total_energy / max_total_energy
+
+        return 1 - normalized_total_energy
     
-    def compute_dispersion_remaining_energy(self, i, action, neighbor_i, remaining_energy_before):
-        '''
-        Compute the variation of sensors remaining energy after transmission and reception
-        '''
-        temporary_remaining_energy = copy.deepcopy(remaining_energy_before)
-        temporary_remaining_energy[i] -= neighbor_i[action]['transmission_energy']
-        if action != self.n_sensors:
-            temporary_remaining_energy[action] -= neighbor_i[action]['reception_energy']
-        dispersion_remaining_energy = np.std(temporary_remaining_energy)
-
-        return dispersion_remaining_energy
-
-    def compute_reward_dispersion_remaining_energy(self, i, action, neighbor_i, remaining_energy_before):
+    def compute_reward_dispersion_remaining_energy(self):
         '''
         Compute the reward based on the standard deviation of the remaining energy
         '''
-        if len(neighbor_i) == 1:
-            return 1
-        else:
-            dispersion_remaining_energy = self.compute_dispersion_remaining_energy(i, action, neighbor_i, remaining_energy_before)
-            # Normalize the standard deviation of the remaining energy
-            total_dispersion_remaining_energy = np.sum([self.compute_dispersion_remaining_energy(i, x, neighbor_i, remaining_energy_before) for x in neighbor_i])
-            normalized_dispersion_remaining_energy = dispersion_remaining_energy / total_dispersion_remaining_energy
+        dispersion_remaining_energy = np.std(self.remaining_energy)
+        # Normalize the standard deviation of the remaining energy
+        max_dispersion_remaining_energy = initial_energy / 2 # maximum standard deviation of the remaining energy if n_sensors is even
+        normalized_dispersion_remaining_energy = dispersion_remaining_energy / max_dispersion_remaining_energy
 
-            return 1 - normalized_dispersion_remaining_energy
+        return np.clip(1 - normalized_dispersion_remaining_energy, 0, 1)
     
-    def compute_reward_number_of_packets(self, i, action, neighbors_i):
+    def compute_reward_number_of_packets(self, action):
         '''
-        Compute the reward based on the number of packets of each sensor in the neighborhood
+        Compute the reward based on the number of packets of the receiver
         '''
-        if len(neighbors_i) == 1 or action == self.n_sensors:
-            return 1
-        elif self.n_sensors in neighbors_i.keys():
-            return 0
-        else:
-            total_number_of_packets = np.sum([self.number_of_packets[x] for x in neighbors_i])
-            normalized_number_of_packets = self.number_of_packets[action] / total_number_of_packets
+        max_number_of_packets = self.n_sensors * initial_number_of_packets
+        if action == self.n_sensors:
+            normalized_number_of_packets = 0
+        else: 
+            normalized_number_of_packets = self.number_of_packets[action] / max_number_of_packets
 
-            return 1 - normalized_number_of_packets
+        return 1 - normalized_number_of_packets
 
-    def compute_individual_rewards(self, i, action, neighbors_i, remaining_energy_before):
+    def compute_individual_rewards(self, i, action):
         '''
         Compute the individual rewards
         '''
-        reward_angle = self.compute_reward_angle(i, action, neighbors_i)
-        reward_distance = self.compute_reward_distance(action, neighbors_i)
-        reward_consumption_energy = self.compute_reward_consumption_energy(action, neighbors_i)
-        reward_dispersion_remaining_energy = self.compute_reward_dispersion_remaining_energy(i, action, neighbors_i, remaining_energy_before)
-        reward_number_of_packets = self.compute_reward_number_of_packets(i, action, neighbors_i)
+        reward_angle = self.compute_reward_angle(i, action)
+        reward_distance = self.compute_reward_distance(i, action)
+        reward_consumption_energy = self.compute_reward_consumption_energy(i, action)
+        reward_dispersion_remaining_energy = self.compute_reward_dispersion_remaining_energy()
+        reward_number_of_packets = self.compute_reward_number_of_packets(action)
 
         return [reward_angle, reward_distance, reward_consumption_energy, reward_dispersion_remaining_energy, reward_number_of_packets]
 
@@ -284,37 +264,4 @@ class WSNRoutingEnv(gym.Env):
         # Cancel the displacement if the sensor goes out of bounds
         for i in range(self.n_sensors):
             if not(np.all(self.sensor_positions[i] >= lower_bound) and np.all(self.sensor_positions[i] <= upper_bound)):
-                self.sensor_positions[i] -= displacement[i]
-
-    def eligible_receivers(self, i):
-        '''
-        Get the list of eligible receivers for the current sensor
-        '''
-        eligible_receivers = {}
-        # eligibility for sensors apart the base station
-        for j in range(self.n_sensors):
-            if i != j:
-                distance = np.linalg.norm(self.sensor_positions[i] - self.sensor_positions[j])
-                transmission_energy = self.transmission_energy(i, distance)
-                reception_energy = self.reception_energy(j)
-                condition_i = (self.remaining_energy[i] >= transmission_energy) and (distance <= self.coverage_radius)
-                condition_j = (self.remaining_energy[j] >= reception_energy) and (distance <= self.coverage_radius)
-                if condition_i and condition_j:
-                    eligible_receivers[j] = {
-                        'distance': distance,
-                        'transmission_energy': transmission_energy,
-                        'reception_energy': reception_energy
-                    }
-        
-        # eligibility for the base station
-        distance = np.linalg.norm(self.sensor_positions[i] - base_station_position)
-        transmission_energy = self.transmission_energy(i, distance)
-        condition_i = (self.remaining_energy[i] >= transmission_energy) and (distance <= self.coverage_radius)
-        if condition_i:
-            eligible_receivers[self.n_sensors] = {
-                'distance': distance,
-                'transmission_energy': transmission_energy,
-                'reception_energy': 0
-            }
-
-        return eligible_receivers
+                self.sensor_positions[i] -= displacement[i]

{gym_examples-2.0.29.dist-info → gym_examples-2.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-examples
-Version: 2.0.29
+Version: 2.0.31
 Summary: A custom environment for multi-agent reinforcement learning focused on WSN routing.
 Home-page: https://github.com/gedji/CODES.git
 Author: Georges Djimefo

gym_examples-2.0.31.dist-info/RECORD

@@ -0,0 +1,7 @@
+gym_examples/__init__.py,sha256=-Zi6pjtuGP4mWLhMJ5XoRMBap3wEBnvbILvg_aozuTw,193
+gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
+gym_examples/envs/wsn_env.py,sha256=M2bo_-wLWkXTJajQc7OgkT7vsXlCyGBTkfXA3ipFSc0,13265
+gym_examples-2.0.31.dist-info/METADATA,sha256=XZzdSuDCJ2CXoAF6osyaCT0nKN9xRQoL5GksbJvxnq4,411
+gym_examples-2.0.31.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+gym_examples-2.0.31.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
+gym_examples-2.0.31.dist-info/RECORD,,

gym_examples-2.0.29.dist-info/RECORD

@@ -1,7 +0,0 @@
-gym_examples/__init__.py,sha256=JrKY4JGnl71Q355qUxX0MfuMRVQmVenwidMKN4QdVEY,193
-gym_examples/envs/__init__.py,sha256=lgMe4pyOuUTgTBUddM0iwMlETsYTwFShny6ifm8PGM8,53
-gym_examples/envs/wsn_env.py,sha256=sCdEj9QwacOrNQjGw5Hq-CLdWLmCYSGCf-iW_byEWY4,15928
-gym_examples-2.0.29.dist-info/METADATA,sha256=iZt19QQ1a4-_hFcVN3KkzCDPk1i55lbM47K_zCVJcj0,411
-gym_examples-2.0.29.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-gym_examples-2.0.29.dist-info/top_level.txt,sha256=rJRksoAF32M6lTLBEwYzRdo4PgtejceaNnnZ3HeY_Rk,13
-gym_examples-2.0.29.dist-info/RECORD,,