def main(): global_batch_size = 1024 slot_num = 10 nnz_per_slot = 5 policy = tf.keras.mixed_precision.Policy("mixed_float16") tf.keras.mixed_precision.set_global_policy(policy) strategy = tf.distribute.MirroredStrategy() dataset = utility.get_dataset(global_batch_size, read_batchsize=global_batch_size) dataset = strategy.experimental_distribute_dataset(dataset) with strategy.scope(): sok.Init(global_batch_size=global_batch_size) model = utility.SOKDenseDemo(max_vocabulary_size_per_gpu=1024, embedding_vec_size=8, slot_num=slot_num, nnz_per_slot=nnz_per_slot, num_dense_layers=0) optimizer = tf.keras.optimizers.Adam(learning_rate=0.1) optimizer = tf.keras.mixed_precision.LossScaleOptimizer(optimizer) loss_fn = tf.keras.losses.BinaryCrossentropy( from_logits=True, reduction=tf.keras.losses.Reduction.NONE) def _replica_loss(labels, logits): labels = tf.cast(labels, logits.dtype) loss = loss_fn(labels, logits) dtype = loss.dtype loss = tf.cast(loss, tf.float32) loss = tf.nn.compute_average_loss(loss, global_batch_size=global_batch_size) return tf.cast(loss, dtype) @tf.function def train_step(inputs, labels): with tf.GradientTape() as tape: logit = model(inputs, training=True) loss = _replica_loss(labels, logit) scaled_loss = optimizer.get_scaled_loss(loss) emb_vars, other_vars =\ sok.split_embedding_variable_from_others(model.trainable_variables) scaled_emb_grads, scaled_other_grads = tape.gradient( scaled_loss, [emb_vars, other_vars]) emb_grads = optimizer.get_unscaled_gradients(scaled_emb_grads) other_grads = optimizer.get_unscaled_gradients(scaled_other_grads) with sok.OptimizerScope(emb_vars): optimizer.apply_gradients(zip(emb_grads, emb_vars), experimental_aggregate_gradients=False) optimizer.apply_gradients(zip(other_grads, other_vars)) return loss for step, (inputs, labels) in enumerate(dataset): replica_loss = strategy.run(train_step, args=(inputs, labels)) total_loss = strategy.reduce("sum", replica_loss, axis=None) print("[INFO]: step {}, loss {}".format(step, total_loss))
def run(hdf5_data): """ Run the solver Args: hdf5_data: object, the hdf5 opened storage Returns: the output of the fortran function as string if successful """ signature = __name__ + '.run(hdf5_data)' logger = logging.getLogger(__name__) utility.log_entrance(logger, signature, {'hdf5_data': hdf5_data}) data = init_data() data["log_level"] = logging.getLogger().getEffectiveLevel() dset = utility.get_1d_array(logger, hdf5_data, "H5_L10_COUNT", expected_dim=4) offset = 1 l10_i_sym = int(dset[0]) n_points = int(dset[1]) n_panels = int(dset[2]) n_bodies = int(dset[3]) mesh_cpanel = utility.get_dataset(hdf5_data, 'H5_L10_CPANEL') mesh_xm = utility.get_dataset(hdf5_data, 'H5_L10_XM') mesh_n = utility.get_dataset(hdf5_data, 'H5_L10_N') mesh_a = utility.get_dataset(hdf5_data, 'H5_L10_A') dset = utility.get_1d_array(logger, hdf5_data, "H5_L12_COUNT", expected_dim=2) i_sym = int(dset[1]) if l10_i_sym != i_sym or int(dset[0]) != 2: raise ValueError('Stopping because the mesh file format is not correct.' 'The symmetry about xoz axis is inconsistent') data["i_sym"] = i_sym data["mesh_p"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_L12_P'), order='F', dtype='i') data["mesh_x"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_L12_X'), order='F', dtype='f') data["n_points"] = n_points data["n_panels"] = n_panels data["n_bodies"] = n_bodies data["mesh_cpanel"] = np.asarray(mesh_cpanel, order='F', dtype='i') data["mesh_xm"] = np.asarray(mesh_xm, order='F', dtype='f') data["mesh_n"] = np.asarray(mesh_n, order='F', dtype='f') data["mesh_a"] = np.asarray(mesh_a, order='F', dtype='f') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_W') bc_omega = np.asarray(dset, order='F', dtype='f') n_problems = bc_omega.shape[0] data["bc_omega"] = bc_omega data["n_problems"] = n_problems dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_BETA') data["bc_switch_type"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_SWITCH_POTENTIAL') data["bc_switch_potential"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_SWITCH_FREE_SURFACE') data["bc_switch_freesurface"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_SWITCH_KOCHIN') data["bc_switch_kochin"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_VELOCITIES') data["bc_normal_velocity"] = np.asarray(dset, order='F', dtype='F') data["nbc_panels"] = data["bc_normal_velocity"].shape[0] data["rho"] = utility.get_1d_array(logger, hdf5_data, "H5_ENV_VOLUME", expected_dim=1)[0] data["g"] = utility.get_1d_array(logger, hdf5_data, "H5_ENV_GRAVITY", expected_dim=1)[0] data["depth"] = utility.get_1d_array(logger, hdf5_data, "H5_ENV_DEPTH", expected_dim=1)[0] dset = utility.get_1d_array(logger, hdf5_data, "H5_ENV_WAVE_POINT", expected_dim=2) data["xeff"] = dset[0] data["y_eff"] = dset[1] data["indiq_solver"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_TYPE", expected_dim=1)[0] data["max_iterations"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GMRES_MAX_ITERATIONS", 1)[0] data["restart_param"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GMRES_RESTART", expected_dim=1)[0] data["tol_gmres"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GMRES_STOPPING", expected_dim=1)[0] data["nds"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_MESH_INTEGRATION'), order='F', dtype='f') data["n_integration"] = data["nds"].shape[0] data["use_higher_order"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_USE_HIGHER_ORDER", 1)[0] data["num_panel_higher_order"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_NUM_PANEL_HIGHER_ORDER", 1)[0] data["b_spline_order"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_B_SPLINE_ORDER", expected_dim=1)[0] data["theta"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_MESH_KOCHIN'), order='F', dtype='f') data["n_theta"] = data["theta"].shape[0] data["meshfs_x"] = np.asarray(utility.get_2d_array(logger, hdf5_data, "H5_MESH_FREE_SURFACE_VECTORS"), dtype='f') data["nfs_points"] = data["meshfs_x"].shape[1] data["meshfs_p"] = np.asarray(utility.get_2d_array(logger, hdf5_data, "H5_MESH_FREE_SURFACE_INDEX"), order='F', dtype='i') + offset data["nfs_panels"] = data["meshfs_p"].shape[1] data["out_phi"] = np.zeros((n_problems, 1+data["nfs_points"]), dtype='F', order="F") data["out_pressure"] = np.zeros((n_problems, data["nbc_panels"]), dtype='F', order="F") data["out_hkochin"] = np.zeros((n_problems, data["n_theta"]), dtype='F', order="F") data["line"] = np.zeros((data["n_integration"], n_problems*2), order="F", dtype='f') data["drift_forces"] = np.zeros((n_problems, data["n_theta"], 2), order="F", dtype='f') data["yaw_moment"] = np.zeros((n_problems, data["n_theta"]), order="F", dtype='f') data["center_buoyancy"] = np.zeros((n_bodies, 3), order="F", dtype='f') data["displacement"] = np.zeros((n_bodies), order="F", dtype='f') data["waterplane_area"] = np.zeros((n_bodies), order="F", dtype='f') data["stifness"] = np.zeros((n_bodies, 6, 6), order="F", dtype='f') n_potentials = 5*n_points*(1 + (i_sym == 1)) +9*n_panels*(1 + (i_sym == 1)) data["out_potential"] = np.zeros((n_problems, n_potentials), dtype='f', order="F") data["n_potentials"] = n_potentials data["n_tabulatedx"] = int(utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GREEN_TABULATION_NUMX", 1)[0]) data["n_tabulatedz"] = int(utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GREEN_TABULATION_NUMZ", 1)[0]) data["n_points_simpson"] = int(utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GREEN_TABULATION_SIMPSON_NPOINTS", 1)[0]) dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_SWITCH_ODE_INFLUENCE') data["fast_influence_switch"] = np.asarray(dset, order='F', dtype='i') data["is_interior_domain"] = np.zeros((n_panels), dtype='i', order="F") remove_irregular_frequencies = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES", 1)[0] if remove_irregular_frequencies: # Bug??? Previous code used dset = hdf5_data.get(structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES) dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_IS_INTERIOR_DOMAIN') data["is_interior_domain"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_RESULTS_CASE_BETA') data["beta"] = np.asarray(dset, order='F', dtype='f') data["n_beta"] = data["beta"].shape[0] dset = utility.get_dataset(hdf5_data, 'H5_RESULTS_CASE_RADIATION') data["rad_case"] = np.asarray(dset, order='F', dtype='f') data["n_radiation"] = data["rad_case"].shape[0] dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_THIN_PANELS') data["is_thin_body"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_USE_DIPOLES_IMPLEMENTATION') data["use_dipoles_implementation"] = dset[0] data["remove_irregular_frequencies"] = utility.get_dataset(hdf5_data, 'H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES')[0] dset = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_COMPUTE_YAW_MOMENT", 1) data["compute_yaw_moment"] = dset[0] dset = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_COMPUTE_DRIFT_FORCES", 1) data["compute_drift_forces"] = dset[0] # Disable kochin, yaw moments and drift forces if data["use_higher_order"] == 1 or data["use_dipoles_implementation"] == 1: data["n_theta"] = 0 logger.info('Disabling koching, yaw monment and drift forces computation as ' 'not supported when higher order panel or dipoles implementation is ' 'enabled') #with CaptureOutput() as capturer: solver_fortran.run_solver(data) write_result(hdf5_data, data)
def main(): config = Config() config_dict = config.get_config() dataset = config_dict['dataset'] la_autoencoder = config_dict[dataset + '_la_autoencoder'] la_autoencoder_classifier = config_dict[dataset + '_la_autoencoder_classifier'] la_simple_classifier = config_dict[dataset + '_la_simple_classifier'] loss_function_autoencoder = config_dict['loss_function_autoencoder'] loss_function_classifier = config_dict['loss_function_classifier'] optimizer_autoencoder = config_dict['optimizer_autoencoder'] optimizer_classifier = config_dict['optimizer_classifier'] latent_size = config_dict[dataset + '_latent_size'] autoencoder_epochs = config_dict[dataset + '_autoencoder_epochs'] classifier_epochs = config_dict[dataset + '_classifier_epochs'] freeze_encoder = config_dict['freeze'] D1D2_ratio = config_dict[dataset + '_D1D2_fraction'] D2_training_ratio = config_dict[dataset + '_D2_training_fraction'] num_reconstructions = config_dict['num_reconstructions'] plot_tsne = config_dict['plot_tSNE'] num_images = 250 plot_learning = config_dict['plot_learning'] x_data, y_data = utility.get_dataset(dataset) x_train_D1, (x_train_D2, y_train_D2), (x_test_D2, y_test_D2) = utility.split_dataset(x_data, y_data, D1D2_ratio, D2_training_ratio) # Autoencoder encoder = Encoder(dataset, latent_size) if plot_tsne == 1: encoder.plot_tSNE(num_images, 'Stage 1') autoencoder_do_training = True autoencoder_store_model = True autoencoder_model_name = 'autoencoder' + str(dataset) autoencoder = Autoencoder(encoder, freeze_encoder, la_autoencoder, loss_function_autoencoder, optimizer_autoencoder, autoencoder_epochs, autoencoder_do_training, autoencoder_store_model, autoencoder_model_name) if plot_learning and autoencoder_do_training: x_train, x_test = autoencoder.train(x_train_D1, x_test_D2) fig, ax = plt.subplots() fig.suptitle('Autoencoder loss') plt.plot(x_train, '-r', label='Training loss') plt.plot(x_test, '-b', label='Validation loss') plt.xlabel('Batches') plt.ylabel('Loss') leg = ax.legend() plt.show(block=False) else: autoencoder.train(x_train_D1, x_test_D2) for i in range(num_reconstructions): autoencoder.show_reconstruction(x_test_D2[i]) if plot_tsne == 1: autoencoder.get_encoder().plot_tSNE(num_images, 'Stage 2') auto_classifier_do_training = True auto_classifier_store_model = True auto_classifer_model_name = 'auto_classifier' + str(dataset) autoencoder_classifier = Classifier(encoder, la_autoencoder_classifier, loss_function_classifier, optimizer_classifier, classifier_epochs, auto_classifier_do_training, auto_classifier_store_model, auto_classifer_model_name) simple_encoder = Encoder(dataset, latent_size) simple_classifier_do_training = True simple_classifier_store_model = True simple_classifier_model_name = 'simple_classifier' + str(dataset) simple_classifier = Classifier(simple_encoder, la_simple_classifier, loss_function_classifier, optimizer_classifier, classifier_epochs, simple_classifier_do_training, simple_classifier_store_model, simple_classifier_model_name) if plot_learning and auto_classifier_do_training and simple_classifier_do_training: auto_train_acc, auto_test_acc = autoencoder_classifier.train_classifier(x_train_D2, y_train_D2, x_test_D2, y_test_D2) simple_train_acc, simple_test_acc = simple_classifier.train_classifier(x_train_D2, y_train_D2, x_test_D2, y_test_D2) fig, ax = plt.subplots() fig.suptitle('Classifier accuracy') plt.plot(auto_train_acc, '-r', label='Auto training accuracy') plt.plot(auto_test_acc, '-b', label='Auto validation accuracy') plt.plot(simple_train_acc, '-g', label='Simple training accuracy') plt.plot(simple_test_acc, '-y', label='Simple validation accuracy') plt.xlabel('Batches') plt.ylabel('Accuracy') leg = ax.legend() plt.show(block=False) else: autoencoder_classifier.train_classifier(x_train_D2, y_train_D2, x_test_D2, y_test_D2) simple_classifier.train_classifier(x_train_D2, y_train_D2, x_test_D2, y_test_D2) if plot_tsne == 1: autoencoder.get_encoder().plot_tSNE(num_images, 'Stage 3') plt.show()
def run(hdf5_data): """ Run the solver Args: hdf5_data: object, the hdf5 opened storage Returns: the output of the fortran function as string if successful """ signature = __name__ + '.run(hdf5_data)' logger = logging.getLogger(__name__) utility.log_entrance(logger, signature, {'hdf5_data': hdf5_data}) data = init_data() data["log_level"] = logging.getLogger().getEffectiveLevel() dset = utility.get_1d_array(logger, hdf5_data, "H5_L10_COUNT", expected_dim=4) offset = 1 l10_i_sym = int(dset[0]) n_points = int(dset[1]) n_panels = int(dset[2]) n_bodies = int(dset[3]) mesh_cpanel = utility.get_dataset(hdf5_data, 'H5_L10_CPANEL') mesh_xm = utility.get_dataset(hdf5_data, 'H5_L10_XM') mesh_n = utility.get_dataset(hdf5_data, 'H5_L10_N') mesh_a = utility.get_dataset(hdf5_data, 'H5_L10_A') dset = utility.get_1d_array(logger, hdf5_data, "H5_L12_COUNT", expected_dim=2) i_sym = int(dset[1]) if l10_i_sym != i_sym or int(dset[0]) != 2: raise ValueError( 'Stopping because the mesh file format is not correct.' 'The symmetry about xoz axis is inconsistent') data["i_sym"] = i_sym data["mesh_p"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_L12_P'), order='F', dtype='i') data["mesh_x"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_L12_X'), order='F', dtype='f') data["n_points"] = n_points data["n_panels"] = n_panels data["n_bodies"] = n_bodies data["mesh_cpanel"] = np.asarray(mesh_cpanel, order='F', dtype='i') data["mesh_xm"] = np.asarray(mesh_xm, order='F', dtype='f') data["mesh_n"] = np.asarray(mesh_n, order='F', dtype='f') data["mesh_a"] = np.asarray(mesh_a, order='F', dtype='f') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_W') bc_omega = np.asarray(dset, order='F', dtype='f') n_problems = bc_omega.shape[0] data["bc_omega"] = bc_omega data["n_problems"] = n_problems dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_BETA') data["bc_switch_type"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_SWITCH_POTENTIAL') data["bc_switch_potential"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_SWITCH_FREE_SURFACE') data["bc_switch_freesurface"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_SWITCH_KOCHIN') data["bc_switch_kochin"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_NORMAL_VELOCITY_VELOCITIES') data["bc_normal_velocity"] = np.asarray(dset, order='F', dtype='F') data["nbc_panels"] = data["bc_normal_velocity"].shape[0] data["rho"] = utility.get_1d_array(logger, hdf5_data, "H5_ENV_VOLUME", expected_dim=1)[0] data["g"] = utility.get_1d_array(logger, hdf5_data, "H5_ENV_GRAVITY", expected_dim=1)[0] data["depth"] = utility.get_1d_array(logger, hdf5_data, "H5_ENV_DEPTH", expected_dim=1)[0] dset = utility.get_1d_array(logger, hdf5_data, "H5_ENV_WAVE_POINT", expected_dim=2) data["xeff"] = dset[0] data["y_eff"] = dset[1] data["indiq_solver"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_TYPE", expected_dim=1)[0] data["max_iterations"] = utility.get_1d_array( logger, hdf5_data, "H5_SOLVER_GMRES_MAX_ITERATIONS", 1)[0] data["restart_param"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GMRES_RESTART", expected_dim=1)[0] data["tol_gmres"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GMRES_STOPPING", expected_dim=1)[0] data["nds"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_MESH_INTEGRATION'), order='F', dtype='f') data["n_integration"] = data["nds"].shape[0] data["use_higher_order"] = utility.get_1d_array( logger, hdf5_data, "H5_SOLVER_USE_HIGHER_ORDER", 1)[0] data["num_panel_higher_order"] = utility.get_1d_array( logger, hdf5_data, "H5_SOLVER_NUM_PANEL_HIGHER_ORDER", 1)[0] data["b_spline_order"] = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_B_SPLINE_ORDER", expected_dim=1)[0] data["theta"] = np.asarray(utility.get_dataset(hdf5_data, 'H5_MESH_KOCHIN'), order='F', dtype='f') data["n_theta"] = data["theta"].shape[0] data["meshfs_x"] = np.asarray(utility.get_2d_array( logger, hdf5_data, "H5_MESH_FREE_SURFACE_VECTORS"), dtype='f') data["nfs_points"] = data["meshfs_x"].shape[1] data["meshfs_p"] = np.asarray(utility.get_2d_array( logger, hdf5_data, "H5_MESH_FREE_SURFACE_INDEX"), order='F', dtype='i') + offset data["nfs_panels"] = data["meshfs_p"].shape[1] data["out_phi"] = np.zeros((n_problems, 1 + data["nfs_points"]), dtype='F', order="F") data["out_pressure"] = np.zeros((n_problems, data["nbc_panels"]), dtype='F', order="F") data["out_hkochin"] = np.zeros((n_problems, data["n_theta"]), dtype='F', order="F") data["line"] = np.zeros((data["n_integration"], n_problems * 2), order="F", dtype='f') data["drift_forces"] = np.zeros((n_problems, data["n_theta"], 2), order="F", dtype='f') data["yaw_moment"] = np.zeros((n_problems, data["n_theta"]), order="F", dtype='f') data["center_buoyancy"] = np.zeros((n_bodies, 3), order="F", dtype='f') data["displacement"] = np.zeros((n_bodies), order="F", dtype='f') data["waterplane_area"] = np.zeros((n_bodies), order="F", dtype='f') data["stifness"] = np.zeros((n_bodies, 6, 6), order="F", dtype='f') n_potentials = 5 * n_points * (1 + (i_sym == 1)) + 9 * n_panels * ( 1 + (i_sym == 1)) data["out_potential"] = np.zeros((n_problems, n_potentials), dtype='f', order="F") data["n_potentials"] = n_potentials data["n_tabulatedx"] = int( utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GREEN_TABULATION_NUMX", 1)[0]) data["n_tabulatedz"] = int( utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GREEN_TABULATION_NUMZ", 1)[0]) data["n_points_simpson"] = int( utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_GREEN_TABULATION_SIMPSON_NPOINTS", 1)[0]) dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_SWITCH_ODE_INFLUENCE') data["fast_influence_switch"] = np.asarray(dset, order='F', dtype='i') data["is_interior_domain"] = np.zeros((n_panels), dtype='i', order="F") remove_irregular_frequencies = utility.get_1d_array( logger, hdf5_data, "H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES", 1)[0] if remove_irregular_frequencies: # Bug??? Previous code used dset = hdf5_data.get(structure.H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES) dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_IS_INTERIOR_DOMAIN') data["is_interior_domain"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_RESULTS_CASE_BETA') data["beta"] = np.asarray(dset, order='F', dtype='f') data["n_beta"] = data["beta"].shape[0] dset = utility.get_dataset(hdf5_data, 'H5_RESULTS_CASE_RADIATION') data["rad_case"] = np.asarray(dset, order='F', dtype='f') data["n_radiation"] = data["rad_case"].shape[0] dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_THIN_PANELS') data["is_thin_body"] = np.asarray(dset, order='F', dtype='i') dset = utility.get_dataset(hdf5_data, 'H5_SOLVER_USE_DIPOLES_IMPLEMENTATION') data["use_dipoles_implementation"] = dset[0] data["remove_irregular_frequencies"] = utility.get_dataset( hdf5_data, 'H5_SOLVER_REMOVE_IRREGULAR_FREQUENCIES')[0] dset = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_COMPUTE_YAW_MOMENT", 1) data["compute_yaw_moment"] = dset[0] dset = utility.get_1d_array(logger, hdf5_data, "H5_SOLVER_COMPUTE_DRIFT_FORCES", 1) data["compute_drift_forces"] = dset[0] # Disable kochin, yaw moments and drift forces if data["use_higher_order"] == 1 or data["use_dipoles_implementation"] == 1: data["n_theta"] = 0 logger.info( 'Disabling koching, yaw monment and drift forces computation as ' 'not supported when higher order panel or dipoles implementation is ' 'enabled') #with CaptureOutput() as capturer: solver_fortran.run_solver(data) write_result(hdf5_data, data)
def run(): args = parse_args() # 初始化随机数种子,以便于复现实验结果 start_epoch = 1 random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if args.device != -1: torch.cuda.manual_seed(args.seed) device = torch.device(f'cuda:{args.device}' if torch.cuda.is_available() and args.device >= 0 else 'cpu') if torch.cuda.is_available() and args.device >= 0: # 开启这个flag需要保证输入数据的维度不变,不然每次cudnn都要重新优化,反而更加耗时 # 现在RNN部分输入会进行fit length,CNN那里可以启用这个参数 if args.arch in ['stack', 'multi', 'stack_multi']: torch.backends.cudnn.benchmark = True # 输出目录 if args.resume_snapshot: # 判断文件是否存在 assert os.path.exists( args.resume_snapshot), f'{args.resume_snapshot} don"t exist!' model_dir, model_file = os.path.split(args.resume_snapshot) output_dir, _ = os.path.split(model_dir) else: base_dir = time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime()) output_dir = os.path.join(args.out_dir, base_dir) model_dir = os.path.join(output_dir, 'save_model') os.makedirs(output_dir) # 创建输出根目录 os.makedirs(model_dir) # 输出参数 logger = get_logger(output_dir) logger.info(pprint.pformat(vars(args))) logger.info(f'output dir is {output_dir}') # 获取数据集 train_dataset, dev_dataset, test_dataset, vocab, vectors = get_dataset( args, logger) vectors_dim = 300 if vectors is None else vectors.size(1) # 创建迭代器 train_loader = torchtext.data.BucketIterator(train_dataset, args.batch_size, device=device, train=True, shuffle=True, sort=False, repeat=False) dev_loader = torchtext.data.BucketIterator(dev_dataset, args.batch_size, device=device, train=False, shuffle=False, sort=False, repeat=False) test_loader = torchtext.data.BucketIterator(test_dataset, args.batch_size, device=device, train=False, shuffle=False, sort=False, repeat=False) # 创建模型,优化器,损失函数 if args.arch == 'stack': model = StackCNN(vocab_size=len(vocab), embed_dim=vectors_dim, embed_weight=vectors, kernel_sizes=args.stack_kernel_sizes, out_channels=args.stack_out_channels).to(device) elif args.arch == 'multi': model = MultiCNN(vocab_size=len(vocab), embed_dim=vectors_dim, embed_weight=vectors, kernel_sizes=args.multi_kernel_sizes, out_channels=args.multi_out_channels).to(device) elif args.arch == 'stack_multi': model = StackMultiCNN( vocab_size=len(vocab), embed_dim=vectors_dim, embed_weight=vectors, stack_kernel_sizes=args.stack_kernel_sizes, stack_out_channels=args.stack_out_channels, multi_kernel_sizes=args.multi_kernel_sizes, multi_out_channels=args.multi_out_channels).to(device) elif args.arch == 'bigru': assert args.hidden_size.find( ',') == -1, '--hidden-size must be a int for BiLSTM/BiGRU model' hidden_size = int(args.hidden_size) model = BiGRU(vocab_size=len(vocab), embedding_dim=vectors_dim, hidden_size=hidden_size, dropout_r=args.dropout, embed_weight=vectors).to(device) elif args.arch == 'bigru_cnn': assert args.hidden_size.find( ',') == -1, '--hidden-size must be a int for BiLSTM/BiGRU model' hidden_size = int(args.hidden_size) model = BiGRUCNN(vocab_size=len(vocab), embedding_dim=vectors_dim, hidden_size=hidden_size, cnn_channel=args.cnn_channel, dropout_r=args.dropout, embed_weight=vectors).to(device) # elif args.arch == 'norm_stack_multi': # model = NormStackMultiCNN(vocab_size=len(vocab), embed_dim=vectors_dim, sent_length=args.fix_length, # embed_weight=vectors).to(device) # elif args.arch == 'stack_multi_atten': # model = QA_StackMultiAttentionCNN(vocab_size=len(vocab), embed_dim=vectors_dim, embed_weight=vectors).to( # device) # elif args.arch == 'ap_stack_multi': # model = QA_AP_StackMultiCNN(vocab_size=len(vocab), embed_dim=vectors_dim, embed_weight=vectors).to( # device) # elif args.arch == 'bilstm': # assert args.hidden_size.find(',') == -1, '--hidden-size must be a int for LSTM model' # hidden_size = int(args.hidden_size) # model = BiLSTM(vocab_size=len(vocab), embedding_dim=vectors_dim, hidden_size=hidden_size, # dropout_r=args.dropout, embed_weight=vectors).to(device) # elif args.arch == 'stack_bilstm': # hidden_size = [int(i) for i in args.hidden_size.split(',')] # model = StackBiLSTM(vocab_size=len(vocab), embedding_dim=vectors_dim, hidden_size=hidden_size, # mlp_d=args.mlp_d, dropout_r=args.dropout, embed_weight=vectors).to(device) # elif args.arch == 'bigru': # assert args.hidden_size.find(',') == -1, '--hidden-size must be a int for BiLSTM/BiGRU model' # hidden_size = int(args.hidden_size) # model = BiGRU(vocab_size=len(vocab), embedding_dim=vectors_dim, hidden_size=hidden_size, # dropout_r=args.dropout, embed_weight=vectors).to(device) # elif args.arch == 'stack_bigru': # hidden_size = [int(i) for i in args.hidden_size.split(',')] # model = StackBiGRU(vocab_size=len(vocab), embedding_dim=vectors_dim, hidden_size=hidden_size, # mlp_d=args.mlp_d, # sent_max_length=args.fix_length, dropout_r=args.dropout, embed_weight=vectors).to(device) else: raise ValueError("--arch is unknown") # 为特定模型指定特殊的优化函数 if args.optimizer == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) elif args.optimizer == 'rmsprop': optimizer = torch.optim.RMSprop(model.parameters(), lr=args.lr) elif args.optimizer == 'adagrad': optimizer = torch.optim.Adagrad(model.parameters(), lr=args.lr) elif args.optimizer == 'sgd': optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) else: raise ValueError("--optimizer is unknown") loss_fn = torch.nn.MarginRankingLoss(margin=args.margin) architecture = model.__class__.__name__ # 载入以训练的数据 if args.resume_snapshot: state = torch.load(args.resume_snapshot) model.load_state_dict(state['model']) optimizer.load_state_dict(state['optimizer']) epoch = state['epoch'] start_epoch = state['epoch'] + 1 if 'best_dev_score' in state: # 适配旧版本保存的模型参数 dev_acc = state['best_dev_score'] test_acc = 0 else: dev_acc = state['dev_accuracy'] test_acc = state['test_accuracy'] logger.info( f"load state {args.resume_snapshot}, dev accuracy {dev_acc}, test accuracy {test_acc}" ) # 记录参数 with open(f'{output_dir}/arguments.csv', 'a') as f: for k, v in vars(args).items(): f.write(f'{k},{v}\n') # 将日志写入到TensorBoard中 writer = SummaryWriter(output_dir) # 记录模型的计算图 try: q = torch.randint_like(torch.Tensor(1, args.fix_length), 2, 100, dtype=torch.long) ql = torch.Tensor([args.fix_length]).type(torch.int) writer.add_graph(model, ((q, ql), (q, ql))) except Exception as e: logger.error("Failed to save model graph: {}".format(e)) # exit() # 开始训练 best_dev_score = -1 # 记录最优的结果 best_test_score = -1 # 记录最优的结果 prev_loss = 0 # 自动调整学习率 # TODO:暂不启用,Adam已经能够自动调整学习率了 # scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=args.lr_reduce_factor, # patience=args.patience, verbose=True) if not args.skip_training: for epoch in range(start_epoch, start_epoch + args.epochs): start_time = time.time() # train epoch loss = train_epoch(epoch, train_loader, model, optimizer, loss_fn, device) writer.add_scalar('train/loss', loss, epoch) logger.info(f'Train Epoch {epoch}: loss={loss}') # evaluate dev_accuracy = evaluate(dev_loader, model, 1) logger.info( f'Evaluation metrices: dev accuracy = {100. * dev_accuracy}%') writer.add_scalar('dev/lr', optimizer.param_groups[0]['lr'], epoch) writer.add_scalar('dev/acc', dev_accuracy, epoch) # 进行测试 test_accuracy = evaluate(test_loader, model, 1) logger.info( f'Evaluation metrices: test accuracy = {100. * test_accuracy}%' ) writer.add_scalar('test/acc', test_accuracy, epoch) # 保存模型 save_state = { 'epoch': epoch, 'dev_accuracy': dev_accuracy, 'test_accuracy': test_accuracy, 'architecture': architecture, 'model': model.state_dict(), 'optimizer': optimizer.state_dict() } torch.save(save_state, f'{model_dir}/{architecture}_epoch_{epoch}.pth') logger.info( 'Save model: epoch {}, dev accuracy {}, test accuracy {}'. format(epoch, dev_accuracy, test_accuracy)) # 计算模型运行时间 duration = time.time() - start_time logger.info('Epoch {} finished in {:.2f} minutes'.format( epoch, duration / 60)) if abs(prev_loss - loss) <= args.early_stopping: logger.info( 'Early stopping. Loss changed by less than {}.'.format( args.early_stopping)) break prev_loss = loss else: # 进行测试 dev_accuracies = evaluate(dev_loader, model, args.topk) for k in args.topk: logger.info( f'Evaluation metrices: top-{k} dev accuracy = {dev_accuracies[k]}%' ) test_accuracies = evaluate(test_loader, model, args.topk) for k in args.topk: logger.info( f'Evaluation metrices: top-{k} test accuracy = {test_accuracies[k]}%' )
def main(): global_batch_size = 1024 slot_num = 10 nnz_per_slot = 5 from tensorflow.python.keras.engine import base_layer_utils base_layer_utils.enable_v2_dtype_behavior() policy = tf.keras.mixed_precision.experimental.Policy("mixed_float16") tf.keras.mixed_precision.experimental.set_policy(policy) dataset = utility.get_dataset(global_batch_size//hvd.size(), read_batchsize=global_batch_size//hvd.size()) sok_init_op = sok.Init(global_batch_size=global_batch_size) model = utility.SOKDenseDemo(max_vocabulary_size_per_gpu=1024, embedding_vec_size=8, slot_num=slot_num, nnz_per_slot=nnz_per_slot, num_dense_layers=0) optimizer = tf.keras.optimizers.Adam(learning_rate=0.1) optimizer = sok.tf.keras.mixed_precision.LossScaleOptimizer(optimizer, 1024) loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=True, reduction='none') def _replica_loss(labels, logits): loss = loss_fn(labels, logits) dtype = loss.dtype loss = tf.cast(loss, tf.float32) loss = tf.nn.compute_average_loss(loss, global_batch_size=global_batch_size) return tf.cast(loss, dtype) def train_step(inputs, labels): logit = model(inputs, training=True) loss = _replica_loss(labels, logit) scaled_loss = optimizer.get_scaled_loss(loss) scaled_gradients = tf.gradients(scaled_loss, model.trainable_variables) emb_vars, other_vars =\ sok.split_embedding_variable_from_others(model.trainable_variables) scaled_emb_grads, scaled_other_grads =\ scaled_gradients[:len(emb_vars)], scaled_gradients[len(emb_vars):] emb_grads = optimizer.get_unscaled_gradients(scaled_emb_grads) other_grads = optimizer.get_unscaled_gradients(scaled_other_grads) other_grads = [hvd.allreduce(grad) for grad in other_grads] with sok.OptimizerScope(emb_vars): emb_train_op = optimizer.apply_gradients(zip(emb_grads, emb_vars)) other_train_op = optimizer.apply_gradients(zip(other_grads, other_vars)) total_loss = hvd.allreduce(loss) with tf.control_dependencies([emb_train_op, other_train_op]): return tf.identity(total_loss) train_iterator = dataset.make_initializable_iterator() iterator_init = train_iterator.initializer inputs, labels = train_iterator.get_next() loss = train_step(inputs, labels) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) with tf.Session() as sess: sess.run(sok_init_op) sess.run([init_op, iterator_init]) for step in range(10): loss_v = sess.run(loss) if hvd.local_rank() == 0: print("[INFO]: step {}, loss {}".format(step, loss_v))