Davout 0.1.1.dev156__tar.gz → 0.1.1.dev158__tar.gz

{davout-0.1.1.dev156/source/Davout.egg-info → davout-0.1.1.dev158}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Davout
-Version: 0.1.1.dev156
+Version: 0.1.1.dev158
 Summary: Scientific computing utilities combining FEM, ANN and tooling
 Author: Matheus Janczkowski
 Author-email: Matheus Janczkowski <matheusj2009@hotmail.com>

{davout-0.1.1.dev156 → davout-0.1.1.dev158}/pyproject.toml

@@ -63,7 +63,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Davout"
-version = "0.1.1.dev156"
+version = "0.1.1.dev158"
 description = "Scientific computing utilities combining FEM, ANN and tooling"
 readme = "README.md"
 authors = [

{davout-0.1.1.dev156 → davout-0.1.1.dev158}/source/Davout/DeepMech/aa_tests/tests_tool_box/test_SVD_based_NNs.py

@@ -352,10 +352,12 @@ class TestSVDArchitecture:
         n_evaluation_runs = 100
 
         # Selects the method for building each Householder vector from 
-        # the flat tensor of DOFs of each Householder chain
+        # the flat tensor of DOFs of each Householder chain. The default
+        # value is 'hardware-based suggestion' which chooses the imple-
+        # mentation based on the hardware: CPU or GPU. The default is 
+        # CPU-oriented
 
-        householder_vector_builder_method = ("get_householder_vector_f"+
-        "rom_parameters")
+        householder_vector_builder_method = "hardware-based suggestion"
 
         # Sets sets of architectures
 
@@ -524,7 +526,8 @@ class TestSVDArchitecture:
             modulating_function_performance, "Householder epsilon": 1.0, 
             "activations accessory layer list": 
             accessory_activation_list_performance, "householder vector"+
-            " builder method": householder_vector_builder_method}  
+            " builder method": householder_vector_builder_method,
+            "hardware device": "CPU"}  
 
             # Assembles the model
 

{davout-0.1.1.dev156 → davout-0.1.1.dev158}/source/Davout/DeepMech/aa_tests/tests_tool_box/test_quotient_space_NNs.py

@@ -11,9 +11,11 @@ import os
 
 import tensorflow as tf
 
-from ...tool_box import ANN_tools
+from .....Davout.DeepMech.tool_box import ANN_tools
 
-from ...tool_box import training_tools
+from .....Davout.DeepMech.tool_box import training_tools
+
+from .....Davout.PythonicUtilities.path_tools import get_parent_path_of_file
 
 # Defines a function to test the ANN tools methods
 
@@ -104,7 +106,60 @@ class TestANNTools(unittest.TestCase):
 
         self.save_model_file = "saved_model.keras"
 
-    # Defines a function to test the gated architecture
+        self.parameters_dtype = "float64"
+    
+    # Defines a function to test saving and reloading the model
+    
+    def test_saving_and_loading(self):
+
+        print("\n#####################################################"+
+        "###################\n#                       Tests saving and"+
+        " loading                       #\n###########################"+
+        "#############################################\n")
+        
+        # Sets the path to save the model
+
+        model_path = os.path.join(get_parent_path_of_file(), "gated_mo"+
+        "del.keras")
+
+        print("\nSaves the model at: "+str(model_path)+"\n")
+
+        # Saves the model
+
+        # Tests now with custom layers
+        
+        ANN_class = ANN_tools.MultiLayerModel(
+        self.input_dimension_gradient_tests, 
+        self.activation_list_gradient_tests, enforce_customLayers=True, 
+        verbose=True, parameters_dtype=self.parameters_dtype, 
+        custom_architecture={"name": "GatedQuotientSpace", 
+        "quotient space dimension": self.quotient_space_dimension})
+
+        custom_model = ANN_class()
+
+        custom_model.save(model_path)
+
+        # Loads it back
+
+        loaded_model = tf.keras.models.load_model(model_path)
+
+        # Gets the training data as a tensorflow array
+
+        self.training_input_constant = tf.constant(self.training_data, 
+        dtype=tf.as_dtype(self.parameters_dtype))
+
+        # Tests the loaded model
+
+        output_original = custom_model(self.training_input_constant)
+
+        output_loaded = loaded_model(self.training_input_constant)
+
+        print("Output from saved model:\n"+str(output_original))
+
+        print("\nOutput from loaded model:\n"+str(output_loaded)+"\n\n"+
+        "The maximum absolute difference between components of the ori"+
+        "ginal and loaded models is: "+str(tf.reduce_max(tf.abs(
+        output_original-output_loaded)).numpy())+"\n")
 
     def test_gated_nn(self):
 

{davout-0.1.1.dev156 → davout-0.1.1.dev158}/source/Davout/DeepMech/custom_architectures/SVD_quotient_space.py

@@ -38,15 +38,63 @@ class SVDQuotientSpace:
         "thod": {"type": str, "description": "String with the name of "+
         "the function that constructs each Householder vector from the"+
         " flat tensor of DOFs of the Householder chain for each orthog"+
-        "onal matrix", "default": "get_householder_vector_from_paramet"+
-        "ers"}}, "custom_architecture", "SVDQuotientSpace")
+        "onal matrix", "default": "hardware-based suggestion"}, "hardw"+
+        "are device": {"type": str, "description": "String with the na"+
+        "me of the device that runs the code. It can be either 'CPU' o"+
+        "r 'GPU'", "default": "CPU"}}, 
+        "custom_architecture", "SVDQuotientSpace")
 
-        # Selects the method for computing the Householder vectors from
-        # the flat tensor of parameters
+        # Checks whether the code is run in CPU or GPU
 
-        self.method_for_householder_vector_from_parameters = getattr(
-        self, architecture_info_dict["householder vector builder metho"+
-        "d"])
+        if architecture_info_dict["hardware device"]=="CPU":
+
+            # Uses the method that stores the Householder DOFs in a Ten-
+            # sorArray. This method was benchmarked to be the fastest 
+            # option in CPU
+
+            self.multiply_input_vector_by_householder_chain = (
+            self.multiply_input_vector_by_householder_chain_tensor_array)
+
+            # Selects, thus, the method that extracts and assembles the
+            # Householder vector
+
+            self.method_for_householder_vector_from_parameters = (
+            self.get_householder_vector_from_parameters_tensor_array)
+
+        elif architecture_info_dict["hardware device"]=="GPU":
+
+            # Uses the method that stores the Householder DOFs in a flat
+            # tensor, then each Householder vector is sliced from the 
+            # flat tensor. This method was benchmarked to be the fastest 
+            # option in GPU
+
+            self.multiply_input_vector_by_householder_chain = (
+            self.multiply_input_vector_by_householder_chain_slice)
+
+            # Selects, thus, the method that extracts and assembles the
+            # Householder vector
+
+            self.method_for_householder_vector_from_parameters = (
+            self.get_householder_vector_from_parameters_slice)
+
+        else:
+
+            raise ValueError("The value for the key 'hardware device' "+
+            "in 'SVDQuotientSpace' is '"+str(architecture_info_dict["h"+
+            "ardware device"])+"'. But it must be 'CPU' or 'GPU'")
+
+        # Checks if a specific method to get the Householder vector was
+        # prescribed by the used
+
+        if architecture_info_dict["householder vector builder method"
+        ]!="hardware-based suggestion":
+
+            # Selects the method for computing the Householder vectors 
+            # from the flat tensor of parameters
+
+            self.method_for_householder_vector_from_parameters = getattr(
+            self, architecture_info_dict["householder vector builder m"+
+            "ethod"])
         
         # Stores variables that will be used in the get_config for seri-
         # alization and class rebuilding
@@ -1328,14 +1376,13 @@ class SVDQuotientSpace:
     # m_rank-1))], where m_rank is the number of columns of the final 
     # orthogonal matrix, and n_rows is the number of rows. Receives the
     # index of the Householder reflector in the Householder chain to
-    # collect the corresponding Householder vector
+    # collect the corresponding Householder vector. This function slices
+    # the flat tensor of Householder parameters to recover the DOFs of 
+    # the current Householder vector
     
-    def get_householder_vector_from_parameters(self, 
+    def get_householder_vector_from_parameters_slice(self, 
     householder_first_index, householder_length, 
-    householder_number_of_leading_zeros, 
-    #split_householder_DOFs,
-    householder_parameters, 
-    #householder_dofs_tensor_array,
+    householder_number_of_leading_zeros, householder_parameters, 
     householder_reflector_index, input_dimensionality):
         
         # Gets the first and last indices of the Householder vector, 
@@ -1349,16 +1396,52 @@ class SVDQuotientSpace:
         number_of_leading_zeros = householder_number_of_leading_zeros[
         householder_reflector_index]
 
-        #"""
+        # Slices the DOFs of this Householder vector from the flat ten-
+        # sor of DOFs of the Householder chain
+
         raw_vector = tf.slice(householder_parameters, [initial_index], [
-        length])#"""
+        length])
+
+        # Computes the average of the raw vector
+
+        average_raw_vector = tf.reduce_mean(raw_vector)
+
+        # Concatenates the non-free component of the Householder vector
+        # to the first position
+
+        raw_vector = tf.math.l2_normalize(tf.concat([tf.sqrt(
+        tf.math.square(average_raw_vector)+
+        self.householder_epsilon_squared)[None], raw_vector], axis=0))
+
+        # Rescales the raw vector to have unit norm, then adds the trai-
+        # ling zeros and returns it
+
+        return raw_vector, number_of_leading_zeros
+
+    # Defines a function to parse a single Householder vector from a
+    # vector of all Householder vectors to construct an orthogonal ma-
+    # trix. The incoming vector is a tensor [0.5*(m_rank*((2*n_rows)-
+    # m_rank-1))], where m_rank is the number of columns of the final 
+    # orthogonal matrix, and n_rows is the number of rows. Receives the
+    # index of the Householder reflector in the Householder chain to
+    # collect the corresponding Householder vector. This function reco-
+    # vers the DOFs of the Householder parameters from a TensorArray
+    
+    def get_householder_vector_from_parameters_tensor_array(self, 
+    householder_first_index, householder_length, 
+    householder_number_of_leading_zeros, householder_dofs_tensor_array,
+    householder_reflector_index, input_dimensionality):
+        
+        # Gets the number of leading zeros of this Householder vector
+
+        number_of_leading_zeros = householder_number_of_leading_zeros[
+        householder_reflector_index]
 
-        #raw_vector = split_householder_DOFs[householder_reflector_index]
+        # Recovers the DOFs of this Householder vector from the Tensor-
+        # Array
 
-        # TensorArray
-        """
         raw_vector = householder_dofs_tensor_array.read(
-        householder_reflector_index) #"""
+        householder_reflector_index)
 
         # Computes the average of the raw vector
 
@@ -1386,10 +1469,7 @@ class SVDQuotientSpace:
     def multiply_input_vector_by_householder_reflector(self, 
     input_vector, householder_reflector_index, householder_first_index, 
     householder_length, householder_number_of_leading_zeros, 
-    #split_householder_DOFs,
-    householder_parameters_orthogonal_matrix, 
-    #householder_dofs_tensor_array,
-    input_dimensionality):
+    tensor_with_householder_parameters, input_dimensionality):
         
         # Gets the Householder vector from the Householder parameters of
         # the B matrix. Keep in mind that the order of the Householder 
@@ -1400,10 +1480,8 @@ class SVDQuotientSpace:
         ) = self.method_for_householder_vector_from_parameters(
         householder_first_index, householder_length, 
         householder_number_of_leading_zeros, 
-        #split_householder_DOFs,
-        householder_parameters_orthogonal_matrix, 
-        #householder_dofs_tensor_array,
-        householder_reflector_index, input_dimensionality)
+        tensor_with_householder_parameters, householder_reflector_index, 
+        input_dimensionality)
 
         # Multiplies the input vector by the Householder reflector (the
         # operation is already broken down into the rank-1 calculation).
@@ -1419,27 +1497,49 @@ class SVDQuotientSpace:
     # Defines a function to create a wrapper for the method that multi-
     # plies the input vector by an orthogonal matrix and, then, calls
     # foldl to evaluate the chain of Householder reflectors operating on
-    # the input vector
+    # the input vector. This function passes the flat tensor of Househol-
+    # der parameters and it is sliced to create the Householder vector
 
