src/cocktails/representation_learning/run.py

import torch; torch.manual_seed(0)
import torch.utils
from torch.utils.data import DataLoader
import torch.distributions
import torch.nn as nn
import matplotlib.pyplot as plt; plt.rcParams['figure.dpi'] = 200
from src.cocktails.representation_learning.dataset import MyDataset, get_representation_from_ingredient, get_max_n_ingredients
import json
import pandas as pd
import numpy as np
import os
from src.cocktails.representation_learning.vae_model import get_vae_model
from src.cocktails.config import COCKTAILS_CSV_DATA, FULL_COCKTAIL_REP_PATH, EXPERIMENT_PATH
from src.cocktails.utilities.cocktail_utilities import get_bunch_of_rep_keys
from src.cocktails.utilities.ingredients_utilities import ingredient_profiles
from resource import getrusage
from resource import RUSAGE_SELF
import gc
gc.collect(2)
device = 'cuda' if torch.cuda.is_available() else 'cpu'

def get_params():
    data = pd.read_csv(COCKTAILS_CSV_DATA)
    max_ingredients, ingredient_set, liquor_set, liqueur_set = get_max_n_ingredients(data)
    num_ingredients = len(ingredient_set)
    rep_keys = get_bunch_of_rep_keys()['custom']
    ing_keys = [k.split(' ')[1] for k in rep_keys]
    ing_keys.remove('volume')
    nb_ing_categories = len(set(ingredient_profiles['type']))
    category_encodings = dict(zip(sorted(set(ingredient_profiles['type'])), np.eye(nb_ing_categories)))

    params = dict(trial_id='test',
                  save_path=EXPERIMENT_PATH + "/deepset_vae/",
                  nb_epochs=2000,
                  print_every=50,
                  plot_every=100,
                  batch_size=64,
                  lr=0.001,
                  dropout=0.,
                  nb_epoch_switch_beta=600,
                  latent_dim=10,
                  beta_vae=0.2,
                  ing_keys=ing_keys,
                  nb_ingredients=len(ingredient_set),
                  hidden_dims_ingredients=[128],
                  hidden_dims_cocktail=[32],
                  hidden_dims_decoder=[32],
                  agg='mean',
                  activation='relu',
                  auxiliaries_dict=dict(categories=dict(weight=0, type='classif', final_activ=None, dim_output=len(set(data['subcategory']))),
                                        glasses=dict(weight=0, type='classif', final_activ=None, dim_output=len(set(data['glass']))),
                                        prep_type=dict(weight=0, type='classif', final_activ=None, dim_output=len(set(data['category']))),
                                        cocktail_reps=dict(weight=0, type='regression', final_activ=None, dim_output=13),
                                        volume=dict(weight=0, type='regression', final_activ='relu',  dim_output=1),
                                        taste_reps=dict(weight=0, type='regression', final_activ='relu', dim_output=2),
                                        ingredients_presence=dict(weight=0, type='multiclassif', final_activ=None, dim_output=num_ingredients)),
                  category_encodings=category_encodings
                  )
    # params = dict(trial_id='test',
    #               save_path=EXPERIMENT_PATH + "/deepset_vae/",
    #               nb_epochs=1000,
    #               print_every=50,
    #               plot_every=100,
    #               batch_size=64,
    #               lr=0.001,
    #               dropout=0.,
    #               nb_epoch_switch_beta=500,
    #               latent_dim=64,
    #               beta_vae=0.3,
    #               ing_keys=ing_keys,
    #               nb_ingredients=len(ingredient_set),
    #               hidden_dims_ingredients=[128],
    #               hidden_dims_cocktail=[128, 128],
    #               hidden_dims_decoder=[128, 128],
    #               agg='mean',
    #               activation='mish',
    #               auxiliaries_dict=dict(categories=dict(weight=0.5, type='classif', final_activ=None, dim_output=len(set(data['subcategory']))),
    #                                     glasses=dict(weight=0.03, type='classif', final_activ=None, dim_output=len(set(data['glass']))),
    #                                     prep_type=dict(weight=0.02, type='classif', final_activ=None, dim_output=len(set(data['category']))),
    #                                     cocktail_reps=dict(weight=1, type='regression', final_activ=None, dim_output=13),
    #                                     volume=dict(weight=1, type='regression', final_activ='relu',  dim_output=1),
    #                                     taste_reps=dict(weight=1, type='regression', final_activ='relu', dim_output=2),
    #                                     ingredients_presence=dict(weight=1.5, type='multiclassif', final_activ=None, dim_output=num_ingredients)),
    #               category_encodings=category_encodings
    #               )
    water_rep, indexes_to_normalize = get_representation_from_ingredient(ingredients=['water'], quantities=[1],
                                                                         max_q_per_ing=dict(zip(ingredient_set, [1] * num_ingredients)), index=0,
                                                                         params=params)
    dim_rep_ingredient = water_rep.size
    params['indexes_ing_to_normalize'] = indexes_to_normalize
    params['deepset_latent_dim'] = dim_rep_ingredient * max_ingredients
    params['input_dim'] = dim_rep_ingredient
    params['dim_rep_ingredient'] = dim_rep_ingredient
    params = compute_expe_name_and_save_path(params)
    del params['category_encodings']  # to dump
    with open(params['save_path'] + 'params.json', 'w') as f:
        json.dump(params, f)

    params = complete_params(params)
    return params

