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

pyerualjetwork/model_operations_cuda.py

@@ -11,8 +11,8 @@ import gc
 
 def save_model(model_name,
                W,
+               model_type,
                scaler_params=None,
-               model_type='PLAN',
                test_acc=None,
                model_path='',
                activation_potentiation=['linear'],
@@ -24,18 +24,29 @@ def save_model(model_name,
 
     """
 
-    Function to save a potentiation learning artificial neural network model.
+    Function to save a potentiation learning artificial neural network model or trained non-bias MLP 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']
+       
+        activation_potentiation: (list[str]): For deeper PLAN networks, activation function parameters. Or activation function parameters for MLP layers. 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
 
 
@@ -45,7 +56,8 @@ def save_model(model_name,
     
     from .visualizations_cuda 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 is not None:
         test_acc= float(test_acc)
@@ -58,17 +70,45 @@ 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 += cp.shape(W)[0] + cp.shape(W)[1]
-            SynapseCount += cp.shape(W)[0] * cp.shape(W)[1]
-    except:
+        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()
+            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(cp.shape(W[0])[1])
+
+        for i in range(len(W)):
+            try:
+                    NeuronCount.append(cp.shape(W[i])[0])
+                    SynapseCount.append(cp.shape(W[i])[0] * cp.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 isinstance(activation_potentiation, str):
+        activation_potentiation = [activation_potentiation]
+        activation_potentiation.append('')
 
     if scaler_params != None:
 
@@ -102,56 +142,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
 
-                cp.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':
 
-                cp.savetxt(model_path + model_name + '_weights.txt',  W)
+                    cp.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':
+                    cp.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)
 
-                cp.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':
 
-                cp.save(model_path + model_name + '_weights.npy',  W)
+                    cp.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':
+                    cp.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)
@@ -168,7 +215,6 @@ def save_model(model_name,
         draw_model_architecture(model_name=model_name, model_path=model_path)
 
 
-
 def load_model(model_name,
                model_path,
                ):
@@ -176,14 +222,14 @@ 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:
 
          df = pd.read_pickle(model_path + model_name + '.pkl')
@@ -196,7 +242,7 @@ def load_model(model_name,
 
     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 != ''] 
+    activation_potentiation = [item for item in activation_potentiation if item != '']
 
     scaler_params_cpu = df['STANDARD SCALER'].tolist()
     
@@ -212,26 +258,38 @@ def load_model(model_name,
         gc.collect()
      
     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 = 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']
+    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(cp.loadtxt(model_path + model_name + f'weights{i}.txt'))
+        elif WeightType == 'npy':
+                W.append(cp.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']
+
+    if model_type == 'PLAN': W = cp.array(W[0], dtype=W[0].dtype)
+
+    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=cp.float32):
@@ -241,17 +299,15 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=cp.float32):
     from storage
 
     Args:
-
-        Input (list or ndarray): Input data for the model (single vector or single matrix).
-
+        Input (list or ndarray or cupyarray): 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 (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
-
+        
+        dtype (cupy.dtype): Data type for the arrays. cp.float32 by default. Example: cp.float64, cp.float16. (optional)
     Returns:
-        cparray: Output from the model.
+        cupyarray: Output from the model.
     """
     
     Input = cp.array(Input, dtype=dtype, copy=False)
@@ -259,25 +315,37 @@ def predict_model_ssd(Input, model_name, model_path='', dtype=cp.float32):
     from .activation_functions_cuda import apply_activation
     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()]
+    try:
 
-    Input = standard_scaler(None, Input, scaler_params)
+        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 = cp.array(Input, dtype=dtype, copy=False)
-    Input = Input.ravel()
+        Input = standard_scaler(None, Input, scaler_params)
 
-    try:
-        Input = apply_activation(Input, activation_potentiation)
-        neural_layer = Input @ W.T
-        return neural_layer
+        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
 
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_ssd." + Style.RESET_ALL)
-        sys.exit()
+        sys.exit(),
+
     
 
 def reverse_predict_model_ssd(output, model_name, model_path='', dtype=cp.float32):
@@ -312,47 +380,54 @@ def reverse_predict_model_ssd(output, model_name, model_path='', dtype=cp.float3
         sys.exit()
 
 
-def predict_model_ram(Input, W, scaler_params=None, activation_potentiation=['linear'], dtype=cp.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 (cupy.dtype): Data type for the arrays. np.float32 by default. Example: cp.float64 or cp.float16. [fp32 for balanced devices, fp64 for strong devices, fp16 for weak devices: not reccomended!] (optional)
-
+        activation_potentiation (list[str]): activation list for deep PLAN or activation list for MLP layers. Default: ['linear']
+        
+        is_mlp (bool, optional): Predict from PLAN model or MLP model ? Default: False (PLAN)
     Returns:
-        cparray: Output from the model.
+    cupyarray: Output from the model.
     """
 
     from .data_operations_cuda import standard_scaler
     from .activation_functions_cuda import apply_activation
 
-    Input = standard_scaler(None, Input, scaler_params)
-    
-    Input = cp.array(Input, dtype=dtype, copy=False)
-    Input = Input.ravel()
-
     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()
 
+
 def reverse_predict_model_ram(output, W, dtype=cp.float32):
 
     """
@@ -407,4 +482,7 @@ def get_scaler():
 
 def get_preds_softmax():
 
-    return 5
+    return 5
+
+def get_model_type():
+    return 6