pyerualjetwork 4.5.3__py3-none-any.whl → 4.6b0__py3-none-any.whl

pyerualjetwork/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.5.3"
+__version__ = "4.6b0"
 __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/data_operations.py

@@ -428,4 +428,33 @@ def batcher(x_test, y_test, batch_size=1):
         sampled_x.append(x_test[sampled_indices])
         sampled_y.append(y_test[sampled_indices])
 
-    return np.concatenate(sampled_x), np.concatenate(sampled_y)
+    return np.concatenate(sampled_x), np.concatenate(sampled_y)
+
+def split_nested_arrays(data):
+
+    n_samples = len(data)
+    if n_samples == 0:
+        return []
+    
+    n_components = len(data[0])
+    
+    result = []
+        
+    for i in range(n_components):
+        component_array = np.array([item[i] for item in data])
+        result.append(component_array)
+    
+    return result
+
+
+def reconstruct_nested_arrays(component_arrays):
+
+    n_components = len(component_arrays)
+    n_samples = len(component_arrays[0])
+    
+    reconstructed_data = []
+    for i in range(n_samples):
+        sample = [component_arrays[j][i] for j in range(n_components)]
+        reconstructed_data.append(sample)
+    
+    return reconstructed_data

pyerualjetwork/data_operations_cuda.py

@@ -476,4 +476,34 @@ def batcher(x_test, y_test, batch_size=1):
 
         offset += num_samples
     
-    return sampled_x, sampled_y
+    return sampled_x, sampled_y
+
+
+def split_nested_arrays(data):
+
+    n_samples = len(data)
+    if n_samples == 0:
+        return []
+    
+    n_components = len(data[0])
+    
+    result = []
+        
+    for i in range(n_components):
+        component_array = cp.array([item[i] for item in data])
+        result.append(component_array)
+    
+    return result
+
+
+def reconstruct_nested_arrays(component_arrays):
+
+    n_components = len(component_arrays)
+    n_samples = len(component_arrays[0])
+    
+    reconstructed_data = []
+    for i in range(n_samples):
+        sample = [component_arrays[j][i] for j in range(n_components)]
+        reconstructed_data.append(sample)
+    
+    return reconstructed_data

pyerualjetwork/model_operations.py

