def main(): if param['disable_calibration'] == 0: print('\nCCD CALIBRATION:\n') calibration.calibrate_data() print('\nCalibration successfully completed.') if param['disable_analysis'] == 0: print('\n----------------------------------------') print('\nDATA ANALYSIS:\n') analysis.analyze_data() print('Data analysis successfully completed.') if param['disable_plots'] == 0: print('\n----------------------------------------') print('\nPLOTTING:\n') plots.make_plots() print('Plotting successfully completed.')
def run_one(parameters_with_uncertainties, household_well_as, group_name, data, numbins): """Run the two mass balance models for one set of input parameters. Outputs the data with predicted values appended, the results of the two regressions, and the parameters for the two models. """ # get the correct subset of the data data_subset = make_subset(data, group_name) # run regressions distributed_results, household_results, data_subset = run_regressions( data_subset, group_name, household_well_as) # calculate parameter values distributed_params, household_params = calculate_parameters( distributed_results, household_results, parameters_with_uncertainties, group_name, household_well_as) # plot results make_plots(distributed_results, distributed_params, household_results, household_params, data_subset, group_name, numbins, household_well_as) # compare subsets compare_subsets(distributed_results, data) return data_subset, distributed_results, distributed_params, household_results, household_params
whitening_factor=np.sqrt(float(ndata)) # whitening scale factor ) return params params = get_params() # load in y normscale hf = h5py.File('plotting_data_%s/y_normscale_value.h5' % params['run_label'], 'r') y_normscale = np.array(hf['y_normscale']) hf.close() # Make directory for plots #plots.make_dirs(params,params['plot_dir'][0]) # Declare plot class variables plotter = plots.make_plots(params, None, None, None) # plot losses #plotter.make_loss_plot(None,None,params['report_interval'],fwd=False) # Make KL plot #plotter.gen_kl_plots(VICI_inverse_model,None,None,None) # Make pp plot plotter.plot_pp(VICI_inverse_model, None, None, 0, None, None, None) # Make corner plots #plotter.make_corner_plot(None,None,sampler='dynesty1')
params['sigma'], params['usepars'], params['n_burnin']) # save samples for latter f = h5py.File("data/generated_samples_%s" % run_label, "w") f.create_dataset("x_data_train_h", data=x_data_train_h) f.create_dataset("y_data_train_lh", data=y_data_train_lh) f.create_dataset("y_data_test_h", data=y_data_test_h) f.create_dataset("pos_test", data=pos_test) f.create_dataset("samples", data=samples) f.close() # Make directory for plots #plots.make_dirs(params['plot_dir'][0]) # Declare plot class variables plotter = plots.make_plots(params, samples, None, pos_test) # First, we learn a multi-fidelity model that lerns to infer high-fidelity (accurate) observations from trget images/objects and low fidelity simulated observations. for this we use the portion of the training set for which we do have real/high fidelity observations. #_, _ = VICI_forward_model.train(params, x_data_train_h, y_data_train_h, y_data_train_lh, "forward_model_dir/forward_model.ckpt", plotter) # This trains the forward model and saves the weights in forward_model_dir/forward_model.ckpt # We then train the inference model using all training images and associated low-fidelity (inaccurate) observations. Using the previously trained forward model to draw from the observation likelihood. #_, _ = VICI_inverse_model.train(params, x_data_train, y_data_train_l, np.shape(y_data_train_h)[1], "forward_model_dir/forward_model.ckpt", "inverse_model_dir/inverse_model.ckpt", plotter, y_data_test_h) # This trains the inverse model to recover posteriors using the forward model weights stored in forward_model_dir/forward_model.ckpt and saves the inverse model weights in inverse_model_dir/inverse_model.ckpt _, _ = VICI_inverse_model.resume_training( params, x_data_train, y_data_train_l, np.shape(y_data_train_h)[1], "forward_model_dir/forward_model.ckpt", "inverse_model_dir/inverse_model.ckpt") # The trained inverse model weights can then be used to infer a probability density of solutions given new measurements xm, xsx, XS, pmax = VICI_inverse_model.run( params, y_data_test_h, np.shape(x_data_train)[1], "inverse_model_dir/inverse_model.ckpt"
print('Training IBM 1') trained_lexicon = IBM1_EM(e, f, lexicon, nr_it=nr_it) print('calculating final scores...') output_naacl(viterbi(e_test, f_test, trained_lexicon), 'AER/naacl_IBM1.txt') os.system('perl data/testing/eval/wa_check_align.pl AER/naacl_IBM1.txt') os.system( 'perl data/testing/eval/wa_eval_align.pl data/testing/answers/test.wa.nonullalign AER/naacl_IBM1.txt' ) if savemodel: dill.dump(trained_lexicon, open("trained_models/" + model + ".dill", "wb")) if plots: make_plots('perplexity_IBM1.p', 'AER_IBM1.p') elif model == 'IBM1_VB': print('Training Bayesian IBM 1') trained_lexicon, elbo_values = IBM1_VB(e, f, lexicon, nr_it=nr_it) pickle.dump(file=open('elbo_values.pkl', 'wb'), obj=elbo_values) print('finished training') # Save model if savemodel: dill.dump(trained_lexicon, open("trained_models/IBM1VB_theta.dill", "wb")) print('calculating final scores...') output_naacl(viterbi(e_test, f_test, trained_lexicon), 'AER/naacl_IBM1VB.txt')
def run(prefix, regions, taxa, iters, procs, program_path, profile, threading_configurations, flamegraph_cmd): os.makedirs(prefix, exist_ok=True) exp_program = [ program.lagrange(binary_path=os.path.abspath(program_path), profile=profile) ] exp = [] exp_name_format = "{taxa}taxa_{regions}regions_{workers}workers_{tpw}tpw" with rich.progress.Progress() as progress_bar: total_datasets = len(regions) * len(taxa) *\ len(threading_configurations) total_work = total_datasets * iters extra_work = 0 if profile: extra_work += 1 make_task = progress_bar.add_task("Making datasets...", total=total_datasets) with open(os.path.join(prefix, 'parameters.yaml'), 'w') as yamlfile: yamlfile.write( yaml.dump( { 'prefix': prefix, 'regions': regions, 'taxa': taxa, 'iters': iters, 'procs': procs, 'program_path': program_path, 'program_sha256': compute_hash_with_path(program_path), 'profile': profile, 'threading_configurations': threading_configurations, }, explicit_start=True, explicit_end=True)) with open(os.path.join(prefix, 'notes.md'), 'a') as notesfile: notesfile.write("- Started on: {}\n".format( datetime.datetime.now().isoformat())) for r, t, tc in itertools.product(regions, taxa, threading_configurations): exp_path = os.path.join( prefix, exp_name_format.format(regions=r, taxa=t, workers=tc[0], tpw=tc[1])) exp.append( experiment.experiment(exp_path, make_datasets(t, r, iters, tc[0], tc[1]), exp_program)) progress_bar.update(make_task, advance=1.0) rich.print("Running {} experiments".format(len(exp))) overall_task = progress_bar.add_task("Running...", total=total_datasets + extra_work) for e in exp: e.run(procs) progress_bar.update(overall_task, advance=1.0) if not profile: results = [] for e in exp: results.extend(e.collect_results()) with open(os.path.join(prefix, 'results.csv'), 'w') as csv_file: writer = csv.DictWriter(csv_file, fieldnames=results[0].header()) writer.writeheader() for result in results: writer.writerow(result.write_row()) dataframe = pandas.read_csv(os.path.join(prefix, 'results.csv')) plots.make_plots(dataframe, prefix) else: fg_work = len(exp) * len(exp[0].datasets) fg_task = progress_bar.add_task("Making Flamegraphs...", total=fg_work) for e in exp: for d in e.datasets: flamegraph.build(d) progress_bar.update(fg_task, advance=1.0) progress_bar.update(overall_task, advance=1.0) with open(os.path.join(prefix, 'notes.md'), 'a') as notesfile: notesfile.write("- Finshed on: {}\n".format( datetime.datetime.now().isoformat()))
loc=(0.86, 0.22), fontsize=20) plt.savefig( '%s/latest_%s/corner_plot_%s_%d.png' % (params['plot_dir'], params['run_label'], params['run_label'], i)) plt.close() del figure print('Made corner plot: %s' % str(i + 1)) # Store ML predictions for later plotting use VI_pred_all.append(VI_pred) VI_pred_all = np.array(VI_pred_all) # Define pp and KL plotting class plotter = plots.make_plots(params, XS_all, VI_pred_all, x_data_test, model_loc) if params['make_kl_plot'] == True: # Make KL plots plotter.gen_kl_plots(VICI_inverse_model, y_data_test, x_data_test, y_normscale, bounds, snrs_test) if params['make_pp_plot'] == True: # Make pp plot plotter.plot_pp(VICI_inverse_model, y_data_test, x_data_test, 0, y_normscale, x_data_test, bounds) if params['make_loss_plot'] == True: plotter.plot_loss()
def train(params, x_data, y_data, siz_high_res, save_dir, plotter, y_data_test,train_files,normscales,y_data_train_noisefree,samples,pos_test,y_normscale): x_data = x_data y_data_train_l = y_data # USEFUL SIZES xsh = np.shape(x_data) yshl1 = np.shape(y_data)[1] ysh1 = np.shape(y_data)[1] print(xsh,yshl1,ysh1) #z_dimension_fm = params['z_dimensions_fw'] #n_weights_fm = params['n_weights_fw'] z_dimension = params['z_dimension'] bs = params['batch_size'] n_weights = params['n_weights'] lam = 1 graph = tf.Graph() session = tf.Session(graph=graph) with graph.as_default(): tf.set_random_seed(np.random.randint(0,10)) SMALL_CONSTANT = 1e-6 # PLACE HOLDERS x_ph = tf.placeholder(dtype=tf.float32, shape=[None, xsh[1]], name="x_ph") bs_ph = tf.placeholder(dtype=tf.int64, name="bs_ph") # batch size placeholder yt_ph = tf.placeholder(dtype=tf.float32, shape=[None, ysh1], name="yt_ph") # LOAD FORWARD MODEL NEURAL NETWORKS #DEC_XYlZtoYh = OELBO_decoder_difference.VariationalAutoencoder("OELBO_decoder", ysh1, z_dimension_fm+yshl1+xsh[1], n_weights_fm) # p(Yh|X,Yl,Z) #ENC_XYltoZ = OELBO_encoder.VariationalAutoencoder("OELBO_encoder", yshl1+xsh[1], z_dimension_fm, n_weights_fm) # p(Z|X,Yl) #ENC_XYhYltoZ = VAE_encoder.VariationalAutoencoder("vae_encoder", xsh[1]+ysh1+yshl1, z_dimension_fm, n_weights_fm) # q(Z|X,Yl,Yh) # LOAD VICI NEURAL NETWORKS autoencoder = VICI_decoder.VariationalAutoencoder("VICI_decoder", xsh[1], z_dimension+ysh1, n_weights) # r(x|z,y) autoencoder_ENC = VICI_encoder.VariationalAutoencoder("VICI_encoder", ysh1, z_dimension, n_weights) # generates params for r(z|y) autoencoder_VAE = VICI_VAE_encoder.VariationalAutoencoder("VICI_VAE_encoder", xsh[1]+ysh1, z_dimension, n_weights) # used to sample from r(z|y)? # DEFINE MULTI-FIDELITY FORWARD MODEL ##################################################################################################################### SMALL_CONSTANT = 1e-6 # NORMALISE INPUTS yl_ph_n = tf_normalise_dataset(yt_ph) # placeholder for normalised low-res y data x_ph_n = tf_normalise_dataset(x_ph) # placeholder for normalised x data #yl_ph_n = yt_ph #x_ph_n = x_ph #yl_ph_n = tf.Print(yl_ph_n, [yl_ph_n], first_n=1, summarize=10, message="Thss is yl_ph_n: ") #x_ph_n = tf.Print(x_ph_n, [x_ph_n], first_n=1, summarize=10, message="This is x_ph_n: ") # GET p(Z|X,Yl) - takes in x data and low res y data and returns mean and logvar of Gaussian z distribution #zxyl_mean,zxyl_log_sig_sq = ENC_XYltoZ._calc_z_mean_and_sigma(tf.concat([x_ph_n,yl_ph_n],1)) #zxyl_mean = tf.Print(zxyl_mean, [zxyl_mean], first_n=1, summarize=10, message="Thss is zxyl_mean: ") #zxyl_log_sig_sq = tf.Print(zxyl_log_sig_sq, [zxyl_log_sig_sq], first_n=1, summarize=10, message="Thss is zxyl_log_sig_sq: ") # then samples z from that distribution #rxyl_samp = ENC_XYhYltoZ._sample_from_gaussian_dist(tf.shape(x_ph_n)[0], z_dimension_fm, zxyl_mean, tf.log(tf.exp(zxyl_log_sig_sq)+SMALL_CONSTANT)) #rxyl_samp = tf.Print(rxyl_samp, [rxyl_samp], first_n=1, summarize=10, message="Thss is rxyl_samp: ") # GET p(Yh|X,Yl,Z) FROM SAMPLES Z ~ p(Z|X,Yl) # then decodes back to high res y data #reconstruction_yh = DEC_XYlZtoYh.calc_reconstruction(tf.concat([x_ph_n,yl_ph_n,rxyl_samp],1)) # = tf.Print(, [], first_n=1, summarize=10, message="Thss is : ") #reconstruction_yh = tf.Print(reconstruction_yh, [reconstruction_yh], first_n=1, summarize=10, message="Thss is reconstruction_yh: ") #yh_diff = reconstruction_yh[0] # looks like the difference between the low res y data and the mean reconstructed high res y data #yh_diff = tf.Print(yh_diff, [yh_diff], first_n=1, summarize=10, message="Thss is yh_diff: ") #yh_mean = yl_ph_n+yh_diff # the mean reconstrcted high res data #yh_mean = tf.Print(yh_mean, [yh_mean], first_n=1, summarize=10, message="Thss is yh_mean: ") #yh_log_sig_sq = reconstruction_yh[1] # the reconstructed high res y data logvar #yh_log_sig_sq = tf.Print(yh_log_sig_sq, [yh_log_sig_sq], first_n=1, summarize=10, message="Thss is yh_log_sig_sq: ") # then sample something? y doesn't seem to be used anywhere after this # this ends up being the reconstruction of the exact y data corresponding to each x data input #y = ENC_XYhYltoZ._sample_from_gaussian_dist(tf.shape(yt_ph)[0], tf.shape(yt_ph)[1], yh_mean, yh_log_sig_sq) #y = tf.Print(y, [y], first_n=1, summarize=10, message="Thss is y: ") # DRAW SYNTHETIC Ys TRAINING DATA # _, y = OM.forward_model(x_ph_amp,x_ph_ph) ########################################################################################################################################## # GET r(z|y) #y_ph = tf.placeholder(dtype=tf.float32, shape=[None, ysh1], name="y_ph") # placeholder for y data #y_ph_n = tf_normalise_dataset(y_ph) # placeholder for normalised y data #y_ph = tf.Print(y_ph, [y_ph], first_n=1, summarize=10, message="Thss is y_ph: ") #y_ph_n = y_ph # run inverse autoencoder to generate mean and logvar of z given y data - these are the parameters for r(z|y) #zy_mean,zy_log_sig_sq = autoencoder_ENC._calc_z_mean_and_sigma(y_ph_n) zy_mean,zy_log_sig_sq = autoencoder_ENC._calc_z_mean_and_sigma(yl_ph_n) # DRAW FROM r(z|y) - given the Gaussian parameters generate z samples rzy_samp = autoencoder_VAE._sample_from_gaussian_dist(bs_ph, z_dimension, zy_mean, zy_log_sig_sq) # GET r(x|z,y) from r(z|y) samples #rzy_samp_y = tf.concat([rzy_samp,y_ph_n],1) rzy_samp_y = tf.concat([rzy_samp,yl_ph_n],1) reconstruction_xzy = autoencoder.calc_reconstruction(rzy_samp_y) x_mean = reconstruction_xzy[0] x_log_sig_sq = reconstruction_xzy[1] # KL(r(z|y)||p(z)) #latent_loss = -0.5 * tf.reduce_sum(1 + zy_log_sig_sq - tf.square(zy_mean) - tf.exp(zy_log_sig_sq), 1) #KL = tf.reduce_mean(latent_loss) # GET q(z|x,y) #xy_ph = tf.concat([x_ph_n,y_ph_n],1) xy_ph = tf.concat([x_ph_n,yl_ph_n],1) zx_mean,zx_log_sig_sq = autoencoder_VAE._calc_z_mean_and_sigma(xy_ph) # DRAW FROM q(z|x,y) qzx_samp = autoencoder_VAE._sample_from_gaussian_dist(bs_ph, z_dimension, zx_mean, zx_log_sig_sq) # GET r(x|z,y) #qzx_samp_y = tf.concat([qzx_samp,y_ph_n],1) qzx_samp_y = tf.concat([qzx_samp,yl_ph_n],1) reconstruction_xzx = autoencoder.calc_reconstruction(qzx_samp_y) x_mean_vae = reconstruction_xzx[0] x_log_sig_sq_vae = reconstruction_xzx[1] # COST FROM RECONSTRUCTION normalising_factor_x_vae = - 0.5 * tf.log(SMALL_CONSTANT+tf.exp(x_log_sig_sq_vae)) - 0.5 * np.log(2 * np.pi) square_diff_between_mu_and_x_vae = tf.square(x_mean_vae - x_ph_n) inside_exp_x_vae = -0.5 * tf.div(square_diff_between_mu_and_x_vae,SMALL_CONSTANT+tf.exp(x_log_sig_sq_vae)) reconstr_loss_x_vae = -tf.reduce_sum(normalising_factor_x_vae + inside_exp_x_vae, 1) cost_R_vae = tf.reduce_mean(reconstr_loss_x_vae) # KL(q(z|x,y)||r(z|y)) v_mean = zy_mean #2 aux_mean = zx_mean #1 v_log_sig_sq = tf.log(tf.exp(zy_log_sig_sq)+SMALL_CONSTANT) #2 aux_log_sig_sq = tf.log(tf.exp(zx_log_sig_sq)+SMALL_CONSTANT) #1 v_log_sig = tf.log(tf.sqrt(tf.exp(v_log_sig_sq))) #2 aux_log_sig = tf.log(tf.sqrt(tf.exp(aux_log_sig_sq))) #1 cost_VAE_a = v_log_sig-aux_log_sig+tf.divide(tf.exp(aux_log_sig_sq)+tf.square(aux_mean-v_mean),2*tf.exp(v_log_sig_sq))-0.5 cost_VAE_b = tf.reduce_sum(cost_VAE_a,1) KL_vae = tf.reduce_mean(cost_VAE_b) # computes the mean over all tensor elements # THE VICI COST FUNCTION lam_ph = tf.placeholder(dtype=tf.float32, name="lam_ph") COST_VAE = KL_vae+cost_R_vae COST = COST_VAE # VARIABLES LISTS var_list_VICI = [var for var in tf.trainable_variables() if var.name.startswith("VICI")] var_list_ELBO = [var for var in tf.trainable_variables() if var.name.startswith("ELBO")] # DEFINE OPTIMISER (using ADAM here) optimizer = tf.train.AdamOptimizer(params['initial_training_rate']) minimize = optimizer.minimize(COST,var_list = var_list_VICI) # DRAW FROM q(x|y) qx_samp = autoencoder_ENC._sample_from_gaussian_dist(bs_ph, xsh[1], x_mean, SMALL_CONSTANT + tf.log(tf.exp(x_log_sig_sq))) # INITIALISE AND RUN SESSION # init = tf.variables_initializer(var_list_VICI) #init = tf.initialize_all_variables() init = tf.global_variables_initializer() session.run(init) #saver_ELBO = tf.train.Saver(var_list_ELBO) #saver_ELBO.restore(session,load_dir) saver = tf.train.Saver() KL_PLOT = np.zeros(np.int(np.round(params['num_iterations']/params['report_interval'])+1)) # vector to store test OELBO values COST_PLOT = np.zeros(np.int(np.round(params['num_iterations']/params['report_interval'])+1)) # vector to store test VAE ELBO values print('Training Inference Model...') # START OPTIMISATION OF OELBO indices_generator = batch_manager.SequentialIndexer(params['batch_size'], xsh[0]) ni = -1 test_n = 100 olvec = [] for i in range(params['num_iterations']): next_indices = indices_generator.next_indices() # run the session - input batchsize the x-data training batch and the y-data training batch #yn = session.run(y, feed_dict={bs_ph:bs, x_ph:x_data[next_indices, :], yt_ph:y_data_train_l[next_indices, :]}) #session.run(minimize, feed_dict={bs_ph:bs, x_ph:x_data[next_indices, :], y_ph:yn, lam_ph:lam, yt_ph:y_data_train_l[next_indices, :]}) # minimising cost function # Make 25 noise realizations if params['do_extra_noise']: x_data_train_l = x_data[next_indices,:] y_data_train_l = y_data_train_noisefree[next_indices,:] + np.random.normal(0,1,size=(params['batch_size'],params['ndata'])) if params['do_normscale']: y_data_train_l /= y_normscale[0] #print('generated {} elements of new training data noise'.format(params['batch_size'])) session.run(minimize, feed_dict={bs_ph:bs, x_ph:x_data_train_l, lam_ph:lam, yt_ph:y_data_train_l}) # minimising cost function else: session.run(minimize, feed_dict={bs_ph:bs, x_ph:x_data[next_indices, :], lam_ph:lam, yt_ph:y_data_train_l[next_indices, :]}) # minimising cost function if i % params['report_interval'] == 0 and i > 0: ni = ni+1 #ynt = session.run(y, feed_dict={bs_ph:test_n, x_ph:x_data[0:test_n,:], yt_ph:y_data_train_l[0:test_n,:]}) #cost_value_vae, KL_VAE = session.run([COST_VAE, KL_vae], feed_dict={bs_ph:test_n, x_ph:x_data[0:test_n,:], y_ph:ynt, lam_ph:lam, yt_ph:y_data_train_l[0:test_n,:]}) cost_value_vae, KL_VAE = session.run([cost_R_vae, KL_vae], feed_dict={bs_ph:test_n, x_ph:x_data_train_l[0:test_n,:], lam_ph:lam, yt_ph:y_data_train_l[0:test_n,:]}) KL_PLOT[ni] = KL_VAE COST_PLOT[ni] = cost_value_vae # plot losses plotter.make_loss_plot(COST_PLOT[:ni+1],KL_PLOT[:ni+1],params['report_interval'],fwd=False) if params['print_values']==True: print('--------------------------------------------------------------') print('Iteration:',i) print('Training Set -ELBO:',cost_value_vae) print('KL Divergence:',KL_VAE) if i % params['plot_interval'] == 0 and i>0: # The trained inverse model weights can then be used to infer a probability density of solutions given new measurements _, _, XS, _, _ = VICI_inverse_model.run(params, y_data_test, np.shape(x_data)[1], "inverse_model_dir_%s/inverse_model.ckpt" % params['run_label']) # Convert XS back to unnormalized version if params['do_normscale']: for m in range(params['ndim_x']): XS[:,m,:] = XS[:,m,:]*normscales[m] # Generate final results plots plotter = plots.make_plots(params,samples,XS,pos_test) # Make corner plots plotter.make_corner_plot(sampler='dynesty1') # Make KL plot # plotter.gen_kl_plots(VICI_inverse_model,y_data_test,x_data,normscales) # Make pp plot # plotter.plot_pp(VICI_inverse_model,y_data_train_l,x_data_train,0,normscales) if i % params['save_interval'] == 0 and i > 0: # Save model save_path = saver.save(session,save_dir) return COST_PLOT, KL_PLOT, train_files
def main(N=30, Q=20, T=10, actions_per_timestep_per_node=15, interactions_per_timestep=90, num_generations=8, num_experiment_per_generation=3, fixed_sigma=0.1, num_epochs=2, alpha_clip_0=0.4, threshold=5E-4): for experiment_run_id in range(num_generations): for generative_id, generative_setting in tqdm( hyperparams_settings.items()): generative_seed = hash(f"{experiment_run_id}-{generative_id}") & ( 2**32 - 1) u_v_t_w, v_a_t_w, X_original, w_original = generate( N=N, Q=Q, T=T, actions_per_timestep_per_node=actions_per_timestep_per_node, fixed_sigma=fixed_sigma, interactions_per_timestep=interactions_per_timestep, seed=generative_seed, **generative_setting) for _ in range(num_experiment_per_generation): for estimation_id, estimation_setting in hyperparams_settings.items( ): print( '===========================================================================' ) print('generative_setting:', generative_id, '\testimation_setting:', estimation_id, '\texperiment_run_id:', experiment_run_id) print( '===========================================================================' ) mlflow.start_run() mlflow.log_param("generative_seed", generative_seed) mlflow.log_param("generative_setting", generative_id) mlflow.log_param("estimation_setting", estimation_id) mlflow.log_param("true_hyperparameters", generative_id == estimation_id) mlflow.log_param("generation_id", f"{generative_id}_{experiment_run_id}") mlflow.log_param("N", N) mlflow.log_param("Q", Q) mlflow.log_param("T", T) mlflow.log_param("interactions_per_timestep", interactions_per_timestep) mlflow.log_param("actions_per_timestep_per_node", actions_per_timestep_per_node) mlflow.log_param("num_epochs", num_epochs) mlflow.log_param("alpha_clip_0", alpha_clip_0) for k, v in generative_setting.items(): mlflow.log_param('generation_' + k, v) for k, v in estimation_setting.items(): mlflow.log_param('estimation_' + k, v) try: X_estimated, w_estimated, _sigma, t2signs_estimated, alphas, evals = model.learn_opinion_dynamics( N=N, Q=Q, T=T, verbose=False, u_v_t_weights=u_v_t_w, v_a_t_weights=v_a_t_w, num_epochs=num_epochs, threshold=threshold, alpha_clip_0=alpha_clip_0, **estimation_setting) comparison, avg_diffs = compare( X_original, X_estimated, w_original, w_estimated) comparison.update( compare_signs(u_v_t_w, X_original, t2signs_estimated, **generative_setting)) for key, val in list(evals.items()) + list( comparison.items()): mlflow.log_metric(key, val) plots.make_plots(X_original, X_estimated, w_original, w_estimated) np.savetxt('estimated_alphas.txt', alphas) mlflow.log_artifact('estimated_alphas.txt') np.savetxt('avg_diffs.txt', avg_diffs) mlflow.log_artifact('avg_diffs.txt') except Exception as e: # pylint: disable=broad-except mlflow.set_tag('crashed', True) mlflow.set_tag('exception', e) with open("exception.txt", 'w') as f: traceback.print_exc(file=f) mlflow.log_artifact("exception.txt") mlflow.end_run()