pyerualjetwork 5.1__py3-none-any.whl → 5.5__py3-none-any.whl

pyerualjetwork/{visualizations_cuda.py → cuda/visualizations.py}

@@ -2,7 +2,6 @@ import networkx as nx
 import matplotlib.pyplot as plt
 import cupy as cp
 from scipy.spatial import ConvexHull
-import seaborn as sns
 from matplotlib.animation import ArtistAnimation
 
 def draw_neural_web(W, ax, G, return_objs=False):
@@ -87,13 +86,13 @@ 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_cuda import load_model, get_scaler, get_act, get_weights
+    from ..model_ops import load_model
     
     model = load_model(model_name=model_name, model_path=model_path)
     
-    W = model[get_weights()]
-    activations = model[get_act()]
-    scaler_params = model[get_scaler()]
+    W = model.weights
+    activations = model.activations
+    scaler_params = model.scaler_params
     
     # Calculate dimensions based on number of activation functions
     num_activations = len(activations)
@@ -183,14 +182,11 @@ def draw_model_architecture(model_name, model_path=''):
     
 def draw_activations(x_train, activation):
 
-    from . import activation_functions_cuda as af
+    from . import activation_functions as af
 
     if activation == 'sigmoid':
         result = af.Sigmoid(x_train)
 
-    elif activation == 'swish':
-        result = af.swish(x_train)
-
     elif activation == 'circular':
         result = af.circular_activation(x_train)
 
@@ -206,18 +202,6 @@ def draw_activations(x_train, activation):
     elif activation == 'relu':
         result = af.Relu(x_train)
 
-    elif activation == 'softplus':
-        result = af.softplus(x_train)
-
-    elif activation == 'elu':
-        result = af.elu(x_train)
-
-    elif activation == 'gelu':
-        result = af.gelu(x_train)
-
-    elif activation == 'selu':
-        result = af.selu(x_train)
-
     elif activation == 'softmax':
         result = af.Softmax(x_train)
 
@@ -236,24 +220,12 @@ def draw_activations(x_train, activation):
     elif activation == 'dlrelu':
         result = af.dlrelu(x_train)
 
-    elif activation == 'exsig':
-        result = af.exsig(x_train)
-
     elif activation == 'sin_plus':
         result = af.sin_plus(x_train)
 
     elif activation == 'acos':
         result = af.acos(x_train, alpha=1.0, beta=0.0)
 
-    elif activation == 'gla':
-        result = af.gla(x_train, alpha=1.0, mu=0.0)
-
-    elif activation == 'srelu':
-        result = af.srelu(x_train)
-
-    elif activation == 'qelu':
-        result = af.qelu(x_train)
-
     elif activation == 'isra':
         result = af.isra(x_train)
 
@@ -266,54 +238,27 @@ def draw_activations(x_train, activation):
     elif activation == 'bent_identity':
         result = af.bent_identity(x_train)
 
-    elif activation == 'sech':
-        result = af.sech(x_train)
-
     elif activation == 'softsign':
         result = af.softsign(x_train)
 
     elif activation == 'pwl':
         result = af.pwl(x_train)
 
-    elif activation == 'cubic':
-        result = af.cubic(x_train)
-
-    elif activation == 'gaussian':
-        result = af.gaussian(x_train)
-
     elif activation == 'sine':
         result = af.sine(x_train)
 
     elif activation == 'tanh_square':
         result = af.tanh_square(x_train)
 
-    elif activation == 'mod_sigmoid':
-        result = af.mod_sigmoid(x_train)
-
     elif activation == 'linear':
         result = x_train
 
-    elif activation == 'quartic':
-        result = af.quartic(x_train)
-
-    elif activation == 'square_quartic':
-        result = af.square_quartic(x_train)
-
-    elif activation == 'cubic_quadratic':
-        result = af.cubic_quadratic(x_train)
-
-    elif activation == 'exp_cubic':
-        result = af.exp_cubic(x_train)
-
     elif activation == 'sine_square':
         result = af.sine_square(x_train)
 
     elif activation == 'logarithmic':
         result = af.logarithmic(x_train)
 
