pyerualjetwork 5.0.2b1__py3-none-any.whl → 5.1__py3-none-any.whl

pyerualjetwork/model_operations_cpu.py

@@ -28,6 +28,11 @@ Module functions:
 - get_acc()
 - get_scaler()
 - get_model_type()
+- get_weights_type()
+- get_weights_format()
+- get_model_version()
+- get_model_df()
+- get_act_pot()
 
 Examples: https://github.com/HCB06/PyerualJetwork/tree/main/Welcome_to_PyerualJetwork/ExampleCodes
 
@@ -57,6 +62,7 @@ def save_model(model_name,
                test_acc=None,
                model_path='',
                activations=['linear'],
+               activation_potentiation=[],
                weights_type='npy',
                weights_format='raw',
                show_architecture=False,
@@ -70,9 +76,9 @@ def save_model(model_name,
         
         W: Weights of the model.
         
-        model_type: (str): Type of the model. Options: 'PLAN', 'MLP'.
+        model_type: (str): Type of the model. Options: 'PLAN', 'MLP', 'PTNN'.
         
-        scaler_params: (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: None.
+        scaler_params: (list[num, num]): standard scaler params list: mean,std. If not used standard scaler then be: [].
         
         test_acc: (float): Test accuracy of the model. default: None
         
@@ -80,6 +86,8 @@ def save_model(model_name,
         
         activations: (list[str]): For deeper PLAN networks, activation function parameters. Or activation function parameters for MLP layers. For more information please run this code: neu.activations_list() default: ['linear']
         
+        activation_potentiation (list, optional): Extra activation potentiation list (PLAN layers activations) for just PTNN models. Default = None.
+
         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'
@@ -93,16 +101,28 @@ def save_model(model_name,
     """
     
     from .visualizations_cpu import draw_model_architecture
+    from .__init__ import __version__
 
-    if model_type != 'PLAN' and model_type != 'MLP':
-        raise ValueError("model_type parameter must be 'PLAN' or 'MLP'.")
+    if model_type != 'PLAN' and model_type != 'MLP' and model_type != 'PTNN':
+        raise ValueError("model_type parameter must be 'PLAN', 'MLP' or 'PTNN'.")
+
+    if model_type == 'PTNN' and activation_potentiation == []:
+        raise ValueError('PTNN models need extra activation_potentiation parameter.')
 
     if isinstance(activations, str):
         activations = [activations]
     else:
         activations = [item if isinstance(item, list) else [item] for item in activations]
 
-    activation = activations.copy()
+    activations = activations.copy()
+
+    if model_type == 'PTNN':
+        if isinstance(activation_potentiation, str):
+            activation_potentiation = [activation_potentiation]
+        else:
+            activation_potentiation = [item if isinstance(item, list) else [item] for item in activation_potentiation]
+
+        activation_potentiation = activation_potentiation.copy()
 
     if test_acc != None:
         test_acc= float(test_acc)
@@ -130,7 +150,7 @@ def save_model(model_name,
             print(Fore.RED + "ERROR: Weight matrices have a problem from: save_model" + Style.RESET_ALL)
             sys.exit()
 
-    elif model_type == 'MLP':
+    elif model_type == 'MLP' or model_type == 'PTNN':
 
         class_count = W[-1].shape[0]
         
@@ -148,36 +168,42 @@ def save_model(model_name,
     
         SynapseCount.append(' ')
         
-        activation.append('')
-        activation.insert(0, '')
-        
-    if len(activation) == 1 and model_type == 'PLAN':
-        activation = [activation]
-        activation.append('')
+        activations.append('')
+        activations.insert(0, '')
 
-    if len(activation) > len(NeuronCount):
-        for i in range(len(activation) - len(NeuronCount)):
+    if len(activations) == 1 and model_type == 'PLAN':
+        activations = [activations]
+        activations.append('')
+
+    if model_type == 'PTNN':
+        if len(activations) > len(activation_potentiation):
+            for i in range(len(activations) - len(activation_potentiation)):
+                activation_potentiation.append('')
+
+        if len(activation_potentiation) > len(activations):
+            for i in range(len(activation_potentiation) - len(activations)):
+                activations.append('')
+
+    if len(activations) > len(NeuronCount):
+        for i in range(len(activations) - len(NeuronCount)):
             NeuronCount.append('')
         
-    if len(activation) > len(SynapseCount):
-        for i in range(len(activation) - len(SynapseCount)):
+    if len(activations) > len(SynapseCount):
+        for i in range(len(activations) - len(SynapseCount)):
             SynapseCount.append('')
 
-
     if scaler_params != None:
 
-        if len(scaler_params) > len(activation):
+        if len(scaler_params) > len(activations):
 
-            activation += ['']
+            activations += ['']
 
-        elif len(activation) > len(scaler_params):
+        elif len(activations) > len(scaler_params):
 
-            for i in range(len(activation) - len(scaler_params)):
+            for i in range(len(activations) - len(scaler_params)):
 
                 scaler_params.append(' ')
 
-    from .__init__ import __version__
-
     data = {'MODEL NAME': model_name,
             'MODEL TYPE': model_type,
             'CLASS COUNT': class_count,
@@ -188,9 +214,9 @@ def save_model(model_name,
             'SAVE DATE': datetime.now(),
             'WEIGHTS TYPE': weights_type,
             'WEIGHTS FORMAT': weights_format,
-            'MODEL PATH': model_path,
             'STANDARD SCALER': scaler_params,
-            'ACTIVATION FUNCTIONS': activation
+            'ACTIVATION FUNCTIONS': activations,
+            'ACTIVATION POTENTIATION': activation_potentiation
             }
 
     df = pd.DataFrame(data)
@@ -274,26 +300,21 @@ def load_model(model_name,
     model_path (str): Path where the model is saved.
 
    Returns:
-    lists: (list[df_elements]), DataFrame of the model
+    lists: Weights, None, test_accuracy, activations, scaler_params, None, model_type, weight_type, weight_format, device_version, (list[df_elements])=Pandas DataFrame of the model
     """
 
+    from .__init__ import __version__
+
     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)
+        print(Fore.RED + "ERROR: Model Path or Model Name error. acceptable form: 'C:/Users/hasancanbeydili/Desktop/denemePLAN/' from: load_model" + Style.RESET_ALL)
 
         sys.exit()
 
-    try:
-        activations = list(df['ACTIVATION FUNCTIONS']) # for PyerualJetwork >=5 Versions.
-    except KeyError:
-        activations = list(df['ACTIVATION POTENTIATION']) # for PyerualJetwork <5 Versions.
-
-    activations = [x for x in activations if not (isinstance(x, float) and np.isnan(x))]
-    activations = [item for item in activations if item != ''] 
 
     scaler_params = df['STANDARD SCALER'].tolist()
     
@@ -311,7 +332,13 @@ def load_model(model_name,
     WeightFormat = str(df['WEIGHTS FORMAT'].iloc[0])
     test_acc = str(df['TEST ACCURACY'].iloc[0])
 
-    from .__init__ import __version__
+    activations = list(df['ACTIVATION FUNCTIONS'])
+    activations = [x for x in activations if not (isinstance(x, float) and np.isnan(x))]
+    activations = [item for item in activations if item != ''] 
+
+    activation_potentiation = list(df['ACTIVATION POTENTIATION'])
+    activation_potentiation = [x for x in activation_potentiation if not (isinstance(x, float) and np.isnan(x))]
+    activation_potentiation = [item for item in activation_potentiation if item != ''] 
 
     device_version = __version__
 
@@ -327,7 +354,7 @@ def load_model(model_name,
     except:
         pass # Version check only in >= 5.0.2
 
-    if model_type == 'MLP': allow_pickle = True
+    if model_type == 'MLP' or model_type == 'PTNN': allow_pickle = True
     else: allow_pickle = False
 
     if WeightType == 'txt':
@@ -347,7 +374,7 @@ def load_model(model_name,
     if WeightType == 'mat':
         W = W['w']
 
-    return W, None, test_acc, activations, scaler_params, None, model_type, WeightType, WeightFormat, device_version, df
+    return W, None, test_acc, activations, scaler_params, None, model_type, WeightType, WeightFormat, device_version, df, activation_potentiation
 
 
 
@@ -370,7 +397,7 @@ def predict_from_storage(Input, model_name, model_path=''):
     
     from .activation_functions_cpu import apply_activation
     from .data_operations_cpu import standard_scaler
-    
+
     try:
 
         model = load_model(model_name, model_path)
@@ -379,30 +406,48 @@ def predict_from_storage(Input, model_name, model_path=''):
         scaler_params = model[get_scaler()]
         W = model[get_weights()]
         model_type = model[get_model_type()]
+        activation_potentiation = model[get_act_pot()]
 
         if isinstance(activations, str):
             activations = [activations]
         elif isinstance(activations, list):
             activations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activations]
-            
+
         Input = standard_scaler(None, Input, scaler_params)
 
         if model_type == 'MLP':
-            
             layer = Input
             for i in range(len(W)):
                 if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activations[i])
+
                 layer = layer @ W[i].T
-            
-            return layer
 
-        else:
+            result = layer
+
+        if model_type == 'PLAN':
 
             Input = apply_activation(Input, activations)
             result = Input @ W.T
+        
+        if model_type == 'PTNN':
+
+            if isinstance(activation_potentiation, str):
+                activation_potentiation = [activation_potentiation]
+            elif isinstance(activation_potentiation, list):
+                activation_potentiation = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiation]
+
+            Input = apply_activation(Input, activation_potentiation)
+            layer = Input @ W[0].T
+
+            for i in range(1, len(W)):
+                if i != len(W) - 1: layer = apply_activation(layer, activations[i])
+
+                layer = layer @ W[i].T
 
-            return result
+            result = layer
 
+        return result
+    
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_storage." + Style.RESET_ALL)
         sys.exit()
@@ -437,7 +482,7 @@ def reverse_predict_from_storage(output, model_name, model_path=''):
     
 
 
-def predict_from_memory(Input, W, scaler_params=None, activations=['linear'], is_mlp=False):
+def predict_from_memory(Input, W, scaler_params=None, activations=['linear'], activation_potentiation=None, model_type='PLAN'):
 
     """
     Function to make a prediction.
@@ -452,7 +497,10 @@ def predict_from_memory(Input, W, scaler_params=None, activations=['linear'], is
         
         activations (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)
+        activation_potentiation (list, optional): Extra activation potentiation list (PLAN layers activations) for just PTNN models. Default = None.
+
+        model_type: (str): Type of the model. Options: 'PLAN', 'MLP', 'PTNN'. Default: PLAN
+        
     Returns:
     ndarray: Output from the model.
     """
@@ -460,6 +508,8 @@ def predict_from_memory(Input, W, scaler_params=None, activations=['linear'], is
     from .data_operations_cpu import standard_scaler
     from .activation_functions_cpu import apply_activation
 
+    if model_type != 'PLAN' and model_type != 'MLP' and model_type != 'PTNN': raise ValueError("model_type parameter must be 'PLAN', 'MLP' or 'PTNN'.")
+
     try:
     
         Input = standard_scaler(None, Input, scaler_params)
@@ -468,23 +518,40 @@ def predict_from_memory(Input, W, scaler_params=None, activations=['linear'], is
             activations = [activations]
         elif isinstance(activations, list):
             activations = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activations]
-            
-        if is_mlp:
-            
+
+        if model_type == 'MLP':
             layer = Input
             for i in range(len(W)):
                 if i != len(W) - 1 and i != 0: layer = apply_activation(layer, activations[i])
+
                 layer = layer @ W[i].T
-            
-            return layer
 
-        else:
+            result = layer
+
+        if model_type == 'PLAN':
 
             Input = apply_activation(Input, activations)
             result = Input @ W.T
+        
+        if model_type == 'PTNN':
+
+            if isinstance(activation_potentiation, str):
+                activation_potentiation = [activation_potentiation]
+            elif isinstance(activation_potentiation, list):
+                activation_potentiation = [item if isinstance(item, list) or isinstance(item, str) else [item] for item in activation_potentiation]
+
+            Input = apply_activation(Input, activation_potentiation)
+            layer = Input @ W[0].T
+
+            for i in range(1, len(W)):
+                if i != len(W) - 1: layer = apply_activation(layer, activations[i])
 
-            return result
+                layer = layer @ W[i].T
+
+            result = layer
         
+        return result
+
     except:
         print(Fore.RED + "ERROR: Unexpected input or wrong model parameters from: predict_model_memory." + Style.RESET_ALL)
         sys.exit()
@@ -565,4 +632,9 @@ def get_model_version():
 
 def get_model_df():
      
-    return 10
+    return 10
+
+
+def get_act_pot():
+     
+    return 11