pyerualjetwork 2.2.8__tar.gz → 2.3.8__tar.gz

pyerualjetwork-2.3.8/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pyerualjetwork
+Version: 2.3.8
+Summary: Weights post process function added: [weight_post_process](optional after training before testing.), new function: manuel_balancer. And scaler_params added for scaled models.
+Author: Hasan Can Beydili
+Author-email: tchasancan@gmail.com
+Keywords: model evaluation,classifcation,pruning learning artficial neural networks

{pyerualjetwork-2.2.8 → pyerualjetwork-2.3.8}/plan_bi/__init__.py

@@ -2,4 +2,4 @@
 
 # Bu dosya, plan modülünün ana giriş noktasıdır.
 
-from .plan_bi import auto_balancer, normalization, Softmax, Sigmoid, Relu, weight_identification, fex, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, get_pot, synthetic_augmentation, standard_scaler, multiple_evaluate, encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate
+from .plan_bi import auto_balancer, normalization, Softmax, Sigmoid, Relu, weight_identification, fex, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, get_pot, synthetic_augmentation, standard_scaler, multiple_evaluate, encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate, manuel_balancer, weight_normalization

{pyerualjetwork-2.2.8 → pyerualjetwork-2.3.8}/plan_bi/plan_bi.py

@@ -17,6 +17,7 @@ def fit(
     x_train: List[Union[int, float]],
     y_train: List[Union[int, float, str]], # At least two.. and one hot encoded
     activation_potential: Union[float],
+    show_training
 ) -> str:
         
     infoPLAN = """
@@ -26,6 +27,7 @@ def fit(
         x_train (list[num]): List of input data.
         y_train (list[num]): List of y_train. (one hot encoded)
         activation_potential (float): Input activation potential 
+        show_training (bool, str): True, None or 'final'
     
     Returns:
         list([num]): (Weight matrices list, train_predictions list, Train_acc).
@@ -85,6 +87,34 @@ def fit(
         
         for i, w in enumerate(W):
             trained_W[i] = trained_W[i] + w
+            
+                          if show_training == True:
+                                       
+                    fig, ax = plt.subplots(1, 10, figsize=(18, 14))
+                    
+                    try:
+                        row = x_train[1].shape[0]
+                        col = x_train[1].shape[1]
+                    except:
+                        print(Fore.RED + 'ERROR: You try train showing but inputs is raveled. x_train inputs to must be reshape for training_show.', infoPLAN + Style.RESET_ALL)
+                        return 'e'
+                        
+                    for j in range(10):
+                          
+                
+                        mat = trained_W[0][j,:].reshape(row, col)
+                        
+
+                    
+                        ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
+                        ax[j].set_aspect('equal')
+                        
+                        ax[j].set_xticks([])
+                        ax[j].set_yticks([])  
+                        ax[j].set_title(f'{j+1}. Neuron')
+                        
+
+                    plt.show()
 
          
         W = weight_identification(len(layers) - 1, len(class_count), neurons, x_train_size)
@@ -127,6 +157,27 @@ def fit(
     trained_W.append(np.eye(len(class_count)))
     
     return trained_W
+    
+def weight_normalization(
+    W,
+    class_count
+) -> str:
+    """
+    Row(Neuron) based normalization. For unbalanced models.
+
+    Args:
+            W (list(num)): Trained weight matrix list.
+            class_count (int): Class count of model.
+
+    Returns:
+        list([numpy_arrays],[...]): posttrained weight matices of the model. .
+    """
+
+    for i in range(class_count):
+        
+            W[0][i,:] = normalization(W[0][i,:])
+    
+    return W
         
 # FUNCTIONS -----
 
@@ -528,7 +579,7 @@ def save_model(model_name,
              weights_type,
              weights_format,
              model_path,
-             scaler,
+             scaler_params,
              W
  ):
     
@@ -544,7 +595,7 @@ def save_model(model_name,
     weights_type (str): Type of weights to save (options: 'txt', 'npy', 'mat').
     WeightFormat (str): Format of the weights (options: 'd', 'f', 'raw').
     model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/
-    scaler (bool): trained data it used standard_scaler ? (True or False)
+    scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W: Weights list of the model.
     
     Returns:
@@ -592,7 +643,7 @@ def save_model(model_name,
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
             'MODEL PATH': model_path,
-            'STANDARD SCALER': scaler
+            'STANDARD SCALER': scaler_params
             }
     try:
         
@@ -742,11 +793,11 @@ def predict_model_ssd(Input, model_name, model_path):
     """
     W, activation_potential, df = load_model(model_name,model_path)
     
