Upload 11 files

config-classification-v6.txt

@@ -0,0 +1,74 @@
+# config-classification-v6.txt - Quanta Classifier V6 için Yapılandırma
+# Veri Seti Üzerinde Sınıflandırma
+
+[NEAT]
+fitness_criterion     = max
+fitness_threshold     = 0.98  # Hedef doğruluk oranı (%98) - Veriye göre ayarlanabilir
+pop_size              = 300   # Daha zor görev ve iyi CPU için artırıldı
+reset_on_extinction   = False
+
+[DefaultGenome]
+# node activation options
+activation_default      = sigmoid # Çıkış katmanı dahil sigmoid uygun
+activation_mutate_rate  = 0.1     # Aktivasyon mutasyonunu hafifçe açabiliriz (isteğe bağlı)
+activation_options      = sigmoid relu tanh clamped # Daha fazla seçenek ekleyebiliriz
+
+# node aggregation options
+aggregation_default     = sum
+aggregation_mutate_rate = 0.0
+aggregation_options     = sum
+
+# node bias options (önceki gibi)
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+bias_mutate_power       = 0.5
+bias_mutate_rate        = 0.7
+bias_replace_rate       = 0.1
+
+# genome compatibility options (önceki gibi)
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient   = 0.5
+
+# connection add/remove rates (önceki gibi)
+conn_add_prob           = 0.5
+conn_delete_prob        = 0.5
+
+# connection enable options (önceki gibi)
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+
+feed_forward            = True
+initial_connection      = full_nodirect
+
+# node add/remove rates (önceki gibi)
+node_add_prob           = 0.2
+node_delete_prob        = 0.2
+
+# network parameters
+num_hidden              = 0
+num_inputs              = 2   # Örnek veri setimiz için 2 özellik (feature)
+num_outputs             = 1   # Binary sınıflandırma için 1 sigmoid çıktı
+
+# species options (önceki gibi)
+species_fitness_func = max
+max_stagnation       = 25    # Stagnasyonu biraz artırabiliriz
+species_set_size     = 40    # Tür sayısını artırabiliriz
+
+# weight options (önceki gibi)
+weight_init_mean      = 0.0
+weight_init_stdev     = 1.0
+weight_max_value      = 30
+weight_min_value      = -30
+weight_mutate_power   = 0.5
+weight_mutate_rate    = 0.8
+weight_replace_rate   = 0.1
+
+[DefaultSpeciesSet]
+compatibility_threshold = 3.0
+
+[DefaultStagnation]
+species_fitness_func = max
+max_stagnation       = 20    # Türler için stagnasyon (globalden farklı)
+species_elitism      = 2

config-feedforward-v3.txt

@@ -0,0 +1,73 @@
+# config-feedforward-v3.txt
+
+[NEAT]
+fitness_criterion     = max
+fitness_threshold     = 0.98  # V3 için eşik, ayarlanabilir
+pop_size              = 150
+reset_on_extinction   = False
+
+[DefaultGenome]
+# node activation options
+activation_default      = sigmoid
+activation_mutate_rate  = 0.0
+activation_options      = sigmoid
+
+# node aggregation options
+aggregation_default     = sum
+aggregation_mutate_rate = 0.0
+aggregation_options     = sum
+
+# node bias options
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+bias_mutate_power       = 0.5
+bias_mutate_rate        = 0.7
+bias_replace_rate       = 0.1
+
+# genome compatibility options
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient   = 0.5
+
+# connection add/remove rates
+conn_add_prob           = 0.5
+conn_delete_prob        = 0.5
+
+# connection enable options
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+
+feed_forward            = True
+initial_connection      = full_nodirect # Başlangıçta girdilerle çıktılar arası bağlantı
+
+# node add/remove rates
+node_add_prob           = 0.2
+node_delete_prob        = 0.2
+
+# network parameters
+num_hidden              = 0
+num_inputs              = 2 # <-- YENİ DEĞER: Artık 2 girdimiz var
+num_outputs             = 1
+
+# species options
+species_fitness_func = max
+max_stagnation       = 20
+species_set_size     = 30
+
+# weight options
+weight_init_mean      = 0.0
+weight_init_stdev     = 1.0
+weight_max_value      = 30
+weight_min_value      = -30
+weight_mutate_power   = 0.5
+weight_mutate_rate    = 0.8
+weight_replace_rate   = 0.1
+
+[DefaultSpeciesSet]
+compatibility_threshold = 3.0
+
+[DefaultStagnation]
+species_fitness_func = max
+max_stagnation       = 15
+species_elitism      = 2

config-feedforward-v4.txt

@@ -0,0 +1,55 @@
+# config-feedforward-v4.txt
+
+[NEAT]
+fitness_criterion     = max
+fitness_threshold     = 0.96  # V4 için eşik, zorluk arttı, ayarlanabilir
+pop_size              = 200   # Daha zor problem için popülasyonu artırabiliriz
+reset_on_extinction   = False
+
+[DefaultGenome]
+# ... (V3'teki bias, activation, aggregation, compatibility, connection, enabled ayarları aynı kalabilir) ...
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+bias_mutate_power       = 0.5
+bias_mutate_rate        = 0.7
+bias_replace_rate       = 0.1
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient   = 0.5
+conn_add_prob           = 0.5
+conn_delete_prob        = 0.5
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+feed_forward            = True
+initial_connection      = full_nodirect
+
+# node add/remove rates
+node_add_prob           = 0.3 # Biraz daha fazla yapısal çeşitlilik için artırılabilir
+node_delete_prob        = 0.2
+
+# network parameters
+num_hidden              = 0
+num_inputs              = 2 # V3'teki gibi
+num_outputs             = 2 # <-- YENİ DEĞER: Artık 2 çıktımız var
+
+# ... (V3'teki species, stagnation, weight ayarları aynı kalabilir) ...
+species_fitness_func = max
+max_stagnation       = 20
+species_set_size     = 30
+weight_init_mean      = 0.0
+weight_init_stdev     = 1.0
+weight_max_value      = 30
+weight_min_value      = -30
+weight_mutate_power   = 0.5
+weight_mutate_rate    = 0.8
+weight_replace_rate   = 0.1
+
+
+[DefaultSpeciesSet]
+compatibility_threshold = 3.0
+
+[DefaultStagnation]
+species_fitness_func = max
+max_stagnation       = 15
+species_elitism      = 2

config-feedforward-v5.txt

@@ -0,0 +1,74 @@
+# config-feedforward-v5.txt - Quanta Simulator V5 için Yapılandırma
+# Non-Linear Hedefler + Karmaşıklık Cezası
+
+[NEAT]
+fitness_criterion     = max
+fitness_threshold     = 0.95  # V5 için hedef eşik (zorluk nedeniyle biraz düşük)
+pop_size              = 250   # Donanım (i7-12700H) için artırılmış popülasyon
+reset_on_extinction   = False
+
+[DefaultGenome]
+# node activation options
+activation_default      = sigmoid
+activation_mutate_rate  = 0.0
+activation_options      = sigmoid
+
+# node aggregation options
+aggregation_default     = sum
+aggregation_mutate_rate = 0.0
+aggregation_options     = sum
+
+# node bias options
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+bias_mutate_power       = 0.5
+bias_mutate_rate        = 0.7
+bias_replace_rate       = 0.1
+
+# genome compatibility options
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient   = 0.5
+
+# connection add/remove rates
+conn_add_prob           = 0.5
+conn_delete_prob        = 0.5
+
+# connection enable options
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+
+feed_forward            = True
+initial_connection      = full_nodirect
+
+# node add/remove rates
+node_add_prob           = 0.3 # Yapısal çeşitlilik için biraz artırıldı
+node_delete_prob        = 0.2
+
+# network parameters
+num_hidden              = 0   # Başlangıçta gizli düğüm yok
+num_inputs              = 2   # V5 için 2 girdi
+num_outputs             = 2   # V5 için 2 çıktı
+
+# species options
+species_fitness_func = max
+max_stagnation       = 20    # Türlerin gelişmeden kalabileceği max nesil
+species_set_size     = 30
+
+# weight options
+weight_init_mean      = 0.0
+weight_init_stdev     = 1.0
+weight_max_value      = 30
+weight_min_value      = -30
+weight_mutate_power   = 0.5
+weight_mutate_rate    = 0.8
+weight_replace_rate   = 0.1
+
+[DefaultSpeciesSet]
+compatibility_threshold = 3.0
+
+[DefaultStagnation]
+species_fitness_func = max
+max_stagnation       = 15    # Türler için max_stagnation (globalden farklı olabilir)
+species_elitism      = 2     # Her türden sonraki nesle aktarılacak en iyi birey sayısı

config-feedforward.txt

@@ -0,0 +1,71 @@
+[NEAT]
+fitness_criterion     = max
+fitness_threshold     = 0.99  # Hedef fitness değeri (1.0'a ne kadar yakınsa o kadar iyi)
+pop_size              = 150   # Popülasyon büyüklüğü (Donanımına göre artırılabilir)
+reset_on_extinction   = False
+
+[DefaultGenome]
+# node activation options
+activation_default      = sigmoid
+activation_mutate_rate  = 0.0
+activation_options      = sigmoid
+
+# node aggregation options
+aggregation_default     = sum
+aggregation_mutate_rate = 0.0
+aggregation_options     = sum
+
+# node bias options
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_max_value          = 30.0
+bias_min_value          = -30.0
+bias_mutate_power       = 0.5
+bias_mutate_rate        = 0.7
+bias_replace_rate       = 0.1
+
+# genome compatibility options
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient   = 0.5
+
+# connection add/remove rates
+conn_add_prob           = 0.5
+conn_delete_prob        = 0.5
+
+# connection enable options
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+
+feed_forward            = True  # İleri beslemeli ağ
+initial_connection      = full_nodirect # Başlangıçta tam bağlı (girdi-çıktı arası)
+
+# node add/remove rates
+node_add_prob           = 0.2 # Yeni düğüm ekleme olasılığı
+node_delete_prob        = 0.2 # Düğüm silme olasılığı
+
+# network parameters
+num_hidden              = 0 # Başlangıçta gizli katman yok
+num_inputs              = 1 # Ağ girdisi sayısı (Şimdilik basit, tek sabit girdi)
+num_outputs             = 1 # Ağ çıktısı sayısı (Olasılığı temsil eden tek bir değer)
+
+# species options
+species_fitness_func = max
+max_stagnation       = 20 # Türlerin gelişmeden kalabileceği maksimum nesil sayısı
+species_set_size     = 30
+
+# weight options
+weight_init_mean      = 0.0
+weight_init_stdev     = 1.0
+weight_max_value      = 30
+weight_min_value      = -30
+weight_mutate_power   = 0.5 # Mutasyonun ağırlığı ne kadar değiştireceği
+weight_mutate_rate    = 0.8 # Ağırlıkların mutasyona uğrama olasılığı
+weight_replace_rate   = 0.1 # Ağırlığın tamamen yeni bir değerle değişme olasılığı
+
+[DefaultSpeciesSet]
+compatibility_threshold = 3.0
+
+[DefaultStagnation]
+species_fitness_func = max
+max_stagnation       = 15
+species_elitism      = 2 # Her türden sonraki nesle aktarılacak en iyi birey sayısı

