Davout 0.1.1.dev180__py3-none-any.whl → 0.1.1.dev182__py3-none-any.whl

Davout/DeepMech/aa_tests/SVD_framework/dataset_generator.py

@@ -14,6 +14,8 @@ from .....Davout.DeepMech.aa_tests.mecsol_2026_quotient_space.box_with_imposed_d
 
 from .....Davout.DeepMech.aa_tests.mecsol_2026_quotient_space.young_modulus_field_generator import generate_field
 
+from input_data_filler import fill_load_steps
+
 import numpy as np
 
 import traceback
@@ -26,7 +28,8 @@ def generate_dataset(n_samples, limits_list, p_norm_list, results_path,
 displacement_file_name, young_modulus_file, mesh_file_name, cube_size,
 influence_radius, damping_factor, radius_power, mesh_data_class, 
 lagrange_multiplier_file_name, strain_energy_file_name,
-save_snapshot_displacement=False):
+displacement_matrix_file_name, strain_energy_matrix_file_name, 
+input_matrix_file_name, save_snapshot_displacement=False):
     
     # Initializes the list of samples
 
@@ -162,10 +165,11 @@ save_snapshot_displacement=False):
             strain_energy_file_name+"_"+simulation_number+".npy")[:,1:
             ].tolist())
 
-            # Adds the Young modulus data and the displacement gradient
+            # Adds the displacement gradient and, then, the Young modulus
+            # data. The variables related to the quotient space must come
+            # first
 
-            successful_sample_data = [sample_data[variables_indices["p"+
-            "eak E"]], sample_data[variables_indices["base E"]]]
+            successful_sample_data = []
 
             successful_sample_data.extend(displacement_gradient[0])
 
@@ -173,6 +177,9 @@ save_snapshot_displacement=False):
 
             successful_sample_data.extend(displacement_gradient[2])
 
+            successful_sample_data.extend([sample_data[variables_indices[
+            "peak E"]], sample_data[variables_indices["base E"]]])
+
             succesful_data.append(successful_sample_data)
 
             # Updates the list of completed simulations
@@ -189,14 +196,14 @@ save_snapshot_displacement=False):
 
             # Saves the lists into binary and txt files
 
-            np.save(results_path+"//00_successful_displacement_matrix.n"+
-            "py", np.array(succesful_displacement))
+            np.save(results_path+"//"+displacement_matrix_file_name, 
+            np.array(succesful_displacement))
 
-            np.save(results_path+"//00_successful_strain_energy_matrix"+
-            ".npy", np.array(succesful_strain_energy))
+            np.save(results_path+"//"+strain_energy_matrix_file_name, 
+            np.array(succesful_strain_energy))
 
-            np.save(results_path+"//00_successful_data_matrix.npy", 
-            np.array(succesful_data))
+            np.save(results_path+"//"+input_matrix_file_name, np.array(
+            succesful_data))
 
             list_toTxt(completed_simulations, "00_completed_simulations", 
             parent_path=results_path)
@@ -339,7 +346,7 @@ if __name__=="__main__":
 
     cube_size = 0.5
 
-    n_divisions = 10
+    n_divisions = 6#10
 
     E_extremum = 10E6
 
@@ -355,7 +362,8 @@ if __name__=="__main__":
 
     # Sets the paths and files names
 
-    results_path = get_parent_path_of_file()+"//results"
+    results_path = (get_parent_path_of_file()+"//results_n_divisions_"+
+    str(n_divisions))
 
     displacement_file_name = "displacement_young_modulus_field"
 
@@ -367,6 +375,31 @@ if __name__=="__main__":
 
     mesh_file_name = "box_mesh_mecsol"
 
