Davout 0.1.1.dev168__tar.gz → 0.1.1.dev169__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Davout
-Version: 0.1.1.dev168
+Version: 0.1.1.dev169
 Summary: Scientific computing utilities combining FEM, ANN and tooling
 Author: Matheus Janczkowski
 Author-email: Matheus Janczkowski <matheusj2009@hotmail.com>
@@ -23,11 +23,11 @@ to the repository and source files: https://github.com/Matheus-Janczkowski/Davou
 
 1. Link to the booklet on installation of a miscelaneous of software: https://www.overleaf.com/read/wbxhncmtnmkm#0eb73b
 
-2. Link to the book on python programming: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/blob/main/introduction_to_python_programming.pdf
+2. Link to the book on python programming: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/tree/main/introduction_to_python_programming
 
 3. Link to the booklet on writing using LaTeX: https://www.overleaf.com/read/sdrvfrpdjhft#66d6f9
 
-4. Link to the book on continuum mechanics: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/blob/main/introduction_to_continuum_mechanics.pdf
+4. Link to the book on continuum mechanics: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/tree/main/introduction_to_continuum_mechanics
 
 4. Link for the presentation template: https://www.overleaf.com/read/sbgxdphxswmm#6d7d64
 

{davout-0.1.1.dev168 → davout-0.1.1.dev169}/README.md

@@ -4,11 +4,11 @@ to the repository and source files: https://github.com/Matheus-Janczkowski/Davou
 
 1. Link to the booklet on installation of a miscelaneous of software: https://www.overleaf.com/read/wbxhncmtnmkm#0eb73b
 
-2. Link to the book on python programming: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/blob/main/introduction_to_python_programming.pdf
+2. Link to the book on python programming: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/tree/main/introduction_to_python_programming
 
 3. Link to the booklet on writing using LaTeX: https://www.overleaf.com/read/sdrvfrpdjhft#66d6f9
 
-4. Link to the book on continuum mechanics: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/blob/main/introduction_to_continuum_mechanics.pdf
+4. Link to the book on continuum mechanics: https://github.com/Matheus-Janczkowski/CompMechSelfStudy/tree/main/introduction_to_continuum_mechanics
 
 4. Link for the presentation template: https://www.overleaf.com/read/sbgxdphxswmm#6d7d64
 

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

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

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

@@ -515,7 +515,7 @@ if __name__=="__main__":
 
     n_best_samples = 10
 
-    training_flag = False 
+    training_flag = True 
 
     test_flag = False
 

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

@@ -4,6 +4,8 @@ import tensorflow as tf
 
 import sys
 
+import inspect
+
 import numpy as np
 
 from tqdm import tqdm
@@ -14,7 +16,7 @@ import time
 
 from copy import deepcopy
 
-from scipy.optimize import minimize
+from scipy.optimize import minimize, _minimize
 
 from scipy import stats
 
@@ -26,6 +28,10 @@ from ...PythonicUtilities import path_tools
 
 from ...PythonicUtilities import string_tools
 
+from ...PythonicUtilities.function_tools import verify_dictionary_as_function_argument
+
+from ...PythonicUtilities.user_interaction_tools import PrintForLoopInfo
+
 # Defines a class to optimize the model's parameters
 
 class ModelTraining:
@@ -33,8 +39,8 @@ class ModelTraining:
     def __init__(self, model, training_inputArray, training_trueArray,
     loss_metric=tf.keras.losses.MeanAbsoluteError(), optimizer=
     tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9, nesterov=
-    True), n_iterations=1000, gradient_tolerance=1E-3, 
-    float_type=tf.float32, verbose_deltaIterations=100, verbose=False,
+    True), n_iterations=1000, gradient_tolerance=1E-3, float_type=
+    tf.float32, verbose_deltaIterations=100, verbose=False,
     save_model_file="trained_model.keras", parent_path="get current pa"+
     "th"):
         
@@ -99,7 +105,6 @@ class ModelTraining:
     # tor to create a map for compilation, hence, speeding it up
 
     @tf.function
-
     def train_step(self):
 
         with tf.GradientTape() as tape:
@@ -111,7 +116,7 @@ class ModelTraining:
         self.optimizer.apply_gradients(zip(gradients, 
         self.model.trainable_variables))
 