def complete_params(params):
    data = pd.read_csv(COCKTAILS_CSV_DATA)
    cocktail_reps = np.loadtxt(FULL_COCKTAIL_REP_PATH)
    nb_ing_categories = len(set(ingredient_profiles['type']))
    category_encodings = dict(zip(sorted(set(ingredient_profiles['type'])), np.eye(nb_ing_categories)))
    params['cocktail_reps'] = cocktail_reps
    params['raw_data'] = data
    params['category_encodings'] = category_encodings
    return params

def compute_losses_and_accuracies(loss_functions, auxiliaries, auxiliaries_str, outputs, data):
    losses = dict()
    accuracies = dict()
    other_metrics = dict()
    for i_k, k in enumerate(auxiliaries_str):
        # get ground truth
        # compute loss
        if k == 'volume':
            outputs[i_k] = outputs[i_k].flatten()
        ground_truth = auxiliaries[k]
        if ground_truth.dtype == torch.float64:
            losses[k] = loss_functions[k](outputs[i_k], ground_truth.float()).float()
        elif ground_truth.dtype == torch.int64:
            if str(loss_functions[k]) != "BCEWithLogitsLoss()":
                losses[k] = loss_functions[k](outputs[i_k].float(), ground_truth.long()).float()
            else:
                losses[k] = loss_functions[k](outputs[i_k].float(), ground_truth.float()).float()
        else:
            losses[k] = loss_functions[k](outputs[i_k], ground_truth).float()
        # compute accuracies
        if str(loss_functions[k]) == 'CrossEntropyLoss()':
            bs, n_options = outputs[i_k].shape
            predicted = outputs[i_k].argmax(dim=1).detach().numpy()
            true = ground_truth.int().detach().numpy()
            confusion_matrix = np.zeros([n_options, n_options])
            for i in range(bs):
                confusion_matrix[true[i], predicted[i]] += 1
            acc = confusion_matrix.diagonal().sum() / bs
            for i in range(n_options):
                if confusion_matrix[i].sum() != 0:
                    confusion_matrix[i] /= confusion_matrix[i].sum()
            other_metrics[k + '_confusion'] = confusion_matrix
            accuracies[k] = np.mean(outputs[i_k].argmax(dim=1).detach().numpy() == ground_truth.int().detach().numpy())
            assert (acc - accuracies[k]) < 1e-5

        elif str(loss_functions[k]) == 'BCEWithLogitsLoss()':
            assert k == 'ingredients_presence'
            outputs_rescaled = outputs[i_k].detach().numpy() * data.dataset.std_ing_quantities + data.dataset.mean_ing_quantities
            predicted_presence = (outputs_rescaled > 0).astype(bool)
            presence = ground_truth.detach().numpy().astype(bool)
            other_metrics[k + '_false_positive'] = np.mean(np.logical_and(predicted_presence.astype(bool), ~presence.astype(bool)))
            other_metrics[k + '_false_negative'] = np.mean(np.logical_and(~predicted_presence.astype(bool), presence.astype(bool)))
            accuracies[k] = np.mean(predicted_presence == presence)  # accuracy for multi class labeling
        elif str(loss_functions[k]) == 'MSELoss()':
            accuracies[k] = np.nan
        else:
            raise ValueError
    return losses, accuracies, other_metrics

