pyerualjetwork 4.1.8__py3-none-any.whl → 4.1.8b1__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -48,7 +48,7 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.1.8"
+__version__ = "4.1.8b1"
 __update__ = "* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\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/plan.py

@@ -24,7 +24,6 @@ from .loss_functions import binary_crossentropy, categorical_crossentropy
 from .activation_functions import apply_activation, Softmax, all_activations
 from .metrics import metrics
 from .model_operations import get_acc, get_preds, get_preds_softmax
-from .memory_operations import optimize_labels
 from .visualizations import (
     draw_neural_web,
     update_neural_web_for_fit,
@@ -103,6 +102,8 @@ def fit(
     Returns:
         numpyarray([num]): (Weight matrix).
     """
+    
+    from model_operations import get_acc
 
     # Pre-checks
 
@@ -172,7 +173,7 @@ def fit(
     return normalization(LTPW, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
+def learner(x_train, y_train, optimizator, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
            neural_web_history=False, show_current_activations=False, auto_normalization=True,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None, except_this=None,
@@ -191,9 +192,9 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         y_train (array-like): Labels for training data. one-hot encoded.
 
-        optimizer (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat (and) optimizer = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+        optimizator (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat (and) optimizator = lambda *args, **kwargs: planeat.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
         ```python
-        genetic_optimizer = lambda *args, **kwargs: planeat.evolve(*args,
+        genetic_optimizator = lambda *args, **kwargs: planeat.evolve(*args,
                                                                     activation_add_prob=0.85,
                                                                     mutations=False,
                                                                     strategy='cross_over',
@@ -201,7 +202,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         model = plan.learner(x_train,
                              y_train,
-                             optimizer=genetic_optimizer,
+                             optimizator=genetic_optimizator,
                              strategy='accuracy',
                              show_history=True,
                              target_acc=0.94,
@@ -255,37 +256,52 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     
     """
 
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
 
     activation_potentiation = all_activations()
 
     # Pre-checks
 
     x_train = x_train.astype(dtype, copy=False)
-    y_train = optimize_labels(y_train, cuda=False)
+
+    if len(y_train[0]) < 256:
+        if y_train.dtype != np.uint8:
+            y_train = np.array(y_train, copy=False).astype(np.uint8, copy=False)
+    elif len(y_train[0]) <= 32767:
+        if y_train.dtype != np.uint16:
+            y_train = np.array(y_train, copy=False).astype(np.uint16, copy=False)
+    else:
+        if y_train.dtype != np.uint32:
+            y_train = np.array(y_train, copy=False).astype(np.uint32, copy=False)
+
+    if x_test is not None:
+        x_test = x_test.astype(dtype, copy=False)
+
+        if len(y_test[0]) < 256:
+            if y_test.dtype != np.uint8:
+                y_test = np.array(y_test, copy=False).astype(np.uint8, copy=False)
+        elif len(y_test[0]) <= 32767:
+            if y_test.dtype != np.uint16:
+                y_test = np.array(y_test, copy=False).astype(np.uint16, copy=False)
+        else:
+            if y_test.dtype != np.uint32:
+                y_test = np.array(y_test, copy=False).astype(np.uint32, copy=False)
 
     if x_test is None and y_test is None:
         x_test = x_train
         y_test = y_train
         data = 'Train'
     else:
-        x_test = x_test.astype(dtype, copy=False)
-        y_test = optimize_labels(y_test, cuda=False)
         data = 'Test'
 
     # Filter activation functions
-    if only_this is not None:
+    if only_this != None:
         activation_potentiation = only_this
-    if except_this is not None:
+    if except_this != None:
         activation_potentiation = [item for item in activation_potentiation if item not in except_this]
     if gen is None:
         gen = len(activation_potentiation)
 
-    if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
-
-    if start_this_act is None and len(activation_potentiation) % 2 != 0: raise ValueError("Activation length must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    if start_this_act is not None and len(activation_potentiation) + 1 % 2 != 0: raise ValueError("You are using start_this parameter, activation length still must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    
     # Initialize visualization components
     viz_objects = initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train)
 
@@ -320,8 +336,32 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     best_acc_per_gen_list = []
     postfix_dict = {}
     loss_list = []
+    weight_pop = []
     target_pop = []
 
+    for i in range(len(activation_potentiation)):
+        print(f"\rPre-Run {i}/{len(activation_potentiation)}",end='')
+        
+        if i == 0 and start_this_act is not None:
+            act_pop[0] = activation_potentiation[i]
+            weight_pop[0] = W
+        else:
+            act_pop.append(activation_potentiation[i])
+            weight_pop.append(W)
+            
+        x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
+        W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
+        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=act_pop[-1], dtype=dtype)
+
+        if strategy == 'accuracy': target_pop.append(model[get_acc()])
+        elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
+            precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
+            
+            if strategy == 'precision': target_pop.append(precision_score)
+            if strategy == 'recall': target_pop.append(recall_score)
+            if strategy == 'f1': target_pop.append(f1_score)
+
+    weight_pop, act_pop = optimizator(np.array(weight_pop, dtype=dtype), act_pop, 0, np.array(target_pop, dtype=dtype), target_fitness=target_fitness, bar_status=False)
     progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
 
     for i in range(gen):
@@ -331,19 +371,16 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         progress.n = 0
         progress.last_print_n = 0
         progress.update(0)
+        
+        weight_pop, act_pop = optimizator(np.array(weight_pop, dtype=dtype), act_pop, i, np.array(target_pop, dtype=dtype, copy=False), target_fitness=target_fitness, bar_status=False)
+        target_pop = []
 
         for j in range(len(activation_potentiation)):
 
             x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            
-            if i == 0:
-                act_pop.append(activation_potentiation[j])
-                W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
-                weight_pop.append(W)
-
             model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype)