-        return loss, tf.linalg.global_norm(gradients)
+        return loss, gradients
     
     # Defines a method for the optimization loop. But names it call so
     # that it is called as soon as the class is created
@@ -130,7 +135,11 @@ class ModelTraining:
 
         for i in range(self.n_iterations):
 
-            loss_value, gradient_norm = self.train_step()
+            loss_value, gradient_vector = self.train_step()
+
+            # Evaluates the gradient's norm
+
+            gradient_norm = tf.linalg.global_norm(gradient_vector)
 
             if gradient_norm.numpy()<=self.gradient_tolerance:
 
@@ -148,13 +157,18 @@ class ModelTraining:
             
                 if i%self.verbose_deltaIterations==0:
 
+                    gradient_maximum_component = tf.reduce_max(tf.abs(
+                    gradient_vector)).numpy()
+
                     print("Iteration "+integer_toString(i, max_digits)+
                     ": loss="+format(loss_value.numpy(), '.5e')+", gra"+
                     "dient norm: "+format(gradient_norm.numpy(), '.5e')+
                     ", gradient norm divided by the square root of the"+
                     " number of trainable parameters: "+format(
                     gradient_norm.numpy()/
-                    self.number_trainable_parameters, '.5e'))
+                    self.number_trainable_parameters, '.5e')+"\nThe ma"+
+                    "ximum component of the gradient in absolute value"+
+                    " is: "+format(gradient_maximum_component, '.5e'))
 
         # Evaluates the elapsed time
 
@@ -303,14 +317,6 @@ class ModelCustomTraining:
         self.training_trueValues = tf.constant(training_trueArray, dtype
         =self.float_type)
 
-        # Construct a class to give the loss function, its gradient, and
-        # the instructions for parameters (weights and biases) flattening
-        # and reconstruction
-
-        self.loss_class, self.model_parameters = loss_tools.build_loss_gradient_varying_model_parameters(
-        self.model, self.loss_metric, self.training_input, 
-        model_true_values=self.training_trueValues, verbose=verbose)
-
         # Gets the number of output neurons. Tries to get first via a 
         # custom attribute
 
@@ -322,6 +328,190 @@ class ModelCustomTraining:
         
             self.n_outputs = self.model.trainable_variables[-1].shape[0]
 