def compute_metric_output(aux_other_metrics, data, ingredient_quantities, x_hat):
    ing_q = ingredient_quantities.detach().numpy() * data.dataset.std_ing_quantities + data.dataset.mean_ing_quantities
    ing_presence = (ing_q > 0)
    x_hat = x_hat.detach().numpy() * data.dataset.std_ing_quantities + data.dataset.mean_ing_quantities
    # abs_diff = np.abs(ing_q - x_hat) * data.dataset.max_ing_quantities
    abs_diff = np.abs(ing_q - x_hat)
    ing_q_abs_loss_when_present, ing_q_abs_loss_when_absent = [], []
    for i in range(ingredient_quantities.shape[0]):
        ing_q_abs_loss_when_present.append(np.mean(abs_diff[i, np.where(ing_presence[i])]))
        ing_q_abs_loss_when_absent.append(np.mean(abs_diff[i, np.where(~ing_presence[i])]))
    aux_other_metrics['ing_q_abs_loss_when_present'] = np.mean(ing_q_abs_loss_when_present)
    aux_other_metrics['ing_q_abs_loss_when_absent'] = np.mean(ing_q_abs_loss_when_absent)
    return aux_other_metrics

def run_epoch(opt, train, model, data, loss_functions, weights, params):
    if train:
        model.train()
    else:
        model.eval()

    # prepare logging of losses
    losses = dict(kld_loss=[],
                  mse_loss=[],
                  vae_loss=[],
                  volume_loss=[],
                  global_loss=[])
    accuracies = dict()
    other_metrics = dict()
    for aux in params['auxiliaries_dict'].keys():
        losses[aux] = []
        accuracies[aux] = []
    if train: opt.zero_grad()

    for d in data:
        nb_ingredients = d[0]
        batch_size = nb_ingredients.shape[0]
        x_ingredients = d[1].float()
        ingredient_quantities = d[2]
        cocktail_reps = d[3]
        auxiliaries = d[4]
        for k in auxiliaries.keys():
            if auxiliaries[k].dtype == torch.float64: auxiliaries[k] = auxiliaries[k].float()
        taste_valid = d[-1]
        x = x_ingredients.to(device)
        x_hat, z, mean, log_var, outputs, auxiliaries_str = model.forward_direct(ingredient_quantities.float())
        # get auxiliary losses and accuracies
        aux_losses, aux_accuracies, aux_other_metrics = compute_losses_and_accuracies(loss_functions, auxiliaries, auxiliaries_str, outputs, data)

        # compute vae loss
        mse_loss = ((ingredient_quantities - x_hat) ** 2).mean().float()
        kld_loss = torch.mean(-0.5 * torch.sum(1 + log_var - mean ** 2 - log_var.exp(), dim=1)).float()
        vae_loss = mse_loss + params['beta_vae'] * (params['latent_dim'] / params['nb_ingredients']) * kld_loss
        # compute total volume loss to train decoder
        # volume_loss = ((ingredient_quantities.sum(dim=1) - x_hat.sum(dim=1)) ** 2).mean().float()
        volume_loss = torch.FloatTensor([0])

        aux_other_metrics = compute_metric_output(aux_other_metrics, data, ingredient_quantities, x_hat)

        indexes_taste_valid = np.argwhere(taste_valid.detach().numpy()).flatten()
        if indexes_taste_valid.size > 0:
            outputs_taste = model.get_auxiliary(z[indexes_taste_valid], aux_str='taste_reps')
            gt = auxiliaries['taste_reps'][indexes_taste_valid]
            factor_loss = indexes_taste_valid.size / (0.3 * batch_size)# factor on the loss: if same ratio as actual dataset factor = 1 if there is less data, then the factor decreases, more data, it increases
            aux_losses['taste_reps'] = (loss_functions['taste_reps'](outputs_taste, gt) * factor_loss).float()
        else:
            aux_losses['taste_reps'] = torch.FloatTensor([0]).reshape([])
        aux_accuracies['taste_reps'] = 0

        # aggregate losses
        global_loss = torch.sum(torch.cat([torch.atleast_1d(vae_loss), torch.atleast_1d(volume_loss)] + [torch.atleast_1d(aux_losses[k] * weights[k]) for k in params['auxiliaries_dict'].keys()]))
        # for k in params['auxiliaries_dict'].keys():
        #     global_loss += aux_losses[k] * weights[k]

        if train:
            global_loss.backward()
            opt.step()
            opt.zero_grad()

        # logging
        losses['global_loss'].append(float(global_loss))
        losses['mse_loss'].append(float(mse_loss))
        losses['vae_loss'].append(float(vae_loss))
        losses['volume_loss'].append(float(volume_loss))
        losses['kld_loss'].append(float(kld_loss))
        for k in params['auxiliaries_dict'].keys():
            losses[k].append(float(aux_losses[k]))
            accuracies[k].append(float(aux_accuracies[k]))
        for k in aux_other_metrics.keys():
            if k not in other_metrics.keys():
                other_metrics[k] = [aux_other_metrics[k]]
            else:
                other_metrics[k].append(aux_other_metrics[k])

    for k in losses.keys():
        losses[k] = np.mean(losses[k])
    for k in accuracies.keys():
        accuracies[k] = np.mean(accuracies[k])
    for k in other_metrics.keys():
        other_metrics[k] = np.mean(other_metrics[k], axis=0)
    return model, losses, accuracies, other_metrics