quanta_classifier_v6.py

@@ -0,0 +1,235 @@
+# quanta_classifier_v6.py
+
+import neat
+import numpy as np
+import os
+import logging
+import pickle
+import datetime
+import traceback
+
+# --- YENİ: Scikit-learn importları ---
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+
+# --- Loglama Ayarları ---
+log_filename = f"quanta_log_v6_classifier_{datetime.datetime.now():%Y%m%d_%H%M%S}.log"
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+    handlers=[
+        logging.FileHandler(log_filename),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+logger.info("="*70)
+logger.info("Quanta Classifier Başlatılıyor (Sürüm 6 - Veri Seti ile Sınıflandırma)")
+logger.info(f"Başlangıç Zamanı: {datetime.datetime.now()}")
+logger.info("="*70)
+
+# --- Global Değişkenler (Veri Seti) ---
+# Not: Global değişkenler büyük projelerde önerilmez, ancak NEAT'in
+# fitness fonksiyonuna kolayca veri aktarmak için bu örnekte kullanılmıştır.
+# Daha büyük projelerde sınıf yapısı veya functools.partial tercih edilebilir.
+X_train, X_test, y_train, y_test = None, None, None, None
+
+# --- Veri Seti Oluşturma ve Hazırlama ---
+def prepare_data(n_samples=500, n_features=2, n_informative=2, n_redundant=0, random_state=42):
+    """
+    Scikit-learn kullanarak sentetik bir sınıflandırma veri seti oluşturur ve böler.
+    """
+    global X_train, X_test, y_train, y_test
+    logger.info(f"{n_samples} örnekli, {n_features} özellikli sentetik veri seti oluşturuluyor...")
+
+    X, y = make_classification(
+        n_samples=n_samples,
+        n_features=n_features,
+        n_informative=n_informative,
+        n_redundant=n_redundant,
+        n_clusters_per_class=1, # Sınıf başına küme sayısı
+        flip_y=0.05, # Gürültü ekle (etiketlerin %5'ini ters çevir)
+        random_state=random_state
+    )
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.3, random_state=random_state, stratify=y # Sınıf oranlarını koru
+    )
+    logger.info(f"Veri seti bölündü: {len(X_train)} eğitim, {len(X_test)} test örneği.")
+    logger.info(f"Girdi Boyutu (Özellik Sayısı): {X_train.shape[1]}")
+    logger.info(f"Sınıf Dağılımı (Eğitim): {np.bincount(y_train)}")
+
+
+# --- NEAT Fitness Fonksiyonu (Sınıflandırma için) ---
+def eval_genomes_classification(genomes, config):
+    """
+    Genomları eğitim verisi üzerindeki sınıflandırma doğruluğuna göre değerlendirir.
+    """
+    global X_train, y_train # Global eğitim verisini kullan
+
+    if X_train is None or y_train is None:
+         logger.error("Eğitim verisi yüklenmemiş! Fitness hesaplanamıyor.")
+         # Tüm genomlara düşük fitness ver
+         for genome_id, genome in genomes:
+              genome.fitness = -1.0
+         return
+
+    for genome_id, genome in genomes:
+        genome.fitness = 0.0 # Başlangıç fitness
+        try:
+            net = neat.nn.FeedForwardNetwork.create(genome, config)
+        except Exception as e:
+            logger.error(f"Genome {genome_id} ağ oluşturma hatası: {e}")
+            genome.fitness = -1.0 # Ceza
+            continue
+
+        correct_predictions = 0
+        # Eğitim verisi üzerinde tahmin yap
+        for xi, yi in zip(X_train, y_train):
+            try:
+                output = net.activate(xi)
+                # Binary sınıflandırma: Tek sigmoid çıkışı 0.5 eşiği ile yorumla
+                prediction = 1 if output[0] >= 0.5 else 0
+                if prediction == yi:
+                    correct_predictions += 1
+            except Exception as e:
+                # logger.warning(f"G:{genome_id} Aktivasyon hatası: {e}")
+                pass # Hatalı aktivasyonları sayma
+
+        # Fitness = Doğruluk Oranı (Accuracy)
+        accuracy = correct_predictions / len(y_train)
+        genome.fitness = accuracy
+        # logger.debug(f"Genome {genome_id}: Accuracy = {accuracy:.4f}, Fitness = {genome.fitness:.4f}")
+
+
+# --- NEAT Çalıştırma Fonksiyonu ---
+def run_neat(config_file, generations=100):
+    """
+    NEAT evrimini başlatır, yönetir ve sonucu değerlendirir.
+    """
+    logger.info(f"NEAT yapılandırması yükleniyor: {config_file}")
+    config = None
+    try:
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_file)
+        logger.info(f"Yapılandırma: Giriş={config.genome_config.num_inputs}, Çıkış={config.genome_config.num_outputs}, Pop={config.pop_size}, Eşik={config.fitness_threshold}")
+        # Yapılandırmadaki girdi sayısı ile veri setinin özellik sayısını kontrol et
+        if config.genome_config.num_inputs != X_train.shape[1]:
+             logger.error(f"Yapılandırma hatası: Config'deki girdi sayısı ({config.genome_config.num_inputs}) veri özelliği sayısı ({X_train.shape[1]}) ile eşleşmiyor!")
+             return None
+        # Binary sınıflandırma için çıktı sayısını kontrol et
+        if config.genome_config.num_outputs != 1:
+             logger.warning(f"Yapılandırma uyarısı: Binary sınıflandırma için çıktı sayısı ({config.genome_config.num_outputs}) genellikle 1 olmalıdır.")
+
+    except Exception as e:
+        logger.critical(f"Yapılandırma dosyası yüklenemedi: {config_file} - Hata: {e}")
+        return None
+
+    logger.info("Yeni popülasyon oluşturuluyor...")
+    p = neat.Population(config)
+
+    # Raporlayıcılar
+    p.add_reporter(neat.StdOutReporter(True)) # Konsola detaylı raporlama
+    stats = neat.StatisticsReporter() # İstatistikleri toplar (ileride görselleştirme için)
+    p.add_reporter(stats)
+    checkpoint_prefix = 'neat-checkpoint-v6-'
+    p.add_reporter(neat.Checkpointer(generation_interval=20, filename_prefix=checkpoint_prefix)) # 20 nesilde bir checkpoint
+    logger.info(f"Checkpoint dosyaları '{checkpoint_prefix}*' olarak kaydedilecek.")
+
+    logger.info(f"Evrim başlıyor (Maksimum {generations} nesil)...")
+    winner = None
+    try:
+        # Fitness fonksiyonunu (eval_genomes_classification) çalıştır
+        winner = p.run(eval_genomes_classification, generations)
+        logger.info(' ' + "="*30 + " Evrim Tamamlandı " + "="*30)
+    except Exception as e:
+        logger.critical(f"Evrim sırasında kritik bir hata oluştu: {e}")
+        logger.error(traceback.format_exc())
+        if not winner and p and p.best_genome:
+             logger.warning("Evrim hata ile durdu, bulunan son en iyi genom kullanılıyor.")
+             winner = p.best_genome
+
+    # En iyi genomu işle
+    if winner:
+        logger.info(f'En iyi genom bulundu/kullanıldı (Fitness - Eğitim Doğruluğu: {winner.fitness:.6f}):')
+        num_nodes = len(winner.nodes)
+        num_connections = len(winner.connections)
+        logger.info(f'Kazanan Karmaşıklığı: {num_nodes} Düğüm, {num_connections} Bağlantı')
+
+        # En iyi genomu kaydet
+        winner_filename = "winner_classifier_v6.pkl"
+        try:
+            with open(winner_filename, 'wb') as f:
+                pickle.dump(winner, f)
+            logger.info(f"En iyi genom '{winner_filename}' dosyasına başarıyla kaydedildi.")
+        except Exception as e:
+            logger.error(f"En iyi genom kaydedilemedi: {e}")
+
+        # --- YENİ: En İyi Genomun TEST SETİ Üzerinde Değerlendirilmesi ---
+        logger.info(" " + "="*20 + " En İyi Genomun Test Seti Performansı " + "="*20)
+        try:
+            if config is None:
+                 logger.error("Yapılandırma yüklenemediği için final test atlanıyor.")
+                 raise RuntimeError("Config object is None.")
+
+            winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
+
+            # Test seti üzerinde tahmin yap
+            y_pred = []
+            logger.info(f"Test seti ({len(X_test)} örnek) üzerinde tahminler yapılıyor...")
+            for xi in X_test:
+                output = winner_net.activate(xi)
+                prediction = 1 if output[0] >= 0.5 else 0
+                y_pred.append(prediction)
+
+            # Performans metriklerini hesapla ve raporla
+            accuracy_test = accuracy_score(y_test, y_pred)
+            conf_matrix = confusion_matrix(y_test, y_pred)
+            class_report = classification_report(y_test, y_pred)
+
+            logger.info(f"\n--- Test Seti Sonuçları ---")
+            logger.info(f"Doğruluk (Accuracy): {accuracy_test:.4f}")
+            logger.info(f"\nKarışıklık Matrisi (Confusion Matrix):\n{conf_matrix}")
+            logger.info(f"\nSınıflandırma Raporu:\n{class_report}")
+            logger.info("---------------------------\n")
+
+        except Exception as e:
+            logger.error(f"En iyi genom test edilirken hata oluştu: {e}")
+            logger.error(traceback.format_exc())
+    else:
+        logger.warning("Evrim sonunda test edilecek bir kazanan genom bulunamadı.")
+
+    logger.info("="*70)
+    logger.info("Quanta Classifier Adım 6 (Veri Seti ile Sınıflandırma) tamamlandı.")
+    logger.info(f"Bitiş Zamanı: {datetime.datetime.now()}")
+    logger.info("="*70)
+    # return winner
+
+
+if __name__ == '__main__':
+    # Betiğin bulunduğu dizini al
+    local_dir = os.path.dirname(os.path.abspath(__file__))
+    # V6 config dosyasının tam yolunu oluştur
+    config_path = os.path.join(local_dir, 'config-classification-v6.txt')
+
+    if not os.path.exists(config_path):
+        logger.critical(f"Yapılandırma dosyası bulunamadı: {config_path}")
+    else:
+        try:
+            # 1. Veri setini hazırla
+            prepare_data(n_samples=1000, n_features=2, n_informative=2, random_state=123)
+
+            # 2. NEAT evrimini çalıştır (Config'deki eşiğe ulaşana kadar veya max nesil)
+            # MAX_GENERATIONS sabitini burada da tanımlayabiliriz:
+            MAX_GENERATIONS_RUN = 150 # Deneme için 150 nesil, gerekirse artırılır
+            run_neat(config_path, generations=MAX_GENERATIONS_RUN)
+
+        except ImportError as ie:
+             logger.critical(f"Gerekli kütüphane bulunamadı: {ie}")
+             logger.critical("Lütfen 'pip install scikit-learn numpy neat-python' komutu ile kurun.")
+        except Exception as main_e:
+            logger.critical(f"Ana program akışında beklenmedik bir hata oluştu: {main_e}")
+            logger.error(traceback.format_exc())