+        # Verifies if the optimizer is a dictionary
+
+        optimizer_name = None
+
+        optimizer_additional_info = {}
+
+        if isinstance(self.optimizer, dict):
+
+            # Verifies if there is a key for the optimizer's name
+
+            if "name" in self.optimizer:
+
+                # Gets the name
+
+                optimizer_name = self.optimizer["name"]
+
+            # Otherwise, throws an error
+
+            else:
+
+                raise KeyError("There is no key 'name' in the dictiona"+
+                "ry 'optimizer' in 'ModelCustomTraining'. The name mus"+
+                "t be provided to tell the optimization method")
+
+            # Copies all additional information
+
+            for key, value in self.optimizer.items():
+
+                # Excludes the key 'name'
+
+                if key!="name":
+
+                    optimizer_additional_info[key] = value 
+
+        # Verifies if the optimizer variable is a string
+
+        elif isinstance(self.optimizer, str):
+
+            # Copies the optimizer name
+
+            optimizer_name = str(self.optimizer)
+
+        # If an optimizer name was recovered, tracks if it is an optimi-
+        # zer native to Keras or native to scipy
+
+        if optimizer_name is not None:
+
+            # Verifies if it is from Keras
+
+            if hasattr(tf.keras.optimizers, optimizer_name):
+
+                # Sets the optimizer from Keras as an instance of the
+                # corresponding class
+
+                optimizer_class = getattr(tf.keras.optimizers, 
+                optimizer_name)
+
+                # Verifies if the user-given parameters of the optimizer
+                # are consistent
+
+                verify_dictionary_as_function_argument(
+                optimizer_class.__init__, optimizer_additional_info)
+
+                # Sets the hyperparameters
+
+                self.optimizer = optimizer_class(
+                **optimizer_additional_info)
+
+                # Sets the training method as the wrapper for automatic
+                # differentiation and the keras optimizer
+
+                self.set_training = self.set_keras_training
+
+                # Sets the loss function as the one appropriate for Ke-
+                # ras optimizers
+
+                self.loss_function = self.loss_function_keras
+
+                # Sets the flag that tells if a scipy optimizer will be
+                # used to False
+
+                self.use_scipy_optimizer = False
+
+            # Verifies if it is a scipy method
+
+            else:
+
+                # Gets the optimization methods available at scipy
+
+                available_scipy_optimizers = getattr(_minimize,'MINIMI'+
+                'ZE_METHODS',{})
+
+                # Verifies if the given optimizer name is in the list of
+                # available methods
+
+                if not (optimizer_name.lower() in (
+                available_scipy_optimizers)):
+
+                    # Gets the available methods in Keras
+
+                    native_keras_optimizers = ""
+
+                    for name, optimizer_object in inspect.getmembers(
+                    tf.keras.optimizers):
+
+                        if inspect.isclass(optimizer_object) and (
+                        issubclass(optimizer_object, 
+                        tf.keras.optimizers.Optimizer)):
+
+                            native_keras_optimizers += ("\n'"+str(name)+
+                            "'")
+
+                    # Gets the available methods in scipy
+
+                    native_scipy_methods = ""
+
+                    for name in available_scipy_optimizers:
+
+                        native_scipy_methods += "\n'"+str(name)+"'"
+
+                    raise NameError("'"+str(optimizer_name)+"' was not"+
+                    " found in the native Keras' optimizers nor in the"+
+                    " available optimizers at scipy. Check the availab"+
+                    "le methods in Keras:\n"+native_keras_optimizers+
+                    "\n\nand the methods available in scipy:\n"+
+                    native_scipy_methods)
+
+                # Sets the method and the dictionary of additional in-
+                # formation
+
+                self.optimizer = optimizer_name.lower()
+
+                self.optimizer_additional_info = (
+                optimizer_additional_info)
+
+                # Sets the training method as the wrapper for scipy
+
+                self.set_training = self.set_scipy_training
+
+                # Sets the loss function as the one appropriate for sci-
+                # py using a flat tensor of trainable parameters of the
+                # model as input
+
+                self.loss_function = self.loss_function_scipy
+
+                # Sets the flag that tells if a scipy optimizer will be
+                # used to False
+
+                self.use_scipy_optimizer = True
+
+        # Otherwise, treats the given optimizer as a keras-native opti-
+        # mizer
+
+        else:
+
+            # Sets the training method as the wrapper for automatic dif-
+            # ferentiation and the keras optimizer
+
+            self.set_training = self.set_keras_training
+
+            # Sets the loss function as the one appropriate for Keras 
+            # optimizers
+
+            self.loss_function = self.loss_function_keras
+
+            # Sets the flag that tells if a scipy optimizer will be used
+            # to False
+
+            self.use_scipy_optimizer = False
+
+        # If a scipy optimizer will be used, instantiates the class for
+        # the loss function and automatic differentiation, then takes 
+        # the flat tensor of model parameters
+
+        if self.use_scipy_optimizer:
+
+            # Constructs a class to give the loss function, its gra-
+            # dient, and the instructions for parameters (weights and 
+            # biases) flattening and reconstruction
+
+            self.loss_class, self.model_parameters = loss_tools.build_loss_gradient_varying_model_parameters(
+            self.model, self.loss_metric, self.training_input, 
+            model_true_values=self.training_trueValues, verbose=verbose)
+
     # Defines a method to evaluate the hessian of each output neuron of
     # the model
 
@@ -382,14 +572,29 @@ class ModelCustomTraining:
 
         return hessian_matrices
 
-    # Defines a method to evaluate the loss function
+    # Defines a function to evaluate the loss function from the input
+    # proper for use with Keras' optimizers
 
-    def loss_function(self):
+    @tf.function
+    def loss_function_keras(self, model_parameters):
+
+        # Gets the model response
+
+        y_training = self.model(self.training_input)
+
+        # Gets the loss value
+
+        return self.loss_metric(self.training_trueValues, y_training)
+
+    # Defines a method to evaluate the loss function given the trainable
+    # parameters as input
+
+    def loss_function_scipy(self, model_parameters):
 
         # Gets the loss value and returns it
 
         return self.loss_class.evaluate_scalar_function(
-        self.model_parameters)
+        model_parameters)
     
     # Defines a function to evaluate the loss function on other sets of
     # data