-    scaler = str(df['STANDARD SCALER'].iloc[0])
+    scaler_params = str(df['STANDARD SCALER'].iloc[0])
 
-    if scaler == 'True':
+    if scaler_params != None:
 
-        Input = standard_scaler(Input, None)
+        Input = standard_scaler(None, Input, scaler_params)
     
     layers = ['fex','cat']
     
@@ -773,7 +824,7 @@ def predict_model_ssd(Input, model_name, model_path):
     return neural_layer
 
 
-def predict_model_ram(Input, activation_potential, scaler, W):
+def predict_model_ram(Input, activation_potential, scaler_params, W):
     
     infopredict_model_ram = """
     Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
@@ -782,15 +833,15 @@ def predict_model_ram(Input, activation_potential, scaler, W):
     Arguments:
     Input (list or ndarray): Input data for the model (single vector or single matrix).
     activation_potential (float): Activation potential.
-    scaler (bool): trained data it used standard_scaler ? (True or False)
+    scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W (list of ndarrays): Weights of the model.
 
     Returns:
     ndarray: Output from the model.
     """
-    if scaler == True:
+    if scaler_params != None:
 
-       Input = standard_scaler(Input, None)
+       Input = standard_scaler(None, Input, scaler_params)
     
     layers = ['fex','cat']
     
@@ -917,7 +968,7 @@ def synthetic_augmentation(x_train, y_train):
     return np.array(x_balanced), np.array(y_balanced)
 
 
-def standard_scaler(x_train, x_test):
+def standard_scaler(x_train, x_test, scaler_params=None):
     info_standard_scaler = """
   Standardizes training and test datasets. x_test may be None.
 
@@ -928,29 +979,42 @@ def standard_scaler(x_train, x_test):
       Test data
 
   Returns:
+    list:
+    Scaler parameters: mean and std
     tuple
       Standardized training and test datasets
   """
     try:
-
-        mean = np.mean(x_train, axis=0)
-        std = np.std(x_train, axis=0)
-
-        if x_test == None:
-
-            train_data_scaled = (x_train - mean) / std
-            return train_data_scaled
-
-        else:
-            train_data_scaled = (x_train - mean) / std
-            test_data_scaled = (x_test - mean) / std
-            return train_data_scaled, test_data_scaled
+            
+            if scaler_params == None and x_test != None:
+                
+                mean = np.mean(x_train, axis=0)
+                std = np.std(x_train, axis=0)
+                train_data_scaled = (x_train - mean) / std
+                test_data_scaled = (x_test - mean) / std
+                
+                scaler_params = [mean, std]
+                
+                return scaler_params, train_data_scaled, test_data_scaled
+            
+            if scaler_params == None and x_test == None:
+                
+                mean = np.mean(x_train, axis=0)
+                std = np.std(x_train, axis=0)
+                train_data_scaled = (x_train - mean) / std
+                
+                scaler_params = [mean, std]
+                
+                return scaler_params, train_data_scaled
+                
+            if scaler_params != None:
+                test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
+                return test_data_scaled
 
     except:
         print(
             Fore.RED + "ERROR: x_train and x_test must be list[numpyarray] from standard_scaler" + info_standard_scaler)
 
