Upload 9 files

config.json

@@ -0,0 +1,17 @@
+{
+    "output_base_dir": "./my_neuroevolution_results",
+    "seq_length": 10,
+    "train_samples": 5000,
+    "test_samples": 1000,
+    "pop_size": 80,
+    "generations": 100,
+    "mutation_rate": 0.5,
+    "weight_mut_rate": 0.8,
+    "activation_mut_rate": 0.2,
+    "mutation_strength": 0.1,
+    "tournament_size": 5,
+    "elitism_count": 2,
+    "batch_size": 64,
+    "epochs_final_train": 100,
+    "seed": 123
+}

evolution.log

@@ -0,0 +1,150 @@
+2025-03-29 16:23:07,752 - INFO - Starting EvoNet Pipeline Run: 20250329_162307
+2025-03-29 16:23:07,752 - INFO - Output directory: ./my_neuroevolution_results\evorun_20250329_162307
+2025-03-29 16:23:07,752 - INFO - Configuration:
+2025-03-29 16:23:07,752 - INFO -   output_base_dir: ./my_neuroevolution_results
+2025-03-29 16:23:07,752 - INFO -   seq_length: 10
+2025-03-29 16:23:07,752 - INFO -   train_samples: 5000
+2025-03-29 16:23:07,752 - INFO -   test_samples: 1000
+2025-03-29 16:23:07,753 - INFO -   pop_size: 80
+2025-03-29 16:23:07,753 - INFO -   generations: 100
+2025-03-29 16:23:07,753 - INFO -   mutation_rate: 0.5
+2025-03-29 16:23:07,753 - INFO -   weight_mut_rate: 0.8
+2025-03-29 16:23:07,753 - INFO -   activation_mut_rate: 0.2
+2025-03-29 16:23:07,753 - INFO -   mutation_strength: 0.1
+2025-03-29 16:23:07,753 - INFO -   tournament_size: 5
+2025-03-29 16:23:07,753 - INFO -   elitism_count: 2
+2025-03-29 16:23:07,753 - INFO -   batch_size: 64
+2025-03-29 16:23:07,753 - INFO -   epochs_final_train: 100
+2025-03-29 16:23:07,753 - INFO -   seed: 123
+2025-03-29 16:23:07,754 - INFO - Configuration saved to ./my_neuroevolution_results\evorun_20250329_162307\config.json
+2025-03-29 16:23:07,755 - INFO - Using random seed: 123
+2025-03-29 16:23:07,766 - WARNING - GPU not found. Using CPU.
+2025-03-29 16:23:07,766 - INFO - Generating 5000 samples with sequence length 10...
+2025-03-29 16:23:07,768 - INFO - Data generation complete.
+2025-03-29 16:23:07,768 - INFO - Generating 1000 samples with sequence length 10...
+2025-03-29 16:23:07,768 - INFO - Data generation complete.
+2025-03-29 16:23:07,769 - INFO - Initializing population of 80 individuals...
+2025-03-29 16:23:09,618 - INFO - Population initialized.
+2025-03-29 16:23:09,619 - INFO - Starting evolution for 100 generations...
+2025-03-29 16:23:09,815 - WARNING - 5 out of the last 5 calls to <function get_predictions at 0x0000029FA1CB5090> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
+2025-03-29 16:23:09,837 - WARNING - 6 out of the last 6 calls to <function get_predictions at 0x0000029FA1CB5090> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
+2025-03-29 16:23:11,240 - INFO - Generation 1: New overall best fitness: 0.0005
+2025-03-29 16:23:11,241 - INFO - Generation 1/100 - Best Fitness: 0.0005, Avg Fitness: 0.0003
+2025-03-29 16:23:15,416 - INFO - Generation 2: New overall best fitness: 0.0005
+2025-03-29 16:23:15,416 - INFO - Generation 2/100 - Best Fitness: 0.0005, Avg Fitness: 0.0003
+2025-03-29 16:23:19,031 - INFO - Generation 3: New overall best fitness: 0.0006
+2025-03-29 16:23:19,032 - INFO - Generation 3/100 - Best Fitness: 0.0006, Avg Fitness: 0.0003
+2025-03-29 16:23:22,543 - INFO - Generation 4: New overall best fitness: 0.0007
+2025-03-29 16:23:22,544 - INFO - Generation 4/100 - Best Fitness: 0.0007, Avg Fitness: 0.0004
+2025-03-29 16:23:26,214 - INFO - Generation 5: New overall best fitness: 0.0007
+2025-03-29 16:23:26,214 - INFO - Generation 5/100 - Best Fitness: 0.0007, Avg Fitness: 0.0005
+2025-03-29 16:23:31,401 - INFO - Generation 6: New overall best fitness: 0.0007
+2025-03-29 16:23:31,402 - INFO - Generation 6/100 - Best Fitness: 0.0007, Avg Fitness: 0.0005
+2025-03-29 16:23:36,194 - INFO - Generation 7/100 - Best Fitness: 0.0007, Avg Fitness: 0.0006
+2025-03-29 16:23:40,653 - INFO - Generation 8/100 - Best Fitness: 0.0007, Avg Fitness: 0.0006
+2025-03-29 16:23:45,833 - INFO - Generation 9: New overall best fitness: 0.0009
+2025-03-29 16:23:45,834 - INFO - Generation 9/100 - Best Fitness: 0.0009, Avg Fitness: 0.0006
+2025-03-29 16:23:51,287 - INFO - Generation 10/100 - Best Fitness: 0.0009, Avg Fitness: 0.0006
+2025-03-29 16:23:57,811 - INFO - Generation 11: New overall best fitness: 0.0010
+2025-03-29 16:23:57,812 - INFO - Generation 11/100 - Best Fitness: 0.0010, Avg Fitness: 0.0006
+2025-03-29 16:24:03,660 - INFO - Generation 12/100 - Best Fitness: 0.0010, Avg Fitness: 0.0007
+2025-03-29 16:24:08,561 - INFO - Generation 13/100 - Best Fitness: 0.0010, Avg Fitness: 0.0007
+2025-03-29 16:24:13,156 - INFO - Generation 14/100 - Best Fitness: 0.0010, Avg Fitness: 0.0007
+2025-03-29 16:24:18,199 - INFO - Generation 15/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:24:23,022 - INFO - Generation 16/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:24:27,709 - INFO - Generation 17/100 - Best Fitness: 0.0010, Avg Fitness: 0.0009
+2025-03-29 16:24:32,992 - INFO - Generation 18/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:24:38,218 - INFO - Generation 19/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:24:43,234 - INFO - Generation 20/100 - Best Fitness: 0.0010, Avg Fitness: 0.0007
+2025-03-29 16:24:48,349 - INFO - Generation 21/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:24:53,961 - INFO - Generation 22/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:24:59,377 - INFO - Generation 23/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:25:05,294 - INFO - Generation 24/100 - Best Fitness: 0.0010, Avg Fitness: 0.0008
+2025-03-29 16:25:11,954 - INFO - Generation 25: New overall best fitness: 0.0011
+2025-03-29 16:25:11,954 - INFO - Generation 25/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:18,394 - INFO - Generation 26/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:24,756 - INFO - Generation 27/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:30,985 - INFO - Generation 28/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:37,146 - INFO - Generation 29/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:42,858 - INFO - Generation 30/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:48,828 - INFO - Generation 31/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:25:54,665 - INFO - Generation 32/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:26:01,264 - INFO - Generation 33/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:26:07,385 - INFO - Generation 34/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:26:13,600 - INFO - Generation 35/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:26:20,388 - INFO - Generation 36/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:26:27,847 - INFO - Generation 37/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:26:34,794 - INFO - Generation 38/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:26:41,511 - INFO - Generation 39/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:26:48,222 - INFO - Generation 40/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:26:55,038 - INFO - Generation 41/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:03,038 - INFO - Generation 42/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:10,563 - INFO - Generation 43/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:18,195 - INFO - Generation 44/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:26,225 - INFO - Generation 45/100 - Best Fitness: 0.0011, Avg Fitness: 0.0007
+2025-03-29 16:27:33,738 - INFO - Generation 46/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:41,358 - INFO - Generation 47/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:48,662 - INFO - Generation 48/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:27:57,800 - INFO - Generation 49/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:28:05,729 - INFO - Generation 50/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:28:13,621 - INFO - Generation 51/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:28:22,441 - INFO - Generation 52/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:28:30,788 - INFO - Generation 53/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:28:39,245 - INFO - Generation 54/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:28:48,128 - INFO - Generation 55/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:28:56,611 - INFO - Generation 56/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:29:07,827 - INFO - Generation 57/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:29:17,239 - INFO - Generation 58/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:29:28,206 - INFO - Generation 59/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:29:37,831 - INFO - Generation 60/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:29:46,407 - INFO - Generation 61/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:29:55,415 - INFO - Generation 62/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:30:05,102 - INFO - Generation 63/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:30:14,019 - INFO - Generation 64/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:30:23,684 - INFO - Generation 65/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:30:33,262 - INFO - Generation 66/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:30:42,568 - INFO - Generation 67/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:30:53,168 - INFO - Generation 68/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:31:04,197 - INFO - Generation 69/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:31:17,892 - INFO - Generation 70/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:31:30,381 - INFO - Generation 71/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:31:42,523 - INFO - Generation 72/100 - Best Fitness: 0.0011, Avg Fitness: 0.0007
+2025-03-29 16:31:54,222 - INFO - Generation 73/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:32:05,454 - INFO - Generation 74/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:32:16,454 - INFO - Generation 75/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:32:28,258 - INFO - Generation 76/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:32:39,477 - INFO - Generation 77/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:32:50,192 - INFO - Generation 78/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:33:01,331 - INFO - Generation 79/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:33:13,647 - INFO - Generation 80/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:33:27,063 - INFO - Generation 81/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:33:40,751 - INFO - Generation 82/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:33:53,452 - INFO - Generation 83/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:34:08,825 - INFO - Generation 84/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:34:20,926 - INFO - Generation 85/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:34:32,460 - INFO - Generation 86/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:34:44,641 - INFO - Generation 87/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:34:56,168 - INFO - Generation 88/100 - Best Fitness: 0.0011, Avg Fitness: 0.0007
+2025-03-29 16:35:08,763 - INFO - Generation 89/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:35:20,565 - INFO - Generation 90/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:35:33,487 - INFO - Generation 91/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:35:49,718 - INFO - Generation 92/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:36:05,621 - INFO - Generation 93/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:36:19,000 - INFO - Generation 94/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:36:31,437 - INFO - Generation 95/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:36:44,000 - INFO - Generation 96/100 - Best Fitness: 0.0011, Avg Fitness: 0.0008
+2025-03-29 16:36:56,637 - INFO - Generation 97/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:37:10,609 - INFO - Generation 98/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:37:25,139 - INFO - Generation 99/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:37:43,057 - INFO - Generation 100/100 - Best Fitness: 0.0011, Avg Fitness: 0.0009
+2025-03-29 16:37:45,655 - INFO - Evolution complete.
+2025-03-29 16:37:45,659 - INFO - Fitness history data saved to ./my_neuroevolution_results\evorun_20250329_162307\fitness_history.csv
+2025-03-29 16:37:47,223 - INFO - Fitness history plot saved to ./my_neuroevolution_results\evorun_20250329_162307\fitness_history.png
+2025-03-29 16:37:47,223 - INFO - Starting final training of the best evolved model...
+2025-03-29 16:37:59,419 - INFO - Final training complete.
+2025-03-29 16:37:59,419 - INFO - Evaluating final model on test data...
+2025-03-29 16:37:59,569 - INFO - Final Test MSE: 38.610789
+2025-03-29 16:37:59,585 - INFO - Average Kendall's Tau (on 100 samples): 0.9964
+2025-03-29 16:37:59,630 - INFO - Final trained model saved to ./my_neuroevolution_results\evorun_20250329_162307\best_evolved_model_trained.keras
+2025-03-29 16:37:59,635 - INFO - Final results saved to ./my_neuroevolution_results\evorun_20250329_162307\final_results.json
+2025-03-29 16:37:59,635 - INFO - Pipeline finished successfully!

evonet_optimizer.py