@@ -452,19 +657,91 @@ class ModelCustomTraining:
     # Defines a method for training, it assembles the optimization pro-
     # blem and runs it
 
-    def set_training(self, n_max_iterations):
+    def set_scipy_training(self, n_max_iterations):
+
+        # Updates the dictionary of options
+
+        self.optimizer_additional_info["maxiter"] = n_max_iterations
 
         # Sets the minimization problem using the minimize class from 
         # scipy
 
         minimization_problem = minimize(self.loss_class, 
         self.model_parameters, method=self.optimizer, jac=True, tol=
-        self.gradient_tolerance, options={"maxiter": n_max_iterations}, 
+        self.gradient_tolerance, options=self.optimizer_additional_info, 
         callback=self.callback)
 
         # Updates the model parameters
 
         self.model_parameters = minimization_problem.x
+
+        return None, None
+
+    # Defines a method for the train step using native keras optimizers
+
+    def set_keras_training(self, n_max_iterations):
+
+        # Initializes the last evaluations of loss and gradient vectors
+
+        loss_evaluation = None
+
+        gradient_evaluation = None
+
+        # Iterates through the maximum number of iterations
+
+        for i in range(n_max_iterations):
+
+            loss_evaluation, gradient_evaluation = self.keras_training_step()
+
+            # Evaluates the gradient's norm
+
+            gradient_norm = tf.linalg.global_norm(gradient_evaluation)
+
+            if gradient_norm.numpy()<=self.gradient_tolerance:
+
+                print("The gradient's norm has reached the value of "+
+                str(gradient_norm.numpy())+", which is less than the t"+
+                "hreshold of "+str(self.gradient_tolerance)+". Thus, s"+
+                "tops the optimization procedure at iteration "+str(i)+
+                "\n")
+
+                break
+        
+            # Prints the callback
+
+            self.callback(None)
+
+        # Updates the flat tensor of trainable parameters from the upda-
+        # ted parameters of the model
+
+        self.model_parameters, _ = parameters_tools.model_parameters_to_flat_tensor_and_shapes(
+        self.model)
+
+        # Returns the last evaluations of the loss function and of the
+        # gradient vector
+
+        return loss_evaluation, gradient_evaluation
+
+    # Defines a function to compute a single training step using a nati-
+    # ve keras optimizer
+
+    @tf.function
+    def keras_training_step(self):
+
+        # Computes the gradient using automatic differentiation
+
+        with tf.GradientTape() as tape:
+
+            loss = self.loss_function_keras()
+
+        gradients = tape.gradient(loss, self.model.trainable_variables)
+
+        # Applies the gradient vector to the optimizer
+
+        self.optimizer.apply_gradients(zip(gradients, 
+        self.model.trainable_variables))
+
+        return loss, gradients
     
     # Defines a method for the optimization loop. But names it call so
     # that it is called as soon as the class is created
@@ -475,8 +752,7 @@ class ModelCustomTraining:
 
         start_time = time.time()
 
-        initial_loss = self.loss_class.evaluate_scalar_function(
-        self.model_parameters).numpy()
+        initial_loss = self.loss_function(self.model_parameters).numpy()
 
         # Iterates through the optimization loop
 
@@ -516,18 +792,27 @@ class ModelCustomTraining:
                 # Calls the optimization procedure. Using the custom op-
                 # timizer
 
-                self.set_training(self.verbose_deltaIterations)
+                loss_value, evaluated_gradient = self.set_training(
+                self.verbose_deltaIterations)
 
-                # Gets the loss function value and the gradient
+                # If the loss value is None, it signifies that a custom
+                # optimizer was used and the loss function and gradient
+                # vector must be evaluated from the model parameters
 
-                loss_value = self.loss_class.evaluate_scalar_function(
-                self.model_parameters)
+                if self.use_scipy_optimizer:
 
-                # Gets the gradient from the second position of the call
-                # method
+                    # Gets the loss function value and the gradient
 
-                evaluated_gradient = self.loss_class(
-                self.model_parameters)[1]
+                    loss_value = self.loss_function(
+                    self.model_parameters)
+
+                    # Gets the gradient from the second position of the 
+                    # call method
+
+                    evaluated_gradient = self.loss_class(
+                    self.model_parameters)[1]
+
+                # Gets the gradient norm
 
                 gradient_value = tf.norm(evaluated_gradient).numpy()
 
