Replace lunar lander with a working example.

Author: CodeReclaimers

examples/openai-lander/clean.sh renamed to examples/lunar-lander/clean.sh

@@ -1,4 +1,3 @@
 #!/usr/bin/env bash
 rm *.csv *.gv *.svg
-rm winner*
 rm neat-checkpoint-*

examples/openai-lander/config renamed to examples/lunar-lander/config-feedforward

@@ -1,14 +1,16 @@
 [NEAT]
-pop_size              = 150
-# Note: the fitness threshold will never be reached because
-# we are controlling the termination ourselves based on simulation performance.
 fitness_criterion     = max
-fitness_threshold     = 1000.0
+# Terminate when we reliably solve the task (LunarLander is considered solved
+# around an average reward of 200).
+fitness_threshold     = 200.0
+pop_size              = 150
 reset_on_extinction   = 0
 
 no_fitness_termination         = False
 
-[LanderGenome]
+[DefaultGenome]
+# LunarLander observations: x, y, x_dot, y_dot, angle, angular velocity,
+# left leg contact, right leg contact.
 num_inputs              = 8
 num_hidden              = 0
 num_outputs             = 4
@@ -73,4 +75,3 @@ elitism            = 2
 survival_threshold = 0.2
 
 min_species_size               = 2
-

examples/lunar-lander/evolve-feedforward.py

@@ -0,0 +1,150 @@
+"""\
+Feed-forward LunarLander-v3 control example.
+
+This example is structured similarly to examples/xor/evolve-feedforward.py and
+produces the same kinds of visual artifacts:
+
+* Fitness curve over generations
+* Species size stack plot
+* Network diagrams (full and pruned) of the winning genome
+"""
+
+import multiprocessing
+import os
+import pickle
+
+import gymnasium as gym
+import neat
+import visualize
+
+# Evaluation parameters.
+runs_per_net = 5
+max_steps = 1000
+
+
+def eval_genome(genome, config):
+    """Evaluate a single genome on the LunarLander-v3 environment."""
+    net = neat.nn.FeedForwardNetwork.create(genome, config)
+    fitnesses = []
+
+    for _ in range(runs_per_net):
+        # Create a fresh environment for each run (no rendering during training).
+        env = gym.make("LunarLander-v3")
+        observation, info = env.reset()
+
+        total_reward = 0.0
+        for _ in range(max_steps):
+            # Network outputs four action values; take the argmax as the discrete action.
+            action_values = net.activate(observation)
+            action = max(range(len(action_values)), key=lambda i: action_values[i])
+
+            observation, reward, terminated, truncated, info = env.step(action)
+            total_reward += reward
+
+            if terminated or truncated:
+                break
+
+        env.close()
+        fitnesses.append(total_reward)
+
+    # Use the average reward over runs as the fitness.
+    return sum(fitnesses) / len(fitnesses)
+
+
+def eval_genomes(genomes, config):
+    for genome_id, genome in genomes:
+        genome.fitness = eval_genome(genome, config)
+
+
+def run(config_file):
+    # Load configuration.
+    config = neat.Config(
+        neat.DefaultGenome,
+        neat.DefaultReproduction,
+        neat.DefaultSpeciesSet,
+        neat.DefaultStagnation,
+        config_file,
+    )
+
+    # Create the population, which is the top-level object for a NEAT run.
+    p = neat.Population(config)
+
+    # Add a stdout reporter to show progress in the terminal.
+    p.add_reporter(neat.StdOutReporter(True))
+    stats = neat.StatisticsReporter()
+    p.add_reporter(stats)
+    # Periodic checkpoints, similar to other examples.
+    p.add_reporter(neat.Checkpointer(10))
+
+    # Use parallel evaluation across available CPU cores.
+    pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome)
+
+    # Run until solution or fitness threshold is reached (see config).
+    winner = p.run(pe.evaluate, 500)
+
+    # Display the winning genome.
+    print(f"\nBest genome:\n{winner!s}")
+
+    # Save the winner for later reuse in test-feedforward.py.
+    with open("winner-feedforward.pickle", "wb") as f:
+        pickle.dump(winner, f)
+
+    # Visualization artifacts analogous to examples/xor/evolve-feedforward.py.
+    # Fitness & species plots.
+    visualize.plot_stats(
+        stats,
+        ylog=False,
+        view=True,
+        filename="feedforward-fitness.svg",
+    )
+    visualize.plot_species(
+        stats,
+        view=True,
+        filename="feedforward-speciation.svg",
+    )
+
+    # Node labels for easier interpretation of the evolved controller.
+    node_names = {
+        # Observations
+        -1: "x",
+        -2: "y",
+        -3: "x_dot",
+        -4: "y_dot",
+        -5: "angle",
+        -6: "ang_vel",
+        -7: "left_leg",
+        -8: "right_leg",
+        # Discrete actions
+        0: "do_nothing",
+        1: "fire_left",
+        2: "fire_main",
+        3: "fire_right",
+    }
+
+    # Full and pruned network diagrams for the winning genome.
+    visualize.draw_net(
+        config,
+        winner,
+        view=True,
+        node_names=node_names,
+        filename="winner-feedforward.gv",
+    )
+    visualize.draw_net(
+        config,
+        winner,
+        view=True,
+        node_names=node_names,
+        filename="winner-feedforward-pruned.gv",
+        prune_unused=True,
+    )
+
+    return winner, stats
+
+
+if __name__ == "__main__":
+    # Determine path to configuration file. This path manipulation is
+    # here so that the script will run successfully regardless of the
+    # current working directory.
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, "config-feedforward")
+    run(config_path)

