pyerualjetwork 4.3.8.dev14__py3-none-any.whl → 4.3.9__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.3.8dev14"
+__version__ = "4.3.9"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main\n* PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf\n* YouTube tutorials: https://www.youtube.com/@HasanCanBeydili"
 
 def print_version(__version__):

pyerualjetwork/activation_functions.py

@@ -217,8 +217,8 @@ def scaled_cubic(x, alpha=1.0):
 
 def sine_offset(x, beta=0.0):
     return np.sin(x + beta)
-    
-    
+
+
 def apply_activation(Input, activation_list):
     """
     Applies activation functions for inputs

pyerualjetwork/activation_functions_cuda.py

@@ -217,124 +217,73 @@ def scaled_cubic(x, alpha=1.0):
 def sine_offset(x, beta=0.0):
     return cp.sin(x + beta)
 
-
-def safe_add(current_sum, new_value):
-        try:
-            return current_sum + new_value
-        except OverflowError:
-            return cp.array(current_sum) + cp.array(new_value)
     
 def apply_activation(Input, activation_list):
     """
-        Applies a sequence of activation functions to the input.
-        
-        Args:
-            Input (cupy.ndarray): The input to apply activations to.
-            activation_list (list): A list of activation function names to apply.
-        
-        Returns:
-            cupy.ndarray: The input after all activations have been applied.
-    """
+    Applies activation functions for inputs
     
+    Args:
+        Input (cupy.ndarray):
+        activation_list (list):
+    """
     origin_input = cp.copy(Input)
+    
+    activation_functions = {
+        'sigmoid': Sigmoid,
+        'swish': swish,
+        'mod_circular': modular_circular_activation,
+        'tanh_circular': tanh_circular_activation,
+        'leaky_relu': leaky_relu,
+        'relu': Relu,
+        'softplus': softplus,
+        'elu': elu,
+        'gelu': gelu,
+        'selu': selu,
+        'tanh': tanh,
+        'sinakt': sinakt,
+        'p_squared': p_squared,
+        'sglu': lambda x: sglu(x, alpha=1.0),
+        'dlrelu': dlrelu,
+        'exsig': exsig,
+        'sin_plus': sin_plus,
+        'acos': lambda x: acos(x, alpha=1.0, beta=0.0),
+        'gla': lambda x: gla(x, alpha=1.0, mu=0.0),
+        'srelu': srelu,
+        'qelu': qelu,
+        'isra': isra,
+        'waveakt': waveakt,
+        'arctan': arctan,
+        'bent_identity': bent_identity,
+        'sech': sech,
+        'softsign': softsign,
+        'pwl': pwl,
+        'cubic': cubic,
+        'gaussian': gaussian,
+        'sine': sine,
+        'tanh_square': tanh_square,
+        'mod_sigmoid': mod_sigmoid,
+        'linear': lambda x: x,
+        'quartic': quartic,
+        'square_quartic': square_quartic,
+        'cubic_quadratic': cubic_quadratic,
+        'exp_cubic': exp_cubic,
+        'sine_square': sine_square,
+        'logarithmic': logarithmic,
+        'scaled_cubic': lambda x: scaled_cubic(x, 1.0),
+        'sine_offset': lambda x: sine_offset(x, 1.0),
+        'spiral': spiral_activation,
+        'circular': circular_activation
+    }
+    
+    try:
+        
+        valid_mask = cp.array([act in activation_functions for act in activation_list])
+        valid_activations = cp.array(activation_list)[valid_mask]
+
+        activation_outputs = cp.array([activation_functions[act](origin_input) for act in valid_activations])
 