@@ -544,11 +829,11 @@ class ModelCustomTraining:
 
                     break
 
-                print("Iteration group "+integer_toString(i, max_digits)
-                +": loss="+format(loss_value.numpy(), '.5e')+", gradie"+
-                "nt norm: "+format(gradient_value, '.5e')+",\ngradient"+
-                " norm divided by the square root of the number of tra"+
-                "inable parameters: "+format(gradient_value/
+                print("\nIteration group "+integer_toString(i, 
+                max_digits)+": loss="+format(loss_value.numpy(), '.5e')+
+                ", gradient norm: "+format(gradient_value, '.5e')+",\n"+
+                "gradient norm divided by the square root of the numbe"+
+                "r of trainable parameters: "+format(gradient_value/
                 self.number_trainable_parameters, '.5e')+"\nThe maximu"+
                 "m component of the gradient in absolute value is: "+
                 format(gradient_maximum_component, '.5e')+"\nThis cycl"+
@@ -573,8 +858,8 @@ class ModelCustomTraining:
 
             # Gets the final loss function
 
-            final_loss = self.loss_class.evaluate_scalar_function(
-            self.model_parameters).numpy()
+            final_loss = self.loss_function(self.model_parameters
+            ).numpy()
 
             print("\n#################################################"+
             "#######################\n#                        Trainin"+
@@ -588,10 +873,13 @@ class ModelCustomTraining:
 
             print("Training time: "+str(self.elapsed_time)+" seconds.\n")
         
-        # Gets the trained parameters and reassigns them to the model
+        # Gets the trained parameters and reassigns them to the model if 
+        # the model was trained using optimizers from scipy
 
-        self.loss_class.model_output_given_parameters.update_model_parameters(
-        self.model, self.model_parameters)
+        if self.use_scipy_optimizer:
+
+            self.loss_class.model_output_given_parameters.update_model_parameters(
+            self.model, self.model_parameters)
 
         # Saves the model automatically and returns it as well
 
@@ -645,7 +933,12 @@ class ModelCustomTraining:
 
         for i in range(best_models_rank_size):
 
-            models_ranking_dict[i] = np.inf 
+            models_ranking_dict[i+1] = np.inf 
+
+        # Instantiates the class that prints information
+
+        print_class = PrintForLoopInfo(["Initializes the realization o"+
+        "f number "])
 
         # Initializes a variable to store the elapsed time for training
         # each model at each realization
@@ -657,6 +950,11 @@ class ModelCustomTraining:
         for i in tqdm(range(n_realizations), desc="Training realizatio"+
         "ns"):
 
+            # Prints information on terminal that tells that this reali-
+            # zatio is being initialized
+
+            print_class([i+1])
+
             # Reinitializes the model parameters using the same initia-
             # lizers that were assigned when the model was first created
 
@@ -703,13 +1001,11 @@ class ModelCustomTraining:
             # Iterates through the best ranking models to check if the
             # current one outperforms any of them
 
-            for model_number in models_ranking_dict.keys():
+            for model_number, model_loss in models_ranking_dict.items():
 
                 # Gets the model loss and compares it to the loss value
                 # of the current model
 
-                model_loss = models_ranking_dict[model_number]
-
                 if model_loss>training_loss:
 
                     # Deletes the worst performing model, which is the
@@ -734,8 +1030,8 @@ class ModelCustomTraining:
 
                         # And renames the model file
 
-                        path_tools.rename_file(str(j)+"_best_"+
-                        model_base_name+".keras", str(j+1)+"_best_"+
+                        path_tools.rename_file(str(j-1)+"_best_"+
+                        model_base_name+".keras", str(j)+"_best_"+
                         model_base_name+".keras", parent_path=
                         self.parent_path, saving_function=
                         self.model.save)
@@ -748,7 +1044,7 @@ class ModelCustomTraining:
                     # Saves this model
 
                     path_tools.rename_file(self.save_model_file, str(
-                    model_number+1)+"_best_"+model_base_name+".keras", 
+                    model_number)+"_best_"+model_base_name+".keras", 
                     saving_function=self.model.save)
 
                     # Breaks the loop