v4.py

# ==============================================================================
# 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