+    # Sets the file name of the data matrices
+
+    displacement_matrix_file_name = ("00_successful_displacement_matri"+
+    "x.npy")
+
+    strain_energy_matrix_file_name = ("00_successful_strain_energy_mat"+
+    "rix.npy")
+
+    input_matrix_file_name = "00_successful_data_matrix.npy"
+
+    # Sets the file names of the completed (filled-in with load-steps) 
+    # data matrices and the filtered counterpart
+
+    complete_data_matrix_file_name = ("00_successful_complete_data_mat"+
+    "rix.npy")
+
+    complete_and_filtered_data_matrix_file_name = ("00_successful_comp"+
+    "lete_and_filtered_data_matrix.npy")
+
+    # Sets the initial and final time points for the simulation
+
+    initial_time = 0.2
+
+    final_time = 1.0
+
     # Constructs the mesh
 
     mesh_data_class = read_mshMesh({"length x": cube_size, "length y": 
@@ -377,10 +410,31 @@ if __name__=="__main__":
     "bias x": ["Bump", bias_factor], "bias y": ["Bump", bias_factor], 
     "bias z": ["Bump", bias_factor]})
 
-    # Constructs the field
+    # Defines a flag fo generating the dataset and another flag for ge-
+    # nerating the dataset with the intermediate load steps and its fil-
+    # tered version as well
+
+    flag_generate_dataset = False
+
+    flag_fill_in_load_steps = True
+
+    # Generates the dataset from skretch
+
+    if flag_generate_dataset:
+
+        generate_dataset(n_samples, limits_list, p_norm_list, 
+        results_path, displacement_file_name, young_modulus_file, 
+        mesh_file_name, cube_size, influence_radius, damping_factor, 
+        radius_power, mesh_data_class, lagrange_multiplier_file_name, 
+        strain_energy_file_name, displacement_matrix_file_name,
+        strain_energy_matrix_file_name, input_matrix_file_name,
+        save_snapshot_displacement=False)
+
+    # Fills the load-steps and generates the filtered dataset from it
+
+    if flag_fill_in_load_steps:
 
-    generate_dataset(n_samples, limits_list, p_norm_list, results_path,
-    displacement_file_name, young_modulus_file, mesh_file_name, cube_size,
-    influence_radius, damping_factor, radius_power, mesh_data_class,
-    lagrange_multiplier_file_name, strain_energy_file_name, 
-    save_snapshot_displacement=False)
+        fill_load_steps(input_matrix_file_name, 
+        displacement_matrix_file_name, complete_data_matrix_file_name, 
+        complete_and_filtered_data_matrix_file_name, results_path, 
+        initial_time, final_time)

Davout/DeepMech/aa_tests/SVD_framework/input_data_filler.py

@@ -60,10 +60,10 @@ final_time):
 
             # Recovers the displacement gradient
 
-            displacement_gradient = np.array([[sample_data[2], 
-            sample_data[3], sample_data[4]], [sample_data[5], 
-            sample_data[6], sample_data[7]], [sample_data[8], 
-            sample_data[9], sample_data[10]]])
+            displacement_gradient = np.array([[sample_data[0], 
+            sample_data[1], sample_data[2]], [sample_data[3], 
+            sample_data[4], sample_data[5]], [sample_data[6], 
+            sample_data[7], sample_data[8]]])
 
             # Gets the corresponding deformation gradient
 
@@ -118,7 +118,7 @@ final_time):
                 new_disp_grad[0,1], new_disp_grad[0,2], new_disp_grad[
                 1,0], new_disp_grad[1,1], new_disp_grad[1,2], 
                 new_disp_grad[2,0], new_disp_grad[2,1], new_disp_grad[
-                2,2], sample_data[0], sample_data[1]])
+                2,2], sample_data[9], sample_data[10]])
 
                 # Adds this sample to the filtered input data. Inserts 
                 # the load-based data as the first columns, since this 
@@ -137,18 +137,20 @@ final_time):
         new_input_list = np.array(new_input_list)
 
         print("The new input data matrix has shape "+str(
-        new_input_list.shape)+", whereas it had "+str(input_data.shape[0
-        ])+" rows before.\nThe displacement matrix, on the other hand,"+
-        " has "+str(displacement_matrix.shape[0])+"\n")
+        new_input_list.shape)+", whereas it had the shape "+str(
+        input_data.shape)+" before.\nThe displacement matrix, on the o"+
+        "ther hand, has shape equal to "+str(displacement_matrix.shape)+
+        "\n")
 
         np.save(results_path+"//"+new_input_file, new_input_list)
 
         new_filtered_input_list = np.array(new_filtered_input_list)
 
         print("The new filtered input data matrix has shape "+str(
-        new_filtered_input_list.shape)+", whereas it had "+str(
-        input_data.shape[0])+" rows before.\nThe displacement matrix, "+
-        "on the other hand, has "+str(displacement_matrix.shape[0])+"\n")
+        new_filtered_input_list.shape)+", whereas it had the shape "+str(
+        input_data.shape)+" before.\nThe displacement matrix, on th"+
+        "e other hand, has shape equal to "+str(displacement_matrix.shape
+        )+"\n")
 
         np.save(results_path+"//"+new_filtered_input_file, 
         new_filtered_input_list)

