Upload 5 files

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

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)

v4.py

@@ -0,0 +1,1327 @@
+# ==============================================================================
+# EvoNet Optimizer - v4 - PyTorch Tabanlı Geliştirilmiş Sürüm
+# Açıklama: TensorFlow'dan PyTorch'a geçiş yapılmış, modern PyTorch
+#           pratikleri kullanılmış, esneklik artırılmış, kod kalitesi
+#           iyileştirilmiş ve PyTorch ekosistemine uygun hale getirilmiştir.
+#           Çaprazlama, Kontrol Noktası, Adaptif Mutasyon (kavramsal) ve
+#           Gelişmiş Fitness (kavramsal) özellikleri korunmuştur.
+# ==============================================================================
+
+import os
+import subprocess
+import sys
+import argparse
+import random
+import logging
+from datetime import datetime
+import json
+import copy # Model klonlama ve durum dikteleri için
+import time
+from typing import List, Tuple, Dict, Any, Optional, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import TensorDataset, DataLoader
+import matplotlib.pyplot as plt
+from scipy.stats import kendalltau # Hala numpy/scipy kullanıyoruz
+
+# --- Sabitler ve Varsayılan Değerler ---
+DEFAULT_SEQ_LENGTH = 10
+DEFAULT_POP_SIZE = 50
+DEFAULT_GENERATIONS = 50
+DEFAULT_CROSSOVER_RATE = 0.6
+DEFAULT_MUTATION_RATE = 0.4 # Eğer çaprazlama olmazsa mutasyon olasılığı
+DEFAULT_WEIGHT_MUT_RATE = 0.8 # Ağırlık mutasyonu olasılığı (mutasyon içinde)
+# Aktivasyon mutasyonu PyTorch'ta daha farklı ele alınmalı, şimdilik odak ağırlıkta.
+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_v4_pytorch")
+DEFAULT_CHECKPOINT_INTERVAL = 10 # Nesil başına checkpoint (0 = kapalı)
+DEFAULT_DEVICE = "auto" # "auto", "cpu", "cuda"
+
+# --- 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_pytorch.log')
+    # Mevcut handler'ları temizle (özellikle tekrar çalıştırmalarda önemli)
+    for handler in logging.root.handlers[:]:
+        handler.close() # Önce kapat
+        logging.root.removeHandler(handler)
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(levelname)-8s [%(filename)s:%(lineno)d] - %(message)s', # Daha detaylı format
+        handlers=[
+            logging.FileHandler(log_filename, mode='a'), # append modu
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    logging.info("="*50)
+    logging.info("PyTorch EvoNet v4 Logging Başlatıldı.")
+    logging.info("="*50)
+
+# --- Cihaz (GPU/CPU) Ayarları ---
+def setup_device(requested_device: str) -> torch.device:
+    """ Kullanılabilir cihaza göre PyTorch cihazını ayarlar. """
+    if requested_device == "auto":
+        if torch.cuda.is_available():
+            device_name = "cuda"
+            logging.info(f"CUDA (GPU) kullanılabilir: {torch.cuda.get_device_name(0)}")
+        else:
+            device_name = "cpu"
+            logging.info("CUDA (GPU) bulunamadı. CPU kullanılacak.")
+    elif requested_device == "cuda":
+        if torch.cuda.is_available():
+            device_name = "cuda"
+            logging.info(f"CUDA (GPU) manuel olarak seçildi: {torch.cuda.get_device_name(0)}")
+        else:
+            logging.warning("CUDA (GPU) istendi ancak bulunamadı! CPU kullanılacak.")
+            device_name = "cpu"
+    else: # cpu veya geçersiz değer
+        device_name = "cpu"
+        logging.info("CPU manuel olarak seçildi veya geçersiz cihaz belirtildi.")
+
+    return torch.device(device_name)
+
+# --- Veri Üretimi ---
+# (generate_data fonksiyonu öncekiyle aynı, NumPy tabanlı)
+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:
+        # Veriyi float32 olarak üretmek PyTorch için genellikle daha iyidir
+        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
+
+# --- PyTorch Sinir Ağı Modeli ---
+class NeuralNetwork(nn.Module):
+    """ Dinamik olarak yapılandırılabilen basit bir PyTorch MLP modeli. """
+    def __init__(self, input_size: int, output_size: int, hidden_dims: List[int], activations: List[str]):
+        super().__init__()
+        self.input_size = input_size
+        self.output_size = output_size
+        self.hidden_dims = hidden_dims
+        self.activations_str = activations # Mimarinin string listesi (checkpoint için)
+
+        layers = []
+        last_dim = input_size
+        for i, h_dim in enumerate(hidden_dims):
+            layers.append(nn.Linear(last_dim, h_dim))
+            act_func_str = activations[i].lower()
+            if act_func_str == 'relu':
+                layers.append(nn.ReLU())
+            elif act_func_str == 'tanh':
+                layers.append(nn.Tanh())
+            elif act_func_str == 'sigmoid':
+                layers.append(nn.Sigmoid())
+            else:
+                logging.warning(f"Bilinmeyen aktivasyon '{activations[i]}', ReLU kullanılıyor.")
+                layers.append(nn.ReLU()) # Varsayılan
+            last_dim = h_dim
+
+        # Çıkış katmanı (genellikle lineer aktivasyon)
+        layers.append(nn.Linear(last_dim, output_size))
+
+        self.network = nn.Sequential(*layers)
+        self.architecture_id = self._generate_architecture_id() # Mimarinin özeti
+        # Modelin adını (ID'sini) oluşturma (opsiyonel, loglama için kullanışlı)
+        self.model_name = f"model_{self.architecture_id}_rnd{random.randint(10000, 99999)}"
+
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.network(x)
+
+    def get_architecture(self) -> Dict[str, Any]:
+        """ Model mimarisini döndürür (checkpointing için). """
+        return {
+            "input_size": self.input_size,
+            "output_size": self.output_size,
+            "hidden_dims": self.hidden_dims,
+            "activations": self.activations_str
+        }
+
+    def _generate_architecture_id(self) -> str:
+        """ Mimariden kısa bir kimlik üretir. """
+        h_dims_str = '_'.join(map(str, self.hidden_dims))
+        acts_str = ''.join([a[0].upper() for a in self.activations_str]) # R_T_S
+        return f"I{self.input_size}_H{h_dims_str}_A{acts_str}_O{self.output_size}"
+
+    # Eşitlik kontrolü mimari bazında yapılabilir
+    def __eq__(self, other):
+        if not isinstance(other, NeuralNetwork):
+            return NotImplemented
+        return self.get_architecture() == other.get_architecture()
+
+    def __hash__(self):
+         # Mimariyi temsil eden bir tuple oluştur ve hash'ini al
+         arch_tuple = (
+             self.input_size,
+             self.output_size,
+             tuple(self.hidden_dims),
+             tuple(self.activations_str)
+         )
+         return hash(arch_tuple)
+
+
+# --- Neuroevolution Çekirdeği (PyTorch) ---
+
+def create_individual_pytorch(input_size: int, output_size: int) -> NeuralNetwork:
+    """ Rastgele mimariye sahip bir PyTorch NeuralNetwork modeli oluşturur. """
+    try:
+        num_hidden_layers = random.randint(1, 4)
+        hidden_dims = [random.randint(16, 128) for _ in range(num_hidden_layers)] # Biraz daha geniş aralık
+        activations = [random.choice(['relu', 'tanh', 'sigmoid']) for _ in range(num_hidden_layers)]
+
+        model = NeuralNetwork(input_size, output_size, hidden_dims, activations)
+        # PyTorch'ta model oluşturulduktan sonra compile gerekmez.
+        # Ağırlıklar zaten rastgele başlatılır.
+        logging.debug(f"Created individual: {model.model_name}")
+        return model
+    except Exception as e:
+        logging.error(f"Error creating PyTorch individual model: {e}", exc_info=True)
+        raise
+
+# PyTorch için model kopyalama işlevi
+def clone_pytorch_model(model: NeuralNetwork, device: torch.device) -> NeuralNetwork:
+    """ Bir PyTorch modelini (mimari ve ağırlıklar) klonlar. """
+    try:
+        # 1. Aynı mimariyle yeni bir model oluştur
+        arch = model.get_architecture()
+        cloned_model = NeuralNetwork(**arch)
+        # 2. Orijinal modelin state_dict'ini kopyala
+        cloned_model.load_state_dict(copy.deepcopy(model.state_dict()))
+        # 3. Yeni modeli doğru cihaza taşı
+        cloned_model.to(device)
+        cloned_model.model_name = f"cloned_{model.model_name}_{random.randint(1000,9999)}"
+        logging.debug(f"Cloned model {model.model_name} to {cloned_model.model_name}")
+        return cloned_model
+    except Exception as e:
+        logging.error(f"Error cloning PyTorch model {model.model_name}: {e}", exc_info=True)
+        raise
+
+def calculate_fitness_pytorch(
+    individual: NeuralNetwork,
+    X: torch.Tensor,
+    y: torch.Tensor,
+    device: torch.device,
+    fitness_params: Optional[Dict] = None
+) -> float:
+    """ Bir bireyin fitness değerini PyTorch kullanarak hesaplar. """
+    # --- KAVRAMSAL: Gelişmiş Fitness Fonksiyonu (PyTorch ile uyumlu) ---
+    # fitness_params = fitness_params or {}
+    # w_mse = fitness_params.get('w_mse', 1.0)
+    # w_tau = fitness_params.get('w_tau', 0.1)  # Kendall Tau ağırlığı
+    # w_comp = fitness_params.get('w_comp', 0.0001) # Karmaşıklık cezası ağırlığı
+    # --------------------------------------------
+
+    individual.eval() # Modeli değerlendirme moduna al (dropout vs. etkisizleşir)
+    individual.to(device) # Modeli doğru cihaza taşı
+    X, y = X.to(device), y.to(device) # Veriyi doğru cihaza taşı
+
+    try:
+        with torch.no_grad(): # Gradyan hesaplamasını kapat (inferans için)
+            y_pred = individual(X)
+            # Temel Fitness: MSE (Mean Squared Error)
+            # loss_fn = nn.MSELoss()
+            # mse_val = loss_fn(y_pred, y).item()
+            # Alternatif manuel hesaplama:
+            mse_val = torch.mean((y_pred - y)**2).item()
+
+        # MSE sonsuz veya NaN ise minimum fitness ata
+        if not np.isfinite(mse_val):
+            logging.warning(f"Non-finite MSE ({mse_val}) for model {individual.model_name}. Assigning minimal fitness.")
+            return -1e9 # Çok düşük bir değer ata
+
+        # Temel Fitness (MSE'nin tersi, daha yüksek daha iyi)
+        fitness_score = 1.0 / (mse_val + 1e-9) # Sıfıra bölme hatasını önle
+
+        # --- KAVRAMSAL: Gelişmiş Fitness Hesabı ---
+        # if w_tau > 0 or w_comp > 0:
+        #     # Kendall Tau hesapla (NumPy'a çevirerek, maliyetli olabilir)
+        #     y_np = y.cpu().numpy()
+        #     y_pred_np = y_pred.cpu().numpy()
+        #     tau_val = calculate_avg_kendall_tau(y_np, y_pred_np, sample_size=100) # Örnek fonksiyon
+        #
+        #     # Karmaşıklık hesapla (parametre sayısı)
+        #     complexity = sum(p.numel() for p in individual.parameters() if p.requires_grad)
+        #
+        #     # Birleştirilmiş fitness (Örnek formül)
+        #     # MSE'yi minimize etmek istediğimiz için 1/MSE kullanıyoruz.
+        #     # Tau'yu maksimize etmek istiyoruz.
+        #     # Karmaşıklığı minimize etmek istiyoruz.
+        #     fitness_score = (w_mse * fitness_score) + (w_tau * tau_val) - (w_comp * complexity)
+        # --------------------------------------------
+
+        # Sonuçta yine de çok düşük veya sonsuz fitness kontrolü
+        if not np.isfinite(fitness_score) or fitness_score < -1e8:
+             logging.warning(f"Non-finite or very low final fitness ({fitness_score:.4g}) for model {individual.model_name}. Assigning minimal fitness.")
+             return -1e9
+
+        return float(fitness_score)
+
+    except Exception as e:
+        logging.error(f"Error during fitness calculation for model {individual.model_name}: {e}", exc_info=True)
+        return -1e9 # Hata durumunda çok düşük fitness
+
+
+def mutate_individual_pytorch(
+    individual: NeuralNetwork,
+    weight_mut_rate: float, # Bu parametre aslında ağırlıkların *ne kadarının* mutasyona uğrayacağını belirleyebilir
+    mutation_strength: float,
+    device: torch.device
+) -> NeuralNetwork:
+    """ Bir PyTorch bireyine ağırlık bozulması mutasyonu uygular. """
+    try:
+        # Önemli: Orijinal modeli değiştirmemek için klonla
+        mutated_model = clone_pytorch_model(individual, device)
+        mutated_model.model_name = f"mutated_{individual.model_name}_{random.randint(1000,9999)}"
+
+        mutated = False
+        # Modelin state_dict'i üzerinde değişiklik yap
+        state_dict = mutated_model.state_dict()
+        new_state_dict = copy.deepcopy(state_dict) # Derin kopya al
+
+        for name, param in new_state_dict.items():
+            # Sadece eğitilebilir ağırlık/bias tensörlerini değiştir
+            if param.requires_grad and random.random() < weight_mut_rate : # Her parametre için mutasyon olasılığı
+                 mutated = True
+                 # Gaussian gürültü ekle
+                 noise = torch.randn_like(param) * mutation_strength
+                 new_state_dict[name] = param + noise.to(param.device) # Gürültüyü doğru cihaza taşı
+
+        if mutated:
+            mutated_model.load_state_dict(new_state_dict)
+            logging.debug(f"Mutated model {individual.model_name} -> {mutated_model.model_name}")
+            return mutated_model
+        else:
+            # Mutasyon uygulanmadıysa, klonlanmış modeli (isim değiştirilmiş) döndür veya orijinali?
+            # Mantıksal olarak mutasyon fonksiyonu çağrıldıysa bir değişiklik beklenir.
+            # Eğer hiç parametre mutasyona uğramadıysa bile farklı bir obje döndürmek tutarlı olabilir.
+            logging.debug(f"Mutation applied to {individual.model_name}, but no weights changed based on rate.")
+            return mutated_model # Klonlanmış, potansiyel olarak ismi değişmiş modeli döndür
+
+    except Exception as e:
+        logging.error(f"Error during PyTorch mutation of model {individual.model_name}: {e}", exc_info=True)
+        # Hata durumunda orijinal bireyi döndürmek güvenli bir seçenek olabilir
+        # return individual
+        # Ancak evrimsel süreçte sorun yaratabilir, bu yüzden klonlanmışı döndürmek daha iyi
+        return clone_pytorch_model(individual, device) # Hata durumunda temiz klon döndür
+
+
+def check_architecture_compatibility_pytorch(model1: NeuralNetwork, model2: NeuralNetwork) -> bool:
+    """ İki PyTorch modelinin basit çaprazlama için uyumlu olup olmadığını kontrol eder. """
+    # Mimari bilgilerini karşılaştır
+    return model1.get_architecture() == model2.get_architecture()
+
+
+def crossover_individuals_pytorch(
+    parent1: NeuralNetwork,
+    parent2: NeuralNetwork,
+    device: torch.device
+) -> Tuple[Optional[NeuralNetwork], Optional[NeuralNetwork]]:
+    """ İki PyTorch ebeveynden basit ağırlık ortalaması/karıştırması ile çocuklar oluşturur. """
+
+    # 1. Mimari uyumluluğunu kontrol et
+    if not check_architecture_compatibility_pytorch(parent1, parent2):
+        logging.debug(f"Skipping crossover between {parent1.model_name} and {parent2.model_name} due to incompatible architectures.")
+        return None, None
+
+    try:
+        # 2. Çocuklar için yeni model örnekleri oluştur (aynı mimariyle)
+        arch = parent1.get_architecture() # İkisi de aynı mimariye sahip
+        child1 = NeuralNetwork(**arch).to(device)
+        child2 = NeuralNetwork(**arch).to(device)
+        child1.model_name = f"xover_{parent1.architecture_id}_c1_{random.randint(1000,9999)}"
+        child2.model_name = f"xover_{parent1.architecture_id}_c2_{random.randint(1000,9999)}"
+
+
+        # 3. Ebeveynlerin state_dict'lerini al
+        p1_state = parent1.state_dict()
+        p2_state = parent2.state_dict()
+
+        # 4. Çocukların state_dict'lerini oluştur
+        c1_state = child1.state_dict() # Başlangıç (rastgele) state'i al
+        c2_state = child2.state_dict()
+
+        for name in p1_state: # Parametre isimleri üzerinden döngü
+            param1 = p1_state[name]
+            param2 = p2_state[name]
+
+            # Basit ortalama çaprazlama (daha fazla yöntem eklenebilir)
+            # c1_state[name] = (param1 + param2) / 2.0
+            # c2_state[name] = (param1 + param2) / 2.0 # Ortalama için ikisi de aynı
+
+            # Tek nokta veya uniform crossover (ağırlık matrisi üzerinde)
+            mask = torch.rand_like(param1) < 0.5
+            c1_state[name] = torch.where(mask, param1, param2)
+            c2_state[name] = torch.where(mask, param2, param1) # Ters maske ile
+
+        # 5. Yeni state_dict'leri çocuklara yükle
+        child1.load_state_dict(c1_state)
+        child2.load_state_dict(c2_state)
+
+        logging.debug(f"Crossover performed between {parent1.model_name} and {parent2.model_name}")
+        return child1, child2
+
+    except Exception as e:
+        logging.error(f"Error during PyTorch crossover between {parent1.model_name} and {parent2.model_name}: {e}", exc_info=True)
+        return None, None
+
+# (tournament_selection fonksiyonu öncekiyle aynı mantıkta çalışır, sadece model yerine
+#  NeuralNetwork objesini döndürür)
+def tournament_selection(
+    population: List[NeuralNetwork],
+    fitness_scores: List[float],
+    k: int
+) -> NeuralNetwork:
+    """ Turnuva seçimi ile popülasyondan bir birey seçer. """
+    if not population:
+        raise ValueError("Population cannot be empty for tournament selection.")
+    if len(population) < k:
+        logging.warning(f"Tournament size ({k}) is larger than population size ({len(population)}). Using population size.")
+        k = len(population)
+    if k <= 0:
+        logging.warning(f"Tournament size ({k}) must be positive. Using 1.")
+        k = 1
+
+    try:
+        # Popülasyondan k bireyi rastgele seç (indeksleriyle)
+        tournament_indices = random.sample(range(len(population)), k)
+        # Seçilenlerin fitness skorlarını ve kendilerini al
+        tournament_contenders = [(fitness_scores[i], population[i]) for i in tournament_indices]
+        # Fitness'a göre en iyiyi seç
+        winner = max(tournament_contenders, key=lambda item: item[0])[1] # item[0] fitness, item[1] model
+        return winner
+    except Exception as e:
+        logging.error(f"Error during tournament selection: {e}", exc_info=True)
+        # Hata durumunda rastgele bir birey döndür
+        return random.choice(population)
+
+
+# --- Checkpointing (PyTorch) ---
+def save_checkpoint_pytorch(output_dir: str, generation: int, population: List[NeuralNetwork], rnd_state: Any, np_rnd_state: Any, torch_rnd_state: Any):
+    """ Evrim durumunu (PyTorch modelleri ve rastgele durumlar) kaydeder. """
+    checkpoint_dir = os.path.join(output_dir, "checkpoints_pytorch")
+    os.makedirs(checkpoint_dir, exist_ok=True)
+    checkpoint_file = os.path.join(checkpoint_dir, f"evo_gen_{generation}.pt") # .pt uzantısı PyTorch için yaygın
+    logging.info(f"Saving checkpoint for generation {generation} to {checkpoint_file}...")
+
+    population_state = []
+    for model in population:
+        try:
+            # Her model için mimariyi ve state_dict'i kaydet
+            population_state.append({
+                "name": model.model_name,
+                "architecture": model.get_architecture(),
+                "state_dict": model.state_dict()
+            })
+        except Exception as e:
+            logging.error(f"Could not serialize model {model.model_name} for checkpoint: {e}")
+            # Başarısız olursa bu modeli atla
+
+    state = {
+        "generation": generation,
+        "population_state": population_state, # Sadece başarılı olanları içerir
+        "random_state": rnd_state,
+        "numpy_random_state": np_rnd_state,
+        "torch_random_state": torch_rnd_state, # PyTorch RNG durumu
+        "timestamp": datetime.now().isoformat()
+    }
+
+    try:
+        torch.save(state, checkpoint_file)
+        logging.info(f"Checkpoint saved successfully for generation {generation}.")
+    except Exception as e:
+        logging.error(f"Failed to save checkpoint using torch.save for generation {generation}: {e}", exc_info=True)
+
+
+def load_checkpoint_pytorch(checkpoint_path: str, device: torch.device) -> Optional[Dict]:
+    """ Kaydedilmiş PyTorch 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:
+        # Checkpoint'i CPU'ya yüklemek genellikle daha güvenlidir, sonra cihaza taşınır
+        checkpoint = torch.load(checkpoint_path, map_location=torch.device('cpu'))
+
+        population = []
+        for model_state in checkpoint["population_state"]:
+            try:
+                # 1. Mimariden modeli yeniden oluştur
+                arch = model_state["architecture"]
+                model = NeuralNetwork(**arch)
+                # 2. Kaydedilmiş state_dict'i yükle
+                model.load_state_dict(model_state["state_dict"])
+                # 3. Modeli istenen cihaza taşı
+                model.to(device)
+                # 4. Model adını geri yükle (opsiyonel)
+                model.model_name = model_state.get("name", f"loaded_model_{random.randint(1000,9999)}")
+                model.eval() # Değerlendirme modunda başlat
+                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}", exc_info=True)
+
+        if not population:
+            logging.error("Failed to load any model from the checkpoint population state.")
+            return None # Hiç model yüklenemediyse checkpoint geçersiz
+
+        # Yüklenen popülasyonu state'e ekle
+        checkpoint["population"] = population
+
+        logging.info(f"Checkpoint loaded successfully. Resuming from generation {checkpoint['generation'] + 1}.")
+        return checkpoint
+    except Exception as e:
+        logging.error(f"Failed to load checkpoint from {checkpoint_path}: {e}", exc_info=True)
+        return None
+
+def find_latest_checkpoint_pytorch(output_dir: str) -> Optional[str]:
+    """ Verilen klasördeki en son PyTorch checkpoint dosyasını (.pt) bulur. """
+    checkpoint_dir = os.path.join(output_dir, "checkpoints_pytorch")
+    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(".pt")]
+    if not checkpoints:
+        return None
+
+    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ü (PyTorch) ---
+def evolve_population_pytorch(
+    population: List[NeuralNetwork],
+    X: np.ndarray, y: np.ndarray, # Veri hala NumPy olarak geliyor
+    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, # batch_size fitness'ta kullanılmıyor şu an
+    output_dir: str, checkpoint_interval: int, device: torch.device
+) -> Tuple[Optional[NeuralNetwork], List[float], List[float]]:
+    """ PyTorch tabanlı evrimsel süreci çalıştırır. """
+
+    best_fitness_history = []
+    avg_fitness_history = []
+    best_model_overall: Optional[NeuralNetwork] = None
+    best_fitness_overall = -np.inf
+
+    # Veriyi PyTorch tensörlerine dönüştür ve cihaza gönder (bir kere)
+    # Büyük veri setleri için DataLoader düşünülebilir, ancak burada basit tutuyoruz
+    try:
+        X_torch = torch.from_numpy(X).float().to(device)
+        y_torch = torch.from_numpy(y).float().to(device)
+    except Exception as e:
+        logging.critical(f"Failed to convert data to PyTorch tensors or move to device: {e}", exc_info=True)
+        raise
+
+    # --- KAVRAMSAL: Uyarlanabilir Mutasyon Oranı (Adaptif Parametreler) ---
+    # current_mutation_strength = mut_strength
+    # stagnation_counter = 0
+    # stagnation_limit = 10 # Örneğin, 10 nesil iyileşme olmazsa...
+    # min_mut_strength = 0.01
+    # max_mut_strength = 0.5
+    # --------------------------------------------
+
+    pop_size = len(population)
+
+    for gen in range(start_generation, total_generations):
+        generation_start_time = time.time()
+
+        # 1. Fitness Değerlendirme
+        try:
+            # Paralelleştirme potansiyeli (eğer fitness hesaplama çok uzun sürüyorsa)
+            # Örnek: concurrent.futures kullanarak
+            fitness_scores = [calculate_fitness_pytorch(ind, X_torch, y_torch, device) for ind in population]
+        except Exception as e:
+            logging.critical(f"Error calculating fitness for population in Generation {gen+1}: {e}", exc_info=True)
+            # Hata durumunda en iyi modeli döndürmeye çalış
+            if best_model_overall:
+                return best_model_overall, best_fitness_history, avg_fitness_history
+            else:
+                raise # Eğer hiç en iyi model yoksa, hata ver
+
+        # 2. İstatistikler ve En İyiyi Takip
+        current_best_idx = np.argmax(fitness_scores)
+        current_best_fitness = fitness_scores[current_best_idx]
+        # NaN veya Inf değerlerini filtreleyerek ortalama hesapla
+        finite_scores = [s for s in fitness_scores if np.isfinite(s)]
+        avg_fitness = np.mean(finite_scores) if finite_scores else -np.inf
+
+        best_fitness_history.append(current_best_fitness)
+        avg_fitness_history.append(avg_fitness)
+
+        new_best_found = False
+        if current_best_fitness > best_fitness_overall and np.isfinite(current_best_fitness):
+            best_fitness_overall = current_best_fitness
+            new_best_found = True
+            try:
+                # En iyi modeli klonla (orijinal popülasyondaki değişmesin)
+                best_model_overall = clone_pytorch_model(population[current_best_idx], device)
+                logging.info(f"Generation {gen+1}: *** New overall best fitness found: {best_fitness_overall:.6f} (Model: {best_model_overall.model_name}) ***")
+            except Exception as e:
+                logging.error(f"Could not clone new best model {population[current_best_idx].model_name}: {e}", exc_info=True)
+                # Klonlama başarısız olursa, en azından fitness'ı takip et
+                best_model_overall = None # Klonlanamadığı için referansı tutma
+        # else: # En iyi bulunamadıysa veya aynıysa
+             # --- KAVRAMSAL: Adaptif Mutasyon Güncelleme ---
+             # stagnation_counter += 1
+             # logging.debug(f"Stagnation counter: {stagnation_counter}")
+             # if stagnation_counter >= stagnation_limit:
+             #      current_mutation_strength = min(max_mut_strength, current_mutation_strength * 1.2) # Mutasyon gücünü artır
+             #      logging.info(f"Stagnation detected. Increasing mutation strength to {current_mutation_strength:.4f}")
+             #      stagnation_counter = 0 # Sayacı sıfırla
+
+        # if new_best_found:
+        #      stagnation_counter = 0
+        #      current_mutation_strength = max(min_mut_strength, current_mutation_strength * 0.95) # İyileşme varsa azalt
+        #      logging.debug(f"Improvement found. Decreasing mutation strength to {current_mutation_strength:.4f}")
+
+        generation_time = time.time() - generation_start_time
+        logging.info(f"Generation {gen+1}/{total_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:
+                # Fitness skorlarına göre sırala ve en iyileri al (indeksleri)
+                elite_indices = np.argsort(fitness_scores)[-elitism_count:]
+                for idx in elite_indices:
+                    # Elitleri klonlayarak yeni popülasyona ekle
+                    elite_clone = clone_pytorch_model(population[idx], device)
+                    elite_clone.model_name = f"elite_{population[idx].model_name}" # İsimlendirme
+                    new_population.append(elite_clone)
+                logging.debug(f"Added {len(new_population)} elites to the next generation.")
+            except Exception as e:
+                logging.error(f"Error during elitism: {e}", exc_info=True)
+
+        # 3b. Seçilim, Çaprazlama ve Mutasyon ile kalanları doldur
+        num_to_generate = pop_size - len(new_population)
+        generated_count = 0
+        reproduction_attempts = 0 # Sonsuz döngüyü önlemek için
+        max_reproduction_attempts = num_to_generate * 5 # Cömert bir sınır
+
+        while generated_count < num_to_generate and reproduction_attempts < max_reproduction_attempts:
+            reproduction_attempts += 1
+            try:
+                # İki ebeveyn seç
+                parent1 = tournament_selection(population, fitness_scores, tournament_size)
+                parent2 = tournament_selection(population, fitness_scores, tournament_size)
+
+                child1, child2 = None, None
+
+                # Çaprazlama uygula (belirli bir olasılıkla ve farklı ebeveynlerse)
+                if random.random() < crossover_rate and parent1 is not parent2:
+                     # logging.debug(f"Attempting crossover between {parent1.model_name} and {parent2.model_name}")
+                     child1, child2 = crossover_individuals_pytorch(parent1, parent2, device)
+
+                # Eğer çaprazlama yapılmadıysa/başarısız olduysa veya tek çocuk üretildiyse
+                if child1 is None:
+                    # Mutasyon uygula (belirli bir olasılıkla)
+                    if random.random() < mutation_rate:
+                        parent_to_mutate = parent1 # Veya parent2, veya rastgele biri
+                        child1 = mutate_individual_pytorch(parent_to_mutate, weight_mut_rate, mut_strength, device) # Adaptif: current_mutation_strength
+                    else:
+                        # Ne çaprazlama ne mutasyon -> ebeveyni klonla
+                        child1 = clone_pytorch_model(parent1, device)
+                        child1.model_name = f"direct_clone_{parent1.model_name}_{random.randint(1000,9999)}"
+
+                # Çocukları yeni popülasyona ekle (eğer üretildilerse)
+                if child1:
+                    new_population.append(child1)
+                    generated_count += 1
+                    if generated_count >= num_to_generate: break
+
+                if child2: # Eğer çaprazlama iki çocuk ürettiyse
+                    # İkinci çocuğa da mutasyon uygulama seçeneği eklenebilir
+                    # if random.random() < post_crossover_mutation_rate: child2 = mutate(...)
+                    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 (attempt {reproduction_attempts}): {e}", exc_info=True)
+                # Hata durumunda döngüye devam etmeye çalış, ancak sınırı aşarsa durur.
+                # Güvenlik önlemi olarak rastgele birey eklenebilir ama hatayı maskeleyebilir.
+
+        # Eğer döngü sınırı aşıldıysa popülasyonu tamamla
+        if generated_count < num_to_generate:
+            logging.warning(f"Reproduction cycle finished early or hit attempt limit. Adding {num_to_generate - generated_count} random individuals.")
+            input_size = population[0].input_size # İlk bireyden al
+            output_size = population[0].output_size
+            for _ in range(num_to_generate - generated_count):
+                try:
+                    random_ind = create_individual_pytorch(input_size, output_size).to(device)
+                    new_population.append(random_ind)
+                except Exception as e:
+                     logging.error(f"Failed to create random individual to fill population: {e}")
+                     # Bu durumda popülasyon eksik kalabilir
+
+        population = new_population[:pop_size] # Popülasyon boyutunu garantile
+
+        # 4. Checkpoint Alma
+        if checkpoint_interval > 0 and (gen + 1) % checkpoint_interval == 0:
+            try:
+                rnd_state = random.getstate()
+                np_rnd_state = np.random.get_state()
+                torch_rnd_state = torch.get_rng_state() # PyTorch RNG durumu
+                # Cihaz RNG durumları da kaydedilebilir: torch.cuda.get_rng_state_all()
+                save_checkpoint_pytorch(output_dir, gen + 1, population, rnd_state, np_rnd_state, torch_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 temizliği (GPU belleği için önemli olabilir)
+        if device.type == 'cuda':
+            torch.cuda.empty_cache()
+
+    # Evrim Döngüsü Sonu
+    if best_model_overall is None:
+        logging.warning("Evolution finished, but no single best model was tracked (possibly due to errors or all fitness being non-finite).")
+        # Son popülasyondan en iyiyi bulmaya çalış
+        if population:
+             final_fitness_scores = [calculate_fitness_pytorch(ind, X_torch, y_torch, device) for ind in population]
+             valid_scores = [(s, i) for i, s in enumerate(final_fitness_scores) if np.isfinite(s)]
+             if valid_scores:
+                 best_idx_final = max(valid_scores, key=lambda item: item[0])[1]
+                 best_model_overall = clone_pytorch_model(population[best_idx_final], device) # Klonla
+                 best_fitness_overall = final_fitness_scores[best_idx_final]
+                 logging.info(f"Selected best model from final population: {best_model_overall.model_name} with fitness {best_fitness_overall:.6f}")
+             else:
+                 logging.error("Evolution finished. No valid finite fitness scores in the final population.")
+                 return None, best_fitness_history, avg_fitness_history
+        else:
+             logging.error("Evolution finished with an empty population!")
+             return None, best_fitness_history, avg_fitness_history
+    else:
+         logging.info(f"Evolution finished. Best fitness achieved: {best_fitness_overall:.6f} by model {best_model_overall.model_name}")
+
+    return best_model_overall, best_fitness_history, avg_fitness_history
+
+# --- Grafik Çizimi (Öncekiyle aynı, Matplotlib kullanıyor) ---
+def plot_fitness_history(history_best: List[float], history_avg: List[float], output_dir: str, filename: str = "fitness_history_pytorch.png") -> None:
+    if not history_best or not history_avg:
+        logging.warning("Fitness history is empty, cannot plot.")
+        return
+    try:
+        plt.figure(figsize=(12, 7))
+        # NaN veya Inf değerlerini çizimde atlamak için filtrele
+        gens = np.arange(1, len(history_best) + 1)
+        valid_best_indices = [i for i, v in enumerate(history_best) if np.isfinite(v)]
+        valid_avg_indices = [i for i, v in enumerate(history_avg) if np.isfinite(v)]
+
+        if valid_best_indices:
+             plt.plot(gens[valid_best_indices], np.array(history_best)[valid_best_indices], label="Best Fitness", marker='o', linestyle='-', linewidth=2)
+        if valid_avg_indices:
+             plt.plot(gens[valid_avg_indices], np.array(history_avg)[valid_avg_indices], label="Average Fitness", marker='x', linestyle='--', alpha=0.7)
+
+        plt.xlabel("Generation")
+        plt.ylabel("Fitness Score")
+        plt.title("Evolutionary Fitness History (PyTorch)")
+        plt.legend()
+        plt.grid(True)
+        plt.tight_layout()
+        plot_path = os.path.join(output_dir, filename)
+        plt.savefig(plot_path)
+        plt.close() # Belleği boşalt
+        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 (PyTorch) ---
+def evaluate_model_pytorch(
+    model: NeuralNetwork,
+    X_test: np.ndarray, y_test: np.ndarray,
+    batch_size: int, device: torch.device
+) -> Dict[str, float]:
+    """ En iyi modeli test verisi üzerinde PyTorch ile 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 using PyTorch...")
+    model.eval() # Değerlendirme modu
+    model.to(device)
+
+    # NumPy verisini PyTorch DataLoader ile kullanmak
+    try:
+        test_dataset = TensorDataset(torch.from_numpy(X_test).float(), torch.from_numpy(y_test).float())
+        test_loader = DataLoader(test_dataset, batch_size=batch_size) # Shuffle=False önemli
+    except Exception as e:
+        logging.error(f"Failed to create PyTorch DataLoader for test data: {e}", exc_info=True)
+        return {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+
+    all_preds = []
+    all_targets = []
+    total_mse = 0.0
+    num_batches = 0
+
+    try:
+        with torch.no_grad():
+            for inputs, targets in test_loader:
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                batch_mse = torch.mean((outputs - targets)**2)
+                total_mse += batch_mse.item()
+                num_batches += 1
+                # Kendall Tau için tahminleri ve hedefleri topla (CPU'da)
+                all_preds.append(outputs.cpu().numpy())
+                all_targets.append(targets.cpu().numpy())
+
+        avg_mse = total_mse / num_batches if num_batches > 0 else np.inf
+        logging.info(f"Final Test MSE: {avg_mse:.6f}")
+
+        # Kendall Tau hesaplaması
+        all_preds_np = np.concatenate(all_preds, axis=0)
+        all_targets_np = np.concatenate(all_targets, axis=0)
+
+        sample_size = min(500, all_targets_np.shape[0])
+        taus = []
+        if sample_size > 0:
+            indices = np.random.choice(all_targets_np.shape[0], sample_size, replace=False)
+            for i in indices:
+                try:
+                    tau, _ = kendalltau(all_targets_np[i], all_preds_np[i])
+                    if not np.isnan(tau):
+                        taus.append(tau)
+                except ValueError: # Sabit tahmin durumu vb.
+                    pass
+        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(avg_mse), "avg_kendall_tau": float(avg_kendall_tau)}
+
+    except Exception as e:
+        logging.error(f"Error during final PyTorch model evaluation: {e}", exc_info=True)
+        return {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+
+
+# --- Son Eğitim (PyTorch) ---
+def train_final_model_pytorch(
+    model: NeuralNetwork,
+    X_train: np.ndarray, y_train: np.ndarray,
+    epochs: int, batch_size: int, learning_rate: float,
+    device: torch.device, output_dir: str
+) -> Tuple[NeuralNetwork, Dict[str, Any]]:
+    """ En iyi evrimleşmiş modeli PyTorch ile eğitir (Early Stopping ve LR Scheduling ile). """
+    logging.info(f"--- Starting Final Training of Best Evolved Model ({model.model_name}) ---")
+    model.to(device) # Modeli cihaza taşı
+
+    # Veriyi DataLoader'a yükle
+    try:
+        train_dataset = TensorDataset(torch.from_numpy(X_train).float(), torch.from_numpy(y_train).float())
+        # Veriyi train/validation olarak ayır
+        val_split = 0.2
+        num_train = len(train_dataset)
+        split_idx = int(np.floor(val_split * num_train))
+        indices = list(range(num_train))
+        np.random.shuffle(indices) # Karıştır
+        train_indices, val_indices = indices[split_idx:], indices[:split_idx]
+
+        train_sampler = torch.utils.data.SubsetRandomSampler(train_indices)
+        val_sampler = torch.utils.data.SubsetRandomSampler(val_indices) # Veya SequentialSampler
+
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=train_sampler)
+        val_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=val_sampler)
+        logging.info(f"Created DataLoaders. Train samples: {len(train_indices)}, Val samples: {len(val_indices)}")
+    except Exception as e:
+        logging.error(f"Failed to create DataLoaders for final training: {e}", exc_info=True)
+        return model, {"error": "DataLoader creation failed"}
+
+    # Optimizatör ve Kayıp Fonksiyonu
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+    criterion = nn.MSELoss() # Kayıp fonksiyonu
+
+    # Learning Rate Scheduler (Platoda Azaltma)
+    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.3, patience=7, verbose=True, min_lr=1e-7)
+
+    # Early Stopping Parametreleri
+    early_stopping_patience = 15
+    best_val_loss = np.inf
+    epochs_no_improve = 0
+    best_model_state = None # En iyi modelin state_dict'ini sakla
+
+    training_history = {'train_loss': [], 'val_loss': [], 'lr': []}
+    epochs_run = 0
+
+    try:
+        for epoch in range(epochs):
+            epochs_run += 1
+            model.train() # Eğitim modu
+            running_train_loss = 0.0
+            for i, (inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(device), targets.to(device)
+
+                optimizer.zero_grad()       # Gradyanları sıfırla
+                outputs = model(inputs)     # İleri besleme
+                loss = criterion(outputs, targets) # Kaybı hesapla
+                loss.backward()             # Geri yayılım
+                optimizer.step()            # Ağırlıkları güncelle
+
+                running_train_loss += loss.item()
+
+            avg_train_loss = running_train_loss / len(train_loader) if len(train_loader) > 0 else 0.0
+            training_history['train_loss'].append(avg_train_loss)
+            training_history['lr'].append(optimizer.param_groups[0]['lr']) # Mevcut LR'yi kaydet
+
+            # ---- Validation ----
+            model.eval() # Değerlendirme modu
+            running_val_loss = 0.0
+            with torch.no_grad():
+                for inputs, targets in val_loader:
+                    inputs, targets = inputs.to(device), targets.to(device)
+                    outputs = model(inputs)
+                    loss = criterion(outputs, targets)
+                    running_val_loss += loss.item()
+
+            avg_val_loss = running_val_loss / len(val_loader) if len(val_loader) > 0 else np.inf
+            training_history['val_loss'].append(avg_val_loss)
+
+            logging.info(f"Epoch [{epoch+1}/{epochs}] Train Loss: {avg_train_loss:.6f} | Val Loss: {avg_val_loss:.6f} | LR: {optimizer.param_groups[0]['lr']:.2e}")
+
+            # Learning Rate Scheduling
+            scheduler.step(avg_val_loss)
+
+            # Early Stopping Kontrolü
+            if avg_val_loss < best_val_loss:
+                best_val_loss = avg_val_loss
+                epochs_no_improve = 0
+                # En iyi modelin durumunu kaydet (derin kopya)
+                best_model_state = copy.deepcopy(model.state_dict())
+                logging.debug(f"New best validation loss: {best_val_loss:.6f}. Saving model state.")
+            else:
+                epochs_no_improve += 1
+
+            if epochs_no_improve >= early_stopping_patience:
+                logging.info(f"Early stopping triggered after {epoch+1} epochs due to no improvement in validation loss for {early_stopping_patience} epochs.")
+                break
+
+        # Eğitim sonrası en iyi modeli yükle (eğer kaydedildiyse)
+        if best_model_state:
+            logging.info(f"Restoring model to best validation performance (Val Loss: {best_val_loss:.6f}).")
+            model.load_state_dict(best_model_state)
+        else:
+             logging.warning("No best model state was saved during training (possibly validation loss never improved).")
+
+
+        logging.info("Final training complete.")
+        training_summary = {
+            "epochs_run": epochs_run,
+            "final_train_loss": avg_train_loss, # Son epoch'un kaybı
+            "best_val_loss": best_val_loss, # Elde edilen en iyi val kaybı
+            "final_lr": optimizer.param_groups[0]['lr']
+        }
+        # Eğitim grafiğini çizdir (opsiyonel)
+        # plot_training_history(training_history, output_dir)
+
+        return model, training_summary
+
+    except Exception as e:
+        logging.error(f"Error during final PyTorch model training: {e}", exc_info=True)
+        return model, {"error": str(e)}
+
+
+# --- Ana İş Akışı (PyTorch) ---
+def run_pipeline_pytorch(args: argparse.Namespace):
+    """ Checkpoint ve PyTorch tabanlı ana iş akışı. """
+
+    # Cihazı Ayarla
+    device = setup_device(args.device)
+
+    # Çalıştırma adı ve çıktı klasörü
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_name = f"evorun_pt_{timestamp}_gen{args.generations}_pop{args.pop_size}"
+    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)
+        logging.info(f"Attempting to resume PyTorch run from: {output_dir}")
+        # Devam edilen çalıştırmada çıktı klasörü zaten var olmalı
+        if not os.path.isdir(output_dir):
+             logging.error(f"Resume directory not found: {output_dir}. Exiting.")
+             sys.exit(1)
+    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 v4 PyTorch Pipeline: {run_name} ==========")
+    logging.info(f"Output directory: {output_dir}")
+    logging.info(f"Using device: {device}")
+
+    # --- Checkpoint Yükleme ---
+    start_generation = 0
+    population = []
+    initial_state_loaded = False
+    loaded_history_best = [] # Yüklenecek geçmiş fitness verileri
+    loaded_history_avg = []
+
+    latest_checkpoint_path = find_latest_checkpoint_pytorch(output_dir) if resume_run else None
+
+    if latest_checkpoint_path:
+        loaded_state = load_checkpoint_pytorch(latest_checkpoint_path, device)
+        if loaded_state:
+            start_generation = loaded_state['generation']
+            population = loaded_state['population'] # Yüklenen modeller zaten doğru cihazda olmalı
+            # Rastgele durumları geri yükle
+            try:
+                random.setstate(loaded_state['random_state'])
+                np.random.set_state(loaded_state['numpy_random_state'])
+                torch.set_rng_state(loaded_state['torch_random_state'].cpu()) # CPU'ya yüklenen state'i kullan
+                if device.type == 'cuda' and 'torch_cuda_random_state' in loaded_state:
+                    # TODO: CUDA RNG state'i de kaydet/yükle (gerekirse)
+                    # torch.cuda.set_rng_state_all(loaded_state['torch_cuda_random_state'])
+                    pass
+                logging.info(f"Random states restored from checkpoint (Generation {start_generation}).")
+            except Exception as e:
+                logging.warning(f"Could not fully restore random states from checkpoint: {e}")
+
+            # TODO: Fitness geçmişini de checkpoint'e kaydet/yükle
+            # loaded_history_best = loaded_state.get('best_fitness_history', [])
+            # loaded_history_avg = loaded_state.get('avg_fitness_history', [])
+
+            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
+    elif resume_run:
+        logging.warning(f"Resume requested but no valid PyTorch checkpoint (.pt) found in {output_dir}. Starting from scratch.")
+        resume_run = False
+
+
+    # --- Sıfırdan Başlama veya Devam Etme Ayarları ---
+    # Argümanları logla ve kaydet (sadece sıfırdan başlarken veya config yoksa)
+    config_path = os.path.join(output_dir, "config_pytorch.json")
+    args_dict = vars(args)
+    if not initial_state_loaded or not os.path.exists(config_path):
+         logging.info("--- Configuration ---")
+         for k, v in args_dict.items(): logging.info(f"  {k:<25}: {v}")
+         logging.info("---------------------")
+         try:
+             # Argümanları JSON olarak kaydet
+             args_to_save = args_dict.copy()
+             # Cihaz objesini string'e çevir
+             args_to_save['device'] = str(device)
+             with open(config_path, 'w') as f: json.dump(args_to_save, 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)
+    else: # Devam ediliyorsa ve config varsa, onu logla
+         try:
+              with open(config_path, 'r') as f: loaded_args_dict = json.load(f)
+              logging.info("--- Loaded Configuration (from resumed run) ---")
+              for k, v in loaded_args_dict.items(): logging.info(f"  {k:<25}: {v}")
+              logging.info("-----------------------------------------------")
+              # İsteğe bağlı: Yüklenen argümanlarla mevcut argümanları karşılaştır
+              # for k, v in args_dict.items():
+              #      if k in loaded_args_dict and loaded_args_dict[k] != v:
+              #           logging.warning(f"Argument mismatch: '{k}' loaded as {loaded_args_dict[k]}, current is {v}")
+         except Exception as e: logging.warning(f"Could not reload config.json: {e}")
+
+
+    # Rastgele tohumları ayarla (her zaman, devam etse bile determinizm için önemli olabilir)
+    # Ancak checkpoint'ten yüklenen state'ler bunu geçersiz kılabilir.
+    # Genellikle sadece sıfırdan başlarken ayarlamak daha mantıklıdır.
+    if not initial_state_loaded:
+        try:
+            seed = args.seed
+            random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
+            if device.type == 'cuda': torch.cuda.manual_seed_all(seed) # GPU için de
+            # Potansiyel olarak deterministik algoritmaları zorla (performansı düşürebilir)
+            # torch.backends.cudnn.deterministic = True
+            # torch.backends.cudnn.benchmark = False
+            logging.info(f"Using random seed: {seed}")
+        except Exception as e: logging.warning(f"Could not set all random seeds: {e}")
+
+
+    # Veri Üretimi (her zaman, checkpoint veriyi içermiyorsa)
+    # Büyük veri setleri için veriyi kaydet/yükle mekanizması daha iyi olabilir.
+    try:
+        logging.info("Generating/Reloading 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)
+        input_shape = X_train.shape[1] # Sadece özellik sayısı
+        output_shape = y_train.shape[1]
+    except Exception:
+        logging.critical("Failed to generate/reload data. Exiting.")
+        sys.exit(1)
+
+
+    # Popülasyon Başlatma (sadece sıfırdan başlarken)
+    if not initial_state_loaded:
+        logging.info(f"--- Initializing Population (Size: {args.pop_size}) ---")
+        try:
+            population = [create_individual_pytorch(input_shape, output_shape).to(device) 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/Resuming PyTorch Evolution ({args.generations} Total Generations) ---")
+    best_model_evolved: Optional[NeuralNetwork] = None
+    best_fitness_hist = loaded_history_best # Yüklenen geçmişle başla
+    avg_fitness_hist = loaded_history_avg
+
+    if start_generation >= args.generations:
+        logging.warning(f"Loaded checkpoint generation ({start_generation}) is already >= total generations ({args.generations}). Skipping evolution.")
+        # Checkpoint'ten en iyi modeli ve geçmişi düzgün yüklemek önemli
+        # Şimdilik en iyi modeli popülasyondaki ilk model varsayalım (bu doğru olmayabilir!)
+        if population:
+             # TODO: Checkpoint'e en iyi modeli de kaydetmek daha iyi olur.
+             # Geçici çözüm: Son popülasyondan en iyiyi seç
+              try:
+                   logging.info("Selecting best model from loaded population as evolution is skipped...")
+                   fitness_scores_loaded = [calculate_fitness_pytorch(ind, torch.from_numpy(X_train).float(), torch.from_numpy(y_train).float(), device) for ind in population]
+                   valid_scores_loaded = [(s, i) for i, s in enumerate(fitness_scores_loaded) if np.isfinite(s)]
+                   if valid_scores_loaded:
+                       best_idx_loaded = max(valid_scores_loaded, key=lambda item: item[0])[1]
+                       best_model_evolved = clone_pytorch_model(population[best_idx_loaded], device) # Klonla
+                       logging.info(f"Using model {best_model_evolved.model_name} from loaded population as best evolved model.")
+                   else:
+                       logging.warning("Could not determine best model from loaded population (no finite fitness).")
+                       best_model_evolved = None
+              except Exception as e:
+                   logging.error(f"Error selecting best model from loaded population: {e}")
+                   best_model_evolved = None
+        else:
+             best_model_evolved = None # Popülasyon yüklenememişse
+        # Geçmişi de yüklemek lazım (yukarıda TODO olarak belirtildi)
+        best_fitness_hist, avg_fitness_hist = [], []
+    else:
+        try:
+            best_model_evolved, gen_best_hist, gen_avg_hist = evolve_population_pytorch(
+                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, # batch_size evrimde doğrudan kullanılmıyor
+                output_dir, args.checkpoint_interval, device
+            )
+            # Yüklenen geçmişle bu çalıştırmanın geçmişini birleştir
+            best_fitness_hist.extend(gen_best_hist)
+            avg_fitness_hist.extend(gen_avg_hist)
+
+        except Exception as e:
+            logging.critical(f"Fatal error during PyTorch evolution process: {e}", exc_info=True)
+            sys.exit(1)
+    logging.info("--- PyTorch Evolution Complete ---")
+
+    # Fitness geçmişini kaydetme ve çizdirme
+    if best_fitness_hist or avg_fitness_hist:
+        plot_fitness_history(best_fitness_hist, avg_fitness_hist, output_dir)
+        history_path = os.path.join(output_dir, "fitness_history_pytorch.csv")
+        try:
+            # Geçmişi CSV olarak kaydet
+            history_data = np.array([
+                np.arange(1, len(best_fitness_hist) + 1), # Nesil numaraları (1'den başlayarak)
+                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"Full fitness history 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 after evolution, skipping saving/plotting.")
+
+
+    # En iyi modelin son eğitimi, değerlendirme ve sonuç kaydı
+    final_model_path = None
+    training_summary = {}
+    final_metrics = {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+    best_model_architecture = {}
+
+    if best_model_evolved is None:
+        logging.error("Evolution did not yield a best model. Skipping final training and evaluation.")
+    else:
+        best_model_architecture = best_model_evolved.get_architecture()
+        logging.info(f"Best evolved model architecture: {best_model_architecture}")
+        # Model özetini logla (parametre sayısı vb.)
+        try:
+            num_params = sum(p.numel() for p in best_model_evolved.parameters() if p.requires_grad)
+            logging.info(f"Best Evolved Model ({best_model_evolved.model_name}) - Trainable Parameters: {num_params}")
+            # Daha detaylı özet için torchinfo gibi kütüphaneler kullanılabilir:
+            # from torchinfo import summary
+            # summary(best_model_evolved, input_size=(args.batch_size, input_shape)) # input_size örnektir
+        except Exception as e:
+            logging.warning(f"Could not log model summary details: {e}")
+
+
+        # Son Eğitim
+        try:
+             # Eğitmeden önce bir klonunu alalım ki orijinal evrimleşmiş hali kaybolmasın
+             model_to_train = clone_pytorch_model(best_model_evolved, device)
+             final_model, training_summary = train_final_model_pytorch(
+                 model_to_train, X_train, y_train,
+                 args.epochs_final_train, args.batch_size, args.learning_rate, # Args'a learning_rate ekle
+                 device, output_dir
+             )
+        except Exception as e:
+             logging.error(f"Error during final training setup or execution: {e}", exc_info=True)
+             final_model = None # Eğitim başarısız
+             training_summary = {"error": str(e)}
+
+        # Değerlendirme
+        if final_model:
+             final_metrics = evaluate_model_pytorch(final_model, X_test, y_test, args.batch_size, device)
+             # Son eğitilmiş modeli kaydet
+             final_model_path = os.path.join(output_dir, "best_evolved_model_trained_pytorch.pt")
+             try:
+                 # Sadece state_dict kaydetmek genellikle daha iyidir
+                 torch.save({
+                     'architecture': final_model.get_architecture(),
+                     'model_state_dict': final_model.state_dict(),
+                     # 'optimizer_state_dict': optimizer.state_dict(), # Eğitimde kullanılan optimizatör durumu
+                     'training_summary': training_summary,
+                     'evaluation_metrics': final_metrics
+                 }, final_model_path)
+                 logging.info(f"Final trained model state and architecture saved to {final_model_path}")
+             except Exception as e:
+                 logging.error(f"Failed to save final trained model: {e}", exc_info=True)
+                 final_model_path = None # Kaydedilemedi
+        else:
+             logging.error("Final model training failed or did not produce a model. Skipping evaluation and saving.")
+
+
+    logging.info("--- Saving Final Results ---")
+    final_results = {
+        "run_info": {
+            "run_name": run_name,
+            "timestamp": timestamp,
+            "output_directory": output_dir,
+            "framework": "PyTorch",
+            "device_used": str(device),
+            "resumed_run": resume_run,
+            "last_checkpoint_loaded": latest_checkpoint_path
+        },
+        "config": args_dict, # Başlangıç argümanları
+        "evolution_summary": {
+            "start_generation": start_generation,
+            "end_generation": start_generation + len(best_fitness_hist) - (1 if loaded_history_best else 0), # Çalıştırılan son nesil
+            "generations_run_this_session": len(best_fitness_hist) - len(loaded_history_best),
+            "best_fitness_achieved_overall": max(best_fitness_hist) if best_fitness_hist and any(np.isfinite(f) for f in best_fitness_hist) else None,
+            "best_fitness_final_gen": best_fitness_hist[-1] if best_fitness_hist and np.isfinite(best_fitness_hist[-1]) else None,
+            "avg_fitness_final_gen": avg_fitness_hist[-1] if avg_fitness_hist and np.isfinite(avg_fitness_hist[-1]) else None,
+            "best_model_architecture": best_model_architecture
+        },
+        "final_training_summary": training_summary,
+        "final_evaluation_on_test": final_metrics,
+        "saved_trained_model_path": final_model_path
+    }
+    results_path = os.path.join(output_dir, "final_results_pytorch.json")
+    try:
+        # NumPy ve diğer serileştirilemeyen türleri JSON'a uygun hale getir
+        def convert_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()
+            elif isinstance(obj, torch.Tensor): return obj.tolist() # Tensörleri listeye çevir
+            elif isinstance(obj, torch.device): return str(obj) # Cihazı string yap
+            elif isinstance(obj, type): return obj.__name__ # Türleri isim olarak kaydet
+            return obj
+        with open(results_path, 'w') as f:
+            json.dump(final_results, f, indent=4, default=convert_types, sort_keys=True)
+        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"========== PyTorch Pipeline Run {run_name} Finished ==========")
+
+
+# --- Argüman Ayrıştırıcı (PyTorch için Eklemeler) ---
+def parse_arguments_v4() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="EvoNet v4: Neuroevolution with PyTorch, 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 (PyTorch checkpoints).')
+    parser.add_argument('--checkpoint_interval', type=int, default=DEFAULT_CHECKPOINT_INTERVAL, help='Save checkpoint every N generations (0 to disable).')
+    parser.add_argument('--device', type=str, default=DEFAULT_DEVICE, choices=['auto', 'cpu', 'cuda'], help='Device to use (cpu, cuda, or auto-detect).')
+
+    # --- 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='Probability for each weight/bias to be mutated if mutation occurs.')
+    parser.add_argument('--mutation_strength', type=float, default=DEFAULT_MUTATION_STRENGTH, help='Std dev for weight mutation noise (Gaussian).')
+    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 to carry over.')
+
+    # --- Eğitim ve Değerlendirme ---
+    parser.add_argument('--batch_size', type=int, default=DEFAULT_BATCH_SIZE, help='Batch size for final training and evaluation.')
+    parser.add_argument('--epochs_final_train', type=int, default=DEFAULT_EPOCHS_FINAL_TRAIN, help='Max epochs for final training of the best model.')
+    parser.add_argument('--learning_rate', type=float, default=0.001, help='Learning rate for Adam optimizer during final training.')
+
+    # --- Tekrarlanabilirlik ---
+    parser.add_argument('--seed', type=int, default=None, help='Random seed for Python, NumPy, and PyTorch (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 kontroller
+    if args.elitism_count >= args.pop_size:
+        print(f"Warning: Elitism count ({args.elitism_count}) >= Population size ({args.pop_size}). Setting elitism to PopSize - 1.")
+        args.elitism_count = max(0, args.pop_size - 1)
+    if args.tournament_size <= 0:
+         print(f"Warning: Tournament size ({args.tournament_size}) must be > 0. Setting to 1.")
+         args.tournament_size = 1
+    if args.tournament_size > args.pop_size:
+         print(f"Warning: Tournament size ({args.tournament_size}) > Population size ({args.pop_size}). Setting to PopSize.")
+         args.tournament_size = args.pop_size
+
+    return args
+
+
+# --- Ana Çalıştırma Bloğu ---
+if __name__ == "__main__":
+    cli_args = parse_arguments_v4()
+    try:
+        run_pipeline_pytorch(cli_args)
+    except SystemExit:
+        logging.info("SystemExit caught, exiting gracefully.")
+        pass # Argparse veya bilinçli çıkışlar için
+    except KeyboardInterrupt:
+        print("\nKeyboardInterrupt detected. Exiting...")
+        logging.warning("KeyboardInterrupt detected. Attempting graceful shutdown.")
+        sys.exit(130) # Ctrl+C için standart çıkış kodu
+    except Exception as e:
+        # Loglama zaten ayarlandıysa, kritik hata logla
+        if logging.getLogger().hasHandlers():
+            logging.critical("FATAL UNHANDLED ERROR in main execution block:", exc_info=True)
+        else: # Loglama başlamadan hata olursa stderr'a yaz
+            import traceback
+            print(f"\nFATAL UNHANDLED ERROR in main execution block: {e}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)
+        sys.exit(1) # Başarısız çıkış kodu

v5.py

@@ -0,0 +1,1330 @@
+# ==============================================================================
+# EvoNet Optimizer - v5 - Adaptif & Paralel PyTorch Sürümü
+# Açıklama: v4 üzerine inşa edilmiştir. Adaptif mutasyon gücü, fitness'ta
+#           karmaşıklık cezası, paralel fitness hesaplama (CPU),
+#           opsiyonel Weights & Biases entegrasyonu ve genel iyileştirmeler içerir.
+# ==============================================================================
+
+import os
+# os.environ["WANDB_SILENT"] = "true" # W&B loglarını azaltmak için (isteğe bağlı)
+import sys
+import argparse
+import random
+import logging
+from datetime import datetime
+import json
+import copy
+import time
+from typing import List, Tuple, Dict, Any, Optional, Union
+import concurrent.futures # Paralel fitness hesaplama için
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import TensorDataset, DataLoader
+import matplotlib.pyplot as plt
+from scipy.stats import kendalltau
+
+# Opsiyonel W&B importu
+try:
+    import wandb
+    _WANDB_AVAILABLE = True
+except ImportError:
+    _WANDB_AVAILABLE = False
+    print("Warning: wandb library not found. Experiment tracking with W&B is disabled.")
+    print("Install with: pip install wandb")
+
+
+# --- Sabitler ve Varsayılan Değerler ---
+DEFAULT_SEQ_LENGTH = 10
+DEFAULT_POP_SIZE = 50
+DEFAULT_GENERATIONS = 50
+DEFAULT_CROSSOVER_RATE = 0.6
+DEFAULT_MUTATION_RATE = 0.4
+DEFAULT_WEIGHT_MUT_RATE = 0.8
+DEFAULT_MUTATION_STRENGTH = 0.1 # Başlangıç mutasyon gücü
+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_v5_pytorch")
+DEFAULT_CHECKPOINT_INTERVAL = 10
+DEFAULT_DEVICE = "auto"
+DEFAULT_NUM_WORKERS = 0 # Paralel fitness için worker sayısı (0 = Kapalı/Ana thread)
+
+# Adaptif Mutasyon Parametreleri
+DEFAULT_ADAPT_MUTATION = True
+DEFAULT_STAGNATION_LIMIT = 10 # İyileşme olmazsa adaptasyon için nesil sayısı
+DEFAULT_MUT_STRENGTH_DECAY = 0.98 # İyileşme olduğunda azaltma faktörü
+DEFAULT_MUT_STRENGTH_INCREASE = 1.1 # Tıkanma olduğunda artırma faktörü
+DEFAULT_MIN_MUT_STRENGTH = 0.005
+DEFAULT_MAX_MUT_STRENGTH = 0.5
+
+# Gelişmiş Fitness Parametreleri
+DEFAULT_COMPLEXITY_PENALTY = 0.00001 # Parametre başına ceza ağırlığı
+
+
+# --- Loglama Ayarları ---
+# (setup_logging fonksiyonu öncekiyle aynı, v4'teki gibi)
+def setup_logging(log_dir: str, log_level=logging.INFO) -> None:
+    log_filename = os.path.join(log_dir, 'evolution_run_pytorch_v5.log')
+    for handler in logging.root.handlers[:]:
+        handler.close()
+        logging.root.removeHandler(handler)
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(levelname)-8s [%(filename)s:%(lineno)d] - %(message)s',
+        handlers=[
+            logging.FileHandler(log_filename, mode='a'),
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    logging.info("="*50)
+    logging.info("PyTorch EvoNet v5 Logging Başlatıldı.")
+    logging.info("="*50)
+
+# --- Cihaz (GPU/CPU) Ayarları ---
+# (setup_device fonksiyonu öncekiyle aynı, v4'teki gibi)
+def setup_device(requested_device: str) -> torch.device:
+    """ Kullanılabilir cihaza göre PyTorch cihazını ayarlar. """
+    if requested_device == "auto":
+        if torch.cuda.is_available():
+            device_name = "cuda"
+            logging.info(f"CUDA (GPU) kullanılabilir: {torch.cuda.get_device_name(0)}")
+        else:
+            device_name = "cpu"
+            logging.info("CUDA (GPU) bulunamadı. CPU kullanılacak.")
+    elif requested_device == "cuda":
+        if torch.cuda.is_available():
+            device_name = "cuda"
+            logging.info(f"CUDA (GPU) manuel olarak seçildi: {torch.cuda.get_device_name(0)}")
+        else:
+            logging.warning("CUDA (GPU) istendi ancak bulunamadı! CPU kullanılacak.")
+            device_name = "cpu"
+    else: # cpu veya geçersiz değer
+        device_name = "cpu"
+        logging.info("CPU manuel olarak seçildi veya geçersiz cihaz belirtildi.")
+
+    return torch.device(device_name)
+
+
+# --- Veri Üretimi ---
+# (generate_data fonksiyonu öncekiyle aynı, v4'teki gibi)
+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
+
+# --- PyTorch Sinir Ağı Modeli ---
+# (NeuralNetwork sınıfı öncekiyle büyük ölçüde aynı, v4'teki gibi)
+# Küçük iyileştirme: get_num_params metodu eklendi.
+class NeuralNetwork(nn.Module):
+    """ Dinamik olarak yapılandırılabilen basit bir PyTorch MLP modeli. """
+    def __init__(self, input_size: int, output_size: int, hidden_dims: List[int], activations: List[str]):
+        super().__init__()
+        self.input_size = input_size
+        self.output_size = output_size
+        self.hidden_dims = hidden_dims
+        self.activations_str = activations
+
+        layers = []
+        last_dim = input_size
+        for i, h_dim in enumerate(hidden_dims):
+            layers.append(nn.Linear(last_dim, h_dim))
+            act_func_str = activations[i].lower()
+            if act_func_str == 'relu': layers.append(nn.ReLU())
+            elif act_func_str == 'tanh': layers.append(nn.Tanh())
+            elif act_func_str == 'sigmoid': layers.append(nn.Sigmoid())
+            else:
+                logging.warning(f"Bilinmeyen aktivasyon '{activations[i]}', ReLU kullanılıyor.")
+                layers.append(nn.ReLU())
+            last_dim = h_dim
+        layers.append(nn.Linear(last_dim, output_size))
+
+        self.network = nn.Sequential(*layers)
+        self.architecture_id = self._generate_architecture_id()
+        self.model_name = f"model_{self.architecture_id}_rnd{random.randint(10000, 99999)}"
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.network(x)
+
+    def get_architecture(self) -> Dict[str, Any]:
+        return {"input_size": self.input_size, "output_size": self.output_size,
+                "hidden_dims": self.hidden_dims, "activations": self.activations_str}
+
+    def _generate_architecture_id(self) -> str:
+        h_dims_str = '_'.join(map(str, self.hidden_dims))
+        acts_str = ''.join([a[0].upper() for a in self.activations_str])
+        return f"I{self.input_size}_H{h_dims_str}_A{acts_str}_O{self.output_size}"
+
+    def get_num_params(self, trainable_only: bool = True) -> int:
+        """ Modeldeki parametre sayısını döndürür. """
+        if trainable_only:
+            return sum(p.numel() for p in self.parameters() if p.requires_grad)
+        else:
+            return sum(p.numel() for p in self.parameters())
+
+    def __eq__(self, other):
+        if not isinstance(other, NeuralNetwork): return NotImplemented
+        return self.get_architecture() == other.get_architecture()
+
+    def __hash__(self):
+         arch_tuple = (self.input_size, self.output_size, tuple(self.hidden_dims), tuple(self.activations_str))
+         return hash(arch_tuple)
+
+
+# --- Neuroevolution Çekirdeği (PyTorch v5) ---
+
+# (create_individual_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+def create_individual_pytorch(input_size: int, output_size: int) -> NeuralNetwork:
+    """ Rastgele mimariye sahip bir PyTorch NeuralNetwork modeli oluşturur. """
+    try:
+        num_hidden_layers = random.randint(1, 4)
+        hidden_dims = [random.randint(16, 128) for _ in range(num_hidden_layers)]
+        activations = [random.choice(['relu', 'tanh', 'sigmoid']) for _ in range(num_hidden_layers)]
+        model = NeuralNetwork(input_size, output_size, hidden_dims, activations)
+        logging.debug(f"Created individual: {model.model_name} with {model.get_num_params()} params")
+        return model
+    except Exception as e:
+        logging.error(f"Error creating PyTorch individual model: {e}", exc_info=True)
+        raise
+
+# (clone_pytorch_model fonksiyonu öncekiyle aynı, v4'teki gibi)
+def clone_pytorch_model(model: NeuralNetwork, device: torch.device) -> NeuralNetwork:
+    """ Bir PyTorch modelini (mimari ve ağırlıklar) klonlar. """
+    try:
+        arch = model.get_architecture()
+        cloned_model = NeuralNetwork(**arch)
+        cloned_model.load_state_dict(copy.deepcopy(model.state_dict()))
+        cloned_model.to(device)
+        cloned_model.model_name = f"cloned_{model.model_name}_{random.randint(1000,9999)}"
+        logging.debug(f"Cloned model {model.model_name} to {cloned_model.model_name}")
+        return cloned_model
+    except Exception as e:
+        logging.error(f"Error cloning PyTorch model {model.model_name}: {e}", exc_info=True)
+        raise
+
+
+# Bu fonksiyon paralel işçiler tarafından çağrılacak
+# Doğrudan model objesi yerine state_dict ve mimari alıyor
+def _calculate_fitness_worker(
+    model_arch: Dict[str, Any],
+    model_state_dict: Dict[str, torch.Tensor],
+    X_np: np.ndarray, # Veriyi NumPy olarak alalım
+    y_np: np.ndarray,
+    device_str: str, # Cihazı string olarak alalım
+    fitness_params: Dict # Karmaşıklık cezası vb.
+) -> float:
+    """ Bir modelin fitness'ını hesaplayan işçi fonksiyonu (paralel kullanım için). """
+    try:
+        # 1. Modeli yeniden oluştur
+        device = torch.device(device_str)
+        model = NeuralNetwork(**model_arch)
+        model.load_state_dict(model_state_dict)
+        model.to(device)
+        model.eval()
+
+        # 2. Veriyi Tensör'e çevir ve cihaza taşı
+        X = torch.from_numpy(X_np).float().to(device)
+        y = torch.from_numpy(y_np).float().to(device)
+
+        # 3. Fitness Hesaplama (v4'teki calculate_fitness_pytorch benzeri)
+        complexity_penalty_weight = fitness_params.get('complexity_penalty', 0.0)
+
+        with torch.no_grad():
+            y_pred = model(X)
+            mse_val = torch.mean((y_pred - y)**2).item()
+
+        if not np.isfinite(mse_val):
+            # Worker'da loglama yapmak yerine None veya özel bir değer döndürebiliriz
+            # logging.warning(f"Worker: Non-finite MSE ({mse_val}) for model.")
+            return -np.inf # Ana süreçte işlenecek
+
+        # Temel fitness (MSE'nin tersi)
+        fitness_score = 1.0 / (mse_val + 1e-9)
+
+        # Karmaşıklık Cezası Ekle
+        if complexity_penalty_weight > 0:
+            num_params = model.get_num_params(trainable_only=True)
+            complexity_penalty = complexity_penalty_weight * num_params
+            fitness_score -= complexity_penalty
+            # print(f"Debug: Model params: {num_params}, penalty: {complexity_penalty:.4f}, score after penalty: {fitness_score:.4f}") # DEBUG
+
+        # --- KAVRAMSAL: Diğer Gelişmiş Fitness Metrikleri ---
+        # tau_weight = fitness_params.get('w_tau', 0.0)
+        # if tau_weight > 0:
+        #     y_np_local = y.cpu().numpy()
+        #     y_pred_np_local = y_pred.cpu().numpy()
+        #     tau_val = calculate_avg_kendall_tau(y_np_local, y_pred_np_local, sample_size=100)
+        #     fitness_score += tau_weight * tau_val
+        # ----------------------------------------------------
+
+        if not np.isfinite(fitness_score):
+            return -np.inf
+
+        return float(fitness_score)
+
+    except Exception as e:
+        # Hataları ana sürece bildirmek için loglama yerine None/exception döndürmek daha iyi olabilir
+        # Ancak basitlik için burada loglayıp çok düşük değer döndürelim
+        # logging.error(f"Error in fitness worker: {e}", exc_info=True) # Bu log dosyasına yazılmaz
+        print(f"[Worker Error] Failed to calculate fitness: {e}", file=sys.stderr) # stderr'a yazdır
+        return -np.inf # Hata durumunda
+
+
+# (mutate_individual_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+# Sadece mutasyon gücünü parametre olarak alıyor
+def mutate_individual_pytorch(
+    individual: NeuralNetwork,
+    weight_mut_rate: float,
+    current_mutation_strength: float, # Adaptif olarak gelen güç
+    device: torch.device
+) -> NeuralNetwork:
+    """ Bir PyTorch bireyine adaptif güçle ağırlık mutasyonu uygular. """
+    try:
+        mutated_model = clone_pytorch_model(individual, device)
+        mutated_model.model_name = f"mutated_{individual.model_name}_{random.randint(1000,9999)}"
+        mutated = False
+        state_dict = mutated_model.state_dict()
+        new_state_dict = copy.deepcopy(state_dict)
+
+        for name, param in new_state_dict.items():
+            if param.requires_grad and random.random() < weight_mut_rate :
+                 mutated = True
+                 noise = torch.randn_like(param) * current_mutation_strength # Adaptif gücü kullan
+                 new_state_dict[name] = param + noise.to(param.device)
+
+        if mutated:
+            mutated_model.load_state_dict(new_state_dict)
+            logging.debug(f"Mutated model {individual.model_name} -> {mutated_model.model_name} with strength {current_mutation_strength:.4f}")
+            return mutated_model
+        else:
+            logging.debug(f"Mutation applied to {individual.model_name}, but no weights changed based on rate.")
+            return mutated_model # Klonlanmış modeli döndür
+
+    except Exception as e:
+        logging.error(f"Error during PyTorch mutation of model {individual.model_name}: {e}", exc_info=True)
+        return clone_pytorch_model(individual, device)
+
+
+# (check_architecture_compatibility_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+def check_architecture_compatibility_pytorch(model1: NeuralNetwork, model2: NeuralNetwork) -> bool:
+    return model1.get_architecture() == model2.get_architecture()
+
+# (crossover_individuals_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+def crossover_individuals_pytorch(
+    parent1: NeuralNetwork,
+    parent2: NeuralNetwork,
+    device: torch.device
+) -> Tuple[Optional[NeuralNetwork], Optional[NeuralNetwork]]:
+    """ İki PyTorch ebeveynden basit ağırlık ortalaması/karıştırması ile çocuklar oluşturur. """
+    if not check_architecture_compatibility_pytorch(parent1, parent2):
+        logging.debug(f"Skipping crossover between {parent1.model_name} and {parent2.model_name} due to incompatible architectures.")
+        return None, None
+    try:
+        arch = parent1.get_architecture()
+        child1 = NeuralNetwork(**arch).to(device)
+        child2 = NeuralNetwork(**arch).to(device)
+        child1.model_name = f"xover_{parent1.architecture_id}_c1_{random.randint(1000,9999)}"
+        child2.model_name = f"xover_{parent1.architecture_id}_c2_{random.randint(1000,9999)}"
+        p1_state, p2_state = parent1.state_dict(), parent2.state_dict()
+        c1_state, c2_state = child1.state_dict(), child2.state_dict()
+        for name in p1_state:
+            param1, param2 = p1_state[name], p2_state[name]
+            mask = torch.rand_like(param1) < 0.5
+            c1_state[name] = torch.where(mask, param1, param2)
+            c2_state[name] = torch.where(mask, param2, param1)
+        child1.load_state_dict(c1_state)
+        child2.load_state_dict(c2_state)
+        logging.debug(f"Crossover performed between {parent1.model_name} and {parent2.model_name}")
+        return child1, child2
+    except Exception as e:
+        logging.error(f"Error during PyTorch crossover between {parent1.model_name} and {parent2.model_name}: {e}", exc_info=True)
+        return None, None
+
+# (tournament_selection fonksiyonu öncekiyle aynı, v4'teki gibi)
+def tournament_selection(
+    population: List[NeuralNetwork],
+    fitness_scores: List[float],
+    k: int
+) -> NeuralNetwork:
+    """ Turnuva seçimi ile popülasyondan bir birey seçer. """
+    if not population: raise ValueError("Population cannot be empty")
+    valid_indices = [i for i, score in enumerate(fitness_scores) if np.isfinite(score)]
+    if not valid_indices:
+        logging.warning("No individuals with finite fitness scores found for tournament selection. Returning random individual.")
+        return random.choice(population)
+    if len(valid_indices) < k: k = len(valid_indices)
+    if k <= 0: k = 1
+
+    try:
+        # Sadece geçerli fitness'a sahip olanlar arasından seç
+        tournament_indices_pool = random.sample(valid_indices, k)
+        tournament_contenders = [(fitness_scores[i], population[i]) for i in tournament_indices_pool]
+        winner = max(tournament_contenders, key=lambda item: item[0])[1]
+        return winner
+    except Exception as e:
+        logging.error(f"Error during tournament selection: {e}", exc_info=True)
+        return random.choice(population) # Hata durumunda rastgele
+
+
+# --- Checkpointing (PyTorch v5) ---
+# (save_checkpoint_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+# İsteğe bağlı: Adaptif durum veya W&B run ID'si eklenebilir.
+def save_checkpoint_pytorch(output_dir: str, generation: int, population: List[NeuralNetwork],
+                            rnd_state: Any, np_rnd_state: Any, torch_rnd_state: Any,
+                            wandb_run_id: Optional[str] = None): # W&B ID'si ekle
+    """ Evrim durumunu (PyTorch v5) kaydeder. """
+    checkpoint_dir = os.path.join(output_dir, "checkpoints_pytorch_v5")
+    os.makedirs(checkpoint_dir, exist_ok=True)
+    checkpoint_file = os.path.join(checkpoint_dir, f"evo_gen_{generation}.pt")
+    logging.info(f"Saving checkpoint for generation {generation} to {checkpoint_file}...")
+
+    population_state = []
+    for model in population:
+        try:
+            population_state.append({
+                "name": model.model_name,
+                "architecture": model.get_architecture(),
+                "state_dict": model.state_dict()
+            })
+        except Exception as e:
+            logging.error(f"Could not serialize model {model.model_name} for checkpoint: {e}")
+
+    state = {
+        "version": "v5", # Sürüm bilgisi ekle
+        "generation": generation,
+        "population_state": population_state,
+        "random_state": rnd_state,
+        "numpy_random_state": np_rnd_state,
+        "torch_random_state": torch_rnd_state,
+        "wandb_run_id": wandb_run_id, # W&B run ID
+        "timestamp": datetime.now().isoformat()
+        # İsteğe bağlı: Adaptif mutasyonun mevcut durumu (current_mutation_strength, stagnation_counter)
+    }
+    try:
+        torch.save(state, checkpoint_file)
+        logging.info(f"Checkpoint saved successfully for generation {generation}.")
+    except Exception as e:
+        logging.error(f"Failed to save checkpoint using torch.save for generation {generation}: {e}", exc_info=True)
+
+# (load_checkpoint_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+# Sadece W&B run ID'sini okur
+def load_checkpoint_pytorch(checkpoint_path: str, device: torch.device) -> Optional[Dict]:
+    """ Kaydedilmiş PyTorch v5 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:
+        checkpoint = torch.load(checkpoint_path, map_location=torch.device('cpu'))
+        if checkpoint.get("version") != "v5":
+             logging.warning(f"Loading checkpoint from a different version ({checkpoint.get('version', 'Unknown')}). Compatibility not guaranteed.")
+
+        population = []
+        for model_state in checkpoint["population_state"]:
+            try:
+                arch = model_state["architecture"]
+                model = NeuralNetwork(**arch)
+                model.load_state_dict(model_state["state_dict"])
+                model.to(device)
+                model.model_name = model_state.get("name", f"loaded_model_{random.randint(1000,9999)}")
+                model.eval()
+                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}", exc_info=True)
+
+        if not population:
+            logging.error("Failed to load any model from the checkpoint population state.")
+            return None
+
+        checkpoint["population"] = population
+        logging.info(f"Checkpoint loaded successfully. Resuming from generation {checkpoint['generation'] + 1}.")
+        # W&B ID'sini döndür
+        checkpoint["wandb_run_id"] = checkpoint.get("wandb_run_id")
+        return checkpoint
+    except Exception as e:
+        logging.error(f"Failed to load checkpoint from {checkpoint_path}: {e}", exc_info=True)
+        return None
+
+# (find_latest_checkpoint_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+# Sadece klasör adını v5'e göre güncelleyebiliriz
+def find_latest_checkpoint_pytorch(output_dir: str) -> Optional[str]:
+    """ Verilen klasördeki en son PyTorch v5 checkpoint dosyasını (.pt) bulur. """
+    checkpoint_dir = os.path.join(output_dir, "checkpoints_pytorch_v5") # v5 klasörü
+    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(".pt")]
+    if not checkpoints: return None
+    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ü (PyTorch v5 - Adaptif, Paralel) ---
+def evolve_population_pytorch_v5(
+    population: List[NeuralNetwork],
+    X_train_np: np.ndarray, y_train_np: np.ndarray, # Veriyi NumPy olarak al
+    start_generation: int, total_generations: int,
+    crossover_rate: float, mutation_rate: float, weight_mut_rate: float,
+    args: argparse.Namespace, # Tüm argümanları alalım
+    output_dir: str, device: torch.device,
+    wandb_run: Optional[Any] # W&B run objesi
+) -> Tuple[Optional[NeuralNetwork], List[float], List[float]]:
+    """ PyTorch v5 tabanlı evrimsel süreci çalıştırır (Adaptif, Paralel). """
+
+    best_fitness_history = []
+    avg_fitness_history = []
+    best_model_overall: Optional[NeuralNetwork] = None
+    best_fitness_overall = -np.inf
+
+    # Adaptif Mutasyon için başlangıç değerleri
+    current_mutation_strength = args.mutation_strength
+    stagnation_counter = 0
+
+    pop_size = len(population)
+    fitness_params = {'complexity_penalty': args.complexity_penalty} # Fitness worker için parametreler
+
+    # Paralel işleyici havuzu (eğer worker > 0 ise)
+    # 'fork' yerine 'spawn' kullanmak daha güvenli olabilir (özellikle CUDA ile)
+    # Ancak 'spawn' daha fazla overhead yaratabilir. Duruma göre seçilebilir.
+    # context = torch.multiprocessing.get_context("spawn") if args.num_workers > 0 else None
+    # executor = concurrent.futures.ProcessPoolExecutor(max_workers=args.num_workers, mp_context=context) if args.num_workers > 0 else None
+    executor = concurrent.futures.ProcessPoolExecutor(max_workers=args.num_workers) if args.num_workers > 0 else None
+    if executor:
+         logging.info(f"Using ProcessPoolExecutor with {args.num_workers} workers for fitness evaluation.")
+
+    try: # Executor'ı düzgün kapatmak için try...finally
+        for gen in range(start_generation, total_generations):
+            generation_start_time = time.time()
+
+            # 1. Fitness Değerlendirme (Paralel veya Seri)
+            fitness_scores = [-np.inf] * pop_size # Başlangıç değeri
+            population_states = [(ind.get_architecture(), ind.state_dict()) for ind in population]
+
+            try:
+                if executor and args.num_workers > 0:
+                    futures = [executor.submit(_calculate_fitness_worker,
+                                               arch, state, X_train_np, y_train_np,
+                                               str(device), fitness_params)
+                               for arch, state in population_states]
+                    # concurrent.futures.wait(futures) # Beklemeye gerek yok, as_completed daha iyi
+                    results = []
+                    # Sonuçları geldikçe işle (sırasız gelebilir)
+                    for i, future in enumerate(concurrent.futures.as_completed(futures)):
+                        try:
+                            result = future.result()
+                            results.append(result)
+                            # print(f"DEBUG: Worker {i} finished with fitness {result}") # DEBUG
+                        except Exception as exc:
+                            logging.error(f"Fitness calculation job {i} generated an exception: {exc}")
+                            results.append(-np.inf) # Hata durumunda minimum fitness
+                    # Sonuçları doğru sıraya koymak GEREKLİ DEĞİL çünkü seçilim/elitizm zaten skorlara göre çalışır
+                    # Ancak loglama/takip için orijinal sıra önemliyse, future'ları dict ile takip edip sıraya dizmek gerekir.
+                    # Basitlik için, sonuç listesinin popülasyonla aynı sırada olduğunu varsayalım (as_completed sırayı bozar!)
+                    # DÜZELTME: Sonuçları sıraya dizmek ŞART. Future'ları indeksle takip et.
+                    results_map = {}
+                    futures_map = {executor.submit(_calculate_fitness_worker,
+                                                   pop[0], pop[1], X_train_np, y_train_np,
+                                                   str(device), fitness_params): index
+                                   for index, pop in enumerate(population_states)}
+
+                    for future in concurrent.futures.as_completed(futures_map):
+                        original_index = futures_map[future]
+                        try:
+                            result = future.result()
+                            fitness_scores[original_index] = result
+                        except Exception as exc:
+                            logging.error(f'Individual {original_index} generated an exception: {exc}')
+                            fitness_scores[original_index] = -np.inf # Hata durumunda
+
+                else: # Seri hesaplama (num_workers=0)
+                    logging.debug("Calculating fitness sequentially...")
+                    temp_device = torch.device("cpu") # Seri hesaplamayı CPU'da yapmak GPU'yu meşgul etmez
+                    # Ana süreçte modeli CPU'ya taşı, hesapla, sonucu al
+                    for i, (arch, state) in enumerate(population_states):
+                         # Modeli her seferinde yeniden oluşturmak yerine klonlamak daha verimli olabilir mi?
+                         # Ancak _calculate_fitness_worker mantığına uymak için yeniden oluşturalım.
+                         try:
+                              model_instance = NeuralNetwork(**arch)
+                              model_instance.load_state_dict(state)
+                              model_instance.to(temp_device)
+                              fitness_scores[i] = calculate_fitness_pytorch( # Bu fonksiyon artık sadece seri için
+                                                                           model_instance, X_train_np, y_train_np,
+                                                                           temp_device, fitness_params)
+                         except Exception as e:
+                              logging.error(f"Error calculating fitness for individual {i} sequentially: {e}")
+                              fitness_scores[i] = -np.inf
+
+
+            except Exception as e:
+                logging.critical(f"Error during fitness evaluation distribution/collection in Gen {gen+1}: {e}", exc_info=True)
+                raise # Bu kritik bir hata, devam etmek zor
+
+            # Fitness hesaplama sonrası GPU belleğini temizle (paralel workerlar ayrı process olduğu için burada etkisi olmaz ama seri için kalabilir)
+            # if device.type == 'cuda': torch.cuda.empty_cache()
+
+            # 2. İstatistikler ve En İyiyi Takip
+            valid_indices = [i for i, score in enumerate(fitness_scores) if np.isfinite(score)]
+            if not valid_indices:
+                logging.error(f"Generation {gen+1}: No individuals with finite fitness scores found! Cannot proceed.")
+                # Burada ne yapmalı? Popülasyonu sıfırlamak mı, durmak mı? Şimdilik duralım.
+                raise RuntimeError(f"Evolution stopped at generation {gen+1} due to lack of valid individuals.")
+
+            current_best_idx_local = np.argmax([fitness_scores[i] for i in valid_indices])
+            current_best_idx_global = valid_indices[current_best_idx_local]
+            current_best_fitness = fitness_scores[current_best_idx_global]
+
+            finite_scores = [fitness_scores[i] for i in valid_indices]
+            avg_fitness = np.mean(finite_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_pytorch_model(population[current_best_idx_global], device)
+                    logging.info(f"Generation {gen+1}: *** New overall best fitness: {best_fitness_overall:.6f} (Model: {best_model_overall.model_name}) ***")
+                except Exception as e:
+                    logging.error(f"Could not clone new best model {population[current_best_idx_global].model_name}: {e}", exc_info=True)
+                    best_model_overall = None
+            # else: # En iyi bulunamadıysa veya aynıysa
+            #     pass # Stagnation sayacı aşağıda artacak
+
+            generation_time = time.time() - generation_start_time
+            logging.info(f"Generation {gen+1}/{total_generations} | Best Fitness: {current_best_fitness:.6f} | Avg Fitness: {avg_fitness:.6f} | Mut Strength: {current_mutation_strength:.4f} | Time: {generation_time:.2f}s")
+
+            # W&B Loglama (eğer aktifse)
+            if wandb_run:
+                try:
+                    wandb_run.log({
+                        "generation": gen + 1,
+                        "best_fitness": current_best_fitness,
+                        "average_fitness": avg_fitness,
+                        "mutation_strength": current_mutation_strength,
+                        "generation_time_sec": generation_time,
+                        "num_valid_individuals": len(valid_indices),
+                     #   "best_model_params": best_model_overall.get_num_params() if best_model_overall else None # En iyinin parametre sayısı
+                    }, step=gen + 1) # Adım olarak nesil numarasını kullan
+                except Exception as e:
+                    logging.warning(f"Failed to log metrics to W&B: {e}")
+
+
+            # Adaptif Mutasyon Gücü Güncelleme
+            if args.adapt_mutation:
+                if new_best_found:
+                    stagnation_counter = 0
+                    current_mutation_strength = max(args.min_mut_strength, current_mutation_strength * args.mut_strength_decay)
+                    logging.debug(f"Improvement found. Decreasing mutation strength to {current_mutation_strength:.4f}")
+                else:
+                    stagnation_counter += 1
+                    logging.debug(f"No improvement. Stagnation counter: {stagnation_counter}")
+                    if stagnation_counter >= args.stagnation_limit:
+                        current_mutation_strength = min(args.max_mut_strength, current_mutation_strength * args.mut_strength_increase)
+                        logging.info(f"Stagnation detected ({stagnation_counter} gens). Increasing mutation strength to {current_mutation_strength:.4f}")
+                        stagnation_counter = 0 # Sayacı sıfırla
+
+            # 3. Yeni Popülasyon Oluşturma (Elitizm, Çaprazlama, Mutasyon)
+            new_population = []
+
+            # 3a. Elitizm
+            if args.elitism_count > 0 and len(population) >= args.elitism_count:
+                try:
+                    # Sadece geçerli fitness'a sahip elitleri seç
+                    sorted_valid_indices = sorted(valid_indices, key=lambda i: fitness_scores[i], reverse=True)
+                    elite_indices = sorted_valid_indices[:args.elitism_count]
+                    for idx in elite_indices:
+                        elite_clone = clone_pytorch_model(population[idx], device)
+                        elite_clone.model_name = f"elite_{population[idx].model_name}"
+                        new_population.append(elite_clone)
+                    logging.debug(f"Added {len(new_population)} elites to the next generation.")
+                except Exception as e:
+                    logging.error(f"Error during elitism: {e}", exc_info=True)
+
+            # 3b. Kalanları Üretme
+            num_to_generate = pop_size - len(new_population)
+            generated_count = 0
+            reproduction_attempts = 0
+            max_reproduction_attempts = num_to_generate * 5 # Daha cömert sınır
+
+            while generated_count < num_to_generate and reproduction_attempts < max_reproduction_attempts:
+                reproduction_attempts += 1
+                try:
+                    parent1 = tournament_selection(population, fitness_scores, args.tournament_size)
+                    parent2 = tournament_selection(population, fitness_scores, args.tournament_size)
+                    child1, child2 = None, None
+
+                    if random.random() < crossover_rate and parent1 is not parent2:
+                        child1, child2 = crossover_individuals_pytorch(parent1, parent2, device)
+
+                    if child1 is None: # Çaprazlama olmadıysa veya başarısızsa
+                        if random.random() < mutation_rate:
+                             parent_to_mutate = parent1
+                             child1 = mutate_individual_pytorch(parent_to_mutate, weight_mut_rate, current_mutation_strength, device)
+                        else: # Klonlama
+                             child1 = clone_pytorch_model(parent1, device)
+                             child1.model_name = f"direct_clone_{parent1.model_name}_{random.randint(1000,9999)}"
+
+                    if child1:
+                        new_population.append(child1); generated_count += 1
+                        if generated_count >= num_to_generate: break
+                    if child2:
+                        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 (attempt {reproduction_attempts}): {e}", exc_info=True)
+
+            if generated_count < num_to_generate:
+                logging.warning(f"Reproduction cycle failed to generate enough individuals. Adding {num_to_generate - generated_count} random individuals.")
+                # Rastgele bireyleri eklemeden önce popülasyonun boş olmadığından emin ol
+                if population:
+                     input_s = population[0].input_size
+                     output_s = population[0].output_size
+                     for _ in range(num_to_generate - generated_count):
+                         try:
+                             random_ind = create_individual_pytorch(input_s, output_s).to(device)
+                             new_population.append(random_ind)
+                         except Exception as e:
+                             logging.error(f"Failed to create random individual to fill population: {e}")
+                else: # İlk popülasyon da boşsa veya hata oluştuysa
+                     logging.error("Cannot create random individuals as initial population is unavailable.")
+
+
+            population = new_population[:pop_size] # Boyutu garantile
+
+            # 4. Checkpoint Alma
+            if args.checkpoint_interval > 0 and (gen + 1) % args.checkpoint_interval == 0:
+                 try:
+                     rnd_state = random.getstate()
+                     np_rnd_state = np.random.get_state()
+                     torch_rnd_state = torch.get_rng_state().cpu() # CPU state'i kaydet
+                     wandb_id = wandb_run.id if wandb_run else None
+                     save_checkpoint_pytorch(output_dir, gen + 1, population, rnd_state, np_rnd_state, torch_rnd_state, wandb_id)
+                 except Exception as e:
+                     logging.error(f"Failed to execute checkpoint saving for generation {gen+1}: {e}", exc_info=True)
+
+            # Bellek temizliği (çok büyük ağlarda işe yarayabilir)
+            # import gc; gc.collect()
+            # if device.type == 'cuda': torch.cuda.empty_cache()
+
+    finally: # Executor'ı her zaman kapat
+        if executor:
+            logging.info("Shutting down ProcessPoolExecutor...")
+            executor.shutdown(wait=True) # İşlerin bitmesini bekle
+            logging.info("Executor shut down.")
+
+
+    # Evrim Sonu
+    if best_model_overall is None and population:
+        logging.warning("Evolution finished, but no single best model was tracked. Selecting best from final population.")
+        # Son popülasyondan en iyiyi seçmek için fitness'ları tekrar hesapla (veya son skorları kullan?)
+        # En güvenlisi tekrar hesaplamak:
+        final_population_states = [(ind.get_architecture(), ind.state_dict()) for ind in population]
+        final_fitness_scores = [-np.inf] * len(population)
+        # Seri hesaplama yapalım (executor kapalı)
+        temp_device = torch.device("cpu")
+        for i, (arch, state) in enumerate(final_population_states):
+             try:
+                  model_instance = NeuralNetwork(**arch); model_instance.load_state_dict(state); model_instance.to(temp_device)
+                  final_fitness_scores[i] = calculate_fitness_pytorch(model_instance, X_train_np, y_train_np, temp_device, fitness_params)
+             except Exception: final_fitness_scores[i] = -np.inf
+
+        final_valid_indices = [i for i, score in enumerate(final_fitness_scores) if np.isfinite(score)]
+        if final_valid_indices:
+            best_idx_final = max(final_valid_indices, key=lambda i: final_fitness_scores[i])
+            best_model_overall = clone_pytorch_model(population[best_idx_final], device)
+            best_fitness_overall = final_fitness_scores[best_idx_final]
+            logging.info(f"Selected best model from final population: {best_model_overall.model_name} with fitness {best_fitness_overall:.6f}")
+        else:
+            logging.error("Evolution finished. No valid finite fitness scores in the final population.")
+            return None, best_fitness_history, avg_fitness_history
+    elif not population:
+         logging.error("Evolution finished with an empty population!")
+         return None, best_fitness_history, avg_fitness_history
+    else: # best_model_overall zaten bulundu
+         logging.info(f"Evolution finished. Best fitness achieved: {best_fitness_overall:.6f} by model {best_model_overall.model_name}")
+
+    return best_model_overall, best_fitness_history, avg_fitness_history
+
+
+# --- Fitness Hesaplama (Seri - Ana Süreç veya Worker=0 için) ---
+# Paralel worker'dan farklı olarak modeli doğrudan alır.
+def calculate_fitness_pytorch(
+    individual: NeuralNetwork,
+    X_np: np.ndarray, y_np: np.ndarray, # Veriyi NumPy olarak alır
+    device: torch.device,
+    fitness_params: Dict
+) -> float:
+    """ Bir bireyin fitness değerini hesaplar (Seri kullanım için). """
+    individual.eval()
+    individual.to(device)
+    # Veriyi Tensör'e çevir ve cihaza taşı
+    try:
+        X = torch.from_numpy(X_np).float().to(device)
+        y = torch.from_numpy(y_np).float().to(device)
+    except Exception as e:
+         logging.error(f"Error converting data to tensor or moving to device in calculate_fitness_pytorch: {e}")
+         return -np.inf
+
+    complexity_penalty_weight = fitness_params.get('complexity_penalty', 0.0)
+
+    try:
+        with torch.no_grad():
+            y_pred = individual(X)
+            mse_val = torch.mean((y_pred - y)**2).item()
+
+        if not np.isfinite(mse_val):
+            logging.warning(f"Non-finite MSE ({mse_val}) for model {individual.model_name} (Serial Calc). Assigning minimal fitness.")
+            return -np.inf
+
+        fitness_score = 1.0 / (mse_val + 1e-9)
+
+        if complexity_penalty_weight > 0:
+            num_params = individual.get_num_params(trainable_only=True)
+            complexity_penalty = complexity_penalty_weight * num_params
+            fitness_score -= complexity_penalty
+
+        if not np.isfinite(fitness_score):
+             logging.warning(f"Non-finite final fitness ({fitness_score:.4g}) for model {individual.model_name} (Serial Calc). Assigning minimal fitness.")
+             return -np.inf
+
+        return float(fitness_score)
+
+    except Exception as e:
+        logging.error(f"Error during serial fitness calculation for model {individual.model_name}: {e}", exc_info=True)
+        return -np.inf
+
+
+# --- Grafik Çizimi ---
+# (plot_fitness_history fonksiyonu öncekiyle aynı, v4'teki gibi)
+def plot_fitness_history(history_best: List[float], history_avg: List[float], output_dir: str, filename: str = "fitness_history_pytorch_v5.png") -> None:
+    if not history_best or not history_avg: logging.warning("Fitness history empty, cannot plot."); return
+    try:
+        plt.figure(figsize=(12, 7))
+        gens = np.arange(1, len(history_best) + 1)
+        valid_best_indices = [i for i, v in enumerate(history_best) if np.isfinite(v)]
+        valid_avg_indices = [i for i, v in enumerate(history_avg) if np.isfinite(v)]
+        if valid_best_indices: plt.plot(gens[valid_best_indices], np.array(history_best)[valid_best_indices], label="Best Fitness", marker='o', linestyle='-', linewidth=2)
+        if valid_avg_indices: plt.plot(gens[valid_avg_indices], np.array(history_avg)[valid_avg_indices], label="Average Fitness", marker='x', linestyle='--', alpha=0.7)
+        plt.xlabel("Generation"); plt.ylabel("Fitness Score"); plt.title("Evolutionary Fitness History (PyTorch v5)"); plt.legend(); plt.grid(True); plt.tight_layout()
+        plot_path = os.path.join(output_dir, filename); 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 (PyTorch v5) ---
+# (evaluate_model_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+# Sadece loglamayı güncelleyebiliriz.
+def evaluate_model_pytorch(
+    model: NeuralNetwork,
+    X_test_np: np.ndarray, y_test_np: np.ndarray,
+    batch_size: int, device: torch.device
+) -> Dict[str, float]:
+    """ En iyi modeli test verisi üzerinde PyTorch v5 ile 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(f"Evaluating final model {model.model_name} on test data (PyTorch v5)...")
+    model.eval(); model.to(device)
+    try:
+        test_dataset = TensorDataset(torch.from_numpy(X_test_np).float(), torch.from_numpy(y_test_np).float())
+        test_loader = DataLoader(test_dataset, batch_size=batch_size)
+    except Exception as e:
+        logging.error(f"Failed to create PyTorch DataLoader for test data: {e}", exc_info=True)
+        return {"test_mse": np.inf, "avg_kendall_tau": 0.0}
+
+    all_preds, all_targets = [], []
+    total_mse, num_batches = 0.0, 0
+    try:
+        with torch.no_grad():
+            for inputs, targets in test_loader:
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                total_mse += torch.mean((outputs - targets)**2).item()
+                num_batches += 1
+                all_preds.append(outputs.cpu().numpy())
+                all_targets.append(targets.cpu().numpy())
+
+        avg_mse = total_mse / num_batches if num_batches > 0 else np.inf
+        logging.info(f"Final Test MSE: {avg_mse:.6f}")
+        all_preds_np = np.concatenate(all_preds, axis=0)
+        all_targets_np = np.concatenate(all_targets, axis=0)
+        sample_size = min(500, all_targets_np.shape[0]); taus = []
+        if sample_size > 0:
+            indices = np.random.choice(all_targets_np.shape[0], sample_size, replace=False)
+            for i in indices:
+                try:
+                    tau, _ = kendalltau(all_targets_np[i], all_preds_np[i])
+                    if not np.isnan(tau): taus.append(tau)
+                except ValueError: pass
+        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(avg_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}
+
+
+# --- Son Eğitim (PyTorch v5) ---
+# (train_final_model_pytorch fonksiyonu öncekiyle aynı, v4'teki gibi)
+# Sadece loglamayı güncelleyebiliriz.
+def train_final_model_pytorch(
+    model: NeuralNetwork,
+    X_train_np: np.ndarray, y_train_np: np.ndarray,
+    epochs: int, batch_size: int, learning_rate: float,
+    device: torch.device, output_dir: str,
+    wandb_run: Optional[Any] # W&B objesi
+) -> Tuple[NeuralNetwork, Dict[str, Any]]:
+    """ En iyi evrimleşmiş modeli PyTorch v5 ile eğitir. """
+    logging.info(f"--- Starting Final Training of Best Evolved Model ({model.model_name}) ---")
+    model.to(device)
+    try:
+        train_dataset = TensorDataset(torch.from_numpy(X_train_np).float(), torch.from_numpy(y_train_np).float())
+        val_split = 0.2; num_train = len(train_dataset); split_idx = int(np.floor(val_split * num_train))
+        indices = list(range(num_train)); np.random.shuffle(indices)
+        train_indices, val_indices = indices[split_idx:], indices[:split_idx]
+        train_sampler = torch.utils.data.SubsetRandomSampler(train_indices)
+        val_sampler = torch.utils.data.SequentialSampler(val_indices) # Sıralı yapalım val'ı
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=train_sampler, num_workers=min(4, os.cpu_count() or 1)) # DataLoader workerları
+        val_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=val_sampler, num_workers=min(4, os.cpu_count() or 1))
+        logging.info(f"Created DataLoaders. Train samples: {len(train_indices)}, Val samples: {len(val_indices)}")
+    except Exception as e:
+        logging.error(f"Failed to create DataLoaders for final training: {e}", exc_info=True)
+        return model, {"error": "DataLoader creation failed"}
+
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+    criterion = nn.MSELoss()
+    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.3, patience=7, verbose=False, min_lr=1e-7) # verbose=False
+
+    early_stopping_patience = 15; best_val_loss = np.inf; epochs_no_improve = 0; best_model_state = None
+    training_history = {'train_loss': [], 'val_loss': [], 'lr': []}; epochs_run = 0
+
+    try:
+        for epoch in range(epochs):
+            epochs_run += 1; model.train(); running_train_loss = 0.0
+            for inputs, targets in train_loader:
+                inputs, targets = inputs.to(device), targets.to(device)
+                optimizer.zero_grad(); outputs = model(inputs); loss = criterion(outputs, targets)
+                loss.backward(); optimizer.step()
+                running_train_loss += loss.item()
+            avg_train_loss = running_train_loss / len(train_loader) if len(train_loader) > 0 else 0.0
+            training_history['train_loss'].append(avg_train_loss); training_history['lr'].append(optimizer.param_groups[0]['lr'])
+
+            model.eval(); running_val_loss = 0.0
+            with torch.no_grad():
+                for inputs, targets in val_loader:
+                    inputs, targets = inputs.to(device), targets.to(device)
+                    running_val_loss += criterion(model(inputs), targets).item()
+            avg_val_loss = running_val_loss / len(val_loader) if len(val_loader) > 0 else np.inf
+            training_history['val_loss'].append(avg_val_loss)
+            logging.info(f"Epoch [{epoch+1}/{epochs}] Train Loss: {avg_train_loss:.6f} | Val Loss: {avg_val_loss:.6f} | LR: {optimizer.param_groups[0]['lr']:.2e}")
+
+            # W&B Loglama (final training)
+            if wandb_run:
+                try:
+                    wandb_run.log({
+                        "final_train_epoch": epoch + 1,
+                        "final_train_loss": avg_train_loss,
+                        "final_val_loss": avg_val_loss,
+                        "final_learning_rate": optimizer.param_groups[0]['lr']
+                    }, step=start_generation + epochs_run) # Toplam adım sayısı
+                except Exception as e:
+                     logging.warning(f"Failed to log final training metrics to W&B: {e}")
+
+
+            scheduler.step(avg_val_loss)
+            if avg_val_loss < best_val_loss:
+                best_val_loss = avg_val_loss; epochs_no_improve = 0
+                best_model_state = copy.deepcopy(model.state_dict()); logging.debug(f"New best val loss: {best_val_loss:.6f}")
+            else: epochs_no_improve += 1
+            if epochs_no_improve >= early_stopping_patience:
+                logging.info(f"Early stopping triggered after {epoch+1} epochs."); break
+
+        if best_model_state: logging.info(f"Restoring model to best validation performance."); model.load_state_dict(best_model_state)
+        else: logging.warning("No best model state saved during training.")
+
+        logging.info("Final training complete.")
+        training_summary = {"epochs_run": epochs_run, "final_train_loss": avg_train_loss,
+                            "best_val_loss": best_val_loss, "final_lr": optimizer.param_groups[0]['lr']}
+        return model, training_summary
+
+    except Exception as e:
+        logging.error(f"Error during final PyTorch model training: {e}", exc_info=True)
+        return model, {"error": str(e)}
+
+
+# --- Ana İş Akışı (PyTorch v5) ---
+def run_pipeline_pytorch_v5(args: argparse.Namespace):
+    """ Checkpoint, Adaptif, Paralel PyTorch v5 tabanlı ana iş akışı. """
+
+    wandb_run = None # W&B run objesi
+    output_dir = None # Hata durumunda tanımlı olması için
+
+    try: # Ana try bloğu, W&B finish için
+        device = setup_device(args.device)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        run_name = f"evorun_pt_v5_{timestamp}_gen{args.generations}_pop{args.pop_size}"
+        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)
+        resumed_wandb_id = None
+
+        if resume_run:
+            run_name = os.path.basename(output_dir)
+            logging.info(f"Attempting to resume PyTorch v5 run from: {output_dir}")
+            if not os.path.isdir(output_dir): logging.error(f"Resume directory not found: {output_dir}. Exiting."); sys.exit(1)
+        else:
+            try: os.makedirs(output_dir, exist_ok=True)
+            except OSError as e: print(f"FATAL: Could not create output dir: {output_dir}. Error: {e}", file=sys.stderr); sys.exit(1)
+
+        setup_logging(output_dir)
+        logging.info(f"========== Starting/Resuming EvoNet v5 PyTorch Pipeline: {run_name} ==========")
+        logging.info(f"Output directory: {output_dir}")
+        logging.info(f"Using device: {device}")
+
+        # Checkpoint Yükleme
+        start_generation = 0; population = []; initial_state_loaded = False; loaded_history_best = []; loaded_history_avg = []
+        latest_checkpoint_path = find_latest_checkpoint_pytorch(output_dir) if resume_run else None
+
+        if latest_checkpoint_path:
+            loaded_state = load_checkpoint_pytorch(latest_checkpoint_path, device)
+            if loaded_state:
+                start_generation = loaded_state['generation']
+                population = loaded_state['population']
+                resumed_wandb_id = loaded_state.get("wandb_run_id") # W&B ID'sini al
+                try: # Random state yükleme
+                    random.setstate(loaded_state['random_state']); np.random.set_state(loaded_state['numpy_random_state'])
+                    torch.set_rng_state(loaded_state['torch_random_state'].cpu())
+                    logging.info(f"Random states restored from checkpoint (Generation {start_generation}).")
+                except Exception as e: logging.warning(f"Could not fully restore random states: {e}")
+                initial_state_loaded = True
+                logging.info(f"Resuming from Generation {start_generation + 1} with {len(population)} individuals.")
+                if resumed_wandb_id: logging.info(f"Found previous W&B run ID in checkpoint: {resumed_wandb_id}")
+            else: logging.error("Failed to load checkpoint. Starting from scratch."); resume_run = False
+        elif resume_run: logging.warning(f"Resume requested but no valid v5 checkpoint found. Starting from scratch."); resume_run = False
+
+
+        # W&B Başlatma (eğer argüman verildiyse ve kütüphane varsa)
+        if args.use_wandb and _WANDB_AVAILABLE:
+             try:
+                 wandb_kwargs = {
+                     "project": args.wandb_project,
+                     "entity": args.wandb_entity,
+                     "name": run_name,
+                     "config": vars(args), # Argümanları kaydet
+                     "dir": output_dir, # Logları çıktı klasörüne yazdır
+                     "resume": "allow", # Devam etmeye izin ver
+                     "id": resumed_wandb_id # Eğer varsa önceki ID'yi kullan
+                 }
+                 # Entity boşsa argümandan çıkar
+                 if not wandb_kwargs["entity"]: del wandb_kwargs["entity"]
+
+                 wandb_run = wandb.init(**wandb_kwargs)
+                 logging.info(f"Weights & Biases initialized. Run ID: {wandb_run.id if wandb_run else 'N/A'}")
+                 # Eğer yeni bir run başladıysa (resume edilmediyse) veya ID değiştiyse W&B ID'sini logla
+                 if wandb_run and (not resume_run or wandb_run.id != resumed_wandb_id):
+                      logging.info(f"Logging to W&B run: {wandb_run.get_url()}" if wandb_run else "W&B run URL not available.")
+
+             except Exception as e:
+                 logging.error(f"Failed to initialize Weights & Biases: {e}", exc_info=True)
+                 wandb_run = None # Başarısız olursa devam et ama loglama yapma
+
+
+        # Config Kaydetme/Loglama (v4'teki gibi)
+        config_path = os.path.join(output_dir, "config_pytorch_v5.json")
+        args_dict = vars(args)
+        if not initial_state_loaded or not os.path.exists(config_path):
+             logging.info("--- Configuration ---")
+             for k, v in args_dict.items(): logging.info(f"  {k:<25}: {v}")
+             logging.info("---------------------")
+             try:
+                 args_to_save = args_dict.copy(); args_to_save['device'] = str(device)
+                 with open(config_path, 'w') as f: json.dump(args_to_save, 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)
+        else: # Devam ediliyorsa logla
+            try:
+                 with open(config_path, 'r') as f: loaded_args_dict = json.load(f)
+                 logging.info("--- Loaded Configuration (from resumed run) ---")
+                 for k, v in loaded_args_dict.items(): logging.info(f"  {k:<25}: {v}")
+                 logging.info("-----------------------------------------------")
+            except Exception as e: logging.warning(f"Could not reload config.json: {e}")
+
+
+        # Random Tohum Ayarlama (sadece sıfırdan başlarken)
+        if not initial_state_loaded:
+            try:
+                seed = args.seed
+                random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
+                if device.type == 'cuda': torch.cuda.manual_seed_all(seed)
+                logging.info(f"Using random seed: {seed}")
+            except Exception as e: logging.warning(f"Could not set all random seeds: {e}")
+
+
+        # Veri Üretimi (her zaman)
+        try:
+            logging.info("Generating/Reloading data...")
+            X_train_np, y_train_np = generate_data(args.train_samples, args.seq_length)
+            X_test_np, y_test_np = generate_data(args.test_samples, args.seq_length)
+            input_shape = X_train_np.shape[1]
+            output_shape = y_train_np.shape[1]
+        except Exception: logging.critical("Failed to generate/reload data. Exiting."); sys.exit(1)
+
+
+        # Popülasyon Başlatma (sadece sıfırdan başlarken)
+        if not initial_state_loaded:
+            logging.info(f"--- Initializing Population (Size: {args.pop_size}) ---")
+            try:
+                population = [create_individual_pytorch(input_shape, output_shape).to(device) 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/Resuming PyTorch v5 Evolution ({args.generations} Total Generations) ---")
+        best_model_evolved: Optional[NeuralNetwork] = None
+        best_fitness_hist = loaded_history_best
+        avg_fitness_hist = loaded_history_avg
+
+        if start_generation >= args.generations:
+            logging.warning(f"Loaded checkpoint gen ({start_generation}) >= total gens ({args.generations}). Skipping evolution.")
+            # Checkpoint'ten en iyiyi al (v4'teki gibi TODO: daha iyi yöntem)
+            if population:
+                # Son popülasyondan en iyiyi seç (fitness hesaplayarak)
+                 try:
+                     logging.info("Selecting best model from loaded population as evolution is skipped...")
+                     temp_device = torch.device("cpu")
+                     fitness_scores_loaded = [calculate_fitness_pytorch(ind, X_train_np, y_train_np, temp_device, {'complexity_penalty': args.complexity_penalty}) for ind in population]
+                     valid_scores_loaded = [(s, i) for i, s in enumerate(fitness_scores_loaded) if np.isfinite(s)]
+                     if valid_scores_loaded:
+                         best_idx_loaded = max(valid_scores_loaded, key=lambda item: item[0])[1]
+                         best_model_evolved = clone_pytorch_model(population[best_idx_loaded], device)
+                         logging.info(f"Using model {best_model_evolved.model_name} from loaded population.")
+                     else: logging.warning("Could not determine best model from loaded population."); best_model_evolved = None
+                 except Exception as e: logging.error(f"Error selecting best model from loaded population: {e}"); best_model_evolved = None
+            else: best_model_evolved = None
+        else:
+            try:
+                best_model_evolved, gen_best_hist, gen_avg_hist = evolve_population_pytorch_v5(
+                    population, X_train_np, y_train_np, start_generation, args.generations,
+                    args.crossover_rate, args.mutation_rate, args.weight_mut_rate,
+                    args, # Tüm argümanları geçir
+                    output_dir, device, wandb_run
+                )
+                best_fitness_hist.extend(gen_best_hist)
+                avg_fitness_hist.extend(gen_avg_hist)
+            except Exception as e:
+                logging.critical(f"Fatal error during PyTorch v5 evolution process: {e}", exc_info=True)
+                raise # Hatayı yukarı fırlat
+
+        logging.info("--- PyTorch v5 Evolution Complete ---")
+
+        # Fitness Geçmişi Kaydet/Çizdir (v4'teki gibi)
+        if best_fitness_hist or avg_fitness_hist:
+            plot_fitness_history(best_fitness_hist, avg_fitness_hist, output_dir)
+            history_path = os.path.join(output_dir, "fitness_history_pytorch_v5.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"Full fitness history saved to {history_path}")
+                # W&B'ye tablo olarak logla (opsiyonel)
+                if wandb_run:
+                    try:
+                         table = wandb.Table(data=history_data, columns=["Generation", "BestFitness", "AvgFitness"])
+                         wandb_run.log({"fitness_history_table": table})
+                    except Exception as e: logging.warning(f"Failed to log fitness history table to W&B: {e}")
+
+            except Exception as e: logging.error(f"Could not save fitness history data: {e}")
+        else: logging.warning("Fitness history empty, skipping saving/plotting.")
+
+        # En İyi Modeli Eğit/Değerlendir/Kaydet
+        final_model_path = None; training_summary = {}; final_metrics = {"test_mse": np.inf, "avg_kendall_tau": 0.0}; best_model_architecture = {}
+        if best_model_evolved is None:
+            logging.error("Evolution did not yield a best model. Skipping final training and evaluation.")
+        else:
+            best_model_architecture = best_model_evolved.get_architecture()
+            logging.info(f"Best evolved model architecture: {best_model_architecture}")
+            try:
+                num_params = best_model_evolved.get_num_params(); logging.info(f"Best Evolved Model ({best_model_evolved.model_name}) - Params: {num_params}")
+                if wandb_run: wandb_run.summary["best_evolved_params"] = num_params # W&B özete ekle
+            except Exception as e: logging.warning(f"Could not log model summary details: {e}")
+
+            # Son Eğitim
+            try:
+                 model_to_train = clone_pytorch_model(best_model_evolved, device)
+                 final_model, training_summary = train_final_model_pytorch(
+                     model_to_train, X_train_np, y_train_np,
+                     args.epochs_final_train, args.batch_size, args.learning_rate,
+                     device, output_dir, wandb_run
+                 )
+            except Exception as e: logging.error(f"Error during final training: {e}", exc_info=True); final_model = None; training_summary = {"error": str(e)}
+
+            # Değerlendirme ve Kaydetme
+            if final_model:
+                 final_metrics = evaluate_model_pytorch(final_model, X_test_np, y_test_np, args.batch_size, device)
+                 if wandb_run: wandb_run.summary.update(final_metrics) # W&B özete ekle
+
+                 final_model_path = os.path.join(output_dir, "best_evolved_model_trained_pytorch_v5.pt")
+                 try:
+                     torch.save({'architecture': final_model.get_architecture(), 'model_state_dict': final_model.state_dict(),
+                                 'training_summary': training_summary, 'evaluation_metrics': final_metrics}, final_model_path)
+                     logging.info(f"Final trained model state and architecture saved to {final_model_path}")
+                     # W&B'ye artifact olarak kaydet (opsiyonel)
+                     if wandb_run:
+                          try:
+                               artifact = wandb.Artifact(f'final_model_{run_name}', type='model')
+                               artifact.add_file(final_model_path)
+                               wandb_run.log_artifact(artifact)
+                               logging.info(f"Saved final model as W&B artifact.")
+                          except Exception as e: logging.warning(f"Failed to save model as W&B artifact: {e}")
+                 except Exception as e: logging.error(f"Failed to save final trained model: {e}", exc_info=True); final_model_path = None
+            else: logging.error("Final model training failed. Skipping evaluation and saving.")
+
+        # Sonuçları Kaydet
+        logging.info("--- Saving Final Results (v5) ---")
+        final_results = {
+            "run_info": {"run_name": run_name, "timestamp": timestamp, "output_directory": output_dir, "framework": "PyTorch",
+                         "version": "v5", "device_used": str(device), "resumed_run": resume_run, "last_checkpoint": latest_checkpoint_path,
+                         "wandb_url": wandb_run.get_url() if wandb_run else None},
+            "config": args_dict,
+            "evolution_summary": {
+                "start_generation": start_generation, "end_generation": start_generation + len(best_fitness_hist),
+                "generations_run_this_session": len(best_fitness_hist) - len(loaded_history_best),
+                "best_fitness_overall": max(best_fitness_hist) if best_fitness_hist and any(np.isfinite(f) for f in best_fitness_hist) else None,
+                "best_fitness_final_gen": best_fitness_hist[-1] if best_fitness_hist and np.isfinite(best_fitness_hist[-1]) else None,
+                "avg_fitness_final_gen": avg_fitness_hist[-1] if avg_fitness_hist and np.isfinite(avg_fitness_hist[-1]) else None,
+                "best_model_architecture": best_model_architecture,
+                "best_model_params": best_model_evolved.get_num_params() if best_model_evolved else None
+            },
+            "final_training_summary": training_summary,
+            "final_evaluation_on_test": final_metrics,
+            "saved_trained_model_path": final_model_path
+        }
+        results_path = os.path.join(output_dir, "final_results_pytorch_v5.json")
+        try:
+            def convert_types(obj): # JSON için tür dönüştürücü
+                if isinstance(obj, (np.integer, np.int_)): return int(obj)
+                elif isinstance(obj, (np.floating, np.float_)): return float(obj)
+                elif isinstance(obj, np.ndarray): return obj.tolist()
+                elif isinstance(obj, torch.Tensor): return obj.tolist()
+                elif isinstance(obj, torch.device): return str(obj)
+                elif isinstance(obj, type): return obj.__name__
+                elif isinstance(obj, argparse.Namespace): return vars(obj) # Argümanları dict yap
+                return obj
+            with open(results_path, 'w') as f: json.dump(final_results, f, indent=4, default=convert_types, sort_keys=True)
+            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)
+
+    except (Exception, KeyboardInterrupt) as e:
+         # Hata veya kesinti durumunda loglama ve W&B bitirme
+         if isinstance(e, KeyboardInterrupt):
+              logging.warning("KeyboardInterrupt detected. Exiting.")
+         else:
+              logging.critical("Unhandled exception in pipeline:", exc_info=True)
+         # W&B run'ı "crashed" veya "failed" olarak işaretle
+         if wandb_run:
+              exit_code = 1 if not isinstance(e, KeyboardInterrupt) else 130
+              try:
+                   wandb.finish(exit_code=exit_code, quiet=True)
+                   logging.info(f"W&B run marked as {'failed' if exit_code==1 else 'killed'}.")
+              except Exception as wb_e:
+                   logging.error(f"Error finishing W&B run: {wb_e}")
+         # Hatayı tekrar fırlat veya çık
+         if isinstance(e, KeyboardInterrupt): sys.exit(130)
+         else: sys.exit(1)
+
+    finally:
+        # W&B run'ı normal şekilde bitir (eğer hata olmadıysa)
+        if wandb_run and not sys.exc_info()[0]: # Sadece hata yoksa bitir
+             try:
+                 wandb.finish()
+                 logging.info("W&B run finished successfully.")
+             except Exception as e:
+                 logging.error(f"Error finishing W&B run: {e}")
+
+        logging.info(f"========== PyTorch v5 Pipeline Run {run_name} Finished ==========")
+
+
+# --- Argüman Ayrıştırıcı (v5) ---
+def parse_arguments_v5() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="EvoNet v5: Adaptive & Parallel Neuroevolution with PyTorch")
+
+    # --- Dizinler ve Kontrol ---
+    parser.add_argument('--output_base_dir', type=str, default=DEFAULT_OUTPUT_BASE_DIR)
+    parser.add_argument('--resume_from', type=str, default=None, help='Path to previous run dir to resume.')
+    parser.add_argument('--checkpoint_interval', type=int, default=DEFAULT_CHECKPOINT_INTERVAL, help='Checkpoint frequency (gens). 0=disable.')
+    parser.add_argument('--device', type=str, default=DEFAULT_DEVICE, choices=['auto', 'cpu', 'cuda'])
+    parser.add_argument('--seed', type=int, default=None, help='Random seed (default: random).')
+
+    # --- Veri ---
+    parser.add_argument('--seq_length', type=int, default=DEFAULT_SEQ_LENGTH)
+    parser.add_argument('--train_samples', type=int, default=5000)
+    parser.add_argument('--test_samples', type=int, default=1000)
+
+    # --- Evrim Parametreleri ---
+    evo_group = parser.add_argument_group('Evolution Parameters')
+    evo_group.add_argument('--pop_size', type=int, default=DEFAULT_POP_SIZE)
+    evo_group.add_argument('--generations', type=int, default=DEFAULT_GENERATIONS)
+    evo_group.add_argument('--crossover_rate', type=float, default=DEFAULT_CROSSOVER_RATE)
+    evo_group.add_argument('--mutation_rate', type=float, default=DEFAULT_MUTATION_RATE, help='Prob. of mutation if crossover is not applied.')
+    evo_group.add_argument('--weight_mut_rate', type=float, default=DEFAULT_WEIGHT_MUT_RATE, help='Prob. for each weight to mutate if mutation occurs.')
+    evo_group.add_argument('--tournament_size', type=int, default=DEFAULT_TOURNAMENT_SIZE)
+    evo_group.add_argument('--elitism_count', type=int, default=DEFAULT_ELITISM_COUNT)
+    evo_group.add_argument('--complexity_penalty', type=float, default=DEFAULT_COMPLEXITY_PENALTY, help='Penalty weight per parameter in fitness.')
+
+    # --- Adaptif Mutasyon ---
+    adapt_group = parser.add_argument_group('Adaptive Mutation')
+    adapt_group.add_argument('--adapt_mutation', action=argparse.BooleanOptionalAction, default=DEFAULT_ADAPT_MUTATION, help='Enable adaptive mutation strength.')
+    adapt_group.add_argument('--mutation_strength', type=float, default=DEFAULT_MUTATION_STRENGTH, help='Initial mutation strength (std dev).')
+    adapt_group.add_argument('--stagnation_limit', type=int, default=DEFAULT_STAGNATION_LIMIT, help='Generations without improvement to trigger adaptation.')
+    adapt_group.add_argument('--mut_strength_decay', type=float, default=DEFAULT_MUT_STRENGTH_DECAY, help='Factor to decrease strength on improvement.')
+    adapt_group.add_argument('--mut_strength_increase', type=float, default=DEFAULT_MUT_STRENGTH_INCREASE, help='Factor to increase strength on stagnation.')
+    adapt_group.add_argument('--min_mut_strength', type=float, default=DEFAULT_MIN_MUT_STRENGTH)
+    adapt_group.add_argument('--max_mut_strength', type=float, default=DEFAULT_MAX_MUT_STRENGTH)
+
+    # --- Paralellik ---
+    parallel_group = parser.add_argument_group('Parallelism')
+    parallel_group.add_argument('--num_workers', type=int, default=DEFAULT_NUM_WORKERS, help='Number of CPU workers for parallel fitness evaluation (0=disable/serial).')
+
+    # --- Eğitim ve Değerlendirme ---
+    train_group = parser.add_argument_group('Final Training & Evaluation')
+    train_group.add_argument('--batch_size', type=int, default=DEFAULT_BATCH_SIZE)
+    train_group.add_argument('--epochs_final_train', type=int, default=DEFAULT_EPOCHS_FINAL_TRAIN)
+    train_group.add_argument('--learning_rate', type=float, default=0.001, help='LR for final training.')
+
+    # --- Deney Takibi (W&B) ---
+    wandb_group = parser.add_argument_group('Experiment Tracking (Weights & Biases)')
+    wandb_group.add_argument('--use_wandb', action=argparse.BooleanOptionalAction, default=False, help='Enable W&B logging.')
+    wandb_group.add_argument('--wandb_project', type=str, default="EvoNet-v5", help='W&B project name.')
+    wandb_group.add_argument('--wandb_entity', type=str, default=None, help='W&B entity (username or team). Uses default if None.') # Genellikle kullanıcı adı veya takım
+
+    args = parser.parse_args()
+    if args.seed is None: args.seed = random.randint(0, 2**32 - 1); print(f"Generated random seed: {args.seed}")
+    if args.num_workers < 0: print(f"Warning: num_workers ({args.num_workers}) cannot be negative. Setting to 0."); args.num_workers = 0
+    # Diğer v4 kontrolleri (elitism, tournament size) burada da yapılabilir.
+
+    return args
+
+# --- Ana Çalıştırma Bloğu ---
+if __name__ == "__main__":
+    # Önemli Not: concurrent.futures (özellikle ProcessPoolExecutor) ve
+    # multiprocessing'in düzgün çalışması için ana kod bloğunun
+    # `if __name__ == "__main__":` içinde olması genellikle gereklidir.
+    cli_args = parse_arguments_v5()
+    run_pipeline_pytorch_v5(cli_args)