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

pyerualjetwork/model_operations_cuda.py

@@ -28,6 +28,12 @@ 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
 
@@ -58,6 +64,7 @@ def save_model(model_name,
                test_acc=None,
                model_path='',
                activations=['linear'],
+               activation_potentiation=[],
                weights_type='npy',
                weights_format='raw',
                show_architecture=False,
@@ -71,7 +78,7 @@ def save_model(model_name,
         model_name: (str): Name of the model.
         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.
         
@@ -83,6 +90,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: plan.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'
@@ -97,10 +106,14 @@ def save_model(model_name,
     """
     
     from .visualizations_cuda 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(W, list):
         W = W.copy()
 
@@ -112,7 +125,15 @@ def save_model(model_name,
     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 is not None:
         test_acc= float(test_acc)
@@ -140,7 +161,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':
 
         for i in range(len(W)):
             W[i] = W[i].get()
@@ -162,37 +183,45 @@ def save_model(model_name,
 
         SynapseCount.append(' ')
         
-        activation.append('')
-        activation.insert(0, '')
+        activations.append('')
+        activations.insert(0, '')
 
-    if len(activation) == 1 and model_type == 'PLAN':
-        activation = [activation]
-        activation.append('')
+    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) > len(NeuronCount):
-        for i in range(len(activation) - len(NeuronCount)):
+        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(' ')
 
         scaler_params[0] = scaler_params[0].get()
         scaler_params[1] = scaler_params[1].get()
 
-    from .__init__ import __version__
 
     data = {'MODEL NAME': model_name,
             'MODEL TYPE': model_type,
@@ -204,9 +233,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)
@@ -284,8 +313,10 @@ 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:
 
@@ -297,13 +328,6 @@ def load_model(model_name,
 
         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 cp.isnan(x))]
-    activations = [item for item in activations if item != '']
 
     scaler_params_cpu = df['STANDARD SCALER'].tolist()
     
@@ -324,7 +348,14 @@ 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__
 
@@ -340,7 +371,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':
@@ -364,7 +395,7 @@ def load_model(model_name,
         W = W.tolist()
         W = [cp.array(item) for item in 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
 
 
 
@@ -399,6 +430,7 @@ def predict_from_storage(Input, model_name, model_path='', dtype=cp.float32):
         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]
@@ -408,20 +440,37 @@ def predict_from_storage(Input, model_name, model_path='', dtype=cp.float32):
         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]
 
-            return result
+            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
+
+            result = layer
+
+        return result
 
     except:
         print(Fore.RED + "ERROR: Unexpected Output or wrong model parameters from: predict_model_ssd." + Style.RESET_ALL)
@@ -461,7 +510,7 @@ def reverse_predict_from_storage(output, model_name, model_path='', dtype=cp.flo
         sys.exit()
 
 
-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
@@ -476,7 +525,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:
     cupyarray: Output from the model.
     """
@@ -490,24 +542,41 @@ 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]
-            
+
         Input = standard_scaler(None, Input, scaler_params)
-        
-        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_ram." + Style.RESET_ALL)
@@ -594,4 +663,9 @@ def get_model_version():
 
 def get_model_df():
      
-    return 10
+    return 10
+
+
+def get_act_pot():
+     
+    return 11