NextGenC/Quanta

NOT:Bu proje deneysel amaçla yapılmıştır sorumluluk kabul edilemez ve parametre ayarlamaları düzgünce yapılmalıdır - ZAYN (19 yaşında yazılım geliştirici)

NOTE: This project is for experimental purposes, irresponsibility is unacceptable and parameter adjustments must be made properly - ZAYN (19 years old software developer)

Quanta Simülatörü / Sınıflandırıcı (NEAT ile Evrimleşen Ağlar Projesi)

Projeye Genel Bakış / Model Açıklaması

Bu proje, NEAT (NeuroEvolution of Augmenting Topologies - Artan Topolojilerin NöroEvrimi) algoritmasını kullanarak çeşitli görevleri yerine getirebilen yapay sinir ağlarını evrimleştirme sürecini adım adım gösteren bir çalışmadır. Proje, basit olasılıksal davranışları taklit etmekten başlayarak, girdilere bağlı karmaşık ve korelasyonlu çıktılar üretmeye ve son olarak standart bir makine öğrenmesi sınıflandırma görevini veri setleri üzerinden çözmeye kadar ilerlemiştir.

Temel Teknoloji: neat-python kütüphanesi kullanılarak Python'da geliştirilmiştir. Sürüm 6, veri işleme ve değerlendirme için scikit-learn kütüphanesinden yararlanır.

Projenin Amacı: NEAT'in farklı problem tiplerine nasıl uygulanabileceğini göstermek, evrimsel algoritmaların potansiyelini ve esnekliğini vurgulamak ve aşamalı bir geliştirme süreci sunmaktır. "Quanta" ismi, başlangıçtaki olasılıksal ve korelasyonlu davranışları simüle etme hedeflerinden ilham almıştır (ancak proje doğrudan kuantum hesaplama yapmaz).

Sürümlerin Evrimi ve Yetenekleri

Bu proje, aşağıdaki sürümlerle aşama aşama geliştirilmiştir:

• Sürüm 1 (quanta_sim_v1_no_viz): Temel Olasılık Taklidi

  • Amaç: Sabit bir girdi verildiğinde, çıktısının belirli bir hedef olasılıkla (örn. %70) '0' olmasını sağlayan bir ağı evrimleştirmek.
  • Yetenek: NEAT'in en temel formda olasılıksal bir davranışı öğrenme potansiyelini gösterir.
  • Girdi/Çıktı: Sabit Girdi -> Tek Olasılıksal Çıktı.

• Sürüm 2 (quanta_sim_v2_input_dep): Girdiye Bağlı Olasılık

  • Amaç: Ağın ürettiği '0' olma olasılığının, tek bir değişkene (girdi) doğrusal olarak bağlı olmasını sağlamak.
  • Yetenek: Basit bir girdi-çıktı fonksiyonel ilişkisini (olasılık bağlamında) öğrenir.
  • Girdi/Çıktı: Tek Değişken Girdi -> Tek Değişken Olasılıksal Çıktı.

• Sürüm 3 (quanta_sim_v3_multi_input): Çoklu Girdi ile Olasılık

  • Amaç: Ağın ürettiği '0' olma olasılığının, iki farklı girdiye doğrusal olarak bağlı olmasını sağlamak.
  • Yetenek: Çok boyutlu girdi uzayından olasılıksal bir çıktıya haritalama yapmayı öğrenir.
  • Girdi/Çıktı: İki Değişken Girdi -> Tek Değişken Olasılıksal Çıktı.

• Sürüm 4 (quanta_sim_v4_correlated_outputs): Korelasyonlu Çıktılar

  • Amaç: İki girdi alıp iki çıktı üreten bir ağı evrimleştirmek. Hedef, sadece çıktıların bireysel olasılıklarını (P(A=0), P(B=0)) değil, aynı zamanda aralarındaki korelasyonu da girdilere bağlı olarak ayarlamaktır.
  • Yetenek: İstatistiksel olarak ilişkili davranışları simüle eder. Kuantum sistemlerindeki korelasyonların klasik bir benzetmesini oluşturur. Kısmen birleşik olasılık dağılımlarını öğrenir.
  • Girdi/Çıktı: İki Değişken Girdi -> İki Korelasyonlu Olasılıksal Çıktı.