@@ -0,0 +1,500 @@
+import os
+import subprocess
+import sys
+import argparse
+import random
+import logging
+from datetime import datetime
+import json
+from typing import List, Tuple, Dict, Any
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential, load_model, clone_model
+from tensorflow.keras.layers import Dense, Input
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
+import matplotlib.pyplot as plt
+from scipy.stats import kendalltau
+
+# --- Constants ---
+DEFAULT_SEQ_LENGTH = 10
+DEFAULT_POP_SIZE = 50
+DEFAULT_GENERATIONS = 50
+DEFAULT_MUTATION_RATE = 0.4       # Probability of applying any mutation to an individual
+DEFAULT_WEIGHT_MUT_RATE = 0.8     # If mutation occurs, probability of weight perturbation
+DEFAULT_ACTIVATION_MUT_RATE = 0.2 # If mutation occurs, probability of activation change
+DEFAULT_MUTATION_STRENGTH = 0.1 # Magnitude of weight perturbation
+DEFAULT_TOURNAMENT_SIZE = 5
+DEFAULT_ELITISM_COUNT = 2         # Keep top N individuals directly
+DEFAULT_EPOCHS_FINAL_TRAIN = 100
+DEFAULT_BATCH_SIZE = 64
+
+# --- Logging Setup ---
+def setup_logging(log_dir: str, log_level=logging.INFO) -> None:
+    """Configures logging to file and console."""
+    log_filename = os.path.join(log_dir, 'evolution.log')
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_filename),
+            logging.StreamHandler(sys.stdout) # Also print to console
+        ]
+    )
+
+# --- GPU Check ---
+def check_gpu() -> bool:
+    """Checks for GPU availability and sets memory growth."""
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus:
+        try:
+            # Currently, memory growth needs to be the same across GPUs
+            for gpu in gpus:
+                tf.config.experimental.set_memory_growth(gpu, True)
+            logical_gpus = tf.config.list_logical_devices('GPU')
+            logging.info(f"{len(gpus)} Physical GPUs, {len(logical_gpus)} Logical GPUs found.")
+            logging.info(f"Using GPU: {gpus[0].name}")
+            return True
+        except RuntimeError as e:
+            # Memory growth must be set before GPUs have been initialized
+            logging.error(f"Error setting memory growth: {e}")
+            return False
+    else:
+        logging.warning("GPU not found. Using CPU.")
+        return False
+
+# --- Data Generation ---
+def generate_data(num_samples: int, seq_length: int) -> Tuple[np.ndarray, np.ndarray]:
+    """Generates random sequences and their sorted versions."""
+    logging.info(f"Generating {num_samples} samples with sequence length {seq_length}...")
+    X = np.random.rand(num_samples, seq_length) * 100
+    y = np.sort(X, axis=1)
+    logging.info("Data generation complete.")
+    return X, y
+
+# --- Neuroevolution Core ---
+def create_individual(seq_length: int) -> Sequential:
+    """Creates a Keras Sequential model with random architecture."""
+    model = Sequential(name=f"model_random_{random.randint(1000, 9999)}")
+    num_hidden_layers = random.randint(1, 4) # Reduced max layers for simplicity
+    neurons_per_layer = [random.randint(8, 64) for _ in range(num_hidden_layers)]
+    activations = [random.choice(['relu', 'tanh', 'sigmoid']) for _ in range(num_hidden_layers)]
+
+    # Input Layer
+    model.add(Input(shape=(seq_length,)))
+
+    # Hidden Layers
+    for i in range(num_hidden_layers):
+        model.add(Dense(neurons_per_layer[i], activation=activations[i]))
+
+    # Output Layer - must match sequence length for sorting
+    model.add(Dense(seq_length, activation='linear')) # Linear activation for regression output
+
+    # Compile the model immediately for weight manipulation capabilities
+    # Use a standard optimizer; learning rate might be adjusted during final training
+    model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+    return model
+
+@tf.function # Potentially speeds up prediction
+def get_predictions(model: Sequential, X: np.ndarray, batch_size: int) -> tf.Tensor:
+    """Gets model predictions using tf.function."""
+    return model(X, training=False) # Use __call__ inside tf.function
+
+def calculate_fitness(individual: Sequential, X: np.ndarray, y: np.ndarray, batch_size: int) -> float:
+    """Calculates fitness based on inverse MSE. Handles potential errors."""
+    try:
+        # Ensure data is float32 for TensorFlow
+        X_tf = tf.cast(X, tf.float32)
+        y_tf = tf.cast(y, tf.float32)
+
+        # Use the tf.function decorated prediction function
+        y_pred_tf = get_predictions(individual, X_tf, batch_size)
+
+        # Calculate MSE using TensorFlow operations for potential GPU acceleration
+        mse = tf.reduce_mean(tf.square(y_tf - y_pred_tf))
+        mse_val = mse.numpy() # Get the numpy value
+
+        # Fitness: Inverse MSE (add small epsilon to avoid division by zero)
+        fitness_score = 1.0 / (mse_val + 1e-8)
+
+        # Handle potential NaN or Inf values in fitness
+        if not np.isfinite(fitness_score):
+            logging.warning(f"Non-finite fitness detected ({fitness_score}) for model {individual.name}. Assigning low fitness.")
+            return 1e-8 # Assign a very low fitness
+
+        return float(fitness_score)
+
+    except Exception as e:
+        logging.error(f"Error during fitness calculation for model {individual.name}: {e}", exc_info=True)
+        return 1e-8 # Return minimal fitness on error
+
+
+def mutate_individual(individual: Sequential, weight_mut_rate: float, act_mut_rate: float, mut_strength: float) -> Sequential:
+    """Applies mutations (weight perturbation, activation change) to an individual."""
+    mutated_model = clone_model(individual)
+    mutated_model.set_weights(individual.get_weights()) # Crucial: Copy weights
+
+    mutated = False
+    # 1. Weight Mutation
+    if random.random() < weight_mut_rate:
+        mutated = True
+        for layer in mutated_model.layers:
+            if isinstance(layer, Dense):
+                weights_biases = layer.get_weights()
+                new_weights_biases = []
+                for wb in weights_biases:
+                    noise = np.random.normal(0, mut_strength, wb.shape)
+                    new_weights_biases.append(wb + noise)
+                if new_weights_biases: # Ensure layer had weights
+                    layer.set_weights(new_weights_biases)
+        # logging.debug(f"Applied weight mutation to {mutated_model.name}")
+
+    # 2. Activation Mutation (Applied independently)
+    if random.random() < act_mut_rate:
+         # Find Dense layers eligible for activation change (not the output layer)
+        dense_layers = [layer for layer in mutated_model.layers if isinstance(layer, Dense)]
+        if len(dense_layers) > 1: # Ensure there's at least one hidden layer
+            mutated = True
+            layer_to_mutate = random.choice(dense_layers[:-1]) # Exclude output layer
+            current_activation = layer_to_mutate.get_config().get('activation', 'linear')
+            possible_activations = ['relu', 'tanh', 'sigmoid']
+            if current_activation in possible_activations:
+                 possible_activations.remove(current_activation)
+            new_activation = random.choice(possible_activations)
+
+            # Rebuild the model config with the new activation
+            # This is safer than trying to modify layer activation in-place
+            config = mutated_model.get_config()
+            for layer_config in config['layers']:
+                 if layer_config['config']['name'] == layer_to_mutate.name:
+                      layer_config['config']['activation'] = new_activation
+                      # logging.debug(f"Changed activation of layer {layer_to_mutate.name} to {new_activation} in {mutated_model.name}")
+                      break # Found the layer
+
+            # Create a new model from the modified config
+            # Important: Need to re-compile after structural changes from config
+            try:
+                mutated_model_new_act = Sequential.from_config(config)
+                mutated_model_new_act.compile(optimizer=Adam(learning_rate=0.001), loss='mse') # Re-compile
+                mutated_model = mutated_model_new_act # Replace the old model
+            except Exception as e:
+                 logging.error(f"Error rebuilding model after activation mutation for {mutated_model.name}: {e}")
+                 # Revert mutation if rebuilding fails
+
+
+    # Re-compile the final mutated model to ensure optimizer state is fresh
+    if mutated:
+        mutated_model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+        mutated_model._name = f"mutated_{individual.name}" # Rename
+
+    return mutated_model
+
+
+def tournament_selection(population: List[Sequential], fitness_scores: List[float], k: int) -> Sequential:
+    """Selects the best individual from a randomly chosen tournament group."""
+    tournament_indices = random.sample(range(len(population)), k)
+    tournament_fitness = [fitness_scores[i] for i in tournament_indices]
+    winner_index_in_tournament = np.argmax(tournament_fitness)
+    winner_original_index = tournament_indices[winner_index_in_tournament]
+    return population[winner_original_index]
+
+def evolve_population(population: List[Sequential], X: np.ndarray, y: np.ndarray, generations: int,
+                      mutation_rate: float, weight_mut_rate: float, act_mut_rate: float, mut_strength: float,
+                      tournament_size: int, elitism_count: int, batch_size: int) -> Tuple[Sequential, List[float], List[float]]:
+    """Runs the evolutionary process."""
+    best_fitness_history = []
+    avg_fitness_history = []
+    best_model_overall = None
+    best_fitness_overall = -1.0
+
+    for gen in range(generations):
+        # 1. Evaluate Fitness
+        fitness_scores = [calculate_fitness(ind, X, y, batch_size) for ind in population]
+
+        # Track overall best
+        current_best_idx = np.argmax(fitness_scores)
+        current_best_fitness = fitness_scores[current_best_idx]
+        if current_best_fitness > best_fitness_overall:
+            best_fitness_overall = current_best_fitness
+            # Keep a copy of the best model structure and weights
+            best_model_overall = clone_model(population[current_best_idx])
+            best_model_overall.set_weights(population[current_best_idx].get_weights())
+            best_model_overall.compile(optimizer=Adam(), loss='mse') # Re-compile just in case
+            logging.info(f"Generation {gen+1}: New overall best fitness: {best_fitness_overall:.4f}")
+
+
+        avg_fitness = np.mean(fitness_scores)
+        best_fitness_history.append(current_best_fitness)
+        avg_fitness_history.append(avg_fitness)
+
+        logging.info(f"Generation {gen+1}/{generations} - Best Fitness: {current_best_fitness:.4f}, Avg Fitness: {avg_fitness:.4f}")
+
+        new_population = []
+
+        # 2. Elitism: Carry over the best individuals
+        if elitism_count > 0:
+            elite_indices = np.argsort(fitness_scores)[-elitism_count:]
+            for idx in elite_indices:
+                 # Clone elite models to avoid modifications affecting originals if selected again
+                 elite_clone = clone_model(population[idx])
+                 elite_clone.set_weights(population[idx].get_weights())
+                 elite_clone.compile(optimizer=Adam(), loss='mse') # Ensure compiled
+                 new_population.append(elite_clone)
+
+
+        # 3. Selection & Reproduction for the rest of the population
+        while len(new_population) < len(population):
+            # Select parent(s) using tournament selection
+            parent = tournament_selection(population, fitness_scores, tournament_size)
+
+            # Create child through mutation (crossover could be added here)
+            child = parent # Start with the parent
+            if random.random() < mutation_rate:
+                # Clone parent before mutation to avoid modifying the original selected parent
+                parent_clone = clone_model(parent)
+                parent_clone.set_weights(parent.get_weights())
+                parent_clone.compile(optimizer=Adam(), loss='mse') # Ensure compiled
+                child = mutate_individual(parent_clone, weight_mut_rate, act_mut_rate, mut_strength)
+            else:
+                 # If no mutation, still clone the parent to ensure new population has distinct objects
+                 child = clone_model(parent)
+                 child.set_weights(parent.get_weights())
+                 child.compile(optimizer=Adam(), loss='mse') # Ensure compiled
+
+
+            new_population.append(child)
+
+        population = new_population[:len(population)] # Ensure population size is maintained
+
+    if best_model_overall is None: # Handle case where no improvement was ever found
+         best_idx = np.argmax([calculate_fitness(ind, X, y, batch_size) for ind in population])
+         best_model_overall = population[best_idx]
+
+    return best_model_overall, best_fitness_history, avg_fitness_history
+
+
+# --- Plotting ---
+def plot_fitness_history(history_best: List[float], history_avg: List[float], output_dir: str) -> None:
+    """Plots and saves the fitness history."""
+    plt.figure(figsize=(12, 6))
+    plt.plot(history_best, label="Best Fitness per Generation", marker='o', linestyle='-')
+    plt.plot(history_avg, label="Average Fitness per Generation", marker='x', linestyle='--')
+    plt.xlabel("Generation")
+    plt.ylabel("Fitness Score (1 / MSE)")
+    plt.title("Evolutionary Process Fitness History")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plot_path = os.path.join(output_dir, "fitness_history.png")
+    plt.savefig(plot_path)
+    plt.close()
+    logging.info(f"Fitness history plot saved to {plot_path}")
+
+# --- Evaluation ---
+def evaluate_model(model: Sequential, X_test: np.ndarray, y_test: np.ndarray, batch_size: int) -> Dict[str, float]:
+    """Evaluates the final model on the test set."""
+    logging.info("Evaluating final model on test data...")
+    y_pred = model.predict(X_test, batch_size=batch_size, verbose=0)
+    test_mse = np.mean(np.square(y_test - y_pred))
+    logging.info(f"Final Test MSE: {test_mse:.6f}")
+
+    # Calculate Kendall's Tau for a sample (can be slow for large datasets)
+    sample_size = min(100, X_test.shape[0])
+    taus = []
+    indices = np.random.choice(X_test.shape[0], sample_size, replace=False)
+    for i in indices:
+        tau, _ = kendalltau(y_test[i], y_pred[i])
+        if not np.isnan(tau): # Handle potential NaN if predictions are constant
+            taus.append(tau)
+    avg_kendall_tau = np.mean(taus) if taus else 0.0
+    logging.info(f"Average Kendall's Tau (on {sample_size} samples): {avg_kendall_tau:.4f}")
+
+    return {
+        "test_mse": float(test_mse),
+        "avg_kendall_tau": float(avg_kendall_tau)
+    }
+
+# --- Main Pipeline ---
+def run_pipeline(args: argparse.Namespace):
+    """Executes the complete neuroevolution pipeline."""
+
+    # Create unique output directory for this run
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_dir = os.path.join(args.output_base_dir, f"evorun_{timestamp}")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Setup logging for this run
+    setup_logging(output_dir)
+    logging.info(f"Starting EvoNet Pipeline Run: {timestamp}")
+    logging.info(f"Output directory: {output_dir}")
+
+    # Log arguments/configuration
+    logging.info("Configuration:")
+    args_dict = vars(args)
+    for k, v in args_dict.items():
+        logging.info(f"  {k}: {v}")
+    # Save config to file
+    config_path = os.path.join(output_dir, "config.json")
+    with open(config_path, 'w') as f:
+        json.dump(args_dict, f, indent=4)
+    logging.info(f"Configuration saved to {config_path}")
+
+
+    # Set random seeds for reproducibility
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    tf.random.set_seed(args.seed)
+    logging.info(f"Using random seed: {args.seed}")
+
+    # Check GPU
+    check_gpu()
+
+    # Generate Data
+    X_train, y_train = generate_data(args.train_samples, args.seq_length)
+    X_test, y_test = generate_data(args.test_samples, args.seq_length)
+
+    # Initialize Population
+    logging.info(f"Initializing population of {args.pop_size} individuals...")
+    population = [create_individual(args.seq_length) for _ in range(args.pop_size)]
+    logging.info("Population initialized.")
+
+    # Run Evolution
+    logging.info(f"Starting evolution for {args.generations} generations...")
+    best_model_unevolved, best_fitness_hist, avg_fitness_hist = evolve_population(
+        population, X_train, y_train, args.generations,
+        args.mutation_rate, args.weight_mut_rate, args.activation_mut_rate, args.mutation_strength,
+        args.tournament_size, args.elitism_count, args.batch_size
+    )
+    logging.info("Evolution complete.")
+
+    # Save fitness history data
+    history_path = os.path.join(output_dir, "fitness_history.csv")
+    history_data = np.array([best_fitness_hist, avg_fitness_hist]).T
+    np.savetxt(history_path, history_data, delimiter=',', header='BestFitness,AvgFitness', comments='')
+    logging.info(f"Fitness history data saved to {history_path}")
+
+    # Plot fitness history
+    plot_fitness_history(best_fitness_hist, avg_fitness_hist, output_dir)
+
+    # Final Training of the Best Model
+    logging.info("Starting final training of the best evolved model...")
+    # Clone the best model again to ensure we don't modify the original reference unintentionally
+    final_model = clone_model(best_model_unevolved)
+    final_model.set_weights(best_model_unevolved.get_weights())
+    # Use a fresh optimizer instance for final training
+    final_model.compile(optimizer=Adam(learning_rate=0.001), loss='mse', metrics=['mae'])
+
+    # Callbacks for efficient training
+    early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True, verbose=1)
+    reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=1e-6, verbose=1)
+
+    # Use a portion of training data for validation during final training
+    history = final_model.fit(
+        X_train, y_train,
+        epochs=args.epochs_final_train,
+        batch_size=args.batch_size,
+        validation_split=0.2, # Use 20% of training data for validation
+        callbacks=[early_stopping, reduce_lr],
+        verbose=2 # Show one line per epoch
+    )
+    logging.info("Final training complete.")
+
+    # Evaluate the TRAINED final model
+    final_metrics = evaluate_model(final_model, X_test, y_test, args.batch_size)
+
+    # Save the TRAINED final model
+    model_path = os.path.join(output_dir, "best_evolved_model_trained.keras") # Use .keras format
+    final_model.save(model_path)
+    logging.info(f"Final trained model saved to {model_path}")
+
+    # Save final results
+    results = {
+        "config": args_dict,
+        "final_evaluation": final_metrics,
+        "evolution_summary": {
+            "best_fitness_overall": best_fitness_hist[-1] if best_fitness_hist else None,
+            "avg_fitness_final_gen": avg_fitness_hist[-1] if avg_fitness_hist else None,
+        },
+        "training_history": history.history # Include loss/val_loss history from final training
+    }
+    results_path = os.path.join(output_dir, "final_results.json")
+    # Convert numpy types in history to native Python types for JSON serialization
+    for key in results['training_history']:
+        results['training_history'][key] = [float(v) for v in results['training_history'][key]]
+
+    with open(results_path, 'w') as f:
+        json.dump(results, f, indent=4)
+    logging.info(f"Final results saved to {results_path}")
+    logging.info("Pipeline finished successfully!")
+
+
+# --- Argument Parser ---
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="EvoNet: Neuroevolution for Sorting Task")
+
+    # --- Directory ---
+    parser.add_argument('--output_base_dir', type=str, default=os.path.join(os.getcwd(), "evonet_runs"),
+                        help='Base directory to store run results.')
+
+    # --- Data ---
+    parser.add_argument('--seq_length', type=int, default=DEFAULT_SEQ_LENGTH,
+                        help='Length of the sequences to sort.')
+    parser.add_argument('--train_samples', type=int, default=5000, help='Number of training samples.')
+    parser.add_argument('--test_samples', type=int, default=1000, help='Number of test samples.')
+
+    # --- Evolution Parameters ---
+    parser.add_argument('--pop_size', type=int, default=DEFAULT_POP_SIZE, help='Population size.')
+    parser.add_argument('--generations', type=int, default=DEFAULT_GENERATIONS, help='Number of generations.')
+    parser.add_argument('--mutation_rate', type=float, default=DEFAULT_MUTATION_RATE,
+                        help='Overall probability of mutating an individual.')
+    parser.add_argument('--weight_mut_rate', type=float, default=DEFAULT_WEIGHT_MUT_RATE,
+                        help='Probability of weight perturbation if mutation occurs.')
+    parser.add_argument('--activation_mut_rate', type=float, default=DEFAULT_ACTIVATION_MUT_RATE,
+                        help='Probability of activation change if mutation occurs.')
+    parser.add_argument('--mutation_strength', type=float, default=DEFAULT_MUTATION_STRENGTH,
+                        help='Standard deviation of Gaussian noise for weight mutation.')
+    parser.add_argument('--tournament_size', type=int, default=DEFAULT_TOURNAMENT_SIZE,
+                        help='Number of individuals participating in tournament selection.')
+    parser.add_argument('--elitism_count', type=int, default=DEFAULT_ELITISM_COUNT,
+                        help='Number of best individuals to carry over directly.')
+
+    # --- Training & Evaluation ---
+    parser.add_argument('--batch_size', type=int, default=DEFAULT_BATCH_SIZE, help='Batch size for predictions and training.')
+    parser.add_argument('--epochs_final_train', type=int, default=DEFAULT_EPOCHS_FINAL_TRAIN,
+                        help='Max epochs for final training of the best model.')
+
+    # --- Reproducibility ---
+    parser.add_argument('--seed', type=int, default=None, help='Random seed for reproducibility (default: random).')
+
+    args = parser.parse_args()
+
+    # If seed is not provided, generate one
+    if args.seed is None:
+        args.seed = random.randint(0, 2**32 - 1)
+
+    return args
+
+
+# --- Main Execution ---
+if __name__ == "__main__":
+    # 1. Parse Command Line Arguments
+    cli_args = parse_arguments()
+
+    # Ensure output directory exists
+    os.makedirs(cli_args.output_base_dir, exist_ok=True)
+
+    # 2. Run the Pipeline
+    try:
+        run_pipeline(cli_args)
+    except Exception as e:
+        # Log any uncaught exceptions during the pipeline execution
+        # The logger might not be set up if error is early, so print as fallback
+        print(f"FATAL ERROR in pipeline execution: {e}", file=sys.stderr)
+        # Attempt to log if logger was initialized
+        if logging.getLogger().hasHandlers():
+             logging.critical("FATAL ERROR in pipeline execution:", exc_info=True)
+        else:
+             import traceback
+             print(traceback.format_exc(), file=sys.stderr)
+        sys.exit(1) # Exit with error code