+
             acc = model[get_acc()]
-            
             if strategy == 'accuracy': target_pop.append(acc)
 
             elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
@@ -369,7 +406,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
             if ((strategy == 'accuracy' and acc >= best_acc) or 
                 (strategy == 'f1' and f1_score >= best_f1) or 
-                (strategy == 'precision' and precision_score >= best_precision) or
+                (strategy == 'precision' and precision_score >= best_precision) or 
                 (strategy == 'recall' and recall_score >= best_recall)):
 
                 best_acc = acc
@@ -377,8 +414,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                 final_activations = act_pop[j]
                 best_model = model
 
-                final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
-
                 if batch_size == 1:
                     postfix_dict[f"{data} Accuracy"] = best_acc
                 else:
@@ -477,9 +512,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
 
-        weight_pop, act_pop = optimizer(np.array(weight_pop, dtype=dtype), act_pop, i, np.array(target_pop, dtype=dtype, copy=False), target_fitness=target_fitness, bar_status=False)
-        target_pop = []
-
         # Early stopping check
         if early_stop == True and i > 0:
             if best_acc_per_gen_list[i] == best_acc_per_gen_list[i-1]:

pyerualjetwork/plan_cuda.py

@@ -14,7 +14,6 @@ PYERUALJETWORK document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 """
 
 import cupy as cp
-import numpy as np
 from colorama import Fore
 import math
 
@@ -25,7 +24,7 @@ from .loss_functions_cuda import binary_crossentropy, categorical_crossentropy
 from .activation_functions_cuda import apply_activation, Softmax, all_activations
 from .metrics_cuda import metrics
 from .model_operations_cuda import get_acc, get_preds, get_preds_softmax
-from .memory_operations import transfer_to_gpu, transfer_to_cpu, optimize_labels
+from .memory_operations import transfer_to_gpu, transfer_to_cpu
 from .visualizations_cuda import (
     draw_neural_web,
     update_neural_web_for_fit,
@@ -108,6 +107,8 @@ def fit(
         numpyarray([num]): (Weight matrix).
     """
     # Pre-checks
