pyerualjetwork 5.48__tar.gz → 5.48a0__tar.gz

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5.48
+Version: 5.48a0
 Summary: PyereualJetwork is a GPU-accelerated machine learning library in Python for professionals and researchers. It features PLAN, MLP, Deep Learning training, and ENE (Eugenic NeuroEvolution) for genetic optimization, applicable to genetic algorithms or Reinforcement Learning (RL). The library includes data pre-processing, visualizations, model saving/loading, prediction, evaluation, training, and detailed or simplified memory management.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork/__init__.py

@@ -42,7 +42,7 @@ PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welco
 - Contact: tchasancan@gmail.com
 """
 
-__version__ = "5.48"
+__version__ = "5.48a0"
 __update__ = """* Changes: https://github.com/HCB06/PyerualJetwork/blob/main/CHANGES
 * PyerualJetwork Homepage: https://github.com/HCB06/PyerualJetwork/tree/main
 * PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork/cpu/activation_functions.py

@@ -200,6 +200,18 @@ def sine_offset(x, beta=0.0):
     return np.sin(x + beta)
 
 
+def apply_activation_derivative(x, name):
+    if name == 'sigmoid':
+        s = apply_activation(x, 'sigmoid')
+        return s * (1 - s)
+    elif name == 'relu':
+        return (x > 0).astype(float)
+    elif name == 'tanh':
+        return 1 - np.tanh(x) ** 2
+    else:
+        raise ValueError(f"Unknown activation derivative: {name}")
+    
+
 def apply_activation(Input, activation_list):
     """
     Applies activation functions for inputs
@@ -251,4 +263,5 @@ def apply_activation(Input, activation_list):
         
     except Exception as e:
         warnings.warn(f"Error in activation processing: {str(e)}", RuntimeWarning)
-        return Input
+        return Input
+        

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork/cpu/data_ops.py

@@ -436,12 +436,12 @@ def find_closest_factors(a):
             return i, j
         
 
-def batcher(x, y, batch_size=1):
+def batcher(x_test, y_test, batch_size=1):
 
     if batch_size == 1:
-        return x, y
+        return x_test, y_test
     
-    y_labels = np.argmax(y, axis=1)
+    y_labels = np.argmax(y_test, axis=1)
 
     sampled_x, sampled_y = [], []
     
@@ -453,7 +453,7 @@ def batcher(x, y, batch_size=1):
         
         sampled_indices = np.random.choice(class_indices, num_samples, replace=False)
         
-        sampled_x.append(x[sampled_indices])
-        sampled_y.append(y[sampled_indices])
+        sampled_x.append(x_test[sampled_indices])
+        sampled_y.append(y_test[sampled_indices])
 
     return np.concatenate(sampled_x), np.concatenate(sampled_y)

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork/cpu/loss_functions.py

@@ -18,4 +18,14 @@ def binary_crossentropy(y_true_batch, y_pred_batch):
     losses = -np.mean(y_true_batch * np.log(y_pred_batch) + (1 - y_true_batch) * np.log(1 - y_pred_batch), axis=1)
 
     mean_loss = np.mean(losses)
-    return mean_loss
+    return mean_loss
+
+def categorical_crossentropy_derivative(y_true, y_pred):
+    epsilon = 1e-7
+    y_pred = np.clip(y_pred, epsilon, 1. - epsilon)
+    return - (y_true / y_pred)
+
+def binary_crossentropy_derivative(y_true, y_pred):
+    epsilon = 1e-7
+    y_pred = np.clip(y_pred, epsilon, 1. - epsilon)
+    return (y_pred - y_true) / (y_pred * (1 - y_pred))

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork/cuda/data_ops.py

@@ -484,20 +484,20 @@ def find_closest_factors(a):
             j = a // i
             return i, j
         
-def batcher(x, y, batch_size=1):
+def batcher(x_test, y_test, batch_size=1):
 
     if batch_size == 1:
-        return x, y
+        return x_test, y_test
 
-    y_labels = cp.argmax(y, axis=1)
+    y_labels = cp.argmax(y_test, axis=1)
     
     unique_labels = cp.unique(y_labels)
     total_samples = sum(
         int(cp.sum(y_labels == class_label) * batch_size) for class_label in unique_labels
     )
     
-    sampled_x = cp.empty((total_samples, x.shape[1]), dtype=x.dtype)
-    sampled_y = cp.empty((total_samples, y.shape[1]), dtype=y.dtype)
+    sampled_x = cp.empty((total_samples, x_test.shape[1]), dtype=x_test.dtype)
+    sampled_y = cp.empty((total_samples, y_test.shape[1]), dtype=y_test.dtype)
     
     offset = 0
     for class_label in unique_labels:
@@ -507,8 +507,8 @@ def batcher(x, y, batch_size=1):
         
         sampled_indices = cp.random.choice(class_indices, num_samples, replace=False)
         
-        sampled_x[offset:offset + num_samples] = x[sampled_indices]
-        sampled_y[offset:offset + num_samples] = y[sampled_indices]
+        sampled_x[offset:offset + num_samples] = x_test[sampled_indices]
+        sampled_y[offset:offset + num_samples] = y_test[sampled_indices]
 
         offset += num_samples
     

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork/nn.py

@@ -198,7 +198,8 @@ def learn(x_train, y_train, optimizer, template_model, gen, pop_size, fit_start=
         tuple: A list for model parameters: [Weight matrix, Train Preds, Train Accuracy, [Activations functions]].
     """
 