-
 def encode_one_hot(y_train, y_test):
     info_one_hot_encode = """
     Performs one-hot encoding on y_train and y_test data..
@@ -1304,7 +1368,7 @@ def plot_evaluate(y_test, y_preds, acc_list):
     axs[0, 1].set_ylim(0, 1)  # Y eksenini 0 ile 1 arasında sınırla
     axs[0, 1].set_xlabel('Metrics')
     axs[0, 1].set_ylabel('Score')
-    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Wighted)')
+    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
     axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
     
                # Accuracy
@@ -1324,6 +1388,103 @@ def plot_evaluate(y_test, y_preds, acc_list):
     plt.tight_layout()
     plt.show()
    
+   
+def manuel_balancer(x_train, y_train, target_samples_per_class):
+    """
+    Generates synthetic examples to balance classes to the specified number of examples per class.
+
+    Arguments:
+    x_train -- Input dataset (examples) - NumPy array format
+    y_train -- Class labels (one-hot encoded) - NumPy array format
+    target_samples_per_class -- Desired number of samples per class
+
+    Returns:
+    x_balanced -- Balanced input dataset (NumPy array format)
+    y_balanced -- Balanced class labels (one-hot encoded, NumPy array format)
+    """
+    start_time = time.time()
+    x_train = np.array(x_train)
+    y_train = np.array(y_train)
+    classes = np.arange(y_train.shape[1])
+    class_count = len(classes)
+    
+    x_balanced = []
+    y_balanced = []
+
+    for class_label in range(class_count):
+        class_indices = np.where(np.argmax(y_train, axis=1) == class_label)[0]
+        num_samples = len(class_indices)
+        
+        if num_samples > target_samples_per_class:
+      
+            selected_indices = np.random.choice(class_indices, target_samples_per_class, replace=False)
+            x_balanced.append(x_train[selected_indices])
+            y_balanced.append(y_train[selected_indices])
+            
+        else:
+            
+            x_balanced.append(x_train[class_indices])
+            y_balanced.append(y_train[class_indices])
+
+            if num_samples < target_samples_per_class:
+                
+                samples_to_add = target_samples_per_class - num_samples
+                additional_samples = np.zeros((samples_to_add, x_train.shape[1]))
+                additional_labels = np.zeros((samples_to_add, y_train.shape[1]))
+                
+                for i in range(samples_to_add):
+                    uni_start_time = time.time()
+                    
+                    random_indices = np.random.choice(class_indices, 2, replace=False)
+                    sample1 = x_train[random_indices[0]]
+                    sample2 = x_train[random_indices[1]]
+
+                    
+                    synthetic_sample = sample1 + (sample2 - sample1) * np.random.rand()
+
+                    additional_samples[i] = synthetic_sample
+                    additional_labels[i] = y_train[class_indices[0]]
+                    
+                    uni_end_time = time.time()
+                    calculating_est = round(
+               (uni_end_time - uni_start_time) * (samples_to_add - i), 3)
+    
+                    if calculating_est < 60:
+                        print('\rest......(sec):', calculating_est, '\n', end="")
+             
+                    elif calculating_est > 60 and calculating_est < 3600:
+                        print('\rest......(min):', calculating_est/60, '\n', end="")
+             
+                    elif calculating_est > 3600:
+                        print('\rest......(h):', calculating_est/3600, '\n', end="")
+             
+                    print('Augmenting: ', class_label, '/', class_count, '...', i, "/", samples_to_add, "\n", end="")
+
+                x_balanced.append(additional_samples)
+                y_balanced.append(additional_labels)
+                   
+
+    EndTime = time.time()
+
+    calculating_est = round(EndTime - start_time, 2)
+ 
+    print(Fore.GREEN + " \nBalancing Finished with 0 ERROR\n" + Style.RESET_ALL)
+ 
+    if calculating_est < 60:
+        print('Total balancing time(sec): ', calculating_est)
+ 
+    elif calculating_est > 60 and calculating_est < 3600:
+        print('Total balancing time(min): ', calculating_est/60)
+ 
+    elif calculating_est > 3600:
+        print('Total balancing time(h): ', calculating_est/3600)
+    
+    # Stack the balanced arrays
+    x_balanced = np.vstack(x_balanced)
+    y_balanced = np.vstack(y_balanced)
+
+    return x_balanced, y_balanced  
+
 def get_weights():
         
     return 0

{pyerualjetwork-2.2.8 → pyerualjetwork-2.3.8}/plan_di/__init__.py

@@ -2,4 +2,4 @@
 
 # Bu dosya, plan modülünün ana giriş noktasıdır.
 
-from .plan_di import auto_balancer, normalization, Softmax, Sigmoid, Relu, weight_identification, fex, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, synthetic_augmentation, standard_scaler, multiple_evaluate, encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate
+from .plan_di import auto_balancer, normalization, Softmax, Sigmoid, Relu, weight_identification, fex, fit, evaluate, save_model, load_model, predict_model_ssd, predict_model_ram, get_weights, get_df, get_preds, get_acc, synthetic_augmentation, standard_scaler, multiple_evaluate, encode_one_hot, split, metrics, decode_one_hot, roc_curve, confusion_matrix, plot_evaluate, manuel_balancer, weight_normalization

{pyerualjetwork-2.2.8 → pyerualjetwork-2.3.8}/plan_di/plan_di.py

@@ -21,7 +21,8 @@ import seaborn as sns
 def fit(
     x_train: List[Union[int, float]],
     # At least two.. and one hot encoded
-    y_train: List[Union[int, float, str]],
+    y_train: List[Union[int, float, str]], # At least two.. and one hot encoded
+    show_training
 ) -> str:
 
     infoPLAN = """