+
+    from memory_operations import transfer_to_gpu, transfer_to_cpu
     
     if train_bar and val:
         train_progress = initialize_loading_bar(total=len(x_train), ncols=71, desc='Fitting', bar_format=bar_format_normal)
@@ -188,7 +189,7 @@ def fit(
     return normalization(LTPW, dtype=dtype)
 
 
-def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
+def learner(x_train, y_train, optimizator, x_test=None, y_test=None, strategy='accuracy', gen=None, batch_size=1,
            neural_web_history=False, show_current_activations=False, auto_normalization=True,
            neurons_history=False, early_stop=False, loss='categorical_crossentropy', show_history=False,
            interval=33.33, target_acc=None, target_loss=None, except_this=None,
@@ -207,9 +208,9 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         y_train (array-like): Labels for training data.
 
-        optimizer (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat_cuda (and) optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
+        optimizator (function): PLAN optimization technique with hyperparameters. (PLAN using NEAT(PLANEAT) for optimization.) Please use this: from pyerualjetwork import planeat_cuda (and) optimizator = lambda *args, **kwargs: planeat_cuda.evolve(*args, 'here give your neat hyperparameters for example:  activation_add_prob=0.85', **kwargs) Example:
         ```python
-        genetic_optimizer = lambda *args, **kwargs: planeat_cuda.evolve(*args,
+        genetic_optimizator = lambda *args, **kwargs: planeat_cuda.evolve(*args,
                                                                     activation_add_prob=0.85,
                                                                     mutations=False,
                                                                     strategy='cross_over',
@@ -217,7 +218,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         model = plan_cuda.learner(x_train,
                              y_train,
-                             optimizer=genetic_optimizer,
+                             optimizator=genetic_optimizator,
                              strategy='accuracy',
                              show_history=True,
                              target_acc=0.94,
@@ -273,19 +274,16 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     
     """
 
-    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular', 'spiral'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
+    print(Fore.WHITE + "\nRemember, optimization on large datasets can be very time-consuming and computationally expensive. Therefore, if you are working with such a dataset, our recommendation is to include activation function: ['circular'] in the 'except_this' parameter unless absolutely necessary, as they can significantly prolong the process. from: learner\n" + Fore.RESET)
 
     activation_potentiation = all_activations()
 
-    y_train = optimize_labels(y_train, cuda=True)
-
     if x_test is None and y_test is None:
         x_test = x_train
         y_test = y_train
         data = 'Train'
     else:
         data = 'Test'
-        y_test = optimize_labels(y_test, cuda=True)
         
     if memory == 'gpu':
         x_train = transfer_to_gpu(x_train, dtype=dtype)
@@ -308,27 +306,22 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     else:
         raise ValueError("memory parameter must be 'cpu' or 'gpu'.")
 
-    if strategy != 'accuracy' and strategy != 'f1' and strategy != 'recall' and strategy != 'precision': raise ValueError("Strategy parameter only be 'accuracy' or 'f1' or 'recall' or 'precision'.")
-
     # Filter activation functions
-    if only_this is not None:
+    if only_this != None:
         activation_potentiation = only_this
-    if except_this is not None:
+    if except_this != None:
         activation_potentiation = [item for item in activation_potentiation if item not in except_this]
     if gen is None:
         gen = len(activation_potentiation)
 
-    if start_this_act is None and len(activation_potentiation) % 2 != 0: raise ValueError("Activation length must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    if start_this_act is not None and len(activation_potentiation) + 1 % 2 != 0: raise ValueError("You are using start_this parameter, activation length still must be even number. Please use 'except_this' parameter and except some activation. For example: except_this=['linear']")
-    
     # Initialize visualization components
     viz_objects = initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train)
 
     # Initialize progress bar
     if batch_size == 1:
-        ncols = 86
+        ncols = 76
     else:
-        ncols = 99
+        ncols = 89
 
     # Initialize variables
     act_pop = []
@@ -341,6 +334,7 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         weight_pop.append(start_this_W)
         
         x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
+        
         model = evaluate(x_test_batch, y_test_batch, W=start_this_W, loading_bar_status=False, activation_potentiation=act_pop, dtype=dtype, memory=memory)
 
         if loss == 'categorical_crossentropy':
@@ -356,6 +350,31 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
     loss_list = []
     target_pop = []
 
+    for i in range(len(activation_potentiation)):
+        print(f"\rPre-Run {i}/{len(activation_potentiation)}",end='')
+        
+        if i == 0 and start_this_act is not None:
+            act_pop[0] = activation_potentiation[i]
+            weight_pop[0] = W
+        else:
+            act_pop.append(activation_potentiation[i])
+            weight_pop.append(W)
+
+        x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
+        W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype, memory=memory)
+        model = evaluate(x_test_batch, y_test_batch, W=W, loading_bar_status=False, activation_potentiation=act_pop[-1], dtype=dtype, memory=memory)
+
+        if strategy == 'accuracy': target_pop.append(model[get_acc()])
+        elif strategy == 'f1' or strategy == 'precision' or strategy == 'recall':
+            precision_score, recall_score, f1_score = metrics(y_test_batch, model[get_preds()])
+            
+            if strategy == 'precision': target_pop.append(precision_score)
+            if strategy == 'recall': target_pop.append(recall_score)
+            if strategy == 'f1': target_pop.append(f1_score)
+
+        
+
+    weight_pop, act_pop = optimizator(cp.array(weight_pop, dtype=dtype), act_pop, 0, cp.array(target_pop, dtype=dtype), target_fitness=target_fitness, bar_status=False)
     progress = initialize_loading_bar(total=len(activation_potentiation), desc="", ncols=ncols, bar_format=bar_format_learner)
 
     for i in range(gen):
@@ -369,12 +388,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
         for j in range(len(activation_potentiation)):
 
             x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
-            
-            if i == 0:
-                act_pop.append(activation_potentiation[j])
-                W = fit(x_train, y_train, activation_potentiation=act_pop[-1], train_bar=False, auto_normalization=auto_normalization, dtype=dtype)
-                weight_pop.append(W)
-
             model = evaluate(x_test_batch, y_test_batch, W=weight_pop[j], loading_bar_status=False, activation_potentiation=act_pop[j], dtype=dtype, memory=memory)
 
             acc = model[get_acc()]
@@ -411,8 +424,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
                 final_activations = act_pop[j]
                 best_model = model
 
-                final_activations = [final_activations[0]] if len(set(final_activations)) == 1 else final_activations # removing if all same
-
                 if batch_size == 1:
                     postfix_dict[f"{data} Accuracy"] = best_acc
                 else:
@@ -510,9 +521,6 @@ def learner(x_train, y_train, optimizer, x_test=None, y_test=None, strategy='acc
 
         best_acc_per_gen_list.append(best_acc)
         loss_list.append(best_loss)
-        
-        weight_pop, act_pop = optimizer(cp.array(weight_pop, dtype=dtype), act_pop, i, cp.array(target_pop, dtype=dtype, copy=False), target_fitness=target_fitness, bar_status=False)
-        target_pop = []
 
         # Early stopping check
         if early_stop == True and i > 0:
@@ -642,6 +650,7 @@ def evaluate(
     Returns:
         tuple: Model (list).
     """
+    from memory_operations import transfer_to_cpu, transfer_to_gpu
 
     if memory == 'gpu':
         x_test = transfer_to_gpu(x_test, dtype=dtype)

pyerualjetwork/planeat.py

@@ -185,7 +185,7 @@ Notes:
 
 Example:
     ```python
-    weights, activation_potentiations = planeat.evolve(weights, activation_potentiations, 1, fitness, show_info=True, strategy='cross_over', policy='normal_selective')
+    weights, activation_potentiations = learner(weights, activation_potentiations, 1, fitness, info=True, strategy='cross_over', policy='normal_selective')
     ```
 
     - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.

pyerualjetwork/planeat_cuda.py

@@ -186,7 +186,7 @@ Notes:
 
 Example:
     ```python
-    weights, activation_potentiations = planeat.evolve(weights, activation_potentiations, 1, fitness, show_info=True, strategy='cross_over', policy='normal_selective')
+    weights, activation_potentiations = learner(weights, activation_potentiations, 1, fitness, info=True, strategy='cross_over', policy='normal_selective')
     ```
 
     - The function returns the updated weights and activations after processing based on the chosen strategy, policy, and mutation parameters.
@@ -230,15 +230,17 @@ Example:
    else:
       raise ValueError("genome population size must be even number. for example: not 99, make 100 or 98.")
 
+   sort_indices = cp.argsort(fitness)
+
 ### FITNESS LIST IS SORTED IN ASCENDING (OR DESCENDING) ORDER, AND THE WEIGHT AND ACTIVATIONS OF EACH GENOME ARE SORTED ACCORDING TO THIS ORDER:
 
-   if target_fitness == 'max': sort_indices = cp.argsort(fitness)
-   elif target_fitness == 'min': sort_indices = cp.argsort(-fitness)
+   if target_fitness == 'max': sort_indices = np.argsort(fitness)
+   elif target_fitness == 'min': sort_indices = np.argsort(-fitness)
 
    fitness = fitness[sort_indices]
    weights = weights[sort_indices]
 
-   activation_potentiations = [activation_potentiations[int(i)] for i in sort_indices]
+   activation_potentiations = [activation_potentiations[i] for i in sort_indices]
 
 ### GENOMES ARE DIVIDED INTO TWO GROUPS: GOOD GENOMES AND BAD GENOMES:
 
@@ -353,9 +355,9 @@ Example:
       print("  ACTIVATION SELECTION RATE (THRESHOLD VALUE FOR SINGLE CROSS OVER):", str(activation_selection_rate) + '\n')
 
       print("*** Performance ***")
-      print(" MAX REWARD: ", str(cp.round(max(fitness), 2)))
-      print("  MEAN REWARD: ", str(cp.round(cp.mean(fitness), 2)))
-      print("  MIN REWARD: ", str(cp.round(min(fitness), 2)) + '\n')
+      print("  MAX REWARD: ", str(round(max(fitness), 2)))
+      print("  MEAN REWARD: ", str(round(cp.mean(fitness), 2)))
+      print("  MIN REWARD: ", str(round(min(fitness), 2)) + '\n')
 
       print("  BEST GENOME INDEX: ", str(len(weights)-1))
       print("  NOTE: Genomes are always sorted from the least successful to the most successful according to their performance ranking. Therefore, the genome at the last index is the king of the previous generation. " + '\n')

pyerualjetwork/visualizations_cuda.py

@@ -358,7 +358,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
         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(fpr, tpr, 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])

{pyerualjetwork-4.1.8.dist-info → pyerualjetwork-4.1.8b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.1.8
+Version: 4.1.8b1
 Summary: PyerualJetwork is a machine learning library written in Python for professionals, incorporating advanced, unique, new, and modern techniques.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

{pyerualjetwork-4.1.8.dist-info → pyerualjetwork-4.1.8b1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyerualjetwork/__init__.py,sha256=uPTVoRI0TyHt86XYQOHZcvtk1faqxuocKknYhnKUZbY,2175
+pyerualjetwork/__init__.py,sha256=oroCPYREyLkdAV9z-6EW8beNYhimUdntMjWc1Uhd0mM,2177
 pyerualjetwork/activation_functions.py,sha256=WWOdMd5pI6ZKe-ieKCIsKAYPQODHuXYxx7tzhA5xjes,11767
 pyerualjetwork/activation_functions_cuda.py,sha256=KmXJ5Cdig46XAMYakXFPEOlxSxtFJjD21-i3nGtxPjE,11807
 pyerualjetwork/data_operations.py,sha256=ZM24BuPsIAtI0a_Exr4HgCjmlb285wEeO8juFY9sJr0,14680
@@ -11,14 +11,14 @@ pyerualjetwork/metrics.py,sha256=q7MkhnZDRbCjFBDDfUgrl8lBYnUT_1ro1LxeBq105pI,607
 pyerualjetwork/metrics_cuda.py,sha256=73h9GC7XwmnFCVzFEEiPQfF8CwHIz2wsCbxpZrJtYgw,5061
 pyerualjetwork/model_operations.py,sha256=hnhR8dtoICNJWIwGgJ65-LN3GYN_DYH4LMe6YpZVbnI,12967
 pyerualjetwork/model_operations_cuda.py,sha256=XnKKq54ZLaqCm-NaJ6d8IToACKcKg2Ttq6moowVRRWo,13365
-pyerualjetwork/plan.py,sha256=5znxbnGO-3aL_SRDMRNNrDPJs_6hgU8yGiFnwPy69EY,34320
-pyerualjetwork/plan_cuda.py,sha256=KoKjsoWTLM-q07G1Gy0-LYXGlp15Fno6JqHz-Jzi_yE,35983
-pyerualjetwork/planeat.py,sha256=VtWtWndbKoFNYTWd1EsyKBV4Vp5U6cc7uWDgQ4WjHqo,40248
-pyerualjetwork/planeat_cuda.py,sha256=fSn28ZbxctPvBjpKgtv_uGwwUdTEXkBizy76mMlZYJ0,40237
+pyerualjetwork/plan.py,sha256=atpdeF1wDu4HIngP9RN6iUBLKOzkmrFwHyCJQKUj_38,35419
+pyerualjetwork/plan_cuda.py,sha256=sl2Od8-STwAr6GQmwisryU-IsOvWIGSHeFSwHuEa1iM,36035
+pyerualjetwork/planeat.py,sha256=pVp8ndi5E_muwOTFmlcav70-5LLV5A2yA0_SgURvT08,40236
+pyerualjetwork/planeat_cuda.py,sha256=3Vt5_zHUK4Jt_vW6LugQOy3to8gzQfT0_poPxeJTy68,40253
 pyerualjetwork/ui.py,sha256=wu2BhU1k-w3Kcho5Jtq4SEKe68ftaUeRGneUOSCVDjU,575
 pyerualjetwork/visualizations.py,sha256=QaYSIyVkJZ8NqpBKArQKkI1y37nCQo_KIM98IMssnRc,28766
-pyerualjetwork/visualizations_cuda.py,sha256=F60vQ92AXlMgBka3InXnOtGoM25vQJAlBIU2AlYTwks,29200
-pyerualjetwork-4.1.8.dist-info/METADATA,sha256=ZhjLwRdVpV6yuxJD4-ExuvsLeqo-EtSVdfqVqWw7wKs,7793
-pyerualjetwork-4.1.8.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyerualjetwork-4.1.8.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
-pyerualjetwork-4.1.8.dist-info/RECORD,,
+pyerualjetwork/visualizations_cuda.py,sha256=9qw46Y4bo67l0nVVF1FSNS8ksyzbIAJdaPDFOhN5J8Y,29188
+pyerualjetwork-4.1.8b1.dist-info/METADATA,sha256=_mbbAWUIEQ5V5T_iqWlzkZX2IQyKtWdTETlMSvvPw2g,7795
+pyerualjetwork-4.1.8b1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pyerualjetwork-4.1.8b1.dist-info/top_level.txt,sha256=BRyt62U_r3ZmJpj-wXNOoA345Bzamrj6RbaWsyW4tRg,15
+pyerualjetwork-4.1.8b1.dist-info/RECORD,,