quanta_sim_v1_no_viz.py

@@ -0,0 +1,189 @@
+import neat
+import numpy as np
+import os
+import logging
+import pickle  # En iyi genomu kaydetmek/yüklemek için
+import random
+import math
+import datetime # Log dosyası ismi için
+
+# --- Loglama Ayarları ---
+log_filename = f"quanta_log_{datetime.datetime.now():%Y%m%d_%H%M%S}.log"
+logging.basicConfig(
+    level=logging.INFO, # Log seviyesi (INFO, DEBUG, WARNING, ERROR, CRITICAL)
+    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s', # Log formatı
+    handlers=[
+        logging.FileHandler(log_filename), # Dosyaya loglama
+        logging.StreamHandler()            # Konsola (ekrana) loglama
+    ]
+)
+logger = logging.getLogger(__name__)
+
+logger.info("="*50)
+logger.info("Quanta Simülatörü Başlatılıyor (Görselleştirme Olmadan)")
+logger.info("="*50)
+
+# --- Simülasyon Parametreleri ---
+TARGET_PROB_0 = 0.7  # Hedef: %70 olasılıkla 0 üretmek
+TARGET_PROB_1 = 1.0 - TARGET_PROB_0 # Hedef: %30 olasılıkla 1 üretmek
+NUM_TRIALS_PER_GENOME = 100 # Her genomu değerlendirmek için yapılacak deneme sayısı
+MAX_GENERATIONS = 50 # Maksimum evrim nesli (Donanımınıza göre artırılabilir)
+FITNESS_THRESHOLD = 0.99 # Evrimin durması için ulaşılması gereken minimum fitness
+
+logger.info(f"Hedef P(0): {TARGET_PROB_0:.2f}, Hedef P(1): {TARGET_PROB_1:.2f}")
+logger.info(f"Genom Başına Deneme Sayısı: {NUM_TRIALS_PER_GENOME}")
+logger.info(f"Maksimum Nesil Sayısı: {MAX_GENERATIONS}")
+logger.info(f"Fitness Eşiği: {FITNESS_THRESHOLD}")
+
+# --- Basit Kuantum Benzeri Davranış (Taklit) ---
+# Bu fonksiyon, kuantum ölçümünün olasılıksal sonucunu basitçe taklit eder.
+def simulate_simple_qubit_measurement(prob0=TARGET_PROB_0):
+    if random.random() < prob0:
+        return 0
+    else:
+        return 1
+
+# --- NEAT Fitness Fonksiyonu ---
+# Genomları (sinir ağlarını) değerlendirir.
+# Hedef: Ağın çıktısı TARGET_PROB_0'a yakın olasılıkla 0 olmalı.
+def eval_genomes(genomes, config):
+    """
+    Popülasyondaki tüm genomların fitness değerlerini hesaplar.
+    """
+    for genome_id, genome in genomes:
+        genome.fitness = 0.0 # Başlangıç fitness'ı sıfırla
+        try:
+            net = neat.nn.FeedForwardNetwork.create(genome, config)
+        except Exception as e:
+            logger.error(f"Genome {genome_id} için ağ oluşturulamadı: {e}")
+            genome.fitness = -1.0 # Geçersiz genomları cezalandır
+            continue
+
+        count_0 = 0
+        # Her genomu N kez test ederek istatistiksel olarak değerlendir
+        for _ in range(NUM_TRIALS_PER_GENOME):
+            # Ağ Girdisi: Şimdilik sabit bir değer (1.0) kullanıyoruz.
+            # Gelecekte bu girdi, simülasyonun durumunu veya kontrol parametrelerini yansıtabilir.
+            net_input = (1.0,)
+            try:
+                output = net.activate(net_input)
+                # Ağın çıktısını (genellikle 0-1 arası) yorumla
+                # Çıktı < 0.5 ise 0, >= 0.5 ise 1 kabul edelim
+                if output[0] < 0.5:
+                    count_0 += 1
+            except Exception as e:
+                logger.warning(f"Genome {genome_id} ağ aktivasyonunda hata: {e}")
+                # Hata durumunda bu denemeyi atla veya penaltı ver
+                pass # Şimdilik sadece atlıyoruz
+
+        # Gözlemlenen olasılıkları hesapla
+        observed_prob_0 = count_0 / NUM_TRIALS_PER_GENOME
+
+        # Fitness Hesaplama: Hedef olasılıklara ne kadar yakın?
+        # Ortalama Karesel Hata (MSE) benzeri bir yaklaşım, ama ters çevrilmiş.
+        # Hata ne kadar küçükse, fitness o kadar yüksek olmalı.
+        error = (observed_prob_0 - TARGET_PROB_0) ** 2
+        # Fitness = 1 / (hata + epsilon) -> Hata sıfıra yaklaştıkça fitness sonsuza yaklaşır.
+        # Daha stabil bir fitness için: Fitness = 1.0 - hata (0 ile 1 arasında)
+        # Veya hedef eşiğe göre normalize edilebilir. Şimdilik basit tutalım:
+        fitness = max(0.0, 1.0 - math.sqrt(error)) # Hatanın karekökünü 1'den çıkaralım (0-1 arası)
+
+        genome.fitness = fitness
+        # logger.debug(f"Genome {genome_id}: Fitness = {fitness:.4f}, Gözlenen P(0) = {observed_prob_0:.2f}")
+
+
+# --- NEAT Çalıştırma Fonksiyonu ---
+def run_neat(config_file):
+    """
+    NEAT evrimini başlatır ve yönetir.
+    """
+    logger.info(f"NEAT yapılandırması yükleniyor: {config_file}")
+    try:
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_file)
+        # Fitness eşiğini config dosyasından değil, koddan alalım
+        config.fitness_threshold = FITNESS_THRESHOLD
+        logger.info(f"Yapılandırma yüklendi. Fitness Eşiği: {config.fitness_threshold}")
+
+    except Exception as e:
+        logger.critical(f"Yapılandırma dosyası y��klenemedi veya geçersiz: {config_file} - Hata: {e}")
+        return None # Hata durumunda None döndür
+
+    logger.info("Yeni popülasyon oluşturuluyor...")
+    p = neat.Population(config)
+
+    # İstatistikleri ve loglamayı ayarlama (Sadece konsol çıktısı)
+    p.add_reporter(neat.StdOutReporter(True))
+    # Görselleştirme için istatistik toplayıcıya gerek yok.
+    # stats = neat.StatisticsReporter()
+    # p.add_reporter(stats)
+
+    # Periyodik olarak checkpoint (yedek) alma
+    checkpoint_prefix = 'neat-checkpoint-'
+    p.add_reporter(neat.Checkpointer(10, filename_prefix=checkpoint_prefix)) # Her 10 nesilde bir kaydet
+    logger.info(f"Checkpoint dosyaları '{checkpoint_prefix}*' olarak kaydedilecek.")
+
+    logger.info(f"Evrim başlıyor (Maksimum {MAX_GENERATIONS} nesil)...")
+    try:
+        winner = p.run(eval_genomes, MAX_GENERATIONS)
+        logger.info(' ' + "="*20 + " Evrim Tamamlandı " + "="*20)
+    except Exception as e:
+        logger.critical(f"Evrim sırasında kritik bir hata oluştu: {e}")
+        # Belki son checkpoint'ten devam etme mantığı eklenebilir.
+        return None
+
+    # En iyi genomu göster/kaydet
+    logger.info(f'En iyi genom bulundu:')
+    logger.info(f' {winner}') # Konsola detaylı genom bilgisini yazdırır
+
+    # En iyi genomu dosyaya kaydet (pickle ile)
+    winner_filename = "winner_genome.pkl"
+    try:
+        with open(winner_filename, 'wb') as f:
+            pickle.dump(winner, f)
+        logger.info(f"En iyi genom '{winner_filename}' dosyasına başarıyla kaydedildi.")
+    except Exception as e:
+        logger.error(f"En iyi genom kaydedilemedi: {e}")
+
+    # En iyi genomdan ağı oluştur ve son bir kez test et
+    logger.info(" " + "="*20 + " En İyi Genom Testi " + "="*20)
+    if winner:
+        try:
+            winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
+            test_count_0 = 0
+            test_trials = 1000 # Daha fazla deneme ile güvenilirliği artır
+            logger.info(f"En iyi ağ {test_trials} kez test ediliyor...")
+            for _ in range(test_trials):
+                net_input = (1.0,)
+                output = winner_net.activate(net_input)
+                if output[0] < 0.5:
+                    test_count_0 += 1
+
+            observed_prob_0 = test_count_0 / test_trials
+            logger.info(f"Final Test Sonucu: Gözlenen P(0) = {observed_prob_0:.4f} (Hedef: {TARGET_PROB_0:.3f})")
+            logger.info(f"Final Test Sonucu: Gözlenen P(1) = {1.0 - observed_prob_0:.4f} (Hedef: {TARGET_PROB_1:.3f})")
+            final_error = (observed_prob_0 - TARGET_PROB_0) ** 2
+            logger.info(f"Final Test Hatası (Karesel): {final_error:.6f}")
+        except Exception as e:
+            logger.error(f"En iyi genom test edilirken hata oluştu: {e}")
+    else:
+        logger.warning("Test edilecek bir kazanan genom bulunamadı.")
+
+    logger.info("="*50)
+    logger.info("Quanta Simülatörü Adım 1 (Görselleştirmesiz) tamamlandı.")
+    logger.info("="*50)
+    return winner # Kazanan genomu döndür
+
+
+if __name__ == '__main__':
+    # Yapılandırma dosyasının yolu (Python betiği ile aynı klasörde olduğunu varsayar)
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, 'config-feedforward.txt')
+
+    if not os.path.exists(config_path):
+        logger.critical(f"Yapılandırma dosyası bulunamadı: {config_path}")
+        logger.critical("Lütfen 'config-feedforward.txt' dosyasını Python betiğiyle aynı klasöre koyun.")
+    else:
+        # NEAT'i çalıştır
+        run_neat(config_path)

quanta_sim_v2_input_dep.py