-    from .ene import define_genomes
+    from .optimizers.ene import define_genomes
+    from .optimizers.backprop import backprop_update_general
     from .cpu.visualizations import display_decision_boundary_history, create_decision_boundary_hist, plot_decision_boundary
 
     if cuda is False: 
@@ -351,10 +352,13 @@ def learn(x_train, y_train, optimizer, template_model, gen, pop_size, fit_start=
         progress.last_print_n = 0
         progress.update(0)
 
+        x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
+
+        if optimizer == 'backprop':
+            pop_size = 1
+
         for j in range(pop_size):
             
-            x_train_batch, y_train_batch = batcher(x_train, y_train, batch_size=batch_size)
-
             if fit_start is True and i == 0:
                 if start_this_act is not None and j == 0:
                     pass
@@ -369,6 +373,12 @@ def learn(x_train, y_train, optimizer, template_model, gen, pop_size, fit_start=
                 weight_pop[j] = plan_fit(x_train_batch, y_train_batch, activations=act_pop[j], cuda=cuda, auto_normalization=auto_normalization, dtype=dtype)
 
 
+            if optimizer == 'backprop':
+                weight_pop[0], current_loss = backprop_update_general(
+                x_train_batch, y_train_batch, weight_pop[0], act_pop[0],
+                learning_rate=0.01
+            )
+            
             model = evaluate(x_train_batch, y_train_batch, W=weight_pop[j], activations=act_pop[j], activation_potentiations=activation_potentiations[j], auto_normalization=auto_normalization, cuda=cuda, model_type=model_type)
             acc = model[get_acc()]
             
@@ -529,8 +539,9 @@ def learn(x_train, y_train, optimizer, template_model, gen, pop_size, fit_start=
         if model_type == 'PLAN': weight_pop = np.array(weight_pop, copy=False, dtype=dtype)
         else: weight_pop = np.array(weight_pop, copy=False, dtype=object)
 
-        weight_pop, act_pop = optimizer(weight_pop, act_pop, i, np.array(target_pop, dtype=dtype, copy=False), weight_evolve=weight_evolve, is_mlp=is_mlp, bar_status=False)
-        target_pop = []
+        if optimizer != 'backprop':
+            weight_pop, act_pop = optimizer(weight_pop, act_pop, i, np.array(target_pop, dtype=dtype, copy=False), weight_evolve=weight_evolve, is_mlp=is_mlp, bar_status=False)
+            target_pop = []
 
         # Early stopping check
         if early_stop == True and i > 0:

pyerualjetwork-5.48a0/pyerualjetwork/optimizers/__init__.py

@@ -0,0 +1,43 @@
+""" 
+
+Optimizers
+==============
+PyereualJetwork is a large wide GPU-accelerated machine learning library in Python designed for professionals and researchers.
+It features PLAN, MLP Deep Learning and PTNN training, as well as ENE (Eugenic NeuroEvolution) for genetic optimization, 
+which can also be applied to genetic algorithms or Reinforcement Learning (RL) problems. 
+The library includes functions for data pre-processing, visualizations, model saving and loading, prediction and evaluation, 
+training, and both detailed and simplified memory management.
+
+
+PyerualJetwork Main Modules:
+----------------------------
+- nn
+- ene
+- model_ops
+
+CPU Main Modules:
+---------------------------
+- cpu.data_ops
+
+GPU Main Modules:
+---------------------------
+- cuda.data_ops
+
+Memory Module:
+--------------
+- memory_ops
+
+Issue Solver Module:
+--------------
+- issue_solver
+
+Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
+
+PyerualJetwork document: https://github.com/HCB06/PyerualJetwork/blob/main/Welcome_to_PyerualJetwork/PYERUALJETWORK_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf
+
+- 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
+- Contact: tchasancan@gmail.com
+"""

pyerualjetwork-5.48a0/pyerualjetwork/optimizers/backprop.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+from ..cpu.loss_functions import categorical_crossentropy, categorical_crossentropy_derivative
+from ..cpu.activation_functions import apply_activation, apply_activation_derivative
+
+def backprop_update_general(
+    X, y, weights, activations_list,
+    learning_rate=0.01
+):
+    """
+    X: (batch_size, input_dim)
+    y: (batch_size, output_dim)
+    weights: numpy object array, her eleman (in_dim, out_dim) şeklinde ağırlık matrisi
+    activations_list: her katman için aktivasyon ismi listesi (örn: ['relu', 'sigmoid', 'softmax'])
+    apply_activation: x ve aktivasyon adı alır, çıktı verir
+    apply_activation_derivative: x ve aktivasyon adı alır, türev verir
+    loss_function: y_true ve y_pred alır, loss döner
+    loss_derivative: y_true ve y_pred alır, d_loss/d_y_pred döner
+    learning_rate: öğrenme oranı
+    """
+    num_layers = len(weights) + 1
+    activations = [X]
+    inputs = []
+    
+    # Forward pass
+    for i, w in enumerate(weights):
+        inp = np.dot(activations[-1], w)
+        out = apply_activation(inp, activations_list[i])
+        inputs.append(inp)
+        activations.append(out)
+    
+    y_pred = activations[-1]
+    loss = categorical_crossentropy(y, y_pred)
+    
+    # Calculate output error (using provided derivative)
+    error = categorical_crossentropy_derivative(y, y_pred)
+    deltas = [error * apply_activation_derivative(inputs[-1], activations_list[-1])]
+    
+    # Backpropagate
+    for i in reversed(range(len(weights) - 1)):
+        delta = np.dot(deltas[0], weights[i + 1].T) * apply_activation_derivative(inputs[i], activations_list[i])
+        deltas.insert(0, delta)
+    
+    # Update weights
+    for i in range(len(weights)):
+        weights[i] += learning_rate * np.dot(activations[i].T, deltas[i])
+    
+    return weights, loss

{pyerualjetwork-5.48/pyerualjetwork → pyerualjetwork-5.48a0/pyerualjetwork/optimizers}/ene.py

@@ -1,4 +1,4 @@
-""" 
+"""
 
 
 ENE (Eugenic NeuroEvolution)
@@ -33,9 +33,9 @@ import math
 import copy
 
 ### LIBRARY IMPORTS ###
-from .cpu.data_ops import non_neg_normalization
-from .ui import loading_bars, initialize_loading_bar
-from .cpu.activation_functions import all_activations
+from ..cpu.data_ops import non_neg_normalization
+from ..ui import loading_bars, initialize_loading_bar
+from ..cpu.activation_functions import all_activations
 
 def define_genomes(input_shape, output_shape, population_size, neurons=[], activation_functions=[], dtype=np.float32):
    """

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyerualjetwork
-Version: 5.48
+Version: 5.48a0
 Summary: PyereualJetwork is a GPU-accelerated machine learning library in Python for professionals and researchers. It features PLAN, MLP, Deep Learning training, and ENE (Eugenic NeuroEvolution) for genetic optimization, applicable to genetic algorithms or Reinforcement Learning (RL). The library includes data pre-processing, visualizations, model saving/loading, prediction, evaluation, training, and detailed or simplified memory management.
 Author: Hasan Can Beydili
 Author-email: tchasancan@gmail.com

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/pyerualjetwork.egg-info/SOURCES.txt

@@ -1,8 +1,6 @@
 README.md
-setup.cfg
 setup.py
 pyerualjetwork/__init__.py
-pyerualjetwork/ene.py
 pyerualjetwork/fitness_functions.py
 pyerualjetwork/help.py
 pyerualjetwork/issue_solver.py
@@ -27,4 +25,7 @@ pyerualjetwork/cuda/activation_functions.py
 pyerualjetwork/cuda/data_ops.py
 pyerualjetwork/cuda/loss_functions.py
 pyerualjetwork/cuda/metrics.py
-pyerualjetwork/cuda/visualizations.py
+pyerualjetwork/cuda/visualizations.py
+pyerualjetwork/optimizers/__init__.py
+pyerualjetwork/optimizers/backprop.py
+pyerualjetwork/optimizers/ene.py

{pyerualjetwork-5.48 → pyerualjetwork-5.48a0}/setup.py

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