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