Davout/DeepMech/aa_tests/SVD_framework/kinematics_surrogate_model.py

@@ -5,10 +5,16 @@ import numpy as np
 
 import tensorflow as tf
 
+from .....Davout.DeepMech.tool_box.gpu_tools import give_access_of_gpu_to_tensorflow
+
+give_access_of_gpu_to_tensorflow(True)
+
 from time import time
 
 from .....Davout.DeepMech.tool_box import ANN_tools, training_tools
 
+from .....Davout.DeepMech.tool_box.numerical_tools import DataMatrixRegularization
+
 from .....Davout.DeepMech.tool_box.loss_assembler_classes import MaximumAbsoluteError
 
 from .....Davout.PythonicUtilities.path_tools import get_parent_path_of_file
@@ -22,12 +28,19 @@ class RVEKinematicsSurrogateModel:
     activations_list_auxiliar_network, quotient_space_dimension, 
     modulating_function, displacement_data_file, input_data_file, 
     results_path, loss_metric, n_training_samples, saved_model_file,
-    n_monte_carlo_realizations, n_best_models, 
+    n_monte_carlo_realizations, n_best_models, n_best_samples,
     maximum_training_iterations, verbose_delta_iterations,
-    parameters_dtype="float32", householder_epsilon=1.0, verbose=True):
+    mesh_file_name, optimizer, subdofs_to_learn, parameters_dtype="flo"+
+    "at32", householder_epsilon=1.0, verbose=True, integer_dtype="int3"+
+    "2", non_orthogonal_matrices=False, device_type="CPU", 
+    input_data_regularization_method=None):
 
         # Saves the needed information
 
