pyerualjetwork 4.0.2__py3-none-any.whl → 4.0.3b0__py3-none-any.whl

pyerualjetwork/model_operations_cuda.py

@@ -0,0 +1,405 @@
+import cupy as cp
+from colorama import Fore, Style
+import sys
+from datetime import datetime
+import pickle
+from scipy import io
+import scipy.io as sio
+import pandas as pd
+
+
+def save_model(model_name,
+               W,
+               scaler_params=None,
+               model_type='PLAN',
+               test_acc=None,
+               model_path='',
+               activation_potentiation=['linear'],
+               weights_type='npy',
+               weights_format='raw',
+               show_architecture=None,
+               show_info=True
+               ):
+
+    """
+    Function to save a potentiation learning artificial neural network model.
+
+    Arguments:
+
+    model_name (str): Name of the model.
+
+    model_type (str): Type of the model. default: 'PLAN'
+
+    test_acc (float): Test accuracy of the model. default: None
+
+    weights_type (str): Type of weights to save (options: 'txt', 'pkl', 'npy', 'mat'). default: 'npy'
+
+    WeightFormat (str): Format of the weights (options: 'f', 'raw'). default: 'raw'
+
+    model_path (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/ default: ''
+
+    scaler_params (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
+
+    W: Weights of the model. (cparray)
+
+    activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
+
+    show_architecture (str): It draws model architecture. Takes 2 value='basic' or 'detailed'. Default: None(not drawing)
+
+    show_info (bool): Prints model details into console. default: True
+
+    Returns:
+    No return.
+    """
+    
+    from .visualizations_cuda import draw_model_architecture
+
+    class_count = W.shape[0]
+
+    if test_acc != None:
+        test_acc= float(test_acc)
+
+    if weights_type != 'txt' and weights_type != 'npy' and weights_type != 'mat' and weights_type != 'pkl':
+        print(Fore.RED + "ERROR110: Save Weight type (File Extension) Type must be 'txt' or 'npy' or 'mat' or 'pkl' from: save_model" + Style.RESET_ALL)
+        sys.exit()
+
+    if weights_format != 'd' and weights_format != 'f' and weights_format != 'raw':
+        print(Fore.RED + "ERROR111: Weight Format Type must be 'd' or 'f' or 'raw' from: save_model" + Style.RESET_ALL)
+        sys.exit()
+
+    NeuronCount = 0
+    SynapseCount = 0
+
+
+    try:
+            NeuronCount += cp.shape(W)[0] + cp.shape(W)[1]
+            SynapseCount += cp.shape(W)[0] * cp.shape(W)[1]
+    except:
+
+        print(Fore.RED + "ERROR: Weight matrices has a problem from: save_model" + Style.RESET_ALL)
+        sys.exit()
+
+    if scaler_params != None:
+
+        if len(scaler_params) > len(activation_potentiation):
+
+            activation_potentiation += ['']
+
+        elif len(activation_potentiation) > len(scaler_params):
+
+            for i in range(len(activation_potentiation) - len(scaler_params)):
+
+                scaler_params.append(' ')
+
+    data = {'MODEL NAME': model_name,
+            'MODEL TYPE': model_type,
+            'CLASS COUNT': class_count,
+            'NEURON COUNT': NeuronCount,
+            'SYNAPSE COUNT': SynapseCount,
+            'TEST ACCURACY': test_acc,
+            'SAVE DATE': datetime.now(),
+            'WEIGHTS TYPE': weights_type,
+            'WEIGHTS FORMAT': weights_format,
+            'MODEL PATH': model_path,
+            'STANDARD SCALER': scaler_params,
+            'ACTIVATION POTENTIATION': activation_potentiation
+            }
+
+    df = pd.DataFrame(data)
+    df.to_pickle(model_path + model_name + '.pkl')
+
+
+    try:
+
+        if weights_type == 'txt' and weights_format == 'f':
+
+                cp.savetxt(model_path + model_name + '_weights.txt',  W, fmt='%f')
+
+        if weights_type == 'txt' and weights_format == 'raw':
+
+                cp.savetxt(model_path + model_name + '_weights.txt',  W)
+
+        ###
+
+        
+        if weights_type == 'pkl' and weights_format == 'f':
+
+            with open(model_path + model_name + '_weights.pkl', 'wb') as f:
+                pickle.dump(W.astype(float), f)
+
+        if weights_type == 'pkl' and weights_format =='raw':
+        
+            with open(model_path + model_name + '_weights.pkl', 'wb') as f:
+                pickle.dump(W, f)
+
+        ###
+
+        if weights_type == 'npy' and weights_format == 'f':
+
+                cp.save(model_path + model_name + '_weights.npy',  W, W.astype(float))
+
+        if weights_type == 'npy' and weights_format == 'raw':
+
+                cp.save(model_path + model_name + '_weights.npy',  W)
+
+        ###
+
+        if weights_type == 'mat' and weights_format == 'f':
+
+                w = {'w': W.astype(float)}
+                io.savemat(model_path + model_name + '_weights.mat', w)
+
+        if weights_type == 'mat' and weights_format == 'raw':
+                
+                w = {'w': W}
+                io.savemat(model_path + model_name + '_weights.mat', w)
+
+    except:
+
+        print(Fore.RED + "ERROR: Model Weights not saved. Check the Weight parameters. SaveFilePath expl: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: save_model" + Style.RESET_ALL)
+        sys.exit()
+    
+    if show_info:
+        print(df)
+    
+        message = (
+            Fore.GREEN + "Model Saved Successfully\n" +
+            Fore.MAGENTA + "Don't forget, if you want to load model: model log file and weight files must be in the same directory." +
+            Style.RESET_ALL
+        )
+        
+        print(message)
+
+    if show_architecture is not None:
+        draw_model_architecture(model_name=model_name, model_path=model_path, style=show_architecture)
+
+
+
+def load_model(model_name,
+               model_path,
+               ):
+    """
+   Function to load a potentiation learning model.
+
+   Arguments:
+
+   model_name (str): Name of the model.
+
+   model_path (str): Path where the model is saved.
+
+   Returns:
+   lists: W(list[num]), activation_potentiation, DataFrame of the model
+    """
+    try:
+
+         df = pd.read_pickle(model_path + model_name + '.pkl')
+
+    except:
+
+        print(Fore.RED + "ERROR: Model Path error. acceptable form: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: load_model" + Style.RESET_ALL)
+
+        sys.exit()
+
+    activation_potentiation = list(df['ACTIVATION POTENTIATION'])
+    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()
+    
+    try:
+        if scaler_params[0] == None:
+            scaler_params = scaler_params[0]
+
+    except:
+        scaler_params = [item for item in scaler_params if isinstance(item, cp.ndarray)]
+
+     
+    model_name = str(df['MODEL NAME'].iloc[0])
+    WeightType = str(df['WEIGHTS TYPE'].iloc[0])
+
+    if WeightType == 'txt':
+            W = cp.loadtxt(model_path + model_name + '_weights.txt')
+    elif WeightType == 'npy':
+            W = cp.load(model_path + model_name + '_weights.npy')
+    elif WeightType == 'mat':
+            W = sio.loadmat(model_path + model_name + '_weights.mat')
+    elif WeightType == 'pkl':
+        with open(model_path + model_name + '_weights.pkl', 'rb') as f:
+            W = pickle.load(f)
+    else:
+
+        raise ValueError(
+            Fore.RED + "Incorrect weight type value. Value must be 'txt', 'npy', 'pkl' or 'mat' from: load_model." + Style.RESET_ALL)
+        
+    if WeightType == 'mat':
+        W = W['w']
+
+    return W, None, None, activation_potentiation, scaler_params
+
+
+def predict_model_ssd(Input, model_name, model_path=''):
+
+    """
+    Function to make a prediction using a potentiation learning artificial neural network (PLAN).
+    from storage
+
+    Arguments:
+
+    Input (list or cparray): Input data for the model (single vector or single matrix).
+
+    model_name (str): Name of the model.
+
+    model_path (str): Path of the model. Default: ''
+
+    Returns:
+    cparray: Output from the model.
+    """
+            
+    Input = cp.array(Input, copy=False)
+        
+    from .plan_cuda import feed_forward
+    from .data_operations_cuda import standard_scaler
+    
+    model = load_model(model_name, model_path)
+    
+    activation_potentiation = model[get_act_pot()]
+    scaler_params = model[get_scaler()]
+    W = model[get_weights()]
+
+    Input = standard_scaler(None, Input, scaler_params)
+
+    neural_layer = Input
+    neural_layer = cp.array(neural_layer)
+    neural_layer = neural_layer.ravel()
+
+    try:
+        neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+        return neural_layer
+    except:
+        print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_ssd." + Style.RESET_ALL)
+        sys.exit()
+    
+
+def reverse_predict_model_ssd(output, model_name, model_path=''):
+
+    """
+    reverse prediction function from storage
+    Arguments:
+
+    output (list or cparray): output layer for the model (single probability vector, output layer of trained model).
+
+    model_name (str): Name of the model.
+
+    model_path (str): Path of the model. Default: ''
+
+    Returns:
+    cparray: Input from the model.
+    """
+        
+    Input = cp.array(Input, copy=False)
+        
+    model = load_model(model_name, model_path)
+    
+    W = model[get_weights()]
+
+    try:
+        Input = cp.dot(output, cp.copy(W))
+        return Input
+    except:
+        print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: reverse_predict_model_ssd." + Style.RESET_ALL)
+        sys.exit()
+    
+
+
+def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['linear']):
+
+    """
+    Function to make a prediction using a potentiation learning artificial neural network (PLAN).
+    from memory.
+
+    Arguments:
+
+    Input (list or cparray): Input data for the model (single vector or single matrix).
+
+    W (list of cparray): Weights of the model.
+
+    scaler_params (list): standard scaler params list: mean,std. (optional) Default: None.
+    
+    activation_potentiation (list): ac list for deep PLAN. default: [None] ('linear') (optional)
+
+    Returns:
+    cparray: Output from the model.
+    """
+
+    from .data_operations_cuda import standard_scaler
+    from .plan_cuda import feed_forward
+    
+    Input = cp.array(Input, copy=False)
+    Input = standard_scaler(None, Input, scaler_params)
+    
+    try:
+        
+        neural_layer = Input
+        neural_layer = cp.array(neural_layer)
+        neural_layer = neural_layer.ravel()
+
+        neural_layer = feed_forward(neural_layer, cp.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
+
+        return neural_layer
+    
+    except:
+        print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram." + Style.RESET_ALL)
+        sys.exit()
+
+def reverse_predict_model_ram(output, W):
+
+    """
+    reverse prediction function from memory
+
+    Arguments:
+
+    output (list or cparray): output layer for the model (single probability vector, output layer of trained model).
+
+    W (list of cparray): Weights of the model.
+
+    Returns:
+    cparray: Input from the model.
+    """
+    Input = cp.array(Input, copy=False)
+        
+    try:
+        Input = cp.dot(output, cp.copy(W))
+        return Input
+    
+    except:
+        print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: reverse_predict_model_ram." + Style.RESET_ALL)
+        sys.exit()
+
+
+def get_weights():
+
+    return 0
+
+
+def get_preds():
+
+    return 1
+
+
+def get_acc():
+
+    return 2
+
+
+def get_act_pot():
+
+    return 3
+
+
+def get_scaler():
+
+    return 4
+
+def get_preds_softmax():
+
+    return 5

pyerualjetwork/plan.py

@@ -14,17 +14,16 @@ ANAPLAN document: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/
 """
 
 import numpy as np
-from colorama import Fore, Style
-import sys
+from colorama import Fore
 
 ### LIBRARY IMPORTS ###
-from .ui import loading_bars, initialize_loading_bar
-from .data_operations import normalization, decode_one_hot, batcher
-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 .visualizations import (
+from ui import loading_bars, initialize_loading_bar
+from data_operations import normalization, decode_one_hot, batcher
+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 visualizations import (
     draw_neural_web,
     plot_evaluate,
     neuron_history,
@@ -547,89 +546,73 @@ def feed_forward(
 
 
 def evaluate(
-    x_test,         # list[num]: Test input data.
-    y_test,         # list[num]: Test labels.
-    W,               # list[num]: Weight matrix list of the neural network.
-    activation_potentiation=['linear'], # (list): Activation potentiation list for deep PLAN. (optional)
-    loading_bar_status=True,  # bar_status (bool): Loading bar for accuracy (True or None) (optional) Default: True
-    show_metrics=None, # show_metrices (bool): (True or None) (optional) Default: None   
+    x_test,         # NumPy array: Test input data.
+    y_test,         # NumPy array: Test labels.
+    W,              # List of NumPy arrays: Neural network weight matrices.
+    activation_potentiation=['linear'], # List of activation functions.
+    loading_bar_status=True,  # Optionally show loading bar.
+    show_metrics=None,        # Optionally show metrics.
 ) -> tuple:
     """
-    Tests the neural network model with the given test data.
+    Evaluates the neural network model using the given test data.
 
     Args:
-    
-        x_test (list[num]): Test input data.
-
-        y_test (list[num]): Test labels.
-
-        W (list[num]): Weight matrix list of the neural network.
-
-        activation_potentiation (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: [None]
-
-        loading_bar_status:  Evaluate progress have a loading bar ? (True or False) Default: True.
-
-        show_metrics (bool): (True or None) (optional) Default: None
+        x_test (np.ndarray): Test input data.
+        y_test (np.ndarray): Test labels.
+        W (list[np.ndarray]): List of neural network weight matrices.
+        activation_potentiation (list): List of activation functions.
+        loading_bar_status (bool): Option to show a loading bar (optional).
+        show_metrics (bool): Option to show metrics (optional).
 
     Returns:
-        tuple: A tuple containing the predicted labels and the accuracy of the model.
+        tuple: Predicted labels, model accuracy, and other evaluation metrics.
     """
-    predict_probabilitys = []
-    real_classes = []
-    predict_classes = []
-
-    try:
+    # Initialize arrays to store probabilities, real and predicted classes, and accuracy
+    predict_probabilitys = np.empty((len(x_test), W.shape[0]), dtype=np.float32)
+    real_classes = np.empty(len(x_test), dtype=np.int32)           # Real classes
+    predict_classes = np.empty(len(x_test), dtype=np.int32)        # Predicted classes
 
-        true_predict = 0
-        y_preds = []
-        y_preds_raw = []
-        acc_list = []
+    true_predict = 0
+    acc_list = np.empty(len(x_test), dtype=np.float32)             # Accuracy list
 
-        
-        if loading_bar_status == True:
-
-            loading_bar = initialize_loading_bar(total=len(x_test), ncols=64, desc='Testing', bar_format=bar_format_normal)
+    if loading_bar_status:
+        loading_bar = initialize_loading_bar(total=len(x_test), ncols=64, desc='Testing', bar_format=bar_format_normal)
 
-        for inpIndex, Input in enumerate(x_test):
-            Input = np.array(Input)
-            Input = Input.ravel()
-            neural_layer = Input
-
-                
-            neural_layer = feed_forward(neural_layer, W, is_training=False, Class='?', activation_potentiation=activation_potentiation)
-            neural_layer = Softmax(neural_layer)
+    for inpIndex in range(len(x_test)):
+        # Flatten the input data for processing
+        Input = x_test[inpIndex].ravel()  # Flatten the input
 
-            max_value = max(neural_layer)
+        neural_layer = Input
 
-            predict_probabilitys.append(max_value)
-            
-            RealOutput = np.argmax(y_test[inpIndex])
-            real_classes.append(RealOutput)
-            PredictedOutput = np.argmax(neural_layer)
-            predict_classes.append(PredictedOutput)
+        # Perform feedforward operation
+        neural_layer = feed_forward(neural_layer, np.copy(W), is_training=False, Class='?', activation_potentiation=activation_potentiation)
 
-            if RealOutput == PredictedOutput:
-                true_predict += 1
-            acc = true_predict / len(y_test)
+        # Calculate probabilities and predictions
+        predict_probabilitys[inpIndex] = Softmax(neural_layer)
 
+        # Find the actual class and predicted class
+        RealOutput = np.argmax(y_test[inpIndex])
+        real_classes[inpIndex] = RealOutput
+        PredictedOutput = np.argmax(neural_layer)
+        predict_classes[inpIndex] = PredictedOutput
 
-            acc_list.append(acc)
-            y_preds.append(PredictedOutput)
-            y_preds_raw.append(Softmax(neural_layer))
-
-            if loading_bar_status == True:
-                loading_bar.update(1)
-                
-            if inpIndex > 0 and loading_bar_status == True:
-                loading_bar.set_postfix({"Test Accuracy": acc})
+        # Check if the prediction is correct
+        if RealOutput == PredictedOutput:
+            true_predict += 1
+        
+        # Dynamically calculate accuracy
+        acc = true_predict / (inpIndex + 1)  
+        acc_list[inpIndex] = acc
 
-        if show_metrics == True:
-            
-            loading_bar.close()
-            plot_evaluate(x_test, y_test, y_preds, acc_list, W=np.copy(W), activation_potentiation=activation_potentiation)
+        if loading_bar_status:
+            loading_bar.update(1)
+            loading_bar.set_postfix({"Test Accuracy": acc})
 
-    except Exception as e:
+    if loading_bar_status:
+        loading_bar.close()
 
-        raise(e)
+    if show_metrics:
+        # Plot the evaluation metrics
+        plot_evaluate(x_test, y_test, predict_classes, acc_list, W=np.copy(W), activation_potentiation=activation_potentiation)
 
-    return W, y_preds, acc, None, None, y_preds_raw
+    return W, predict_classes, acc_list[-1], None, None, predict_probabilitys