Davout 0.1.1.dev169__tar.gz → 0.1.1.dev171__tar.gz

{davout-0.1.1.dev169/source/Davout.egg-info → davout-0.1.1.dev171}/PKG-INFO

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

{davout-0.1.1.dev169 → davout-0.1.1.dev171}/pyproject.toml

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

{davout-0.1.1.dev169 → davout-0.1.1.dev171}/source/Davout/DeepMech/aa_tests/mecsol_2026_quotient_space/neural_network_trainer.py

@@ -24,7 +24,8 @@ class SurrogateModel:
     def __init__(self, displacement_data_file, input_data_file, 
     saved_model_file, results_path, n_training_samples, 
     quotient_space_dimension, n_monte_carlo_realizations, n_best_models,
-    n_best_samples, mesh_file_name, screenshots_path):
+    n_best_samples, mesh_file_name, screenshots_path, optimizer, 
+    loss_metric):
 
         # Stores the data
 
@@ -50,6 +51,10 @@ class SurrogateModel:
 
         self.screenshots_path = screenshots_path
 
+        self.optimizer = optimizer
+
+        self.loss_metric = loss_metric
+
         # Reads the two files
 
         self.output_data = np.load(self.results_path+"//"+
@@ -60,7 +65,7 @@ class SurrogateModel:
         # Sets a list of layers and the activation functions
 
         self.activations_list = [{"elu": {"number of neurons": 100}}, {
-        "elu": {"number of neurons": 1000}}, {"linear": 
+        "elu": {"number of neurons": 100}}, {"linear": 
         self.n_output_neurons}]
 
     # Defines a function to train the neural network model
@@ -108,12 +113,11 @@ class SurrogateModel:
         # Sets the optimization class for training
 
         training_class = training_tools.ModelCustomTraining(custom_model,
-        training_data, training_true_values, 
-        tf.keras.losses.MeanAbsoluteError(), verbose=True, n_iterations=
-        maximum_iterations, verbose_deltaIterations=
+        training_data, training_true_values, self.loss_metric, verbose=
+        True, n_iterations=maximum_iterations, verbose_deltaIterations=
         verbose_delta_iterations, save_model_file=self.saved_model_file, 
         match_data_float_type_to_trainables=True, parent_path=
-        self.results_path)
+        self.results_path, optimizer=self.optimizer)
 
         t_initial = time()
 
@@ -515,6 +519,11 @@ if __name__=="__main__":
 
     n_best_samples = 10
 
+    optimizer = "Adam"
+
+    loss_metric = {"name": "LpNormError", "p": 12, 
+    "use_stable_implementation": True}
+
     training_flag = True 
 
     test_flag = False
@@ -532,7 +541,8 @@ if __name__=="__main__":
     surrogate_model_class = SurrogateModel(displacement_data_file, 
     input_data_file, saved_model_file, results_path, n_training_samples, 
     quotient_space_dimension, n_monte_carlo_realizations, n_best_models,
-    n_best_samples, mesh_file_name, screenshots_path)
+    n_best_samples, mesh_file_name, screenshots_path, optimizer, 
+    loss_metric)
 
     # Sets training forth if it is the case
 

{davout-0.1.1.dev169 → davout-0.1.1.dev171}/source/Davout/DeepMech/tool_box/loss_assembler_classes.py

@@ -951,7 +951,7 @@ class QuadraticLossOverAnyResidualAssembler(tf.keras.losses.Loss):
 #                          Conventional losses                         #
 ########################################################################
 
-# Defines a function for the maximum absolute error
+# Defines a class for the maximum absolute error
 
 class MaximumAbsoluteError(tf.keras.losses.Loss):
 
@@ -965,4 +965,162 @@ class MaximumAbsoluteError(tf.keras.losses.Loss):
 
     def minimum_absolute_error(self, y_true, y_pred):
 