+        self.non_orthogonal_matrices = non_orthogonal_matrices
+
+        self.device_type = device_type
+
         self.activations_list_main_network = activations_list_main_network
 
         self.activations_list_auxiliar_network = (
@@ -45,6 +58,8 @@ class RVEKinematicsSurrogateModel:
 
         self.loss_metric = loss_metric
 
+        self.optimizer = optimizer
+
         self.n_training_samples = n_training_samples
 
         self.saved_model_file = saved_model_file
@@ -53,7 +68,9 @@ class RVEKinematicsSurrogateModel:
 
         self.n_best_models = n_best_models
 
-        self.parameters_dtype = parameters_dtype
+        self.n_best_samples = n_best_samples
+
+        self.mesh_file_name = mesh_file_name
 
         self.householder_epsilon = householder_epsilon
 
@@ -63,19 +80,56 @@ class RVEKinematicsSurrogateModel:
 
         self.verbose_delta_iterations = verbose_delta_iterations
 
-    # Defines a function to train the neural network model
+        # Saves the tensorflow dtypes
 
-    def train_surrogate_model(self):
+        self.parameters_dtype = parameters_dtype
 
-        # Reads the two files
+        self.integer_dtype = integer_dtype
 
-        output_data = np.load(self.results_path+"//"+
+        # Converts the tensor of DOFs to a tensorflow integer tensor
+
+        self.subdofs_to_learn = tf.convert_to_tensor(subdofs_to_learn,
+        dtype=tf.as_dtype(self.integer_dtype))
+
+        # Gets the number of output neurons from the tensor of the indi-
+        # ces of the DOFs that will actually be learnt
+
+        self.n_output_neurons = self.subdofs_to_learn.shape[0]
+
+        # Reads the output data 
+
+        self.whole_output_data = np.load(self.results_path+"//"+
         self.displacement_data_file)
 
+        # Gets the numbers of samples and of total of DOFs
+
+        self.number_of_samples, self.total_number_of_dofs = (
+        self.whole_output_data.shape)
+
+        # Checks whether subdofs to learn has any DOF index that is lar-
+        # ger than the number of DOFs of the output data
+
+        if tf.reduce_max(self.subdofs_to_learn).numpy(
+        )>=self.total_number_of_dofs:
+
+            raise IndexError("The maximum DOF index requested by 'subd"+
+            "ofs_to_learn' is "+str(tf.reduce_max(self.subdofs_to_learn
+            ).numpy())+". But the output data at\n"+str(
+            self.results_path+"//"+self.displacement_data_file)+"\nhas"+
+            " only "+str(self.total_number_of_dofs)+" columns")
+
+        # Otherwise, uses the subdofs to learn to retrieve the needed 
+        # DOFs for training
+
+        self.output_data = self.whole_output_data[:,
+        self.subdofs_to_learn]
+
+        # Gets the input data
+
         input_data = np.load(self.results_path+"//"+self.input_data_file)
 
         # Checks whether there is sufficient samples in the dataset
-
+        
         if self.n_training_samples>=input_data.shape[0]:
 
             raise IndexError(str(self.n_training_samples)+" samples we"+
@@ -83,7 +137,7 @@ class RVEKinematicsSurrogateModel:
             input_data.shape[0])+" samples in the input data matrix at"+
             ":\n"+str(self.results_path+"//"+self.input_data_file))
 
-        if self.n_training_samples>=output_data.shape[0]:
+        if self.n_training_samples>=self.output_data.shape[0]:
 
             raise IndexError(str(self.n_training_samples)+" samples we"+
             "re asked for training, but there are only "+str(
@@ -91,26 +145,40 @@ class RVEKinematicsSurrogateModel:
             "t:\n"+str(self.results_path+"//"+
             self.displacement_data_file))
 
-        if output_data.shape[0]!=input_data.shape[0]:
+        if self.output_data.shape[0]!=input_data.shape[0]:
 
             raise IndexError("The output data matrix has "+str(
-            output_data.shape[0])+" samples, whereas the input data ma"+
-            "trix has "+str(input_data.shape[0])+" samples.\n\nThe out"+
-            "put data matrix is at:\n"+str(self.results_path+"//"+
+            self.output_data.shape[0])+" samples, whereas the input da"+
+            "ta matrix has "+str(input_data.shape[0])+" samples.\n\nTh"+
+            "e output data matrix is at:\n"+str(self.results_path+"//"+
             self.displacement_data_file)+"\n\nthe input data matrix is"+
             "at:\n"+str(self.results_path+"//"+self.input_data_file))
 
-        # Sets the training data
+        # Checks if a regularization technique was requested for the in-
+        # put data matrix
+
+        if input_data_regularization_method is not None:
 
-        training_data = input_data[0:self.n_training_samples,:]
+            # Instantiates the data regularization class
 
-        training_true_values = output_data[0:self.n_training_samples,:]
+            data_regularization_class = DataMatrixRegularization(
+            regularization_function=input_data_regularization_method)
 
-        # Gets the number of input and output neurons
+            # Regularizes the data matrix and saves the regularization
+            # data using this input data
 
-        n_input_neurons = input_data.shape[1]
+            self.input_data, _ = data_regularization_class(input_data, 
+            True)
 
-        n_output_neurons = output_data.shape[1]
+        # Otherwise, simply saves the input data into the class
+        
+        else:
+
+            self.input_data = input_data
+
+        # Gets the number of input neurons
+
+        self.n_input_neurons = self.input_data.shape[1]
 
         # Verifies if the output layer of the main network has the same
         # number of output neurons
@@ -121,32 +189,47 @@ class RVEKinematicsSurrogateModel:
 
             n_output_neurons_main_network += value
 
-        if n_output_neurons_main_network!=n_output_neurons:
+        if n_output_neurons_main_network!=self.n_output_neurons:
 
             raise ValueError("The main network has "+str(
             n_output_neurons_main_network)+" neurons in the output lay"+
             "er; whereas the data indicate that there must be "+str(
-            n_output_neurons)+" neurons in the output layer")
+            self.n_output_neurons)+" neurons in the output layer")
 
         # Sets the architecture dictionary
     