def prepare_data_and_loss(params):
    train_data = MyDataset(split='train', params=params)
    test_data = MyDataset(split='test', params=params)

    train_data_loader = DataLoader(train_data, batch_size=params['batch_size'], shuffle=True)
    test_data_loader = DataLoader(test_data, batch_size=params['batch_size'], shuffle=True)

    loss_functions = dict()
    weights = dict()
    for k in sorted(params['auxiliaries_dict'].keys()):
        if params['auxiliaries_dict'][k]['type'] == 'classif':
            if k == 'glasses':
                classif_weights = train_data.glasses_weights
            elif k == 'prep_type':
                classif_weights = train_data.prep_types_weights
            elif k == 'categories':
                classif_weights = train_data.categories_weights
            else:
                raise ValueError
            loss_functions[k] = nn.CrossEntropyLoss(torch.FloatTensor(classif_weights))
        elif params['auxiliaries_dict'][k]['type'] == 'multiclassif':
            loss_functions[k] = nn.BCEWithLogitsLoss()
        elif params['auxiliaries_dict'][k]['type'] == 'regression':
            loss_functions[k] = nn.MSELoss()
        else:
            raise ValueError
        weights[k] = params['auxiliaries_dict'][k]['weight']


    return loss_functions, train_data_loader, test_data_loader, weights

def print_losses(train, losses, accuracies, other_metrics):
    keyword = 'Train' if train else 'Eval'
    print(f'\t{keyword} logs:')
    keys = ['global_loss', 'vae_loss', 'mse_loss', 'kld_loss', 'volume_loss']
    for k in keys:
        print(f'\t\t{k} - Loss: {losses[k]:.2f}')
    for k in sorted(accuracies.keys()):
        print(f'\t\t{k} (aux) - Loss: {losses[k]:.2f}, Acc: {accuracies[k]:.2f}')
    for k in sorted(other_metrics.keys()):
        if 'confusion' not in k:
            print(f'\t\t{k} - {other_metrics[k]:.2f}')


def run_experiment(params, verbose=True):
    loss_functions, train_data_loader, test_data_loader, weights = prepare_data_and_loss(params)
    params['filter_decoder_output'] = train_data_loader.dataset.filter_decoder_output

    model_params = [params[k] for k in ["input_dim", "deepset_latent_dim", "hidden_dims_ingredients", "activation",
                               "hidden_dims_cocktail", "hidden_dims_decoder", "nb_ingredients", "latent_dim", "agg", "dropout", "auxiliaries_dict",
                                        "filter_decoder_output"]]
    model = get_vae_model(*model_params)
    opt = torch.optim.AdamW(model.parameters(), lr=params['lr'])


    all_train_losses = []
    all_eval_losses = []
    all_train_accuracies = []
    all_eval_accuracies = []
    all_eval_other_metrics = []
    all_train_other_metrics = []
    best_loss = np.inf
    model, eval_losses, eval_accuracies, eval_other_metrics = run_epoch(opt=opt, train=False, model=model, data=test_data_loader, loss_functions=loss_functions,
                                                                        weights=weights, params=params)
    all_eval_losses.append(eval_losses)
    all_eval_accuracies.append(eval_accuracies)
    all_eval_other_metrics.append(eval_other_metrics)
    if verbose: print(f'\n--------\nEpoch #0')
    if verbose: print_losses(train=False, accuracies=eval_accuracies, losses=eval_losses, other_metrics=eval_other_metrics)
    for epoch in range(params['nb_epochs']):
        if verbose and (epoch + 1) % params['print_every'] == 0: print(f'\n--------\nEpoch #{epoch+1}')
        model, train_losses, train_accuracies, train_other_metrics = run_epoch(opt=opt, train=True, model=model, data=train_data_loader, loss_functions=loss_functions,
                                                                            weights=weights, params=params)
        if verbose and (epoch + 1) % params['print_every'] == 0: print_losses(train=True, accuracies=train_accuracies, losses=train_losses, other_metrics=train_other_metrics)
        model, eval_losses, eval_accuracies, eval_other_metrics = run_epoch(opt=opt, train=False, model=model, data=test_data_loader, loss_functions=loss_functions,
                                                                            weights=weights, params=params)
        if verbose and (epoch + 1) % params['print_every'] == 0: print_losses(train=False, accuracies=eval_accuracies, losses=eval_losses, other_metrics=eval_other_metrics)
        if eval_losses['global_loss'] < best_loss:
            best_loss = eval_losses['global_loss']
            if verbose: print(f'Saving new best model with loss {best_loss:.2f}')
            torch.save(model.state_dict(), params['save_path'] + f'checkpoint_best.save')

        # log
        all_train_losses.append(train_losses)
        all_train_accuracies.append(train_accuracies)
        all_eval_losses.append(eval_losses)
        all_eval_accuracies.append(eval_accuracies)
        all_eval_other_metrics.append(eval_other_metrics)
        all_train_other_metrics.append(train_other_metrics)

        # if epoch == params['nb_epoch_switch_beta']:
        #     params['beta_vae'] = 2.5
            # params['auxiliaries_dict']['prep_type']['weight'] /= 10
            # params['auxiliaries_dict']['glasses']['weight'] /= 10

        if (epoch + 1) % params['plot_every'] == 0:

            plot_results(all_train_losses, all_train_accuracies, all_train_other_metrics,
                         all_eval_losses, all_eval_accuracies, all_eval_other_metrics, params['plot_path'], weights)

    return model

