pyerualjetwork 4.1.3__tar.gz → 4.1.5__tar.gz

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.1.3
+Version: 4.1.5
 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
@@ -11,7 +11,11 @@ Description-Content-Type: text/markdown
 
 Note: anaplan old name of pyerualjetwork
 
-https://libraries.io/pypi/pyerualjetwork
+Libraries.io Page: https://libraries.io/pypi/pyerualjetwork
+
+PyPi Page: https://pypi.org/project/pyerualjetwork/
+
+GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
       pip install pyerualjetwork
@@ -53,6 +57,11 @@ PyerualJetwork is a machine learning library written in Python for professionals
 Both the PLAN 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. PyerualJetwork is written in fully functional programming with non-oop elements. PyerualJetwork consists of many functions that complement each other, which facilitates the learning process and debugging during use.
 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:
+
+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>

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/README.md

@@ -2,7 +2,11 @@
 
 Note: anaplan old name of pyerualjetwork
 
-https://libraries.io/pypi/pyerualjetwork
+Libraries.io Page: https://libraries.io/pypi/pyerualjetwork
+
+PyPi Page: https://pypi.org/project/pyerualjetwork/
+
+GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
       pip install pyerualjetwork
@@ -44,6 +48,11 @@ PyerualJetwork is a machine learning library written in Python for professionals
 Both the PLAN 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. PyerualJetwork is written in fully functional programming with non-oop elements. PyerualJetwork consists of many functions that complement each other, which facilitates the learning process and debugging during use.
 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:
+
+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>
@@ -83,4 +92,4 @@ Anaconda users can access the 'Anaconda Prompt' terminal from the Start menu and
 
 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.
 
-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 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-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork/__init__.py

@@ -2,7 +2,6 @@
 import subprocess
 subprocess.check_call(["pip", "install", 'setuptools==75.6.0'])
 import pkg_resources
-from datetime import datetime
 
 print("Auto checking and installation dependencies for PyerualJetwork")
 
@@ -14,7 +13,8 @@ package_names = [
     'networkx==3.3',
     'numpy==1.26.4',
     'matplotlib==3.9.0',
-    'colorama==0.4.6'
+    'colorama==0.4.6',
+    'psutil==6.1.1'
 ]
 
 installed_packages = pkg_resources.working_set
@@ -47,7 +47,7 @@ for package_name in package_names:
 
 print(f"PyerualJetwork is ready to use with {err} errors")
 
-__version__ = "4.1.3"
+__version__ = "4.1.5"
 __update__ = "* Note: CUDA modules need cupy. Enter this command in your terminal: 'pip install cupy-cuda12x' or your cuda version.\n* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES\n* PyerualJetwork document: https://github.com/HCB06/Anaplan/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-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork/data_operations_cuda.py

@@ -1,7 +1,6 @@
 from tqdm import tqdm
 import cupy as cp
 from colorama import Fore, Style
-import sys
 import math
 import numpy as np
 
@@ -136,6 +135,10 @@ def split(X, y, test_size, random_state=42, dtype=cp.float32, use_cpu=False):
     x_train, x_test = X[train_indices], X[test_indices]
     y_train, y_test = y[train_indices], y[test_indices]
 
+    del X
+    del y
+    cp.get_default_memory_pool.free_all_blocks()
+
     return x_train, x_test, y_train, y_test
 
 
@@ -191,7 +194,7 @@ def manuel_balancer(x_train, y_train, target_samples_per_class, dtype=cp.float32
             
             if use_cpu:
                 selected_indices = np.random.choice(
-                    class_indices, target_samples_per_class, replace=False)
+                    class_indices.get(), target_samples_per_class, replace=False)
             else:
                 selected_indices = cp.random.choice(class_indices, target_samples_per_class, replace=False)
 

pyerualjetwork-4.1.5/pyerualjetwork/memory_operations.py