-        return tf.reduce_min(tf.abs(y_true - y_pred))
+        return tf.reduce_min(tf.abs(y_true - y_pred))
+
+# Defines a class for the Lp norm of the absolute error
+
+class LpNormError(tf.keras.losses.Loss):
+
+    """
+    Lp norm of the error. This loss evaluates the following expression,
+
+    L = (E_ij^p)^(1/p),
+
+    where E_ij is the error measured at the j-th component of the i-th 
+    sample. 
+    
+    Parameters
+    ----------
+    p : float, default=2.0
+        p exponent of the Lp norm.
+        
+    name : str, default="lp_norm_loss"
+        Name of the loss function instance.
+    """
+
+    def __init__(self, p=2.0, epsilon=1E-7, dtype=tf.float32, name="lp"+
+    "_norm_loss", use_stable_implementation=False, **kwargs):
+
+        super().__init__(name=name, dtype=tf.as_dtype(dtype), **kwargs)
+
+        # Saves the original rawly given objects
+
+        self.raw_p = float(p)
+
+        self.raw_epsilon = float(epsilon)
+
+        self.raw_dtype = tf.as_dtype(dtype).name
+
+        self.use_stable_implementation = use_stable_implementation
+
+        # Saves the live object
+
+        self.epsilon = tf.cast(epsilon, dtype=self.dtype)
+
+        # Verifies if the stable implementation is to be used
+
+        if self.use_stable_implementation:
+
+            self.p = tf.cast(self.raw_p, dtype=self.dtype)
+            
+            # Selects the call method that scales and rescales the loss
+            # function to avoid numerical instabilities
+
+            self.call_method = self.scale_evaluate_and_rescale_method
+
+        # Verifies if the exponent p is an even positive integer
+
+        elif self.raw_p%2==0 and self.raw_p>1.0:
+
+            self.p = tf.cast(self.raw_p, dtype=self.dtype)
+
+            # Selects the call method to avoid evaluating the absolute
+            # value
+
+            self.call_method = self.even_exponent_loss
+
+        # Otherwise, changes p to half of p to compensate for the smooth
+        # absolute value
+
+        elif self.raw_p>=1.0:
+
+            self.p = tf.cast(self.raw_p*0.5, dtype=self.dtype)
+
+            # Selects the call method to ensure evaluating the absolute
+            # value before evaluating the Lp norm
+
+            self.call_method = self.non_even_exponent_loss
+
+        else:
+
+            raise ValueError("The 'p' exponent in 'LpNormError' loss c"+
+            "lass must be greater than or equal to 1. Currently, it is"+
+            ": "+str(p))
+
+        # Sets the reciprocal of the original p exponent
+
+        self.p_reciprocal = tf.cast(1.0/self.raw_p, dtype=self.dtype)
+
+    # Defines the generic call method to be differentiated using AD
+
+    def call(self, y_true, y_model):
+
+        return self.call_method(y_true, y_model)
+
+    # Defines the call method to evaluate the loss function when the ex-
+    # ponent is an even integer
+
+    def even_exponent_loss(self, y_true, y_model):
+
+        # Computes the Lp norm of the error tensor. Adds a constant epsi-
+        # lon to the computation of the p-th root to avoid exploding gra-
+        # dients when the p-th root tends to zero
+
+        return tf.pow(tf.reduce_sum(tf.pow(y_true-y_model, self.p), 
+        axis=-1)+self.epsilon, self.p_reciprocal)
+
+    # Defines the call method to evaluate the loss function when the ex-
+    # ponent is not an integer or when it is an odd integer. Thus, the 
+    # absolute value is taken first
+
+    def non_even_exponent_loss(self, y_true, y_model):
+
+        # Evaluates the smooth absolute value of the error tensor first
+
+        absolute_error = tf.square(y_true-y_model)+self.epsilon
+
+        # Computes the Lp norm of the error tensor
+
+        return tf.pow(tf.reduce_sum(tf.pow(absolute_error, self.p),
+        axis=-1), self.p_reciprocal)
+
+    # Defines a safe and numerically stable evaluation of this loss 
+    # function common to both even and odd exponents. With the caveat
+    # that the absolute value is calculated using tf.abs
+
+    def scale_evaluate_and_rescale_method(self, y_true, y_model):
+
+        # Evaluates the absolute error tensor
+
+        absolute_error_tensor = tf.abs(y_true-y_model)
+
+        # Gets the maximum error per sample as a tensor
+
+        maximum_per_sample = tf.reduce_max(absolute_error_tensor, axis=
+        -1, keepdims=True)
+
+        # Divides the error tensor by the maximum absolute error. But 
+        # care is taken to avoid division by zero
+
+        absolute_error_tensor = tf.math.divide_no_nan(
+        absolute_error_tensor, maximum_per_sample)
+
+        # Evaluates the Lp norm by computing the powers with the scaled
+        # components then muliplying by the scale factor
+
+        return tf.squeeze(maximum_per_sample, axis=-1)*tf.pow(
+        tf.reduce_sum(tf.pow(absolute_error_tensor, self.p), axis=-1),
+        self.p_reciprocal)
+
+    # Defines the get-config method to ensure serialization when saving
+    # and loading models
+
+    def get_config(self):
+
+        config = super().get_config()
+
+        config.update({"p": self.raw_p, "dtype": self.raw_dtype, "epsi"+
+        "lon": self.raw_epsilon, "use_stable_implementation":
+        self.use_stable_implementation})
+
+        return config