• Sürüm 5 (quanta_sim_v5_nonlinear_simple): Doğrusal Olmayan Hedefler ve Basitlik

  • Amaç: Sürüm 4'teki görevi, P(A=0), P(B=0) ve Korelasyon(A,B) için doğrusal olmayan (non-linear) hedef fonksiyonları ile zorlaştırmak. Ek olarak, ağ karmaşıklığını (düğüm/bağlantı sayısı) cezalandırarak daha basit çözümleri teşvik etmek.
  • Yetenek: Karmaşık, doğrusal olmayan girdi-çıktı ilişkilerini öğrenir. Performans ve model basitliği arasındaki dengeyi araştırır (Occam'ın Usturası prensibi).
  • Girdi/Çıktı: İki Değişken Girdi -> İki Korelasyonlu Olasılıksal Çıktı (Non-Linear Hedefler).

• Sürüm 6 (quanta_classifier_v6): Veri Seti ile Sınıflandırma (Sıçrama Sürümü)

  • Amaç: NEAT'i standart bir makine öğrenmesi görevine uygulamak. scikit-learn ile oluşturulan sentetik bir veri setindeki noktaları özelliklerine göre iki sınıfa ayırabilen bir ağı evrimleştirmek.
  • Yetenek: Fonksiyon taklidinin ötesine geçerek, veriden öğrenme ve sınıflandırma yapma yeteneğini gösterir. Eğitim verisi üzerinde doğruluk (accuracy) ile eğitilir, performansı görünmeyen test verisi üzerinde standart metriklerle (Accuracy, Precision, Recall, F1-Score, Confusion Matrix) ölçülür. Gerçek dünya problemlerine doğru önemli bir adımdır.
  • Girdi/Çıktı: Veri Özellikleri (örn. 2 özellik) -> Tek İkili Sınıf Tahmini.

Kullanım Alanları

Bu proje ve içerdiği kod sürümleri çeşitli amaçlar için kullanılabilir:

• Eğitim: NEAT algoritmasının temellerini, farklı problem türlerine uygulanışını ve evrimsel sürecin nasıl çalıştığını öğrenmek için bir araç.
• Araştırma ve Prototipleme:
  • Belirli olasılıksal, korelasyonlu veya karmaşık davranışları sergileyen sistemleri modellemek için başlangıç noktası.
  • Fonksiyon formunun bilinmediği durumlarda fonksiyon yaklaşımı denemeleri.
  • Geleneksel sinir ağı mimarilerinin zorlandığı problemlerde NEAT ile topoloji araştırması yapmak için bir temel.
  • Sınıflandırma problemlerinde evrimsel yaklaşımların performansını test etmek.
• Deneyler: Farklı NEAT hiperparametrelerinin (popülasyon boyutu, mutasyon oranları, karmaşıklık cezası vb.) evrim süreci üzerindeki etkilerini incelemek.

Sınırlamalar ve Potansiyel Yanlılık (Bias)

• Hesaplama Maliyeti: NEAT, özellikle büyük popülasyonlar ve çok sayıda deneme gerektiren fitness fonksiyonları ile hesaplama açısından pahalı olabilir.
• Hiperparametre Hassasiyeti: Algoritmanın performansı, yapılandırma dosyasındaki parametrelere oldukça duyarlıdır. Optimal ayarları bulmak deneme yanılma gerektirebilir.
• Yorumlanabilirlik: Evrimleşen ağların iç yapısı karmaşık olabilir ve karar verme mekanizmalarını yorumlamak zor olabilir ("kara kutu").
• "Kuantum" Benzetmesi: V1-V5'teki "kuantum" benzetmesi tamamen istatistiksel ve analojiktir; gerçek kuantum mekaniği simülasyonu yapılmamaktadır.
• Veri Bağımlılığı (V6): Sürüm 6, sentetik veri kullanır. Performans, gerçek dünya veri setlerinin karmaşıklığı, gürültüsü ve boyutuna göre önemli ölçüde değişecektir. Veri oluşturma süreci veya kullanılan metrikler yanlılığa (bias) yol açabilir.
• GPU Kullanımı: Mevcut implementasyonlar GPU hızlandırmasını kullanmaz, tamamen CPU üzerinde çalışır.
• Kod Yapısı (V6): V6'da veri aktarımı için global değişkenler kullanılmıştır; bu, büyük ölçekli projeler için ideal bir pratik değildir.

Eğitim Verisi (V6)

Sürüm 6 (quanta_classifier_v6.py), eğitim ve test için sklearn.datasets.make_classification fonksiyonu ile sentetik bir veri seti oluşturur. Varsayılan parametreler (kod içinde değiştirilebilir):

• Örnek Sayısı (n_samples): 1000
• Özellik Sayısı (n_features): 2 (2'si bilgilendirici - n_informative=2, 0'ı gereksiz - n_redundant=0)
• Sınıf Sayısı: 2 (Binary)
• Sınıf Başına Küme: 1
• Gürültü (flip_y): ~%5 etiket rastgele ters çevrilir.
• Veri, %70 eğitim ve %30 test seti olarak train_test_split ile bölünür (stratify=y ile sınıf oranları korunur).

Değerlendirme Sonuçları (V6)

Sürüm 6'nın temel fitness metriği eğitim seti üzerindeki doğruluk oranıdır. Evrim tamamlandıktan sonra, en iyi modelin performansı ayrı bir test seti üzerinde aşağıdaki metriklerle değerlendirilir ve loglanır:

• Doğruluk (Accuracy)
• Hassasiyet (Precision)
• Duyarlılık (Recall)
• F1 Skoru (F1-Score)
• Karışıklık Matrisi (Confusion Matrix)

Spesifik sonuçlar, çalıştırma ortamına, yapılandırma parametrelerine ve rastgelelik faktörlerine bağlı olarak değişecektir. Detaylı sonuçlar için lütfen quanta_classifier_v6.py betiğini çalıştırdıktan sonra oluşan log dosyasını inceleyin.

Nasıl Kullanılır?

Bu depo, bir evrim sürecini gösteren Python betiklerini içerir. Aşağıdaki adımları izleyebilirsiniz:

1. Bu depoyu klonlayın (git clone ...).
2. Gerekli kütüphaneleri kurun: pip install neat-python numpy scikit-learn
3. İlgilendiğiniz sürümün Python betiğini çalıştırın (örn. python quanta_classifier_v6.py veya python quanta_sim_v5_nonlinear_simple.py). Her betik, yanında ilgili config-*.txt dosyasını bekler.
4. Farklı sürümlerin kodlarını inceleyerek NEAT'in farklı görevlere nasıl uyarlandığını anlayın.
5. Yapılandırma dosyalarını veya Python kodlarını değiştirerek kendi deneylerinizi yapın.

Quanta Simulator / Classifier (NEAT Evolving Networks Project)

Project Overview / Model Description

This project demonstrates the step-by-step process of evolving Artificial Neural Networks (ANNs) capable of performing various tasks using the NEAT (NeuroEvolution of Augmenting Topologies) algorithm. The project progresses from mimicking simple probabilistic behaviors to generating complex, correlated outputs dependent on inputs, and finally, to solving a standard machine learning classification task using datasets.

Core Technology: Developed in Python using the neat-python library. Version 6 utilizes the scikit-learn library for data handling and evaluation.

Project Goal: To showcase how the NEAT algorithm can be applied to different problem types, highlight the potential and flexibility of evolutionary algorithms, and present a phased development process. The name "Quanta" is inspired by the initial goals of simulating probabilistic and correlated behaviors (however, the project does not perform actual quantum computation).

Version Evolution and Capabilities

This project was developed progressively through the following versions:

• Version 1 (quanta_sim_v1_no_viz): Basic Probability Mimicry

  • Goal: Evolve a network that outputs '0' with a specific target probability (e.g., 70%) given a constant input.
  • Capability: Demonstrates NEAT's basic potential to learn probabilistic behavior.
  • Input/Output: Constant Input -> Single Probabilistic Output.

• Version 2 (quanta_sim_v2_input_dep): Input-Dependent Probability

  • Goal: Evolve a network where the probability of outputting '0' depends linearly on a single variable input.
  • Capability: Learns a simple input-output functional relationship (in a probabilistic context).
  • Input/Output: Single Variable Input -> Single Variable Probabilistic Output.

• Version 3 (quanta_sim_v3_multi_input): Probability with Multiple Inputs

  • Goal: Evolve a network where the probability of outputting '0' depends linearly on two different inputs.
  • Capability: Learns to map from a multi-dimensional input space to a probabilistic output.
  • Input/Output: Two Variable Inputs -> Single Variable Probabilistic Output.

• Version 4 (quanta_sim_v4_correlated_outputs): Correlated Outputs

  • Goal: Evolve a network (2 inputs, 2 outputs) where not only the individual output probabilities (P(A=0), P(B=0)) match targets, but also the correlation between them, all dependent on the inputs.
  • Capability: Simulates statistically correlated behaviors. Forms a classical analogy to correlations found in quantum systems. Partially learns joint probability distributions.
  • Input/Output: Two Variable Inputs -> Two Correlated Probabilistic Outputs.

• Version 5 (quanta_sim_v5_nonlinear_simple): Non-Linear Targets and Simplicity

  • Goal: Tackle the Version 4 task with more complex, non-linear target functions for P(A=0), P(B=0), and Correlation(A,B). Additionally, introduce a penalty for network complexity (number of nodes/connections) to favor simpler solutions.
  • Capability: Learns complex, non-linear input-output relationships; explores the trade-off between performance and model simplicity (Occam's Razor principle).
  • Input/Output: Two Variable Inputs -> Two Correlated Probabilistic Outputs (Non-Linear Targets).

• Version 6 (quanta_classifier_v6): Classification with Dataset (The Leap Version)

  • Goal: Apply NEAT to a standard machine learning task. Evolve a network capable of classifying data points from a synthetic dataset (generated via scikit-learn) into two classes based on their features.
  • Capability: Moves beyond function approximation to demonstrate learning from data and performing classification. Trained based on accuracy on the training set, performance evaluated on unseen test data using standard ML metrics (Accuracy, Precision, Recall, F1-Score, Confusion Matrix). Represents a significant step towards real-world problems.
  • Input/Output: Data Features (e.g., 2 features) -> Single Binary Class Prediction.

Intended Use Cases

This project and its code versions can be used for various purposes:

• Education: A tool to learn the fundamentals of the NEAT algorithm, its application to different problem types, and how the evolutionary process works.
• Research and Prototyping:
  • A starting point for modeling systems exhibiting specific probabilistic, correlated, or complex behaviors.
  • Function approximation experiments where the function form is unknown.
  • A basis for exploring topology search with NEAT for problems where traditional neural network architectures might struggle.
  • Testing the performance of evolutionary approaches on classification problems.
• Experimentation: Studying the effects of different NEAT hyperparameters (population size, mutation rates, complexity penalty, etc.) on the evolutionary process.

Limitations and Potential Bias

• Computational Cost: NEAT can be computationally expensive, especially with large populations and fitness functions requiring many trials.
• Hyperparameter Sensitivity: The algorithm's performance is quite sensitive to the parameters in the configuration file. Finding optimal settings may require experimentation.
• Interpretability: The internal structure of evolved networks can be complex, making it difficult to interpret their decision-making mechanisms ("black box").
• "Quantum" Analogy: The "quantum" aspect in V1-V5 is purely statistical and analogical; no actual quantum mechanics simulation is performed.
• Data Dependency (V6): Version 6 uses synthetic data. Performance will vary significantly depending on the complexity, noise, and dimensionality of real-world datasets. Bias could potentially arise from the synthetic data generation process or the chosen evaluation metrics.
• GPU Usage: The current implementations do not utilize GPU acceleration; they run entirely on the CPU.
• Code Structure (V6): Version 6 uses global variables for data passing, which is not an ideal practice for large-scale projects.

Training Data (V6)

Version 6 (quanta_classifier_v6.py) generates a synthetic dataset for training and testing using the sklearn.datasets.make_classification function. Default parameters (can be changed in the code):

• Number of Samples (n_samples): 1000
• Number of Features (n_features): 2 (both informative - n_informative=2, 0 redundant - n_redundant=0)
• Number of Classes: 2 (Binary)
• Clusters per Class: 1
• Noise (flip_y): ~5% of labels are randomly flipped.
• The data is split into 70% training and 30% testing sets using train_test_split (stratify=y preserves class proportions).

Evaluation Results (V6)

The primary fitness metric for Version 6 is the accuracy on the training set. After evolution completes, the best model's performance is evaluated on a separate test set using the following metrics, which are logged:

• Accuracy
• Precision
• Recall
• F1-Score
• Confusion Matrix

Specific results will vary depending on the execution environment, configuration parameters, and random factors. Please refer to the log file generated after running the quanta_classifier_v6.py script for detailed results.

How to Use

This repository contains Python scripts demonstrating an evolutionary process. You can follow these steps:

1. Clone this repository (git clone ...).
2. Install the required libraries: pip install neat-python numpy scikit-learn
3. Run the Python script for the version you are interested in (e.g., python quanta_classifier_v6.py or python quanta_sim_v5_nonlinear_simple.py). Each script expects its corresponding config-*.txt file to be in the same directory.
4. Examine the code of different versions to understand how NEAT is adapted for various tasks.
5. Modify the configuration files or Python code to conduct your own experiments.