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