{davout-0.1.1.dev169 → davout-0.1.1.dev171}/source/Davout/DeepMech/tool_box/training_tools.py

@@ -24,6 +24,8 @@ from ..tool_box import loss_tools
 
 from ..tool_box import parameters_tools
 
+from ..tool_box import loss_assembler_classes
+
 from ...PythonicUtilities import path_tools
 
 from ...PythonicUtilities import string_tools
@@ -32,6 +34,10 @@ from ...PythonicUtilities.function_tools import verify_dictionary_as_function_ar
 
 from ...PythonicUtilities.user_interaction_tools import PrintForLoopInfo
 
+from ...PythonicUtilities.programming_tools import dispatch_classes
+
+from ...PythonicUtilities.dictionary_tools import delete_dictionary_keys
+
 # Defines a class to optimize the model's parameters
 
 class ModelTraining:
@@ -48,8 +54,6 @@ class ModelTraining:
 
         self.model = model
 
-        self.loss_metric = loss_metric
-
         self.optimizer = optimizer
 
         self.n_iterations = n_iterations
@@ -60,6 +64,11 @@ class ModelTraining:
 
         self.verbose = verbose
 
+        # Transforms the loss metric to a live loss class instance if it
+        # were given as a string or dictionary
+
+        self.loss_metric = verify_loss_metric(loss_metric)
+
         # Gets the number of trainable parameters of the model
 
         self.number_trainable_parameters = self.model.count_params()
@@ -233,7 +242,10 @@ class ModelCustomTraining:
 
         self.verbose = verbose
 
-        self.loss_metric = loss_metric
+        # Transforms the loss metric to a live loss class instance if it
+        # were given as a string or dictionary
+
+        self.loss_metric = verify_loss_metric(loss_metric)
 
         # Gets the number of trainable parameters of the model
 
@@ -389,7 +401,8 @@ class ModelCustomTraining:
                 # are consistent
 
                 verify_dictionary_as_function_argument(
-                optimizer_class.__init__, optimizer_additional_info)
+                optimizer_class.__init__, optimizer_additional_info,
+                list_of_arguments_not_to_be_verified=["self", "kwargs"])
 
                 # Sets the hyperparameters
 
@@ -512,6 +525,13 @@ class ModelCustomTraining:
             self.model, self.loss_metric, self.training_input, 
             model_true_values=self.training_trueValues, verbose=verbose)
 
+        # Otherwise, initializes the flat tensor of model parameters as
+        # a None object
+
+        else:
+
+            self.model_parameters = None
+
     # Defines a method to evaluate the hessian of each output neuron of
     # the model
 
@@ -576,7 +596,7 @@ class ModelCustomTraining:
     # proper for use with Keras' optimizers
 
     @tf.function