-    elif activation == 'scaled_cubic':
-        result = af.scaled_cubic(x_train, 1.0)
-
     elif activation == 'sine_offset':
         result = af.sine_offset(x_train, 1.0)
 
@@ -325,192 +270,11 @@ def draw_activations(x_train, activation):
         print('\rWARNING: error in drawing some activation.', end='')
         return x_train
 
-
-def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activations):
-    
-    from .metrics_cuda import metrics, confusion_matrix, roc_curve
-    from .ui import loading_bars, initialize_loading_bar
-    from .data_operations_cuda import decode_one_hot
-    from .model_operations_cuda import predict_model_ram
-    
-    bar_format_normal = loading_bars()[0]
-    
-    acc = acc_list[len(acc_list) - 1]
-    y_true = decode_one_hot(y_test)
-
-    y_true = cp.array(y_true, copy=True)
-    y_preds = cp.array(y_preds, copy=True)
-    Class = cp.unique(decode_one_hot(y_test))
-
-    precision, recall, f1 = metrics(y_test, y_preds)
-    
-    
-    cm = confusion_matrix(y_true, y_preds, len(Class))
-    fig, axs = plt.subplots(2, 2, figsize=(16, 12))
-
-    sns.heatmap(cm.get(), annot=True, fmt='d', ax=axs[0, 0])
-    axs[0, 0].set_title("Confusion Matrix")
-    axs[0, 0].set_xlabel("Predicted Class")
-    axs[0, 0].set_ylabel("Actual Class")
-    
-    if len(Class) == 2:
-        fpr, tpr, thresholds = roc_curve(y_true, y_preds)
-   
-        roc_auc = cp.trapz(tpr, fpr)
-        axs[1, 0].plot(fpr.get(), tpr.get(), color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
-        axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
-        axs[1, 0].set_xlim([0.0, 1.0])
-        axs[1, 0].set_ylim([0.0, 1.05])
-        axs[1, 0].set_xlabel('False Positive Rate')
-        axs[1, 0].set_ylabel('True Positive Rate')
-        axs[1, 0].set_title('Receiver Operating Characteristic (ROC) Curve')
-        axs[1, 0].legend(loc="lower right")
-        axs[1, 0].legend(loc="lower right")
-    else:
-
-        for i in range(len(Class)):
-            
-            y_true_copy = cp.copy(y_true)
-            y_preds_copy = cp.copy(y_preds)
-        
-            y_true_copy[y_true_copy == i] = 0
-            y_true_copy[y_true_copy != 0] = 1
-            
-            y_preds_copy[y_preds_copy == i] = 0
-            y_preds_copy[y_preds_copy != 0] = 1
-            
-
-            fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
-            
-            roc_auc = cp.trapz(tpr, fpr)
-            axs[1, 0].plot(fpr.get(), tpr.get(), color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
-            axs[1, 0].plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
-            axs[1, 0].set_xlim([0.0, 1.0])
-            axs[1, 0].set_ylim([0.0, 1.05])
-            axs[1, 0].set_xlabel('False Positive Rate')
-            axs[1, 0].set_ylabel('True Positive Rate')
-            axs[1, 0].set_title('Receiver Operating Characteristic (ROC) Curve')
-            axs[1, 0].legend(loc="lower right")
-            axs[1, 0].legend(loc="lower right")
-    
-
-    metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
-    values = [precision, recall, f1, acc.get()]
-    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
-    
-    
-    bars = axs[0, 1].bar(metric, values, color=colors)
-    
-    
-    for bar, value in zip(bars, values):
-        axs[0, 1].text(bar.get_x() + bar.get_width() / 2, bar.get_height() - 0.05, f'{value:.2f}',
-                       ha='center', va='bottom', fontsize=12, color='white', weight='bold')
-    
-    axs[0, 1].set_ylim(0, 1) 
-    axs[0, 1].set_xlabel('Metrics')
-    axs[0, 1].set_ylabel('Score')
-    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
-    axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
-    
-    feature_indices=[0, 1]
-
-    h = .02
-    x_min, x_max = x_test[:, feature_indices[0]].min() - 1, x_test[:, feature_indices[0]].max() + 1
-    y_min, y_max = x_test[:, feature_indices[1]].min() - 1, x_test[:, feature_indices[1]].max() + 1
-    xx, yy = cp.meshgrid(cp.arange(x_min, x_max, h),
-                         cp.arange(y_min, y_max, h))
-    
-    grid = cp.c_[xx.ravel(), yy.ravel()]
-
-    grid_full = cp.zeros((grid.shape[0], x_test.shape[1]), dtype=cp.float32)
-    grid_full[:, feature_indices] = grid
-    
-    Z = [None] * len(grid_full)
-
-    predict_progress = initialize_loading_bar(total=len(grid_full),leave=False,
-        bar_format=bar_format_normal ,desc="Predicts For Decision Boundary",ncols= 65)
-
-    for i in range(len(grid_full)):
-
-        Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
-        predict_progress.update(1)
-
-    predict_progress.close()
-
-    Z = cp.array(Z)
-    Z = Z.reshape(xx.shape)
-
-    axs[1,1].contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-    axs[1,1].scatter(x_test[:, feature_indices[0]].get(), x_test[:, feature_indices[1]].get(), c=decode_one_hot(y_test).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-    axs[1,1].set_xlabel(f'Feature {0 + 1}')
-    axs[1,1].set_ylabel(f'Feature {1 + 1}')
-    axs[1,1].set_title('Decision Boundary')
-
-    plt.show()
-
-    
-def plot_decision_boundary(x, y, activations, W, artist=None, ax=None):
-    
-    from .model_operations_cuda import predict_model_ram
-    from .data_operations_cuda import decode_one_hot
-    
-    feature_indices = [0, 1]
-
-    h = .02
-    x_min, x_max = x[:, feature_indices[0]].min() - 1, x[:, feature_indices[0]].max() + 1
-    y_min, y_max = x[:, feature_indices[1]].min() - 1, x[:, feature_indices[1]].max() + 1
-    xx, yy = cp.meshgrid(cp.arange(x_min, x_max, h),
-                         cp.arange(y_min, y_max, h))
-    
-    grid = cp.c_[xx.ravel(), yy.ravel()]
-    grid_full = cp.zeros((grid.shape[0], x.shape[1]))
-    grid_full[:, feature_indices] = grid
-    
-    Z = [None] * len(grid_full)
-
-    for i in range(len(grid_full)):
-        Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activations=activations))
-
-    Z = cp.array(Z, dtype=cp.int32)
-    Z = Z.reshape(xx.shape)
-
-    if ax is None:
-
-        plt.contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-        plt.scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-        plt.xlabel(f'Feature {0 + 1}')
-        plt.ylabel(f'Feature {1 + 1}')
-        plt.title('Decision Boundary')
-
-        plt.show()
-
-    else:
-
-        try:
-            art1_1 = ax[1, 0].contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax[1, 0].set_xlabel(f'Feature {0 + 1}')
-            ax[1, 0].set_ylabel(f'Feature {1 + 1}')
-            ax[1, 0].set_title('Decision Boundary')
-
-            return art1_1, art1_2
-        
-        except:
-
-            art1_1 = ax.contourf(xx.get(), yy.get(), Z.get(), alpha=0.8)
-            art1_2 = ax.scatter(x[:, feature_indices[0]].get(), x[:, feature_indices[1]].get(), c=decode_one_hot(y).get(), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax.set_xlabel(f'Feature {0 + 1}')
-            ax.set_ylabel(f'Feature {1 + 1}')
-            ax.set_title('Decision Boundary')
-
-
-            return art1_1, art1_2
-  
         
 def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
     
-    from .metrics_cuda import pca
-    from .data_operations_cuda import decode_one_hot
+    from .metrics import pca
+    from .data_ops import decode_one_hot
     
     if x.shape[1] > 2:
 
@@ -699,7 +463,7 @@ def update_neuron_history_for_learner(LTPW, ax1, row, col, class_count, artist5,
 
 def initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train):
 
-    from .data_operations_cuda import find_closest_factors
+    from .data_ops import find_closest_factors
     viz_objects = {}
     
     if show_history:

pyerualjetwork/{ene_cpu.py → ene.py}

@@ -1,17 +1,16 @@
 """ 
 
 
-ENE (Eugenic NeuroEvolution) on CPU
+ENE (Eugenic NeuroEvolution)
 ===================================
 
-This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution) algorithm on CPU.
+This module contains all the functions necessary for implementing and testing the ENE (Eugenic NeuroEvolution).
 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()
@@ -21,7 +20,7 @@ Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJe
 
 PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
 
-- Author: Hasan Can Beydili
+- Creator: 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
@@ -34,9 +33,9 @@ import math
 import copy
 
 ### LIBRARY IMPORTS ###
-from .data_operations_cpu import normalization, non_neg_normalization
+from .cpu.data_ops import non_neg_normalization
 from .ui import loading_bars, initialize_loading_bar
-from .activation_functions_cpu import apply_activation, all_activations
+from .cpu.activation_functions import all_activations
 
 def define_genomes(input_shape, output_shape, population_size, neurons=[], activation_functions=[], dtype=np.float32):
    """
@@ -97,13 +96,6 @@ def define_genomes(input_shape, output_shape, population_size, neurons=[], activ
             if l != hidden:
                population_activations[i][l] = activation_functions[l]
 
-            # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
-
-            for j in range(population_weights[i][l].shape[0]):
-
-               population_weights[i][l][j,:] = apply_activation(population_weights[i][l][j,:], population_activations[i])
-               population_weights[i][l][j,:] = normalization(population_weights[i][l][j,:], dtype=dtype)
-
       return population_weights, population_activations
 
    else:
@@ -118,13 +110,6 @@ def define_genomes(input_shape, output_shape, population_size, neurons=[], activ
          population_weights[i] = np.random.uniform(-1, 1, (output_shape, input_shape)).astype(dtype)
          population_activations[i] = activations[int(random.uniform(0, len(activations)-1))]
 
-         # ACTIVATIONS APPLYING IN WEIGHTS SPECIFIC OUTPUT CONNECTIONS (MORE PLAN LIKE FEATURES(FOR NON-LINEARITY)):
-
-         for j in range(population_weights[i].shape[0]):
-
-            population_weights[i][j,:] = apply_activation(population_weights[i][j,:], population_activations[i])
-            population_weights[i][j,:] = normalization(population_weights[i][j,:], dtype=dtype)
-
       return np.array(population_weights, dtype=dtype), population_activations
 
 
@@ -137,7 +122,7 @@ def evolver(weights,
             policy='aggressive', 
             bad_genomes_selection_prob=None, 
             bar_status=True, 
-            strategy='normal_selective',
+            strategy='more_selective',
             bad_genomes_mutation_prob=None,
             fitness_bias=1,
             cross_over_mode='tpm',
@@ -152,7 +137,7 @@ def evolver(weights,
             weight_mutate_threshold=16,
             weight_mutate_prob=1,
             is_mlp=False,
-            save_best_genome=False,
+            save_best_genome=True,
             dtype=np.float32):
    """
    Applies the evolving process of a population of genomes using selection, crossover, mutation, and activation function potentiation.
@@ -171,7 +156,7 @@ def evolver(weights,
       what_gen (int): The current generation number, used for informational purposes or logging.
       
       fitness (numpy.ndarray): A 1D array containing the fitness values of each genome. 
-         The array is used to rank the genomes based on their performance. PLANEAT maximizes or minimizes this fitness based on the `target_fitness` parameter.
+         The array is used to rank the genomes based on their performance. ENE maximizes or minimizes this fitness based on the `target_fitness` parameter.
       
       weight_evolve (bool, optional): Are weights to be evolves or just activation combinations Default: True. Note: Regardless of whether this parameter is True or False, you must give the evolver function a list of weights equal to the number of activation potentiations. You can create completely random weights if you want. If this parameter is False, the weights entering the evolver function and the resulting weights will be exactly the same.
       
@@ -182,7 +167,7 @@ def evolver(weights,
          - 'normal_selective': Normal selection based on fitness, where a portion of the bad genes are discarded.
          - 'more_selective': A more selective strategy, where fewer bad genes survive.
          - 'less_selective': A less selective strategy, where more bad genes survive.
-         Default is 'normal_selective'.
+         Default is 'more_selective'.
       
       bar_status (bool, optional): Loading bar status during evolving process of genomes. True or False. Default: True
 
@@ -241,7 +226,7 @@ def evolver(weights,
 
       is_mlp (bool, optional): Evolve PLAN model or MLP model ? Default: False (PLAN)
       
-      save_best_genome (bool, optional): Save the best genome of the previous generation to the next generation. Default: False
+      save_best_genome (bool, optional): Save the best genome of the previous generation to the next generation. (index of best individual: 0) Default: True
 
       dtype (numpy.dtype, optional): Data type for the arrays. Default: np.float32. 
          Example: np.float64 or np.float16 [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not recommended!].
@@ -328,7 +313,7 @@ def evolver(weights,
    else:
       raise ValueError("genome population size must be even number. for example: not 99, make 100 or 98.")
 
-   if weight_evolve is False: origin_weights = np.copy(weights)
+   if weight_evolve is False: origin_weights = copy.deepcopy(weights)
 
    if is_mlp:
       activation_mutate_add_prob = 0
@@ -350,14 +335,14 @@ def evolver(weights,
 
    good_weights = weights[slice_center:]
    bad_weights = weights[:slice_center]
-   best_weight = np.copy(good_weights[-1]) if is_mlp is False else copy.deepcopy(good_weights[-1])
+   best_weight = copy.deepcopy(good_weights[-1])
 
    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]
+   best_activations = copy.deepcopy(good_activations[-1]) if isinstance(good_activations[-1], list) else good_activations[-1]
 
    
-### PLANEAT IS APPLIED ACCORDING TO THE SPECIFIED POLICY, STRATEGY, AND PROBABILITY CONFIGURATION:
+### ENE IS APPLIED ACCORDING TO THE SPECIFIED POLICY, STRATEGY, AND PROBABILITY CONFIGURATION:
    
    bar_format = loading_bars()[0]
    
@@ -367,23 +352,23 @@ def evolver(weights,
    best_fitness = normalized_fitness[-1]
    epsilon = np.finfo(float).eps
    
-   child_W = np.copy(bad_weights)
-   child_act = bad_activations.copy()
+   child_W = copy.deepcopy(bad_weights)
+   child_act = copy.deepcopy(bad_activations)
 
-   mutated_W = np.copy(bad_weights)
-   mutated_act = bad_activations.copy()
+   mutated_W = copy.deepcopy(bad_weights)
+   mutated_act = copy.deepcopy(bad_activations)
 
 
    for i in range(len(bad_weights)):
       
       if policy == 'aggressive':
-         first_parent_W = np.copy(best_weight)
-         first_parent_act = best_activations
+         first_parent_W = copy.deepcopy(best_weight)
+         first_parent_act = copy.deepcopy(best_activations)
          first_parent_fitness = best_fitness
 
       elif policy == 'explorer':
-         first_parent_W = good_weights[i]
-         first_parent_act = good_activations[i]
+         first_parent_W = copy.deepcopy(good_weights[i])
+         first_parent_act = copy.deepcopy(good_activations[i])
          first_parent_fitness = normalized_fitness[len(good_weights) + i]
 
       else: raise ValueError("policy parameter must be: 'aggressive' or 'explorer'")
@@ -489,8 +474,8 @@ def evolver(weights,
    activations = child_act + mutated_act
 
    if save_best_genome:
-      weights[0] = best_weight
-      activations[0] = best_activations
+      weights[0] = copy.deepcopy(best_weight)
+      activations[0] = copy.deepcopy(best_activations)
    
    ### INFO PRINTING CONSOLE
    
@@ -532,57 +517,6 @@ def evolver(weights,
    return weights, activations
 
 
-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.
-
-    Args:
-        Input (list or numpy.ndarray): A list or 2D numpy array where each element represents
-                                               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.
-        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)
-
-    Returns:
-        list: A list of outputs corresponding to each genome in the population after applying the respective 
-              activation function and weights.
-
-    Example:
-        ```python
-        outputs = evaluate(Input, weights, activations)
-        ```
-
-    - The function returns a list of outputs after processing the population, where each element corresponds to
-      the output for each genome in population.
-   """
-   ### THE OUTPUTS ARE RETURNED, WHERE EACH GENOME'S OUTPUT MATCHES ITS INDEX:
-   
-   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, activations[i])
-
-         layer = layer @ weights[i].T
-      
-      return layer
-
-   else:
-
-      Input = apply_activation(Input, activations)
-      result = Input @ weights.T
-
-      return result
-
 def cross_over(first_parent_W,
                second_parent_W,
                first_parent_act,
@@ -678,18 +612,18 @@ def cross_over(first_parent_W,
    decision = dominant_parent_selection(bad_genomes_selection_prob)
 
    if decision == 'first_parent':
-      dominant_parent_W = np.copy(first_parent_W)
+      dominant_parent_W = copy.deepcopy(first_parent_W)
       dominant_parent_act = first_parent_act
 
-      undominant_parent_W = np.copy(second_parent_W)
+      undominant_parent_W = copy.deepcopy(second_parent_W)
       undominant_parent_act = second_parent_act
       succes = second_parent_fitness + epsilon
 
    elif decision == 'second_parent':
-      dominant_parent_W = np.copy(second_parent_W)
+      dominant_parent_W = copy.deepcopy(second_parent_W)
       dominant_parent_act = second_parent_act
 
-      undominant_parent_W = np.copy(first_parent_W)
+      undominant_parent_W = copy.deepcopy(first_parent_W)
       undominant_parent_act = first_parent_act
       succes = first_parent_fitness + epsilon
 
@@ -727,7 +661,7 @@ def cross_over(first_parent_W,
    if isinstance(dominant_parent_act, str): dominant_parent_act = [dominant_parent_act]
    if isinstance(undominant_parent_act, str): undominant_parent_act = [undominant_parent_act]
 
-   child_act = list(np.copy(dominant_parent_act))
+   child_act = list(copy.deepcopy(dominant_parent_act))
 
    activation_selection_add_prob = 1 - activation_selection_add_prob # if prob 0.8 (%80) then 1 - 0.8. Because 0-1 random number probably greater than 0.2
    potential_activation_selection_add = random.uniform(0, 1)

pyerualjetwork/fitness_functions.py

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

pyerualjetwork/help.py

@@ -1,4 +1,4 @@
-from pyerualjetwork.activation_functions_cpu import all_activations
+from pyerualjetwork.cpu.activation_functions import all_activations
 
 
 def activation_potentiation():
@@ -11,7 +11,7 @@ def activation_potentiation():
 
 def docs_and_examples():
 
-    print('PLAN document: https://github.com/HCB06/Anaplan/tree/main/Welcome_to_PLAN\n')
-    print('PLAN examples: https://github.com/HCB06/Anaplan/tree/main/Welcome_to_PyerualJetwork/ExampleCodes\n')
-    print('PLANEAT examples: https://github.com/HCB06/Anaplan/tree/main/Welcome_to_PyerualJetwork/ExampleCodes/ENE\n')
-    print('Anaplan document and examples: https://github.com/HCB06/Anaplan/tree/main/Welcome_to_Anaplan')
+    print('PLAN & ENE document: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PLAN\n')
+    print('PLAN examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes\n')
+    print('ENE examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes/ENE\n')
+    print('PyerualJetwork document and examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork')