def get_default_models(): """Our default set of models (6 model * 6 hyperparameters=36 models).""" # BetaVAE config. model_name = h.fixed("model.name", "supervised_vae") model_fn = h.fixed("model.model", "@supervised_vae()") betas = h.sweep("supervised_vae.beta", h.discrete([0., 1., 4.])) omegas = h.sweep("supervised_vae.omega", h.discrete([0.0, 1.0, 10.0])) params_product = h.product([betas, omegas]) config_supervised_vae = h.zipit([model_name, params_product, model_fn]) all_models = h.chainit([config_supervised_vae]) return all_models
def get_default_models(): """Our default set of models (6 model * 6 hyperparameters=36 models).""" # BetaVAE config. model_name = h.fixed("model.name", "balanced_beta_vae") model_fn = h.fixed("model.model", "@balanced_beta_vae()") beta_sizes = h.sweep("balanced_beta_vae.beta_size", h.discrete([0.0, 0.1, 0.5, 1., 2., 4., 8., 16.])) beta_variances = h.sweep("balanced_beta_vae.beta_variance", h.discrete([0.0, 0.1, 0.5, 1., 2., 4., 8., 16.])) betas_product = h.product([beta_sizes, beta_variances]) config_balanced_beta_vae = h.zipit([model_name, betas_product, model_fn]) all_models = h.chainit([config_balanced_beta_vae]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "softmax_vae") model_fn = h.fixed("model.model", "@vae()") beta = h.fixed('vae.beta', self.beta) softmax_layers = h.fixed('conv_encoder.softmax_layers', True) scale_temperature = h.fixed('conv_encoder.scale_temperature', self.scale_temperature) softmax_temperature = h.sweep( 'conv_encoder.softmax_temperature', h.discrete(np.logspace(-4., 2., 6, endpoint=False)), ) all_layers = h.fixed('conv_encoder.all_layers', self.all_layers) config_masked = h.zipit([ model_name, model_fn, beta, softmax_layers, scale_temperature, softmax_temperature, all_layers, ]) all_models = h.chainit([config_masked, ]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "vd_vae") model_fn = h.fixed("model.model", "@vd_vae()") beta = h.fixed('vae.beta', self.beta) all_layers = h.fixed('conv_encoder.all_layers', self.all_layers) vd_layers = h.fixed('conv_encoder.vd_layers', True) vd_threshold = h.fixed('vd_vae.vd_threshold', 3.) scale_per_layer = h.fixed('vd_vae.scale_per_layer', self.scale_per_layer) anneal_kld_from = h.fixed('vd_vae.anneal_kld_from', self.anneal_kld_from) anneal_kld_for = h.fixed('vd_vae.anneal_kld_for', self.anneal_kld_for) lmbd_kld_vd = h.sweep("vd_vae.lmbd_kld_vd", h.discrete([*np.logspace(-5, 1, 6, endpoint=False)])) config_vdm = h.zipit([ model_name, model_fn, beta, all_layers, vd_layers, vd_threshold, scale_per_layer, anneal_kld_from, anneal_kld_for, lmbd_kld_vd, ]) all_models = h.chainit([config_vdm, ]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "weight_decay_vae") model_fn = h.fixed("model.model", "@dim_wise_mask_l1_vae()") beta = h.fixed('vae.beta', self.beta) scale_per_layer = h.fixed('dim_wise_l1_vae.scale_per_layer', self.scale_per_layer) dim = h.fixed('dim_wise_l1_vae.dim', self.dim) all_layers_1 = h.fixed('dim_wise_l1_vae.all_layers', self.all_layers) all_layers_2 = h.fixed('conv_encoder.all_layers', self.all_layers) # make the masks full (no zero-entries) perc_sparse = h.fixed("conv_encoder.perc_sparse", h.discrete(0)) # but allow to modify the entries mask_trainable = h.fixed('masked_layer.mask_trainable', False) lmbds_l2 = h.sweep('dim_wise_mask_l1_vae.lmbd_l2', h.discrete(self.lmbd_l2_range)) lmbds_l1 = h.fixed("dim_wise_l1_vae.lmbd_l1", h.discrete(self.lmbd_l1_range[0])) config_weight_decay = h.zipit([ model_name, model_fn, beta, scale_per_layer, dim, all_layers_1, all_layers_2, perc_sparse, mask_trainable, lmbds_l2, lmbds_l1, ]) all_models = h.chainit([config_weight_decay, ]) return all_models
def get_default_models(): """Our default set of models (6 model * 6 hyperparameters=36 models).""" # BetaVAE config. model_name = h.fixed("model.name", "augmented_variance_vae") model_fn = h.fixed("model.model", "@augmented_variance_vae()") mean_var_weights = h.sweep("augmented_variance_vae.mean_var_weight", h.discrete([0.0, 0.1, 0.5, 1., 2., 4., 8., 16.])) variance_weights = h.sweep("augmented_variance_vae.variance_weight", h.discrete([0.0, 0.1, 0.5, 1., 2., 4., 8., 16.])) weights_product = h.product([mean_var_weights, variance_weights]) config_balanced_beta_vae = h.zipit([model_name, weights_product, model_fn]) all_models = h.chainit([ config_balanced_beta_vae ]) return all_models
def get_datasets(): """Returns all the data sets.""" return h.sweep( "dataset.name", h.categorical(["dsprites_full" #"dsprites_full", "color_dsprites", "noisy_dsprites", #"scream_dsprites", "smallnorb", "cars3d", "shapes3d" ]))
def get_default_models(): """Our default set of models (6 model * 6 hyperparameters=36 models).""" # BetaVAE config. model_name = h.fixed("model.name", "beta_vae") model_fn = h.fixed("model.model", "@vae()") betas = h.sweep("vae.beta", h.discrete([0., 0.5, 1., 2., 4., 8.])) params_product = h.product([betas]) config_vae = h.zipit([model_name, params_product, model_fn]) all_models = h.chainit([config_vae]) return all_models
def get_default_models(): """Our default set of models (6 model * 6 hyperparameters=36 models).""" # BetaVAE config. model_name = h.fixed("model.name", "beta_vae") model_fn = h.fixed("model.model", "@vae()") betas = h.sweep("vae.beta", h.discrete([1., 2., 4., 6., 8., 16.])) config_beta_vae = h.zipit([model_name, betas, model_fn]) # AnnealedVAE config. model_name = h.fixed("model.name", "annealed_vae") model_fn = h.fixed("model.model", "@annealed_vae()") iteration_threshold = h.fixed("annealed_vae.iteration_threshold", 100000) c = h.sweep("annealed_vae.c_max", h.discrete([5., 10., 25., 50., 75., 100.])) gamma = h.fixed("annealed_vae.gamma", 1000) config_annealed_beta_vae = h.zipit( [model_name, c, iteration_threshold, gamma, model_fn]) # FactorVAE config. model_name = h.fixed("model.name", "factor_vae") model_fn = h.fixed("model.model", "@factor_vae()") discr_fn = h.fixed("discriminator.discriminator_fn", "@fc_discriminator") gammas = h.sweep("factor_vae.gamma", h.discrete([10., 20., 30., 40., 50., 100.])) config_factor_vae = h.zipit([model_name, gammas, model_fn, discr_fn]) # DIP-VAE-I config. model_name = h.fixed("model.name", "dip_vae_i") model_fn = h.fixed("model.model", "@dip_vae()") lambda_od = h.sweep("dip_vae.lambda_od", h.discrete([1., 2., 5., 10., 20., 50.])) lambda_d_factor = h.fixed("dip_vae.lambda_d_factor", 10.) dip_type = h.fixed("dip_vae.dip_type", "i") config_dip_vae_i = h.zipit( [model_name, model_fn, lambda_od, lambda_d_factor, dip_type]) # DIP-VAE-II config. model_name = h.fixed("model.name", "dip_vae_ii") model_fn = h.fixed("model.model", "@dip_vae()") lambda_od = h.sweep("dip_vae.lambda_od", h.discrete([1., 2., 5., 10., 20., 50.])) lambda_d_factor = h.fixed("dip_vae.lambda_d_factor", 1.) dip_type = h.fixed("dip_vae.dip_type", "ii") config_dip_vae_ii = h.zipit( [model_name, model_fn, lambda_od, lambda_d_factor, dip_type]) # BetaTCVAE config. model_name = h.fixed("model.name", "beta_tc_vae") model_fn = h.fixed("model.model", "@beta_tc_vae()") betas = h.sweep("beta_tc_vae.beta", h.discrete([1., 2., 4., 6., 8., 10.])) config_beta_tc_vae = h.zipit([model_name, model_fn, betas]) all_models = h.chainit([ config_beta_vae, config_factor_vae, config_dip_vae_i, config_dip_vae_ii, config_beta_tc_vae, config_annealed_beta_vae ]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "small_vae") model_fn = h.fixed("model.model", "@vae()") beta = h.fixed('vae.beta', self.beta) perc_filters = h.sweep("conv_encoder.perc_units", h.discrete(1 - np.linspace(.1, 1, 6, endpoint=False))) config_vae = h.zipit([ model_name, beta, perc_filters, model_fn, ]) all_models = h.chainit([config_vae, ]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "proximal_vae") model_fn = h.fixed("model.model", "@proximal_vae()") beta = h.fixed('vae.beta', self.beta) all_layers = h.fixed('proximal_vae.all_layers', self.all_layers) lmbds_prox = h.sweep("proximal_vae.lmbd_prox", h.discrete(self.lmbd_prox_range)) config_proximal = h.zipit([ model_name, model_fn, beta, all_layers, lmbds_prox, ]) all_models = h.chainit([config_proximal, ]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "masked_vae") model_fn = h.fixed("model.model", "@vae()") beta = h.fixed('vae.beta', self.beta) perc_sparse = h.sweep("conv_encoder.perc_sparse", h.discrete([ *np.linspace(.1, 1, 6, endpoint=False) ])) all_layers = h.fixed('conv_encoder.all_layers', self.all_layers) config_masked = h.zipit([ model_name, model_fn, beta, perc_sparse, all_layers, ]) all_models = h.chainit([config_masked, ]) return all_models
def get_default_models(self): model_name = h.fixed("model.name", "wae") model_fn = h.fixed("model.model", "@wae()") scale = h.fixed("wae.scale", 1 / 8) adaptive = h.fixed("wae.adaptive", not self.code_norm) code_norm = h.fixed("conv_encoder.code_normalization", self.code_norm) betas = h.sweep("vae.beta", h.discrete([*self._beta_range])) config_vae = h.zipit([ model_name, model_fn, scale, adaptive, code_norm, betas, ]) all_models = h.chainit([config_vae, ]) return all_models
def get_default_models(self): # DimWiseL1 config. model_name = h.fixed("model.name", f"dim_wise_l1_{self.dim}_vae") model_fn = h.fixed("model.model", "@dim_wise_l1_vae()") beta = h.fixed('vae.beta', self.beta) scale_per_layer = h.fixed('dim_wise_l1_vae.scale_per_layer', self.scale_per_layer) lmbds_l1 = h.sweep("dim_wise_l1_vae.lmbd_l1", h.discrete([ *np.logspace(-5, -3, 8) ])) dim = h.fixed('dim_wise_l1_vae.dim', self.dim) all_layers = h.fixed('dim_wise_l1_vae.all_layers', self.all_layers) config_dim_wise_l1 = h.zipit([ model_name, model_fn, beta, scale_per_layer, lmbds_l1, dim, all_layers, ]) all_models = h.chainit([config_dim_wise_l1, ]) return all_models
def main(): sweep = h.product(( h.sweep('dataset', DATASETS), h.sweep('method', METHODS), h.sweep( 'beta', ( # 1, # 4, # 8, 16, # 32, )), h.sweep( 'all_layers', ( True, # False, )), h.sweep( 'scale', ( True, # False, )), h.sweep('anneal', ( True, False, )), )) df_list = [] model_names = set() for setting in sweep: dataset, method, beta, all_layers, scale, anneal = setting['dataset'], setting['method'], setting['beta'], \ setting[ 'all_layers'], setting['scale'], setting['anneal'] if 'masked' in method or 'small' in method or 'weight_decay' in method or 'proximal' in method or 'wae' in method: scale = False out_dir = PLOT_DIR / (method + ('_anneal' if anneal else '') + ('_all' if all_layers else '') + ('_scale' if scale else '')) / f'beta_{beta}' df = load_results() if 'dim_wise_mask_l1' in method: dim_wise_df = df.loc[df[MODEL_COL_STR].str.contains( 'dim_wise_mask_l1')] dim_wise_df[MODEL_COL_STR] = dim_wise_df.apply( lambda row: row[MODEL_COL_STR].replace( 'l1', 'l1_' + row['train_config.dim_wise_l1_vae.dim']. replace("'", '')), axis=1, ) df.loc[df[MODEL_COL_STR].str.contains( 'dim_wise_mask_l1')] = dim_wise_df df = df.loc[df[MODEL_COL_STR].str.contains(method)] if 'dim_wise_mask_l1' in method: if not ('row' in method or 'col' in method): # non dim wise l1 df = df.loc[df['train_config.dim_wise_l1_vae.dim'] == 'None'] idxs_all_layers = ( df['train_config.dim_wise_l1_vae.all_layers'] == 'True') | (df['train_config.conv_encoder.all_layers'] == 'True') df = df.loc[idxs_all_layers] if all_layers else df.loc[~idxs_all_layers] idxs_scale = (df[get_scale_col_name(method)] == 'True') df = df.loc[idxs_scale] if scale else df.loc[~idxs_scale] idxs_anneal = (~df['train_config.vd_vae.anneal_kld_for'].isin( ('None', None))) df = df.loc[idxs_anneal] if anneal else df.loc[~idxs_anneal] print(dataset, out_dir.parts[1:]) print(len(df)) if len(df) < 1: continue if 'dim_wise' in method: # TODO nicer way of mapping reg. strengths df[MODEL_COL_STR] = df[MODEL_COL_STR] + '_' + df[ 'train_config.dim_wise_l1_vae.lmbd_l1'].map("{:.2e}".format) df[MODEL_COL_STR] = df[MODEL_COL_STR].str.replace( 'dim_wise_mask_l1_', '') df[MODEL_COL_STR] = df[MODEL_COL_STR].str.replace('_vae', '') # df = df.loc[df['train_config.dim_wise_l1_vae.lmbd_l1'].between(1e-10, 1e0)] df = df.loc[df['train_config.dim_wise_l1_vae.lmbd_l1'].isin(( # 1e-10, # 3.1622776601683795e-10, # 1e-09, # 3.1622776601683795e-09, # 1e-08, # 3.162277660168379e-08, # 1e-07, # 4.641588833612782e-07, 1e-06, # 3.162277660168379e-06, 1e-05, # 3.727593720314938e-05, 0.0001, # 0.00031622776601683794, 0.001, # 0.0031622776601683794, 0.01, # 0.03162277660168379, 0.1, # 0.31622776601683794, # 1.0, ))] reg_weight_col = 'train_config.dim_wise_l1_vae.lmbd_l1' elif method == 'masked': df[MODEL_COL_STR] = df[MODEL_COL_STR] + '_' + df[ 'train_config.conv_encoder.perc_sparse'].map( lambda x: round(float(x), 2)).map(str) reg_weight_col = 'train_config.conv_encoder.perc_sparse' df[reg_weight_col] = pd.to_numeric(df[reg_weight_col]) # TODO use get_reg_col_name() fn here elif 'vd' in method: reg_weight_col = 'train_config.vd_vae.lmbd_kld_vd' elif 'proximal' in method: reg_weight_col = 'train_config.proximal_vae.lmbd_prox' elif 'softmax' in method: reg_weight_col = 'train_config.conv_encoder.softmax_temperature' elif 'wae' in method: reg_weight_col = 'train_config.vae.beta' new_reg_weight_col = reg_weight_col.replace('vae', 'wae') df[new_reg_weight_col] = df[reg_weight_col] df[reg_weight_col] = beta reg_weight_col = new_reg_weight_col # ablation test methods elif 'weight_decay' in method: reg_weight_col = 'train_config.dim_wise_l1_vae.lmbd_l2' elif 'small_vae' in method: reg_weight_col = 'train_config.conv_encoder.perc_units' if dataset == 'shapes3d': dlib_df = load_results() dlib_df = dlib_df.loc[dlib_df[MODEL_COL_STR] == "'beta_vae'"] else: dlib_df = load_dlib_df() model_name = out_dir.parent.name df[MODEL_COL_STR] = model_name model_names.add(model_name) dlib_df[reg_weight_col] = 0 df = pd.concat((df, dlib_df), sort=True) df = df.loc[(df['train_config.vae.beta'] == beta) & (df[DATASET_COL_STR] == f"'{dataset}'")] if len(df[MODEL_COL_STR].unique()) < 2: continue df[MODEL_COL_STR] = df[MODEL_COL_STR].str.replace("'", '') # out_dir.mkdir(exist_ok=True, parents=True) # plot_results( # df=df, # dataset=dataset, # out_dir=out_dir, # reg_weight_col=reg_weight_col, # ) df = df.loc[df[reg_weight_col] != 0] df_list.append(df) df = pd.concat(df_list) shapes_baseline = load_results() shapes_baseline = shapes_baseline.loc[ (shapes_baseline[DATASET_COL_STR].str.contains('shapes3d')) & (shapes_baseline[MODEL_COL_STR].str.contains('beta_vae'))] df = pd.concat((df, load_dlib_df(), shapes_baseline)) df = df.loc[df['train_config.vae.beta'] == 16] top_k_groups = None # plot_fig_15(df, methods=model_names, top_k_groups=top_k_groups) # plot_fig_16(df, methods=METHODS[:3] + ('beta_vae',)) # plot_fig_16(df, methods=[*model_names, 'beta_vae'], top_k_groups=top_k_groups) # plot_fig_16(df, methods=model_names, top_k_groups=top_k_groups, diff_over_baseline=True) # plot_fig_17(df, methods=METHODS[:3] + ('beta_vae',)) # plot_fig_17(df, methods=[*model_names, 'beta_vae'], top_k_groups=top_k_groups) plot_fig_17(df, methods=model_names, top_k_groups=top_k_groups, diff_over_baseline=True)
def get_seeds(num): """Returns random seeds.""" return h.sweep("model.random_seed", h.categorical(list(range(num))))
def get_num_latent(sweep): return h.sweep("encoder.num_latent", h.discrete(sweep))
def get_datasets(): """Returns all the data sets.""" return h.sweep("dataset.name", h.categorical(["shapes3d", "abstract_dsprites"]))
"""Different studies that can be reproduced.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from disentanglement_lib.config.sparsity_study import sweep as sparsity_study from disentanglement_lib.config.abstract_reasoning_study_v1.stage1 import sweep as abstract_reasoning_study_v1 from disentanglement_lib.config.fairness_study_v1 import sweep as fairness_study_v1 from disentanglement_lib.config.tests import sweep as tests from disentanglement_lib.config.unsupervised_study_v1 import sweep as unsupervised_study_v1 import disentanglement_lib.utils.hyperparams as h _betas = h.sweep('beta', (1, 2, 4, 6, 8, 16, 32, 64)) _datasets = h.sweep('dataset', ( "dsprites_full", "color_dsprites", "noisy_dsprites", "scream_dsprites", "smallnorb", "cars3d", "shapes3d", )) _all_layers = h.sweep('all_layers', (True, False)) _scale_per_layer = h.sweep('scale_per_layer', (True, False)) _dims = h.sweep('dim', ('col', 'row')) _sweep_dim_wise = h.product((_betas, _datasets, _all_layers, _scale_per_layer, _dims)) _dim_wise_studies = {
def get_datasets(): """Returns all the data sets.""" return h.sweep( "dataset.name", h.categorical([ "mpi3d_toy"]))