-    def loss_function_keras(self, model_parameters):
+    def loss_function_keras(self):
 
         # Gets the model response
 
@@ -589,12 +609,12 @@ class ModelCustomTraining:
     # Defines a method to evaluate the loss function given the trainable
     # parameters as input
 
-    def loss_function_scipy(self, model_parameters):
+    def loss_function_scipy(self):
 
         # Gets the loss value and returns it
 
         return self.loss_class.evaluate_scalar_function(
-        model_parameters)
+        self.model_parameters)
     
     # Defines a function to evaluate the loss function on other sets of
     # data
@@ -752,7 +772,7 @@ class ModelCustomTraining:
 
         start_time = time.time()
 
-        initial_loss = self.loss_function(self.model_parameters).numpy()
+        initial_loss = self.loss_function().numpy()
 
         # Iterates through the optimization loop
 
@@ -803,8 +823,7 @@ class ModelCustomTraining:
 
                     # Gets the loss function value and the gradient
 
-                    loss_value = self.loss_function(
-                    self.model_parameters)
+                    loss_value = self.loss_function()
 
                     # Gets the gradient from the second position of the 
                     # call method
@@ -812,6 +831,14 @@ class ModelCustomTraining:
                     evaluated_gradient = self.loss_class(
                     self.model_parameters)[1]
 
+                # If it is a Keras' optimizer, the gradient must be 
+                # flattened
+
+                else:
+
+                    evaluated_gradient = tf.concat([tf.reshape(tensor, 
+                    [-1]) for tensor in evaluated_gradient], axis=0)
+
                 # Gets the gradient norm
 
                 gradient_value = tf.norm(evaluated_gradient).numpy()
@@ -858,8 +885,7 @@ class ModelCustomTraining:
 
             # Gets the final loss function
 
-            final_loss = self.loss_function(self.model_parameters
-            ).numpy()
+            final_loss = self.loss_function().numpy()
 
             print("\n#################################################"+
             "#######################\n#                        Trainin"+
@@ -1099,7 +1125,7 @@ class ModelCustomTraining:
         print("Loads the best model")
 
         self.model = tf.keras.models.load_model(self.parent_path+"//1_"+
-        "best_model.keras")
+        "best_"+model_base_name+".keras")
 
 ########################################################################
 #                               Utilities                              #
@@ -1122,4 +1148,125 @@ def integer_toString(number, maximum_digits):
 
         number_string = " "+number_string
 