-    for i in range(len(activation_list)):
-        try:
-            if activation_list[i] == 'sigmoid':
-                Input = safe_add(Input, Sigmoid(origin_input))
-            elif activation_list[i] == 'swish':
-                Input = safe_add(Input, swish(origin_input))
-            elif activation_list[i] == 'mod_circular':
-                Input = safe_add(Input, modular_circular_activation(origin_input))
-            elif activation_list[i] == 'tanh_circular':
-                Input = safe_add(Input, tanh_circular_activation(origin_input))
-            elif activation_list[i] == 'leaky_relu':
-                Input = safe_add(Input, leaky_relu(origin_input))
-            elif activation_list[i] == 'relu':
-                Input = safe_add(Input, Relu(origin_input))
-            elif activation_list[i] == 'softplus':
-                Input = safe_add(Input, softplus(origin_input))
-            elif activation_list[i] == 'elu':
-                Input = safe_add(Input, elu(origin_input))
-            elif activation_list[i] == 'gelu':
-                Input = safe_add(Input, gelu(origin_input))
-            elif activation_list[i] == 'selu':
-                Input = safe_add(Input, selu(origin_input))
-            elif activation_list[i] == 'tanh':
-                Input = safe_add(Input, tanh(origin_input))
-            elif activation_list[i] == 'sinakt':
-                Input = safe_add(Input, sinakt(origin_input))
-            elif activation_list[i] == 'p_squared':
-                Input = safe_add(Input, p_squared(origin_input))
-            elif activation_list[i] == 'sglu':
-                Input = safe_add(Input, sglu(origin_input, alpha=1.0))
-            elif activation_list[i] == 'dlrelu':
-                Input = safe_add(Input, dlrelu(origin_input))
-            elif activation_list[i] == 'exsig':
-                Input = safe_add(Input, exsig(origin_input))
-            elif activation_list[i] == 'sin_plus':
-                Input = safe_add(Input, sin_plus(origin_input))
-            elif activation_list[i] == 'acos':
-                Input = safe_add(Input, acos(origin_input, alpha=1.0, beta=0.0))
-            elif activation_list[i] == 'gla':
-                Input = safe_add(Input, gla(origin_input, alpha=1.0, mu=0.0))
-            elif activation_list[i] == 'srelu':
-                Input = safe_add(Input, srelu(origin_input))
-            elif activation_list[i] == 'qelu':
-                Input = safe_add(Input, qelu(origin_input))
-            elif activation_list[i] == 'isra':
-                Input = safe_add(Input, isra(origin_input))
-            elif activation_list[i] == 'waveakt':
-                Input = safe_add(Input, waveakt(origin_input))
-            elif activation_list[i] == 'arctan':
-                Input = safe_add(Input, arctan(origin_input))
-            elif activation_list[i] == 'bent_identity':
-                Input = safe_add(Input, bent_identity(origin_input))
-            elif activation_list[i] == 'sech':
-                Input = safe_add(Input, sech(origin_input))
-            elif activation_list[i] == 'softsign':
-                Input = safe_add(Input, softsign(origin_input))
-            elif activation_list[i] == 'pwl':
-                Input = safe_add(Input, pwl(origin_input))
-            elif activation_list[i] == 'cubic':
-                Input = safe_add(Input, cubic(origin_input))
-            elif activation_list[i] == 'gaussian':
-                Input = safe_add(Input, gaussian(origin_input))
-            elif activation_list[i] == 'sine':
-                Input = safe_add(Input, sine(origin_input))
-            elif activation_list[i] == 'tanh_square':
-                Input = safe_add(Input, tanh_square(origin_input))
-            elif activation_list[i] == 'mod_sigmoid':
-                Input = safe_add(Input, mod_sigmoid(origin_input))
-            elif activation_list[i] == 'linear':
-                Input = safe_add(Input, origin_input)
-            elif activation_list[i] == 'quartic':
-                Input = safe_add(Input, quartic(origin_input))
-            elif activation_list[i] == 'square_quartic':
-                Input = safe_add(Input, square_quartic(origin_input))
-            elif activation_list[i] == 'cubic_quadratic':
-                Input = safe_add(Input, cubic_quadratic(origin_input))
-            elif activation_list[i] == 'exp_cubic':
-                Input = safe_add(Input, exp_cubic(origin_input))
-            elif activation_list[i] == 'sine_square':
-                Input = safe_add(Input, sine_square(origin_input))
-            elif activation_list[i] == 'logarithmic':
-                Input = safe_add(Input, logarithmic(origin_input))
-            elif activation_list[i] == 'scaled_cubic':
-                Input = safe_add(Input, scaled_cubic(origin_input, 1.0))
-            elif activation_list[i] == 'sine_offset':
-                Input = safe_add(Input, sine_offset(origin_input, 1.0))
-            elif activation_list[i] == 'spiral':
-                Input = safe_add(Input, spiral_activation(origin_input))
-            elif activation_list[i] == 'circular':
-                Input = safe_add(Input, circular_activation(origin_input))
+        return Input + cp.sum(activation_outputs, axis=0)
         
