pyerualjetwork 4.8__py3-none-any.whl → 5b0__py3-none-any.whl

pyerualjetwork/{plan.py → neu.py}

@@ -1,23 +1,40 @@
 # -*- coding: utf-8 -*-
-"""
+""" 
+
+
+NEU (Neural Networks)
+=====================
+This module hosts functions for training and evaluating artificial neural networks for labeled classification tasks (for now).
+
+Currently, two types of models can be trained:
 
-MAIN MODULE FOR PLAN
+    PLAN (Potentiation Learning Artificial Neural Network)
+    MLP (Multi-Layer Perceptron → Deep Learning) -- With non-bias
+
+For more information about PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+
+Module functions:
+-----------------
+- plan_fit()
+- learn()
+- evaluate()
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
-PLAN document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
-PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+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
 import copy
 
+import neu
+
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
 from .data_operations import normalization, batcher
@@ -40,23 +57,23 @@ bar_format_learner = loading_bars()[1]
 
 # BUILD -----
 
-def fit(
+def plan_fit(
     x_train,
     y_train,
-    activation_potentiation=['linear'],
+    activations=['linear'],
     W=None,
     auto_normalization=False,
     dtype=np.float32
 ):
     """
-    Creates a model to fitting data.
+    Creates a PLAN model to fitting data.
     
     Args:
         x_train (aray-like[num]): List or numarray of input data.
 
         y_train (aray-like[num]): List or numarray of target labels. (one hot encoded)
 
-        activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None] (optional)
+        activations (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None] (optional)
 
         W (numpy.ndarray): If you want to re-continue or update model
 
@@ -74,8 +91,8 @@ def fit(
 
     weight = np.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
-    if auto_normalization is True: x_train = normalization(apply_activation(x_train, activation_potentiation))
-    elif auto_normalization is False: x_train = apply_activation(x_train, activation_potentiation)
+    if auto_normalization is True: x_train = normalization(apply_activation(x_train, activations))
+    elif auto_normalization is False: x_train = apply_activation(x_train, activations)
     else: raise ValueError('normalization parameter only be True or False')
     
     weight += y_train.T @ x_train
@@ -83,11 +100,11 @@ def fit(
     return normalization(weight, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
+def learn(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
            weight_evolve=True, neural_web_history=False, show_current_activations=False, auto_normalization=False,
            neurons_history=False, early_stop=False, show_history=False, target_loss=None,
            interval=33.33, target_acc=None, loss='categorical_crossentropy', acc_impact=0.9, loss_impact=0.1,
-           start_this_act=None, start_this_W=None, neurons=None, hidden=0, activation_functions=None, dtype=np.float32):
+           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], dtype=np.float32):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation(or activation function) & weight values for the given dataset.
@@ -99,15 +116,15 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     :Args:
     :param x_train: (array-like): Training input data.
     :param y_train: (array-like): Labels for training data. one-hot encoded.
-    :param optimizer: (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat (and) optimizer = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+    :param optimizer: (function): Optimization technique with hyperparameters. (PLAN and MLP (both) using ENE for optimization.) Please use this: from pyerualjetwork.ene import evolver (and) optimizer = lambda *args, **kwargs: evolver(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
     ```python
-    optimizer = lambda *args, **kwargs: planeat.evolver(*args,
+             optimizer = lambda *args, **kwargs: ene.evolver(*args,
                                                             activation_add_prob=0.05,
                                                             strategy='aggressive',
                                                             policy='more_selective',
                                                             **kwargs)
 
-    model = plan.learner(x_train,
+             model = neu.learn(x_train,
                             y_train,
                             optimizer,
                             fit_start=True,
@@ -135,40 +152,40 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     :param loss_impact: (float, optional): Impact of loss for optimization [0-1]. Default: 0.1
     :param start_this_act: (list, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the list of activation functions selected up to the learned portion to this parameter. Default is None
     :param start_this_W: (numpy.array, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the weight matrix of this genome. Default is None
-    :param hidden: (int, optional): If you dont want train PLAN model this parameter represents a hidden layer count for MLP model. Default: 0 (PLAN)
-    :param 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)
-    :param 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!
+    :param neurons: (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP. Number of elements --> Layer count. Default: [] (No hidden layer) --> architecture setted to PLAN, if not --> architecture setted to MLP.
+    :param activation_functions: (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP. if neurons is not [] --> uses default: ['linear'] * len(neurons). if neurons is [] --> uses [].
     :param dtype: (numpy.dtype): Data type for the Weight matrices. np.float32 by default. Example: np.float64 or np.float16.
 
     Returns:
-        tuple: A list for model parameters: [Weight matrix, Test loss, Test Accuracy, [Activations functions]].
+        tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]].
     """
 
-    from .planeat import define_genomes
+    from .ene import define_genomes
 
     data = 'Train'
 
     except_this = ['spiral', 'circular']
-    activation_potentiation = [item for item in all_activations() if item not in except_this]
-    activation_potentiation_len = len(activation_potentiation)
+    activations = [item for item in all_activations() if item not in except_this]
+    activations_len = len(activations)
    
     # Pre-checks
 
-    if pop_size is None: pop_size = activation_potentiation_len
+    if pop_size is None: pop_size = activations_len
     y_train = optimize_labels(y_train, cuda=False)
 
-    if pop_size < activation_potentiation_len: raise ValueError(f"pop_size must be higher or equal to {activation_potentiation_len}")
+    if pop_size < activations_len: raise ValueError(f"pop_size must be higher or equal to {activations_len}")
 
-    if gen is None: gen = activation_potentiation_len
+    if gen is None: gen = activations_len
 
     if target_acc is not None and (target_acc < 0 or target_acc > 1): raise ValueError('target_acc must be in range 0 and 1')
     if fit_start is not True and fit_start is not False: raise ValueError('fit_start parameter only be True or False. Please read doc-string')
 
-    if hidden is not 0 and neurons is not None and activation_functions is not None:
+    if neurons is not []:
         fit_start = False
         weight_evolve = True
         is_mlp = True
-        activation_potentiation = activation_functions
+        if activation_functions == []: activation_functions = ['linear'] * len(neurons)
+        activations = activation_functions
     else:
         is_mlp = False
 
@@ -184,10 +201,10 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=77, bar_format=bar_format_learner)
+    progress = initialize_loading_bar(total=activations_len, desc="", ncols=77, bar_format=bar_format_learner)
 
