feat: improve fitness

Author: marcpinet

ai/car_ai.py

@@ -2,9 +2,10 @@
 
 
 import neat
+import pygame
 from render.car import Car, Action
 from render.neural_network.nn import NN
-import pygame
+from render.track import Track
 
 
 # ------------------ CLASSES ------------------
@@ -14,7 +15,7 @@ class CarAI:
     TOTAL_GENERATIONS = 0
     TIME_LIMIT = 15
 
-    def __init__(self, genomes: neat.DefaultGenome, config: neat.Config, start_position: list):
+    def __init__(self, genomes: neat.DefaultGenome, config: neat.Config, start_position: list, track: Track):
         CarAI.TOTAL_GENERATIONS += 1
 
         self.genomes = genomes
@@ -31,7 +32,7 @@ def __init__(self, genomes: neat.DefaultGenome, config: neat.Config, start_posit
             net = neat.nn.FeedForwardNetwork.create(genome, config)
             self.nets.append(net)
             genome.fitness = 0
-            self.cars.append(Car(start_position))
+            self.cars.append(Car(start_position, track))
             self.nns.append(NN(config, genome, (60, 130)))
 
         self.remaining_cars = len(self.cars)

render/car.py

@@ -4,6 +4,7 @@
 import pygame
 import math
 from render.colors import Color
+from render.track import Track
 
 
 # ------------------ GLOBAL VARIABLES  ------------------
@@ -39,7 +40,7 @@ class Car:
     DRAW_SENSORS = True
     SENSORS_DRAW_DISTANCE = 1920
 
-    def __init__(self, start_position: list):
+    def __init__(self, start_position: list, track: Track):
         # The _sprite is the untouched sprite (not rotated) while the sprite is the one which will be moved around
         self._sprite = pygame.image.load(CAR_SPRITE_PATH).convert_alpha()
 
@@ -67,6 +68,15 @@ def __init__(self, start_position: list):
 
         self.driven_distance = 0
         self.speed_penalty = 0
+        track_width = track.width
+        track_height = track.height
+        self.track_diagonal = math.sqrt(track_width**2 + track_height**2)
+        
+        self.DISTANCE_NORMALIZER = self.track_diagonal / 2
+        self.MAX_EXPECTED_SPEED = self.track_diagonal / 100
+        self.minimum_speed = self.CAR_SIZE_X / 6
+        self.angle_increment = math.degrees(math.atan2(self.CAR_SIZE_Y, self.speed * 10))
+        self.penalty_factor = self.track_diagonal / 1000
 
     def draw(self, track: pygame.Surface) -> None:
         """Draw the car on the track (and its sensors if enabled)
@@ -177,6 +187,13 @@ def check_sensor(self, degree: int, track: pygame.Surface) -> None:
         distance = int(math.hypot(x - self.center[0], y - self.center[1]))
         self.sensors.append([(x, y), distance])
 
+    def update_adaptive_parameters(self) -> None:
+        """Update the adaptive parameters of the car such as the angle increment, the minimum speed, etc."""
+        self.angle_increment = math.degrees(math.atan2(self.CAR_SIZE_Y, self.speed * 10))
+        
+        min_sensor_distance = min(sensor[1] for sensor in self.sensors) if self.sensors else self.CAR_SIZE_X
+        self.minimum_speed = max(self.CAR_SIZE_X / 6, min_sensor_distance / 20)
+
     def update_center(self) -> None:
         """Update the center of the car after a rotation (when it turns left or right)"""
         sprite_as_rect = self._sprite.get_rect()
@@ -205,7 +222,7 @@ def update_sprite(self, track: pygame.Surface) -> None:
         self.position[1] += sin * self.speed
 
         # Update the driven distance with the speed
-        self.driven_distance += self.speed
+        self.update_adaptive_parameters()
 
         # Calculate Corners
         self.refresh_corners_positions()
@@ -242,17 +259,16 @@ def get_reward(self) -> float:
             float: The calculated reward
         """
 
-        # Reward for distance driven
-        distance_reward = self.driven_distance / 10000
-
-        MAX_EXPECTED_SPEED = 5000
-        speed_reward = (self.speed / MAX_EXPECTED_SPEED) ** 0.5  # Square root to apply diminishing returns
-
-        malus = self.speed_penalty / 100
-
-        # Calculate the final reward
-        final_reward = distance_reward + speed_reward - malus
-
+        distance_reward = self.driven_distance / self.DISTANCE_NORMALIZER
+        
+        speed_reward = (self.speed / self.MAX_EXPECTED_SPEED) ** 0.5
+        
+        malus = self.speed_penalty / self.penalty_factor
+        
+        progress_factor = min(1.0, self.driven_distance / (self.track_diagonal * 0.75))
+        
+        final_reward = (distance_reward + speed_reward - malus) * (1 + progress_factor)
+        
         return final_reward
 
 
@@ -266,7 +282,7 @@ def brake(self) -> None:
             self.speed -= Car.SPEED_INCREMENT
         else:  
             self.speed = Car.MINIMUM_SPEED
-            self.speed_penalty += 1  # speed_penalty for going too slow
+            self.speed_penalty += 1
 
     def turn_left(self) -> None:
         """Turn the car to the left"""

render/engine.py

@@ -9,49 +9,12 @@
 from ai.car_ai import CarAI
 from render.car import Car
 from render.colors import Color
-
+from render.track import Track
 
 
 # ------------------ CLASSES ------------------
 
 
-class Track:
-    
-    BRUSH_LIMIT_SIZE = 25
-    
-    def __init__(self, width: int, height: int):
-        self.surface = pygame.Surface((width, height))
-        self.surface.fill(Color.WHITE)
-        self.brush_size = 50
-        self.last_position = None
-
-    def draw(self, position: Tuple[int, int], color: Tuple[int, int, int]):
-        if self.last_position:
-            self.draw_interpolated(self.last_position, position, color)
-        else:
-            pygame.draw.circle(self.surface, color, position, self.brush_size)
-        self.last_position = position
-        
-    def adjust_brush_size(self, amount: int):
-        self.brush_size = max(Track.BRUSH_LIMIT_SIZE, self.brush_size + amount)
-
-    def draw_interpolated(self, start: Tuple[int, int], end: Tuple[int, int], color: Tuple[int, int, int]):
-        dx = end[0] - start[0]
-        dy = end[1] - start[1]
-        distance = max(abs(dx), abs(dy))
-        
-        for i in range(distance):
-            x = int(start[0] + float(i) / distance * dx)
-            y = int(start[1] + float(i) / distance * dy)
-            pygame.draw.circle(self.surface, color, (x, y), self.brush_size)
-
-    def reset_last_position(self):
-        self.last_position = None
-
-    def get_surface(self) -> pygame.Surface:
-        return self.surface
-
-
 class Engine:
     WIDTH = 1900
     HEIGHT = 950
@@ -70,7 +33,7 @@ def __init__(self, neat_config_path: str, debug: bool, max_simulations: int):
         self.clock = pygame.time.Clock()
 
         self.track = Track(self.WIDTH, self.HEIGHT)
-        self.car = Car([0, 0])
+        self.car = Car([0, 0], self.track)
         self.decided_car_pos = None
 
         self.state = "drawing_track"
@@ -148,7 +111,7 @@ def start_ai(self):
         population.run(self.run_simulation, self.max_simulations)
 
     def run_simulation(self, genomes: List[neat.DefaultGenome], config: neat.Config) -> None:
-        car_ai = CarAI(genomes, config, self.decided_car_pos)
+        car_ai = CarAI(genomes, config, self.decided_car_pos, self.track)
         timer = time.time()
 
         while True:

render/track.py

@@ -0,0 +1,42 @@
+import pygame
+from typing import Tuple
+from render.colors import Color
+
+
+class Track:
+    
+    BRUSH_LIMIT_SIZE = 25
+    
+    def __init__(self, width: int, height: int):
+        self.width = width
+        self.height = height
+        self.surface = pygame.Surface((width, height))
+        self.surface.fill(Color.WHITE)
+        self.brush_size = 50
+        self.last_position = None
+
+    def draw(self, position: Tuple[int, int], color: Tuple[int, int, int]):
+        if self.last_position:
+            self.draw_interpolated(self.last_position, position, color)
+        else:
+            pygame.draw.circle(self.surface, color, position, self.brush_size)
+        self.last_position = position
+        
+    def adjust_brush_size(self, amount: int):
+        self.brush_size = max(Track.BRUSH_LIMIT_SIZE, self.brush_size + amount)
+
+    def draw_interpolated(self, start: Tuple[int, int], end: Tuple[int, int], color: Tuple[int, int, int]):
+        dx = end[0] - start[0]
+        dy = end[1] - start[1]
+        distance = max(abs(dx), abs(dy))
+        
+        for i in range(distance):
+            x = int(start[0] + float(i) / distance * dx)
+            y = int(start[1] + float(i) / distance * dy)
+            pygame.draw.circle(self.surface, color, (x, y), self.brush_size)
+
+    def reset_last_position(self):
+        self.last_position = None
+
+    def get_surface(self) -> pygame.Surface:
+        return self.surface