@@ -0,0 +1,237 @@
+# quanta_sim_v2_input_dep.py
+
+import neat
+import numpy as np
+import os
+import logging
+import pickle
+import random
+import math
+import datetime
+# Görselleştirme importları YOKTUR.
+
+# --- Loglama Ayarları ---
+log_filename = f"quanta_log_v2_input_dep_{datetime.datetime.now():%Y%m%d_%H%M%S}.log" # <-- V2 için dosya adı
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+    handlers=[
+        logging.FileHandler(log_filename),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+logger.info("="*50)
+logger.info("Quanta Simülatörü Başlatılıyor (Sürüm 2 - Girdiye Bağlı Olasılık)") # <-- GÜNCELLENDİ
+logger.info("="*50)
+
+# --- Simülasyon Parametreleri ---
+# TARGET_PROB_0 artık sabit değil, girdiye göre hesaplanacak.
+# Bu yüzden aşağıdaki satırları kaldırabilir veya yorum satırı yapabiliriz.
+# TARGET_PROB_0 = 0.7
+# TARGET_PROB_1 = 1.0 - TARGET_PROB_0
+
+NUM_TEST_INPUTS = 6 # Farklı girdi değerlerini test etmek için kullanılacak girdi sayısı
+NUM_TRIALS_PER_INPUT = 20 # Her bir girdi değeri için yapılacak deneme sayısı
+# Toplam deneme sayısı = NUM_TEST_INPUTS * NUM_TRIALS_PER_INPUT (örn: 6 * 20 = 120)
+
+MAX_GENERATIONS = 100 # <-- Gerekirse artırılabilir, problem biraz daha zorlaştı.
+FITNESS_THRESHOLD = 0.98 # <-- Hedef biraz daha zor olduğu için eşiği hafifçe düşürebiliriz (isteğe bağlı)
+
+logger.info(f"Test Edilecek Girdi Sayısı: {NUM_TEST_INPUTS}")
+logger.info(f"Girdi Başına Deneme Sayısı: {NUM_TRIALS_PER_INPUT}")
+logger.info(f"Toplam Değerlendirme Denemesi/Genom: {NUM_TEST_INPUTS * NUM_TRIALS_PER_INPUT}")
+logger.info(f"Maksimum Nesil Sayısı: {MAX_GENERATIONS}")
+logger.info(f"Fitness Eşiği: {FITNESS_THRESHOLD}")
+
+# --- YENİ: Hedef Olasılık Fonksiyonu ---
+def calculate_target_prob0(input_value):
+    """
+    Verilen girdiye göre hedef P(0) olasılığını hesaplar.
+    Lineer Fonksiyon: target_P0(x) = 0.1 + 0.8 * x
+    """
+    return 0.1 + 0.8 * input_value
+
+logger.info(f"Hedef P(0) Fonksiyonu: P(0|x) = 0.1 + 0.8 * x")
+
+# --- NEAT Fitness Fonksiyonu ---
+# (Bu fonksiyon Sürüm 2 için önemli ölçüde güncellendi)
+def eval_genomes(genomes, config):
+    """
+    Popülasyondaki tüm genomların fitness değerlerini hesaplar.
+    Fitness, ağın farklı girdiler için hedeflenen olasılıkları
+    ne kadar iyi üretebildiğine göre belirlenir.
+    """
+    # Test edilecek girdi değerlerini belirleyelim (0 ile 1 arasında eşit aralıklı)
+    test_inputs = np.linspace(0.0, 1.0, NUM_TEST_INPUTS)
+    # Örnek: NUM_TEST_INPUTS=6 ise -> [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
+
+    for genome_id, genome in genomes:
+        genome.fitness = 0.0 # Başlangıç fitness'ı sıfırla
+        try:
+            net = neat.nn.FeedForwardNetwork.create(genome, config)
+        except Exception as e:
+            logger.error(f"Genome {genome_id} için ağ oluşturulamadı: {e}")
+            genome.fitness = -10.0 # Daha büyük ceza verilebilir
+            continue
+
+        total_squared_error = 0.0
+
+        # Her bir test girdisi için ağı değerlendir
+        for net_input_val in test_inputs:
+            net_input = (net_input_val,) # Girdiyi tuple formatına getir
+            target_prob_0 = calculate_target_prob0(net_input_val) # Bu girdi için hedef P(0)
+
+            count_0 = 0
+            # Her girdi için N kez test et
+            for _ in range(NUM_TRIALS_PER_INPUT):
+                try:
+                    output = net.activate(net_input)
+                    # Ağın çıktısını yorumla (< 0.5 ise 0)
+                    if output[0] < 0.5:
+                        count_0 += 1
+                except Exception as e:
+                    logger.warning(f"Genome {genome_id}, Input {net_input_val:.2f} ağ aktivasyonunda hata: {e}")
+                    # Hata durumunda bu denemeyi atla veya penaltı ver
+                    pass # Şimdilik sadece atlıyoruz
+
+            # Gözlemlenen olasılığı hesapla
+            if NUM_TRIALS_PER_INPUT > 0:
+                observed_prob_0 = count_0 / NUM_TRIALS_PER_INPUT
+            else:
+                observed_prob_0 = 0.5 # Sıfıra bölme hatasını önle (pek olası değil ama güvenli)
+
+            # Bu girdi için hatanın karesini hesapla
+            error = (observed_prob_0 - target_prob_0) ** 2
+            total_squared_error += error
+
+            # logger.debug(f"  Genome {genome_id}, Input {net_input_val:.2f}: TargetP0={target_prob_0:.3f}, ObsP0={observed_prob_0:.3f}, Error^2={error:.4f}")
+
+        # Ortalama Karesel Hatayı (Mean Squared Error - MSE) hesapla
+        average_squared_error = total_squared_error / NUM_TEST_INPUTS
+
+        # Fitness'ı hesapla: Hata ne kadar küçükse, fitness o kadar yüksek (Maks 1.0)
+        # Hatanın karekökünü (RMSE gibi) 1'den çıkaralım
+        fitness = max(0.0, 1.0 - math.sqrt(average_squared_error))
+
+        genome.fitness = fitness
+        # logger.info(f"Genome {genome_id}: AvgError^2 = {average_squared_error:.4f}, Fitness = {fitness:.4f}")
+
+
+# --- NEAT Çalıştırma Fonksiyonu ---
+def run_neat(config_file):
+    """
+    NEAT evrimini başlatır ve yönetir.
+    """
+    logger.info(f"NEAT yapılandırması yükleniyor: {config_file}")
+    try:
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_file)
+        # Fitness eşiğini config dosyasından değil, koddan alalım
+        config.fitness_threshold = FITNESS_THRESHOLD # <-- V2 için güncel eşik
+        logger.info(f"Yapılandırma yüklendi. Fitness Eşiği: {config.fitness_threshold}")
+
+    except Exception as e:
+        logger.critical(f"Yapılandırma dosyası yüklenemedi veya geçersiz: {config_file} - Hata: {e}")
+        return None
+
+    logger.info("Yeni popülasyon oluşturuluyor...")
+    p = neat.Population(config)
+
+    # İstatistikleri ve loglamayı ayarlama
+    p.add_reporter(neat.StdOutReporter(True)) # Konsola raporlama
+    # stats = neat.StatisticsReporter() # Görselleştirme YOK, bu yüzden buna gerek yok
+    # p.add_reporter(stats)
+
+    # Checkpoint (yedek) alma
+    checkpoint_prefix = 'neat-checkpoint-v2-' # <-- V2 için farklı prefix
+    p.add_reporter(neat.Checkpointer(10, filename_prefix=checkpoint_prefix))
+    logger.info(f"Checkpoint dosyaları '{checkpoint_prefix}*' olarak kaydedilecek.")
+
+    logger.info(f"Evrim başlıyor (Maksimum {MAX_GENERATIONS} nesil)...")
+    try:
+        winner = p.run(eval_genomes, MAX_GENERATIONS)
+        logger.info(' ' + "="*20 + " Evrim Tamamlandı " + "="*20)
+    except Exception as e:
+        logger.critical(f"Evrim sırasında kritik bir hata oluştu: {e}")
+        return None
+
+    # En iyi genomu göster/kaydet
+    if winner:
+        logger.info(f'En iyi genom bulundu (Fitness: {winner.fitness:.6f}):')
+        logger.info(f' {winner}') # Konsola detaylı genom bilgisini yazdırır
+
+        # En iyi genomu dosyaya kaydet (pickle ile)
+        winner_filename = "winner_genome_v2.pkl" # <-- V2 için farklı dosya adı
+        try:
+            with open(winner_filename, 'wb') as f:
+                pickle.dump(winner, f)
+            logger.info(f"En iyi genom '{winner_filename}' dosyasına başarıyla kaydedildi.")
+        except Exception as e:
+            logger.error(f"En iyi genom kaydedilemedi: {e}")
+
+        # --- YENİ: En İyi Genomu Farklı Girdilerle Test Etme ---
+        logger.info(" " + "="*20 + " En İyi Genom Detaylı Testi " + "="*20)
+        try:
+            winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
+            test_trials_final = 1000 # Her girdi için final test deneme sayısı
+            logger.info(f"En iyi ağ, farklı girdilerle {test_trials_final} kez test ediliyor...")
+
+            test_inputs_final = np.linspace(0.0, 1.0, 11) # Daha fazla ara noktayla test edelim (0.0, 0.1, ..., 1.0)
+            final_total_error_sq = 0.0
+            results = []
+
+            for net_input_val in test_inputs_final:
+                target_p0 = calculate_target_prob0(net_input_val)
+                net_input = (net_input_val,)
+                count_0 = 0
+                for _ in range(test_trials_final):
+                    output = winner_net.activate(net_input)
+                    if output[0] < 0.5:
+                        count_0 += 1
+
+                observed_p0 = count_0 / test_trials_final
+                error_sq = (observed_p0 - target_p0) ** 2
+                final_total_error_sq += error_sq
+                results.append({
+                    "input": net_input_val,
+                    "target_p0": target_p0,
+                    "observed_p0": observed_p0,
+                    "error_sq": error_sq
+                })
+                logger.info(f"  Input={net_input_val: <4.2f} -> TargetP(0)={target_p0: <5.3f}, ObservedP(0)={observed_p0: <5.3f}, Error^2={error_sq:.5f}")
+
+            final_avg_error_sq = final_total_error_sq / len(test_inputs_final)
+            final_rmse = math.sqrt(final_avg_error_sq)
+            logger.info("-" * 40)
+            logger.info(f"Final Ortalama Karesel Hata (MSE): {final_avg_error_sq:.6f}")
+            logger.info(f"Final Kök Ortalama Karesel Hata (RMSE): {final_rmse:.6f}")
+            logger.info(f"Final Fitness Yaklaşımı (1 - RMSE): {1.0 - final_rmse:.6f}")
+            logger.info("-" * 40)
+
+        except Exception as e:
+            logger.error(f"En iyi genom test edilirken hata oluştu: {e}")
+
+    else:
+        logger.warning("Test edilecek bir kazanan genom bulunamadı.")
+
+    logger.info("="*50)
+    logger.info("Quanta Simülatörü Adım 2 (Girdiye Bağlı Olasılık) tamamlandı.")
+    logger.info("="*50)
+    return winner
+
+
+if __name__ == '__main__':
+    # Yapılandırma dosyasının yolu (Python betiği ile aynı klasörde olduğunu varsayar)
+    local_dir = os.path.dirname(__file__)
+    # V1'deki config dosyasını kullanıyoruz, ismi aynı kalabilir.
+    config_path = os.path.join(local_dir, 'config-feedforward.txt')
+
+    if not os.path.exists(config_path):
+        logger.critical(f"Yapılandırma dosyası bulunamadı: {config_path}")
+        logger.critical("Lütfen 'config-feedforward.txt' dosyasını Python betiğiyle aynı klasöre koyun.")
+    else:
+        # NEAT'i çalıştır
+        run_neat(config_path)