-    if fit_start is False or pop_size > activation_potentiation_len:
-        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), neurons=neurons, hidden=hidden, activation_functions=activation_functions, population_size=pop_size, dtype=dtype)
+    if fit_start is False or pop_size > activations_len:
+        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), neurons=neurons, activation_functions=activation_functions, population_size=pop_size, dtype=dtype)
 
     else:
         weight_pop = [0] * pop_size
@@ -210,18 +227,18 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
 
             x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
             
-            if fit_start is True and i == 0 and j < activation_potentiation_len:
+            if fit_start is True and i == 0 and j < activations_len:
                 if start_this_act is not None and j == 0:
                     pass
                 else:
-                    act_pop[j] = activation_potentiation[j]
-                    W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                    act_pop[j] = activations[j]
+                    W = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
             
             if weight_evolve is False:
-                weight_pop[j] = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
 
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j], auto_normalization=auto_normalization, is_mlp=is_mlp)
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activations=act_pop[j], auto_normalization=auto_normalization, is_mlp=is_mlp)
             acc = model[get_acc()]
             
             if loss == 'categorical_crossentropy':
@@ -278,7 +295,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
-                                        activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                                        activations=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
                                                            y_pred_batch=train_model[get_preds_softmax()])
@@ -298,7 +315,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight,
-                                        activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                                        activations=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -351,7 +368,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
                 train_model = evaluate(x_train, y_train, W=best_weight, 
-                                    activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                                    activations=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
                 
             if loss == 'categorical_crossentropy':
                 train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -373,7 +390,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     progress.close()
 
     train_model = evaluate(x_train, y_train, W=best_weight,
-                        activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                        activations=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -395,7 +412,7 @@ def evaluate(
     x_test,
     y_test,
     W,
-    activation_potentiation=['linear'],
+    activations=['linear'],
     auto_normalization=False,
     is_mlp=False
 ) -> tuple:
@@ -409,7 +426,7 @@ def evaluate(
 
         W (np.ndarray): Neural net weight matrix.
         
-        activation_potentiation (list, optional): Activation list. Default = ['linear'].
+        activations (list, optional): Activation list. Default = ['linear'].
 
         auto_normalization (bool, optional): Normalization for x_test ? Default = False.
         
@@ -421,15 +438,15 @@ def evaluate(
 
     if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
 
-    if isinstance(activation_potentiation, str):
-        activation_potentiation = [activation_potentiation]
-    elif isinstance(activation_potentiation, list):
-        activation_potentiation = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiation]
+    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 = x_test
         for i in range(len(W)):
-            if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activation_potentiation[i])
+            if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activations[i])
 
             layer = layer @ W[i].T
 
@@ -437,7 +454,7 @@ def evaluate(
 
     else:
 
-        x_test = apply_activation(x_test, activation_potentiation)
+        x_test = apply_activation(x_test, activations)
         result = x_test @ W.T
     
     max_vals = np.max(result, axis=1, keepdims=True)

pyerualjetwork/{plan_cuda.py → neu_cuda.py}

@@ -1,18 +1,33 @@
 # -*- coding: utf-8 -*-
-"""
+""" 
+
+
+NEU (Neural Networks) on CUDA
+=============================
+This module hosts functions for training and evaluating artificial neural networks on CUDA GPU for labeled classification tasks (for now).
+
+Currently, two types of models can be trained:
 
-MAIN MODULE FOR PLAN_CUDA
+    PLAN (Potentiation Learning Artificial Neural Network)
+    MLP (Multi-Layer Perceptron → Deep Learning) -- With non-bias
+
+For more information about PLAN: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
+
+Module functions:
+-----------------
+- plan_fit()
+- learn()
+- evaluate()
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
-PLAN document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
-PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+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 cupy as cp
@@ -41,21 +56,21 @@ bar_format_learner = loading_bars()[1]
 
 # BUILD -----
 
-def fit(
+def plan_fit(
     x_train,
     y_train,
-    activation_potentiation=['linear'],
+    activation_functions=['linear'],
     W=None,
     auto_normalization=False,
     dtype=cp.float32
 ):
     """
-    Creates a model to fitting data.,
+    Creates a PLAN model to fitting data.,
     
-    fit Args:
+    plan_fit Args:
         :param (aray-like[cupy]) x_train: (aray-like[cupy]): List or cupy array of input data.
         :param (aray-like[cupy]) y_train: List or cupy array of target labels. (one hot encoded)
-        :param (list) activation_potentiation: For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None] (optional)
+        :param (list) activation_functions: For deeper PLAN networks, activation function parameters. For more information please run this code: nn.activations_list() default: [None] (optional)
         W (cupy.ndarray, optional): If you want to re-continue or update model
         auto_normalization (bool, optional): Normalization may solves overflow problem. Default: False
         dtype (cupy.dtype, optional): Data type for the arrays. cp.float32 by default. Example: cp.float64 or cp.float16.
@@ -69,40 +84,40 @@ def fit(
 
     weight = cp.zeros((len(y_train[0]), len(x_train[0].ravel()))).astype(dtype, copy=False) if W is None else W
 
-    if auto_normalization is True: x_train = normalization(apply_activation(x_train, activation_potentiation))
-    elif auto_normalization is False: x_train = apply_activation(x_train, activation_potentiation)
+    if auto_normalization is True: x_train = normalization(apply_activation(x_train, activation_functions))
+    elif auto_normalization is False: x_train = apply_activation(x_train, activation_functions)
     else: raise ValueError('normalization parameter only be True or False')
     
     weight += y_train.T @ x_train
 
     return normalization(weight, dtype=dtype)
 
-
-def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
+def learn(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, pop_size=None,
            weight_evolve=True, neural_web_history=False, show_current_activations=False, auto_normalization=False, target_acc=None,
            neurons_history=False, early_stop=False, show_history=False, loss='categorical_crossentropy',
            interval=33.33, target_loss=None, loss_impact=0.1, acc_impact=0.9,
-           start_this_act=None, start_this_W=None, neurons=None, hidden=0, activation_functions=None, dtype=cp.float32, memory='gpu'):
+           start_this_act=None, start_this_W=None, neurons=[], activation_functions=[], dtype=cp.float32, memory='gpu'):
     """
     Optimizes the activation functions for a neural network by leveraging train data to find 
     the most accurate combination of activation potentiation(or activation function) & weight values for the given dataset.
 
     Why genetic optimization ENE(Eugenic NeuroEvolution) and not backpropagation?
     Because PLAN is different from other neural network architectures. In PLAN, the learnable parameters are not the weights; instead, the learnable parameters are the activation functions.
-    Since activation functions are not differentiable, we cannot use gradient descent or backpropagation. However, I developed a more powerful genetic optimization algorithm: PLANEAT.
+    Since activation functions are not differentiable, we cannot use gradient descent or backpropagation. However, I developed a more powerful genetic optimization algorithm: ENE.
 
     :Args:
     :param x_train: (array-like): Training input data.
     :param y_train: (array-like): Labels for training data.
-    :param optimizer: (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat_cuda (and) optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+    :param optimizer: (function): Optimization technique with hyperparameters. (PLAN and MLP (both) using ENE for optimization.) Please use this: from pyerualjetwork.ene_cuda import evolver (and) optimizer = lambda *args, **kwargs: evolver(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
     ```python
-    optimizer = lambda *args, **kwargs: planeat_cuda.evolver(*args,
-                                                                activation_add_prob=0.05,
-                                                                strategy='aggressive',
-                                                                policy='more_selective',
-                                                                **kwargs)
+    
+            optimizer = lambda *args, **kwargs: ene_cuda.evolver(*args,
+                                                    activation_add_prob=0.05,
+                                                    strategy='aggressive',
+                                                    policy='more_selective',
+                                                    **kwargs)
 
-    model = plan_cuda.learner(x_train,
+             model = neu_cuda.learn(x_train,
                             y_train,
                             optimizer,
                             fit_start=True,
@@ -130,30 +145,29 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     :param acc_impact: (float, optional): Impact of accuracy for optimization [0-1]. Default: 0.9
     :param start_this_act: (list, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the list of activation functions selected up to the learned portion to this parameter. Default is None
     :param start_this_W: (cupy.array, optional): To resume a previously canceled or interrupted training from where it left off, or to continue from that point with a different strategy, provide the weight matrix of this genome. Default is None
-    :param hidden: (int, optional): If you dont want train PLAN model this parameter represents a hidden layer count for MLP model. Default: 0 (PLAN)
-    :param 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)
-    :param 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!
+    :param neurons: (list[int], optional): If you dont want train PLAN model this parameter represents neuron count of each hidden layer for MLP. Number of elements --> Layer count. Default: [] (No hidden layer) --> architecture setted to PLAN, if not --> architecture setted to MLP.
+    :param activation_functions: (list[str], optional): If you dont want train PLAN model this parameter represents activation function of each hidden layer for MLP. if neurons is not [] --> uses default: ['linear'] * len(neurons). if neurons is [] --> uses [].
     :param dtype: (cupy.dtype): Data type for the Weight matrices. np.float32 by default. Example: cp.float64 or cp.float16.
     :param memory: (str): The memory parameter determines whether the dataset to be processed on the GPU will be stored in the CPU's RAM or the GPU's RAM. Options:  'gpu', 'cpu'. Default: 'gpu'.
 
     Returns:
-        tuple: A list for model parameters: [Weight matrix, Preds, Accuracy, [Activations functions]]. You can acces this parameters in model_operations module. For example: model_operations.get_weights() for Weight matrix.
+        tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]]. You can acces this parameters in model_operations module. For example: model_operations.get_weights() for Weight matrix.
     """
 
-    from .planeat_cuda import define_genomes
+    from .ene_cuda import define_genomes
 
     data = 'Train'
 
     except_this = ['spiral', 'circular']
-    activation_potentiation = [item for item in all_activations() if item not in except_this]
-    activation_potentiation_len = len(activation_potentiation)
+    activation_functions = [item for item in all_activations() if item not in except_this]
+    activation_functions_len = len(activation_functions)
 
-    if pop_size is None: pop_size = activation_potentiation_len
+    if pop_size is None: pop_size = activation_functions_len
     y_train = optimize_labels(y_train, cuda=True)
 
-    if pop_size < activation_potentiation_len: raise ValueError(f"pop_size must be higher or equal to {activation_potentiation_len}")
+    if pop_size < activation_functions_len: raise ValueError(f"pop_size must be higher or equal to {activation_functions_len}")
 
-    if gen is None: gen = activation_potentiation_len
+    if gen is None: gen = activation_functions_len
 
     if memory == 'gpu':
         x_train = transfer_to_gpu(x_train, dtype=x_train.dtype)
@@ -173,11 +187,12 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     if target_acc is not None and (target_acc < 0 or target_acc > 1): raise ValueError('target_acc must be in range 0 and 1')
     if fit_start is not True and fit_start is not False: raise ValueError('fit_start parameter only be True or False. Please read doc-string')
 
-    if hidden is not 0 and neurons is not None and activation_functions is not None:
+    if neurons is not []:
         fit_start = False
         weight_evolve = True
         is_mlp = True
-        activation_potentiation = activation_functions
+        if activation_functions == []: activation_functions = ['linear'] * len(neurons)
+        activations = activation_functions
     else:
         is_mlp = False
 
@@ -193,10 +208,10 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     loss_list = []
     target_pop = []
 
-    progress = initialize_loading_bar(total=activation_potentiation_len, desc="", ncols=79, bar_format=bar_format_learner)
+    progress = initialize_loading_bar(total=activation_functions_len, desc="", ncols=79, bar_format=bar_format_learner)
 
-    if fit_start is False or pop_size > activation_potentiation_len:
-        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), neurons=neurons, hidden=hidden, activation_functions=activation_functions, population_size=pop_size, dtype=dtype)
+    if fit_start is False or pop_size > activation_functions_len:
+        weight_pop, act_pop = define_genomes(input_shape=len(x_train[0]), output_shape=len(y_train[0]), neurons=neurons, activation_functions=activation_functions, population_size=pop_size, dtype=dtype)
         
     else:
         weight_pop = [0] * pop_size
@@ -222,18 +237,18 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             x_train_batch = cp.array(x_train_batch, dtype=x_train_batch.dtype, copy=False)
             y_train_batch = cp.array(y_train_batch, dtype=y_train.dtype)
 
-            if fit_start is True and i == 0 and j < activation_potentiation_len:
+            if fit_start is True and i == 0 and j < activation_functions_len:
                 if start_this_act is not None and j == 0:
                     pass
                 else:
-                    act_pop[j] = activation_potentiation[j]
-                    W = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
+                    act_pop[j] = activation_functions[j]
+                    W = plan_fit(x_train_batch, y_train_batch, activation_functions=act_pop[j], auto_normalization=auto_normalization, dtype=dtype)
                     weight_pop[j] = W
                     
             if weight_evolve is False:
-                weight_pop[j] = fit(x_train_batch, y_train_batch, activation_potentiation=act_pop[j], auto_normalization=auto_normalization, dtype=dtype) 
+                weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activation_functions=act_pop[j], auto_normalization=auto_normalization, dtype=dtype) 
             
-            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_potentiation=act_pop[j], auto_normalization=auto_normalization, is_mlp=is_mlp)
+            model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activation_functions=act_pop[j], auto_normalization=auto_normalization, is_mlp=is_mlp)
             acc = model[get_acc()]
  
             if loss == 'categorical_crossentropy':
@@ -291,7 +306,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_acc is not None and best_acc >= target_acc:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight, 
-                                        activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                                        activation_functions=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
                                                            y_pred_batch=train_model[get_preds_softmax()])
@@ -311,7 +326,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
                 if target_loss is not None and best_loss <= target_loss:
                     progress.close()
                     train_model = evaluate(x_train, y_train, W=best_weight,
-                                        activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                                        activation_functions=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
 
                     if loss == 'categorical_crossentropy':
                         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -363,7 +378,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:
                 progress.close()
                 train_model = evaluate(x_train, y_train, W=best_weight, 
-                                    activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                                    activation_functions=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
                 
             if loss == 'categorical_crossentropy':
                 train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -384,7 +399,7 @@ def learner(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1,
     # Final evaluation
     progress.close()
     train_model = evaluate(x_train, y_train, W=best_weight,
-                        activation_potentiation=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
+                        activation_functions=final_activations, auto_normalization=auto_normalization, is_mlp=is_mlp)
 
     if loss == 'categorical_crossentropy':
         train_loss = categorical_crossentropy(y_true_batch=y_train, 
@@ -405,7 +420,7 @@ def evaluate(
     x_test,
     y_test,
     W,
-    activation_potentiation=['linear'],
+    activation_functions=['linear'],
     auto_normalization=False,
     is_mlp=False
 ) -> tuple:
@@ -419,7 +434,7 @@ def evaluate(
         
         W (cp.ndarray): Neural net weight matrix.
         
-        activation_potentiation (list): Activation list. Default = ['linear'].
+        activation_functions (list): Activation list. Default = ['linear'].
 
         auto_normalization (bool, optional): Normalization for x_test ? Default = False.
         
@@ -431,15 +446,15 @@ def evaluate(
 
     if auto_normalization: x_test = normalization(x_test, dtype=x_test.dtype)
 
-    if isinstance(activation_potentiation, str):
-        activation_potentiation = [activation_potentiation]
-    elif isinstance(activation_potentiation, list):
-        activation_potentiation = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiation]
+    if isinstance(activation_functions, str):
+        activation_functions = [activation_functions]
+    elif isinstance(activation_functions, list):
+        activation_functions = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_functions]
 
     if is_mlp:
         layer = x_test
         for i in range(len(W)):
-            if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activation_potentiation[i])
+            if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activation_functions[i])
 
             layer = layer @ W[i].T
 
@@ -447,7 +462,7 @@ def evaluate(
 
     else:
 
-        x_test = apply_activation(x_test, activation_potentiation)
+        x_test = apply_activation(x_test, activation_functions)
         result = x_test @ W.T
 
     max_vals = cp.max(result, axis=1, keepdims=True)

{pyerualjetwork-4.8.dist-info → pyerualjetwork-5b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.8
+Version: 5b0
 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
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

pyerualjetwork-5b0.dist-info/RECORD

@@ -0,0 +1,25 @@
+pyerualjetwork/__init__.py,sha256=jec86Uk9HsivIT2ZJGGRxAwLDdKKr074d_UyYmhtTGY,2631
+pyerualjetwork/activation_functions.py,sha256=X7Kv8qv8oZq8hvTdUiV-GkFjKHRlKIQypRPXh6gdkm4,7614
+pyerualjetwork/activation_functions_cuda.py,sha256=pefklsl9QuSVbKwiUUHeF_ExN0bICH7QIF1MfoMU40Q,7665
+pyerualjetwork/data_operations.py,sha256=LKmLfl43zSCCuP2cWkBM-D6GtlhxXQggsNvZNUwHDe4,16347
+pyerualjetwork/data_operations_cuda.py,sha256=7p_v0yabHwq5Ft0jxWGEq1ZKyBFxOxvZvtPQjkcligk,18525
+pyerualjetwork/ene.py,sha256=Dnx96FmQHxCbeT0IcUOydG7R8lPTlzmU_xXU9P4VBPY,45117
+pyerualjetwork/ene_cuda.py,sha256=KgmpfgUH9KK5hDy6qqk3P9CX7N1dsFTTVIbFcASOLrM,45648
+pyerualjetwork/fitness_functions.py,sha256=urRdeMvUhNgWxD4ZGHCRdQlIf9cTWYMvF3_aVBojRqY,1235
+pyerualjetwork/help.py,sha256=F1xDDKqHGeUIXM-mo5c0Eav5XidCVNc62LvXqwS2Zbs,785
+pyerualjetwork/loss_functions.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
+pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
+pyerualjetwork/memory_operations.py,sha256=Ch2QydBGHR5Be6fZu59C8eF8z-C2c3HVDIH8fz07BZo,14258
+pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,6077
+pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
+pyerualjetwork/model_operations.py,sha256=F5qYAU578yrS1cUCwsaPJnqgfEAEUD_50vspakypTGY,15971
+pyerualjetwork/model_operations_cuda.py,sha256=lgYAEGUERTMU7TEWRVKaa3yk_IOt4Jo9RJP9lDsNREU,17206
+pyerualjetwork/neu.py,sha256=5CwWKZ-tix4M4_Gf0PfmnMLJttHdKXsB1GZ6_FvfB04,24966
+pyerualjetwork/neu_cuda.py,sha256=3NnpiQPwqcbbkQSLZNyCSZLJdb5DS_Q0_fEAzPYkEYU,26327
+pyerualjetwork/ui.py,sha256=JBTFYz5R24XwNKhA3GSW-oYAoiIBxAE3kFGXkvm5gqw,656
+pyerualjetwork/visualizations.py,sha256=utnX9zQhzmtvBJLOLNGm2jecVVk4zHXABQdjb0XzJac,28352
+pyerualjetwork/visualizations_cuda.py,sha256=gnoaaazZ-nc9E1ImqXrZBRgQ4Rnpi2qh2yGJ2eLKMlE,28807
+pyerualjetwork-5b0.dist-info/METADATA,sha256=Wjw5A82pD-qSNvLGtVFTHHs31hfxQW6jMZKNBUDbzQc,7503
+pyerualjetwork-5b0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-5b0.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-5b0.dist-info/RECORD,,