final_results.json

@@ -0,0 +1,539 @@
+{
+    "config": {
+        "output_base_dir": "./my_neuroevolution_results",
+        "seq_length": 10,
+        "train_samples": 5000,
+        "test_samples": 1000,
+        "pop_size": 80,
+        "generations": 100,
+        "mutation_rate": 0.5,
+        "weight_mut_rate": 0.8,
+        "activation_mut_rate": 0.2,
+        "mutation_strength": 0.1,
+        "tournament_size": 5,
+        "elitism_count": 2,
+        "batch_size": 64,
+        "epochs_final_train": 100,
+        "seed": 123
+    },
+    "final_evaluation": {
+        "test_mse": 38.61078889492296,
+        "avg_kendall_tau": 0.9964444444444444
+    },
+    "evolution_summary": {
+        "best_fitness_overall": 0.0010725238619096907,
+        "avg_fitness_final_gen": 0.0008708313889016431
+    },
+    "training_history": {
+        "loss": [
+            546.2453002929688,
+            259.88385009765625,
+            160.8056182861328,
+            121.15694427490234,
+            103.09577941894531,
+            93.04764556884766,
+            86.2327880859375,
+            81.19600677490234,
+            76.95745849609375,
+            73.48666381835938,
+            69.82528686523438,
+            66.72440338134766,
+            64.06942749023438,
+            61.33348083496094,
+            59.45895767211914,
+            57.71091842651367,
+            55.872772216796875,
+            54.16001892089844,
+            52.91276550292969,
+            51.56428146362305,
+            50.49087142944336,
+            49.65439987182617,
+            48.75180435180664,
+            48.34307861328125,
+            47.3436279296875,
+            46.7180061340332,
+            46.27332305908203,
+            45.95494079589844,
+            45.99394607543945,
+            45.554264068603516,
+            45.08098220825195,
+            45.12644958496094,
+            44.66641616821289,
+            44.55065155029297,
+            44.405067443847656,
+            44.24126052856445,
+            44.15995788574219,
+            44.05458068847656,
+            43.82747268676758,
+            43.609779357910156,
+            43.547706604003906,
+            43.29800033569336,
+            43.19523620605469,
+            43.16196060180664,
+            42.95027160644531,
+            42.81744384765625,
+            43.091712951660156,
+            42.707786560058594,
+            42.47276306152344,
+            42.355682373046875,
+            42.49977111816406,
+            42.08684158325195,
+            42.29066467285156,
+            41.80927276611328,
+            41.90619659423828,
+            41.8099250793457,
+            41.549163818359375,
+            41.396934509277344,
+            41.21516036987305,
+            41.11375427246094,
+            40.800689697265625,
+            40.44392013549805,
+            40.39072036743164,
+            40.210655212402344,
+            40.23362350463867,
+            40.23074722290039,
+            39.86910629272461,
+            39.74824905395508,
+            39.67206954956055,
+            39.67225646972656,
+            39.297149658203125,
+            39.36761474609375,
+            39.19108200073242,
+            38.89718246459961,
+            38.87799835205078,
+            38.871070861816406,
+            38.60243225097656,
+            38.5323486328125,
+            38.74274444580078,
+            38.49137496948242,
+            38.1933479309082,
+            38.089134216308594,
+            38.048973083496094,
+            37.9232177734375,
+            37.71906661987305,
+            37.57664489746094,
+            37.903602600097656,
+            37.46571350097656,
+            37.543052673339844,
+            37.541290283203125,
+            37.1763916015625,
+            36.93217849731445,
+            36.88774108886719,
+            36.782711029052734,
+            36.954158782958984,
+            36.48606872558594,
+            36.34406280517578,
+            36.34116744995117,
+            36.13870620727539,
+            35.894798278808594
+        ],
+        "mae": [
+            18.270145416259766,
+            12.641241073608398,
+            9.978185653686523,
+            8.655787467956543,
+            7.988434791564941,
+            7.588530540466309,
+            7.30443000793457,
+            7.094987869262695,
+            6.908982753753662,
+            6.748968601226807,
+            6.582261085510254,
+            6.4301300048828125,
+            6.297377109527588,
+            6.160496711730957,
+            6.065600395202637,
+            5.973959922790527,
+            5.875831127166748,
+            5.78226375579834,
+            5.717526912689209,
+            5.645669460296631,
+            5.583215236663818,
+            5.5392632484436035,
+            5.489008903503418,
+            5.464126110076904,
+            5.406632900238037,
+            5.367351055145264,
+            5.343441009521484,
+            5.327566623687744,
+            5.331641674041748,
+            5.305015563964844,
+            5.273298740386963,
+            5.281223773956299,
+            5.2487711906433105,
+            5.242580413818359,
+            5.235714912414551,
+            5.22819185256958,
+            5.223107814788818,
+            5.215035915374756,
+            5.200500965118408,
+            5.18730354309082,
+            5.1813459396362305,
+            5.171675682067871,
+            5.160656452178955,
+            5.158697605133057,
+            5.1457648277282715,
+            5.143444538116455,
+            5.157040119171143,
+            5.133112907409668,
+            5.117641448974609,
+            5.114692687988281,
+            5.1225385665893555,
+            5.094179153442383,
+            5.106266975402832,
+            5.074340343475342,
+            5.085508346557617,
+            5.074405193328857,
+            5.0639567375183105,
+            5.0499067306518555,
+            5.040680408477783,
+            5.036265850067139,
+            5.013760089874268,
+            4.9970011711120605,
+            4.989516735076904,
+            4.973187446594238,
+            4.977268218994141,
+            4.97721004486084,
+            4.951179504394531,
+            4.944492816925049,
+            4.943199157714844,
+            4.94016170501709,
+            4.913013458251953,
+            4.921325206756592,
+            4.903163909912109,
+            4.890426158905029,
+            4.887558937072754,
+            4.888551235198975,
+            4.870633125305176,
+            4.86383581161499,
+            4.8799238204956055,
+            4.856790542602539,
+            4.84244441986084,
+            4.841256141662598,
+            4.829007148742676,
+            4.817996501922607,
+            4.810219764709473,
+            4.801018714904785,
+            4.82061243057251,
+            4.793266296386719,
+            4.801506042480469,
+            4.7967915534973145,
+            4.774496555328369,
+            4.759250640869141,
+            4.757969379425049,
+            4.748015880584717,
+            4.763484477996826,
+            4.726821422576904,
+            4.717569828033447,
+            4.720791339874268,
+            4.704056739807129,
+            4.687249183654785
+        ],
+        "val_loss": [
+            355.85028076171875,
+            198.4627227783203,
+            138.49102783203125,
+            112.78740692138672,
+            99.88117980957031,
+            91.56582641601562,
+            85.2259750366211,
+            80.70155334472656,
+            77.23670959472656,
+            73.29762268066406,
+            69.72806549072266,
+            67.10668182373047,
+            64.06816101074219,
+            62.02535629272461,
+            60.76095199584961,
+            58.276878356933594,
+            56.67515182495117,
+            55.075042724609375,
+            53.78398513793945,
+            52.859310150146484,
+            51.962432861328125,
+            50.62075424194336,
+            51.23684310913086,
+            49.018898010253906,
+            48.78486633300781,
+            48.1305046081543,
+            48.10685729980469,
+            47.723087310791016,
+            47.94329071044922,
+            47.151859283447266,
+            47.02169418334961,
+            46.635581970214844,
+            45.934898376464844,
+            46.0821418762207,
+            45.82994842529297,
+            46.47359848022461,
+            45.441795349121094,
+            45.479679107666016,
+            45.500396728515625,
+            45.16574478149414,
+            45.373207092285156,
+            44.835838317871094,
+            45.28779602050781,
+            45.18010330200195,
+            44.22176742553711,
+            44.56682586669922,
+            44.70293045043945,
+            45.086891174316406,
+            44.14433288574219,
+            43.95674133300781,
+            44.348411560058594,
+            45.011810302734375,
+            43.68522644042969,
+            44.200740814208984,
+            43.5811653137207,
+            43.36353302001953,
+            43.99952697753906,
+            42.700592041015625,
+            42.49974822998047,
+            43.01130294799805,
+            42.199161529541016,
+            41.973419189453125,
+            41.9033203125,
+            41.96733474731445,
+            43.144779205322266,
+            41.36708068847656,
+            41.23895263671875,
+            41.200260162353516,
+            41.32600402832031,
+            40.975711822509766,
+            40.65323257446289,
+            40.83009719848633,
+            40.8490104675293,
+            40.55123519897461,
+            40.89341354370117,
+            40.507877349853516,
+            40.25646209716797,
+            40.46010208129883,
+            40.98613357543945,
+            40.15856170654297,
+            40.59947967529297,
+            40.15495681762695,
+            40.13038635253906,
+            39.703712463378906,
+            40.23557662963867,
+            39.47261428833008,
+            39.48463439941406,
+            39.428077697753906,
+            39.35265350341797,
+            38.96087646484375,
+            39.11784744262695,
+            38.510807037353516,
+            38.77788543701172,
+            38.9130973815918,
+            38.90206527709961,
+            38.353179931640625,
+            38.32897186279297,
+            38.58757400512695,
+            38.03741455078125,
+            38.96195602416992
+        ],
+        "val_mae": [
+            14.81877613067627,
+            11.014273643493652,
+            9.209857940673828,
+            8.31789779663086,
+            7.8487067222595215,
+            7.5107526779174805,
+            7.277787685394287,
+            7.0798516273498535,
+            6.912877559661865,
+            6.746294975280762,
+            6.584061622619629,
+            6.454700469970703,
+            6.3074188232421875,
+            6.200479984283447,
+            6.125111103057861,
+            6.004154205322266,
+            5.9107279777526855,
+            5.826013565063477,
+            5.759653091430664,
+            5.69955587387085,
+            5.671257495880127,
+            5.592477321624756,
+            5.6359992027282715,
+            5.5066704750061035,
+            5.480874538421631,
+            5.46126651763916,
+            5.460818767547607,
+            5.435495376586914,
+            5.446165084838867,
+            5.404515743255615,
+            5.398741722106934,
+            5.376246929168701,
+            5.3371262550354,
+            5.347751617431641,
+            5.340644836425781,
+            5.379054069519043,
+            5.310771942138672,
+            5.311794281005859,
+            5.3252387046813965,
+            5.307089805603027,
+            5.31290864944458,
+            5.2750959396362305,
+            5.326480865478516,
+            5.314337730407715,
+            5.258793354034424,
+            5.263396263122559,
+            5.2734599113464355,
+            5.282870769500732,
+            5.236101150512695,
+            5.2455010414123535,
+            5.255309581756592,
+            5.277646541595459,
+            5.214536666870117,
+            5.260697841644287,
+            5.2117719650268555,
+            5.1837873458862305,
+            5.225375175476074,
+            5.150074481964111,
+            5.1272478103637695,
+            5.172309875488281,
+            5.12300968170166,
+            5.10131311416626,
+            5.11003303527832,
+            5.106845855712891,
+            5.181298732757568,
+            5.072604656219482,
+            5.0620012283325195,
+            5.0632781982421875,
+            5.061835765838623,
+            5.043211460113525,
+            5.014331817626953,
+            5.024109840393066,
+            5.031244277954102,
+            5.010079860687256,
+            5.016538619995117,
+            5.0130205154418945,
+            4.99027681350708,
+            5.008115291595459,
+            5.03699254989624,
+            4.9775004386901855,
+            5.0150980949401855,
+            4.961390018463135,
+            4.971592426300049,
+            4.9428887367248535,
+            4.9885478019714355,
+            4.943417549133301,
+            4.943925380706787,
+            4.9367451667785645,
+            4.91554594039917,
+            4.90092134475708,
+            4.91062593460083,
+            4.876039028167725,
+            4.889153957366943,
+            4.889742374420166,
+            4.894570350646973,
+            4.847760200500488,
+            4.861299514770508,
+            4.878693103790283,
+            4.834355354309082,
+            4.890781879425049
+        ],
+        "lr": [
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513,
+            0.0010000000474974513
+        ]
+    }
+}

fitness_history.csv