-        except Exception as e:
-            warnings.warn(f"Error in activation {activation_list[i]}: {str(e)}", RuntimeWarning)
-            if not isinstance(Input, cp.ndarray):
-                Input = cp.array(Input)
-            if not isinstance(origin_input, cp.ndarray):
-                origin_input = cp.array(origin_input)
-            continue
- 
-    return Input
+    except Exception as e:
+        warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
+        return Input

pyerualjetwork/data_operations_cuda.py

@@ -401,7 +401,7 @@ def standard_scaler(x_train=None, x_test=None, scaler_params=None, dtype=cp.floa
 
         return scaled_data  # sample data scaled
     
-    
+
 def normalization(
     Input,  # num: Input data to be normalized.
     dtype=cp.float32

pyerualjetwork/fitness_functions.py

@@ -0,0 +1,72 @@
+import numpy as np
+from scipy.spatial.distance import pdist
+
+def diversity_score(population):
+    """
+    Calculates the diversity score of a population based on the
+    Euclidean distances between individuals in the population.
+    
+    :param population: That calculates the diversity score of a population based on the Euclidean distances between
+    individuals in the population
+    :return: The function returns the diversity score,
+    which is a measure of how spread out or diverse the population is in terms of their characteristics.
+    """
+    if len(population) < 2:
+        return 0
+        
+    population = np.nan_to_num(population, nan=0.0)
+    
+    distances = pdist(population, metric='euclidean')
+    distances = np.maximum(distances, 1e-10)
+    
+    avg_distance = np.mean(distances)
+    if population.shape[1] == 0:
+        return 0
+        
+    max_possible_distance = np.sqrt(population.shape[1])
+    max_possible_distance = max(max_possible_distance, 1e-10)
+    
+    diversity = avg_distance / max_possible_distance
+    return diversity
+
+def multi_head_fitness(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
+    """
+    The function calculates a fitness score based on accuracy, margin loss, and diversity score using
+    specified parameters.
+    
+    @param y_true The `y_true` parameter represents the true labels of the data points. It is an array
+    or list containing the actual labels of the data points.
+    @param y_pred The `y_pred` parameter in the `multi_head_fitness` function represents the
+    predicted values for a given dataset. It is a NumPy array containing the predicted values for each
+    sample in the dataset.
+    @param diversity_score The `diversity_score` parameter in the `multi_head_fitness` function
+    represents a measure of diversity in the predictions. It is used as a factor in calculating the
+    fitness of the model. The function combines accuracy, margin loss, and diversity score to evaluate
+    the overall performance of the model
+    @param accuracy Accuracy is a measure of the correct predictions made by a model. It is typically
+    calculated as the number of correct predictions divided by the total number of predictions. In the
+    context of the `multi_head_fitness` function, the accuracy parameter represents the accuracy
+    of the model's predictions.
+    @param alpha Alpha is a parameter that controls the impact of accuracy on the overall fitness score
+    in the multi_head_fitness function. It is used as an exponent to raise the accuracy value
+    to, influencing its contribution to the fitness calculation.
+    @param beta The `beta` parameter in the `multi_head_fitness` function is used as an exponent
+    in the fitness calculation formula. It controls the impact of the margin loss term on the overall
+    fitness value. A higher value of `beta` will amplify the effect of the margin loss term, making it
+    @param lambda_div The `lambda_div` parameter in the `multi_head_fitness` function represents
+    the weight given to the diversity score in calculating the fitness value. It is a hyperparameter
+    that controls the impact of diversity score on the overall fitness calculation. A higher value of
+    `lambda_div` will increase the importance
+    @return The function `multi_head_fitness` returns the fitness value calculated based on the
+    input parameters `y_true`, `y_pred`, `diversity_score`, `accuracy`, and optional parameters `alpha`,
+    `beta`, and `lambda_div`. The fitness value is computed using a formula that combines accuracy,
+    margin loss, and diversity score with specified weights and coefficients.
+    """
+    incorrect = y_true != y_pred
+    margin_loss = np.abs(y_true[incorrect] - y_pred[incorrect]).mean() if np.any(incorrect) else 0
+
+    margin_loss = np.nan_to_num(margin_loss, nan=0.0)
+    accuracy = max(accuracy, 1e-10)
+    
+    fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
+    return fitness

pyerualjetwork/fitness_functions_cuda.py

@@ -0,0 +1,85 @@
+import cupy as cp
+
+def cupy_pairwise_distances(X):
+    """
+    Pairwise Euclidean distances
+    """
+    r = cp.sum(X * X, 1)
+    r = r.reshape(-1, 1)
+
+    distances = cp.maximum(r - 2 * cp.dot(X, X.T) + r.T, 0.0)
+
+    triu_indices = cp.triu_indices(distances.shape[0], k=1)
+    return cp.sqrt(distances[triu_indices])
+
+
+def diversity_score(population):
+    """
+    Calculates the diversity score of a population based on the
+    Euclidean distances between individuals in the population.
+   
+    :param population: That calculates the diversity score of a population based on the Euclidean distances between
+    individuals in the population
+    :return: The function returns the diversity score,
+    which is a measure of how spread out or diverse the population is in terms of their characteristics.
+    """
+    if len(population) < 2:
+        return 0
+    
+    population = cp.nan_to_num(population, nan=0.0)
+    
+    distances = cupy_pairwise_distances(population)
+    distances = cp.maximum(distances, 1e-10)
+    
+    avg_distance = cp.mean(distances)
+    if population.shape[1] == 0:
+        return 0
+    
+    max_possible_distance = cp.sqrt(population.shape[1])
+    max_possible_distance = float(max(max_possible_distance, 1e-10))
+    
+    diversity = float(avg_distance / max_possible_distance)
+    return diversity
+
+
+def multi_head_fitness(y_true, y_pred, diversity_score, accuracy, alpha=2, beta=1.5, lambda_div=0.05):
+    """
+    The function calculates a fitness score based on accuracy, margin loss, and diversity score using
+    specified parameters.
+    
+    @param y_true The `y_true` parameter represents the true labels of the data points. It is an array
+    or list containing the actual labels of the data points.
+    @param y_pred The `y_pred` parameter in the `multi_head_fitness` function represents the
+    predicted values for a given dataset. It is a NumPy array containing the predicted values for each
+    sample in the dataset.
+    @param diversity_score The `diversity_score` parameter in the `multi_head_fitness` function
+    represents a measure of diversity in the predictions. It is used as a factor in calculating the
+    fitness of the model. The function combines accuracy, margin loss, and diversity score to evaluate
+    the overall performance of the model
+    @param accuracy Accuracy is a measure of the correct predictions made by a model. It is typically
+    calculated as the number of correct predictions divided by the total number of predictions. In the
+    context of the `multi_head_fitness` function, the accuracy parameter represents the accuracy
+    of the model's predictions.
+    @param alpha Alpha is a parameter that controls the impact of accuracy on the overall fitness score
+    in the multi_head_fitness function. It is used as an exponent to raise the accuracy value
+    to, influencing its contribution to the fitness calculation.
+    @param beta The `beta` parameter in the `multi_head_fitness` function is used as an exponent
+    in the fitness calculation formula. It controls the impact of the margin loss term on the overall
+    fitness value. A higher value of `beta` will amplify the effect of the margin loss term, making it
+    @param lambda_div The `lambda_div` parameter in the `multi_head_fitness` function represents
+    the weight given to the diversity score in calculating the fitness value. It is a hyperparameter
+    that controls the impact of diversity score on the overall fitness calculation. A higher value of
+    `lambda_div` will increase the importance
+    @return The function `multi_head_fitness` returns the fitness value calculated based on the
+    icput parameters `y_true`, `y_pred`, `diversity_score`, `accuracy`, and optional parameters `alpha`,
+    `beta`, and `lambda_div`. The fitness value is computed using a formula that combines accuracy,
+    margin loss, and diversity score with specified weights and coefficients.
+    """
+    incorrect = y_true != y_pred
+    margin_loss = cp.abs(y_true[incorrect] - y_pred[incorrect]).mean() if cp.any(incorrect) else 0
+
+    margin_loss = cp.nan_to_num(margin_loss, nan=0.0)
+    accuracy = max(accuracy, 1e-10)
+    
+    fitness = (accuracy ** alpha) * ((1 - margin_loss) ** beta) * (1 + lambda_div * diversity_score)
+    return fitness

pyerualjetwork/model_operations.py

@@ -258,7 +258,7 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
     ndarray: Output from the model.
     """
     
-    from .plan import feed_forward
+    from .activation_functions import apply_activation
     from .data_operations import standard_scaler
     
     model = load_model(model_name, model_path)
@@ -269,12 +269,12 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
 
     Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
 
-    neural_layer = Input
-    neural_layer = np.array(neural_layer, copy=False)
-    neural_layer = neural_layer.ravel()
+    Input = np.array(Input, dtype=dtype, copy=False)
+    Input = Input.ravel()
 
     try:
-        neural_layer = feed_forward(neural_layer, np.copy(W.astype(dtype, copy=False)), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        Input = apply_activation(Input, activation_potentiation)
+        neural_layer = Input @ W.T
         return neural_layer
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_ssd." + Style.RESET_ALL)
@@ -304,7 +304,7 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=np.float3
     W = model[get_weights()]
 
     try:
-        Input = np.dot(output.astype(dtype, copy=False), np.copy(W.astype(dtype, copy=False)))
+        Input = W.T @ output
         return Input
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: reverse_predict_model_ssd." + Style.RESET_ALL)
@@ -334,18 +334,18 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['li
     ndarray: Output from the model.
     """
 
-    from data_operations import standard_scaler
-    from plan import feed_forward
+    from .data_operations import standard_scaler
+    from .activation_functions import apply_activation
 
     Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
     
+    Input = np.array(Input, dtype=dtype, copy=False)
+    Input = Input.ravel()
+
     try:
         
-        neural_layer = Input
-        neural_layer = np.array(neural_layer, copy=False)
-        neural_layer = neural_layer.ravel()
-
-        neural_layer = feed_forward(neural_layer, np.copy(W.astype(dtype, copy=False)), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        Input = apply_activation(Input, activation_potentiation)
+        neural_layer = Input @ W.T
 
         return neural_layer
     
@@ -371,7 +371,7 @@ def reverse_predict_model_ram(output, W, dtype=np.float32):
     """
 
     try:
-        Input = np.dot(output.astype(dtype, copy=False), np.copy(W.astype(dtype, copy=False)))
+        Input = W.T @ output
         return Input
     
     except:

pyerualjetwork/model_operations_cuda.py

@@ -263,10 +263,10 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=cp.float32):
     Returns:
     ndarray: Output from the model.
     """
-            
+    
     Input = cp.array(Input, dtype=dtype, copy=False)
-        
-    from .plan_cuda import feed_forward
+    
+    from .activation_functions_cuda import apply_activation
     from .data_operations_cuda import standard_scaler
     
     model = load_model(model_name, model_path)
@@ -277,13 +277,14 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=cp.float32):
 
     Input = standard_scaler(None, Input, scaler_params)
 
-    neural_layer = Input
-    neural_layer = cp.array(neural_layer)
-    neural_layer = neural_layer.ravel()
+    Input = cp.array(Input, dtype=dtype, copy=False)
+    Input = Input.ravel()
 
     try:
-        neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        Input = apply_activation(Input, activation_potentiation)
+        neural_layer = Input @ W.T
         return neural_layer
+
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_ssd." + Style.RESET_ALL)
         sys.exit()
@@ -314,7 +315,7 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=cp.float3
     W = model[get_weights()]
 
     try:
-        Input = cp.dot(output, cp.copy(W))
+        Input = W.T @ output
         return Input
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: reverse_predict_model_ssd." + Style.RESET_ALL)
@@ -344,19 +345,17 @@ def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['li
     """
 
     from .data_operations_cuda import standard_scaler
-    from .plan_cuda import feed_forward
+    from .activation_functions_cuda import apply_activation
 
-    Input = cp.array(Input, dtype=dtype, copy=False)
-    
     Input = standard_scaler(None, Input, scaler_params)
     
+    Input = cp.array(Input, dtype=dtype, copy=False)
+    Input = Input.ravel()
+
     try:
         
-        neural_layer = Input
-        neural_layer = cp.array(neural_layer)
-        neural_layer = neural_layer.ravel()
-
-        neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        Input = apply_activation(Input, activation_potentiation)
+        neural_layer = Input @ W.T
 
         return neural_layer
     
@@ -384,7 +383,7 @@ def reverse_predict_model_ram(output, W, dtype=cp.float32):
     output = cp.array(output, dtype=dtype, copy=False)
 
     try:
-        Input = cp.dot(output, cp.copy(W))
+        Input = W.T @ output
         return Input
     
     except: