pyerualjetwork 5b3__py3-none-any.whl → 5.0.2__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -11,10 +11,10 @@ training, and both detailed and simplified memory management.
 
 Library (CPU) Main Modules:
 ---------------------------
-- neu
-- ene
-- data_operations
-- model_operations
+- neu_cpu
+- ene_cpu
+- data_operations_cpu
+- model_operations_cpu
 
 Library (GPU) Main Modules:
 ---------------------------
@@ -27,9 +27,13 @@ Memory Module:
 --------------
 - memory_operations
 
+Issue Solver Module:
+--------------
+- issue_solver
+
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -38,7 +42,7 @@ PyerualJetwork document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_A
 - Contact: tchasancan@gmail.com
 """
 
-__version__ = "5b3"
+__version__ = "5.0.2"
 __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

pyerualjetwork/{data_operations.py → data_operations_cpu.py}

@@ -1,9 +1,9 @@
 """ 
 
 
-Data Operations
-===============
-This module contains functions for handling all operational processes related to data and datasets.
+Data Operations on CPU
+======================
+This module contains functions for handling all operational processes related to data and datasets on CPU memory(RAM).
 
 Module functions:
 -----------------
@@ -19,7 +19,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili

pyerualjetwork/data_operations_cuda.py

@@ -3,7 +3,7 @@
 
 Data Operations on GPU (CUDA)
 =============================
-This module contains functions for handling all operational processes related to data and datasets on GPU memory.
+This module contains functions for handling all operational processes related to data and datasets on CUDA GPU memory(VRAM).
 
 Module functions:
 ---------------

pyerualjetwork/{ene.py → ene_cpu.py}

@@ -1,10 +1,10 @@
 """ 
 
 
-ENE (Eugenic NeuroEvolution)
-============================
+ENE (Eugenic NeuroEvolution) on CPU
+===================================
 
-This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution) algorithm.
+This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution) algorithm on CPU.
 For more information about the ENE algorithm: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
 
 Module functions:
@@ -19,7 +19,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -34,9 +34,9 @@ import math
 import copy
 
 ### LIBRARY IMPORTS ###
-from .data_operations import normalization, non_neg_normalization
+from .data_operations_cpu import normalization, non_neg_normalization
 from .ui import loading_bars, initialize_loading_bar
-from .activation_functions import apply_activation, all_activations
+from .activation_functions_cpu import apply_activation, all_activations
 
 def define_genomes(input_shape, output_shape, population_size, neurons=[], activation_functions=[], dtype=np.float32):
    """
@@ -280,7 +280,7 @@ def evolver(weights,
 
    Example:
       ```python
-      weights, activations = planeat.evolver(weights, activations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggressive')
+      weights, activations = ene_cpu.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.

pyerualjetwork/ene_cuda.py

@@ -2,7 +2,7 @@
 
 
 ENE (Eugenic NeuroEvolution) on CUDA
-======================================
+====================================
 
 This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution) algorithm on CUDA GPU.
 For more information about the ENE algorithm: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PLAN/PLAN.pdf
@@ -19,7 +19,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -280,7 +280,7 @@ def evolver(weights,
 
    Example:
       ```python
-      weights, activations = planeat_cuda.evolver(weights, activations, 1, fitness, show_info=True, strategy='normal_selective', policy='aggressive')
+      weights, activations = ene_cuda.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.

pyerualjetwork/fitness_functions.py

@@ -13,4 +13,5 @@ def wals(acc, loss, acc_impact, loss_impact):
     loss += np.finfo(float).eps
     loss_impact += np.finfo(float).eps
     
-    return (acc * acc_impact) + ((loss_impact / loss) * loss_impact)
+    return (acc * acc_impact) + ((loss_impact / loss) * loss_impact)
+import __init__

pyerualjetwork/help.py

@@ -1,4 +1,4 @@
-from activation_functions import all_activations
+from pyerualjetwork.activation_functions_cpu import all_activations
 
 
 def activation_potentiation():

pyerualjetwork/issue_solver.py

@@ -0,0 +1,77 @@
+""" 
+
+
+Issue Solver
+============
+This module provides ready-to-use functions to identify potential issues caused by version incompatibilities in major updates,
+ensuring users are not affected by such problems. PyereualJetwork aims to offer a seamless experience for its users.
+
+
+Module functions:
+-----------------
+- update_model_to_v5()
+
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_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
+"""
+
+def update_model_to_v5(model_name, model_path, is_cuda):
+
+    """
+    update_model_to_v5 function helps users for update models from older versions to newer versions.
+   
+    :param str model_name: Name of saved model.
+    
+    :param str model_path: Path of saved model.
+
+    :param bool is_cuda: If model saved with cuda modules.
+    
+    :return: prints terminal if succes.
+    """
+
+    if is_cuda:
+
+        from .model_operations_cuda import (get_act, 
+                                            get_weights,
+                                            get_scaler, 
+                                            get_acc, 
+                                            get_model_type,
+                                            get_weights_type, 
+                                            get_weights_format,
+                                            load_model,
+                                            save_model)
+    else:
+
+        from .model_operations_cpu import (get_act, 
+                                            get_weights,
+                                            get_scaler, 
+                                            get_acc, 
+                                            get_model_type, 
+                                            get_weights_type,
+                                            get_weights_format,
+                                            load_model,
+                                            save_model)
+
+    model = load_model(model_name, model_path)
+
+    activations = model[get_act()]
+    weights = model[get_weights()]
+    scaler_params = model[get_scaler()]
+    test_acc = model[get_acc()]
+    model_type = model[get_model_type()]
+    weights_type = model[get_weights_type()]
+    weights_format = model[get_weights_format()]
+
+    from .__init__ import __version__
+    device_version = __version__
+
+    save_model("updated_" + model_name, weights, model_type, scaler_params, test_acc, model_path, activations, weights_type, weights_format)
+
+    print(f"\nModel succesfully updated to {device_version}. NOTE: This operation just for compatibility. You may still have perfomance issues in this situation please install model's version of pyerualjetwork.")

pyerualjetwork/memory_operations.py

@@ -15,7 +15,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili

pyerualjetwork/{metrics.py → metrics_cpu.py}

@@ -13,7 +13,7 @@ def metrics(y_ts, test_preds, average='weighted'):
         tuple: Precision, recall, F1 score.
     """
     
-    from .data_operations import decode_one_hot
+    from .data_operations_cpu import decode_one_hot
     
     y_test_d = decode_one_hot(y_ts)
     y_test_d = np.array(y_test_d)

pyerualjetwork/metrics_cuda.py

@@ -1,7 +1,7 @@
 import cupy as cp
 
 def metrics(y_ts, test_preds, average='weighted'):
-    from .data_operations import decode_one_hot
+    from .data_operations_cpu import decode_one_hot
     y_test_d = cp.array(decode_one_hot(y_ts))
     y_pred = cp.array(test_preds)
 

pyerualjetwork/{model_operations.py → model_operations_cpu.py}

@@ -1,9 +1,9 @@
 """ 
 
 
-Model Operations
-================
-This module hosts functions for handling all operational processes related to models, including:
+Model Operations on CPU
+=======================
+This module hosts functions for handling all operational processes related to models on CPU, including:
 
 - Saving and loading models
 - Making predictions from memory
@@ -31,7 +31,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -92,7 +92,7 @@ def save_model(model_name,
         No return.
     """
     
-    from .visualizations import draw_model_architecture
+    from .visualizations_cpu import draw_model_architecture
 
     if model_type != 'PLAN' and model_type != 'MLP':
         raise ValueError("model_type parameter must be 'PLAN' or 'MLP'.")
@@ -176,11 +176,14 @@ def save_model(model_name,
 
                 scaler_params.append(' ')
 
+    from .__init__ import __version__
+
     data = {'MODEL NAME': model_name,
             'MODEL TYPE': model_type,
             'CLASS COUNT': class_count,
             'NEURON COUNT': NeuronCount,
             'SYNAPSE COUNT': SynapseCount,
+            'VERSION': __version__,
             'TEST ACCURACY': test_acc,
             'SAVE DATE': datetime.now(),
             'WEIGHTS TYPE': weights_type,
@@ -271,16 +274,18 @@ def load_model(model_name,
     model_path (str): Path where the model is saved.
 
    Returns:
-    lists: (list[df_elements]), DataFrame of the model
+    lists: Weights, None, test_accuracy, activations, scaler_params, None, model_type, weight_type, weight_format, device_version, (list[df_elements])=Pandas DataFrame of the model
     """
 
+    from .__init__ import __version__
+
     try:
 
          df = pd.read_pickle(model_path + model_name + '.pkl')
 
     except:
 
-        print(Fore.RED + "ERROR: Model Path error. acceptable form: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: load_model" + Style.RESET_ALL)
+        print(Fore.RED + "ERROR: Model Path or Model Name error. acceptable form: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: load_model" + Style.RESET_ALL)
 
         sys.exit()
 
@@ -305,6 +310,22 @@ def load_model(model_name,
     model_name = str(df['MODEL NAME'].iloc[0])
     model_type = str(df['MODEL TYPE'].iloc[0])
     WeightType = str(df['WEIGHTS TYPE'].iloc[0])
+    WeightFormat = str(df['WEIGHTS FORMAT'].iloc[0])
+    test_acc = str(df['TEST ACCURACY'].iloc[0])
+
+    device_version = __version__
+
+    try:
+        model_version = str(df['VERSION'].iloc[0])
+        if model_version != device_version:
+            message = (
+            Fore.MAGENTA + f"WARNING: Your PyerualJetwork version({device_version}) is different from this model's version({model_version}).\nIf you have a performance issue, please install this model version. Use this: pip install pyerualjetwork=={model_version} or look issue_solver module." +
+            Style.RESET_ALL
+        )
+            print(message)
+        
+    except:
+        pass # Version check only in >= 5.0.2
 
     if model_type == 'MLP': allow_pickle = True
     else: allow_pickle = False
@@ -326,7 +347,7 @@ def load_model(model_name,
     if WeightType == 'mat':
         W = W['w']
 
-    return W, None, None, activations, scaler_params, None, model_type
+    return W, None, test_acc, activations, scaler_params, None, model_type, WeightType, WeightFormat, device_version, df
 
 
 
@@ -347,8 +368,8 @@ def predict_from_storage(Input, model_name, model_path=''):
         ndarray: Output from the model.
     """
     
-    from .activation_functions import apply_activation
-    from .data_operations import standard_scaler
+    from .activation_functions_cpu import apply_activation
+    from .data_operations_cpu import standard_scaler
     
     try:
 
@@ -436,8 +457,8 @@ def predict_from_memory(Input, W, scaler_params=None, activations=['linear'], is
     ndarray: Output from the model.
     """
 
-    from .data_operations import standard_scaler
-    from .activation_functions import apply_activation
+    from .data_operations_cpu import standard_scaler
+    from .activation_functions_cpu import apply_activation
 
     try:
     
@@ -516,9 +537,32 @@ def get_scaler():
 
     return 4
 
+
 def get_preds_softmax():
 
     return 5
 
+
 def get_model_type():
-     return 6
+
+    return 6
+
+
+def get_weights_type():
+     
+    return 7
+
+
+def get_weights_format():
+     
+    return 8
+
+
+def get_model_version():
+     
+    return 9
+
+
+def get_model_df():
+     
+    return 10

pyerualjetwork/model_operations_cuda.py

@@ -31,7 +31,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -60,7 +60,7 @@ def save_model(model_name,
                activations=['linear'],
                weights_type='npy',
                weights_format='raw',
-               show_architecture=None,
+               show_architecture=False,
                show_info=True
                ):
 
@@ -192,12 +192,15 @@ def save_model(model_name,
         scaler_params[0] = scaler_params[0].get()
         scaler_params[1] = scaler_params[1].get()
 
+    from .__init__ import __version__
+
     data = {'MODEL NAME': model_name,
             'MODEL TYPE': model_type,
             'CLASS COUNT': class_count,
             'NEURON COUNT': NeuronCount,
             'SYNAPSE COUNT': SynapseCount,
             'TEST ACCURACY': test_acc,
+            'VERSION': __version__,
             'SAVE DATE': datetime.now(),
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
@@ -281,8 +284,10 @@ def load_model(model_name,
     model_path (str): Path where the model is saved.
 
    Returns:
-    lists: (list[df_elements]), DataFrame of the model
+    lists: Weights, None, test_accuracy, activations, scaler_params, None, model_type, weight_type, weight_format, device_version, (list[df_elements])=Pandas DataFrame of the model
     """
+
+    from .__init__ import __version__
     
     try:
 
@@ -318,6 +323,22 @@ def load_model(model_name,
     model_name = str(df['MODEL NAME'].iloc[0])
     model_type = str(df['MODEL TYPE'].iloc[0])
     WeightType = str(df['WEIGHTS TYPE'].iloc[0])
+    WeightFormat = str(df['WEIGHTS FORMAT'].iloc[0])
+    test_acc = str(df['TEST ACCURACY'].iloc[0])
+
+    device_version = __version__
+
+    try:
+        model_version = str(df['VERSION'].iloc[0])
+        if model_version != device_version:
+            message = (
+            Fore.MAGENTA + f"WARNING: Your PyerualJetwork version({device_version}) is different from this model's version({model_version}).\nIf you have a performance issue, please install this model version. Use this: pip install pyerualjetwork=={model_version}" +
+            Style.RESET_ALL
+        )
+            print(message)
+        
+    except:
+        pass # Version check only in >= 5.0.2
 
     if model_type == 'MLP': allow_pickle = True
     else: allow_pickle = False
@@ -343,7 +364,7 @@ def load_model(model_name,
         W = W.tolist()
         W = [cp.array(item) for item in W]
 
-    return W, None, None, activations, scaler_params, None, model_type
+    return W, None, test_acc, activations, scaler_params, None, model_type, WeightType, WeightFormat, device_version, df
 
 
 
@@ -545,9 +566,32 @@ def get_scaler():
 
     return 4
 
+
 def get_preds_softmax():
 
     return 5
 
+
 def get_model_type():
-    return 6
+
+    return 6
+
+
+def get_weights_type():
+     
+    return 7
+
+
+def get_weights_format():
+     
+    return 8
+
+
+def get_model_version():
+     
+    return 9
+
+
+def get_model_df():
+     
+    return 10

pyerualjetwork/{neu.py → neu_cpu.py}

@@ -2,9 +2,9 @@
 """ 
 
 
-NEU (Neural Networks)
-=====================
-This module hosts functions for training and evaluating artificial neural networks for labeled classification tasks (for now).
+NEU (Neural Networks) on CPU
+============================
+This module hosts functions for training and evaluating artificial neural networks on CPU for labeled classification tasks (for now).
 
 Currently, two types of models can be trained:
 
@@ -21,7 +21,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -35,13 +35,13 @@ import copy
 
 ### LIBRARY IMPORTS ###
 from .ui import loading_bars, initialize_loading_bar
-from .data_operations import normalization, batcher
-from .activation_functions import apply_activation, all_activations
-from .model_operations import get_acc, get_preds_softmax
+from .data_operations_cpu import normalization, batcher
+from .activation_functions_cpu import apply_activation, all_activations
+from .model_operations_cpu import get_acc, get_preds_softmax
 from .memory_operations import optimize_labels
-from .loss_functions import categorical_crossentropy, binary_crossentropy
+from .loss_functions_cpu import categorical_crossentropy, binary_crossentropy
 from .fitness_functions import wals
-from .visualizations import (
+from .visualizations_cpu import (
     draw_neural_web,
     display_visualizations_for_learner,
     update_history_plots_for_learner,
@@ -71,7 +71,7 @@ def plan_fit(
 
         y_train (aray-like[num]): List or numarray of target labels. (one hot encoded)
 
-        activations (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: neu.activations_list() default: [None] (optional)
 
         W (numpy.ndarray): If you want to re-continue or update model
 
@@ -109,20 +109,20 @@ def learn(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, p
 
     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. one-hot encoded.
     :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: ene.evolver(*args,
+             optimizer = lambda *args, **kwargs: ene_cpu.evolver(*args,
                                                             activation_add_prob=0.05,
                                                             strategy='aggressive',
                                                             policy='more_selective',
                                                             **kwargs)
 
-             model = neu.learn(x_train,
+             model = neu_cpu.learn(x_train,
                             y_train,
                             optimizer,
                             fit_start=True,
@@ -158,7 +158,7 @@ def learn(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, p
         tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]].
     """
 
-    from .ene import define_genomes
+    from .ene_cpu import define_genomes
 
     data = 'Train'
 

pyerualjetwork/neu_cuda.py

@@ -21,7 +21,7 @@ Module functions:
 
 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
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
 - Author: Hasan Can Beydili
 - YouTube: https://www.youtube.com/@HasanCanBeydili
@@ -70,7 +70,7 @@ def plan_fit(
     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) activations: For deeper PLAN networks, activation function parameters. For more information please run this code: nn.activations_list() default: [None] (optional)
+        :param (list) activations: For deeper PLAN networks, activation function parameters. For more information please run this code: neu_cuda.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.
@@ -179,7 +179,7 @@ def learn(x_train, y_train, optimizer, fit_start=True, gen=None, batch_size=1, p
         x_train = transfer_to_cpu(x_train, dtype=x_train.dtype)
         y_train = transfer_to_cpu(y_train, dtype=y_train.dtype)
 
-        from .data_operations import batcher
+        from .data_operations_cpu import batcher
 
     else:
         raise ValueError("memory parameter must be 'cpu' or 'gpu'.")

pyerualjetwork/{visualizations.py → visualizations_cpu.py}

@@ -86,7 +86,7 @@ def draw_model_architecture(model_name, model_path=''):
     Visualizes the architecture of a neural network model with multiple inputs based on activation functions.
     """
     
-    from .model_operations import load_model, get_scaler, get_act, get_weights
+    from .model_operations_cpu import load_model, get_scaler, get_act, get_weights
     
     model = load_model(model_name=model_name, model_path=model_path)
     
@@ -182,7 +182,7 @@ def draw_model_architecture(model_name, model_path=''):
     
 def draw_activations(x_train, activation):
 
-    from . import activation_functions as af
+    from . import activation_functions_cpu as af
 
     if activation == 'sigmoid':
         result = af.Sigmoid(x_train)
@@ -327,10 +327,10 @@ def draw_activations(x_train, activation):
 
 def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
     
-    from .metrics import metrics, confusion_matrix, roc_curve
+    from .metrics_cpu import metrics, confusion_matrix, roc_curve
     from .ui import loading_bars, initialize_loading_bar
-    from .data_operations import decode_one_hot
-    from .model_operations import predict_model_ram
+    from .data_operations_cpu import decode_one_hot
+    from .model_operations_cpu import predict_model_ram
     
     bar_format_normal = loading_bars()[0]
     
@@ -455,8 +455,8 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
 
 def plot_decision_boundary(x, y, activations, W, artist=None, ax=None):
     
-    from .model_operations import predict_model_ram
-    from .data_operations import decode_one_hot
+    from .model_operations_cpu import predict_model_ram
+    from .data_operations_cpu import decode_one_hot
     
     feature_indices = [0, 1]
 
@@ -513,8 +513,8 @@ def plot_decision_boundary(x, y, activations, W, artist=None, ax=None):
         
 def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     
-    from .metrics import pca
-    from .data_operations import decode_one_hot
+    from .metrics_cpu import pca
+    from .data_operations_cpu import decode_one_hot
     
     if x.shape[1] > 2:
 
@@ -707,7 +707,7 @@ def show():
 
 def initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train):
 
-    from .data_operations import find_closest_factors
+    from .data_operations_cpu import find_closest_factors
     viz_objects = {}
     
     if show_history:

{pyerualjetwork-5b3.dist-info → pyerualjetwork-5.0.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5b3
-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.0.2
+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,16 +26,22 @@ 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 data_operations
-	from pyerualjetwork import model_operations
+	from pyerualjetwork import neu_cpu
+	from pyerualjetwork import ene_cpu
+	from pyerualjetwork import data_operations_cpu
+	from pyerualjetwork import model_operations_cpu
 	
-	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
 	
+	PyerualJetwork has Issue Solver. This operation provides users ready-to-use functions to identify potential issues
+ 	caused by version incompatibilities in major updates, ensuring users are not affected by such problems. 
+  	PyereualJetwork aims to offer a seamless experience for its users.
+
+	from pyerualjetwork import issue_solver
+
       Optimized for Visual Studio Code
       
       requires=[
@@ -43,7 +49,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 +63,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 +77,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 +93,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 +122,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_cpu”. 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.0.2.dist-info/RECORD

@@ -0,0 +1,26 @@
+pyerualjetwork/__init__.py,sha256=z_I7fQb2UO1O5xO71zzt-zdLmw8ArbtlY_LrB6Yovyg,2726
+pyerualjetwork/activation_functions_cpu.py,sha256=X7Kv8qv8oZq8hvTdUiV-GkFjKHRlKIQypRPXh6gdkm4,7614
+pyerualjetwork/activation_functions_cuda.py,sha256=pefklsl9QuSVbKwiUUHeF_ExN0bICH7QIF1MfoMU40Q,7665
+pyerualjetwork/data_operations_cpu.py,sha256=dLczgxNx8W_GIgBLageegVhv-aczjNYfohB-PPpOU4Y,16401
+pyerualjetwork/data_operations_cuda.py,sha256=5zgyJGPjQuHyx6IHNkRwMguYhm-GcI6Hal49WNvw-bM,18536
+pyerualjetwork/ene_cpu.py,sha256=2y5__d-vx7t5Ajs4IPuNnQe8ULR39Km_KQFNIUnalGA,45167
+pyerualjetwork/ene_cuda.py,sha256=0tOIONUEDmvGZiCihzIHBrGVtRMPR1g23ZNfoI0i39s,45663
+pyerualjetwork/fitness_functions.py,sha256=pUmAbUy5ex1Vpu6n_RRac_df-FR52gYIV8uxYS5H3tw,1252
+pyerualjetwork/help.py,sha256=FcX8mxo1_mvoqONVXY0Kn7S09CDkhi0jwNmn8g9mYZc,804
+pyerualjetwork/issue_solver.py,sha256=iNDYVNSc__N1ckyt84dw51Cdf_bd5vsmvdNtVBM4oCQ,3118
+pyerualjetwork/loss_functions_cpu.py,sha256=6PyBI232SQRGuFnG3LDGvnv_PUdWzT2_2mUODJiejGI,618
+pyerualjetwork/loss_functions_cuda.py,sha256=C93IZJcrOpT6HMK9x1O4AHJWXYTkN5WZiqdssPbvAPk,617
+pyerualjetwork/memory_operations.py,sha256=g24d-cDuUFc0fOEtk3AJe-z_EBctYV5S4cY1rQ6VGiE,14279
+pyerualjetwork/metrics_cpu.py,sha256=vbfMwS0ay2heMSa0GNo-ydLjQ8cfexbLwaREp4FKAtY,6081
+pyerualjetwork/metrics_cuda.py,sha256=PWyJyexeqlPKb09LAcF55JvhZVeXLCu3P_siYq5m2gg,5065
+pyerualjetwork/model_operations_cpu.py,sha256=Z-TU1vNkUOB6nfFYCj9mSZsq-VaSYqL1KxbG2Rxqnt0,17255
+pyerualjetwork/model_operations_cuda.py,sha256=lTkedasKliBjiyq0Di3alH4BLUlocnHhCI3sq1XDwgE,18408
+pyerualjetwork/neu_cpu.py,sha256=5K9oDNiTH6rVyOYo-2esw8ZLJ6M7-YLfiOyq_a9LBQU,25017
+pyerualjetwork/neu_cuda.py,sha256=VS9YVsYe0DLaqGDCrKyVnYXehu8eE7qZycdaUHCyyM0,26030
+pyerualjetwork/ui.py,sha256=JBTFYz5R24XwNKhA3GSW-oYAoiIBxAE3kFGXkvm5gqw,656
+pyerualjetwork/visualizations_cpu.py,sha256=StyD1Hl1Gt55EMqR6tO3yVJZdPyGkOgCnQ75Zn8K6J8,28252
+pyerualjetwork/visualizations_cuda.py,sha256=7lYrkOdrjwQGB3T4k_vI8UDxsm_TRjzaSSg9GhlNczs,28667
+pyerualjetwork-5.0.2.dist-info/METADATA,sha256=tnE3ncDV2pNq1sFcbv8Z0d6QXL-y5gxLtgwD7N-F2pc,8126
+pyerualjetwork-5.0.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-5.0.2.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-5.0.2.dist-info/RECORD,,

pyerualjetwork-5b3.dist-info/RECORD

@@ -1,25 +0,0 @@
-pyerualjetwork/__init__.py,sha256=oRByBl-TW3JDnYYencDENYU_PkCV_f8piVIkK641M4g,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=bNl8nnL5R3WS8vNWxFbVzeX9eeGgownHdebbsKKNfvU,24948
-pyerualjetwork/neu_cuda.py,sha256=0hUCQ02tLFg1cGuqOxT3jfBx3W28hIL6nhEu4m2LeY8,25999
-pyerualjetwork/ui.py,sha256=JBTFYz5R24XwNKhA3GSW-oYAoiIBxAE3kFGXkvm5gqw,656
-pyerualjetwork/visualizations.py,sha256=4DpboCi1GnJjKRVQ0RdGyQyHagZQTLUbCgSI7UHzd6o,28212
-pyerualjetwork/visualizations_cuda.py,sha256=7lYrkOdrjwQGB3T4k_vI8UDxsm_TRjzaSSg9GhlNczs,28667
-pyerualjetwork-5b3.dist-info/METADATA,sha256=jxcttUe0NJiI48xfRmAl4Ck0ZrodlOenv4UvkoPAVDI,7503
-pyerualjetwork-5b3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-5b3.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-5b3.dist-info/RECORD,,