def plot_results(all_train_losses, all_train_accuracies, all_train_other_metrics,
                 all_eval_losses, all_eval_accuracies, all_eval_other_metrics, plot_path, weights):

    steps = np.arange(len(all_eval_accuracies))

    loss_keys = sorted(all_train_losses[0].keys())
    acc_keys = sorted(all_train_accuracies[0].keys())
    metrics_keys = sorted(all_train_other_metrics[0].keys())

    plt.figure()
    plt.title('Train losses')
    for k in loss_keys:
        factor = 1 if k == 'mse_loss' else 1
        if k not in weights.keys():
            plt.plot(steps[1:], [train_loss[k] * factor for train_loss in all_train_losses], label=k)
        else:
            if weights[k] != 0:
                plt.plot(steps[1:], [train_loss[k] * factor for train_loss in all_train_losses], label=k)

    plt.legend()
    plt.ylim([0, 4])
    plt.savefig(plot_path + 'train_losses.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Train accuracies')
    for k in acc_keys:
        if weights[k] != 0:
            plt.plot(steps[1:], [train_acc[k] for train_acc in all_train_accuracies], label=k)
    plt.legend()
    plt.ylim([0, 1])
    plt.savefig(plot_path + 'train_acc.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Train other metrics')
    for k in metrics_keys:
        if 'confusion' not in k and 'presence' in k:
            plt.plot(steps[1:], [train_metric[k] for train_metric in all_train_other_metrics], label=k)
    plt.legend()
    plt.ylim([0, 1])
    plt.savefig(plot_path + 'train_ing_presence_errors.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Train other metrics')
    for k in metrics_keys:
        if 'confusion' not in k and 'presence' not in k:
            plt.plot(steps[1:], [train_metric[k] for train_metric in all_train_other_metrics], label=k)
    plt.legend()
    plt.savefig(plot_path + 'train_ing_q_error.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Eval losses')
    for k in loss_keys:
        factor = 1 if k == 'mse_loss' else 1
        if k not in weights.keys():
            plt.plot(steps, [eval_loss[k] * factor for eval_loss in all_eval_losses], label=k)
        else:
            if weights[k] != 0:
                plt.plot(steps, [eval_loss[k] * factor for eval_loss in all_eval_losses], label=k)
    plt.legend()
    plt.ylim([0, 4])
    plt.savefig(plot_path + 'eval_losses.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Eval accuracies')
    for k in acc_keys:
        if weights[k] != 0:
            plt.plot(steps, [eval_acc[k] for eval_acc in all_eval_accuracies], label=k)
    plt.legend()
    plt.ylim([0, 1])
    plt.savefig(plot_path + 'eval_acc.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Eval other metrics')
    for k in metrics_keys:
        if 'confusion' not in k and 'presence' in k:
            plt.plot(steps, [eval_metric[k] for eval_metric in all_eval_other_metrics], label=k)
    plt.legend()
    plt.ylim([0, 1])
    plt.savefig(plot_path + 'eval_ing_presence_errors.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)

    plt.figure()
    plt.title('Eval other metrics')
    for k in metrics_keys:
        if 'confusion' not in k and 'presence' not in k:
            plt.plot(steps, [eval_metric[k] for eval_metric in all_eval_other_metrics], label=k)
    plt.legend()
    plt.savefig(plot_path + 'eval_ing_q_error.png', dpi=200)
    fig = plt.gcf()
    plt.close(fig)


    for k in metrics_keys:
        if 'confusion' in k:
            plt.figure()
            plt.title(k)
            plt.ylabel('True')
            plt.xlabel('Predicted')
            plt.imshow(all_eval_other_metrics[-1][k], vmin=0, vmax=1)
            plt.colorbar()
            plt.savefig(plot_path + f'eval_{k}.png', dpi=200)
            fig = plt.gcf()
            plt.close(fig)

    for k in metrics_keys:
        if 'confusion' in k:
            plt.figure()
            plt.title(k)
            plt.ylabel('True')
            plt.xlabel('Predicted')
            plt.imshow(all_train_other_metrics[-1][k], vmin=0, vmax=1)
            plt.colorbar()
            plt.savefig(plot_path + f'train_{k}.png', dpi=200)
            fig = plt.gcf()
            plt.close(fig)

    plt.close('all')


def get_model(model_path):

    with open(model_path + 'params.json', 'r') as f:
        params = json.load(f)
    params['save_path'] = model_path
    max_ing_quantities = np.loadtxt(params['save_path'] + 'max_ing_quantities.txt')
    mean_ing_quantities = np.loadtxt(params['save_path'] + 'mean_ing_quantities.txt')
    std_ing_quantities = np.loadtxt(params['save_path'] + 'std_ing_quantities.txt')
    min_when_present_ing_quantities = np.loadtxt(params['save_path'] + 'min_when_present_ing_quantities.txt')
    def filter_decoder_output(output):
        output = output.detach().numpy()
        output_unnormalized = output * std_ing_quantities + mean_ing_quantities
        if output.ndim == 1:
            output_unnormalized[np.where(output_unnormalized < min_when_present_ing_quantities)] = 0
        else:
            for i in range(output.shape[0]):
                output_unnormalized[i, np.where(output_unnormalized[i] < min_when_present_ing_quantities)] = 0
        return output_unnormalized.copy()
    params['filter_decoder_output'] = filter_decoder_output
    model_chkpt = model_path + "checkpoint_best.save"
    model_params = [params[k] for k in ["input_dim", "deepset_latent_dim", "hidden_dims_ingredients", "activation",
                                        "hidden_dims_cocktail", "hidden_dims_decoder", "nb_ingredients", "latent_dim", "agg", "dropout", "auxiliaries_dict",
                                        "filter_decoder_output"]]
    model = get_vae_model(*model_params)
    model.load_state_dict(torch.load(model_chkpt))
    model.eval()
    return model, filter_decoder_output, params


def compute_expe_name_and_save_path(params):
    weights_str = '['
    for aux in params['auxiliaries_dict'].keys():
        weights_str += f'{params["auxiliaries_dict"][aux]["weight"]}, '
    weights_str = weights_str[:-2] + ']'
    save_path = params['save_path'] + params["trial_id"]
    save_path += f'_lr{params["lr"]}'
    save_path += f'_betavae{params["beta_vae"]}'
    save_path += f'_bs{params["batch_size"]}'
    save_path += f'_latentdim{params["latent_dim"]}'
    save_path += f'_hding{params["hidden_dims_ingredients"]}'
    save_path += f'_hdcocktail{params["hidden_dims_cocktail"]}'
    save_path += f'_hddecoder{params["hidden_dims_decoder"]}'
    save_path += f'_agg{params["agg"]}'
    save_path += f'_activ{params["activation"]}'
    save_path += f'_w{weights_str}'
    counter = 0
    while os.path.exists(save_path + f"_{counter}"):
        counter += 1
    save_path = save_path + f"_{counter}" + '/'
    params["save_path"] = save_path
    os.makedirs(save_path)
    os.makedirs(save_path + 'plots/')
    params['plot_path'] = save_path + 'plots/'
    print(f'logging to {save_path}')
    return params



if __name__ == '__main__':
    params = get_params()
    run_experiment(params)