pyerualjetwork 4.8b0__tar.gz → 5__tar.gz

{pyerualjetwork-4.8b0 → pyerualjetwork-5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.8b0
-Summary: PyerualJetwork is a machine learning library supported with GPU(CUDA) acceleration written in Python for professionals and researchers including with PLAN algorithm, PLANEAT algorithm (genetic optimization). Also includes data pre-process and memory manegament
+Version: 5
+Summary: PyereualJetwork is a GPU-accelerated machine learning library in Python for professionals and researchers. It features PLAN, MLP, Deep Learning training, and ENE (Eugenic NeuroEvolution) for genetic optimization, applicable to genetic algorithms or Reinforcement Learning (RL). The library includes data pre-processing, visualizations, model saving/loading, prediction, evaluation, training, and detailed or simplified memory management.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com
 Keywords: model evaluation,classification,potentiation learning artificial neural networks,NEAT,genetic algorithms,reinforcement learning,neural networks
@@ -26,13 +26,13 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 
 	pip install pyerualjetwork
 	
-	from pyerualjetwork import plan
-	from pyerualjetwork import planeat
+	from pyerualjetwork import neu
+	from pyerualjetwork import ene
 	from pyerualjetwork import data_operations
 	from pyerualjetwork import model_operations
 	
-	from pyerualjetwork import plan_cuda
-	from pyerualjetwork import planeat_cuda
+	from pyerualjetwork import neu_cuda
+	from pyerualjetwork import ene_cuda
 	from pyerualjetwork import data_operations_cuda
 	from pyerualjetwork import model_operations_cuda
 	
@@ -43,7 +43,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	    'tqdm==4.66.4',
 	    'pandas==2.2.2',
 	    'networkx==3.3',
-		'seaborn==0.13.2',
+	    'seaborn==0.13.2',
 	    'numpy==1.26.4',
 	    'matplotlib==3.9.0',
 	    'colorama==0.4.6',
@@ -57,10 +57,13 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 
 ABOUT PYERUALJETWORK:
 
-PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques with optimized GPU acceleration. Its most important component is the PLAN (Potentiation Learning Artificial Neural Network) https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4862342. (THIS ARTICLE IS FIRST VERSION OF PLAN.) MODERN VERSION OF PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
-Both the PLAN algorithm and the PyerualJetwork library were created by Author, and all rights are reserved by Author.
+PyereualJetwork is a large, GPU-accelerated machine learning library in Python designed for professionals and researchers.
+It features PLAN, MLP, and Deep Learning training, as well as ENE (Eugenic NeuroEvolution) for genetic optimization, 
+which can also be applied to genetic algorithms or Reinforcement Learning (RL) problems. 
+The library includes functions for data pre-processing, visualizations, model saving and loading, prediction and evaluation, 
+training, and both detailed and simplified memory management. https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4862342. (THIS ARTICLE IS FIRST VERSION OF PLAN.) MODERN VERSION OF PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+Both the PLAN algorithm ENE algorithm and the PyerualJetwork library were created by Author, and all rights are reserved by Author.
 PyerualJetwork is free to use for commercial business and individual users.
-As of 12/21/2024, the library includes PLAN and PLANEAT module, but other machine learning modules are expected to be added in the future.
 
 PyerualJetwork ready for both eager execution(like PyTorch) and static graph(like Tensorflow) concepts because PyerualJetwork using only functions.
 For example:
@@ -68,13 +71,13 @@ For example:
 fit function only fits given training data(suitable for dynamic graph) but learner function learns and optimize entire architecture(suitable for static graph). Or more deeper eager executions PyerualJetwork have: feed_forward function, list of activation functions, loss functions. You can create your unique model architecture. Move your data to GPU or CPU or manage how much should in GPU, Its all up to you.
 <br><br>
 
-PyerualJetworket includes Plan Vision, NLPlan, PLANEAT and at the between of both, Deep Plan.<br>
+PyerualJetworket includes PLAN, MLP & ENE.<br>
 
 PLAN VISION:<br>
 
 ![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PlanVision.jpg)
 
-You can create artificial intelligence models that perform computer vision tasks using the plan module:<br>
+You can create artificial intelligence models that perform computer vision tasks using the neu module:<br>
 
 ![AUTONOMOUS](https://github.com/HCB06/PyerualJetwork/blob/main/Media/autonomous.gif)<br><br><br>
 ![XRAY](https://github.com/HCB06/PyerualJetwork/blob/main/Media/chest_xray.png)<br><br><br>
@@ -84,13 +87,13 @@ NLPlan:<br>
 
 ![NLPLAN](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLPlan.jpg)<br>
 
-You can create artificial intelligence models that perform natural language processing tasks using the plan module:
+You can create artificial intelligence models that perform natural language processing tasks using the neu module:
 
 ![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLP.gif)
 
 PLANEAT:<br>
 
-You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the planeat module:
+You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the ene module:
 
 ![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_1.gif)<br>
 ![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_2.gif)<br>
@@ -113,6 +116,6 @@ HOW DO I IMPORT IT TO MY PROJECT?
 
 Anaconda users can access the 'Anaconda Prompt' terminal from the Start menu and add the necessary library modules to the Python module search queue by typing "pip install pyerualjetwork" and pressing enter. If you are not using Anaconda, you can simply open the 'cmd' Windows command terminal from the Start menu and type "pip install PyerualJetwork". (Visual Studio Code reccomended) After installation, it's important to periodically open the terminal of the environment you are using and stay up to date by using the command "pip install PyerualJetwork --upgrade".
 
-After installing the module using "pip" you can now call the library module in your project environment. Use: “from pyerualjetwork import plan”. Now, you can call the necessary functions from the plan module.
+After installing the module using "pip" you can now call the library module in your project environment. Use: “from pyerualjetwork import neu”. Now, you can call the necessary functions from the neu module.
 
-The PLAN algorithm will not be explained in this document. This document focuses on how professionals can integrate and use PyerualJetwork in their systems. However, briefly, the PLAN algorithm can be described as a classification algorithm. PLAN algorithm achieves this task with an incredibly energy-efficient, fast, and hyperparameter-free user-friendly approach. For more detailed information, you can check out ![PYERUALJETWORK USER MANUEL](https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf) file.
+The PLAN algorithm & ENE algorithm will not be explained in this document. This document focuses on how professionals can integrate and use PyerualJetwork in their systems. However, briefly, the PLAN algorithm can be described as a classification algorithm. PLAN algorithm achieves this task with an incredibly energy-efficient, fast, and hyperparameter-free user-friendly approach. For more detailed information, you can check out ![PYERUALJETWORK USER MANUEL](https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf) file.

{pyerualjetwork-4.8b0 → pyerualjetwork-5}/README.md

@@ -17,13 +17,13 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 
 	pip install pyerualjetwork
 	
-	from pyerualjetwork import plan
-	from pyerualjetwork import planeat
+	from pyerualjetwork import neu
+	from pyerualjetwork import ene
 	from pyerualjetwork import data_operations
 	from pyerualjetwork import model_operations
 	
-	from pyerualjetwork import plan_cuda
-	from pyerualjetwork import planeat_cuda
+	from pyerualjetwork import neu_cuda
+	from pyerualjetwork import ene_cuda
 	from pyerualjetwork import data_operations_cuda
 	from pyerualjetwork import model_operations_cuda
 	
@@ -34,7 +34,7 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 	    'tqdm==4.66.4',
 	    'pandas==2.2.2',
 	    'networkx==3.3',
-		'seaborn==0.13.2',
+	    'seaborn==0.13.2',
 	    'numpy==1.26.4',
 	    'matplotlib==3.9.0',
 	    'colorama==0.4.6',
@@ -48,10 +48,13 @@ YouTube Tutorials: https://www.youtube.com/watch?v=6wMQstZ00is&list=PLNgNWpM7Hbs
 
 ABOUT PYERUALJETWORK:
 
-PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques with optimized GPU acceleration. Its most important component is the PLAN (Potentiation Learning Artificial Neural Network) https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4862342. (THIS ARTICLE IS FIRST VERSION OF PLAN.) MODERN VERSION OF PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
-Both the PLAN algorithm and the PyerualJetwork library were created by Author, and all rights are reserved by Author.
+PyereualJetwork is a large, GPU-accelerated machine learning library in Python designed for professionals and researchers.
+It features PLAN, MLP, and Deep Learning training, as well as ENE (Eugenic NeuroEvolution) for genetic optimization, 
+which can also be applied to genetic algorithms or Reinforcement Learning (RL) problems. 
+The library includes functions for data pre-processing, visualizations, model saving and loading, prediction and evaluation, 
+training, and both detailed and simplified memory management. https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4862342. (THIS ARTICLE IS FIRST VERSION OF PLAN.) MODERN VERSION OF PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+Both the PLAN algorithm ENE algorithm and the PyerualJetwork library were created by Author, and all rights are reserved by Author.
 PyerualJetwork is free to use for commercial business and individual users.
-As of 12/21/2024, the library includes PLAN and PLANEAT module, but other machine learning modules are expected to be added in the future.
 
 PyerualJetwork ready for both eager execution(like PyTorch) and static graph(like Tensorflow) concepts because PyerualJetwork using only functions.
 For example:
@@ -59,13 +62,13 @@ For example:
 fit function only fits given training data(suitable for dynamic graph) but learner function learns and optimize entire architecture(suitable for static graph). Or more deeper eager executions PyerualJetwork have: feed_forward function, list of activation functions, loss functions. You can create your unique model architecture. Move your data to GPU or CPU or manage how much should in GPU, Its all up to you.
 <br><br>
 
-PyerualJetworket includes Plan Vision, NLPlan, PLANEAT and at the between of both, Deep Plan.<br>
+PyerualJetworket includes PLAN, MLP & ENE.<br>
 
 PLAN VISION:<br>
 
 ![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PlanVision.jpg)
 
-You can create artificial intelligence models that perform computer vision tasks using the plan module:<br>
+You can create artificial intelligence models that perform computer vision tasks using the neu module:<br>
 
 ![AUTONOMOUS](https://github.com/HCB06/PyerualJetwork/blob/main/Media/autonomous.gif)<br><br><br>
 ![XRAY](https://github.com/HCB06/PyerualJetwork/blob/main/Media/chest_xray.png)<br><br><br>
@@ -75,13 +78,13 @@ NLPlan:<br>
 
 ![NLPLAN](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLPlan.jpg)<br>
 
-You can create artificial intelligence models that perform natural language processing tasks using the plan module:
+You can create artificial intelligence models that perform natural language processing tasks using the neu module:
 
 ![PLAN VISION](https://github.com/HCB06/PyerualJetwork/blob/main/Media/NLP.gif)
 
 PLANEAT:<br>
 
-You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the planeat module:
+You can create artificial intelligence models that perform reinforcement learning tasks and genetic optimization tasks using the ene module:
 
 ![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_1.gif)<br>
 ![PLANEAT](https://github.com/HCB06/PyerualJetwork/blob/main/Media/PLANEAT_2.gif)<br>
@@ -104,6 +107,6 @@ HOW DO I IMPORT IT TO MY PROJECT?
 
 Anaconda users can access the 'Anaconda Prompt' terminal from the Start menu and add the necessary library modules to the Python module search queue by typing "pip install pyerualjetwork" and pressing enter. If you are not using Anaconda, you can simply open the 'cmd' Windows command terminal from the Start menu and type "pip install PyerualJetwork". (Visual Studio Code reccomended) After installation, it's important to periodically open the terminal of the environment you are using and stay up to date by using the command "pip install PyerualJetwork --upgrade".
 
-After installing the module using "pip" you can now call the library module in your project environment. Use: “from pyerualjetwork import plan”. Now, you can call the necessary functions from the plan module.
+After installing the module using "pip" you can now call the library module in your project environment. Use: “from pyerualjetwork import neu”. Now, you can call the necessary functions from the neu module.
 
-The PLAN algorithm will not be explained in this document. This document focuses on how professionals can integrate and use PyerualJetwork in their systems. However, briefly, the PLAN algorithm can be described as a classification algorithm. PLAN algorithm achieves this task with an incredibly energy-efficient, fast, and hyperparameter-free user-friendly approach. For more detailed information, you can check out ![PYERUALJETWORK USER MANUEL](https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf) file.
+The PLAN algorithm & ENE algorithm will not be explained in this document. This document focuses on how professionals can integrate and use PyerualJetwork in their systems. However, briefly, the PLAN algorithm can be described as a classification algorithm. PLAN algorithm achieves this task with an incredibly energy-efficient, fast, and hyperparameter-free user-friendly approach. For more detailed information, you can check out ![PYERUALJETWORK USER MANUEL](https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf) file.

pyerualjetwork-5/pyerualjetwork/__init__.py

@@ -0,0 +1,73 @@
+""" 
+
+PyerualJetwork
+==============
+PyereualJetwork is a large, GPU-accelerated machine learning library in Python designed for professionals and researchers.
+It features PLAN, MLP, and Deep Learning training, as well as ENE (Eugenic NeuroEvolution) for genetic optimization, 
+which can also be applied to genetic algorithms or Reinforcement Learning (RL) problems. 
+The library includes functions for data pre-processing, visualizations, model saving and loading, prediction and evaluation, 
+training, and both detailed and simplified memory management.
+
+
+Library (CPU) Main Modules:
+---------------------------
+- neu
+- ene
+- data_operations
+- model_operations
+
+Library (GPU) Main Modules:
+---------------------------
+- neu_cuda
+- ene_cuda
+- data_operations_cuda
+- model_operations_cuda
+
+Memory Module:
+--------------
+- memory_operations
+
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
+PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+
+- Author: Hasan Can Beydili
+- YouTube: https://www.youtube.com/@HasanCanBeydili
+- Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
+- Instagram: https://www.instagram.com/canbeydilj
+- Contact: tchasancan@gmail.com
+"""
+
+__version__ = "5"
+__update__ = """* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES
+* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main
+* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"""
+
+def print_version(version):
+    print(f"PyerualJetwork Version {version}\n")
+
+def print_update_notes(update):
+    print(f"Notes:\n{update}")
+
+print_version(__version__)
+print_update_notes(__update__)
+
+required_modules = ["scipy", "tqdm", "pandas", "numpy", "colorama", "cupy", "psutil"]
+
+missing_modules = []
+for module in required_modules:
+    try:
+        __import__(module)
+    except ModuleNotFoundError:
+        missing_modules.append(module)
+
+if missing_modules:
+    raise ImportError(
+    f"Missing modules detected: {', '.join(missing_modules)}\n"
+    "Please run the following command to install the missing packages:\n\n"
+    f"    pip install {' '.join(missing_modules)}\n\n"
+    "For more information, visit the PyerualJetwork GitHub README.md file:\n"
+    "https://github.com/HCB06/PyerualJetwork/blob/main/README.md"
+
+    )

{pyerualjetwork-4.8b0 → pyerualjetwork-5}/pyerualjetwork/data_operations.py

@@ -1,3 +1,33 @@
+""" 
+
+
+Data Operations
+===============
+This module contains functions for handling all operational processes related to data and datasets.
+
+Module functions:
+-----------------
+- encode_one_hot()
+- decode_one_hot()
+- split()
+- manuel_balancer()
+- auto_balancer()
+- synthetic_augmentation()
+- non_neg_normalization()
+- normalization()
+- standard_scaler()
+
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
+PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+
+- Author: Hasan Can Beydili
+- YouTube: https://www.youtube.com/@HasanCanBeydili
+- Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
+- Instagram: https://www.instagram.com/canbeydilj
+- Contact: tchasancan@gmail.com
+"""
+
 from tqdm import tqdm
 import numpy as np
 from colorama import Fore, Style
@@ -383,7 +413,7 @@ def non_neg_normalization(
     dtype=np.float32
 ):
     """
-    Normalizes the input data [0-1] range.
+    Normalizes the input data [0-1] range using max-abs normalization but non negative number.
     Args:
         Input (numpy): Input data to be normalized.
         dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.

{pyerualjetwork-4.8b0 → pyerualjetwork-5}/pyerualjetwork/data_operations_cuda.py

@@ -1,3 +1,33 @@
+""" 
+
+
+Data Operations on GPU (CUDA)
+=============================
+This module contains functions for handling all operational processes related to data and datasets on GPU memory.
+
+Module functions:
+---------------
+- encode_one_hot()
+- decode_one_hot()
+- split()
+- manuel_balancer()
+- auto_balancer()
+- synthetic_augmentation()
+- non_neg_normalization()
+- normalization()
+- standard_scaler()
+
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
+PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+
+- Author: Hasan Can Beydili
+- YouTube: https://www.youtube.com/@HasanCanBeydili
+- Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
+- Instagram: https://www.instagram.com/canbeydilj
+- Contact: tchasancan@gmail.com
+"""
+
 from tqdm import tqdm
 import cupy as cp
 from colorama import Fore, Style

pyerualjetwork-4.8b0/pyerualjetwork/planeat.py → pyerualjetwork-5/pyerualjetwork/ene.py

@@ -1,15 +1,31 @@
 """ 
-MAIN MODULE FOR PLANEAT
+
+
+ENE (Eugenic NeuroEvolution)
+============================
+
+This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution) algorithm.
+For more information about the ENE algorithm: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+
+Module functions:
+-----------------
+- evolver()
+- define_genomes()
+- evaluate()
+- cross_over() 
+- mutation()
+- dominant_parent_selection()
+- second_parent_selection()
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
 PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
-@author: Hasan Can Beydili
-@YouTube: https://www.youtube.com/@HasanCanBeydili
-@Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
-@Instagram: https://www.instagram.com/canbeydilj
-@contact: tchasancan@gmail.com
+- Author: Hasan Can Beydili
+- YouTube: https://www.youtube.com/@HasanCanBeydili
+- Linkedin: https://www.linkedin.com/in/hasan-can-beydili-77a1b9270/
+- Instagram: https://www.instagram.com/canbeydilj
+- Contact: tchasancan@gmail.com
 """
 
 import numpy as np
@@ -22,7 +38,7 @@ from .data_operations import normalization, non_neg_normalization
 from .ui import loading_bars, initialize_loading_bar
 from .activation_functions import apply_activation, all_activations
 
-def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons=None, activation_functions=None, dtype=np.float32):
+def define_genomes(input_shape, output_shape, population_size, neurons=[], activation_functions=[], dtype=np.float32):
    """
    Initializes a population of genomes, where each genome is represented by a set of weights 
    and an associated activation function. Each genome is created with random weights and activation 
@@ -36,17 +52,15 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
       
       population_size (int): The number of genomes (individuals) in the population.
 
-      hidden (int, optional): If you dont want train PLAN model this parameter represents a hidden layer count for MLP model. Default: 0 (PLAN)
+      neurons (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP. Default: [] (PLAN)
 
-      neurons (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP. Default: None (PLAN)
-
-      activation_functions (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP. Default: None (PLAN) NOTE: THIS EFFECTS HIDDEN LAYERS OUTPUT. NOT OUTPUT LAYER!
+      activation_functions (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP. Default: [] (PLAN) NOTE: THIS EFFECTS HIDDEN LAYERS OUTPUT. NOT OUTPUT LAYER!
 
       dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16.
 
    Returns:
       tuple: A tuple containing:
-         - population_weights (numpy.ndarray): A 2D numpy array of shape (population_size, output_shape, input_shape) representing the 
+         - population_weights (numpy.ndarray[numpy.ndarray]): representing the 
             weight matrices for each genome.
          - population_activations (list): A list of activation functions applied to each genome.
    
@@ -56,6 +70,9 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
       The weights for each genome are then modified by applying the corresponding activation function 
       and normalized using the `normalization()` function. (Max abs normalization.)
    """
+
+   hidden = len(neurons)
+
    if hidden > 0:
       population_weights = np.empty((population_size, hidden + 1), dtype=object)
       population_activations = [[0] * (hidden) for _ in range(population_size)]
@@ -112,7 +129,7 @@ def define_genomes(input_shape, output_shape, population_size, hidden=0, neurons
 
 
 def evolver(weights, 
-            activation_potentiations,
+            activations,
             what_gen, 
             fitness,
             weight_evolve=True,
@@ -148,7 +165,7 @@ def evolver(weights,
       weights (numpy.ndarray): Array of weights for each genome. 
          (first returned value of define_genomes function)
       
-      activation_potentiations (list[str]): A list of activation functions for each genome. 
+      activations (list[str]): A list of activation functions for each genome. 
          (second returned value of define_genomes function) NOTE!: 'activation potentiations' for PLAN 'activation functions' for MLP.
       
       what_gen (int): The current generation number, used for informational purposes or logging.
@@ -242,7 +259,7 @@ def evolver(weights,
       tuple: A tuple containing:
          - weights (numpy.ndarray): The updated weights for the population after selection, crossover, and mutation. 
                                     The shape is (population_size, output_shape, input_shape).
-         - activation_potentiations (list): The updated list of activation functions for the population.
+         - activations (list): The updated list of activation functions for the population.
 
    Notes:
       - **Selection Process**: 
@@ -263,7 +280,7 @@ def evolver(weights,
 
    Example:
       ```python
-      weights, activation_potentiations = planeat.evolver(weights, activation_potentiations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggressive')
+      weights, activations = ene.evolver(weights, activations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggressive')
       ```
 
       - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
@@ -327,7 +344,7 @@ def evolver(weights,
    fitness = fitness[sort_indices]
    weights = weights[sort_indices]
 
-   activation_potentiations = [activation_potentiations[i] for i in sort_indices]
+   activations = [activations[i] for i in sort_indices]
 
 ### GENOMES ARE DIVIDED INTO TWO GROUPS: GOOD GENOMES AND BAD GENOMES:
 
@@ -335,8 +352,8 @@ def evolver(weights,
    bad_weights = weights[:slice_center]
    best_weight = np.copy(good_weights[-1]) if is_mlp is False else copy.deepcopy(good_weights[-1])
 
-   good_activations = list(activation_potentiations[slice_center:])
-   bad_activations = list(activation_potentiations[:slice_center])
+   good_activations = list(activations[slice_center:])
+   bad_activations = list(activations[:slice_center])
    best_activations = good_activations[-1].copy() if isinstance(good_activations[-1], list) else good_activations[-1]
 
    
@@ -469,11 +486,11 @@ def evolver(weights,
    else:
       weights = np.vstack((child_W, mutated_W), dtype=dtype)
    
-   activation_potentiations = child_act + mutated_act
+   activations = child_act + mutated_act
 
    if save_best_genome:
       weights[0] = best_weight
-      activation_potentiations[0] = best_activations
+      activations[0] = best_activations
    
    ### INFO PRINTING CONSOLE
    
@@ -497,7 +514,7 @@ def evolver(weights,
       print("  ACTIVATION SELECTION THRESHOLD:", str(activation_selection_threshold))
       print("  ACTIVATION SELECTION ADD PROB: ", str(activation_selection_add_prob))
       print("  ACTIVATION SELECTION CHANGE PROB: ", str(activation_selection_change_prob))
-      print("  FITNESS BIAS: ", str(fitness_bias) + '\n')
+      print("  FITNESS BIAS: ", str(fitness_bias))
       print("  SAVE BEST GENOME: ", str(save_best_genome) + '\n')
 
 
@@ -506,15 +523,16 @@ def evolver(weights,
       print("  MEAN FITNESS: ", str(round(np.mean(fitness), 2)))
       print("  MIN FITNESS: ", str(round(min(fitness), 2)) + '\n')
 
+      print("  BEST GENOME ACTIVATION LENGTH: ", str(len(best_activations)))
       print("  PREVIOUS BEST GENOME ACTIVATION LENGTH: ", str(len(best_activations)))
-      print("  PREVIOUS BEST GENOME INDEX: ", str(previous_best_genome_index))
+      print("  PREVIOUS BEST GENOME INDEX: ", str(previous_best_genome_index) + '\n')
       
    if weight_evolve is False: weights = origin_weights
 
-   return weights, activation_potentiations
+   return weights, activations
 
 
-def evaluate(Input, weights, activation_potentiations, is_mlp=False):
+def evaluate(Input, weights, activations, is_mlp=False):
    """
     Evaluates the performance of a population of genomes, applying different activation functions 
     and weights depending on whether reinforcement learning mode is enabled or not.
@@ -524,7 +542,7 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
                                                a genome (A list of input features for each genome, or a single set of input features for one genome).
         weights (list or numpy.ndarray): A list or 2D numpy array of weights corresponding to each genome 
                                          in `x_population`. This determines the strength of connections.
-        activation_potentiations (list or str): A list where each entry represents an activation function 
+        activations (list or str): A list where each entry represents an activation function 
                                                 or a potentiation strategy applied to each genome. If only one 
                                                 activation function is used, this can be a single string.
         is_mlp (bool, optional): Evaluate PLAN model or MLP model ? Default: False (PLAN)
@@ -535,7 +553,7 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
 
     Example:
         ```python
-        outputs = evaluate(Input, weights, activation_potentiations)
+        outputs = evaluate(Input, weights, activations)
         ```
 
     - The function returns a list of outputs after processing the population, where each element corresponds to
@@ -543,16 +561,16 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
    """
    ### THE OUTPUTS ARE RETURNED, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
    
-   if isinstance(activation_potentiations, str):
-      activation_potentiations = [activation_potentiations]
-   elif isinstance(activation_potentiations, list):
-      activation_potentiations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiations]
+   if isinstance(activations, str):
+      activations = [activations]
+   elif isinstance(activations, list):
+      activations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activations]
 
 
    if is_mlp:
       layer = Input
       for i in range(len(weights)):
-         if i != len(weights) - 1 and i != 0: layer = apply_activation(layer, activation_potentiations[i])
+         if i != len(weights) - 1 and i != 0: layer = apply_activation(layer, activations[i])
 
          layer = layer @ weights[i].T
       
@@ -560,7 +578,7 @@ def evaluate(Input, weights, activation_potentiations, is_mlp=False):
 
    else:
 
-      Input = apply_activation(Input, activation_potentiations)
+      Input = apply_activation(Input, activations)
       result = Input @ weights.T
 
       return result