Neuroevolution/run_train_ycommand.py at main · htil/Neuroevolution · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
from Model import Individual, ModelTrainer
from utils import load_csv, save_to_csv
import random
import os
from run_all import (GENERATIONS, POPULATION_SIZE, BEST_INDIVIDUALS_SIZE,
                     CROSSOVER_RATE, MUTATION_RATE, MUTATION_STRENGTH,
                     TRAINING_EPOCHS, TRAINING_LEARNING_RATE, TRAINING_VERBOSE,
                     SAVE_MODELS, SAVE_CSV_RESULTS)

BASE_DIRECTORY = 'train_ycommand'
RUN_TYPE = 'y_command'

# Import shared configuration from run_all.py
generations = GENERATIONS
population_size = POPULATION_SIZE
best_individuals_size = BEST_INDIVIDUALS_SIZE
crossover_rate = CROSSOVER_RATE
mutation_rate = MUTATION_RATE
mutation_strength = MUTATION_STRENGTH

# Training configuration
training_epochs = TRAINING_EPOCHS
training_learning_rate = TRAINING_LEARNING_RATE
training_verbose = TRAINING_VERBOSE

# Load data (CSV conversion is handled by run_all.py)
X = load_csv('data/csv_output/matrix.csv')
y_command = load_csv('data/csv_output/command.csv')
y_continuous = load_csv('data/csv_output/continuous_command.csv')

# Select target based on RUN_TYPE
target_map = {
    'y_command': y_command,
    'y_continuous': y_continuous
}
y_target = target_map[RUN_TYPE]


# ---------------------------------------------------------------------------------------------------------------------------------
# Genetic Algorithm Implementation ------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------

# Loop through generations
individuals = []

for generation in range(generations):

    if generation == 0:
        # INITIAL POPULATION: Create random individuals
        # print("Creating initial random population...")
        individuals = []
        for i in range(population_size):
            individual_id = f"{generation}_{i}"
            individual = Individual(input_features=4096, h1=512, h2=256, h3=128, output_features=3, individual_id=individual_id, verbose=False)
            individual.generation = generation

            # Train the individual before evaluating fitness
            trainer = ModelTrainer(individual.model, learning_rate=training_learning_rate, verbose=training_verbose)
            trainer.train(X, y_target, epochs=training_epochs)

            # Evaluate fitness after training
            fitness = individual.evaluate_fitness(X, y_target)
            individuals.append(individual)
            if SAVE_MODELS:
                individual.save(f'{BASE_DIRECTORY}/models/{RUN_TYPE}/model_{individual.individual_id}')
    else:
        # SUBSEQUENT GENERATIONS: Evolve from previous generation
        # print("Evolving population...")

        # 1. Sort by fitness (best first) - using Individual's __lt__ method
        individuals.sort()  # Best individuals first (highest fitness)

        # 2. SELECT: Keep top performers (elites)
        elites = individuals[:best_individuals_size]
        # print(f"  Keeping top {best_individuals_size} elites:")
        # for i, elite in enumerate(elites):
        #     print(f"    Elite {i+1}: {elite}")

        # 3. CROSSOVER: Create offspring from elites
        offspring = []
        offspring_count = population_size - best_individuals_size
        # print(f"  Creating {offspring_count} offspring via crossover...")

        for i in range(offspring_count):
            # Select two parents randomly from elites (can be same parent twice)
            parent1 = random.choice(elites)
            parent2 = random.choice(elites)

            # Create offspring via crossover
            child = parent1.crossover(parent2, crossover_rate=crossover_rate)
            child.individual_id = f"{generation}_{i}"
            child.generation = generation

            # Apply mutation to introduce diversity
            child.mutate(mutation_rate=mutation_rate, mutation_strength=mutation_strength)

            offspring.append(child)
            # print(f"    Offspring {i+1}: Parents {parent1.individual_id} × {parent2.individual_id} (mutated)")

        # 4. REPLACE: Form next generation (elites + offspring)
        individuals = elites + offspring
        # print(f"  Next generation: {len(elites)} elites + {len(offspring)} offspring = {len(individuals)} individuals")

    # Train and evaluate fitness for all individuals (offspring need training and evaluation)
    # print("Training and evaluating fitness...")
    fitnesses = []
    for i, individual in enumerate(individuals):
        if individual.fitness is None:  # Only train and evaluate if not already evaluated
            # Train the individual before evaluating fitness
            trainer = ModelTrainer(individual.model, learning_rate=training_learning_rate, verbose=training_verbose)
            trainer.train(X, y_target, epochs=training_epochs)
            fitness = individual.evaluate_fitness(X, y_target)
        else:
            fitness = individual.fitness
        fitnesses.append(fitness)
        if SAVE_MODELS:
            individual.save(f'{BASE_DIRECTORY}/models/{RUN_TYPE}/model_{individual.individual_id}')

    # Save results (optional)
    if SAVE_CSV_RESULTS:
        save_to_csv(fitnesses, f'{BASE_DIRECTORY}/results/{RUN_TYPE}/fitnesses_generation_{generation}.csv')
        save_to_csv(individuals, f'{BASE_DIRECTORY}/results/{RUN_TYPE}/individuals_generation_{generation}.csv')

    # Display generation statistics
    best_fitness = max(fitnesses)
    worst_fitness = min(fitnesses)
    avg_fitness = sum(fitnesses)/len(fitnesses)

    print(f"\nGeneration {generation} Statistics:")
    print(f"  Best fitness: {best_fitness:.6f}")
    print(f"  Worst fitness: {worst_fitness:.6f}")
    print(f"  Average fitness: {avg_fitness:.6f}")

# Find the best individual from the final generation
individuals.sort()  # Sort by fitness (best first)
best_individual = individuals[0]

# Create best_model directory path
best_model_path = f'{BASE_DIRECTORY}/best_model/best_model_{RUN_TYPE}'

# Save the best model
best_individual.save(best_model_path)
print(f"\n✓ Best model saved to: {best_model_path}.pth")
print(f"  Best fitness: {best_individual.fitness:.6f}")
print(f"  Individual ID: {best_individual.individual_id}")
print(f"  Generation: {best_individual.generation}")

# ---------------------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------------------------------------------