@@ -0,0 +1,101 @@
+BestFitness,AvgFitness
+4.879378336679981065e-04,2.923409132461042646e-04
+5.120372187027128581e-04,3.102480528539362900e-04
+5.961601522501598378e-04,3.354280512428634421e-04
+6.632602251899356437e-04,3.921150275019214849e-04
+6.656605376610913146e-04,4.989973818539260222e-04
+7.395930847630745753e-04,5.248300942283199181e-04
+7.395930847630745753e-04,5.502964959263820233e-04
+7.395930847630745753e-04,5.866856208493637656e-04
+8.535108813708519853e-04,6.384033667292426288e-04
+8.535108813708519853e-04,6.492234966614883994e-04
+1.025801949338753022e-03,6.200751622285075254e-04
+1.025801949338753022e-03,6.713093422606043314e-04
+1.025801949338753022e-03,6.627829985415179155e-04
+1.025801949338753022e-03,6.980553544763470897e-04
+1.025801949338753022e-03,8.000164903113022663e-04
+1.025801949338753022e-03,7.926606643373794231e-04
+1.025801949338753022e-03,8.537321248410459796e-04
+1.025801949338753022e-03,7.865953276882823924e-04
+1.025801949338753022e-03,7.954519342879059086e-04
+1.025801949338753022e-03,7.495992568831947190e-04
+1.025801949338753022e-03,8.129212712032358448e-04
+1.025801949338753022e-03,8.320175320381643924e-04
+1.025801949338753022e-03,8.283260998181871332e-04
+1.025801949338753022e-03,8.094471947653295463e-04
+1.072523861909690677e-03,8.034063857733104302e-04
+1.072523861909690677e-03,8.078584674860950308e-04
+1.072523861909690677e-03,8.126480465242214490e-04
+1.072523861909690677e-03,8.406919351322233568e-04
+1.072523861909690677e-03,8.421425704229778837e-04
+1.072523861909690677e-03,8.266319397254315651e-04
+1.072523861909690677e-03,8.189656164316591385e-04
+1.072523861909690677e-03,8.671482166059202518e-04
+1.072523861909690677e-03,8.636414180249784092e-04
+1.072523861909690677e-03,8.666964492040071322e-04
+1.072523861909690677e-03,8.248040059764021525e-04
+1.072523861909690677e-03,7.558637790243980057e-04
+1.072523861909690677e-03,8.607504905122149086e-04
+1.072523861909690677e-03,7.852067503426332857e-04
+1.072523861909690677e-03,7.922704422613266028e-04
+1.072523861909690677e-03,8.327999675597427820e-04
+1.072523861909690677e-03,8.109242161579308323e-04
+1.072523861909690677e-03,8.236296535256398387e-04
+1.072523861909690677e-03,8.268113823558676662e-04
+1.072523861909690677e-03,8.363130032633112661e-04
+1.072523861909690677e-03,7.378171369123170823e-04
+1.072523861909690677e-03,8.482781612404125676e-04
+1.072523861909690677e-03,8.403266371703604909e-04
+1.072523861909690677e-03,8.268147025820285143e-04
+1.072523861909690677e-03,8.879933677382103327e-04
+1.072523861909690677e-03,7.699174581584162158e-04
+1.072523861909690677e-03,8.077807061097061004e-04
+1.072523861909690677e-03,8.427391672955050414e-04
+1.072523861909690677e-03,8.554911134751854102e-04
+1.072523861909690677e-03,8.291372182286990819e-04
+1.072523861909690677e-03,7.750175427182952412e-04
+1.072523861909690677e-03,8.376154870339909322e-04
+1.072523861909690677e-03,7.886120355178166111e-04
+1.072523861909690677e-03,8.278253787101065922e-04
+1.072523861909690677e-03,8.515559088346543858e-04
+1.072523861909690677e-03,8.587190911354431345e-04
+1.072523861909690677e-03,8.255115092803182392e-04
+1.072523861909690677e-03,8.642214780840772959e-04
+1.072523861909690677e-03,8.628927131915506074e-04
+1.072523861909690677e-03,8.631160812412311169e-04
+1.072523861909690677e-03,8.044881614619446304e-04
+1.072523861909690677e-03,8.570926279075916435e-04
+1.072523861909690677e-03,8.749681438229552294e-04
+1.072523861909690677e-03,8.278706554081565394e-04
+1.072523861909690677e-03,8.157551330855907640e-04
+1.072523861909690677e-03,7.964370127076100207e-04
+1.072523861909690677e-03,7.918045828701765054e-04
+1.072523861909690677e-03,7.336502007874407894e-04
+1.072523861909690677e-03,8.215698327851003952e-04
+1.072523861909690677e-03,8.380718853258096448e-04
+1.072523861909690677e-03,7.967431312469321980e-04
+1.072523861909690677e-03,8.511079970992240775e-04
+1.072523861909690677e-03,8.306266038751997354e-04
+1.072523861909690677e-03,8.281458760471336732e-04
+1.072523861909690677e-03,7.722702630573293143e-04
+1.072523861909690677e-03,8.440294699035297624e-04
+1.072523861909690677e-03,8.662165717125309972e-04
+1.072523861909690677e-03,8.175639995972565225e-04
+1.072523861909690677e-03,8.118812444553594665e-04
+1.072523861909690677e-03,8.510362443319926824e-04
+1.072523861909690677e-03,8.722723885450754536e-04
+1.072523861909690677e-03,7.916319241258804170e-04
+1.072523861909690677e-03,8.069695097822701538e-04
+1.072523861909690677e-03,7.472721163610672630e-04
+1.072523861909690677e-03,8.339170941398657078e-04
+1.072523861909690677e-03,8.487886671014362172e-04
+1.072523861909690677e-03,7.984410213554164531e-04
+1.072523861909690677e-03,8.079140745054025699e-04
+1.072523861909690677e-03,8.537223872123788151e-04
+1.072523861909690677e-03,8.168824582432641923e-04
+1.072523861909690677e-03,8.591290731223225757e-04
+1.072523861909690677e-03,8.346388265996646525e-04
+1.072523861909690677e-03,8.873753424933579275e-04
+1.072523861909690677e-03,8.757968718670166002e-04
+1.072523861909690677e-03,8.716829100268331122e-04
+1.072523861909690677e-03,8.708313889016430645e-04

v2.py