examples/lunar-lander/test-feedforward.py

@@ -0,0 +1,91 @@
+"""\
+Test and visualize the performance of the best genome produced by
+examples/lunar-lander/evolve-feedforward.py on the LunarLander-v3 environment.
+"""
+
+import os
+import pickle
+import sys
+
+import gymnasium as gym
+import neat
+
+
+def run_episodes(net, episodes=3, render=True):
+    """Run a few episodes using the provided network and optionally render."""
+    if render:
+        env = gym.make("LunarLander-v3", render_mode="human")
+    else:
+        env = gym.make("LunarLander-v3")
+
+    try:
+        rewards = []
+        for episode in range(episodes):
+            observation, info = env.reset()
+            total_reward = 0.0
+            step = 0
+
+            while True:
+                step += 1
+                action_values = net.activate(observation)
+                action = max(range(len(action_values)), key=lambda i: action_values[i])
+
+                observation, reward, terminated, truncated, info = env.step(action)
+                total_reward += reward
+
+                if terminated or truncated:
+                    break
+
+            rewards.append(total_reward)
+            print(
+                f"Episode {episode + 1}: steps={step}, total_reward={total_reward:.2f}",
+            )
+    finally:
+        env.close()
+
+    if rewards:
+        avg = sum(rewards) / len(rewards)
+        print(f"\nAverage reward over {len(rewards)} episodes: {avg:.2f}")
+
+
+def load_and_test(genome_path, config_path, episodes=3, render=True):
+    """Load a saved genome and test it on LunarLander-v3."""
+    # Load the config.
+    config = neat.Config(
+        neat.DefaultGenome,
+        neat.DefaultReproduction,
+        neat.DefaultSpeciesSet,
+        neat.DefaultStagnation,
+        config_path,
+    )
+
+    # Load the genome.
+    with open(genome_path, "rb") as f:
+        genome = pickle.load(f)
+
+    print("Loaded genome:")
+    print(genome)
+
+    # Create the network and run episodes.
+    net = neat.nn.FeedForwardNetwork.create(genome, config)
+    run_episodes(net, episodes=episodes, render=render)
+
+
+if __name__ == "__main__":
+    # Determine local paths.
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, "config-feedforward")
+
+    # Optional argument: custom path to winner genome.
+    if len(sys.argv) > 1:
+        genome_path = sys.argv[1]
+    else:
+        genome_path = os.path.join(local_dir, "winner-feedforward.pickle")
+
+    if not os.path.exists(genome_path):
+        print(f"Error: Genome file not found at {genome_path}")
+        print("Please train a network first by running evolve-feedforward.py")
+        sys.exit(1)
+
+    print(f"Testing genome from: {genome_path}\n")
+    load_and_test(genome_path, config_path, episodes=3, render=True)