-    return number_string
+    return number_string
+
+# Defines a function to verify if a given loss metric is a valid Keras'
+# loss or whether it is a custom loss
+
+def verify_loss_metric(loss_metric):
+
+    # Assembles a dictionary of all natively available Keras' losses
+
+    available_keras_losses = {}
+
+    for loss_name, loss_class in inspect.getmembers(tf.keras.losses):
+
+        # Verifies if the object is indeed a class and if it is a sub-
+        # class of the Keras' Loss parent class. Also excludes objects
+        # starting with _
+
+        if inspect.isclass(loss_class) and issubclass(loss_class, 
+        tf.keras.losses.Loss) and (not loss_name.startswith("_")):
+
+            # Saves the object's name in lower case 
+
+            available_keras_losses[loss_name.lower()] = loss_class
+
+    # Verifies if the loss metric is a string
+
+    if isinstance(loss_metric, str):
+
+        # Converts it to a dictionary first
+
+        loss_metric = {"name": loss_metric}
+
+    # Verifies if the loss metric is a dictionary
+
+    if isinstance(loss_metric, dict):
+
+        # Verifies if this dictionary has the key name
+
+        if not ("name" in loss_metric):
+
+            raise ValueError("'loss_metric' is a dictionary, but it do"+
+            "es not have the key 'name'. This key is essential to find"+
+            "ing the loss metric. Check the given 'loss_metric':\n"+str(
+            loss_metric))
+
+        # Recovers the name of the loss metric and removes this key-value
+        # pair from the dictionary
+
+        loss_metric_name = loss_metric["name"]
+
+        loss_metric_info = delete_dictionary_keys(loss_metric, "name")
+
+        # Verifies if this loss is a Keras' loss
+
+        if loss_metric_name.lower() in available_keras_losses:
+
+            # Recovers the loss class
+
+            loss_metric = available_keras_losses[
+            loss_metric_name.lower()]
+
+            # Verifies if the input dictionary has valid arguments for 
+            # the instantiation of the class
+
+            verify_dictionary_as_function_argument(loss_metric.__init__, 
+            loss_metric_info, list_of_arguments_not_to_be_verified=["s"+
+            "elf", "kwargs"])
+
+            # Instantiates the class
+
+            return loss_metric(**loss_metric_info)
+
+        # Otherwise, verifies if they are a custom loss function defined
+        # in loss_assembler_class.py
+
+        else:
+
+            # Verifies if the given loss name is a valid class
+
+            loss_metric_result = dispatch_classes([loss_metric_name],
+            loss_assembler_classes, class_input=loss_metric_info,
+            class_kind_name_for_error_message="loss class", 
+            return_error_message=True)
+
+            # If the result is a string, it means the loss class was not
+            # found
+
+            if isinstance(loss_metric_result, str):
+
+                keras_losses = ""
+
+                for name in available_keras_losses:
+
+                    keras_losses += "\n'"+str(name)+"'"
+
+                raise ValueError("'loss_metric' was not found in Keras"+
+                "' native loss functions nor in the custom-built ones."+
+                "\nThe given name is '"+str(loss_metric_name)+"'. Chec"+
+                "k the available Keras' loss functions:\n"+keras_losses+
+                "\n\nCheck the error for the custom-built losses:\n"+
+                loss_metric_result)
+
+            # Otherwise, takes the loss class instance from the result
+            # dictionary
+
+            return loss_metric_result[loss_metric_name]
+
+    # Otherwise, verifies if the loss metric is a Keras' loss instance
+
+    elif not isinstance(loss_metric, tf.keras.losses.Loss):
+
+        raise TypeError("'loss_metric' can be a string with the name o"+
+        "f a loss function from\nKeras or from the custom-built loss f"+
+        "unctions. It can also be a dictio-\nnary with the name of the"+
+        " loss function and additional information. Fi-\nnally, 'loss_"+
+        "metric' can be an instance of a Keras' native loss. Curren-\n"+
+        "tly, it is neither. Check the provided 'loss_metric':\n"+str(
+        loss_metric))
+
+    # If no error has been risen, just returns the loss instance
+
+    return loss_metric

{davout-0.1.1.dev169 → davout-0.1.1.dev171}/source/Davout/PythonicUtilities/function_tools.py

@@ -81,7 +81,7 @@ False):
 # arguments? Does it have any keys that are not keyword arguments?
 
 def verify_dictionary_as_function_argument(function_object, 
-input_dictionary):
+input_dictionary, list_of_arguments_not_to_be_verified=[]):
 
     # Gets the dictionary of keyword arguments and the list of positi-
     # onal arguments
@@ -93,7 +93,8 @@ input_dictionary):
 
     for argument_name in positional_arguments_list:
 
-        if not (argument_name in input_dictionary):
+        if (not (argument_name in input_dictionary)) and (not (
+        argument_name in list_of_arguments_not_to_be_verified)):
 
             # Gets a string with the positional arguments
 

{davout-0.1.1.dev169 → davout-0.1.1.dev171}/source/Davout/PythonicUtilities/programming_tools.py

@@ -41,6 +41,17 @@ sys.modules["dictionary_tools"] = dictionary_tools
 
 specifications.loader.exec_module(dictionary_tools)
 
+# Imports function tools
+
+specifications = util.spec_from_file_location("function_tools", 
+broken_path[1]/"PythonicUtilities"/"function_tools.py")
+
+function_tools = util.module_from_spec(specifications)
+
+sys.modules["function_tools"] = function_tools
+
+specifications.loader.exec_module(function_tools)
+
 ########################################################################
 #                             Progress bar                             #
 ########################################################################