-    def multiply_input_vector_by_householder_chain(self, input_vector, 
-    householder_reflector_indices, householder_first_index, 
+    def multiply_input_vector_by_householder_chain_slice(self, 
+    input_vector, householder_reflector_indices, householder_first_index, 
     householder_length, householder_number_of_leading_zeros, 
     householder_parameters_orthogonal_matrix, input_dimensionality):
 
-        # Splits the Householder DOFs of each Householder vector from 
-        # the flat tensor of DOFs of the chain
+        # Defines the step function that will perform each update of the
+        # input tensor by means of the Householder reflector
 
-        #split_householder_DOFs = tf.split(
-        #householder_parameters_orthogonal_matrix, householder_length)
+        def update_step(accumulator_vector, householder_reflector_index):
 
-        """
-        split_householder_DOFs = tf.RaggedTensor.from_row_lengths(
-        householder_parameters_orthogonal_matrix,
-        householder_length)#"""
+            return self.multiply_input_vector_by_householder_reflector(
+            accumulator_vector, householder_reflector_index, 
+            householder_first_index, householder_length, 
+            householder_number_of_leading_zeros, 
+            householder_parameters_orthogonal_matrix,
+            input_dimensionality)
+
+        # Uses foldl to perform the chain multiplication
+
+        return tf.foldl(update_step, householder_reflector_indices,
+        initializer=input_vector)
+
+    # Defines a function to create a wrapper for the method that multi-
+    # plies the input vector by an orthogonal matrix and, then, calls
+    # foldl to evaluate the chain of Householder reflectors operating on
+    # the input vector. This function splits the flat tensor of Househol-
+    # der parameters first and passes a TensorArray object to create the 
+    # Householder vector
+
+    def multiply_input_vector_by_householder_chain_tensor_array(
+    self, input_vector, householder_reflector_indices, 
+    householder_first_index, householder_length, 
+    householder_number_of_leading_zeros, 
+    householder_parameters_orthogonal_matrix, input_dimensionality):
+
+        # Splits the Householder DOFs of each Householder vector from 
+        # the flat tensor of DOFs of the chain
 
-        """
         householder_dofs_tensor_array = self.split_flat_tensor_into_householder_dofs(
-        householder_parameters_orthogonal_matrix, householder_length)#"""
+        householder_parameters_orthogonal_matrix, householder_length)
 
         # Defines the step function that will perform each update of the
         # input tensor by means of the Householder reflector
@@ -1450,10 +1550,7 @@ class SVDQuotientSpace:
             accumulator_vector, householder_reflector_index, 
             householder_first_index, householder_length, 
             householder_number_of_leading_zeros, 
-            #split_householder_DOFs,
-            householder_parameters_orthogonal_matrix,
-            #householder_dofs_tensor_array,
-            input_dimensionality)
+            householder_dofs_tensor_array, input_dimensionality)
 
         # Uses foldl to perform the chain multiplication
 

{davout-0.1.1.dev156 → davout-0.1.1.dev158}/source/Davout/DeepMech/tool_box/ANN_tools.py

@@ -4,6 +4,8 @@ import tensorflow as tf
 
 import numpy as np
 
+import inspect
+
 from ...DeepMech import custom_architectures
 
 from ..tool_box import differentiation_tools as diff_tools
@@ -679,8 +681,23 @@ class MixedActivationLayer(tf.keras.layers.Layer):
 
         code_info_dictionary = config.pop("code_given_info_class")
 
+        # Gets all the necessary arguments of CodeGivenLayerInfo
+
+        arguments_of_layer_info = inspect.signature(CodeGivenLayerInfo
+        ).parameters.keys()
+
+        # Completes the dictionary of code-given information to allow
+        # for the inclusion of keys that were not incorporated in older
+        # models. Notice that, for missing keys, the default value will
+        # be None
+
+        complete_dictionary = {argument_name: code_info_dictionary.get(
+        argument_name, None) for argument_name in arguments_of_layer_info}
+
+        # Instantiates the class of code-given information
+
         config["code_given_info_class"] = CodeGivenLayerInfo(
-        **code_info_dictionary)
+        **complete_dictionary)
 
         return cls(**config)
 

{davout-0.1.1.dev156 → davout-0.1.1.dev158/source/Davout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Davout
-Version: 0.1.1.dev156
+Version: 0.1.1.dev158
 Summary: Scientific computing utilities combining FEM, ANN and tooling
 Author: Matheus Janczkowski
 Author-email: Matheus Janczkowski <matheusj2009@hotmail.com>