@@ -10,8 +10,8 @@ import pandas as pd
 
 def save_model(model_name,
                W,
+               model_type,
                scaler_params=None,
-               model_type='PLAN',
                test_acc=None,
                model_path='',
                activation_potentiation=['linear'],
@@ -25,15 +25,25 @@ def save_model(model_name,
     Function to save a potentiation learning artificial neural network model.
     Args:
         model_name: (str): Name of the model.
+        
         W: Weights of the model.
+        
+        model_type: (str): Type of the model. Options: 'PLAN', 'MLP'.
+        
         scaler_params: (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
-        model_type: (str): Type of the model. default: 'PLAN'
+        
         test_acc: (float): Test accuracy of the model. default: None
+        
         model_path: (str): Path where the model will be saved. For example: C:/Users/beydili/Desktop/denemePLAN/ default: ''
+        
         activation_potentiation: (list): For deeper PLAN networks, activation function parameters. For more information please run this code: plan.activations_list() default: ['linear']
+        
         weights_type: (str): Type of weights to save (options: 'txt', 'pkl', 'npy', 'mat'). default: 'npy'
+        
         weights_format: (str): Format of the weights (options: 'f', 'raw'). default: 'raw'
-        show_architecture: (bool): It draws model architecture. True or False. Default: False
+        
+        show_architecture: (bool): It draws model architecture. True or False. Default: False. NOTE! draw architecture only works for PLAN models. Not MLP models for now, but it will be.
+        
         show_info: (bool): Prints model details into console. default: True
 
     Returns:
@@ -42,7 +52,8 @@ def save_model(model_name,
     
     from .visualizations import draw_model_architecture
 
-    class_count = W.shape[0]
+    if model_type != 'PLAN' and model_type != 'MLP':
+        raise ValueError("model_type parameter must be 'PLAN' or 'MLP'.")
 
     if test_acc != None:
         test_acc= float(test_acc)
@@ -55,17 +66,41 @@ def save_model(model_name,
         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
+    if model_type == 'PLAN':
+        class_count = W.shape[0]
 
+        NeuronCount = 0
+        SynapseCount = 0
 
-    try:
-            NeuronCount += np.shape(W)[0] + np.shape(W)[1]
-            SynapseCount += np.shape(W)[0] * np.shape(W)[1]
-    except:
+        try:
+                NeuronCount += np.shape(W)[0] + np.shape(W)[1]
+                SynapseCount += np.shape(W)[0] * np.shape(W)[1]
+        except:
 
-        print(Fore.RED + "ERROR: Weight matrices has a problem from: save_model" + Style.RESET_ALL)
-        sys.exit()
+            print(Fore.RED + "ERROR: Weight matrices has a problem from: save_model" + Style.RESET_ALL)
+            sys.exit()
+
+    elif model_type == 'MLP':
+        class_count = W[-1].shape[0]
+        
+        NeuronCount = []
+        SynapseCount = []
+
+        NeuronCount.append(np.shape(W[0])[1])
+
+        for i in range(len(W)):
+            try:
+                    NeuronCount.append(np.shape(W[i])[0])
+                    SynapseCount.append(np.shape(W[i])[0] * np.shape(W[i])[1])
+            except:
+
+                print(Fore.RED + "ERROR: Weight matrices has a problem from: save_model" + Style.RESET_ALL)
+                sys.exit()
+
+        SynapseCount.append(' ')
+        
+        activation_potentiation.append('')
+        activation_potentiation.insert(0, '')
 
     if scaler_params != None:
 
@@ -96,56 +131,63 @@ def save_model(model_name,
     df = pd.DataFrame(data)
     df.to_pickle(model_path + model_name + '.pkl')
 
+    if isinstance(W, list): max_file = len(W)
+    else: max_file = 1
 
-    try:
+    for i in range(max_file):
 
-        if weights_type == 'txt' and weights_format == 'f':
+        if max_file > 1: weight = W[i]
+        else: weight = W
 
-                np.savetxt(model_path + model_name + '_weights.txt',  W, fmt='%f')
+        try:
 
-        if weights_type == 'txt' and weights_format == 'raw':
+            if weights_type == 'txt' and weights_format == 'f':
 
-                np.savetxt(model_path + model_name + '_weights.txt',  W)
+                    np.savetxt(model_path + model_name + f'weights{i}.txt',  weight, fmt='%f')
 
-        ###
+            if weights_type == 'txt' and weights_format == 'raw':
 
-        
-        if weights_type == 'pkl' and weights_format == 'f':
+                    np.savetxt(model_path + model_name + f'weights{i}.txt',  weight)
 
-            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 == 'pkl' and weights_format == 'f':
 
-        ###
+                with open(model_path + model_name + f'weights{i}.pkl', 'wb') as f:
+                    pickle.dump(weight.astype(float), f)
 
-        if weights_type == 'npy' and weights_format == 'f':
+            if weights_type == 'pkl' and weights_format =='raw':
+            
+                with open(model_path + model_name + f'weights{i}.pkl', 'wb') as f:
+                    pickle.dump(weight, f)
 
-                np.save(model_path + model_name + '_weights.npy',  W, W.astype(float))
+            ###
 
-        if weights_type == 'npy' and weights_format == 'raw':
+            if weights_type == 'npy' and weights_format == 'f':
 
-                np.save(model_path + model_name + '_weights.npy',  W)
+                    np.save(model_path + model_name + f'weights{i}.npy',  weight, weight.astype(float))
 
-        ###
+            if weights_type == 'npy' and weights_format == 'raw':
 
-        if weights_type == 'mat' and weights_format == 'f':
+                    np.save(model_path + model_name + f'weights{i}.npy',  weight)
 
-                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)
+            if weights_type == 'mat' and weights_format == 'f':
 
-    except:
+                    w = {'w': weight.astype(float)}
+                    io.savemat(model_path + model_name + f'weights{i}.mat', w)
 
-        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 weights_type == 'mat' and weights_format == 'raw':
+                    
+                    w = {'w': weight}
+                    io.savemat(model_path + model_name + f'weights{i}.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)
@@ -170,13 +212,12 @@ def load_model(model_name,
    Function to load a potentiation learning model.
 
    Args:
-
     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
+    lists: (list[df_elements]), DataFrame of the model
     """
 
     try:
@@ -204,26 +245,36 @@ def load_model(model_name,
 
      
     model_name = str(df['MODEL NAME'].iloc[0])
+    model_type = str(df['MODEL TYPE'].iloc[0])
     WeightType = str(df['WEIGHTS TYPE'].iloc[0])
+    layers = list(df['NEURON COUNT'])
 
-    if WeightType == 'txt':
-            W = np.loadtxt(model_path + model_name + '_weights.txt')
-    elif WeightType == 'npy':
-            W = np.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']
+    if model_type == 'MLP': max_file = len(layers)-1
+    else: max_file = 1
+
+    W = []
+
+    for i in range(max_file):
+         
+        if WeightType == 'txt':
+                W.append(np.loadtxt(model_path + model_name + f'weights{i}.txt'))
+        elif WeightType == 'npy':
+                W.append(np.load(model_path + model_name + f'weights{i}.npy'))
+        elif WeightType == 'mat':
+                W.append(sio.loadmat(model_path + model_name + f'weights{i}.mat'))
+        elif WeightType == 'pkl':
+            with open(model_path + model_name + f'weights{i}.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[-1] = W[-1]['w']
+
+    return W, None, None, activation_potentiation, scaler_params, None, model_type
 
-    return W, None, None, activation_potentiation, scaler_params
 
 
 def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
@@ -233,15 +284,13 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
     from storage
 
     Args:
-
         Input (list or ndarray): 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: ''
-
-        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
-
+        
+        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64, np.float16. (optional)
     Returns:
         ndarray: Output from the model.
     """
@@ -249,25 +298,37 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=np.float32):
     from .activation_functions import apply_activation
     from .data_operations 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()]
+    try:
 
-    Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
+        model = load_model(model_name, model_path)
+        
+        activation_potentiation = model[get_act_pot()]
+        scaler_params = model[get_scaler()]
+        W = model[get_weights()]
+        model_type = model[get_model_type()]
 
-    Input = np.array(Input, dtype=dtype, copy=False)
-    Input = Input.ravel()
+        Input = standard_scaler(None, Input, scaler_params)
+
+        if model_type == 'MLP':
+            
+            layer = Input
+            for i in range(len(W)):
+                if i != len(W) - 1: layer = apply_activation(layer, activation_potentiation[i])
+                layer = layer @ W[i].T
+            
+            return layer
+
+        else:
+
+            Input = apply_activation(Input, activation_potentiation)
+            result = Input @ W.T
+
+            return result
 
-    try:
-        Input = apply_activation(Input, activation_potentiation)
-        neural_layer = Input @ W.T
-        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='', dtype=np.float32):
 
@@ -300,43 +361,49 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=np.float3
     
 
 
-def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['linear'], dtype=np.float32):
+def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['linear'], is_mlp=False):
 
     """
     Function to make a prediction using a potentiation learning artificial neural network (PLAN).
     from memory.
 
     Args:
-
         Input (list or ndarray): Input data for the model (single vector or single matrix).
-
+        
         W (list of ndarrays): 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)
-
-        dtype (numpy.dtype): Data type for the arrays. np.float32 by default. Example: np.float64 or np.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!]
-
+        
+        is_mlp (bool, optional): Predict from PLAN model or MLP model ? Default: False (PLAN)
     Returns:
-        ndarray: Output from the model.
+    ndarray: Output from the model.
     """
 
-    from .data_operations import standard_scaler
-    from .activation_functions import apply_activation
-
-    Input = standard_scaler(None, Input, scaler_params, dtype=dtype)
-    
-    Input = np.array(Input, dtype=dtype, copy=False)
-    Input = Input.ravel()
+    from data_operations import standard_scaler
+    from activation_functions import apply_activation
 
     try:
+    
+        Input = standard_scaler(None, Input, scaler_params)
         
-        Input = apply_activation(Input, activation_potentiation)
-        neural_layer = Input @ W.T
+        if is_mlp:
+            
+            layer = Input
+            for i in range(len(W)):
+                if i != len(W) - 1: layer = apply_activation(layer, activation_potentiation[i])
+                layer = layer @ W[i].T
+            
+            return layer
 
-        return neural_layer
-    
+        else:
+
+            Input = apply_activation(Input, activation_potentiation)
+            result = Input @ W.T
+
+            return result
+        
     except:
         print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_ram." + Style.RESET_ALL)
         sys.exit()
@@ -393,4 +460,7 @@ def get_scaler():
 
 def get_preds_softmax():
 
-    return 5
+    return 5
+
+def get_model_type():
+     return 6