quanta_sim_v3_multi_input.py

@@ -0,0 +1,235 @@
+# quanta_sim_v3_multi_input.py
+
+import neat
+import numpy as np
+import os
+import logging
+import pickle
+import random
+import math
+import datetime
+import itertools # <-- YENİ: Girdi kombinasyonları için
+
+# --- Loglama Ayarları ---
+log_filename = f"quanta_log_v3_multi_input_{datetime.datetime.now():%Y%m%d_%H%M%S}.log" # <-- V3 için dosya adı
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+    handlers=[
+        logging.FileHandler(log_filename),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+logger.info("="*50)
+logger.info("Quanta Simülatörü Başlatılıyor (Sürüm 3 - Çoklu Girdi)") # <-- GÜNCELLENDİ
+logger.info("="*50)
+
+# --- Simülasyon Parametreleri ---
+NUM_TEST_VALUES_PER_AXIS = 3 # Her bir girdi ekseni için test edilecek değer sayısı (örn: 0.0, 0.5, 1.0)
+NUM_TRIALS_PER_INPUT_PAIR = 20 # Her bir girdi çifti için yapılacak deneme sayısı
+# Toplam test noktası sayısı = NUM_TEST_VALUES_PER_AXIS * NUM_TEST_VALUES_PER_AXIS
+# Toplam değerlendirme denemesi/Genom = NUM_TEST_POINTS * NUM_TRIALS_PER_INPUT_PAIR
+
+MAX_GENERATIONS = 150 # <-- Problem zorlaştığı için artırılabilir
+FITNESS_THRESHOLD = 0.97 # <-- Hedef zorlaştığı için eşik ayarlanabilir
+
+num_test_points = NUM_TEST_VALUES_PER_AXIS ** 2 # İki girdi olduğu için karesi
+total_trials_per_genome = num_test_points * NUM_TRIALS_PER_INPUT_PAIR
+
+logger.info(f"Eksen Başına Test Değeri Sayısı: {NUM_TEST_VALUES_PER_AXIS}")
+logger.info(f"Toplam Test Girdi Çifti Sayısı: {num_test_points}")
+logger.info(f"Girdi Çifti Başına Deneme Sayısı: {NUM_TRIALS_PER_INPUT_PAIR}")
+logger.info(f"Toplam Değerlendirme Denemesi/Genom: {total_trials_per_genome}")
+logger.info(f"Maksimum Nesil Sayısı: {MAX_GENERATIONS}")
+logger.info(f"Fitness Eşiği: {FITNESS_THRESHOLD}")
+
+# --- YENİ: İki Girdi İçin Hedef Olasılık Fonksiyonu ---
+def calculate_target_prob0(input1, input2):
+    """
+    Verilen iki girdiye göre hedef P(0) olasılığını hesaplar.
+    Lineer Fonksiyon: target_P0(x1, x2) = 0.1 + 0.5*x1 + 0.3*x2
+    """
+    # Değerlerin 0-1 aralığında kalmasını sağlayalım (isteğe bağlı, fonksiyona göre)
+    target = 0.1 + 0.5 * input1 + 0.3 * input2
+    return max(0.0, min(1.0, target)) # Güvenlik önlemi
+
+logger.info(f"Hedef P(0) Fonksiyonu: P(0|x1, x2) = 0.1 + 0.5*x1 + 0.3*x2")
+
+# --- NEAT Fitness Fonksiyonu ---
+# (Bu fonksiyon Sürüm 3 için önemli ölçüde güncellendi)
+def eval_genomes(genomes, config):
+    """
+    Popülasyondaki tüm genomların fitness değerlerini hesaplar.
+    Fitness, ağın farklı girdi çiftleri için hedeflenen olasılıkları
+    ne kadar iyi üretebildiğine göre belirlenir.
+    """
+    # Test edilecek girdi değerlerini her eksen için belirleyelim
+    axis_values = np.linspace(0.0, 1.0, NUM_TEST_VALUES_PER_AXIS)
+    # Örnek: NUM_TEST_VALUES_PER_AXIS=3 ise -> [0.0, 0.5, 1.0]
+
+    # Tüm girdi çiftlerini (kombinasyonlarını) oluşturalım
+    # Örnek: [(0.0, 0.0), (0.0, 0.5), (0.0, 1.0), (0.5, 0.0), ..., (1.0, 1.0)]
+    test_input_pairs = list(itertools.product(axis_values, repeat=2))
+
+    for genome_id, genome in genomes:
+        genome.fitness = 0.0 # Başlangıç fitness'ı sıfırla
+        try:
+            # İki girdili config ile ağı oluştur
+            net = neat.nn.FeedForwardNetwork.create(genome, config)
+        except Exception as e:
+            logger.error(f"Genome {genome_id} için ağ oluşturulamadı: {e}")
+            genome.fitness = -10.0
+            continue
+
+        total_squared_error = 0.0
+
+        # Her bir test girdi çifti için ağı değerlendir
+        for input_pair in test_input_pairs:
+            x1, x2 = input_pair # Girdi çiftini ayır
+            target_prob_0 = calculate_target_prob0(x1, x2) # Bu çift için hedef P(0)
+
+            count_0 = 0
+            # Her girdi çifti için N kez test et
+            for _ in range(NUM_TRIALS_PER_INPUT_PAIR):
+                try:
+                    # Ağı iki girdi ile aktive et
+                    output = net.activate(input_pair)
+                    # Ağın çıktısını yorumla (< 0.5 ise 0)
+                    if output[0] < 0.5:
+                        count_0 += 1
+                except Exception as e:
+                    logger.warning(f"Genome {genome_id}, Input {input_pair} ağ aktivasyonunda hata: {e}")
+                    pass
+
+            # Gözlemlenen olasılığı hesapla
+            if NUM_TRIALS_PER_INPUT_PAIR > 0:
+                observed_prob_0 = count_0 / NUM_TRIALS_PER_INPUT_PAIR
+            else:
+                observed_prob_0 = 0.5
+
+            # Bu girdi çifti için hatanın karesini hesapla
+            error = (observed_prob_0 - target_prob_0) ** 2
+            total_squared_error += error
+
+        # Ortalama Karesel Hatayı (Mean Squared Error - MSE) hesapla
+        average_squared_error = total_squared_error / len(test_input_pairs)
+
+        # Fitness'ı hesapla (1 - RMSE)
+        fitness = max(0.0, 1.0 - math.sqrt(average_squared_error))
+        genome.fitness = fitness
+        # logger.info(f"Genome {genome_id}: AvgError^2 = {average_squared_error:.4f}, Fitness = {fitness:.4f}")
+
+
+# --- NEAT Çalıştırma Fonksiyonu ---
+def run_neat(config_file):
+    """
+    NEAT evrimini başlatır ve yönetir.
+    """
+    logger.info(f"NEAT yapılandırması yükleniyor: {config_file}")
+    try:
+        # V3 config dosyasını kullanarak config nesnesini oluştur
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_file) # <-- config_file şimdi v3 dosyasını gösteriyor
+        config.fitness_threshold = FITNESS_THRESHOLD
+        logger.info(f"Yapılandırma yüklendi. Giriş Sayısı: {config.genome_config.num_inputs}, Fitness Eşiği: {config.fitness_threshold}")
+
+    except Exception as e:
+        logger.critical(f"Yapılandırma dosyası yüklenemedi veya geçersiz: {config_file} - Hata: {e}")
+        return None
+
+    logger.info("Yeni popülasyon oluşturuluyor...")
+    p = neat.Population(config)
+
+    # Raporlayıcılar
+    p.add_reporter(neat.StdOutReporter(True))
+    # Checkpoint
+    checkpoint_prefix = 'neat-checkpoint-v3-' # <-- V3 için prefix
+    p.add_reporter(neat.Checkpointer(15, filename_prefix=checkpoint_prefix)) # Daha seyrek kaydedilebilir
+    logger.info(f"Checkpoint dosyaları '{checkpoint_prefix}*' olarak kaydedilecek.")
+
+    logger.info(f"Evrim başlıyor (Maksimum {MAX_GENERATIONS} nesil)...")
+    try:
+        winner = p.run(eval_genomes, MAX_GENERATIONS)
+        logger.info(' ' + "="*20 + " Evrim Tamamlandı " + "="*20)
+    except Exception as e:
+        logger.critical(f"Evrim sırasında kritik bir hata oluştu: {e}")
+        return None
+
+    # En iyi genomu işle
+    if winner:
+        logger.info(f'En iyi genom bulundu (Fitness: {winner.fitness:.6f}):')
+        logger.info(f' {winner}')
+
+        # En iyi genomu kaydet
+        winner_filename = "winner_genome_v3.pkl" # <-- V3 için dosya adı
+        try:
+            with open(winner_filename, 'wb') as f:
+                pickle.dump(winner, f)
+            logger.info(f"En iyi genom '{winner_filename}' dosyasına başarıyla kaydedildi.")
+        except Exception as e:
+            logger.error(f"En iyi genom kaydedilemedi: {e}")
+
+        # --- YENİ: En İyi Genomu Çoklu Girdi İle Detaylı Test Etme ---
+        logger.info(" " + "="*20 + " En İyi Genom Detaylı Testi (Çoklu Girdi) " + "="*20)
+        try:
+            winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
+            test_trials_final = 500 # Final test için deneme sayısı
+            logger.info(f"En iyi ağ, farklı girdi çiftleriyle {test_trials_final} kez test ediliyor...")
+
+            # Daha hassas bir girdi ızgarası oluşturalım (örn: 5x5 = 25 nokta)
+            final_axis_values = np.linspace(0.0, 1.0, 5)
+            final_test_pairs = list(itertools.product(final_axis_values, repeat=2))
+            final_total_error_sq = 0.0
+
+            logger.info(f"{'Input (x1,x2)': <15} {'Target P(0)': <12} {'Observed P(0)': <14} {'Error^2': <10}")
+            logger.info("-" * 60)
+
+            for input_pair in final_test_pairs:
+                x1, x2 = input_pair
+                target_p0 = calculate_target_prob0(x1, x2)
+                count_0 = 0
+                for _ in range(test_trials_final):
+                    output = winner_net.activate(input_pair)
+                    if output[0] < 0.5:
+                        count_0 += 1
+
+                observed_p0 = count_0 / test_trials_final
+                error_sq = (observed_p0 - target_p0) ** 2
+                final_total_error_sq += error_sq
+
+                logger.info(f"({x1:.2f}, {x2:.2f})       {target_p0:<12.3f} {observed_p0:<14.3f} {error_sq:<10.5f}")
+
+            final_avg_error_sq = final_total_error_sq / len(final_test_pairs)
+            final_rmse = math.sqrt(final_avg_error_sq)
+            logger.info("-" * 60)
+            logger.info(f"Final Ortalama Karesel Hata (MSE): {final_avg_error_sq:.6f}")
+            logger.info(f"Final Kök Ortalama Karesel Hata (RMSE): {final_rmse:.6f}")
+            logger.info(f"Final Fitness Yaklaşımı (1 - RMSE): {1.0 - final_rmse:.6f}")
+            logger.info("-" * 60)
+
+        except Exception as e:
+            logger.error(f"En iyi genom test edilirken hata oluştu: {e}")
+
+    else:
+        logger.warning("Test edilecek bir kazanan genom bulunamadı.")
+
+    logger.info("="*50)
+    logger.info("Quanta Simülatörü Adım 3 (Çoklu Girdi) tamamlandı.")
+    logger.info("="*50)
+    return winner
+
+
+if __name__ == '__main__':
+    # V3 için yeni yapılandırma dosyasının yolu
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, 'config-feedforward-v3.txt') # <-- YENİ Config Dosyası
+
+    if not os.path.exists(config_path):
+        logger.critical(f"Yapılandırma dosyası bulunamadı: {config_path}")
+        logger.critical("Lütfen 'config-feedforward-v3.txt' dosyasını Python betiğiyle aynı klasöre koyun.")
+    else:
+        # NEAT'i çalıştır
+        run_neat(config_path)