-        custom_architecture = {"name": "SVDQuotientSpace", "weights mo"+
-        "dulating function": self.modulating_function, "Householder ep"+
-        "silon": self.householder_epsilon, "activations accessory laye"+
-        "r list": self.activations_list_auxiliar_network}
+        self.custom_architecture = {"name": "SVDQuotientSpace", "weigh"+
+        "ts modulating function": self.modulating_function, "Household"+
+        "er epsilon": self.householder_epsilon, "activations accessory"+
+        " layer list": self.activations_list_auxiliar_network, "non-or"+
+        "thogonal matrices": self.non_orthogonal_matrices, "hardware d"+
+        "evice": self.device_type, "convex with respect to quotient sp"+
+        "ace": False}
+
+    # Defines a function to train the neural network model
+
+    def train_surrogate_model(self):
+
+        # Sets the training data
+
+        training_data = self.input_data[0:self.n_training_samples,:]
+
+        training_true_values = self.output_data[0:self.n_training_samples
+        ,:]
 
         # Creates the class of neural network information
 
-        ANN_class = ANN_tools.MultiLayerModel(n_input_neurons,
+        ANN_class = ANN_tools.MultiLayerModel(self.n_input_neurons,
         self.activations_list_main_network, enforce_customLayers=True, 
         verbose=self.verbose, parameters_dtype=self.parameters_dtype, 
-        custom_architecture=custom_architecture, input_size_main_network=
-        self.quotient_space_dimension)
+        custom_architecture=self.custom_architecture, 
+        input_size_main_network=self.quotient_space_dimension)
 
         self.custom_model = ANN_class()
 
         # Defines the loss metric
 
+        """
         self.live_loss_metric = None
 
         if isinstance(self.loss_metric, str):
@@ -159,7 +242,9 @@ class RVEKinematicsSurrogateModel:
                 "metric by the name '"+str(self.loss_metric)+"'")
 
             self.live_loss_metric = getattr(tf.keras.losses, 
-            self.loss_metric)(dtype=tf.as_dtype(self.parameters_dtype))
+            self.loss_metric)(dtype=tf.as_dtype(self.parameters_dtype))"""
+
+        self.live_loss_metric = self.loss_metric
 
         # Sets the optimization class for training
 
@@ -169,7 +254,7 @@ class RVEKinematicsSurrogateModel:
         self.maximum_training_iterations, verbose_deltaIterations=
         self.verbose_delta_iterations, save_model_file=
         self.saved_model_file, match_data_float_type_to_trainables=True, 
-        parent_path=self.results_path)
+        parent_path=self.results_path, optimizer=self.optimizer)
 
         t_initial = time()
 
@@ -183,7 +268,8 @@ class RVEKinematicsSurrogateModel:
 
         training_class.monte_carlo_training(n_realizations=
         self.n_monte_carlo_realizations, best_models_rank_size=
-        self.n_best_models, show_reinitialization_distance=True)
+        self.n_best_models, show_reinitialization_distance=True, 
+        model_base_name=self.saved_model_file)
 
         # Checks the loss again with the best model of the Monte Carlo
         # training
@@ -275,6 +361,20 @@ class RVEKinematicsSurrogateModel:
 
 if __name__=="__main__":
 
+    # Sets the number of transfinite divisions in the RVE mesh
+
+    n_divisions = 6
+
+    # Sets a dictionary for the number of DOFs in the mesh for each num-
+    # ber of divisions
+
+    dofs_per_number_of_divisions = {6: 3993, 8: 10125, 10: 20577}
+
+    # Defines the array with the DOFs to be learnt
+
+    subdofs_to_learn = np.arange(0, dofs_per_number_of_divisions[
+    n_divisions], 3)
+
     # Defines the number of input neurons of the main network. Remember
     # that the data matrix is a tensor [n_samples, n_input_variables]. 
     # The first quotient_space_dimension columns must be dedicated to 
@@ -286,7 +386,7 @@ if __name__=="__main__":
     # Defines the number of neurons of the different hidden layers and of
     # the output layer
 