@@ -0,0 +1,192 @@
+import psutil
+import numpy as np
+import cupy as cp
+import gc
+import logging
+
+def get_available_memory():
+    """
+    The function `get_available_memory` returns the amount of available memory in the system using the
+    `psutil` library.
+    :return: The function `get_available_memory()` returns the amount of available memory in bytes on
+    the system.
+    """
+    memory = psutil.virtual_memory().available
+    return memory
+
+def get_optimal_batch_size_for_cpu(x, data_size_bytes, available_memory):
+    """
+    The function calculates the optimal batch size for a given data size and available memory based on
+    the size of each element.
+    
+    :param x: `x` is a NumPy array representing the input data for which we want to determine the
+    optimal batch size for processing on the CPU
+    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes
+    that you want to process in batches
+    :param available_memory: The `available_memory` parameter represents the total memory available on
+    the CPU in bytes. This function calculates the optimal batch size for processing data based on the
+    provided parameters. Let me know if you need any further assistance or explanation!
+    :return: the optimal batch size for a given array `x` based on the available memory and the size of
+    each element in bytes.
+    """
+    safe_memory = available_memory * 0.25
+    element_size = data_size_bytes / x.size
+    return int(safe_memory / (element_size * 2))
+
+def transfer_to_cpu(x, dtype=np.float32):
+    """
+    The `transfer_to_cpu` function converts data to a specified data type on the CPU, handling memory constraints
+    by batching the conversion process.
+    
+    :param x: The `x` parameter in the `transfer_to_cpu` function is the input data that you want to transfer to
+    the CPU. It can be either a NumPy array or any other data structure that supports the `get` method
+    for retrieving the data
+    :param dtype: The `dtype` parameter in the `transfer_to_cpu` function specifies the data type to which the
+    input array `x` should be converted before moving it to the CPU. By default, it is set to
+    `np.float32`, which is a 32-bit floating-point number data type in NumPy
+    :return: The `transfer_to_cpu` function returns the processed data in NumPy array format with the specified
+    data type (`dtype`). If the input `x` is already a NumPy array with the same data type as specified,
+    it returns `x` as is. Otherwise, it converts the input data to the specified data type and returns
+    the processed NumPy array.
+    """
+    try:
+        if isinstance(x, np.ndarray):
+            return x.astype(dtype) if x.dtype != dtype else x
+            
+        data_size = x.nbytes
+        available_memory = get_available_memory()
+        
+        logging.debug(f"Data size: {data_size/1e6:.2f}MB, Available memory: {available_memory/1e6:.2f}MB")
+        
+        if data_size <= available_memory * 0.25:
+            final_result = np.array(x.get(), dtype=dtype, copy=False)
+            del x
+            cp.get_default_memory_pool().free_all_blocks()
+            return final_result
+            
+        batch_size = get_optimal_batch_size_for_cpu(x, data_size, available_memory)
+        logging.debug(f"Using batch size: {batch_size}")
+        
+        result = []
+        total_batches = (x.size + batch_size - 1) // batch_size
+        
+        for i in range(0, x.size, batch_size):
+            try:
+                chunk = x[i:i + batch_size]
+                result.append(np.array(chunk.get(), dtype=dtype))
+                del chunk
+                
+                if i > 0 and i % (batch_size * 10) == 0:
+                    cp.get_default_memory_pool().free_all_blocks()
+                    gc.collect()
+                    
+            except Exception as e:
+                logging.error(f"Error processing batch {i//batch_size + 1}/{total_batches}: {str(e)}")
+                raise
+                
+        final_result = np.concatenate(result)
+        del x
+        cp.get_default_memory_pool().free_all_blocks()
+        gc.collect()
+        return final_result
+        
+    except Exception as e:
+        logging.error(f"Error in transfer_to_cpu: {str(e)}")
+        raise
+
+def get_optimal_batch_size_for_gpu(x, data_size_bytes):
+    """
+    The function calculates the optimal batch size for a GPU based on available memory and data size.
+    
+    :param x: A list or array containing the data elements that will be processed on the GPU
+    :param data_size_bytes: The `data_size_bytes` parameter represents the total size of the data in
+    bytes that you want to process on the GPU. This could be the size of a single batch of data or the
+    total size of the dataset, depending on how you are structuring your computations
+    :return: the optimal batch size that can be used for processing the given data on the GPU, based on
+    the available free memory on the GPU and the size of the data elements.
+    """
+    free_memory = cp.get_default_memory_pool().free_bytes()
+    device_memory = cp.cuda.runtime.memGetInfo()[0]
+    safe_memory = min(free_memory, device_memory) * 0.25
+    
+    element_size = data_size_bytes / len(x)
+    return int(safe_memory / (element_size * 2))
+
+
+def transfer_to_gpu(x, dtype=cp.float32):
+    """
+    The `transfer_to_gpu` function in Python converts input data to GPU arrays, optimizing memory usage by
+    batching and handling out-of-memory errors.
+    
+    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to
+    the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the
+    function will convert it to a CuPy array and
+    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the
+    input array `x` should be converted when moving it to the GPU. By default, it is set to
+    `cp.float32`, which is a 32-bit floating-point data type provided by the Cu
+    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype`
+    (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns
+    `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in
+    batches to
+    """
+    
+    try:
+        if isinstance(x, cp.ndarray):
+            return x.astype(dtype) if x.dtype != dtype else x
+            
+        data_size = x.nbytes
+        free_gpu_memory = cp.cuda.runtime.memGetInfo()[0]
+        
+        logging.debug(f"Data size: {data_size/1e6:.2f}MB, Free GPU memory: {free_gpu_memory/1e6:.2f}MB")
+        
+        if data_size <= free_gpu_memory * 0.25:
+            new_x = cp.array(x, dtype=dtype, copy=False)
+            del x
+            gc.collect()
+            return new_x
+            
+        batch_size = get_optimal_batch_size_for_gpu(x, data_size)
+        logging.debug(f"Using batch size: {batch_size}")
+        
+        result = []
+        total_batches = (len(x) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(x), batch_size):
+            try:
+                chunk = x[i:i + batch_size]
+                gpu_chunk = cp.array(chunk, dtype=dtype)
+                result.append(gpu_chunk)
+                
+                del chunk
+
+                if i > 0 and i % (batch_size * 5) == 0:
+                    pool = cp.get_default_memory_pool()
+                    if pool.used_bytes() > free_gpu_memory * 0.75:
+                        pool.free_all_blocks()
+                    gc.collect()
+                    
+            except cp.cuda.memory.OutOfMemoryError:
+                logging.error(f"GPU out of memory at batch {i//batch_size + 1}/{total_batches}")
+                cp.get_default_memory_pool().free_all_blocks()
+                batch_size = max(batch_size // 2, 1)
+                continue
+                
+            except Exception as e:
+                logging.error(f"Error processing batch {i//batch_size + 1}/{total_batches}: {str(e)}")
+                raise
+                
+        try:
+            final_result = cp.concatenate(result)
+            del result
+            del x
+            gc.collect()
+            cp.get_default_memory_pool().free_all_blocks()
+            return final_result
+            
+        except Exception as e:
+            logging.error(f"Error concatenating results: {str(e)}")
+            raise
+            
+    except Exception as e:
+        logging.error(f"Error in transfer_to_gpu: {str(e)}")
+        raise

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork/model_operations_cuda.py

@@ -6,7 +6,7 @@ import pickle
 from scipy import io
 import scipy.io as sio
 import pandas as pd
-
+import gc
 
 def save_model(model_name,
                W,
@@ -207,14 +207,17 @@ def load_model(model_name,
     activation_potentiation = [x for x in activation_potentiation if not (isinstance(x, float) and cp.isnan(x))]
     activation_potentiation = [item for item in activation_potentiation if item != ''] 
 
-    scaler_params = df['STANDARD SCALER'].tolist()
+    scaler_params_cpu = df['STANDARD SCALER'].tolist()
     
     try:
-        if scaler_params[0] == None:
-            scaler_params = scaler_params[0]
+        if scaler_params_cpu[0] == None: # model not scaled
+            scaler_params = scaler_params_cpu[0]
 
     except:
-        scaler_params = [item for item in scaler_params if isinstance(item, cp.ndarray)]
+        scaler_params = cp.array(scaler_params_cpu)
+        del scaler_params_cpu
+        gc.collect()
+        scaler_params = [item for item in scaler_params if isinstance(item, cp.ndarray)] # model scaled
 
      
     model_name = str(df['MODEL NAME'].iloc[0])

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork/plan_cuda.py

@@ -299,7 +299,7 @@ def learner(x_train, y_train, x_test=None, y_test=None, strategy='accuracy', bat
         x_test_batch, y_test_batch = batcher(x_test, y_test, batch_size=batch_size)
         W = fit(x_train, y_train, activation_potentiation=best_activations, 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=activations, dtype=dtype)
-
+        
         if loss == 'categorical_crossentropy':
             test_loss = categorical_crossentropy(y_true_batch=y_test_batch, y_pred_batch=model[get_preds_softmax()])
         else:

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork/visualizations_cuda.py

@@ -348,8 +348,8 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     acc = acc_list[len(acc_list) - 1]
     y_true = decode_one_hot(y_test)
 
-    y_true = cp.array(y_true)
-    y_preds = cp.array(y_preds)
+    y_true = cp.array(y_true, copy=False)
+    y_preds = cp.array(y_preds, copy=False)
     Class = cp.unique(decode_one_hot(y_test))
 
     precision, recall, f1 = metrics(y_test, y_preds)
@@ -358,7 +358,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     cm = confusion_matrix(y_true, y_preds, len(Class))
     fig, axs = plt.subplots(2, 2, figsize=(16, 12))
 
-    sns.heatmap(cm, annot=True, fmt='d', ax=axs[0, 0])
+    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")
@@ -393,7 +393,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
             fpr, tpr, thresholds = roc_curve(y_true_copy, y_preds_copy)
             
             roc_auc = cp.trapz(tpr, fpr)
-            axs[1, 0].plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
+            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])
@@ -405,7 +405,7 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     
 
     metric = ['Precision', 'Recall', 'F1 Score', 'Accuracy']
-    values = [precision, recall, f1, acc]
+    values = [precision, recall, f1, acc.get()]
     colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']
     
     
@@ -432,35 +432,29 @@ def plot_evaluate(x_test, y_test, y_preds, acc_list, W, activation_potentiation)
     
     grid = cp.c_[xx.ravel(), yy.ravel()]
 
-    try:
-
-        grid_full = cp.zeros((grid.shape[0], x_test.shape[1]))
-        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)
+    grid_full = cp.zeros((grid.shape[0], x_test.shape[1]), dtype=cp.float32)
+    grid_full[:, feature_indices] = grid
+    
+    Z = [None] * len(grid_full)
 
-        for i in range(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)
 
-            Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
-            predict_progress.update(1)
+    for i in range(len(grid_full)):
 
-        predict_progress.close()
+        Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
+        predict_progress.update(1)
 
-        Z = cp.array(Z)
-        Z = Z.reshape(xx.shape)
+    predict_progress.close()
 
-        axs[1,1].contourf(xx, yy, Z, alpha=0.8)
-        axs[1,1].scatter(x_test[:, feature_indices[0]], x_test[:, feature_indices[1]], c=decode_one_hot(y_test), 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')
+    Z = cp.array(Z)
+    Z = Z.reshape(xx.shape)
 
-    except Exception as e:
-        # Hata meydana geldiğinde yapılacak işlemler
-        print(f"Hata oluştu: {e}")
+    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()
 
@@ -487,13 +481,13 @@ def plot_decision_boundary(x, y, activation_potentiation, W, artist=None, ax=Non
     for i in range(len(grid_full)):
         Z[i] = cp.argmax(predict_model_ram(grid_full[i], W=W, activation_potentiation=activation_potentiation))
 
-    Z = cp.array(Z)
+    Z = cp.array(Z, dtype=cp.int32)
     Z = Z.reshape(xx.shape)
 
     if ax is None:
 
-        plt.contourf(xx, yy, Z, alpha=0.8)
-        plt.scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
+        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')
@@ -503,8 +497,8 @@ def plot_decision_boundary(x, y, activation_potentiation, W, artist=None, ax=Non
     else:
 
         try:
-            art1_1 = ax[1, 0].contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax[1, 0].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
+            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')
@@ -513,11 +507,11 @@ def plot_decision_boundary(x, y, activation_potentiation, W, artist=None, ax=Non
         
         except:
 
-            art1_1 = ax[0].contourf(xx, yy, Z, alpha=0.8)
-            art1_2 = ax[0].scatter(x[:, feature_indices[0]], x[:, feature_indices[1]], c=decode_one_hot(y), edgecolors='k', marker='o', s=20, alpha=0.9)
-            ax[0].set_xlabel(f'Feature {0 + 1}')
-            ax[0].set_ylabel(f'Feature {1 + 1}')
-            ax[0].set_title('Decision Boundary')
+            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
@@ -558,7 +552,7 @@ def plot_decision_space(x, y, y_preds=None, s=100, color='tab20'):
             if y_preds[i] == cls:
                 class_points.append(X_pca[i])
         
-        class_points = cp.array(class_points)
+        class_points = cp.array(class_points, dtype=y.dtype)
         
 
         if len(class_points) > 2:
@@ -604,7 +598,7 @@ def neuron_history(LTPW, ax1, row, col, class_count, artist5, data, fig1, acc=Fa
 
 def initialize_visualization_for_fit(val, show_training, neurons_history, x_train, y_train):
     """Initializes the visualization setup based on the parameters."""
-    from .data_operations import find_closest_factors
+    from .data_operations_cuda import find_closest_factors
     visualization_objects = {}
 
     if show_training:
@@ -640,7 +634,7 @@ def initialize_visualization_for_fit(val, show_training, neurons_history, x_trai
 
 def update_weight_visualization_for_fit(ax, LTPW, artist2):
     """Updates the weight visualization plot."""
-    art2 = ax.imshow(LTPW, interpolation='sinc', cmap='viridis')
+    art2 = ax.imshow(LTPW.get(), interpolation='sinc', cmap='viridis')
     artist2.append([art2])
 
 
@@ -680,7 +674,7 @@ def display_visualization_for_fit(fig, artist_list, interval):
 
 def initialize_visualization_for_learner(show_history, neurons_history, neural_web_history, x_train, y_train):
     """Initialize all visualization components"""
-    from .data_operations import find_closest_factors
+    from .data_operations_cuda import find_closest_factors
     viz_objects = {}
     
     if show_history:
@@ -728,7 +722,7 @@ def update_history_plots_for_learner(viz_objects, depth_list, loss_list, best_ac
     hist = viz_objects['history']
     
     # Loss plot
-    art1 = hist['ax'][0].plot(depth_list, loss_list, color='r', markersize=6, linewidth=2)
+    art1 = hist['ax'][0].plot(depth_list.get(), loss_list.get(), color='r', markersize=6, linewidth=2)
     hist['ax'][0].set_title('Test Loss Over Depth')
     hist['artist1'].append(art1)
     

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 4.1.3
+Version: 4.1.5
 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
@@ -11,7 +11,11 @@ Description-Content-Type: text/markdown
 
 Note: anaplan old name of pyerualjetwork
 
-https://libraries.io/pypi/pyerualjetwork
+Libraries.io Page: https://libraries.io/pypi/pyerualjetwork
+
+PyPi Page: https://pypi.org/project/pyerualjetwork/
+
+GitHub Page: https://github.com/HCB06/PyerualJetwork
 
 
       pip install pyerualjetwork
@@ -53,6 +57,11 @@ PyerualJetwork is a machine learning library written in Python for professionals
 Both the PLAN 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. PyerualJetwork is written in fully functional programming with non-oop elements. PyerualJetwork consists of many functions that complement each other, which facilitates the learning process and debugging during use.
 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:
+
+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>

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/pyerualjetwork.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ pyerualjetwork/data_operations_cuda.py
 pyerualjetwork/help.py
 pyerualjetwork/loss_functions.py
 pyerualjetwork/loss_functions_cuda.py
+pyerualjetwork/memory_operations.py
 pyerualjetwork/metrics.py
 pyerualjetwork/metrics_cuda.py
 pyerualjetwork/model_operations.py

{pyerualjetwork-4.1.3 → pyerualjetwork-4.1.5}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 # Setting Up
 setup(
     name="pyerualjetwork",
-    version="4.1.3",
+    version="4.1.5",
     author="Hasan Can Beydili",
     author_email="tchasancan@gmail.com",
     description=(