quanta_sim_v4_correlated_outputs.py

@@ -0,0 +1,287 @@
+# quanta_sim_v4_correlated_outputs.py
+
+import neat
+import numpy as np
+import os
+import logging
+import pickle
+import random
+import math
+import datetime
+import itertools
+
+# --- Loglama Ayarları ---
+log_filename = f"quanta_log_v4_corr_{datetime.datetime.now():%Y%m%d_%H%M%S}.log" # <-- V4 için dosya adı
+logging.basicConfig(
+    level=logging.INFO, # DEBUG seviyesi daha fazla bilgi verir ama yavaşlatabilir
+    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+    handlers=[
+        logging.FileHandler(log_filename),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+logger.info("="*70)
+logger.info("Quanta Simülatörü Başlatılıyor (Sürüm 4 - Korelasyonlu Çıktılar)") # <-- GÜNCELLENDİ
+logger.info("="*70)
+
+# --- Simülasyon Parametreleri ---
+NUM_TEST_VALUES_PER_AXIS = 3 # Değerlendirme için ızgara boyutu (3x3=9 nokta)
+NUM_TRIALS_PER_PAIR = 30     # Her girdi çifti için deneme sayısı (artırıldı)
+
+MAX_GENERATIONS = 250 # <-- Problem çok daha zor, nesil sayısı artırıldı
+FITNESS_THRESHOLD = 0.97 # <-- Hedef zor, eşik ayarlanabilir
+
+num_test_points = NUM_TEST_VALUES_PER_AXIS ** 2
+total_trials_per_genome = num_test_points * NUM_TRIALS_PER_PAIR
+
+# Fitness fonksiyonundaki hata ağırlıkları
+W_PA0 = 1.0 # P(A=0) hatasının ağırlığı
+W_PB0 = 1.0 # P(B=0) hatasının ağırlığı
+W_CORR = 1.5 # Korelasyon hatasının ağırlığı (genellikle daha zordur, ağırlığı artırılabilir)
+TOTAL_WEIGHT = W_PA0 + W_PB0 + W_CORR
+
+logger.info(f"Eksen Başına Test Değeri: {NUM_TEST_VALUES_PER_AXIS} ({num_test_points} test noktası)")
+logger.info(f"Girdi Çifti Başına Deneme: {NUM_TRIALS_PER_PAIR} (Toplam {total_trials_per_genome} deneme/genom)")
+logger.info(f"Maksimum Nesil: {MAX_GENERATIONS}")
+logger.info(f"Fitness Eşiği: {FITNESS_THRESHOLD}")
+logger.info(f"Fitness Hata Ağırlıkları: P(A=0)={W_PA0:.1f}, P(B=0)={W_PB0:.1f}, Corr={W_CORR:.1f}")
+
+# --- YENİ: Hedef Fonksiyonları (P(A=0), P(B=0), Korelasyon) ---
+def target_PA0(x1, x2):
+    return 0.2 + 0.6 * x1
+
+def target_PB0(x1, x2):
+    return 0.7 - 0.5 * x2
+
+def target_Corr(x1, x2):
+    # Hedef korelasyon (-1 ile +1 arasında olmalı)
+    return -0.8 * x1 * x2
+
+logger.info(f"Hedef P(A=0|x1,x2) = 0.2 + 0.6*x1")
+logger.info(f"Hedef P(B=0|x1,x2) = 0.7 - 0.5*x2")
+logger.info(f"Hedef Corr(A,B|x1,x2) = -0.8 * x1 * x2")
+
+# --- Korelasyon Hesaplama Yardımcı Fonksiyonu ---
+def calculate_correlation(pA0, pB0, pA0B0, epsilon=1e-9):
+    """ Verilen olasılıklardan korelasyonu hesaplar. """
+    pA1 = 1.0 - pA0
+    pB1 = 1.0 - pB0
+
+    # Kovaryans = P(A=0,B=0) - P(A=0)*P(B=0)
+    covariance = pA0B0 - pA0 * pB0
+
+    # Standart sapmaların karesi (varyanslar)
+    varA = pA0 * pA1
+    varB = pB0 * pB1
+
+    # Sıfıra bölme hatasını önlemek için epsilon ekle
+    denominator = math.sqrt((varA + epsilon) * (varB + epsilon))
+
+    if denominator < epsilon: # Eğer varyans çok küçükse (olasılıklar 0 veya 1'e çok yakınsa)
+        return 0.0 # Korelasyon anlamsızdır veya sıfırdır
+
+    correlation = covariance / denominator
+    # Korelasyonun teorik olarak -1 ile 1 arasında kalmasını sağla (küçük hatalar olabilir)
+    return max(-1.0, min(1.0, correlation))
+
+# --- NEAT Fitness Fonksiyonu ---
+# (Bu fonksiyon Sürüm 4 için önemli ölçüde güncellendi)
+def eval_genomes(genomes, config):
+    """
+    Popülasyondaki genomların fitness'ını hesaplar. Fitness, ağın
+    P(A=0), P(B=0) ve Corr(A,B) hedeflerini farklı girdilerde
+    ne kadar iyi yakaladığına göre belirlenir.
+    """
+    axis_values = np.linspace(0.0, 1.0, NUM_TEST_VALUES_PER_AXIS)
+    test_input_pairs = list(itertools.product(axis_values, repeat=2))
+
+    for genome_id, genome in genomes:
+        genome.fitness = 0.0
+        try:
+            net = neat.nn.FeedForwardNetwork.create(genome, config)
+        except Exception as e:
+            logger.error(f"Genome {genome_id} için ağ oluşturulamadı: {e}")
+            genome.fitness = -20.0 # Daha büyük ceza
+            continue
+
+        total_weighted_error_sum = 0.0
+
+        for input_pair in test_input_pairs:
+            x1, x2 = input_pair
+            targ_pA0 = target_PA0(x1, x2)
+            targ_pB0 = target_PB0(x1, x2)
+            targ_corr = target_Corr(x1, x2)
+
+            count_A0 = 0
+            count_B0 = 0
+            count_A0B0 = 0 # Hem A=0 hem B=0 olan durumların sayısı
+
+            # Denemeleri yap
+            for _ in range(NUM_TRIALS_PER_PAIR):
+                try:
+                    output1, output2 = net.activate(input_pair)
+                    # Çıktıları ikili sonuçlara çevir
+                    res_A = 1 if output1 >= 0.5 else 0 # A=0 veya A=1
+                    res_B = 1 if output2 >= 0.5 else 0 # B=0 veya B=1
+
+                    if res_A == 0: count_A0 += 1
+                    if res_B == 0: count_B0 += 1
+                    if res_A == 0 and res_B == 0: count_A0B0 += 1
+
+                except Exception as e:
+                    logger.warning(f"Genome {genome_id}, Input {input_pair} aktivasyon hatası: {e}")
+                    # Hata durumunda bu denemeyi geçebiliriz veya penaltı verebiliriz
+                    pass
+
+            # Gözlemlenen olasılıkları hesapla
+            if NUM_TRIALS_PER_PAIR > 0:
+                obs_pA0 = count_A0 / NUM_TRIALS_PER_PAIR
+                obs_pB0 = count_B0 / NUM_TRIALS_PER_PAIR
+                obs_pA0B0 = count_A0B0 / NUM_TRIALS_PER_PAIR
+            else:
+                obs_pA0, obs_pB0, obs_pA0B0 = 0.5, 0.5, 0.25 # Varsayılan
+
+            # Gözlemlenen korelasyonu hesapla
+            obs_corr = calculate_correlation(obs_pA0, obs_pB0, obs_pA0B0)
+
+            # Hataları hesapla
+            error_pA0 = (obs_pA0 - targ_pA0) ** 2
+            error_pB0 = (obs_pB0 - targ_pB0) ** 2
+            error_corr = (obs_corr - targ_corr) ** 2
+
+            # Ağırlıklı toplam hatayı hesapla
+            weighted_error = (W_PA0 * error_pA0 + W_PB0 * error_pB0 + W_CORR * error_corr) / TOTAL_WEIGHT
+            total_weighted_error_sum += weighted_error
+
+            # logger.debug(f"  G:{genome_id} In:{input_pair} Tgt:({targ_pA0:.2f},{targ_pB0:.2f},{targ_corr:.2f}) Obs:({obs_pA0:.2f},{obs_pB0:.2f},{obs_corr:.2f}) Err:{weighted_error:.4f}")
+
+        # Ortalama ağırlıklı hatayı hesapla
+        average_weighted_error = total_weighted_error_sum / len(test_input_pairs)
+
+        # Fitness (1 - sqrt(AvgError))
+        fitness = max(0.0, 1.0 - math.sqrt(average_weighted_error))
+        genome.fitness = fitness
+        # logger.info(f"Genome {genome_id}: AvgWeightedError = {average_weighted_error:.4f}, Fitness = {fitness:.4f}")
+
+
+# --- NEAT Çalıştırma Fonksiyonu ---
+def run_neat(config_file):
+    logger.info(f"NEAT yapılandırması yükleniyor: {config_file}")
+    try:
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_file)
+        config.fitness_threshold = FITNESS_THRESHOLD
+        logger.info(f"Yapılandırma: Giriş={config.genome_config.num_inputs}, Çıkış={config.genome_config.num_outputs}, Pop={config.pop_size}, Eşik={config.fitness_threshold}")
+    except Exception as e:
+        logger.critical(f"Yapılandırma dosyası yüklenemedi: {config_file} - Hata: {e}")
+        return None
+
+    logger.info("Yeni popülasyon oluşturuluyor...")
+    p = neat.Population(config)
+
+    # Raporlayıcılar
+    p.add_reporter(neat.StdOutReporter(True))
+    checkpoint_prefix = 'neat-checkpoint-v4-'
+    p.add_reporter(neat.Checkpointer(20, filename_prefix=checkpoint_prefix)) # Daha seyrek checkpoint
+    logger.info(f"Checkpoint dosyaları '{checkpoint_prefix}*' olarak kaydedilecek.")
+
+    logger.info(f"Evrim başlıyor (Maksimum {MAX_GENERATIONS} nesil)...")
+    try:
+        winner = p.run(eval_genomes, MAX_GENERATIONS)
+        logger.info(' ' + "="*30 + " Evrim Tamamlandı " + "="*30)
+    except Exception as e:
+        logger.critical(f"Evrim sırasında kritik bir hata oluştu: {e}")
+        # Hata durumunda son checkpoint'i yüklemeyi deneyebiliriz (ileriki sürüm?)
+        return None # Şimdilik None dönelim
+
+    # En iyi genomu işle
+    if winner:
+        logger.info(f'En iyi genom bulundu (Fitness: {winner.fitness:.6f}):')
+        # logger.info(f' {winner}') # Çok uzun olabilir, log dosyasında kalsın
+
+        # En iyi genomu kaydet
+        winner_filename = "winner_genome_v4.pkl"
+        try:
+            with open(winner_filename, 'wb') as f:
+                pickle.dump(winner, f)
+            logger.info(f"En iyi genom '{winner_filename}' dosyasına başarıyla kaydedildi.")
+        except Exception as e:
+            logger.error(f"En iyi genom kaydedilemedi: {e}")
+
+        # --- YENİ: En İyi Genomu Korelasyon İçin Detaylı Test Etme ---
+        logger.info(" " + "="*25 + " En İyi Genom Detaylı Testi (Korelasyon) " + "="*25)
+        try:
+            winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
+            test_trials_final = 1000 # Final test için daha fazla deneme
+            logger.info(f"En iyi ağ, farklı girdi çiftleriyle {test_trials_final} kez test ediliyor...")
+
+            final_axis_values = np.linspace(0.0, 1.0, 5) # 5x5 = 25 nokta
+            final_test_pairs = list(itertools.product(final_axis_values, repeat=2))
+            final_total_weighted_error_sq_sum = 0.0
+
+            hdr = f"{'Input (x1,x2)': <14} {'Tgt(PA0,PB0,Corr)': <22} {'Obs(PA0,PB0,Corr)': <22} {'Err^2(Comb)': <10}"
+            logger.info(hdr)
+            logger.info("-" * len(hdr))
+
+            for input_pair in final_test_pairs:
+                x1, x2 = input_pair
+                targ_pA0 = target_PA0(x1, x2)
+                targ_pB0 = target_PB0(x1, x2)
+                targ_corr = target_Corr(x1, x2)
+
+                count_A0, count_B0, count_A0B0 = 0, 0, 0
+                for _ in range(test_trials_final):
+                    output1, output2 = winner_net.activate(input_pair)
+                    res_A = 0 if output1 < 0.5 else 1
+                    res_B = 0 if output2 < 0.5 else 1
+                    if res_A == 0: count_A0 += 1
+                    if res_B == 0: count_B0 += 1
+                    if res_A == 0 and res_B == 0: count_A0B0 += 1
+
+                obs_pA0 = count_A0 / test_trials_final
+                obs_pB0 = count_B0 / test_trials_final
+                obs_pA0B0 = count_A0B0 / test_trials_final
+                obs_corr = calculate_correlation(obs_pA0, obs_pB0, obs_pA0B0)
+
+                error_pA0 = (obs_pA0 - targ_pA0) ** 2
+                error_pB0 = (obs_pB0 - targ_pB0) ** 2
+                error_corr = (obs_corr - targ_corr) ** 2
+                weighted_error_sq = (W_PA0 * error_pA0 + W_PB0 * error_pB0 + W_CORR * error_corr) / TOTAL_WEIGHT
+                final_total_weighted_error_sq_sum += weighted_error_sq
+
+                tgt_str = f"({targ_pA0:.2f},{targ_pB0:.2f},{targ_corr:.2f})"
+                obs_str = f"({obs_pA0:.2f},{obs_pB0:.2f},{obs_corr:.2f})"
+                logger.info(f"({x1:.2f}, {x2:.2f})       {tgt_str: <22} {obs_str: <22} {weighted_error_sq:<10.5f}")
+
+            final_avg_weighted_error_sq = final_total_weighted_error_sq_sum / len(final_test_pairs)
+            final_rmse_equivalent = math.sqrt(final_avg_weighted_error_sq)
+            logger.info("-" * len(hdr))
+            logger.info(f"Final Ortalama Ağırlıklı Karesel Hata (MSE ~): {final_avg_weighted_error_sq:.6f}")
+            logger.info(f"Final Kök Ort. Karesel Hata (~RMSE): {final_rmse_equivalent:.6f}")
+            logger.info(f"Final Fitness Yaklaşımı (1 - ~RMSE): {1.0 - final_rmse_equivalent:.6f}")
+            logger.info("-" * len(hdr))
+
+        except Exception as e:
+            logger.error(f"En iyi genom test edilirken hata oluştu: {e}")
+            import traceback
+            logger.error(traceback.format_exc()) # Hatanın detayını logla
+    else:
+        logger.warning("Test edilecek bir kazanan genom bulunamadı.")
+
+    logger.info("="*70)
+    logger.info("Quanta Simülatörü Adım 4 (Korelasyonlu Çıktılar) tamamlandı.")
+    logger.info("="*70)
+    return winner
+
+
+if __name__ == '__main__':
+    local_dir = os.path.dirname(os.path.abspath(__file__)) # Daha sağlam yol bulma
+    config_path = os.path.join(local_dir, 'config-feedforward-v4.txt') # <-- V4 Config Dosyası
+
+    if not os.path.exists(config_path):
+        logger.critical(f"Yapılandırma dosyası bulunamadı: {config_path}")
+    else:
+        run_neat(config_path)

quanta_sim_v5_nonlinear_simple.py

@@ -0,0 +1,290 @@
+# quanta_sim_v5_nonlinear_simple.py
+
+import neat
+import numpy as np
+import os
+import logging
+import pickle
+import random
+import math
+import datetime
+import itertools
+import traceback # Hata ayıklama için
+
+# --- Loglama Ayarları ---
+log_filename = f"quanta_log_v5_nonsimple_{datetime.datetime.now():%Y%m%d_%H%M%S}.log"
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+    handlers=[
+        logging.FileHandler(log_filename),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+logger.info("="*70)
+logger.info("Quanta Simülatörü Başlatılıyor (Sürüm 5 - Non-Linear Hedefler + Basitlik)")
+logger.info(f"Başlangıç Zamanı: {datetime.datetime.now()}")
+logger.info("="*70)
+
+# --- Simülasyon Parametreleri ---
+NUM_TEST_VALUES_PER_AXIS = 4 # Değerlendirme için ızgara boyutu (4x4=16 nokta)
+NUM_TRIALS_PER_PAIR = 30     # Her girdi çifti için deneme sayısı
+
+MAX_GENERATIONS = 300 # Zor problem için artırılmış nesil sayısı
+
+# Fitness fonksiyonundaki hata ağırlıkları
+W_PA0 = 1.0
+W_PB0 = 1.0
+W_CORR = 1.5 # Korelasyon genellikle daha zordur
+TOTAL_WEIGHT = W_PA0 + W_PB0 + W_CORR
+
+# Karmaşıklık Cezası Ağırlıkları (Deneme yanılma ile ayarlanabilir!)
+COMPLEXITY_PENALTY_WEIGHT_NODE = 0.001
+COMPLEXITY_PENALTY_WEIGHT_CONN = 0.0005
+
+num_test_points = NUM_TEST_VALUES_PER_AXIS ** 2
+total_trials_per_genome = num_test_points * NUM_TRIALS_PER_PAIR
+
+logger.info(f"Eksen Başına Test Değeri: {NUM_TEST_VALUES_PER_AXIS} ({num_test_points} test noktası)")
+logger.info(f"Girdi Çifti Başına Deneme: {NUM_TRIALS_PER_PAIR} (Toplam {total_trials_per_genome} deneme/genom)")
+logger.info(f"Maksimum Nesil: {MAX_GENERATIONS}")
+logger.info(f"Fitness Hata Ağırlıkları: P(A0)={W_PA0:.1f}, P(B0)={W_PB0:.1f}, Corr={W_CORR:.1f}")
+logger.info(f"Karmaşıklık Ceza Ağırlıkları: Düğüm={COMPLEXITY_PENALTY_WEIGHT_NODE}, Bağlantı={COMPLEXITY_PENALTY_WEIGHT_CONN}")
+
+# --- Doğrusal Olmayan Hedef Fonksiyonları ---
+def target_PA0(x1, x2):
+    # P(A=0) hedefi (0.1 ile 0.9 arasında salınır)
+    return 0.5 + 0.4 * math.sin(math.pi * x1)
+
+def target_PB0(x1, x2):
+    # P(B=0) hedefi (0.1 ile 0.9 arasında salınır)
+    return 0.5 + 0.4 * math.cos(math.pi * x2)
+
+def target_Corr(x1, x2):
+    # Hedef Korelasyon (0 ile -0.8 arasında salınır)
+    return -0.8 * math.sin(math.pi * x1 * x2)
+
+logger.info(f"Hedef P(A=0|x1,x2) = 0.5 + 0.4*sin(pi*x1)")
+logger.info(f"Hedef P(B=0|x1,x2) = 0.5 + 0.4*cos(pi*x2)")
+logger.info(f"Hedef Corr(A,B|x1,x2) = -0.8*sin(pi*x1*x2)")
+
+# --- Korelasyon Hesaplama Yardımcı Fonksiyonu ---
+def calculate_correlation(pA0, pB0, pA0B0, epsilon=1e-9):
+    pA1 = 1.0 - pA0
+    pB1 = 1.0 - pB0
+    covariance = pA0B0 - pA0 * pB0
+    varA = pA0 * pA1
+    varB = pB0 * pB1
+    denominator = math.sqrt((varA + epsilon) * (varB + epsilon))
+    if denominator < epsilon: return 0.0
+    correlation = covariance / denominator
+    return max(-1.0, min(1.0, correlation))
+
+# --- NEAT Fitness Fonksiyonu ---
+def eval_genomes(genomes, config):
+    axis_values = np.linspace(0.0, 1.0, NUM_TEST_VALUES_PER_AXIS)
+    test_input_pairs = list(itertools.product(axis_values, repeat=2))
+
+    for genome_id, genome in genomes:
+        genome.fitness = 0.0 # Başlangıç fitness
+        try:
+            net = neat.nn.FeedForwardNetwork.create(genome, config)
+        except Exception as e:
+            logger.error(f"Genome {genome_id} ağ oluşturma hatası: {e}")
+            genome.fitness = -30.0
+            continue
+
+        total_weighted_error_sum = 0.0
+
+        # Performans Değerlendirme
+        for input_pair in test_input_pairs:
+            x1, x2 = input_pair
+            targ_pA0 = target_PA0(x1, x2)
+            targ_pB0 = target_PB0(x1, x2)
+            targ_corr = target_Corr(x1, x2)
+
+            count_A0, count_B0, count_A0B0 = 0, 0, 0
+            for _ in range(NUM_TRIALS_PER_PAIR):
+                try:
+                    output1, output2 = net.activate(input_pair)
+                    res_A = 0 if output1 < 0.5 else 1
+                    res_B = 0 if output2 < 0.5 else 1
+                    if res_A == 0: count_A0 += 1
+                    if res_B == 0: count_B0 += 1
+                    if res_A == 0 and res_B == 0: count_A0B0 += 1
+                except Exception as e:
+                    # Aktivasyon hatalarını loglamak çok fazla çıktı üretebilir
+                    pass
+
+            # Gözlemlenen değerler
+            if NUM_TRIALS_PER_PAIR > 0:
+                obs_pA0 = count_A0 / NUM_TRIALS_PER_PAIR
+                obs_pB0 = count_B0 / NUM_TRIALS_PER_PAIR
+                obs_pA0B0 = count_A0B0 / NUM_TRIALS_PER_PAIR
+            else:
+                obs_pA0, obs_pB0, obs_pA0B0 = 0.5, 0.5, 0.25
+
+            obs_corr = calculate_correlation(obs_pA0, obs_pB0, obs_pA0B0)
+
+            # Hatalar
+            error_pA0 = (obs_pA0 - targ_pA0) ** 2
+            error_pB0 = (obs_pB0 - targ_pB0) ** 2
+            error_corr = (obs_corr - targ_corr) ** 2
+            weighted_error = (W_PA0 * error_pA0 + W_PB0 * error_pB0 + W_CORR * error_corr) / TOTAL_WEIGHT
+            total_weighted_error_sum += weighted_error
+
+        # Temel fitness
+        average_weighted_error = total_weighted_error_sum / len(test_input_pairs)
+        base_fitness = max(0.0, 1.0 - math.sqrt(average_weighted_error))
+
+        # Karmaşıklık Cezası
+        num_nodes = len(genome.nodes)
+        num_connections = len(genome.connections)
+        complexity_penalty = (COMPLEXITY_PENALTY_WEIGHT_NODE * num_nodes +
+                              COMPLEXITY_PENALTY_WEIGHT_CONN * num_connections)
+
+        # Final fitness
+        final_fitness = max(0.0, base_fitness - complexity_penalty)
+        genome.fitness = final_fitness
+
+# --- NEAT Çalıştırma Fonksiyonu ---
+def run_neat(config_file):
+    logger.info(f"NEAT yapılandırması yükleniyor: {config_file}")
+    config = None # Önce None olarak tanımla
+    try:
+        config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                             neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                             config_file)
+        logger.info(f"Yapılandırma: Giriş={config.genome_config.num_inputs}, Çıkış={config.genome_config.num_outputs}, Pop={config.pop_size}, Eşik={config.fitness_threshold}")
+    except Exception as e:
+        logger.critical(f"Yapılandırma dosyası yüklenemedi: {config_file} - Hata: {e}")
+        return None
+
+    logger.info("Yeni popülasyon oluşturuluyor...")
+    p = neat.Population(config)
+
+    # Raporlayıcılar
+    p.add_reporter(neat.StdOutReporter(True))
+    checkpoint_prefix = 'neat-checkpoint-v5-'
+    # Checkpointer her 25 nesilde bir kaydetsin
+    p.add_reporter(neat.Checkpointer(25, filename_prefix=checkpoint_prefix))
+    logger.info(f"Checkpoint dosyaları '{checkpoint_prefix}*' olarak kaydedilecek.")
+
+    logger.info(f"Evrim başlıyor (Maksimum {MAX_GENERATIONS} nesil)...")
+    winner = None # Önce None olarak tanımla
+    try:
+        winner = p.run(eval_genomes, MAX_GENERATIONS)
+        logger.info(' ' + "="*30 + " Evrim Tamamlandı " + "="*30)
+    except Exception as e:
+        logger.critical(f"Evrim sırasında kritik bir hata oluştu: {e}")
+        logger.error(traceback.format_exc()) # Tam hata izini logla
+        # Hata durumunda bile popülasyonun en iyisini almayı deneyebiliriz (checkpoint yoksa)
+        if not winner and p and p.best_genome:
+             logger.warning("Evrim hata ile durdu, bulunan son en iyi genom kullanılıyor.")
+             winner = p.best_genome
+        # return None # Hata durumunda çıkmak yerine devam etmeyi deneyelim
+
+    # En iyi genomu işle (hata olsa bile 'winner' dolu olabilir)
+    if winner:
+        logger.info(f'En iyi genom bulundu/kullanıldı (Final Fitness: {winner.fitness:.6f}):')
+        num_nodes = len(winner.nodes)
+        num_connections = len(winner.connections)
+        logger.info(f'Kazanan Karmaşıklığı: {num_nodes} Düğüm, {num_connections} Bağlantı')
+
+        # En iyi genomu kaydet
+        winner_filename = "winner_genome_v5.pkl"
+        try:
+            with open(winner_filename, 'wb') as f:
+                pickle.dump(winner, f)
+            logger.info(f"En iyi genom '{winner_filename}' dosyasına başarıyla kaydedildi.")
+        except Exception as e:
+            logger.error(f"En iyi genom kaydedilemedi: {e}")
+
+        # --- Final Test ---
+        logger.info(" " + "="*20 + " En İyi Genom Detaylı Testi (Non-Linear) " + "="*20)
+        try:
+            # Eğer config yüklenmemişse (ilk hatada), testi atla
+            if config is None:
+                 logger.error("Yapılandırma yüklenemediği için final test atlanıyor.")
+                 raise RuntimeError("Config object is None, cannot create network.")
+
+            winner_net = neat.nn.FeedForwardNetwork.create(winner, config)
+            test_trials_final = 1000 # Final test için deneme sayısı
+            logger.info(f"En iyi ağ, farklı girdi çiftleriyle {test_trials_final} kez test ediliyor...")
+
+            final_axis_values = np.linspace(0.0, 1.0, 6) # 6x6 = 36 nokta test
+            final_test_pairs = list(itertools.product(final_axis_values, repeat=2))
+            final_total_weighted_error_sq_sum = 0.0
+
+            hdr = f"{'Input (x1,x2)': <14} {'Tgt(PA0,PB0,Corr)': <22} {'Obs(PA0,PB0,Corr)': <22} {'Err^2(Comb)': <10}"
+            logger.info(hdr)
+            logger.info("-" * len(hdr))
+
+            for input_pair in final_test_pairs:
+                x1, x2 = input_pair
+                targ_pA0 = target_PA0(x1, x2)
+                targ_pB0 = target_PB0(x1, x2)
+                targ_corr = target_Corr(x1, x2)
+
+                count_A0, count_B0, count_A0B0 = 0, 0, 0
+                for _ in range(test_trials_final):
+                    output1, output2 = winner_net.activate(input_pair)
+                    res_A = 0 if output1 < 0.5 else 1
+                    res_B = 0 if output2 < 0.5 else 1
+                    if res_A == 0: count_A0 += 1
+                    if res_B == 0: count_B0 += 1
+                    if res_A == 0 and res_B == 0: count_A0B0 += 1
+
+                obs_pA0 = count_A0 / test_trials_final
+                obs_pB0 = count_B0 / test_trials_final
+                obs_pA0B0 = count_A0B0 / test_trials_final
+                obs_corr = calculate_correlation(obs_pA0, obs_pB0, obs_pA0B0)
+
+                error_pA0 = (obs_pA0 - targ_pA0) ** 2
+                error_pB0 = (obs_pB0 - targ_pB0) ** 2
+                error_corr = (obs_corr - targ_corr) ** 2
+                weighted_error_sq = (W_PA0 * error_pA0 + W_PB0 * error_pB0 + W_CORR * error_corr) / TOTAL_WEIGHT
+                final_total_weighted_error_sq_sum += weighted_error_sq
+
+                tgt_str = f"({targ_pA0:.2f},{targ_pB0:.2f},{targ_corr:.2f})"
+                obs_str = f"({obs_pA0:.2f},{obs_pB0:.2f},{obs_corr:.2f})"
+                logger.info(f"({x1:.2f}, {x2:.2f})       {tgt_str: <22} {obs_str: <22} {weighted_error_sq:<10.5f}")
+
+            final_avg_weighted_error_sq = final_total_weighted_error_sq_sum / len(final_test_pairs)
+            final_rmse_equivalent = math.sqrt(final_avg_weighted_error_sq)
+            logger.info("-" * len(hdr))
+            logger.info(f"Final Ortalama Ağırlıklı Karesel Hata (MSE ~): {final_avg_weighted_error_sq:.6f}")
+            logger.info(f"Final Kök Ort. Karesel Hata (~RMSE): {final_rmse_equivalent:.6f}")
+            logger.info(f"Not: Bu RMSE, karmaşıklık cezasını içermez, sadece performans ölçümüdür.")
+            logger.info("-" * len(hdr))
+
+        except Exception as e:
+            logger.error(f"En iyi genom test edilirken hata oluştu: {e}")
+            logger.error(traceback.format_exc())
+    else:
+        logger.warning("Evrim sonunda test edilecek bir kazanan genom bulunamadı.")
+
+    logger.info("="*70)
+    logger.info("Quanta Simülatörü Adım 5 (Non-Linear + Basitlik) tamamlandı.")
+    logger.info(f"Bitiş Zamanı: {datetime.datetime.now()}")
+    logger.info("="*70)
+    # return winner # Fonksiyondan bir şey döndürmeye gerek yoksa kaldırılabilir
+
+
+if __name__ == '__main__':
+    # Betiğin bulunduğu dizini al
+    local_dir = os.path.dirname(os.path.abspath(__file__))
+    # V5 config dosyasının tam yolunu oluştur
+    config_path = os.path.join(local_dir, 'config-feedforward-v5.txt')
+
+    if not os.path.exists(config_path):
+        logger.critical(f"Yapılandırma dosyası bulunamadı: {config_path}")
+        logger.critical(f"Lütfen '{os.path.basename(config_path)}' dosyasını betikle aynı klasöre koyun.")
+    else:
+        try:
+            run_neat(config_path)
+        except Exception as main_e:
+            logger.critical(f"Ana program akışında beklenmedik bir hata oluştu: {main_e}")
+            logger.error(traceback.format_exc())