-    n_neurons_per_layer = [100, 1000, 20577]
+    n_neurons_per_layer = [100, 1000, subdofs_to_learn.shape[0]]
 
     # Sets a list of layers and the activation functions
 
@@ -294,11 +394,12 @@ if __name__=="__main__":
     n_neurons_per_layer[0]}}, {"elu": {"number of neurons":
     n_neurons_per_layer[1]}}, {"linear": n_neurons_per_layer[2]}]
 
-    activations_list_auxiliar_network = [{"quadratic": {"number"+
-    " of neurons": min(quotient_space_dimension, n_neurons_per_layer[0]),
-    "a2": 1.0}}, {"quadratic":  {"number of neurons": min(
-    n_neurons_per_layer[0], n_neurons_per_layer[1]), "a2": 1.0}}, {"qu"+
-    "adratic": {"number of neurons": min(n_neurons_per_layer[1],
+    activations_list_auxiliar_network = [{"quadratic": {"number of neu"+
+    "rons": min(quotient_space_dimension, n_neurons_per_layer[0]), "a2": 
+    1.0}}, 
+    {"quadratic":  {"number of neurons": min(n_neurons_per_layer[0], 
+    n_neurons_per_layer[1]), "a2": 1.0}}, 
+    {"quadratic": {"number of neurons": min(n_neurons_per_layer[1], 
     n_neurons_per_layer[2])}}]
 
     # Sets the modulating function for the weights matrices
@@ -307,6 +408,8 @@ if __name__=="__main__":
 
     # Sets the training information
 
+    optimizer = "Adam"
+
     n_training_samples = 10000
 
     maximum_training_iterations = 1000
@@ -317,20 +420,42 @@ if __name__=="__main__":
 
     n_best_models = 5
 
+    n_best_samples = 10
+
     loss_metric = "MeanSquaredError"
 
+    loss_metric = {"name": "LpNormError", "p": 12, "use_stable_impleme"+
+    "ntation": True}
+
     parameters_dtype = "float32"
 
     saved_model_file = "RVE_kinematics_model.keras"
 
     # Sets the path for the data
 
-    results_path = get_parent_path_of_file()+"//results"
+    results_path = (get_parent_path_of_file()+"//results_n_divisions_"+
+    str(n_divisions))
    
     displacement_data_file = "00_successful_displacement_matrix.npy"
 
     input_data_file = "00_successful_complete_and_filtered_data_matrix.npy"
 
+    mesh_file_name = get_parent_path_of_file()+"//box_mesh_mecsol"
+
+    # Sets the method to regularize the input data matrix
+
+    input_data_regularization_method = ("maximum_absolute_order_normal"+
+    "ization")
+
+    # Sets the device type where the training will be performed
+
+    device_type = "GPU"
+
+    # Sets whether the constraint on orthogonality of the SVD matrices
+    # will not be enforced
+
+    non_orthogonal_matrices = True
+
     # Instantiates the class that owns all information about training 
     # and testing models
 
@@ -339,14 +464,21 @@ if __name__=="__main__":
     quotient_space_dimension, modulating_function, 
     displacement_data_file, input_data_file, results_path, loss_metric, 
     n_training_samples, saved_model_file, n_monte_carlo_realizations, 
-    n_best_models, maximum_training_iterations, verbose_delta_iterations,
-    parameters_dtype=parameters_dtype, householder_epsilon=1.0, verbose=
-    True)
+    n_best_models, n_best_samples, maximum_training_iterations, 
+    verbose_delta_iterations, mesh_file_name, optimizer, 
+    subdofs_to_learn, parameters_dtype=parameters_dtype, 
+    householder_epsilon=1.0, verbose=True, device_type=
+    device_type, non_orthogonal_matrices=non_orthogonal_matrices,
+    input_data_regularization_method=input_data_regularization_method)
 
     training_flag = True
 
+    testing_flag = False
+
     if training_flag:
 
         modeling_class.train_surrogate_model()
 
-    modeling_class.test_surrogate_model()
+    if testing_flag:
+
+        modeling_class.test_surrogate_model()