@@ -688,7 +699,9 @@ None, searched_entity="classes"):
 @optional_argumentsInitializer({'reserved_entities': lambda: []})
 
 def dispatch_classes(methods_names, searched_file, parent_class=None, 
-class_input=None, reserved_entities=None):
+class_input=None, reserved_entities=None, 
+class_kind_name_for_error_message="class method", return_error_message=
+False):
 
     # Assures methods_names is a list, or a tuple or a dictionary
 
@@ -732,9 +745,18 @@ class_input=None, reserved_entities=None):
 
                     available_list += "'"+name+"'\n"
 
+                # If the error message is to be returned instead of au-
+                # tomatically risen
+
+                if return_error_message:
+
+                    return ("'"+str(method_name)+"' is not an availabl"+
+                    "e "+class_kind_name_for_error_message+". Find one"+
+                    " in the list:"+available_list)
+
                 raise NameError("'"+str(method_name)+"' is not an avai"+
-                "lable class method. Find one in the list:"+
-                available_list)
+                "lable "+class_kind_name_for_error_message+". Find one"+
+                " in the list:"+available_list)
 
     elif isinstance(class_input, tuple):
 
@@ -756,9 +778,62 @@ class_input=None, reserved_entities=None):
 
                     available_list += "'"+name+"'\n"
 
+                # If the error message is to be returned instead of au-
+                # tomatically risen
+
+                if return_error_message:
+
+                    return ("'"+str(method_name)+"' is not an availabl"+
+                    "e "+class_kind_name_for_error_message+". Find one"+
+                    " in the list:"+available_list)
+
                 raise NameError("'"+str(method_name)+"' is not an avai"+
-                "lable class method. Find one in the list:"+
-                available_list)
+                "lable "+class_kind_name_for_error_message+". Find one"+
+                " in the list:"+available_list)
+
+    # If the class input is a dictionary
+
+    elif isinstance(class_input, dict):
+    
+        for method_name in methods_names:
+
+            # If the name is in the list of available methods, updates 
+            # the dictionary of classes
+
+            if method_name in available_methodsNames:
+
+                # Verifies if the given class input has all the necessary
+                # positional arguments and possible keyword arguments
+
+                function_tools.verify_dictionary_as_function_argument(
+                methods_classesDict[method_name].__init__, class_input,
+                list_of_arguments_not_to_be_verified=["self", "kwargs"])
+
+                # Instantiates the class by unpacking the dictionary
+
+                methods_classes[method_name] = methods_classesDict[
+                method_name](**class_input)
+
+            else:
+
+                available_list = "\n"
+
+                for name in available_methodsNames:
+
+                    available_list += "'"+name+"'\n"
+
+                # If the error message is to be returned instead of au-
+                # tomatically risen
+
+                if return_error_message:
+
+                    return ("'"+str(method_name)+"' is not an availabl"+
+                    "e "+class_kind_name_for_error_message+". Find one"+
+                    " in the list:"+available_list)
+
+                raise NameError("'"+str(method_name)+"' is not an avai"+
+                "lable "+class_kind_name_for_error_message+". Find one"+
+                " in the list:"+available_list)
 
     else:
 
@@ -780,9 +855,18 @@ class_input=None, reserved_entities=None):
 
                     available_list += "'"+name+"'\n"
 
+                # If the error message is to be returned instead of au-
+                # tomatically risen
+
+                if return_error_message:
+
+                    return ("'"+str(method_name)+"' is not an availabl"+
+                    "e "+class_kind_name_for_error_message+". Find one"+
+                    " in the list:"+available_list)
+
                 raise NameError("'"+str(method_name)+"' is not an avai"+
-                "lable class method. Find one in the list:"+
-                available_list)
+                "lable "+class_kind_name_for_error_message+". Find one"+
+                " in the list:"+available_list)
         
     # Returns the dictionary of classes that will be used given the na-
     # mes and the available classes