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))