@@ -0,0 +1,643 @@
+# ==============================================================================
+# EvoNet Optimizer 2 - Revize Edilmiş ve İyileştirilmiş Kod
+# Açıklama: Bu kod, sıralama görevini öğrenmek için rastgele topolojilere
+# sahip sinir ağlarını evrimleştiren bir neuroevolution süreci uygular.
+# Daha sağlam hata kontrolü, yapılandırma, loglama ve iyileştirilmiş
+# evrimsel operatörler içerir.
+# ==============================================================================
+
+import os
+import subprocess
+import sys
+import argparse
+import random
+import logging
+from datetime import datetime
+import json
+from typing import List, Tuple, Dict, Any
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential, load_model, clone_model
+from tensorflow.keras.layers import Dense, Input
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
+import matplotlib.pyplot as plt
+from scipy.stats import kendalltau
+
+# --- Sabitler ve Varsayılan Değerler ---
+DEFAULT_SEQ_LENGTH = 10
+DEFAULT_POP_SIZE = 50
+DEFAULT_GENERATIONS = 50
+DEFAULT_MUTATION_RATE = 0.4       # Bireye mutasyon uygulama olasılığı
+DEFAULT_WEIGHT_MUT_RATE = 0.8     # Mutasyon olursa, ağırlık bozulması olasılığı
+DEFAULT_ACTIVATION_MUT_RATE = 0.2 # Mutasyon olursa, aktivasyon değişimi olasılığı
+DEFAULT_MUTATION_STRENGTH = 0.1 # Ağırlık bozulmasının büyüklüğü (std dev)
+DEFAULT_TOURNAMENT_SIZE = 5       # Turnuva seçilimindeki birey sayısı
+DEFAULT_ELITISM_COUNT = 2         # Sonraki nesle doğrudan aktarılacak en iyi birey sayısı
+DEFAULT_EPOCHS_FINAL_TRAIN = 100  # En iyi modelin son eğitimindeki max epoch
+DEFAULT_BATCH_SIZE = 64           # Tahmin ve eğitim için batch boyutu
+DEFAULT_OUTPUT_BASE_DIR = os.path.join(os.getcwd(), "evonet_runs_revised") # Ana çıktı klasörü
+
+# --- Loglama Ayarları ---
+def setup_logging(log_dir: str, log_level=logging.INFO) -> None:
+    """Loglamayı dosyaya ve konsola ayarlayan fonksiyon."""
+    log_filename = os.path.join(log_dir, 'evolution_run.log')
+    # Önceki handler'ları temizle (Jupyter gibi ortamlarda tekrar çalıştırmada önemli)
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    # Yeni handler'ları ayarla
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(levelname)-8s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_filename, mode='w'), # 'w' modu ile her çalıştırmada üzerine yazar
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    logging.info("Logging setup complete.")
+
+# --- GPU Kontrolü ---
+def check_gpu() -> bool:
+    """GPU varlığını kontrol eder ve bellek artışını ayarlar."""
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus:
+        try:
+            for gpu in gpus:
+                tf.config.experimental.set_memory_growth(gpu, True)
+            logical_gpus = tf.config.list_logical_devices('GPU')
+            logging.info(f"{len(gpus)} Physical GPUs, {len(logical_gpus)} Logical GPUs found.")
+            if logical_gpus:
+                 logging.info(f"Using GPU: {tf.config.experimental.get_device_details(gpus[0])['device_name']}")
+            return True
+        except RuntimeError as e:
+            logging.error(f"Error setting memory growth for GPU: {e}", exc_info=True)
+            return False
+    else:
+        logging.warning("GPU not found. Using CPU.")
+        return False
+
+# --- Veri Üretimi ---
+def generate_data(num_samples: int, seq_length: int) -> Tuple[np.ndarray, np.ndarray]:
+    """Rastgele diziler ve sıralanmış hallerini üretir."""
+    logging.info(f"Generating {num_samples} samples with sequence length {seq_length}...")
+    try:
+        X = np.random.rand(num_samples, seq_length).astype(np.float32) * 100
+        y = np.sort(X, axis=1).astype(np.float32)
+        logging.info("Data generation successful.")
+        return X, y
+    except Exception as e:
+        logging.error(f"Error during data generation: {e}", exc_info=True)
+        raise # Hatanın yukarıya bildirilmesi önemli
+
+# --- Neuroevolution Çekirdeği ---
+def create_individual(seq_length: int, input_shape: Tuple) -> Sequential:
+    """Rastgele mimariye sahip bir Keras Sequential modeli oluşturur ve derler."""
+    try:
+        model = Sequential(name=f"model_random_{random.randint(10000, 99999)}")
+        num_hidden_layers = random.randint(1, 4)
+        neurons_per_layer = [random.randint(8, 64) for _ in range(num_hidden_layers)]
+        activations = [random.choice(['relu', 'tanh', 'sigmoid']) for _ in range(num_hidden_layers)]
+
+        model.add(Input(shape=input_shape)) # Input katmanı
+
+        for i in range(num_hidden_layers): # Gizli katmanlar
+            model.add(Dense(neurons_per_layer[i], activation=activations[i]))
+
+        model.add(Dense(seq_length, activation='linear')) # Çıkış katmanı
+
+        # Ağırlık manipülasyonu ve potansiyel eğitim için modeli derle
+        model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+        #logging.debug(f"Created individual: {model.name} with {len(model.layers)} layers.")
+        return model
+    except Exception as e:
+        logging.error(f"Error creating individual model: {e}", exc_info=True)
+        raise
+
+@tf.function # TensorFlow grafiği olarak derleyerek potansiyel hızlandırma
+def get_predictions(model: Sequential, X: tf.Tensor) -> tf.Tensor:
+    """Model tahminlerini tf.function kullanarak alır."""
+    return model(X, training=False)
+
+def calculate_fitness(individual: Sequential, X: np.ndarray, y: np.ndarray, batch_size: int) -> float:
+    """Bir bireyin fitness değerini (1/MSE) hesaplar, hataları yönetir."""
+    if not isinstance(X, tf.Tensor): X = tf.cast(X, tf.float32)
+    if not isinstance(y, tf.Tensor): y = tf.cast(y, tf.float32)
+
+    try:
+        y_pred_tf = get_predictions(individual, X) # Batching predict içinde yapılır
+        mse = tf.reduce_mean(tf.square(y - y_pred_tf))
+        mse_val = mse.numpy()
+
+        # Fitness: Ters MSE (sıfıra bölmeyi önlemek için epsilon ekle)
+        fitness_score = 1.0 / (mse_val + 1e-8)
+
+        if not np.isfinite(fitness_score) or fitness_score < 0:
+            logging.warning(f"Non-finite or negative fitness detected ({fitness_score:.4g}) for model {individual.name}. Assigning minimal fitness.")
+            return 1e-8 # Çok düşük bir fitness ata
+
+        #logging.debug(f"Fitness for {individual.name}: {fitness_score:.4f} (MSE: {mse_val:.4f})")
+        return float(fitness_score)
+
+    except tf.errors.InvalidArgumentError as e:
+         logging.error(f"TensorFlow InvalidArgumentError during fitness calculation for model {individual.name} (potential shape mismatch?): {e}")
+         return 1e-8
+    except Exception as e:
+        logging.error(f"Unhandled error during fitness calculation for model {individual.name}: {e}", exc_info=True)
+        return 1e-8 # Hata durumunda minimum fitness döndür
+
+
+def mutate_individual(individual: Sequential, weight_mut_rate: float, act_mut_rate: float, mut_strength: float) -> Sequential:
+    """Bir bireye mutasyonlar uygular (ağırlık bozulması, aktivasyon değişimi)."""
+    try:
+        # Mutasyon için modeli klonla, orijinali bozma
+        mutated_model = clone_model(individual)
+        mutated_model.set_weights(individual.get_weights())
+
+        mutated = False
+        # 1. Ağırlık Mutasyonu
+        if random.random() < weight_mut_rate:
+            mutated = True
+            for layer in mutated_model.layers:
+                if isinstance(layer, Dense) and layer.get_weights(): # Sadece ağırlığı olan Dense katmanları
+                    weights_biases = layer.get_weights()
+                    new_weights_biases = []
+                    for wb in weights_biases:
+                        noise = np.random.normal(0, mut_strength, wb.shape).astype(np.float32)
+                        new_weights_biases.append(wb + noise)
+                    layer.set_weights(new_weights_biases)
+
+        # 2. Aktivasyon Mutasyonu (Bağımsız olasılık)
+        if random.random() < act_mut_rate:
+            dense_layers = [layer for layer in mutated_model.layers if isinstance(layer, Dense)]
+            if len(dense_layers) > 1: # En az bir gizli katman varsa
+                layer_to_mutate = random.choice(dense_layers[:-1]) # Çıkış katmanı hariç
+                current_activation_name = tf.keras.activations.serialize(layer_to_mutate.activation)
+                possible_activations = ['relu', 'tanh', 'sigmoid']
+                if current_activation_name in possible_activations:
+                     possible_activations.remove(current_activation_name)
+                if possible_activations: # Değiştirilecek başka aktivasyon varsa
+                    new_activation = random.choice(possible_activations)
+                    # Katman konfigürasyonunu güncellemek daha güvenli
+                    layer_config = layer_to_mutate.get_config()
+                    layer_config['activation'] = new_activation
+                    # Yeni konfigürasyondan yeni katman oluştur ve ağırlıkları aktar
+                    try:
+                        new_layer = Dense.from_config(layer_config)
+                        # Model içinde katmanı değiştirmek yerine, modeli yeniden oluşturmak daha sağlam olabilir.
+                        # Ancak basitlik için bu yaklaşımı deneyelim (riskli olabilir).
+                        # Aktivasyon değiştirmek için katmanı yeniden build etmek gerekebilir.
+                        # Bu kısım karmaşık olabilir, şimdilik loglayalım.
+                        logging.debug(f"Attempting activation change on layer {layer_to_mutate.name} to {new_activation} (Implementation needs robust handling).")
+                        # Gerçek uygulamada modeli yeniden oluşturmak daha iyi olabilir.
+                        # Şimdilik sadece ağırlık mutasyonuna odaklanalım. Aktivasyon mutasyonu deneysel kalabilir.
+                        mutated = True # Aktivasyon mutasyon denemesi yapıldı olarak işaretle
+                    except Exception as e:
+                        logging.warning(f"Could not directly modify/rebuild layer for activation change: {e}")
+
+
+        # Mutasyona uğradıysa modeli yeniden derle (optimizer durumu sıfırlanabilir)
+        if mutated:
+            mutated_model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+            mutated_model._name = f"mutated_{individual.name}_{random.randint(1000,9999)}" # İsmi güncelle
+            #logging.debug(f"Mutated model {individual.name} -> {mutated_model.name}")
+
+        return mutated_model
+    except Exception as e:
+        logging.error(f"Error during mutation of model {individual.name}: {e}", exc_info=True)
+        return individual # Hata olursa orijinal bireyi döndür
+
+
+def tournament_selection(population: List[Sequential], fitness_scores: List[float], k: int) -> Sequential:
+    """Rastgele seçilen bir turnuva grubundan en iyi bireyi seçer."""
+    if not population:
+        raise ValueError("Population cannot be empty for selection.")
+    if len(population) < k:
+        logging.warning(f"Tournament size {k} is larger than population size {len(population)}. Using population size.")
+        k = len(population)
+    try:
+        tournament_indices = random.sample(range(len(population)), k)
+        tournament_fitness = [fitness_scores[i] for i in tournament_indices]
+        winner_local_idx = np.argmax(tournament_fitness)
+        winner_global_idx = tournament_indices[winner_local_idx]
+        #logging.debug(f"Tournament winner: Index {winner_global_idx}, Fitness: {fitness_scores[winner_global_idx]:.4f}")
+        return population[winner_global_idx]
+    except Exception as e:
+        logging.error(f"Error during tournament selection: {e}", exc_info=True)
+        # Hata durumunda rastgele bir birey seçmek bir alternatif olabilir
+        return random.choice(population)
+
+
+def evolve_population(population: List[Sequential], X: np.ndarray, y: np.ndarray, generations: int,
+                      mutation_rate: float, weight_mut_rate: float, act_mut_rate: float, mut_strength: float,
+                      tournament_size: int, elitism_count: int, batch_size: int) -> Tuple[Sequential, List[float], List[float]]:
+    """Evrimsel süreci çalıştırır, en iyi modeli ve fitness geçmişini döndürür."""
+    best_fitness_history = []
+    avg_fitness_history = []
+    best_model_overall = None
+    best_fitness_overall = -np.inf # Negatif sonsuz ile başla
+
+    # Veriyi TensorFlow tensor'üne dönüştür (döngü dışında bir kez yap)
+    X_tf = tf.cast(X, tf.float32)
+    y_tf = tf.cast(y, tf.float32)
+
+    for gen in range(generations):
+        generation_start_time = datetime.now()
+        # 1. Fitness Değerlendirme
+        try:
+            # Tüm popülasyon için fitness'ı hesapla
+            fitness_scores = [calculate_fitness(ind, X_tf, y_tf, batch_size) for ind in population]
+        except Exception as e:
+            logging.critical(f"Error calculating fitness for population in Generation {gen+1}: {e}", exc_info=True)
+            # Bu kritik bir hata, süreci durdurmak gerekebilir veya önceki popülasyonla devam edilebilir.
+            # Şimdilik en iyi modeli döndürelim ve çıkalım.
+            if best_model_overall: return best_model_overall, best_fitness_history, avg_fitness_history
+            else: raise # Henüz iyi model yoksa hatayı yükselt
+
+        # 2. İstatistikler ve En İyiyi Takip Etme
+        current_best_idx = np.argmax(fitness_scores)
+        current_best_fitness = fitness_scores[current_best_idx]
+        avg_fitness = np.mean(fitness_scores)
+        best_fitness_history.append(current_best_fitness)
+        avg_fitness_history.append(avg_fitness)
+
+        if current_best_fitness > best_fitness_overall:
+            best_fitness_overall = current_best_fitness
+            try:
+                # En iyi modelin yapısını ve ağırlıklarını güvenli bir şekilde kopyala
+                best_model_overall = clone_model(population[current_best_idx])
+                best_model_overall.set_weights(population[current_best_idx].get_weights())
+                best_model_overall.compile(optimizer=Adam(), loss='mse') # Yeniden derle
+                logging.info(f"Generation {gen+1}: *** New overall best fitness found: {best_fitness_overall:.6f} ***")
+            except Exception as e:
+                 logging.error(f"Could not clone or set weights for the new best model: {e}", exc_info=True)
+                 # Klonlama başarısız olursa devam et, ama en iyi model güncellenmemiş olabilir.
+                 best_fitness_overall = current_best_fitness # Fitness'�� yine de güncelle
+
+        generation_time = (datetime.now() - generation_start_time).total_seconds()
+        logging.info(f"Generation {gen+1}/{generations} | Best Fitness: {current_best_fitness:.6f} | Avg Fitness: {avg_fitness:.6f} | Time: {generation_time:.2f}s")
+
+        # 3. Yeni Popülasyon Oluşturma
+        new_population = []
+
+        # 3a. Elitizm
+        if elitism_count > 0 and len(population) >= elitism_count:
+            try:
+                elite_indices = np.argsort(fitness_scores)[-elitism_count:]
+                for idx in elite_indices:
+                    elite_clone = clone_model(population[idx])
+                    elite_clone.set_weights(population[idx].get_weights())
+                    elite_clone.compile(optimizer=Adam(), loss='mse')
+                    new_population.append(elite_clone)
+                    #logging.debug(f"Added elite model {elite_clone.name} (Index: {idx}, Fitness: {fitness_scores[idx]:.4f})")
+            except Exception as e:
+                 logging.error(f"Error during elitism: {e}", exc_info=True)
+
+
+        # 3b. Seçilim ve Üreme (Kalan Bireyler İçin)
+        num_to_generate = len(population) - len(new_population)
+        offspring_population = []
+        while len(offspring_population) < num_to_generate:
+            try:
+                # Ebeveyn seç
+                parent = tournament_selection(population, fitness_scores, tournament_size)
+
+                # Çocuk oluştur (mutasyon uygula veya uygulama)
+                if random.random() < mutation_rate:
+                    child = mutate_individual(parent, weight_mut_rate, act_mut_rate, mut_strength)
+                else:
+                    # Mutasyon yoksa, yine de klonla ki aynı nesne referansı olmasın
+                    child = clone_model(parent)
+                    child.set_weights(parent.get_weights())
+                    child.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+                    child._name = f"cloned_{parent.name}_{random.randint(1000,9999)}" # İsmi güncelle
+
+                offspring_population.append(child)
+            except Exception as e:
+                logging.error(f"Error during selection/reproduction cycle: {e}", exc_info=True)
+                # Hata durumunda döngüyü kırmak veya rastgele birey eklemek düşünülebilir
+                # Şimdilik döngü devam etsin, belki sonraki denemede düzelir
+                if len(offspring_population) < num_to_generate: # Eksik kalmaması için rastgele ekle
+                    logging.warning("Adding random individual due to reproduction error.")
+                    offspring_population.append(create_individual(y.shape[1], X.shape[1:]))
+
+
+        new_population.extend(offspring_population)
+        population = new_population # Popülasyonu güncelle
+
+    # Döngü bittiğinde en iyi modeli döndür
+    if best_model_overall is None and population: # Hiç iyileşme olmadıysa veya elitizm yoksa
+         logging.warning("No overall best model tracked (or cloning failed). Returning best from final population.")
+         final_fitness_scores = [calculate_fitness(ind, X_tf, y_tf, batch_size) for ind in population]
+         best_idx_final = np.argmax(final_fitness_scores)
+         best_model_overall = population[best_idx_final]
+    elif not population:
+         logging.error("Evolution finished with an empty population!")
+         return None, best_fitness_history, avg_fitness_history
+
+
+    logging.info(f"Evolution finished. Best fitness achieved: {best_fitness_overall:.6f}")
+    return best_model_overall, best_fitness_history, avg_fitness_history
+
+
+# --- Grafik Çizimi ---
+def plot_fitness_history(history_best: List[float], history_avg: List[float], output_dir: str) -> None:
+    """Fitness geçmişini çizer ve kaydeder."""
+    if not history_best or not history_avg:
+        logging.warning("Fitness history is empty, cannot plot.")
+        return
+    try:
+        plt.figure(figsize=(12, 7))
+        plt.plot(history_best, label="Best Fitness per Generation", marker='o', linestyle='-', linewidth=2)
+        plt.plot(history_avg, label="Average Fitness per Generation", marker='x', linestyle='--', alpha=0.7)
+        plt.xlabel("Generation")
+        plt.ylabel("Fitness Score (1 / MSE)")
+        plt.title("Evolutionary Process Fitness History")
+        plt.legend()
+        plt.grid(True, which='both', linestyle='--', linewidth=0.5)
+        plt.tight_layout()
+        plot_path = os.path.join(output_dir, "fitness_history.png")
+        plt.savefig(plot_path)
+        plt.close() # Bellekte figürü kapat
+        logging.info(f"Fitness history plot saved to {plot_path}")
+    except Exception as e:
+        logging.error(f"Error plotting fitness history: {e}", exc_info=True)
+
+# --- Değerlendirme ---
+def evaluate_model(model: Sequential, X_test: np.ndarray, y_test: np.ndarray, batch_size: int) -> Dict[str, float]:
+    """Son modeli test verisi üzerinde değerlendirir."""
+    if model is None:
+        logging.error("Cannot evaluate a None model.")
+        return {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+    logging.info("Evaluating final model on test data...")
+    try:
+        y_pred = model.predict(X_test, batch_size=batch_size, verbose=0)
+        test_mse = np.mean(np.square(y_test - y_pred))
+        logging.info(f"Final Test MSE: {test_mse:.6f}")
+
+        # Kendall's Tau (örneklem üzerinde)
+        sample_size = min(500, X_test.shape[0]) # Örneklem boyutunu ayarla
+        taus = []
+        indices = np.random.choice(X_test.shape[0], sample_size, replace=False)
+        for i in indices:
+            try:
+                tau, _ = kendalltau(y_test[i], y_pred[i])
+                if not np.isnan(tau): taus.append(tau)
+            except ValueError as ve: # Eğer y_pred sabit değerler içeriyorsa
+                 logging.debug(f"Kendall tau ValueError for sample {i}: {ve}")
+
+        avg_kendall_tau = np.mean(taus) if taus else 0.0
+        logging.info(f"Average Kendall's Tau (on {sample_size} samples): {avg_kendall_tau:.4f}")
+
+        return {
+            "test_mse": float(test_mse),
+            "avg_kendall_tau": float(avg_kendall_tau)
+        }
+    except Exception as e:
+        logging.error(f"Error during final model evaluation: {e}", exc_info=True)
+        return {"test_mse": np.inf, "avg_kendall_tau": 0.0} # Hata durumunda kötü değerler döndür
+
+# --- Ana İş Akışı ---
+def run_pipeline(args: argparse.Namespace):
+    """Tüm neuroevolution iş akışını çalıştırır."""
+
+    # Benzersiz çıktı klasörü oluştur
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_name = f"evorun_{timestamp}_gen{args.generations}_pop{args.pop_size}"
+    output_dir = os.path.join(args.output_base_dir, run_name)
+    try:
+        os.makedirs(output_dir, exist_ok=True)
+    except OSError as e:
+        print(f"FATAL: Could not create output directory: {output_dir}. Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Loglamayı ayarla
+    setup_logging(output_dir)
+    logging.info(f"========== Starting EvoNet Pipeline Run: {run_name} ==========")
+    logging.info(f"Output directory: {output_dir}")
+
+    # Argümanları logla ve kaydet
+    logging.info("--- Configuration ---")
+    args_dict = vars(args)
+    for k, v in args_dict.items():
+        logging.info(f"  {k:<20}: {v}")
+    logging.info("---------------------")
+    config_path = os.path.join(output_dir, "config.json")
+    try:
+        with open(config_path, 'w') as f:
+            json.dump(args_dict, f, indent=4, sort_keys=True)
+        logging.info(f"Configuration saved to {config_path}")
+    except Exception as e:
+        logging.error(f"Failed to save configuration: {e}", exc_info=True)
+
+
+    # Rastgele tohumları ayarla
+    try:
+        random.seed(args.seed)
+        np.random.seed(args.seed)
+        tf.random.set_seed(args.seed)
+        logging.info(f"Using random seed: {args.seed}")
+        # Deterministic ops (TensorFlow >= 2.8): Opsiyonel, performansı düşürebilir ama tekrarlanabilirliği artırır
+        # tf.config.experimental.enable_op_determinism()
+    except Exception as e:
+         logging.warning(f"Could not set all random seeds: {e}")
+
+
+    # GPU kontrolü
+    is_gpu_available = check_gpu()
+
+    # Veri Üretimi
+    try:
+        X_train, y_train = generate_data(args.train_samples, args.seq_length)
+        X_test, y_test = generate_data(args.test_samples, args.seq_length)
+        input_shape = X_train.shape[1:] # Model oluşturmak için girdi şekli
+    except Exception:
+        logging.critical("Failed to generate data. Exiting.")
+        sys.exit(1)
+
+
+    # Popülasyon Başlatma
+    logging.info(f"--- Initializing Population (Size: {args.pop_size}) ---")
+    try:
+        population = [create_individual(args.seq_length, input_shape) for _ in range(args.pop_size)]
+        logging.info("Population initialized successfully.")
+    except Exception:
+        logging.critical("Failed to initialize population. Exiting.")
+        sys.exit(1)
+
+    # Evrim Süreci
+    logging.info(f"--- Starting Evolution ({args.generations} Generations) ---")
+    try:
+        best_model_unevolved, best_fitness_hist, avg_fitness_hist = evolve_population(
+            population, X_train, y_train, args.generations,
+            args.mutation_rate, args.weight_mut_rate, args.activation_mut_rate, args.mutation_strength,
+            args.tournament_size, args.elitism_count, args.batch_size
+        )
+    except Exception as e:
+        logging.critical(f"Fatal error during evolution process: {e}", exc_info=True)
+        sys.exit(1)
+    logging.info("--- Evolution Complete ---")
+
+    # Fitness geçmişini kaydet ve çizdir
+    if best_fitness_hist and avg_fitness_hist:
+        history_path = os.path.join(output_dir, "fitness_history.csv")
+        try:
+            history_data = np.array([np.arange(1, len(best_fitness_hist) + 1), best_fitness_hist, avg_fitness_hist]).T
+            np.savetxt(history_path, history_data, delimiter=',', header='Generation,BestFitness,AvgFitness', comments='', fmt=['%d', '%.8f', '%.8f'])
+            logging.info(f"Fitness history data saved to {history_path}")
+        except Exception as e:
+            logging.error(f"Could not save fitness history data: {e}", exc_info=True)
+        plot_fitness_history(best_fitness_hist, avg_fitness_hist, output_dir)
+    else:
+        logging.warning("Fitness history is empty, skipping saving/plotting.")
+
+
+    # En İyi Modelin Son Eğitimi
+    if best_model_unevolved is None:
+        logging.error("Evolution did not yield a best model. Skipping final training and evaluation.")
+        final_metrics = {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+        final_model_path = None
+        training_summary = {}
+    else:
+        logging.info("--- Starting Final Training of Best Evolved Model ---")
+        try:
+            # En iyi modeli tekrar klonla ve derle (güvenlik için)
+            final_model = clone_model(best_model_unevolved)
+            final_model.set_weights(best_model_unevolved.get_weights())
+            # Son eğitim için belki farklı bir öğrenme oranı denenebilir
+            final_model.compile(optimizer=Adam(learning_rate=0.001), loss='mse', metrics=['mae'])
+            logging.info("Model Summary of Best Evolved (Untrained):")
+            final_model.summary(print_fn=logging.info)
+
+
+            # Callback'ler
+            early_stopping = EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True, verbose=1) # Sabrı biraz artır
+            reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.3, patience=7, min_lr=1e-7, verbose=1) # Faktörü ve sabrı ayarla
+
+            history = final_model.fit(
+                X_train, y_train,
+                epochs=args.epochs_final_train,
+                batch_size=args.batch_size,
+                validation_split=0.2, # Eğitim verisinin %20'si validasyon için
+                callbacks=[early_stopping, reduce_lr],
+                verbose=2 # Her epoch için bir satır log
+            )
+            logging.info("Final training complete.")
+            training_summary = {
+                 "epochs_run": len(history.history['loss']),
+                 "final_train_loss": history.history['loss'][-1],
+                 "final_val_loss": history.history['val_loss'][-1]
+            }
+
+            # Eğitilmiş modeli değerlendir
+            final_metrics = evaluate_model(final_model, X_test, y_test, args.batch_size)
+
+            # Eğitilmiş modeli kaydet
+            final_model_path = os.path.join(output_dir, "best_evolved_model_trained.keras")
+            final_model.save(final_model_path)
+            logging.info(f"Final trained model saved to {final_model_path}")
+
+        except Exception as e:
+             logging.error(f"Error during final training or evaluation: {e}", exc_info=True)
+             final_metrics = {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+             final_model_path = None
+             training_summary = {"error": str(e)}
+
+
+    # Sonuçları Kaydet
+    logging.info("--- Saving Final Results ---")
+    final_results = {
+        "run_info": {
+            "run_name": run_name,
+            "timestamp": timestamp,
+            "output_directory": output_dir,
+            "gpu_used": is_gpu_available,
+        },
+        "config": args_dict,
+        "evolution_summary": {
+            "generations_run": len(best_fitness_hist) if best_fitness_hist else 0,
+            "best_fitness_achieved": best_fitness_overall if best_fitness_overall > -np.inf else None,
+            "best_fitness_final_gen": best_fitness_hist[-1] if best_fitness_hist else None,
+            "avg_fitness_final_gen": avg_fitness_hist[-1] if avg_fitness_hist else None,
+        },
+         "final_training_summary": training_summary,
+        "final_evaluation_on_test": final_metrics,
+        "saved_model_path": final_model_path
+    }
+    results_path = os.path.join(output_dir, "final_results.json")
+    try:
+        # JSON'a kaydederken NumPy türlerini dönüştür
+        def convert_numpy_types(obj):
+            if isinstance(obj, np.integer): return int(obj)
+            elif isinstance(obj, np.floating): return float(obj)
+            elif isinstance(obj, np.ndarray): return obj.tolist()
+            return obj
+        with open(results_path, 'w') as f:
+            json.dump(final_results, f, indent=4, default=convert_numpy_types) # default handler ekle
+        logging.info(f"Final results summary saved to {results_path}")
+    except Exception as e:
+        logging.error(f"Failed to save final results JSON: {e}", exc_info=True)
+
+    logging.info(f"========== Pipeline Run {run_name} Finished ==========")
+
+
+# --- Argüman Ayrıştırıcı ---
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="EvoNet Revised: Neuroevolution for Sorting Task")
+
+    # --- Dizinler ---
+    parser.add_argument('--output_base_dir', type=str, default=DEFAULT_OUTPUT_BASE_DIR,
+                        help='Base directory to store run results.')
+
+    # --- Veri Ayarları ---
+    parser.add_argument('--seq_length', type=int, default=DEFAULT_SEQ_LENGTH, help='Length of sequences.')
+    parser.add_argument('--train_samples', type=int, default=5000, help='Number of training samples.')
+    parser.add_argument('--test_samples', type=int, default=1000, help='Number of test samples.')
+
+    # --- Evrim Parametreleri ---
+    parser.add_argument('--pop_size', type=int, default=DEFAULT_POP_SIZE, help='Population size.')
+    parser.add_argument('--generations', type=int, default=DEFAULT_GENERATIONS, help='Number of generations.')
+    parser.add_argument('--mutation_rate', type=float, default=DEFAULT_MUTATION_RATE, help='Overall mutation probability.')
+    parser.add_argument('--weight_mut_rate', type=float, default=DEFAULT_WEIGHT_MUT_RATE, help='Weight mutation probability (if mutation occurs).')
+    parser.add_argument('--activation_mut_rate', type=float, default=DEFAULT_ACTIVATION_MUT_RATE, help='Activation mutation probability (if mutation occurs).')
+    parser.add_argument('--mutation_strength', type=float, default=DEFAULT_MUTATION_STRENGTH, help='Std dev for weight mutation noise.')
+    parser.add_argument('--tournament_size', type=int, default=DEFAULT_TOURNAMENT_SIZE, help='Number of individuals in tournament selection.')
+    parser.add_argument('--elitism_count', type=int, default=DEFAULT_ELITISM_COUNT, help='Number of elite individuals to carry over.')
+
+    # --- Eğitim ve Değerlendirme ---
+    parser.add_argument('--batch_size', type=int, default=DEFAULT_BATCH_SIZE, help='Batch size for predictions and final training.')
+    parser.add_argument('--epochs_final_train', type=int, default=DEFAULT_EPOCHS_FINAL_TRAIN, help='Max epochs for final training.')
+
+    # --- Tekrarlanabilirlik ---
+    parser.add_argument('--seed', type=int, default=None, help='Random seed (default: random).')
+
+    args = parser.parse_args()
+
+    # Varsayılan tohum ayarla (eğer verilmediyse)
+    if args.seed is None:
+        args.seed = random.randint(0, 2**32 - 1)
+        print(f"Generated random seed: {args.seed}") # Loglama başlamadan önce print et
+
+    return args
+
+
+# --- Ana Çalıştırma Bloğu ---
+if __name__ == "__main__":
+    # Argümanları ayrıştır
+    cli_args = parse_arguments()
+
+    # Ana iş akışını çalıştır
+    try:
+        run_pipeline(cli_args)
+    except SystemExit: # sys.exit() çağrılarını yakala ve normal çıkış yap
+        pass
+    except Exception as e:
+        # Loglama başlamamışsa bile hatayı yazdırmaya çalış
+        print(f"\nFATAL UNHANDLED ERROR in main execution block: {e}", file=sys.stderr)
+        # Loglama ayarlandıysa oraya da yaz
+        if logging.getLogger().hasHandlers():
+             logging.critical("FATAL UNHANDLED ERROR in main execution block:", exc_info=True)
+        else:
+             import traceback
+             print(traceback.format_exc(), file=sys.stderr)
+        sys.exit(1) # Hata kodu ile çık

v3.py

@@ -0,0 +1,784 @@
+# ==============================================================================
+# EvoNet Optimizer - v3 - Daha İleri İyileştirmeler
+# Açıklama: Çaprazlama, Kontrol Noktası eklenmiş, Adaptif Mutasyon ve
+# Gelişmiş Fitness için kavramsal öneriler içeren versiyon.
+# ==============================================================================
+
+import os
+import subprocess
+import sys
+import argparse
+import random
+import logging
+from datetime import datetime
+import json
+import pickle # Checkpointing için
+import time   # Checkpointing için
+from typing import List, Tuple, Dict, Any, Optional
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential, load_model, clone_model
+from tensorflow.keras.layers import Dense, Input
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
+import matplotlib.pyplot as plt
+from scipy.stats import kendalltau
+
+# --- Sabitler ve Varsayılan Değerler ---
+DEFAULT_SEQ_LENGTH = 10
+DEFAULT_POP_SIZE = 50
+DEFAULT_GENERATIONS = 50
+DEFAULT_CROSSOVER_RATE = 0.6      # Çaprazlama uygulama olasılığı
+DEFAULT_MUTATION_RATE = 0.4       # Mutasyon uygulama olasılığı (eğer çaprazlama olmazsa)
+DEFAULT_WEIGHT_MUT_RATE = 0.8
+DEFAULT_ACTIVATION_MUT_RATE = 0.2 # Aktivasyon mutasyonu hala deneysel
+DEFAULT_MUTATION_STRENGTH = 0.1
+DEFAULT_TOURNAMENT_SIZE = 5
+DEFAULT_ELITISM_COUNT = 2
+DEFAULT_EPOCHS_FINAL_TRAIN = 100
+DEFAULT_BATCH_SIZE = 64
+DEFAULT_OUTPUT_BASE_DIR = os.path.join(os.getcwd(), "evonet_runs_v3")
+DEFAULT_CHECKPOINT_INTERVAL = 10  # Kaç nesilde bir checkpoint alınacağı (0 = kapalı)
+
+# --- Loglama Ayarları ---
+# (setup_logging fonksiyonu öncekiyle aynı, tekrar eklemiyorum)
+def setup_logging(log_dir: str, log_level=logging.INFO) -> None:
+    log_filename = os.path.join(log_dir, 'evolution_run.log')
+    for handler in logging.root.handlers[:]: logging.root.removeHandler(handler)
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(levelname)-8s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_filename, mode='a'), # 'a' mode append for resuming
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    logging.info("Logging setup complete.")
+
+# --- GPU Kontrolü ---
+# (check_gpu fonksiyonu öncekiyle aynı, tekrar eklemiyorum)
+def check_gpu() -> bool:
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus:
+        try:
+            for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)
+            logical_gpus = tf.config.list_logical_devices('GPU')
+            logging.info(f"{len(gpus)} Physical GPUs, {len(logical_gpus)} Logical GPUs found.")
+            if logical_gpus: logging.info(f"Using GPU: {tf.config.experimental.get_device_details(gpus[0])['device_name']}")
+            return True
+        except RuntimeError as e:
+            logging.error(f"Error setting memory growth for GPU: {e}", exc_info=True)
+            return False
+    else:
+        logging.warning("GPU not found. Using CPU.")
+        return False
+
+# --- Veri Üretimi ---
+# (generate_data fonksiyonu öncekiyle aynı, tekrar eklemiyorum)
+def generate_data(num_samples: int, seq_length: int) -> Tuple[np.ndarray, np.ndarray]:
+    logging.info(f"Generating {num_samples} samples with sequence length {seq_length}...")
+    try:
+        X = np.random.rand(num_samples, seq_length).astype(np.float32) * 100
+        y = np.sort(X, axis=1).astype(np.float32)
+        logging.info("Data generation successful.")
+        return X, y
+    except Exception as e:
+        logging.error(f"Error during data generation: {e}", exc_info=True)
+        raise
+
+# --- Neuroevolution Çekirdeği ---
+
+def create_individual(seq_length: int, input_shape: Tuple) -> Sequential:
+    """Rastgele mimariye sahip bir Keras Sequential modeli oluşturur ve derler."""
+    # (Fonksiyon öncekiyle büyük ölçüde aynı, isim revize edildi)
+    try:
+        model = Sequential(name=f"model_rnd_{random.randint(10000, 99999)}")
+        num_hidden_layers = random.randint(1, 4)
+        neurons_per_layer = [random.randint(8, 64) for _ in range(num_hidden_layers)]
+        activations = [random.choice(['relu', 'tanh', 'sigmoid']) for _ in range(num_hidden_layers)]
+        model.add(Input(shape=input_shape))
+        for i in range(num_hidden_layers):
+            model.add(Dense(neurons_per_layer[i], activation=activations[i]))
+        model.add(Dense(seq_length, activation='linear'))
+        model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+        return model
+    except Exception as e:
+        logging.error(f"Error creating individual model: {e}", exc_info=True)
+        raise
+
+@tf.function
+def get_predictions(model: Sequential, X: tf.Tensor) -> tf.Tensor:
+    """Model tahminlerini tf.function kullanarak alır."""
+    return model(X, training=False)
+
+def calculate_fitness(individual: Sequential, X: np.ndarray, y: np.ndarray, batch_size: int, fitness_params: Dict = None) -> float:
+    """Bir bireyin fitness değerini hesaplar. Gelişmiş fitness için öneri içerir."""
+    # --- KAVRAMSAL: Gelişmiş Fitness Fonksiyonu ---
+    # Burada sadece MSE kullanılıyor. Daha gelişmiş bir fitness için:
+    # 1. Diğer metrikleri hesapla (örn: Kendall Tau).
+    # 2. Model karmaşıklığını hesapla (örn: parametre sayısı).
+    # 3. Bu değerleri ağırlıklı bir formülle birleştir.
+    # fitness_params = fitness_params or {}
+    # w_mse = fitness_params.get('w_mse', 1.0)
+    # w_tau = fitness_params.get('w_tau', 0.1)
+    # w_comp = fitness_params.get('w_comp', 0.0001)
+    # --------------------------------------------
+    if not isinstance(X, tf.Tensor): X = tf.cast(X, tf.float32)
+    if not isinstance(y, tf.Tensor): y = tf.cast(y, tf.float32)
+    try:
+        y_pred_tf = get_predictions(individual, X)
+        mse = tf.reduce_mean(tf.square(y - y_pred_tf))
+        mse_val = mse.numpy()
+        fitness_score = 1.0 / (mse_val + 1e-8) # Temel fitness
+
+        # --- KAVRAMSAL: Gelişmiş Fitness Hesabı ---
+        # if w_tau > 0 or w_comp > 0:
+        #     # Kendall Tau hesapla (maliyetli olabilir, örneklem gerekebilir)
+        #     tau_val = calculate_avg_kendall_tau(y.numpy(), y_pred_tf.numpy(), sample_size=100) # Örnek bir fonksiyon
+        #     # Karmaşıklık hesapla
+        #     complexity = individual.count_params()
+        #     # Birleştirilmiş fitness
+        #     fitness_score = w_mse * fitness_score + w_tau * tau_val - w_comp * complexity
+        # --------------------------------------------
+
+        if not np.isfinite(fitness_score) or fitness_score < -1e6: # Negatif olabilen fitness için kontrol
+            logging.warning(f"Non-finite or very low fitness ({fitness_score:.4g}) for model {individual.name}. Assigning minimal fitness.")
+            return -1e7 # Gelişmiş fitness negatif olabileceği için daha düşük sınır
+        return float(fitness_score)
+    except Exception as e:
+        logging.error(f"Error during fitness calculation for model {individual.name}: {e}", exc_info=True)
+        return -1e7
+
+# (Aktivasyon mutasyonu hala deneysel, ana odak ağırlık mutasyonunda)
+def mutate_individual(individual: Sequential, weight_mut_rate: float, mut_strength: float) -> Sequential:
+    """Bir bireye ağırlık bozulması mutasyonu uygular."""
+    try:
+        mutated_model = clone_model(individual)
+        mutated_model.set_weights(individual.get_weights())
+        mutated = False
+        if random.random() < weight_mut_rate: # Ağırlık mutasyon olasılığı (dışarıdan gelen genel rate ile birleştirilebilir)
+            mutated = True
+            for layer in mutated_model.layers:
+                if isinstance(layer, Dense) and layer.get_weights():
+                    weights_biases = layer.get_weights()
+                    new_weights_biases = [wb + np.random.normal(0, mut_strength, wb.shape).astype(np.float32) for wb in weights_biases]
+                    layer.set_weights(new_weights_biases)
+
+        if mutated:
+            mutated_model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+            mutated_model._name = f"mutated_{individual.name}_{random.randint(1000,9999)}"
+        return mutated_model
+    except Exception as e:
+        logging.error(f"Error during mutation of model {individual.name}: {e}", exc_info=True)
+        return individual
+
+
+def check_architecture_compatibility(model1: Sequential, model2: Sequential) -> bool:
+    """İki modelin basit çaprazlama için uyumlu olup olmadığını kontrol eder (katman sayısı ve tipleri)."""
+    if len(model1.layers) != len(model2.layers):
+        return False
+    for l1, l2 in zip(model1.layers, model2.layers):
+        if type(l1) != type(l2):
+            return False
+        # Daha detaylı kontrol (nöron sayısı vb.) eklenebilir, ancak basit tutalım.
+    return True
+
+def crossover_individuals(parent1: Sequential, parent2: Sequential) -> Tuple[Optional[Sequential], Optional[Sequential]]:
+    """İki ebeveynden basit ağırlık ortalaması/karıştırması ile çocuklar oluşturur."""
+    # Mimari uyumluluğunu kontrol et (basit versiyon)
+    if not check_architecture_compatibility(parent1, parent2):
+        logging.debug("Skipping crossover due to incompatible architectures.")
+        return None, None # Uyumsuzsa çaprazlama yapma
+
+    try:
+        # Çocukları ebeveynleri klonlayarak başlat
+        child1 = clone_model(parent1)
+        child2 = clone_model(parent2)
+        child1.set_weights(parent1.get_weights()) # Başlangıç ağırlıklarını ata
+        child2.set_weights(parent2.get_weights())
+
+        p1_weights = parent1.get_weights()
+        p2_weights = parent2.get_weights()
+        child1_new_weights = []
+        child2_new_weights = []
+
+        # Katman katman ağırlıkları çaprazla
+        for i in range(len(p1_weights)): # Ağırlık matrisleri/bias vektörleri üzerinde döngü
+            w1 = p1_weights[i]
+            w2 = p2_weights[i]
+            # Basit ortalama veya rastgele seçim (örnek: rastgele seçim)
+            mask = np.random.rand(*w1.shape) < 0.5
+            cw1 = np.where(mask, w1, w2)
+            cw2 = np.where(mask, w2, w1) # Ters maske ile
+            # Veya basit ortalama: cw1 = (w1 + w2) / 2.0; cw2 = cw1
+            child1_new_weights.append(cw1.astype(np.float32))
+            child2_new_weights.append(cw2.astype(np.float32))
+
+
+        child1.set_weights(child1_new_weights)
+        child2.set_weights(child2_new_weights)
+
+        # Çocukları derle
+        child1.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+        child2.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+        child1._name = f"xover_{parent1.name[:10]}_{parent2.name[:10]}_c1_{random.randint(1000,9999)}"
+        child2._name = f"xover_{parent1.name[:10]}_{parent2.name[:10]}_c2_{random.randint(1000,9999)}"
+        #logging.debug(f"Crossover performed between {parent1.name} and {parent2.name}")
+        return child1, child2
+
+    except Exception as e:
+        logging.error(f"Error during crossover between {parent1.name} and {parent2.name}: {e}", exc_info=True)
+        return None, None # Hata olursa çocuk üretme
+
+# (tournament_selection fonksiyonu öncekiyle aynı)
+def tournament_selection(population: List[Sequential], fitness_scores: List[float], k: int) -> Sequential:
+    if not population: raise ValueError("Population cannot be empty.")
+    if len(population) < k: k = len(population)
+    try:
+        tournament_indices = random.sample(range(len(population)), k)
+        tournament_fitness = [fitness_scores[i] for i in tournament_indices]
+        winner_local_idx = np.argmax(tournament_fitness)
+        winner_global_idx = tournament_indices[winner_local_idx]
+        return population[winner_global_idx]
+    except Exception as e:
+        logging.error(f"Error during tournament selection: {e}", exc_info=True)
+        return random.choice(population)
+
+# --- Checkpointing ---
+def save_checkpoint(output_dir: str, generation: int, population: List[Sequential], rnd_state: Tuple, np_rnd_state: Tuple, tf_rnd_state: Any):
+    """Evrim durumunu kaydeder."""
+    checkpoint_dir = os.path.join(output_dir, "checkpoints")
+    os.makedirs(checkpoint_dir, exist_ok=True)
+    checkpoint_file = os.path.join(checkpoint_dir, f"evo_gen_{generation}.pkl")
+    logging.info(f"Saving checkpoint for generation {generation} to {checkpoint_file}...")
+    try:
+        # Modelleri kaydetmek için ağırlıkları ve konfigürasyonları al
+        population_state = []
+        for model in population:
+            try:
+                 # Önce modeli diske kaydetmeyi dene (daha sağlam olabilir ama yavaş)
+                 # model_path = os.path.join(checkpoint_dir, f"model_gen{generation}_{model.name}.keras")
+                 # model.save(model_path)
+                 # population_state.append({"config": model.get_config(), "saved_path": model_path})
+
+                 # Alternatif: Ağırlık ve config'i pickle içine göm (daha riskli)
+                 population_state.append({
+                     "name": model.name,
+                     "config": model.get_config(),
+                     "weights": model.get_weights()
+                 })
+            except Exception as e:
+                 logging.error(f"Could not serialize model {model.name} for checkpoint: {e}")
+                 population_state.append(None) # Hata durumunda None ekle
+
+        state = {
+            "generation": generation,
+            "population_state": [p for p in population_state if p is not None], # Başarısız olanları çıkarma
+            "random_state": rnd_state,
+            "numpy_random_state": np_rnd_state,
+            "tensorflow_random_state": tf_rnd_state, # TensorFlow state'i pickle ile kaydetmek sorunlu olabilir
+            "timestamp": datetime.now().isoformat()
+        }
+        with open(checkpoint_file, 'wb') as f:
+            pickle.dump(state, f)
+        logging.info(f"Checkpoint saved successfully for generation {generation}.")
+    except Exception as e:
+        logging.error(f"Failed to save checkpoint for generation {generation}: {e}", exc_info=True)
+
+
+def load_checkpoint(checkpoint_path: str) -> Optional[Dict]:
+    """Kaydedilmiş evrim durumunu yükler."""
+    if not os.path.exists(checkpoint_path):
+        logging.error(f"Checkpoint file not found: {checkpoint_path}")
+        return None
+    logging.info(f"Loading checkpoint from {checkpoint_path}...")
+    try:
+        with open(checkpoint_path, 'rb') as f:
+            state = pickle.load(f)
+
+        population = []
+        for model_state in state["population_state"]:
+            try:
+                # Eğer model ayrı kaydedildiyse:
+                # model = load_model(model_state["saved_path"])
+                # population.append(model)
+
+                # Pickle içine gömüldüyse:
+                model = Sequential.from_config(model_state["config"])
+                model.set_weights(model_state["weights"])
+                # Modelin yeniden derlenmesi GEREKİR!
+                model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+                model._name = model_state.get("name", f"model_loaded_{random.randint(1000,9999)}") # İsmi geri yükle
+                population.append(model)
+            except Exception as e:
+                logging.error(f"Failed to load model state from checkpoint for model {model_state.get('name', 'UNKNOWN')}: {e}")
+
+        # Sadece başarıyla yüklenen modelleri al
+        state["population"] = population
+        if not population:
+             logging.error("Failed to load any model from the checkpoint population state.")
+             return None # Hiç model yüklenemediyse checkpoint geçersiz
+
+        logging.info(f"Checkpoint loaded successfully. Resuming from generation {state['generation'] + 1}.")
+        return state
+    except Exception as e:
+        logging.error(f"Failed to load checkpoint from {checkpoint_path}: {e}", exc_info=True)
+        return None
+
+def find_latest_checkpoint(output_dir: str) -> Optional[str]:
+     """Verilen klasördeki en son checkpoint dosyasını bulur."""
+     checkpoint_dir = os.path.join(output_dir, "checkpoints")
+     if not os.path.isdir(checkpoint_dir):
+          return None
+     checkpoints = [f for f in os.listdir(checkpoint_dir) if f.startswith("evo_gen_") and f.endswith(".pkl")]
+     if not checkpoints:
+          return None
+     # Dosya adından nesil numarasını çıkar ve en yükseğini bul
+     latest_gen = -1
+     latest_file = None
+     for cp in checkpoints:
+          try:
+               gen_num = int(cp.split('_')[2].split('.')[0])
+               if gen_num > latest_gen:
+                    latest_gen = gen_num
+                    latest_file = os.path.join(checkpoint_dir, cp)
+          except (IndexError, ValueError):
+               logging.warning(f"Could not parse generation number from checkpoint file: {cp}")
+               continue
+     return latest_file
+
+
+# --- Ana Evrim Döngüsü (Checkpoint ve Crossover ile) ---
+def evolve_population_v3(population: List[Sequential], X: np.ndarray, y: np.ndarray, start_generation: int, total_generations: int,
+                      crossover_rate: float, mutation_rate: float, weight_mut_rate: float, mut_strength: float,
+                      tournament_size: int, elitism_count: int, batch_size: int,
+                      output_dir: str, checkpoint_interval: int) -> Tuple[Optional[Sequential], List[float], List[float]]:
+    """Evrimsel süreci çalıştırır (Checkpoint ve Crossover içerir)."""
+    best_fitness_history = []
+    avg_fitness_history = []
+    best_model_overall = None
+    best_fitness_overall = -np.inf
+
+    X_tf = tf.cast(X, tf.float32)
+    y_tf = tf.cast(y, tf.float32)
+
+    # --- KAVRAMSAL: Uyarlanabilir Mutasyon Oranı ---
+    # current_mutation_rate = mutation_rate # Başlangıç değeri
+    # stagnation_counter = 0
+    # --------------------------------------------
+
+    for gen in range(start_generation, total_generations):
+        generation_start_time = datetime.now()
+        # 1. Fitness Değerlendirme
+        try:
+            fitness_scores = [calculate_fitness(ind, X_tf, y_tf, batch_size) for ind in population]
+        except Exception as e:
+            logging.critical(f"Error calculating fitness for population in Generation {gen+1}: {e}", exc_info=True)
+            if best_model_overall: return best_model_overall, best_fitness_history, avg_fitness_history
+            else: raise
+
+        # 2. İstatistikler ve En İyiyi Takip
+        current_best_idx = np.argmax(fitness_scores)
+        current_best_fitness = fitness_scores[current_best_idx]
+        avg_fitness = np.mean(fitness_scores)
+        best_fitness_history.append(current_best_fitness)
+        avg_fitness_history.append(avg_fitness)
+
+        new_best_found = False
+        if current_best_fitness > best_fitness_overall:
+            best_fitness_overall = current_best_fitness
+            new_best_found = True
+            try:
+                best_model_overall = clone_model(population[current_best_idx])
+                best_model_overall.set_weights(population[current_best_idx].get_weights())
+                best_model_overall.compile(optimizer=Adam(), loss='mse')
+                logging.info(f"Generation {gen+1}: *** New overall best fitness found: {best_fitness_overall:.6f} ***")
+            except Exception as e:
+                 logging.error(f"Could not clone new best model: {e}", exc_info=True)
+                 best_fitness_overall = current_best_fitness # Sadece fitness'ı güncelle
+
+        generation_time = (datetime.now() - generation_start_time).total_seconds()
+        logging.info(f"Generation {gen+1}/{total_generations} | Best Fitness: {current_best_fitness:.6f} | Avg Fitness: {avg_fitness:.6f} | Time: {generation_time:.2f}s")
+
+        # --- KAVRAMSAL: Uyarlanabilir Mutasyon Oranı Güncelleme ---
+        # if new_best_found:
+        #     stagnation_counter = 0
+        #     # current_mutation_rate = max(min_mutation_rate, current_mutation_rate * 0.98) # Azalt
+        # else:
+        #     stagnation_counter += 1
+        # if stagnation_counter > stagnation_limit:
+        #     # current_mutation_rate = min(max_mutation_rate, current_mutation_rate * 1.1) # Artır
+        #     stagnation_counter = 0 # Sayacı sıfırla
+        # logging.debug(f"Current mutation rate: {current_mutation_rate:.4f}")
+        # --------------------------------------------
+
+        # 3. Yeni Popülasyon Oluşturma
+        new_population = []
+
+        # 3a. Elitizm
+        if elitism_count > 0 and len(population) >= elitism_count:
+            try:
+                elite_indices = np.argsort(fitness_scores)[-elitism_count:]
+                for idx in elite_indices:
+                    elite_clone = clone_model(population[idx])
+                    elite_clone.set_weights(population[idx].get_weights())
+                    elite_clone.compile(optimizer=Adam(), loss='mse')
+                    new_population.append(elite_clone)
+            except Exception as e:
+                 logging.error(f"Error during elitism: {e}", exc_info=True)
+
+
+        # 3b. Seçilim, Çaprazlama ve Mutasyon
+        num_to_generate = len(population) - len(new_population)
+        generated_count = 0
+        while generated_count < num_to_generate:
+            try:
+                # İki ebeveyn seç
+                parent1 = tournament_selection(population, fitness_scores, tournament_size)
+                parent2 = tournament_selection(population, fitness_scores, tournament_size)
+
+                child1, child2 = None, None # Çocukları başlat
+
+                # Çaprazlama uygula (belirli bir olasılıkla)
+                if random.random() < crossover_rate and parent1 is not parent2:
+                    child1, child2 = crossover_individuals(parent1, parent2)
+
+                # Eğer çaprazlama yapılmadıysa veya başarısız olduysa, mutasyonla devam et
+                if child1 is None: # İlk çocuk oluşmadıysa
+                    # Ebeveynlerden birini mutasyona uğrat
+                     parent_to_mutate = parent1 # Veya parent2 veya rastgele biri
+                     if random.random() < mutation_rate: # Genel mutasyon oranı kontrolü
+                           child1 = mutate_individual(parent_to_mutate, weight_mut_rate, mut_strength)
+                     else: # Mutasyon da olmazsa, ebeveyni klonla
+                           child1 = clone_model(parent_to_mutate); child1.set_weights(parent_to_mutate.get_weights())
+                           child1.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+                           child1._name = f"cloned_{parent_to_mutate.name}_{random.randint(1000,9999)}"
+
+                    # Yeni popülasyona ekle
+                    if child1:
+                         new_population.append(child1)
+                         generated_count += 1
+                         if generated_count >= num_to_generate: break # Gerekli sayıya ulaşıldıysa çık
+
+                else: # Çaprazlama başarılı olduysa (child1 ve child2 var)
+                     # Çaprazlama sonrası çocuklara ayrıca mutasyon uygulama seçeneği eklenebilir
+                     # if random.random() < post_crossover_mutation_rate: child1 = mutate(...)
+                     # if random.random() < post_crossover_mutation_rate: child2 = mutate(...)
+
+                     new_population.append(child1)
+                     generated_count += 1
+                     if generated_count >= num_to_generate: break
+
+                     if child2: # İkinci çocuk da varsa ekle
+                          new_population.append(child2)
+                          generated_count += 1
+                          if generated_count >= num_to_generate: break
+
+            except Exception as e:
+                logging.error(f"Error during selection/reproduction cycle: {e}", exc_info=True)
+                if generated_count < num_to_generate: # Eksik kalırsa rastgele doldur
+                    logging.warning("Adding random individual due to reproduction error.")
+                    new_population.append(create_individual(y.shape[1], X.shape[1:]))
+                    generated_count += 1
+
+        population = new_population[:len(population)] # Popülasyon boyutunu garantile
+
+        # 4. Checkpoint Alma
+        if checkpoint_interval > 0 and (gen + 1) % checkpoint_interval == 0:
+            try:
+                # Rastgele durumları al
+                rnd_state = random.getstate()
+                np_rnd_state = np.random.get_state()
+                # tf_rnd_state = tf.random.get_global_generator().state # TF state kaydetmek zor olabilir
+                tf_rnd_state = None # Şimdilik None
+                save_checkpoint(output_dir, gen + 1, population, rnd_state, np_rnd_state, tf_rnd_state)
+            except Exception as e:
+                 logging.error(f"Failed to execute checkpoint saving for generation {gen+1}: {e}", exc_info=True)
+
+
+    # Döngü sonu
+    if best_model_overall is None and population:
+         logging.warning("No overall best model tracked. Returning best from final population.")
+         final_fitness_scores = [calculate_fitness(ind, X_tf, y_tf, batch_size) for ind in population]
+         best_idx_final = np.argmax(final_fitness_scores)
+         best_model_overall = population[best_idx_final]
+    elif not population:
+         logging.error("Evolution finished with an empty population!")
+         return None, best_fitness_history, avg_fitness_history
+
+    logging.info(f"Evolution finished. Best fitness achieved: {best_fitness_overall:.6f}")
+    return best_model_overall, best_fitness_history, avg_fitness_history
+
+# --- Grafik Çizimi (Öncekiyle aynı) ---
+def plot_fitness_history(history_best: List[float], history_avg: List[float], output_dir: str) -> None:
+    if not history_best or not history_avg:
+        logging.warning("Fitness history is empty, cannot plot.")
+        return
+    try:
+        plt.figure(figsize=(12, 7)); plt.plot(history_best, label="Best Fitness", marker='o', linestyle='-', linewidth=2)
+        plt.plot(history_avg, label="Average Fitness", marker='x', linestyle='--', alpha=0.7); plt.xlabel("Generation")
+        plt.ylabel("Fitness Score"); plt.title("Evolutionary Fitness History"); plt.legend(); plt.grid(True); plt.tight_layout()
+        plot_path = os.path.join(output_dir, "fitness_history.png"); plt.savefig(plot_path); plt.close()
+        logging.info(f"Fitness history plot saved to {plot_path}")
+    except Exception as e: logging.error(f"Error plotting fitness history: {e}", exc_info=True)
+
+# --- Değerlendirme (Öncekiyle aynı) ---
+def evaluate_model(model: Sequential, X_test: np.ndarray, y_test: np.ndarray, batch_size: int) -> Dict[str, float]:
+    if model is None: return {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+    logging.info("Evaluating final model on test data...")
+    try:
+        y_pred = model.predict(X_test, batch_size=batch_size, verbose=0)
+        test_mse = np.mean(np.square(y_test - y_pred))
+        logging.info(f"Final Test MSE: {test_mse:.6f}")
+        sample_size = min(500, X_test.shape[0]); taus = []; indices = np.random.choice(X_test.shape[0], sample_size, replace=False)
+        for i in indices:
+            try: tau, _ = kendalltau(y_test[i], y_pred[i]);
+            if not np.isnan(tau): taus.append(tau)
+            except ValueError: pass # Handle constant prediction case
+        avg_kendall_tau = np.mean(taus) if taus else 0.0
+        logging.info(f"Average Kendall's Tau (on {sample_size} samples): {avg_kendall_tau:.4f}")
+        return {"test_mse": float(test_mse), "avg_kendall_tau": float(avg_kendall_tau)}
+    except Exception as e:
+        logging.error(f"Error during final model evaluation: {e}", exc_info=True)
+        return {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+
+# --- Ana İş Akışı (Checkpoint Yükleme ile) ---
+def run_pipeline_v3(args: argparse.Namespace):
+    """Checkpoint ve Crossover içeren ana iş akışı."""
+
+    # Çalıştırma adı ve çıktı klasörü
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_name = f"evorun_{timestamp}_gen{args.generations}_pop{args.pop_size}"
+    # Eğer resume path verilmişse, o klasörü kullan
+    output_dir = args.resume_from if args.resume_from else os.path.join(args.output_base_dir, run_name)
+    resume_run = bool(args.resume_from)
+    if resume_run:
+         run_name = os.path.basename(output_dir) # Klasör adını kullan
+         logging.info(f"Attempting to resume run from: {output_dir}")
+    else:
+         try: os.makedirs(output_dir, exist_ok=True)
+         except OSError as e: print(f"FATAL: Could not create output directory: {output_dir}. Error: {e}", file=sys.stderr); sys.exit(1)
+
+    # Loglamayı ayarla ('a' modu ile devam etmeye uygun)
+    setup_logging(output_dir)
+    logging.info(f"========== Starting/Resuming EvoNet Pipeline Run: {run_name} ==========")
+    logging.info(f"Output directory: {output_dir}")
+
+    # --- Checkpoint Yükleme ---
+    start_generation = 0
+    population = []
+    initial_state_loaded = False
+    latest_checkpoint_path = find_latest_checkpoint(output_dir) if resume_run else None
+
+    if latest_checkpoint_path:
+        loaded_state = load_checkpoint(latest_checkpoint_path)
+        if loaded_state:
+            start_generation = loaded_state['generation'] # Kaldığı nesilden başla
+            population = loaded_state['population']
+            # Rastgele durumları geri yükle
+            try:
+                random.setstate(loaded_state['random_state'])
+                np.random.set_state(loaded_state['numpy_random_state'])
+                # tf.random.set_global_generator(tf.random.Generator.from_state(loaded_state['tensorflow_random_state'])) # TF state sorunlu olabilir
+                logging.info(f"Random states restored from checkpoint.")
+            except Exception as e:
+                 logging.warning(f"Could not fully restore random states from checkpoint: {e}")
+            initial_state_loaded = True
+            logging.info(f"Resuming from Generation {start_generation + 1} with {len(population)} individuals.")
+        else:
+             logging.error("Failed to load checkpoint. Starting from scratch.")
+             resume_run = False # Checkpoint yüklenemediyse sıfırdan başla
+    elif resume_run:
+         logging.warning(f"Resume requested but no valid checkpoint found in {output_dir}. Starting from scratch.")
+         resume_run = False # Checkpoint yoksa sıfırdan başla
+
+
+    # --- Sıfırdan Başlama veya Devam Etme Ayarları ---
+    if not initial_state_loaded:
+        # Argümanları logla ve kaydet (sadece sıfırdan başlarken)
+        logging.info("--- Configuration ---")
+        args_dict = vars(args)
+        for k, v in args_dict.items(): logging.info(f"  {k:<20}: {v}")
+        logging.info("---------------------")
+        config_path = os.path.join(output_dir, "config.json")
+        try:
+            with open(config_path, 'w') as f: json.dump(args_dict, f, indent=4, sort_keys=True)
+            logging.info(f"Configuration saved to {config_path}")
+        except Exception as e: logging.error(f"Failed to save configuration: {e}", exc_info=True)
+
+        # Rastgele tohumları ayarla
+        try:
+            random.seed(args.seed); np.random.seed(args.seed); tf.random.set_seed(args.seed)
+            logging.info(f"Using random seed: {args.seed}")
+        except Exception as e: logging.warning(f"Could not set all random seeds: {e}")
+
+        # GPU kontrolü
+        is_gpu_available = check_gpu()
+
+        # Veri Üretimi
+        try:
+            X_train, y_train = generate_data(args.train_samples, args.seq_length)
+            X_test, y_test = generate_data(args.test_samples, args.seq_length)
+            input_shape = X_train.shape[1:]
+        except Exception: logging.critical("Failed to generate data. Exiting."); sys.exit(1)
+
+        # Popülasyon Başlatma
+        logging.info(f"--- Initializing Population (Size: {args.pop_size}) ---")
+        try:
+            population = [create_individual(args.seq_length, input_shape) for _ in range(args.pop_size)]
+            logging.info("Population initialized successfully.")
+        except Exception: logging.critical("Failed to initialize population. Exiting."); sys.exit(1)
+    else:
+         # Checkpoint'ten devam ediliyorsa, veriyi yeniden üretmemiz gerekebilir
+         # veya checkpoint'e veriyi de dahil edebiliriz (büyük olabilir).
+         # Şimdilik veriyi yeniden üretelim.
+         logging.info("Reloading data for resumed run...")
+         is_gpu_available = check_gpu() # GPU durumunu tekrar kontrol et
+         try:
+            X_train, y_train = generate_data(args.train_samples, args.seq_length)
+            X_test, y_test = generate_data(args.test_samples, args.seq_length)
+         except Exception: logging.critical("Failed to reload data for resumed run. Exiting."); sys.exit(1)
+         # Config dosyasını tekrar okuyup loglayabiliriz
+         config_path = os.path.join(output_dir, "config.json")
+         try:
+              with open(config_path, 'r') as f: args_dict = json.load(f)
+              logging.info("--- Loaded Configuration (from resumed run) ---")
+              for k, v in args_dict.items(): logging.info(f"  {k:<20}: {v}")
+              logging.info("-----------------------------------------------")
+         except Exception as e:
+              logging.warning(f"Could not reload config.json: {e}")
+              args_dict = vars(args) # Argümanları kullan
+
+
+    # Evrim Süreci
+    logging.info(f"--- Starting/Resuming Evolution ({args.generations} Total Generations) ---")
+    if start_generation >= args.generations:
+         logging.warning(f"Loaded checkpoint generation ({start_generation}) is already >= total generations ({args.generations}). Skipping evolution.")
+         best_model_unevolved = population[0] if population else None # En iyi modeli checkpoint'ten almaya çalışmak lazım
+         best_fitness_hist, avg_fitness_hist = [], [] # Geçmişi de yüklemek lazım
+         # TODO: Checkpoint'ten en iyi modeli ve geçmişi de yükle
+         # Şimdilik basitleştirilmiş - evrim atlanıyor
+    else:
+        try:
+            best_model_unevolved, best_fitness_hist, avg_fitness_hist = evolve_population_v3(
+                population, X_train, y_train, start_generation, args.generations,
+                args.crossover_rate, args.mutation_rate, args.weight_mut_rate, args.mutation_strength,
+                args.tournament_size, args.elitism_count, args.batch_size,
+                output_dir, args.checkpoint_interval
+            )
+        except Exception as e:
+            logging.critical(f"Fatal error during evolution process: {e}", exc_info=True)
+            sys.exit(1)
+    logging.info("--- Evolution Complete ---")
+
+    # (Fitness geçmişini kaydetme ve çizdirme - öncekiyle aynı)
+    if best_fitness_hist or avg_fitness_hist: # Sadece listeler boş değilse
+        # Geçmişi de checkpoint'ten yükleyip birleştirmek gerekebilir.
+        # Şimdilik sadece bu çalıştırmadaki kısmı kaydediyoruz/çizdiriyoruz.
+        # TODO: Checkpoint'ten yüklenen geçmişle birleştir.
+        plot_fitness_history(best_fitness_hist, avg_fitness_hist, output_dir)
+        history_path = os.path.join(output_dir, "fitness_history_run.csv") # Farklı isim?
+        try:
+            history_data = np.array([np.arange(start_generation + 1, start_generation + len(best_fitness_hist) + 1), best_fitness_hist, avg_fitness_hist]).T
+            np.savetxt(history_path, history_data, delimiter=',', header='Generation,BestFitness,AvgFitness', comments='', fmt=['%d', '%.8f', '%.8f'])
+            logging.info(f"Fitness history (this run) saved to {history_path}")
+        except Exception as e: logging.error(f"Could not save fitness history data: {e}")
+    else: logging.warning("Fitness history is empty, skipping saving/plotting.")
+
+    # (En iyi modelin son eğitimi, değerlendirme ve sonuç kaydı - öncekiyle aynı)
+    if best_model_unevolved is None:
+        logging.error("Evolution did not yield a best model. Skipping final training and evaluation.")
+        final_metrics = {"test_mse": np.inf, "avg_kendall_tau": 0.0}; final_model_path = None; training_summary = {}
+    else:
+        logging.info("--- Starting Final Training of Best Evolved Model ---")
+        try:
+            final_model = clone_model(best_model_unevolved); final_model.set_weights(best_model_unevolved.get_weights())
+            final_model.compile(optimizer=Adam(learning_rate=0.001), loss='mse', metrics=['mae'])
+            logging.info("Model Summary of Best Evolved (Untrained):"); final_model.summary(print_fn=logging.info)
+            early_stopping = EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True, verbose=1)
+            reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.3, patience=7, min_lr=1e-7, verbose=1)
+            history = final_model.fit(X_train, y_train, epochs=args.epochs_final_train, batch_size=args.batch_size, validation_split=0.2, callbacks=[early_stopping, reduce_lr], verbose=2)
+            logging.info("Final training complete.")
+            training_summary = {"epochs_run": len(history.history['loss']), "final_train_loss": history.history['loss'][-1], "final_val_loss": history.history['val_loss'][-1]}
+            final_metrics = evaluate_model(final_model, X_test, y_test, args.batch_size)
+            final_model_path = os.path.join(output_dir, "best_evolved_model_trained.keras")
+            final_model.save(final_model_path); logging.info(f"Final trained model saved to {final_model_path}")
+        except Exception as e:
+             logging.error(f"Error during final training or evaluation: {e}", exc_info=True)
+             final_metrics = {"test_mse": np.inf, "avg_kendall_tau": 0.0}; final_model_path = None; training_summary = {"error": str(e)}
+
+    logging.info("--- Saving Final Results ---")
+    final_results = { # ... (öncekiyle aynı sonuç yapısı) ...
+        "run_info": {"run_name": run_name, "timestamp": timestamp, "output_directory": output_dir, "gpu_used": is_gpu_available, "resumed": resume_run},
+        "config": args_dict,
+        "evolution_summary": { # TODO: Checkpoint'ten yüklenen geçmişle birleştirilmeli
+            "generations_run_this_session": len(best_fitness_hist) if best_fitness_hist else 0,
+            "best_fitness_achieved_overall": best_fitness_overall if best_fitness_overall > -np.inf else None,
+            "best_fitness_final_gen": best_fitness_hist[-1] if best_fitness_hist else None,
+            "avg_fitness_final_gen": avg_fitness_hist[-1] if avg_fitness_hist else None, },
+        "final_training_summary": training_summary, "final_evaluation_on_test": final_metrics, "saved_model_path": final_model_path }
+    results_path = os.path.join(output_dir, "final_results.json")
+    try:
+        def convert_numpy_types(obj):
+            if isinstance(obj, np.integer): return int(obj)
+            elif isinstance(obj, np.floating): return float(obj)
+            elif isinstance(obj, np.ndarray): return obj.tolist()
+            return obj
+        with open(results_path, 'w') as f: json.dump(final_results, f, indent=4, default=convert_numpy_types)
+        logging.info(f"Final results summary saved to {results_path}")
+    except Exception as e: logging.error(f"Failed to save final results JSON: {e}", exc_info=True)
+
+    logging.info(f"========== Pipeline Run {run_name} Finished ==========")
+
+
+# --- Argüman Ayrıştırıcı (Yeni Argümanlar Eklendi) ---
+def parse_arguments_v3() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="EvoNet v3: Neuroevolution with Crossover & Checkpointing")
+
+    # --- Dizinler ve Kontrol ---
+    parser.add_argument('--output_base_dir', type=str, default=DEFAULT_OUTPUT_BASE_DIR, help='Base directory for new runs.')
+    parser.add_argument('--resume_from', type=str, default=None, help='Path to a previous run directory to resume from.')
+    parser.add_argument('--checkpoint_interval', type=int, default=DEFAULT_CHECKPOINT_INTERVAL, help='Save checkpoint every N generations (0 to disable).')
+
+    # --- Veri Ayarları ---
+    parser.add_argument('--seq_length', type=int, default=DEFAULT_SEQ_LENGTH, help='Length of sequences.')
+    parser.add_argument('--train_samples', type=int, default=5000, help='Number of training samples.')
+    parser.add_argument('--test_samples', type=int, default=1000, help='Number of test samples.')
+
+    # --- Evrim Parametreleri ---
+    parser.add_argument('--pop_size', type=int, default=DEFAULT_POP_SIZE, help='Population size.')
+    parser.add_argument('--generations', type=int, default=DEFAULT_GENERATIONS, help='Total number of generations.')
+    parser.add_argument('--crossover_rate', type=float, default=DEFAULT_CROSSOVER_RATE, help='Probability of applying crossover.')
+    parser.add_argument('--mutation_rate', type=float, default=DEFAULT_MUTATION_RATE, help='Probability of applying mutation (if crossover is not applied).')
+    parser.add_argument('--weight_mut_rate', type=float, default=DEFAULT_WEIGHT_MUT_RATE, help='Weight mutation probability within mutation.')
+    # parser.add_argument('--activation_mut_rate', type=float, default=DEFAULT_ACTIVATION_MUT_RATE, help='Activation mutation probability (experimental).')
+    parser.add_argument('--mutation_strength', type=float, default=DEFAULT_MUTATION_STRENGTH, help='Std dev for weight mutation noise.')
+    parser.add_argument('--tournament_size', type=int, default=DEFAULT_TOURNAMENT_SIZE, help='Tournament selection size.')
+    parser.add_argument('--elitism_count', type=int, default=DEFAULT_ELITISM_COUNT, help='Number of elite individuals.')
+
+    # --- Eğitim ve Değerlendirme ---
+    parser.add_argument('--batch_size', type=int, default=DEFAULT_BATCH_SIZE, help='Batch size.')
+    parser.add_argument('--epochs_final_train', type=int, default=DEFAULT_EPOCHS_FINAL_TRAIN, help='Max epochs for final training.')
+
+    # --- Tekrarlanabilirlik ---
+    parser.add_argument('--seed', type=int, default=None, help='Random seed (default: random).')
+
+    args = parser.parse_args()
+    if args.seed is None: args.seed = random.randint(0, 2**32 - 1); print(f"Generated random seed: {args.seed}")
+    # Basit kontrol: Crossover + Mutation oranı > 1 olmamalı (teknik olarak olabilir ama mantık gereği biri seçilmeli)
+    # if args.crossover_rate + args.mutation_rate > 1.0: logging.warning("Sum of crossover and mutation rates exceeds 1.0")
+    return args
+
+
+# --- Ana Çalıştırma Bloğu ---
+if __name__ == "__main__":
+    cli_args = parse_arguments_v3()
+    try:
+        run_pipeline_v3(cli_args)
+    except SystemExit: pass
+    except Exception as e:
+        print(f"\nFATAL UNHANDLED ERROR in main execution block: {e}", file=sys.stderr)
+        if logging.getLogger().hasHandlers(): logging.critical("FATAL UNHANDLED ERROR:", exc_info=True)
+        else: import traceback; print(traceback.format_exc(), file=sys.stderr)
+        sys.exit(1)