@@ -30,7 +31,7 @@ def fit(
     Args:
         x_train (list[num]): List of input data.
         y_train (list[num]): List of y_train. (one hot encoded)
-        activation_potential (float): Input activation potential 
+        show_training (bool, str): True, None or 'final'
     
     Returns:
         list([num]): (Weight matrices list, train_predictions list, Train_acc).
@@ -57,13 +58,14 @@ def fit(
     x_train[0] = x_train[0].ravel()
     x_train_size = len(x_train[0])
 
-    W = weight_identification(
+    W = pdi.weight_identification(
         len(layers) - 1, len(class_count), neurons, x_train_size)
 
     trained_W = [1] * len(W)
     print(Fore.GREEN + "Train Started with 0 ERROR" + Style.RESET_ALL)
     start_time = time.time()
-    y = decode_one_hot(y_train)
+    y = pdi.decode_one_hot(y_train)
+
     for index, inp in enumerate(x_train):
         uni_start_time = time.time()
         inp = np.array(inp)
@@ -78,15 +80,40 @@ def fit(
 
         for Lindex, Layer in enumerate(layers):
 
-            neural_layer = normalization(neural_layer)
+            neural_layer = pdi.normalization(neural_layer)
 
             if Layer == 'fex':
-                W[Lindex] = fex(neural_layer, W[Lindex], True, y[index])
+                W[Lindex] = pdi.fex(neural_layer, W[Lindex], True, y[index])
 
         for i, w in enumerate(W):
                 trained_W[i] = trained_W[i] + w
 
-        W = weight_identification(
+                if show_training == True:
+                                       
+                    fig, ax = plt.subplots(1, 10, figsize=(18, 14))
+                    
+                    try:
+                        row = x_train[1].shape[0]
+                        col = x_train[1].shape[1]
+                    except:
+                        print(Fore.RED + 'ERROR: You try train showing but inputs is raveled. x_train inputs to must be reshape for training_show.', infoPLAN + Style.RESET_ALL)
+                        return 'e'
+                        
+                    for j in range(10):
+             
+                        mat = trained_W[0][j,:].reshape(row, col)
+   
+                        ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
+                        ax[j].set_aspect('equal')
+                        
+                        ax[j].set_xticks([])
+                        ax[j].set_yticks([])  
+                        ax[j].set_title(f'{j+1}. Neuron')
+               
+               
+                    plt.show()
+                                            
+        W = pdi.weight_identification(
             len(layers) - 1, len(class_count), neurons, x_train_size)
 
         uni_end_time = time.time()
@@ -105,6 +132,31 @@ def fit(
 
         print('\rTraining: ', index, "/", len(x_train), "\n", end="")
 
+    if show_training == 'final':
+        
+        fig, ax = plt.subplots(1, 10, figsize=(18, 14))
+        
+        try:
+            row = x_train[1].shape[0]
+            col = x_train[1].shape[1]
+        except:
+            print(Fore.RED + 'ERROR: You try train showing but inputs is raveled. x_train inputs to must be reshape for training_show.', infoPLAN  + Style.RESET_ALL)
+            return 'e'
+            
+        for j in range(10):
+            
+            mat = trained_W[0][j,:].reshape(row, col)
+
+            ax[j].imshow(mat, interpolation='sinc', cmap='viridis')
+            ax[j].set_aspect('equal')  
+           
+            ax[j].set_xticks([])
+            ax[j].set_yticks([]) 
+            ax[j].set_title(f'{j+1}. Neuron')  
+            
+
+        plt.show()
+
     EndTime = time.time()
 
     calculating_est = round(EndTime - start_time, 2)
@@ -122,11 +174,32 @@ def fit(
     
     layers.append('cat')
     trained_W.append(np.eye(len(class_count)))
-
+                
+                
     return trained_W
 
 # FUNCTIONS -----
 
+def weight_normalization(
+    W,
+    class_count
+) -> str:
+    """
+    Row(Neuron) based normalization. For unbalanced models.
+
+    Args:
+            W (list(num)): Trained weight matrix list.
+            class_count (int): Class count of model.
+
+    Returns:
+        list([numpy_arrays],[...]): posttrained weight matices of the model. .
+    """
+
+    for i in range(class_count):
+        
+            W[0][i,:] = normalization(W[0][i,:])
+    
+    return W
 
 def weight_identification(
     layer_count,      # int: Number of layers in the neural network.
@@ -508,7 +581,7 @@ def save_model(model_name,
                weights_type,
                weights_format,
                model_path,
-               scaler,
+               scaler_params,
                W
                ):
 
@@ -523,7 +596,7 @@ def save_model(model_name,
     weights_type (str): Type of weights to save (options: 'txt', 'npy', 'mat').
     WeightFormat (str): Format of the weights (options: 'd', 'f', 'raw').
     model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/
-    scaler (bool): trained data it used standard_scaler ? (True or False)
+    scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W: Weights of the model.
     
     Returns:
@@ -573,7 +646,7 @@ def save_model(model_name,
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
             'MODEL PATH': model_path,
-            'STANDARD SCALER': scaler
+            'STANDARD SCALER': scaler_params
             }
     try:
 
@@ -720,11 +793,11 @@ def predict_model_ssd(Input, model_name, model_path):
     """
     W, df = load_model(model_name, model_path)
 
-    scaler = str(df['STANDARD SCALER'].iloc[0])
+    scaler_params = str(df['STANDARD SCALER'].iloc[0])
 
-    if scaler == 'True':
+    if scaler_params != None:
 
-        Input = standard_scaler(Input, None)
+        Input = standard_scaler(None, Input, scaler_params)
 
     layers = ['fex', 'cat']
 
@@ -752,7 +825,7 @@ def predict_model_ssd(Input, model_name, model_path):
     return neural_layer
 
 
-def predict_model_ram(Input, scaler, W):
+def predict_model_ram(Input, scaler_params, W):
 
     infopredict_model_ram = """
     Function to make a prediction using a divided pruning learning artificial neural network (PLAN).
@@ -760,16 +833,16 @@ def predict_model_ram(Input, scaler, W):
 
     Arguments:
     Input (list or ndarray): Input data for the model (single vector or single matrix).
-    scaler (bool): trained data it used standard_scaler ? (True or False)
+    scaler_params (int, float): standard scaler params list: mean,std. If not used standard scaler then be: None.
     W (list of ndarrays): Weights of the model.
 
     Returns:
     ndarray: Output from the model.
     """
 
-    if scaler == True:
+    if scaler_params != None:
 
-        Input = standard_scaler(Input, None)
+        Input = standard_scaler(None, Input, scaler_params)
 
     layers = ['fex', 'cat']
 
@@ -896,7 +969,7 @@ def synthetic_augmentation(x_train, y_train):
     return np.array(x_balanced), np.array(y_balanced)
 
 
-def standard_scaler(x_train, x_test):
+def standard_scaler(x_train, x_test, scaler_params=None):
     info_standard_scaler = """
   Standardizes training and test datasets. x_test may be None.
 
@@ -907,29 +980,42 @@ def standard_scaler(x_train, x_test):
       Test data
 
   Returns:
+    list:
+    Scaler parameters: mean and std
     tuple
       Standardized training and test datasets
   """
     try:
-
-        mean = np.mean(x_train, axis=0)
-        std = np.std(x_train, axis=0)
-
-        if x_test == None:
-
-            train_data_scaled = (x_train - mean) / std
-            return train_data_scaled
-
-        else:
-            train_data_scaled = (x_train - mean) / std
-            test_data_scaled = (x_test - mean) / std
-            return train_data_scaled, test_data_scaled
+            
+            if scaler_params == None and x_test != None:
+                
+                mean = np.mean(x_train, axis=0)
+                std = np.std(x_train, axis=0)
+                train_data_scaled = (x_train - mean) / std
+                test_data_scaled = (x_test - mean) / std
+                
+                scaler_params = [mean, std]
+                
+                return scaler_params, train_data_scaled, test_data_scaled
+            
+            if scaler_params == None and x_test == None:
+                
+                mean = np.mean(x_train, axis=0)
+                std = np.std(x_train, axis=0)
+                train_data_scaled = (x_train - mean) / std
+                
+                scaler_params = [mean, std]
+                
+                return scaler_params, train_data_scaled
+                
+            if scaler_params != None:
+                test_data_scaled = (x_test - scaler_params[0]) / scaler_params[1]
+                return test_data_scaled
 
     except:
         print(
             Fore.RED + "ERROR: x_train and x_test must be list[numpyarray] from standard_scaler" + info_standard_scaler)
 
-
 def encode_one_hot(y_train, y_test):
     info_one_hot_encode = """
     Performs one-hot encoding on y_train and y_test data..
@@ -1276,7 +1362,7 @@ def plot_evaluate(y_test, y_preds, acc_list):
     axs[0, 1].set_ylim(0, 1)  # Y eksenini 0 ile 1 arasında sınırla
     axs[0, 1].set_xlabel('Metrics')
     axs[0, 1].set_ylabel('Score')
-    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Wighted)')
+    axs[0, 1].set_title('Precision, Recall, F1 Score, and Accuracy (Weighted)')
     axs[0, 1].grid(True, axis='y', linestyle='--', alpha=0.7)
     
                # Accuracy
@@ -1296,6 +1382,102 @@ def plot_evaluate(y_test, y_preds, acc_list):
     plt.tight_layout()
     plt.show()
 
+def manuel_balancer(x_train, y_train, target_samples_per_class):
+    """
+    Generates synthetic examples to balance classes to the specified number of examples per class.
+
+    Arguments:
+    x_train -- Input dataset (examples) - NumPy array format
+    y_train -- Class labels (one-hot encoded) - NumPy array format
+    target_samples_per_class -- Desired number of samples per class
+
+    Returns:
+    x_balanced -- Balanced input dataset (NumPy array format)
+    y_balanced -- Balanced class labels (one-hot encoded, NumPy array format)
+    """
+    start_time = time.time()
+    x_train = np.array(x_train)
+    y_train = np.array(y_train)
+    classes = np.arange(y_train.shape[1])
+    class_count = len(classes)
+    
+    x_balanced = []
+    y_balanced = []
+
+    for class_label in range(class_count):
+        class_indices = np.where(np.argmax(y_train, axis=1) == class_label)[0]
+        num_samples = len(class_indices)
+        
+        if num_samples > target_samples_per_class:
+      
+            selected_indices = np.random.choice(class_indices, target_samples_per_class, replace=False)
+            x_balanced.append(x_train[selected_indices])
+            y_balanced.append(y_train[selected_indices])
+            
+        else:
+            
+            x_balanced.append(x_train[class_indices])
+            y_balanced.append(y_train[class_indices])
+
+            if num_samples < target_samples_per_class:
+                
+                samples_to_add = target_samples_per_class - num_samples
+                additional_samples = np.zeros((samples_to_add, x_train.shape[1]))
+                additional_labels = np.zeros((samples_to_add, y_train.shape[1]))
+                
+                for i in range(samples_to_add):
+                    uni_start_time = time.time()
+                    
+                    random_indices = np.random.choice(class_indices, 2, replace=False)
+                    sample1 = x_train[random_indices[0]]
+                    sample2 = x_train[random_indices[1]]
+
+                    
+                    synthetic_sample = sample1 + (sample2 - sample1) * np.random.rand()
+
+                    additional_samples[i] = synthetic_sample
+                    additional_labels[i] = y_train[class_indices[0]]
+                    
+                    uni_end_time = time.time()
+                    calculating_est = round(
+               (uni_end_time - uni_start_time) * (samples_to_add - i), 3)
+    
+                    if calculating_est < 60:
+                        print('\rest......(sec):', calculating_est, '\n', end="")
+             
+                    elif calculating_est > 60 and calculating_est < 3600:
+                        print('\rest......(min):', calculating_est/60, '\n', end="")
+             
+                    elif calculating_est > 3600:
+                        print('\rest......(h):', calculating_est/3600, '\n', end="")
+             
+                    print('Augmenting: ', class_label, '/', class_count, '...', i, "/", samples_to_add, "\n", end="")
+
+                x_balanced.append(additional_samples)
+                y_balanced.append(additional_labels)
+                   
+
+    EndTime = time.time()
+
+    calculating_est = round(EndTime - start_time, 2)
+ 
+    print(Fore.GREEN + " \nBalancing Finished with 0 ERROR\n" + Style.RESET_ALL)
+ 
+    if calculating_est < 60:
+        print('Total balancing time(sec): ', calculating_est)
+ 
+    elif calculating_est > 60 and calculating_est < 3600:
+        print('Total balancing time(min): ', calculating_est/60)
+ 
+    elif calculating_est > 3600:
+        print('Total balancing time(h): ', calculating_est/3600)
+    
+    # Stack the balanced arrays
+    x_balanced = np.vstack(x_balanced)
+    y_balanced = np.vstack(y_balanced)
+
+    return x_balanced, y_balanced
+
 def get_weights():
 
     return 0

pyerualjetwork-2.3.8/pyerualjetwork.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pyerualjetwork
+Version: 2.3.8
+Summary: Weights post process function added: [weight_post_process](optional after training before testing.), new function: manuel_balancer. And scaler_params added for scaled models.
+Author: Hasan Can Beydili
+Author-email: tchasancan@gmail.com
+Keywords: model evaluation,classifcation,pruning learning artficial neural networks

{pyerualjetwork-2.2.8 → pyerualjetwork-2.3.8}/setup.py

@@ -5,10 +5,10 @@ from setuptools import setup, find_packages
 setup(
       
       name = "pyerualjetwork",
-      version = "2.2.8",
+      version = "2.3.8",
       author = "Hasan Can Beydili",
       author_email = "tchasancan@gmail.com",
-      description= "Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)",
+      description= "Weights post process function added: [weight_post_process](optional after training before testing.), new function: manuel_balancer. And scaler_params added for scaled models.",
       packages = find_packages(),
       keywords = ["model evaluation", "classifcation", 'pruning learning artficial neural networks'],
 

pyerualjetwork-2.2.8/PKG-INFO

@@ -1,7 +0,0 @@
-Metadata-Version: 2.1
-Name: pyerualjetwork
-Version: 2.2.8
-Summary: Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
-Author: Hasan Can Beydili
-Author-email: tchasancan@gmail.com
-Keywords: model evaluation,classifcation,pruning learning artficial neural networks

pyerualjetwork-2.2.8/pyerualjetwork.egg-info/PKG-INFO

@@ -1,7 +0,0 @@
-Metadata-Version: 2.1
-Name: pyerualjetwork
-Version: 2.2.8
-Summary: Code improvements (Documentation in desc. Examples in GİTHUB: https://github.com/HCB06/PyerualJetwork)
-Author: Hasan Can Beydili
-Author-email: tchasancan@gmail.com
-Keywords: model evaluation,classifcation,pruning learning artficial neural networks