Delete src

src/cocktails/config.py

@@ -1,21 +0,0 @@
-import os
-
-REPO_PATH = '/'.join(os.path.abspath(__file__).split('/')[:-3]) + '/'
-
-# QUADRUPLETS_PATH = REPO_PATH + 'checkpoints/cocktail_representation/quadruplets.pickle'
-INGREDIENTS_LIST_PATH = REPO_PATH + 'checkpoints/cocktail_representation/ingredient_list.csv'
-# ING_MATCH_SCORE_Q_PATH = REPO_PATH + 'checkpoints/cocktail_representation/ingredient_match_score_q.txt'
-# ING_MATCH_SCORE_COUNT_PATH = REPO_PATH + 'checkpoints/cocktail_representation/ingredient_match_score_count.txt'
-# COCKTAIL_DATA_FOLDER_PATH = REPO_PATH + 'checkpoints/cocktail_representation/'
-COCKTAILS_CSV_DATA = REPO_PATH + 'checkpoints/cocktail_representation/cocktails_data.csv'
-# COCKTAILS_PKL_DATA = REPO_PATH + 'checkpoints/cocktail_representation/cocktails_data.pkl'
-# COCKTAILS_URL_DATA = REPO_PATH + 'checkpoints/cocktail_representation/cocktails_names_urls.pkl'
-EXPERIMENT_PATH = REPO_PATH + 'experiments/cocktails/representation_learning/'
-# ANALYSIS_PATH = REPO_PATH + 'experiments/cocktails/representation_analysis/'
-# REPRESENTATIONS_PATH = REPO_PATH + 'experiments/cocktails/learned_representations/'
-
-FULL_COCKTAIL_REP_PATH = REPO_PATH + "/checkpoints/cocktail_representation/handcoded_reps/cocktail_handcoded_reps_minmax_norm-1_1_dim13_customkeys.txt"
-RECIPE2FEATURES_PATH = REPO_PATH + "/checkpoints/cocktail_representation/"  # get this by running run_without_vae
-COCKTAIL_REP_CHKPT_PATH = REPO_PATH + "/checkpoints/cocktail_representation/handcoded_reps/"
-# FULL_COCKTAIL_REP_PATH = REPO_PATH + "experiments/cocktails/representation_analysis/affective_mapping/clustered_representations/all_cocktail_reps_norm-1_1_custom_keys_dim13.txt'
-COCKTAIL_NN_PATH = REPO_PATH + "/checkpoints/cocktail_representation/handcoded_reps/nn_model.pickle"

src/cocktails/pipeline/cocktail2affect.py

@@ -1,372 +0,0 @@
-import pandas as pd
-import numpy as np
-import os
-from src.cocktails.utilities.cocktail_utilities import get_bunch_of_rep_keys
-from src.cocktails.utilities.other_scrubbing_utilities import print_recipe
-from src.cocktails.config import COCKTAILS_CSV_DATA
-from src.music.config import CHECKPOINTS_PATH, EXPERIMENT_PATH
-import matplotlib.pyplot as plt
-from sklearn.cluster import KMeans
-from sklearn.mixture import GaussianMixture
-from sklearn.neighbors import NearestNeighbors
-import pickle
-import random
-
-experiment_path = EXPERIMENT_PATH + '/cocktails/representation_analysis/affective_mapping/'
-min_max_path = CHECKPOINTS_PATH + "/cocktail_representation/minmax/"
-cluster_model_path = CHECKPOINTS_PATH + "/music2cocktails/affects2affect_cluster/cluster_model.pickle"
-affective_space_dimensions = ((-1, 1), (-1, 1), (-1, 1))  # valence, arousal, dominance
-n_splits = (3, 3, 2)  # number of bins per dimension
-# dimensions_weights = [1, 1, 0.5]
-dimensions_weights = [1, 1, 1]
-total_n_clusters = np.prod(n_splits)  # total number of bins
-affective_boundaries = [np.arange(asd[0], asd[1]+1e-6, (asd[1] - asd[0]) / n_split) for asd, n_split in zip(affective_space_dimensions, n_splits)]
-for af in affective_boundaries:
-    af[-1] += 1e-6
-all_keys = get_bunch_of_rep_keys()['custom']
-original_affective_keys = get_bunch_of_rep_keys()['affective']
-affective_keys = [a.split(' ')[1] for a in original_affective_keys]
-random.seed(0)
-cluster_colors = ['#%06X' % random.randint(0, 0xFFFFFF) for _ in range(total_n_clusters)]
-
-clustering_method = 'k_means'  # 'k_means', 'handcoded', 'agglo', 'spectral'
-if clustering_method != 'handcoded':
-    total_n_clusters = 10
-min_arousal = np.loadtxt(min_max_path + 'min_arousal.txt')
-max_arousal = np.loadtxt(min_max_path + 'max_arousal.txt')
-min_val = np.loadtxt(min_max_path + 'min_valence.txt')
-max_val = np.loadtxt(min_max_path + 'max_valence.txt')
-min_dom = np.loadtxt(min_max_path + 'min_dominance.txt')
-max_dom = np.loadtxt(min_max_path + 'max_dominance.txt')
-
-def get_cocktail_reps(path, save=False):
-    cocktail_data = pd.read_csv(path)
-    cocktail_reps = np.array([cocktail_data[k] for k in original_affective_keys]).transpose()
-    n_data, dim_rep = cocktail_reps.shape
-    # print(f'{n_data} data points of {dim_rep} dimensions: {affective_keys}')
-    cocktail_reps = normalize_cocktail_reps_affective(cocktail_reps, save=save)
-    if save:
-        np.savetxt(experiment_path + f'cocktail_reps_for_affective_mapping_-1_1_norm_sigmoid_rescaling_{dim_rep}_keys.txt', cocktail_reps)
-    return cocktail_reps
-
-def sigmoid(x, shift, beta):
-    return (1 / (1 + np.exp(-(x + shift) * beta)) - 0.5) * 2
-
-def normalize_cocktail_reps_affective(cocktail_reps, save=False):
-    if save:
-        min_cr = cocktail_reps.min(axis=0)
-        max_cr = cocktail_reps.max(axis=0)
-        np.savetxt(min_max_path + 'min_cocktail_reps_affective.txt', min_cr)
-        np.savetxt(min_max_path + 'max_cocktail_reps_affective.txt', max_cr)
-    else:
-        min_cr = np.loadtxt(min_max_path + 'min_cocktail_reps_affective.txt')
-        max_cr = np.loadtxt(min_max_path + 'max_cocktail_reps_affective.txt')
-    cocktail_reps = ((cocktail_reps - min_cr) / (max_cr - min_cr) - 0.5) * 2
-    cocktail_reps[:, 0] = sigmoid(cocktail_reps[:, 0], shift=0.05, beta=4)
-    cocktail_reps[:, 1] = sigmoid(cocktail_reps[:, 1], shift=0.3, beta=5)
-    cocktail_reps[:, 2] = sigmoid(cocktail_reps[:, 2], shift=0.15, beta=3)
-    cocktail_reps[:, 3] = sigmoid(cocktail_reps[:, 3], shift=0.9, beta=20)
-    cocktail_reps[:, 4] = sigmoid(cocktail_reps[:, 4], shift=0, beta=4)
-    cocktail_reps[:, 5] = sigmoid(cocktail_reps[:, 5], shift=0.2, beta=3)
-    cocktail_reps[:, 6] = sigmoid(cocktail_reps[:, 6], shift=0.5, beta=5)
-    cocktail_reps[:, 7] = sigmoid(cocktail_reps[:, 7], shift=0.2, beta=6)
-    return cocktail_reps
-
-def plot(cocktail_reps):
-    dim_rep = cocktail_reps.shape[1]
-    for i in range(dim_rep):
-        for j in range(i+1, dim_rep):
-            plt.figure()
-            plt.scatter(cocktail_reps[:, i], cocktail_reps[:, j], s=150, alpha=0.5)
-            plt.xlabel(affective_keys[i])
-            plt.ylabel(affective_keys[j])
-            plt.savefig(experiment_path + f'scatters/{affective_keys[i]}_vs_{affective_keys[j]}.png', dpi=300)
-            plt.close('all')
-        plt.figure()
-        plt.hist(cocktail_reps[:, i])
-        plt.xlabel(affective_keys[i])
-        plt.savefig(experiment_path + f'hists/{affective_keys[i]}.png', dpi=300)
-    plt.close('all')
-
-def get_clusters(affective_coordinates, save=False):
-    if clustering_method in ['k_means', 'gmm',]:
-        if clustering_method == 'k_means': model = KMeans(n_clusters=total_n_clusters)
-        elif clustering_method == 'gmm': model = GaussianMixture(n_components=total_n_clusters, covariance_type="full")
-        model.fit(affective_coordinates * np.array(dimensions_weights))
-
-        def find_cluster(aff_coord):
-            if aff_coord.ndim == 1:
-                aff_coord = aff_coord.reshape(1, -1)
-            return model.predict(aff_coord * np.array(dimensions_weights))
-        cluster_centers = model.cluster_centers_ if clustering_method == 'k_means' else []
-        if save:
-            to_save = dict(cluster_model=model,
-                           cluster_centers=cluster_centers,
-                           nb_clusters=len(cluster_centers),
-                           dimensions_weights=dimensions_weights)
-            with open(cluster_model_path, 'wb') as f:
-                pickle.dump(to_save, f)
-        stop= 1
-
-    elif clustering_method == 'handcoded':
-        def find_cluster(aff_coord):
-            if aff_coord.ndim == 1:
-                aff_coord = aff_coord.reshape(1, -1)
-            cluster_coordinates = []
-            for i in range(aff_coord.shape[0]):
-                cluster_coordinates.append([np.argwhere(affective_boundaries[j] <= aff_coord[i, j]).flatten()[-1] for j in range(3)])
-            cluster_coordinates = np.array(cluster_coordinates)
-            cluster_ids = cluster_coordinates[:, 0] * np.prod(n_splits[1:]) + cluster_coordinates[:, 1] * n_splits[-1] + cluster_coordinates[:, 2]
-            return cluster_ids
-        # find cluster centers
-        cluster_centers = []
-        for i in range(n_splits[0]):
-            asd = affective_space_dimensions[0]
-            x_coordinate = np.arange(asd[0] + 1 / n_splits[0], asd[1], (asd[1] - asd[0]) / n_splits[0])[i]
-            for j in range(n_splits[1]):
-                asd = affective_space_dimensions[1]
-                y_coordinate = np.arange(asd[0] + 1 / n_splits[1], asd[1], (asd[1] - asd[0]) / n_splits[1])[j]
-                for k in range(n_splits[2]):
-                    asd = affective_space_dimensions[2]
-                    z_coordinate = np.arange(asd[0] + 1 / n_splits[2], asd[1], (asd[1] - asd[0]) / n_splits[2])[k]
-                    cluster_centers.append([x_coordinate, y_coordinate, z_coordinate])
-        cluster_centers = np.array(cluster_centers)
-    else:
-        raise NotImplemented
-    cluster_ids = find_cluster(affective_coordinates)
-    return cluster_ids, cluster_centers, find_cluster
-
-
-def cocktail2affect(cocktail_reps, save=False):
-    if cocktail_reps.ndim == 1:
-        cocktail_reps = cocktail_reps.reshape(1, -1)
-
-    assert affective_keys == ['booze', 'sweet', 'sour', 'fizzy', 'complex', 'bitter', 'spicy', 'colorful']
-    all_weights = []
-
-    # valence
-    # + sweet - bitter - booze + colorful
-    weights = np.array([-1, 1, 0, 0, 0, -1, 0, 1])
-    valence = (cocktail_reps * weights).sum(axis=1)
-    if save:
-        min_ = valence.min()
-        max_ = valence.max()
-        np.savetxt(min_max_path + 'min_valence.txt', np.array([min_]))
-        np.savetxt(min_max_path + 'max_valence.txt', np.array([max_]))
-    else:
-        min_ = min_val
-        max_ = max_val
-    valence = 2 * ((valence - min_) / (max_ - min_) - 0.5)
-    valence = sigmoid(valence, shift=0.1, beta=3.5)
-    valence = valence.reshape(-1, 1)
-    all_weights.append(weights.copy())
-
-    # arousal
-    # + fizzy + sour + complex - sweet + spicy + bitter
-    # weights = np.array([0, -1, 1, 1, 1, 1, 1, 0])
-    weights = np.array([0.7, 0, 1.5, 1.5, 0.6, 0, 0.6, 0])
-    arousal = (cocktail_reps * weights).sum(axis=1)
-    if save:
-        min_ = arousal.min()
-        max_ = arousal.max()
-        np.savetxt(min_max_path + 'min_arousal.txt', np.array([min_]))
-        np.savetxt(min_max_path + 'max_arousal.txt', np.array([max_]))
-    else:
-        min_, max_ = min_arousal, max_arousal
-    arousal = 2 * ((arousal - min_) / (max_ - min_) - 0.5)  # normalize to -1, 1
-    arousal = sigmoid(arousal, shift=0.3, beta=4)
-    arousal = arousal.reshape(-1, 1)
-    all_weights.append(weights.copy())
-
-    # dominance
-    # assert affective_keys == ['booze', 'sweet', 'sour', 'fizzy', 'complex', 'bitter', 'spicy', 'colorful']
-    # + booze + fizzy - complex - bitter - sweet
-    weights = np.array([1.5, -0.8, 0, 0.7, -1, -1.5, 0, 0])
-    dominance = (cocktail_reps * weights).sum(axis=1)
-    if save:
-        min_ = dominance.min()
-        max_ = dominance.max()
-        np.savetxt(min_max_path + 'min_dominance.txt', np.array([min_]))
-        np.savetxt(min_max_path + 'max_dominance.txt', np.array([max_]))
-    else:
-        min_, max_ = min_dom, max_dom
-    dominance = 2 * ((dominance - min_) / (max_ - min_) - 0.5)
-    dominance = sigmoid(dominance, shift=-0.05, beta=5)
-    dominance = dominance.reshape(-1, 1)
-    all_weights.append(weights.copy())
-
-    affective_coordinates = np.concatenate([valence, arousal, dominance], axis=1)
-    # if save:
-    #     assert (affective_coordinates.min(axis=0) == np.array([ac[0] for ac in affective_space_dimensions])).all()
-    #     assert (affective_coordinates.max(axis=0) == np.array([ac[1] for ac in affective_space_dimensions])).all()
-    return affective_coordinates, all_weights
-
-def save_reps(path, affective_cluster_ids):
-    cocktail_data = pd.read_csv(path)
-    rep_keys = get_bunch_of_rep_keys()['custom']
-    cocktail_reps = np.array([cocktail_data[k] for k in rep_keys]).transpose()
-    np.savetxt(experiment_path + 'clustered_representations/' + f'min_cocktail_reps_custom_keys_dim{cocktail_reps.shape[1]}.txt', cocktail_reps.min(axis=0))
-    np.savetxt(experiment_path + 'clustered_representations/' + f'max_cocktail_reps_custom_keys_dim{cocktail_reps.shape[1]}.txt', cocktail_reps.max(axis=0))
-    cocktail_reps = ((cocktail_reps - cocktail_reps.min(axis=0)) / (cocktail_reps.max(axis=0) - cocktail_reps.min(axis=0)) - 0.5) * 2  # normalize in -1, 1
-    np.savetxt(experiment_path + 'clustered_representations/' + f'all_cocktail_reps_norm-1_1_custom_keys_dim{cocktail_reps.shape[1]}.txt', cocktail_reps)
-    np.savetxt(experiment_path + 'clustered_representations/' + 'affective_cluster_ids.txt', affective_cluster_ids)
-    for cluster_id in sorted(set(affective_cluster_ids)):
-        indexes = np.argwhere(affective_cluster_ids == cluster_id).flatten()
-        reps = cocktail_reps[indexes, :]
-        np.savetxt(experiment_path + 'clustered_representations/' + f'rep_cluster{cluster_id}_norm-1_1_custom_keys_dim{cocktail_reps.shape[1]}.txt', reps)
-
-def study_affects(affective_coordinates, affective_cluster_ids):
-    plt.figure()
-    plt.hist(affective_cluster_ids, bins=total_n_clusters)
-    plt.xlabel('Affective cluster ids')
-    plt.xticks(np.arange(total_n_clusters))
-    plt.savefig(experiment_path + 'affective_cluster_distrib.png')
-    fig = plt.gcf()
-    plt.close(fig)
-
-    fig = plt.figure()
-    ax = fig.add_subplot(projection='3d')
-    ax.set_xlim([-1, 1])
-    ax.set_ylim([-1, 1])
-    ax.set_zlim([-1, 1])
-    for cluster_id in sorted(set(affective_cluster_ids)):
-        indexes = np.argwhere(affective_cluster_ids == cluster_id).flatten()
-        ax.scatter(affective_coordinates[indexes, 0], affective_coordinates[indexes, 1], affective_coordinates[indexes, 2], c=cluster_colors[cluster_id], s=150)
-        ax.set_xlabel('Valence')
-        ax.set_ylabel('Arousal')
-        ax.set_zlabel('Dominance')
-        stop = 1
-    plt.savefig(experiment_path + 'scatters_affect/affective_mapping.png')
-    fig = plt.gcf()
-    plt.close(fig)
-
-    affects = ['Valence', 'Arousal', 'Dominance']
-    for i in range(3):
-        for j in range(i + 1, 3):
-            fig = plt.figure()
-            ax = fig.add_subplot()
-            for cluster_id in sorted(set(affective_cluster_ids)):
-                indexes = np.argwhere(affective_cluster_ids == cluster_id).flatten()
-                ax.scatter(affective_coordinates[indexes, i], affective_coordinates[indexes, j], alpha=0.5, c=cluster_colors[cluster_id], s=150)
-            ax.set_xlabel(affects[i])
-            ax.set_ylabel(affects[j])
-            plt.savefig(experiment_path + f'scatters_affect/scatter_{affects[i]}_vs_{affects[j]}.png')
-            fig = plt.gcf()
-            plt.close(fig)
-        plt.figure()
-        plt.hist(affective_coordinates[:, i])
-        plt.xlabel(affects[i])
-        plt.savefig(experiment_path + f'hists_affect/hist_{affects[i]}.png')
-        fig = plt.gcf()
-        plt.close(fig)
-    plt.close('all')
-    stop = 1
-
-def sample_clusters(path, cocktail_reps, all_weights, affective_cluster_ids, affective_cluster_centers, affective_coordinates, n_samples=4):
-    cocktail_data = pd.read_csv(path)
-    these_cocktail_reps = normalize_cocktail_reps_affective(np.array([cocktail_data[k] for k in original_affective_keys]).transpose())
-
-    names = cocktail_data['names']
-    urls = cocktail_data['urls']
-    ingr_str = cocktail_data['ingredients_str']
-    for cluster_id in sorted(set(affective_cluster_ids)):
-        indexes = np.argwhere(affective_cluster_ids == cluster_id).flatten()
-        print('\n\n\n---------\n----------\n-----------\n')
-        cluster_str = ''
-        cluster_str += f'Affective cluster #{cluster_id}' + \
-                       f'\n\tSize: {len(indexes)}' + \
-                       f'\n\tCenter: ' + \
-                       f'\n\t\tVal: {affective_cluster_centers[cluster_id][0]:.2f}, ' + \
-                       f'\n\t\tArousal: {affective_cluster_centers[cluster_id][1]:.2f}, ' + \
-                       f'\n\t\tDominance: {affective_cluster_centers[cluster_id][2]:.2f}'
-        print(cluster_str)
-        if affective_cluster_centers[cluster_id][2] == np.max(affective_cluster_centers[:, 2]):
-            stop = 1
-        sampled_idx = np.random.choice(indexes, size=min(len(indexes), n_samples), replace=False)
-        cocktail_str = ''
-        for i in sampled_idx:
-            assert np.sum(cocktail_reps[i] - these_cocktail_reps[i]) < 1e-9
-            cocktail_str += f'\n\n-------------'
-            cocktail_str += print_recipe(ingr_str[i], name=names[i], to_print=False)
-            cocktail_str +=  f'\nUrl: {urls[i]}'
-            cocktail_str +=  '\n\nRepresentation: ' + ', '.join([f'{af}: {cr:.2f}' for af, cr in zip(affective_keys, cocktail_reps[i])]) + '\n'
-            cocktail_str += '\n' + generate_explanation(cocktail_reps[i], all_weights, affective_coordinates[i])
-            print(cocktail_str)
-            stop = 1
-        cluster_str += '\n' + cocktail_str
-        with open(f"/home/cedric/Documents/pianocktail/experiments/cocktails/representation_analysis/affective_mapping/clusters/cluster_{cluster_id}", 'w') as f:
-            f.write(cluster_str)
-    stop = 1
-
-def explanation_per_dimension(i, cocktail_rep, all_weights, aff_coord):
-    names = ['valence', 'arousal', 'dominance']
-    weights = all_weights[i]
-    explanation_str = f'\n{names[i].capitalize()} explanation ({aff_coord[i]:.2f}):'
-    strengths = np.abs(weights * cocktail_rep)
-    strengths /= strengths.sum()
-    indexes = np.flip(np.argsort(strengths))
-    for ind in indexes:
-        if strengths[ind] != 0:
-            if np.sign(weights[ind]) == np.sign(cocktail_rep[ind]):
-                keyword = 'high' if cocktail_rep[ind] > 0 else 'low'
-                explanation_str += f'\n\t{int(strengths[ind]*100)}%: higher {names[i]} because {keyword} {affective_keys[ind]}'
-            else:
-                keyword = 'high' if cocktail_rep[ind] > 0 else 'low'
-                explanation_str += f'\n\t{int(strengths[ind]*100)}%: low {names[i]} because {keyword} {affective_keys[ind]}'
-    return explanation_str
-
-def generate_explanation(cocktail_rep, all_weights, aff_coord):
-    explanation_str = ''
-    for i in range(3):
-        explanation_str += explanation_per_dimension(i, cocktail_rep, all_weights, aff_coord)
-    return explanation_str
-
-def cocktails2affect_clusters(cocktail_rep):
-    if cocktail_rep.ndim == 1:
-        cocktail_rep = cocktail_rep.reshape(1, -1)
-    affective_coordinates, _ = cocktail2affect(cocktail_rep)
-    affective_cluster_ids, _, _ = get_clusters(affective_coordinates)
-    return affective_cluster_ids
-
-
-def setup_affective_space(path, save=False):
-    cocktail_data = pd.read_csv(path)
-    names = cocktail_data['names']
-    recipes = cocktail_data['ingredients_str']
-    urls = cocktail_data['urls']
-    reps = get_cocktail_reps(path)
-    affective_coordinates, all_weights = cocktail2affect(reps)
-    affective_cluster_ids, affective_cluster_centers, find_cluster = get_clusters(affective_coordinates, save=save)
-    nn_model = NearestNeighbors(n_neighbors=1)
-    nn_model.fit(affective_coordinates)
-    def cocktail2affect_cluster(cocktail_rep):
-        affective_coordinates, _ = cocktail2affect(cocktail_rep)
-        return find_cluster(affective_coordinates)
-
-    affective_clusters = dict(affective_coordinates=affective_coordinates,  # coordinates of cocktail in affective space
-                              affective_cluster_ids=affective_cluster_ids,  # cluster id of cocktails
-                              affective_cluster_centers=affective_cluster_centers, # cluster centers in affective space
-                              affective_weights=all_weights,  # weights to compute valence, arousal, dominance from cocktail representations
-                              original_affective_keys=original_affective_keys,
-                              cocktail_reps=reps,  # cocktail representations from the dataset (normalized)
-                              find_cluster=find_cluster,  # function to retrieve a cluster from affective coordinates
-                              nn_model=nn_model,  # to predict the nearest neighbor affective space,
-                              names=names, # names of cocktails in the dataset
-                              urls=urls,  # urls from the dataset
-                              recipes=recipes, # recipes of the dataset
-                              cocktail2affect=cocktail2affect,  # function to compute affects from cocktail representations
-                              cocktails2affect_clusters=cocktails2affect_clusters,
-                              cocktail2affect_cluster=cocktail2affect_cluster
-                              )
-
-    return affective_clusters
-
-if __name__ == '__main__':
-    reps = get_cocktail_reps(COCKTAILS_CSV_DATA, save=True)
-    # plot(reps)
-    affective_coordinates, all_weights = cocktail2affect(reps, save=True)
-    affective_cluster_ids, affective_cluster_centers, find_cluster = get_clusters(affective_coordinates)
-    save_reps(COCKTAILS_CSV_DATA, affective_cluster_ids)
-    study_affects(affective_coordinates, affective_cluster_ids)
-    sample_clusters(COCKTAILS_CSV_DATA, reps, all_weights, affective_cluster_ids, affective_cluster_centers, affective_coordinates)
-    setup_affective_space(COCKTAILS_CSV_DATA, save=True)

src/cocktails/pipeline/cocktailrep2recipe.py

@@ -1,329 +0,0 @@
-import matplotlib.pyplot as plt
-import pickle
-from src.cocktails.utilities.cocktail_generation_utilities.population import *
-from src.cocktails.utilities.glass_and_volume_utilities import glass_volume
-from src.cocktails.config import RECIPE2FEATURES_PATH
-
-def test_mutation_params(cocktail_reps):
-    indexes = np.arange(cocktail_reps.shape[0])
-    np.random.shuffle(indexes)
-    perfs = []
-    mutated_perfs = []
-    pop_params = dict(mutation_params=dict(p_add_ing=0.7,
-                                           p_remove_ing=0.7,
-                                           p_switch_ing=0.5,
-                                           p_change_q=0.7,
-                                           delta_change_q=0.3,
-                                           asexual_rep=True,
-                                           crossover=True,
-                                           ingredient_addition=(0.1, 0.05)),
-                      nb_generations=100,
-                      pop_size=100,
-                      nb_elites=10,
-                      dist='mse',
-                      n_neighbors=5)
-
-    for i in indexes[:20]:
-        target = cocktail_reps[i]
-        for j in range(100):
-            parent = IndividualCocktail(pop_params=pop_params,
-                                        target_affective_cluster=None,
-                                        target=target.copy())
-            perfs.append(parent.perf)
-            child = parent.get_child()[0]
-            # child.compute_cocktail_rep()
-            # child.compute_perf()
-            if perfs[-1] != child.perf:
-                mutated_perfs.append(child.perf)
-            else:
-                perfs.pop(-1)
-    filtered_children = np.argwhere(np.array(mutated_perfs)==-100).flatten()
-    non_filtered_ids = np.argwhere(np.logical_and(np.array(perfs)!=-100, np.array(mutated_perfs)!=-100)).flatten()
-    print(f'Proportion of filtered: {filtered_children.size} / {len(mutated_perfs)} = {int(filtered_children.size / len(mutated_perfs)*100)}%')
-    plt.figure()
-    plt.scatter(np.array(perfs)[non_filtered_ids], np.array(mutated_perfs)[non_filtered_ids], s=100, alpha=0.5)
-    plt.xlabel('parent perf')
-    plt.ylabel('child perf')
-    print(np.corrcoef(np.array(perfs)[non_filtered_ids], np.array(mutated_perfs)[non_filtered_ids])[0, 1])
-    plt.show()
-    stop = 1
-
-def test_crossover(cocktail_reps):
-    indexes = np.arange(cocktail_reps.shape[0])
-    np.random.shuffle(indexes)
-    perfs = []
-    mutated_perfs = []
-    pop_params = dict(mutation_params=dict(p_add_ing=0.7,
-                                           p_remove_ing=0.7,
-                                           p_switch_ing=0.5,
-                                           p_change_q=0.7,
-                                           delta_change_q=0.3,
-                                           asexual_rep=True,
-                                           crossover=True,
-                                           ingredient_addition=(0.1, 0.05)),
-                      nb_generations=100,
-                      pop_size=100,
-                      nb_elites=10,
-                      dist='mse',
-                      n_neighbors=5)
-    for i in indexes[:20]:
-        for j in range(100):
-            target = cocktail_reps[i]
-            parent1 = IndividualCocktail(pop_params=pop_params,
-                                         target_affective_cluster=None,
-                                        target=target.copy())
-            parent2 = IndividualCocktail(pop_params=pop_params,
-                                         target_affective_cluster=None,
-                                         target=target.copy())
-            child = parent1.get_child_with(parent2)[0]
-            # child.compute_cocktail_rep()
-            # child.compute_perf()
-            perfs.append((parent1.perf + parent2.perf)/2)
-            if perfs[-1] != child.perf:
-                mutated_perfs.append(child.perf)
-            else:
-                perfs.pop(-1)
-    filtered_children = np.argwhere(np.array(mutated_perfs)==-100).flatten()
-    non_filtered_ids = np.argwhere(np.logical_and(np.array(perfs)>-45, np.array(mutated_perfs)!=-100)).flatten()
-    print(f'Proportion of filtered: {filtered_children.size} / {len(mutated_perfs)} = {int(filtered_children.size / len(mutated_perfs)*100)}%')
-    plt.figure()
-    plt.scatter(np.array(perfs)[non_filtered_ids], np.array(mutated_perfs)[non_filtered_ids], s=100, alpha=0.5)
-    plt.xlabel('parent perf')
-    plt.ylabel('child perf')
-    print(np.corrcoef(np.array(perfs)[non_filtered_ids], np.array(mutated_perfs)[non_filtered_ids])[0, 1])
-    plt.show()
-    stop = 1
-
-def run_comparisons():
-    np.random.seed(0)
-    indexes = np.arange(cocktail_reps.shape[0])
-    np.random.shuffle(indexes)
-    for n_neighbors in [0, 5]:
-        id_str_neigh = '5neigh_' if n_neighbors == 5 else '0_neigh_'
-        for asexual_rep in [True, False]:
-            id_str_as = id_str_neigh + 'asexual_' if asexual_rep else id_str_neigh
-            for crossover in [True, False]:
-                id_str = id_str_as + 'crossover_' if crossover else id_str_as
-                if crossover or asexual_rep:
-                    mutation_params = dict(p_add_ing = 0.5,
-                                           p_remove_ing = 0.5,
-                                           p_change_q = 0.5,
-                                           delta_change_q = 0.3,
-                                           asexual_rep=asexual_rep,
-                                           crossover=crossover,
-                                           ingredient_addition = (0.1, 0.05))
-                    nb_generations = 100
-                    pop_size=100
-                    nb_elites=10
-                    dist = 'mse'
-                    results = dict()
-                    print(id_str)
-                    for i, ind in enumerate(indexes[:30]):
-                        print(i+1)
-                        target_ing_str = data['ingredients_str'][ind]
-                        target = cocktail_reps[ind]
-                        population = Population(nb_generations=nb_generations, pop_size=pop_size, nb_elite=nb_elites,
-                                                target=target, dist=dist, mutation_params=mutation_params,
-                                                n_neighbors=n_neighbors, target_ing_str=target_ing_str, true_prep_type=data['category'][ind])
-                        population.run_evolution(verbose=False)
-                        best_scores, best_ind = population.get_best_score()
-                        recipes = [ind.get_recipe()[3] for ind in best_ind[:5]]
-                        results[str(ind)] = dict(best_scores=best_scores[:5], recipes=recipes, target=population.target_individual.get_recipe()[3])
-                        with open(f'/home/cedric/Desktop/ga_tests_{id_str}.pickle', 'wb') as f:
-                            pickle.dump(results, f)
-
-def get_cocktail_distribution(cocktail_reps):
-    return (np.mean(cocktail_reps, axis=0), np.cov(cocktail_reps, rowvar=0))
-
-def sample_cocktails(cocktail_reps, n=10, target_affective_cluster=None, to_print=True):
-    distrib = get_cocktail_distribution(cocktail_reps)
-    sampled_cocktail_reps = np.random.multivariate_normal(distrib[0], distrib[1], size=n)
-    recipes = []
-    closest_recipes = []
-    for i_c, cr in enumerate(sampled_cocktail_reps):
-        population = setup_recipe_generation(cr.copy(), target_affective_cluster=target_affective_cluster)
-        closest_recipes.append(population.nn_recipes[0])
-        best_scores, best_individuals = population.run_evolution()
-        recipes.append(best_individuals[0].get_recipe()[3])
-        if to_print:
-            print(f'Sample #{len(recipes)}:')
-            print(recipes[-1])
-            print('Closest from dataset:')
-            print(closest_recipes[-1])
-        stop = 1
-    return recipes, closest_recipes
-
-def setup_recipe_generation(target, known_target_dict=None, target_affective_cluster=None):
-    # pop_params = dict(mutation_params=dict(p_add_ing=0.7,
-    #                                        p_remove_ing=0.7,
-    #                                        p_switch_ing=0.5,
-    #                                        p_change_q=0.7,
-    #                                        delta_change_q=0.3,
-    #                                        asexual_rep=True,
-    #                                        crossover=True,
-    #                                        ingredient_addition=(0.1, 0.05)),
-    #                   nb_generations=2, #100
-    #                   pop_size=5, #100
-    #                   nb_elites=2, #10
-    #                   dist='mse',
-    #                   n_neighbors=3) #5
-    pop_params = dict(mutation_params=dict(p_add_ing=0.4,
-                                           p_remove_ing=1,
-                                           p_switch_ing=0.5,
-                                           p_change_q=1,
-                                           delta_change_q=0.3,
-                                           asexual_rep=True,
-                                           crossover=True,
-                                           ingredient_addition=(0.1, 0.05)),
-                      nb_generations=100,  # 100
-                      pop_size=100,  # 100
-                      nb_elites=10,  # 10
-                      dist='mse',
-                      n_neighbors=5)  # 5
-
-    population = Population(target=target,  target_affective_cluster=target_affective_cluster, known_target_dict=known_target_dict, pop_params=pop_params)
-    return population
-
-def cocktailrep2recipe(cocktail_rep, unit='mL', target_affective_cluster=None, known_target_dict=None, n_output=1, return_ind=False, verbose=True, full_verbose=False, level=0):
-    init_time = time.time()
-    if verbose: print(' ' * level + 'Generating cocktail..')
-    if cocktail_rep.ndim > 1:
-        assert cocktail_rep.shape[0] == 1
-        cocktail_rep = cocktail_rep.flatten()
-        # target_affective_cluster = target_affective_cluster[0]
-    population = setup_recipe_generation(cocktail_rep.copy(), known_target_dict=known_target_dict, target_affective_cluster=target_affective_cluster)
-    if full_verbose:
-        print(' ' * (level + 2) + '3 nearest neighbors:')
-        for i, recipe, score in zip(range(3), population.nn_recipes[:3], population.nn_scores[:3]):
-            print(' ' * (level + 4) + f'#{i+1}, score: {score:.2f}')
-            print(' ' * (level + 4) + recipe[1:].replace('None ()', '').replace('\t\t', ' ' * (level + 6)))
-    best_scores, best_individuals = population.run_evolution(verbose=full_verbose, level=level+2)
-    for i in range(n_output):
-        best_individuals[i].make_recipe_fit_the_glass()
-    instructions = [ind.get_instructions() for ind in best_individuals[:n_output]]
-    recipes = [ind.get_recipe(unit=unit)[3] for ind in best_individuals[:n_output]]
-    glasses = [ind.glass for ind in best_individuals[:n_output]]
-    prep_types = [ind.prep_type for ind in best_individuals[:n_output]]
-    for i, g, p, inst in zip(range(len(recipes)), glasses, prep_types, instructions):
-        recipes[i] = recipes[i].replace('Recipe', 'Ingredients') + f'Serve in:\n   {g.capitalize()} glass.\n' + inst
-    if full_verbose:
-        print(f'\n--------------\n{n_output} best results:')
-        for i, recipe, score in zip(range(n_output), recipes, best_scores[:n_output]):
-            print(f'#{i+1}, score: {score:.2f}')
-            print(recipe)
-    if verbose: print(' ' * (level + 2) + f'Generated in {int(time.time() - init_time)} seconds.')
-    if return_ind:
-        return recipes, best_scores[:n_output], best_individuals[:n_output]
-    else:
-        return recipes, best_scores[:n_output]
-
-
-def interpolate(cocktail_rep1, cocktail_rep2, alpha, verbose=False):
-    recipe, score = cocktailrep2recipe(alpha * cocktail_rep1 + (1 - alpha) * cocktail_rep2, verbose=verbose)
-    return recipe[0], score
-
-def interpolation_study(n_steps, cocktail_reps):
-    alphas = np.arange(0, 1 + 1e-6, 1/(n_steps + 1))
-    indexes = np.random.choice(np.arange(cocktail_reps.shape[0]), size=2, replace=False)
-    target_ing_str1, target_ing_str2 = data['ingredients_str'][indexes[0]], data['ingredients_str'][indexes[1]]
-    cocktail_rep1, cocktail_rep2 = cocktail_reps[indexes[0]], cocktail_reps[indexes[1]]
-    recipes, scores = [], []
-    for alpha in alphas:
-        recipe, score = interpolate(cocktail_rep1, cocktail_rep2, alpha)
-        recipes.append(recipe)
-        scores.append(score[0])
-    print('Point A:')
-    print_recipe(ingredient_str=target_ing_str2)
-    for i, alpha in enumerate(alphas):
-        print(f'Alpha = {alpha}, score = {scores[i]}')
-        print(recipes[i])
-    print('Point B:')
-    print_recipe(ingredient_str=target_ing_str1)
-    stop = 1
-
-def test_robustness_affective_cluster(cocktail_reps):
-    indexes = np.arange(cocktail_reps.shape[0])
-    np.random.shuffle(indexes)
-    matches = []
-    for i in indexes:
-        target_ing_str = data['ingredients_str'][i]
-        true_prep_type = data['category'][i]
-        target = cocktail_reps[i]
-        # get affective cluster
-        recipes, best_scores, best_inds = cocktailrep2recipe(cocktail_rep=target, target_ing_str=target_ing_str, true_prep_type=true_prep_type, n_output=1, verbose=False,
-                                                             return_ind=True)
-
-        matches.append(best_inds[0].does_affective_cluster_match())
-        print(np.mean(matches))
-
-def test(cocktail_reps):
-    indexes = np.arange(these_cocktail_reps.shape[0])
-    unnormalized_cr = np.array([data[k] for k in rep_keys]).transpose()
-
-    for i in indexes:
-        target_ing_str = data['ingredients_str'][i]
-        true_prep_type = data['category'][i]
-        target = these_cocktail_reps[i]
-        # print('preptype:', true_prep_type)
-        # print('cocktail unnormalized', np.sum(unnormalized_cr[i]), unnormalized_cr[i])
-        # print('cocktail hand normalized', np.sum(normalize_cocktail(unnormalized_cr[i])), normalize_cocktail(unnormalized_cr[i]))
-        # print('cocktail rep normalized', np.sum(these_cocktail_reps[i]), these_cocktail_reps[i])
-        # print('cocktail rep normalized', np.sum(all_reps[i]), all_reps[i])
-
-        population = setup_recipe_generation(target.copy(), target_ing_str=target_ing_str, target_affective_cluster=None, true_prep_type=true_prep_type)
-        target = population.target_individual
-        target.compute_perf()
-        if target.perf < -50:
-            print(i)
-            print_recipe(target_ing_str)
-            if not target.is_alcohol_present(): print('No alcohol')
-            if not target.is_total_volume_enough(): print('small volume')
-            if not target.does_fit_glass():
-                print(target.end_volume)
-                print(glass_volume[target.get_glass_type()] * 0.81)
-                print('too much volume')
-            if not target.is_alcohol_reasonable():
-                print(f'amount of alcohol too small or too large: {target.alcohol_precentage}')
-            stop = 1
-
-
-if __name__ == '__main__':
-    these_cocktail_reps = COCKTAIL_REPS.copy()
-    # test_crossover(these_cocktail_reps)
-    # test_mutation_params(these_cocktail_reps)
-    # test(these_cocktail_reps)
-    # recipes, closest_recipes = sample_cocktails(these_cocktail_reps, n=10)
-    # interpolation_study(n_steps=4, cocktail_reps=these_cocktail_reps)
-    # test_robustness_affective_cluster(these_cocktail_reps)
-    indexes = np.arange(these_cocktail_reps.shape[0])
-    np.random.shuffle(indexes)
-    # test_crossover(mutation_params, dist)
-    # test_mutation_params(mutation_params, dist)
-    stop = 1
-    unnormalized_cr = np.array([data[k] for k in rep_keys]).transpose()
-    for i in indexes:
-        print(i)
-        target_ing_str = data['ingredients_str'][i]
-        target_prep_type = data['category'][i]
-        target_glass = data['glass'][i]
-
-        print('preptype:', target_prep_type)
-        print('cocktail unnormalized', np.sum(unnormalized_cr[i]), unnormalized_cr[i])
-        print('cocktail hand normalized', np.sum(normalize_cocktail(unnormalized_cr[i])), normalize_cocktail(unnormalized_cr[i]))
-        print('cocktail rep normalized', np.sum(these_cocktail_reps[i]), these_cocktail_reps[i])
-        print('cocktail rep normalized', np.sum(all_reps[i]), all_reps[i])
-        print(i)
-
-        print('___________Target')
-        nn_model = NearestNeighbors()
-        nn_model.fit(these_cocktail_reps)
-        dists, indexes = nn_model.kneighbors(these_cocktail_reps[i].reshape(1, -1))
-        print(indexes)
-        print_recipe(target_ing_str)
-        target = these_cocktail_reps[i]
-        known_target_dict = dict(prep_type=target_prep_type,
-                                 ing_str=target_ing_str,
-                                 glass=target_glass)
-        recipes, best_scores = cocktailrep2recipe(cocktail_rep=target, known_target_dict=known_target_dict, n_output=1, verbose=True, full_verbose=True)
-
-        stop = 1

src/cocktails/pipeline/get_affect2affective_cluster.py

@@ -1,23 +0,0 @@
-from src.music.config import CHECKPOINTS_PATH
-import pickle
-import numpy as np
-
-# can be computed from cocktail2affect
-cluster_model_path = CHECKPOINTS_PATH + "/music2cocktails/affects2affect_cluster/cluster_model.pickle"
-
-def get_affect2affective_cluster():
-    with open(cluster_model_path, 'rb') as f:
-        data = pickle.load(f)
-    model = data['cluster_model']
-    dimensions_weights = data['dimensions_weights']
-    def find_cluster(aff_coord):
-        if aff_coord.ndim == 1:
-            aff_coord = aff_coord.reshape(1, -1)
-        return model.predict(aff_coord * np.array(dimensions_weights))
-    return find_cluster
-
-def get_affective_cluster_centers():
-    with open(cluster_model_path, 'rb') as f:
-        data = pickle.load(f)
-    return  data['cluster_centers']
-

src/cocktails/pipeline/get_cocktail2affective_cluster.py

@@ -1,9 +0,0 @@
-from src.cocktails.pipeline.get_affect2affective_cluster import get_affect2affective_cluster
-from src.cocktails.pipeline.cocktail2affect import cocktail2affect
-
-def get_cocktail2affective_cluster():
-    find_cluster = get_affect2affective_cluster()
-    def cocktail2affect_cluster(cocktail_rep):
-        affective_coordinates, _ = cocktail2affect(cocktail_rep)
-        return find_cluster(affective_coordinates)
-    return cocktail2affect_cluster

src/cocktails/representation_learning/dataset.py

@@ -1,324 +0,0 @@
-from torch.utils.data import Dataset
-import pickle
-from src.cocktails.utilities.ingredients_utilities import extract_ingredients, ingredient_list, ingredient_profiles,  ingredients_per_type
-from src.cocktails.utilities.other_scrubbing_utilities import print_recipe
-import numpy as np
-
-def get_representation_from_ingredient(ingredients, quantities, max_q_per_ing, index, params):
-    assert len(ingredients) == len(quantities)
-    ing, q = ingredients[index], quantities[index]
-    proportion = q / np.sum(quantities)
-    index_ing = ingredient_list.index(ing)
-    # add keys of profile
-    rep_ingredient = []
-    rep_ingredient += [ingredient_profiles[k][index_ing] for k in params['ing_keys']]
-    # add category encoding
-    # rep_ingredient += list(params['category_encodings'][ingredient_profiles['type'][index_ing]])
-    # add quantitiy and relative quantity
-    rep_ingredient += [q / max_q_per_ing[ing], proportion]
-    ing_one_hot = np.zeros(len(ingredient_list))
-    ing_one_hot[index_ing] = 1
-    rep_ingredient += list(ing_one_hot)
-    indexes_to_normalize = list(range(len(params['ing_keys'])))
-    #TODO: should we add ing one hot? Or make sure no 2 ing have same embedding
-    return np.array(rep_ingredient), indexes_to_normalize
-
-def get_max_n_ingredients(data):
-    max_count = 0
-    ingredient_set = set()
-    alcohol_set = set()
-    liqueur_set = set()
-    ing_str = np.array(data['ingredients_str'])
-    for i in range(len(data['names'])):
-        ingredients, quantities = extract_ingredients(ing_str[i])
-        max_count = max(max_count, len(ingredients))
-        for ing in ingredients:
-            ingredient_set.add(ing)
-            if ing in ingredients_per_type['liquor']:
-                alcohol_set.add(ing)
-            if ing in ingredients_per_type['liqueur']:
-                liqueur_set.add(ing)
-    return max_count, ingredient_set, alcohol_set, liqueur_set
-
-# Add your custom dataset class here
-class MyDataset(Dataset):
-    def __init__(self, split, params):
-        data = params['raw_data']
-        self.dim_rep_ingredient = params['dim_rep_ingredient']
-        n_data = len(data["names"])
-
-        preparation_list = sorted(set(data['category']))
-        categories_list = sorted(set(data['subcategory']))
-        glasses_list = sorted(set(data['glass']))
-
-        max_ingredients, ingredient_set, liquor_set, liqueur_set = get_max_n_ingredients(data)
-        ingredient_set = sorted(ingredient_set)
-        self.ingredient_set = ingredient_set
-
-        ingredient_quantities = []  # output of our network
-        ingr_strs = np.array(data['ingredients_str'])
-        for i in range(n_data):
-            ingredients, quantities = extract_ingredients(ingr_strs[i])
-            # get ingredient presence and quantity
-            ingredient_q_rep = np.zeros([len(ingredient_set)])
-            for ing, q in zip(ingredients, quantities):
-                ingredient_q_rep[ingredient_set.index(ing)] = q
-            ingredient_quantities.append(ingredient_q_rep)
-
-        # take care of ingredient quantities (OUTPUTS)
-        ingredient_quantities = np.array(ingredient_quantities)
-        ingredients_presence = (ingredient_quantities>0).astype(np.int)
-
-        min_ing_quantities = np.min(ingredient_quantities, axis=0)
-        max_ing_quantities = np.max(ingredient_quantities, axis=0)
-        def normalize_ing_quantities(ing_quantities):
-            return ((ing_quantities - min_ing_quantities) / (max_ing_quantities - min_ing_quantities)).copy()
-
-        def denormalize_ing_quantities(normalized_ing_quantities):
-            return (normalized_ing_quantities * (max_ing_quantities - min_ing_quantities) + min_ing_quantities).copy()
-        ing_q_when_present = ingredient_quantities.copy()
-        for i in range(len(ing_q_when_present)):
-            ing_q_when_present[i, np.where(ing_q_when_present[i, :] == 0)] = np.nan
-        self.min_when_present_ing_quantities = np.nanmin(ing_q_when_present, axis=0)
-
-
-        def filter_decoder_output(output):
-            output_unnormalized = output * max_ing_quantities
-            if output.ndim == 1:
-                output_unnormalized[np.where(output_unnormalized<self.min_when_present_ing_quantities)] = 0
-            else:
-                for i in range(output.shape[0]):
-                    output_unnormalized[i, np.where(output_unnormalized[i] < self.min_when_present_ing_quantities)] = 0
-            return output_unnormalized.copy()
-        self.filter_decoder_output = filter_decoder_output
-        # arg_mins = np.nanargmin(ing_q_when_present, axis=0)
-        #
-        # for ing, minq, argminq in zip(ingredient_set, self.min_when_present_ing_quantities, arg_mins):
-        #     print(f'__\n{ing}: {minq}')
-        #     print_recipe(ingr_strs[argminq])
-        #     ingredients, quantities = extract_ingredients(ingr_strs[argminq])
-        #     # get ingredient presence and quantity
-        #     ingredient_q_rep = np.zeros([len(ingredient_set)])
-        #     for ing, q in zip(ingredients, quantities):
-        #         ingredient_q_rep[ingredient_set.index(ing)] = q
-        #     print(np.array(data['urls'])[argminq])
-        #     stop = 1
-
-        self.max_ing_quantities = max_ing_quantities
-        self.mean_ing_quantities = np.mean(ingredient_quantities, axis=0)
-        self.std_ing_quantities = np.std(ingredient_quantities, axis=0)
-        if split == 'train':
-            np.savetxt(params['save_path'] + 'min_when_present_ing_quantities.txt', self.min_when_present_ing_quantities)
-            np.savetxt(params['save_path'] + 'max_ing_quantities.txt', max_ing_quantities)
-            np.savetxt(params['save_path'] + 'mean_ing_quantities.txt', self.mean_ing_quantities)
-            np.savetxt(params['save_path'] + 'std_ing_quantities.txt', self.std_ing_quantities)
-
-        # print(ingredient_quantities[0])
-        # ingredient_quantities = (ingredient_quantities - self.mean_ing_quantities) /  self.std_ing_quantities
-        # print(ingredient_quantities[0])
-        # print(ingredient_quantities[0] * self.std_ing_quantities + self.mean_ing_quantities )
-        ingredient_quantities = ingredient_quantities / max_ing_quantities#= normalize_ing_quantities(ingredient_quantities)
-
-
-
-
-        max_q_per_ing = dict(zip(ingredient_set, max_ing_quantities))
-        # print(ingredient_quantities[0])
-        #########
-        # Process input representation_analysis: list of ingredient representation_analysis
-        #########
-        input_data = []  # input of ingredient encoders
-        all_ing_reps = []
-        for i in range(n_data):
-            ingredients, quantities = extract_ingredients(ingr_strs[i])
-            # get ingredient presence and quantity
-            ingredient_q_rep = np.zeros([len(ingredient_set)])
-            for ing, q in zip(ingredients, quantities):
-                ingredient_q_rep[ingredient_set.index(ing)] = q
-            # get main liquor
-            cocktail_rep = []
-            for j in range(len(ingredients)):
-                cocktail_rep.append(get_representation_from_ingredient(ingredients, quantities, max_q_per_ing, index=j, params=params)[0])
-                all_ing_reps.append(cocktail_rep[-1].copy())
-            input_data.append(cocktail_rep)
-
-
-        all_ing_reps = np.array(all_ing_reps)
-        min_ing_reps = np.min(all_ing_reps[:, params['indexes_ing_to_normalize']], axis=0)
-        max_ing_reps = np.max(all_ing_reps[:, params['indexes_ing_to_normalize']], axis=0)
-
-        def normalize_ing_reps(ing_reps):
-            if ing_reps.ndim == 1:
-                ing_reps = ing_reps.reshape(1, -1)
-            out = ing_reps.copy()
-            out[:, params['indexes_ing_to_normalize']] = (out[:, params['indexes_ing_to_normalize']] - min_ing_reps) / (max_ing_reps - min_ing_reps)
-            return out
-
-        def denormalize_ing_reps(normalized_ing_reps):
-            if normalized_ing_reps.ndim == 1:
-                normalized_ing_reps = normalized_ing_reps.reshape(1, -1)
-            out = normalized_ing_reps.copy()
-            out[:, params['indexes_ing_to_normalize']] = out[:, params['indexes_ing_to_normalize']] * (max_ing_reps - min_ing_reps) + min_ing_reps
-            return out
-
-
-        # put everything in a big matrix
-        dim_cocktail_rep = max_ingredients * self.dim_rep_ingredient
-        input_data2 = []
-        nb_ingredients = []
-        for d in input_data:
-            cocktail_rep = np.zeros([dim_cocktail_rep])
-            cocktail_rep.fill(np.nan)
-            index = 0
-            nb_ingredients.append(len(d))
-            for dj in d:
-                cocktail_rep[index:index + self.dim_rep_ingredient] = normalize_ing_reps(dj)
-                index += self.dim_rep_ingredient
-            input_data2.append(cocktail_rep)
-        input_data = np.array(input_data2)
-        nb_ingredients = np.array(nb_ingredients)
-
-
-
-
-
-        # let us now extract various possible output we might want to predict:
-        #########
-        # Process output cocktail representation_analysis (computed from ingredient reps)
-        #########
-        # quantities_indexes = np.arange(20, 456, 57)
-        # qs = input_data[0, quantities_indexes]
-        # ingredient_quantities[0]
-        # get final volume
-        volumes = np.array(params['raw_data']['end volume'])
-
-        min_vol = volumes.min()
-        max_vol = volumes.max()
-        def normalize_vol(volume):
-            return (volume - min_vol) / (max_vol - min_vol)
-
-        def denormalize_vol(normalized_vol):
-            return normalized_vol * (max_vol - min_vol) + min_vol
-
-        volumes = normalize_vol(volumes)
-
-
-        # computed cocktail representation
-        computed_cocktail_reps = params['cocktail_reps']
-        self.dim_rep = computed_cocktail_reps.shape[1]
-
-        #########
-        # Process output sub categories
-        #########
-        categories = np.array([categories_list.index(sc) for sc in data['subcategory']])
-        counts = dict(zip(categories_list, [0] * len(categories)))
-        for c in data['subcategory']:
-            counts[c] += 1
-        for k in counts.keys():
-            counts[k] /= len(data['subcategory'])
-        self.categories = categories_list
-        self.categories_weights = []
-        for c in self.categories:
-            self.categories_weights.append(1/len(self.categories)/counts[c])
-        print(counts)
-
-        #########
-        # Process output glass type
-        #########
-        glasses = np.array([glasses_list.index(sc) for sc in data['glass']])
-        counts = dict(zip(glasses_list, [0] * len(set(data['glass']))))
-        for c in data['glass']:
-            counts[c] += 1
-        for k in counts.keys():
-            counts[k] /= len(data['glass'])
-        self.glasses = glasses_list
-        self.glasses_weights = []
-        for c in self.glasses:
-            self.glasses_weights.append(1 / len(self.glasses) / counts[c])
-        print(counts)
-
-        #########
-        # Process output preparation type
-        #########
-        prep_type = np.array([preparation_list.index(sc) for sc in data['category']])
-        counts = dict(zip(preparation_list, [0] * len(preparation_list)))
-        for c in data['category']:
-            counts[c] += 1
-        for k in counts.keys():
-            counts[k] /= len(data['category'])
-        self.prep_types = preparation_list
-        self.prep_types_weights = []
-        for c in self.prep_types:
-            self.prep_types_weights.append(1 / len(self.prep_types) / counts[c])
-        print(counts)
-
-        taste_reps = list(data['taste_rep'])
-        taste_rep_ground_truth = []
-        taste_rep_valid = []
-        for tr in taste_reps:
-            if len(tr) > 2:
-                taste_rep_valid.append(True)
-                taste_rep_ground_truth.append([float(tr.split('[')[1].split(',')[0]), float(tr.split(']')[0].split(',')[1][1:])])
-            else:
-                taste_rep_valid.append(False)
-                taste_rep_ground_truth.append([np.nan, np.nan])
-        taste_rep_ground_truth = np.array(taste_rep_ground_truth)
-        taste_rep_valid = np.array(taste_rep_valid)
-        taste_rep_ground_truth /= 10
-
-        auxiliary_data = dict(categories=categories,
-                              glasses=glasses,
-                              prep_type=prep_type,
-                              cocktail_reps=computed_cocktail_reps,
-                              ingredients_presence=ingredients_presence,
-                              taste_reps=taste_rep_ground_truth,
-                              volume=volumes,
-                              ingredients_quantities=ingredient_quantities)
-        self.auxiliary_keys = sorted(params['auxiliaries_dict'].keys())
-        assert self.auxiliary_keys == sorted(auxiliary_data.keys())
-
-        data_preprocessing = dict(min_max_ing_quantities=(min_ing_quantities, max_ing_quantities),
-                                  min_max_ing_reps=(min_ing_reps, max_ing_reps),
-                                  min_max_vol=(min_vol, max_vol))
-
-        if split == 'train':
-            with open(params['save_path'] + 'normalization_funcs.pickle', 'wb') as f:
-                pickle.dump(data_preprocessing, f)
-
-        n_data = len(input_data)
-        assert len(ingredient_quantities) == n_data
-        for aux in self.auxiliary_keys:
-            assert len(auxiliary_data[aux]) == n_data
-
-        if split == 'train':
-            indexes = np.arange(int(0.9 * n_data))
-        elif split == 'test':
-            indexes = np.arange(int(0.9 * n_data), n_data)
-        elif split == 'all':
-            indexes = np.arange(n_data)
-        else:
-            raise ValueError
-
-        # np.random.shuffle(indexes)
-        self.taste_rep_valid = taste_rep_valid[indexes]
-        self.input_ingredients = input_data[indexes]
-        self.ingredient_quantities = ingredient_quantities[indexes]
-        self.computed_cocktail_reps = computed_cocktail_reps[indexes]
-        self.auxiliaries = dict()
-        for aux in self.auxiliary_keys:
-            self.auxiliaries[aux] = auxiliary_data[aux][indexes]
-        self.nb_ingredients = nb_ingredients[indexes]
-
-    def __len__(self):
-        return len(self.input_ingredients)
-
-    def get_auxiliary_data(self, idx):
-        out = dict()
-        for aux in self.auxiliary_keys:
-            out[aux] = self.auxiliaries[aux][idx]
-        return out
-
-    def __getitem__(self, idx):
-        assert self.nb_ingredients[idx] == np.argwhere(~np.isnan(self.input_ingredients[idx])).flatten().size / self.dim_rep_ingredient
-        return [self.nb_ingredients[idx], self.input_ingredients[idx], self.ingredient_quantities[idx], self.computed_cocktail_reps[idx], self.get_auxiliary_data(idx),
-                self.taste_rep_valid[idx]]

src/cocktails/representation_learning/multihead_model.py

@@ -1,148 +0,0 @@
-import torch; torch.manual_seed(0)
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils
-import torch.distributions
-import matplotlib.pyplot as plt; plt.rcParams['figure.dpi'] = 200
-from src.cocktails.representation_learning.simple_model import SimpleNet
-
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-def get_activation(activation):
-    if activation == 'tanh':
-        activ = F.tanh
-    elif activation == 'relu':
-        activ = F.relu
-    elif activation == 'mish':
-        activ = F.mish
-    elif activation == 'sigmoid':
-        activ = F.sigmoid
-    elif activation == 'leakyrelu':
-        activ = F.leaky_relu
-    elif activation == 'exp':
-        activ = torch.exp
-    else:
-        raise ValueError
-    return activ
-
-class IngredientEncoder(nn.Module):
-    def __init__(self, input_dim, deepset_latent_dim, hidden_dims, activation, dropout):
-        super(IngredientEncoder, self).__init__()
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        dims = [input_dim] + hidden_dims + [deepset_latent_dim]
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-
-    def forward(self, x):
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = layer(x)
-            if i_layer != self.n_layers - 1:
-                x = self.activation(dropout(x))
-        return x  # do not use dropout on last layer?
-
-class DeepsetCocktailEncoder(nn.Module):
-    def __init__(self, input_dim, deepset_latent_dim, hidden_dims_ing, activation,
-                 hidden_dims_cocktail, latent_dim, aggregation, dropout):
-        super(DeepsetCocktailEncoder, self).__init__()
-        self.input_dim = input_dim  # dimension of ingredient representation + quantity
-        self.ingredient_encoder = IngredientEncoder(input_dim, deepset_latent_dim, hidden_dims_ing, activation, dropout)  # encode each ingredient separately
-        self.deepset_latent_dim = deepset_latent_dim  # dimension of the deepset aggregation
-        self.aggregation = aggregation
-        self.latent_dim = latent_dim
-        # post aggregation network
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        dims = [deepset_latent_dim] + hidden_dims_cocktail
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.FC_mean  = nn.Linear(hidden_dims_cocktail[-1], latent_dim)
-        self.FC_logvar   = nn.Linear(hidden_dims_cocktail[-1], latent_dim)
-        self.softplus = nn.Softplus()
-
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-
-    def forward(self, nb_ingredients, x):
-
-        # reshape x in (batch size * nb ingredients, dim_ing_rep)
-        batch_size = x.shape[0]
-        all_ingredients = []
-        for i in range(batch_size):
-            for j in range(nb_ingredients[i]):
-                all_ingredients.append(x[i, self.input_dim * j: self.input_dim * (j + 1)].reshape(1, -1))
-        x = torch.cat(all_ingredients, dim=0)
-        # encode ingredients in parallel
-        ingredients_encodings = self.ingredient_encoder(x)
-        assert ingredients_encodings.shape == (torch.sum(nb_ingredients), self.deepset_latent_dim)
-
-        # aggregate
-        x = []
-        index_first = 0
-        for i in range(batch_size):
-            index_last = index_first + nb_ingredients[i]
-            # aggregate
-            if self.aggregation == 'sum':
-                x.append(torch.sum(ingredients_encodings[index_first:index_last], dim=0).reshape(1, -1))
-            elif self.aggregation == 'mean':
-                x.append(torch.mean(ingredients_encodings[index_first:index_last], dim=0).reshape(1, -1))
-            else:
-                raise ValueError
-            index_first = index_last
-        x = torch.cat(x, dim=0)
-        assert x.shape[0] == batch_size
-
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = self.activation(dropout(layer(x)))
-        mean = self.FC_mean(x)
-        logvar = self.FC_logvar(x)
-        return mean, logvar
-
-
-class MultiHeadModel(nn.Module):
-    def __init__(self, encoder, auxiliaries_dict, activation, hidden_dims_decoder):
-        super(MultiHeadModel, self).__init__()
-        self.encoder = encoder
-        self.latent_dim = self.encoder.output_dim
-        self.auxiliaries_str = []
-        self.auxiliaries = nn.ModuleList()
-        for aux_str in sorted(auxiliaries_dict.keys()):
-            if aux_str == 'taste_reps':
-                self.taste_reps_decoder = SimpleNet(input_dim=self.latent_dim, hidden_dims=[], output_dim=auxiliaries_dict[aux_str]['dim_output'],
-                                                    activation=activation, dropout=0.0, final_activ=auxiliaries_dict[aux_str]['final_activ'])
-            else:
-                self.auxiliaries_str.append(aux_str)
-                if aux_str == 'ingredients_quantities':
-                    hd = hidden_dims_decoder
-                else:
-                    hd = []
-                self.auxiliaries.append(SimpleNet(input_dim=self.latent_dim, hidden_dims=hd, output_dim=auxiliaries_dict[aux_str]['dim_output'],
-                                                  activation=activation, dropout=0.0, final_activ=auxiliaries_dict[aux_str]['final_activ']))
-
-    def get_all_auxiliaries(self, x):
-        return [aux(x) for aux in self.auxiliaries]
-
-    def get_auxiliary(self, z, aux_str):
-        if aux_str == 'taste_reps':
-            return self.taste_reps_decoder(z)
-        else:
-            index = self.auxiliaries_str.index(aux_str)
-            return self.auxiliaries[index](z)
-
-    def forward(self, x, aux_str=None):
-        z = self.encoder(x)
-        if aux_str is not None:
-            return z, self.get_auxiliary(z, aux_str), [aux_str]
-        else:
-            return z, self.get_all_auxiliaries(z), self.auxiliaries_str
-
-def get_multihead_model(input_dim, activation, hidden_dims_cocktail, latent_dim, dropout, auxiliaries_dict, hidden_dims_decoder):
-    encoder = SimpleNet(input_dim, hidden_dims_cocktail, latent_dim, activation, dropout)
-    model = MultiHeadModel(encoder, auxiliaries_dict, activation, hidden_dims_decoder)
-    return model

src/cocktails/representation_learning/run.py

@@ -1,557 +0,0 @@
-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)
-

src/cocktails/representation_learning/run_simple_net.py

@@ -1,302 +0,0 @@
-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.simple_model import SimpleNet
-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 + "/simple_net/",
-                  nb_epochs=100,
-                  print_every=50,
-                  plot_every=50,
-                  batch_size=128,
-                  lr=0.001,
-                  dropout=0.15,
-                  output_keyword='glasses',
-                  ing_keys=ing_keys,
-                  nb_ingredients=len(ingredient_set),
-                  hidden_dims=[16],
-                  activation='sigmoid',
-                  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),
-                                        ingredients_quantities=dict(weight=0, type='regression', final_activ=None, dim_output=num_ingredients)),
-
-                  category_encodings=category_encodings
-                  )
-    params['output_dim'] = params['auxiliaries_dict'][params['output_keyword']]['dim_output']
-    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['dim_rep_ingredient'] = dim_rep_ingredient
-    params['input_dim'] = params['nb_ingredients']
-    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_confusion_matrix_and_accuracy(predictions, ground_truth):
-    bs, n_options = predictions.shape
-    predicted = predictions.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()
-    acc2 = np.mean(predicted == true)
-    assert (acc - acc2) < 1e-5
-    return confusion_matrix, acc
-
-
-def run_epoch(opt, train, model, data, loss_function, params):
-    if train:
-        model.train()
-    else:
-        model.eval()
-
-    # prepare logging of losses
-    losses = []
-    accuracies = []
-    cf_matrices = []
-    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].float()
-        cocktail_reps = d[3].float()
-        auxiliaries = d[4]
-        for k in auxiliaries.keys():
-            if auxiliaries[k].dtype == torch.float64: auxiliaries[k] = auxiliaries[k].float()
-        taste_valid = d[-1]
-        predictions = model(ingredient_quantities)
-        loss = loss_function(predictions, auxiliaries[params['output_keyword']].long()).float()
-        cf_matrix, accuracy = compute_confusion_matrix_and_accuracy(predictions, auxiliaries[params['output_keyword']])
-        if train:
-            loss.backward()
-            opt.step()
-            opt.zero_grad()
-
-        losses.append(float(loss))
-        cf_matrices.append(cf_matrix)
-        accuracies.append(accuracy)
-
-    return model, np.mean(losses), np.mean(accuracies), np.mean(cf_matrices, axis=0)
-
-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)
-
-
-    if params['auxiliaries_dict'][params['output_keyword']]['type'] == 'classif':
-        if params['output_keyword'] == 'glasses':
-            classif_weights = train_data.glasses_weights
-        elif params['output_keyword'] == 'prep_type':
-            classif_weights = train_data.prep_types_weights
-        elif params['output_keyword'] == 'categories':
-            classif_weights = train_data.categories_weights
-        else:
-            raise ValueError
-        # classif_weights = (np.array(classif_weights) * 2 + np.ones(len(classif_weights))) / 3
-        loss_function = nn.CrossEntropyLoss(torch.FloatTensor(classif_weights))
-        # loss_function = nn.CrossEntropyLoss()
-
-    elif params['auxiliaries_dict'][params['output_keyword']]['type'] == 'multiclassif':
-        loss_function = nn.BCEWithLogitsLoss()
-    elif params['auxiliaries_dict'][params['output_keyword']]['type'] == 'regression':
-        loss_function = nn.MSELoss()
-    else:
-        raise ValueError
-
-    return loss_function, train_data_loader, test_data_loader
-
-def print_losses(train, loss, accuracy):
-    keyword = 'Train' if train else 'Eval'
-    print(f'\t{keyword} logs:')
-    print(f'\t\t Loss: {loss:.2f}, Acc: {accuracy:.2f}')
-
-
-def run_experiment(params, verbose=True):
-    loss_function, train_data_loader, test_data_loader = prepare_data_and_loss(params)
-
-    model = SimpleNet(params['input_dim'], params['hidden_dims'], params['output_dim'], params['activation'], params['dropout'])
-    opt = torch.optim.AdamW(model.parameters(), lr=params['lr'])
-
-    all_train_losses = []
-    all_eval_losses = []
-    all_eval_cf_matrices = []
-    all_train_accuracies = []
-    all_eval_accuracies = []
-    all_train_cf_matrices = []
-    best_loss = np.inf
-    model, eval_loss, eval_accuracy, eval_cf_matrix = run_epoch(opt=opt, train=False, model=model, data=test_data_loader, loss_function=loss_function,  params=params)
-    all_eval_losses.append(eval_loss)
-    all_eval_accuracies.append(eval_accuracy)
-    if verbose: print(f'\n--------\nEpoch #0')
-    if verbose: print_losses(train=False, accuracy=eval_accuracy, loss=eval_loss)
-    for epoch in range(params['nb_epochs']):
-        if verbose and (epoch + 1) % params['print_every'] == 0: print(f'\n--------\nEpoch #{epoch+1}')
-        model, train_loss, train_accuracy, train_cf_matrix = run_epoch(opt=opt, train=True, model=model, data=train_data_loader, loss_function=loss_function, params=params)
-        if verbose and (epoch + 1) % params['print_every'] == 0: print_losses(train=True, accuracy=train_accuracy, loss=train_loss)
-        model, eval_loss, eval_accuracy, eval_cf_matrix = run_epoch(opt=opt, train=False, model=model, data=test_data_loader, loss_function=loss_function, params=params)
-        if verbose and (epoch + 1) % params['print_every'] == 0: print_losses(train=False, accuracy=eval_accuracy, loss=eval_loss)
-        if eval_loss < best_loss:
-            best_loss = eval_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_loss)
-        all_train_accuracies.append(train_accuracy)
-        all_eval_losses.append(eval_loss)
-        all_eval_accuracies.append(eval_accuracy)
-        all_eval_cf_matrices.append(eval_cf_matrix)
-        all_train_cf_matrices.append(train_cf_matrix)
-
-        if (epoch + 1) % params['plot_every'] == 0:
-
-            plot_results(all_train_losses, all_train_accuracies, all_train_cf_matrices,
-                         all_eval_losses, all_eval_accuracies, all_eval_cf_matrices, params['plot_path'])
-
-    return model
-
-def plot_results(all_train_losses, all_train_accuracies, all_train_cf_matrices,
-                 all_eval_losses, all_eval_accuracies, all_eval_cf_matrices, plot_path):
-
-    steps = np.arange(len(all_eval_accuracies))
-
-    plt.figure()
-    plt.title('Losses')
-    plt.plot(steps[1:], all_train_losses, label='train')
-    plt.plot(steps, all_eval_losses, label='eval')
-    plt.legend()
-    plt.ylim([0, 4])
-    plt.savefig(plot_path + 'losses.png', dpi=200)
-    fig = plt.gcf()
-    plt.close(fig)
-
-    plt.figure()
-    plt.title('Accuracies')
-    plt.plot(steps[1:], all_train_accuracies, label='train')
-    plt.plot(steps, all_eval_accuracies, label='eval')
-    plt.legend()
-    plt.ylim([0, 1])
-    plt.savefig(plot_path + 'accs.png', dpi=200)
-    fig = plt.gcf()
-    plt.close(fig)
-
-
-    plt.figure()
-    plt.title('Train confusion matrix')
-    plt.ylabel('True')
-    plt.xlabel('Predicted')
-    plt.imshow(all_train_cf_matrices[-1], vmin=0, vmax=1)
-    plt.colorbar()
-    plt.savefig(plot_path + f'train_confusion_matrix.png', dpi=200)
-    fig = plt.gcf()
-    plt.close(fig)
-
-    plt.figure()
-    plt.title('Eval confusion matrix')
-    plt.ylabel('True')
-    plt.xlabel('Predicted')
-    plt.imshow(all_eval_cf_matrices[-1], vmin=0, vmax=1)
-    plt.colorbar()
-    plt.savefig(plot_path + f'eval_confusion_matrix.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
-    model_chkpt = model_path + "checkpoint_best.save"
-    model = SimpleNet(params['input_dim'], params['hidden_dims'], params['output_dim'], params['activation'], params['dropout'])
-    model.load_state_dict(torch.load(model_chkpt))
-    model.eval()
-    return model, 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'_bs{params["batch_size"]}'
-    save_path += f'_hd{params["hidden_dims"]}'
-    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)
-

src/cocktails/representation_learning/run_without_vae.py

@@ -1,514 +0,0 @@
-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.multihead_model import get_multihead_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 + "/multihead_model/",
-                  nb_epochs=500,
-                  print_every=50,
-                  plot_every=50,
-                  batch_size=128,
-                  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=[64],
-                  hidden_dims_decoder=[32],
-                  agg='mean',
-                  activation='relu',
-                  auxiliaries_dict=dict(categories=dict(weight=5, type='classif', final_activ=None, dim_output=len(set(data['subcategory']))), #0.5
-                                        glasses=dict(weight=0.5, type='classif', final_activ=None, dim_output=len(set(data['glass']))), #0.1
-                                        prep_type=dict(weight=0.1, type='classif', final_activ=None, dim_output=len(set(data['category']))),#1
-                                        cocktail_reps=dict(weight=1, type='regression', final_activ=None, dim_output=13),#1
-                                        volume=dict(weight=1, type='regression', final_activ='relu',  dim_output=1),#1
-                                        taste_reps=dict(weight=1, type='regression', final_activ='relu', dim_output=2),#1
-                                        ingredients_presence=dict(weight=0, type='multiclassif', final_activ=None, dim_output=num_ingredients),#10
-                                        ingredients_quantities=dict(weight=0, type='regression', 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['dim_rep_ingredient'] = dim_rep_ingredient
-    params['input_dim'] = params['nb_ingredients']
-    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()
-    # 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]
-        z, outputs, auxiliaries_str = model.forward(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
-        aux_other_metrics = compute_metric_output(aux_other_metrics, data, ingredient_quantities, outputs[auxiliaries_str.index('ingredients_quantities')])
-
-        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(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))
-        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)
-
-    model_params = [params[k] for k in ["input_dim", "activation", "hidden_dims_cocktail", "latent_dim", "dropout", "auxiliaries_dict", "hidden_dims_decoder"]]
-    model = get_multihead_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.ylim([0, 15])
-    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.ylim([0, 15])
-    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
-    model_chkpt = model_path + "checkpoint_best.save"
-    model_params = [params[k] for k in ["input_dim", "activation", "hidden_dims_cocktail", "latent_dim", "dropout", "auxiliaries_dict", "hidden_dims_decoder"]]
-    model = get_multihead_model(*model_params)
-    model.load_state_dict(torch.load(model_chkpt))
-    model.eval()
-    max_ing_quantities = np.loadtxt(model_path + 'max_ing_quantities.txt')
-    def predict(ing_qs, aux_str):
-        ing_qs /= max_ing_quantities
-        input_model = torch.FloatTensor(ing_qs).reshape(1, -1)
-        _, outputs, auxiliaries_str = model.forward(input_model, )
-        if isinstance(aux_str, str):
-            return outputs[auxiliaries_str.index(aux_str)].detach().numpy()
-        elif isinstance(aux_str, list):
-            return [outputs[auxiliaries_str.index(aux)].detach().numpy() for aux in aux_str]
-        else:
-            raise ValueError
-    return predict, 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)
-

src/cocktails/representation_learning/simple_model.py

@@ -1,54 +0,0 @@
-import torch; torch.manual_seed(0)
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils
-import torch.distributions
-import matplotlib.pyplot as plt; plt.rcParams['figure.dpi'] = 200
-
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-def get_activation(activation):
-    if activation == 'tanh':
-        activ = F.tanh
-    elif activation == 'relu':
-        activ = F.relu
-    elif activation == 'mish':
-        activ = F.mish
-    elif activation == 'sigmoid':
-        activ = torch.sigmoid
-    elif activation == 'leakyrelu':
-        activ = F.leaky_relu
-    elif activation == 'exp':
-        activ = torch.exp
-    else:
-        raise ValueError
-    return activ
-
-
-class SimpleNet(nn.Module):
-    def __init__(self, input_dim, hidden_dims, output_dim, activation, dropout, final_activ=None):
-        super(SimpleNet, self).__init__()
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        self.output_dim = output_dim
-        dims = [input_dim] + hidden_dims + [output_dim]
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-        if final_activ != None:
-            self.final_activ = get_activation(final_activ)
-            self.use_final_activ = True
-        else:
-            self.use_final_activ = False
-
-    def forward(self, x):
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = layer(x)
-            if i_layer != self.n_layers - 1:
-                x = self.activation(dropout(x))
-        if self.use_final_activ: x = self.final_activ(x)
-        return x
-

src/cocktails/representation_learning/vae_model.py

@@ -1,238 +0,0 @@
-import torch; torch.manual_seed(0)
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils
-import torch.distributions
-import matplotlib.pyplot as plt; plt.rcParams['figure.dpi'] = 200
-
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-def get_activation(activation):
-    if activation == 'tanh':
-        activ = F.tanh
-    elif activation == 'relu':
-        activ = F.relu
-    elif activation == 'mish':
-        activ = F.mish
-    elif activation == 'sigmoid':
-        activ = F.sigmoid
-    elif activation == 'leakyrelu':
-        activ = F.leaky_relu
-    elif activation == 'exp':
-        activ = torch.exp
-    else:
-        raise ValueError
-    return activ
-
-class IngredientEncoder(nn.Module):
-    def __init__(self, input_dim, deepset_latent_dim, hidden_dims, activation, dropout):
-        super(IngredientEncoder, self).__init__()
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        dims = [input_dim] + hidden_dims + [deepset_latent_dim]
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-
-    def forward(self, x):
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = layer(x)
-            if i_layer != self.n_layers - 1:
-                x = self.activation(dropout(x))
-        return x  # do not use dropout on last layer?
-
-class DeepsetCocktailEncoder(nn.Module):
-    def __init__(self, input_dim, deepset_latent_dim, hidden_dims_ing, activation,
-                 hidden_dims_cocktail, latent_dim, aggregation, dropout):
-        super(DeepsetCocktailEncoder, self).__init__()
-        self.input_dim = input_dim  # dimension of ingredient representation + quantity
-        self.ingredient_encoder = IngredientEncoder(input_dim, deepset_latent_dim, hidden_dims_ing, activation, dropout)  # encode each ingredient separately
-        self.deepset_latent_dim = deepset_latent_dim  # dimension of the deepset aggregation
-        self.aggregation = aggregation
-        self.latent_dim = latent_dim
-        # post aggregation network
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        dims = [deepset_latent_dim] + hidden_dims_cocktail
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.FC_mean  = nn.Linear(hidden_dims_cocktail[-1], latent_dim)
-        self.FC_logvar   = nn.Linear(hidden_dims_cocktail[-1], latent_dim)
-        self.softplus = nn.Softplus()
-
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-
-    def forward(self, nb_ingredients, x):
-
-        # reshape x in (batch size * nb ingredients, dim_ing_rep)
-        batch_size = x.shape[0]
-        all_ingredients = []
-        for i in range(batch_size):
-            for j in range(nb_ingredients[i]):
-                all_ingredients.append(x[i, self.input_dim * j: self.input_dim * (j + 1)].reshape(1, -1))
-        x = torch.cat(all_ingredients, dim=0)
-        # encode ingredients in parallel
-        ingredients_encodings = self.ingredient_encoder(x)
-        assert ingredients_encodings.shape == (torch.sum(nb_ingredients), self.deepset_latent_dim)
-
-        # aggregate
-        x = []
-        index_first = 0
-        for i in range(batch_size):
-            index_last = index_first + nb_ingredients[i]
-            # aggregate
-            if self.aggregation == 'sum':
-                x.append(torch.sum(ingredients_encodings[index_first:index_last], dim=0).reshape(1, -1))
-            elif self.aggregation == 'mean':
-                x.append(torch.mean(ingredients_encodings[index_first:index_last], dim=0).reshape(1, -1))
-            else:
-                raise ValueError
-            index_first = index_last
-        x = torch.cat(x, dim=0)
-        assert x.shape[0] == batch_size
-
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = self.activation(dropout(layer(x)))
-        mean = self.FC_mean(x)
-        logvar = self.FC_logvar(x)
-        return mean, logvar
-
-class Decoder(nn.Module):
-    def __init__(self, latent_dim, hidden_dims, num_ingredients, activation, dropout, filter_output=None):
-        super(Decoder, self).__init__()
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        dims = [latent_dim] + hidden_dims + [num_ingredients]
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-        self.filter = filter_output
-
-    def forward(self, x, to_filter=False):
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = layer(x)
-            if i_layer != self.n_layers - 1:
-                x = self.activation(dropout(x))
-        if to_filter:
-            x = self.filter(x)
-        return x
-
-class PredictorHead(nn.Module):
-    def __init__(self, latent_dim, dim_output, final_activ):
-        super(PredictorHead, self).__init__()
-        self.linear = nn.Linear(latent_dim, dim_output)
-        if final_activ != None:
-            self.final_activ = get_activation(final_activ)
-            self.use_final_activ = True
-        else:
-            self.use_final_activ = False
-
-    def forward(self, x):
-        x = self.linear(x)
-        if self.use_final_activ: x = self.final_activ(x)
-        return x
-
-
-class VAEModel(nn.Module):
-    def __init__(self, encoder, decoder, auxiliaries_dict):
-        super(VAEModel, self).__init__()
-        self.encoder = encoder
-        self.decoder = decoder
-        self.latent_dim = self.encoder.latent_dim
-        self.auxiliaries_str = []
-        self.auxiliaries = nn.ModuleList()
-        for aux_str in sorted(auxiliaries_dict.keys()):
-            if aux_str == 'taste_reps':
-                self.taste_reps_decoder = PredictorHead(self.latent_dim, auxiliaries_dict[aux_str]['dim_output'], auxiliaries_dict[aux_str]['final_activ'])
-            else:
-                self.auxiliaries_str.append(aux_str)
-                self.auxiliaries.append(PredictorHead(self.latent_dim, auxiliaries_dict[aux_str]['dim_output'], auxiliaries_dict[aux_str]['final_activ']))
-
-    def reparameterization(self, mean, logvar):
-        std = torch.exp(0.5 * logvar)
-        epsilon = torch.randn_like(std).to(device)        # sampling epsilon
-        z = mean + std * epsilon                          # reparameterization trick
-        return z
-
-
-    def sample(self, n=1):
-        z = torch.randn(size=(n, self.latent_dim))
-        return self.decoder(z)
-
-    def get_all_auxiliaries(self, x):
-        return [aux(x) for aux in self.auxiliaries]
-
-    def get_auxiliary(self, z, aux_str):
-        if aux_str == 'taste_reps':
-            return self.taste_reps_decoder(z)
-        else:
-            index = self.auxiliaries_str.index(aux_str)
-            return self.auxiliaries[index](z)
-
-    def forward_direct(self, x, aux_str=None, to_filter=False):
-        mean, logvar = self.encoder(x)
-        z = self.reparameterization(mean, logvar)  # takes exponential function (log var -> std)
-        x_hat = self.decoder(mean, to_filter=to_filter)
-        if aux_str is not None:
-            return x_hat, z, mean, logvar, self.get_auxiliary(z, aux_str), [aux_str]
-        else:
-            return x_hat, z, mean, logvar, self.get_all_auxiliaries(z), self.auxiliaries_str
-
-    def forward(self, nb_ingredients, x, aux_str=None, to_filter=False):
-        assert False
-        mean, std = self.encoder(nb_ingredients, x)
-        z = self.reparameterization(mean, std)  # takes exponential function (log var -> std)
-        x_hat = self.decoder(mean, to_filter=to_filter)
-        if aux_str is not None:
-            return x_hat, z, mean, std, self.get_auxiliary(z, aux_str), [aux_str]
-        else:
-            return x_hat, z, mean, std, self.get_all_auxiliaries(z), self.auxiliaries_str
-
-
-
-
-class SimpleEncoder(nn.Module):
-
-    def __init__(self, input_dim, hidden_dims, latent_dim, activation, dropout):
-        super(SimpleEncoder, self).__init__()
-        self.latent_dim = latent_dim
-        # post aggregation network
-        self.linears = nn.ModuleList()
-        self.dropouts = nn.ModuleList()
-        dims = [input_dim] + hidden_dims
-        for d_in, d_out in zip(dims[:-1], dims[1:]):
-            self.linears.append(nn.Linear(d_in, d_out))
-            self.dropouts.append(nn.Dropout(dropout))
-        self.FC_mean = nn.Linear(hidden_dims[-1], latent_dim)
-        self.FC_logvar = nn.Linear(hidden_dims[-1], latent_dim)
-        # self.softplus = nn.Softplus()
-
-        self.activation = get_activation(activation)
-        self.n_layers = len(self.linears)
-        self.layer_range = range(self.n_layers)
-
-    def forward(self, x):
-        for i_layer, layer, dropout in zip(self.layer_range, self.linears, self.dropouts):
-            x = self.activation(dropout(layer(x)))
-        mean = self.FC_mean(x)
-        logvar = self.FC_logvar(x)
-        return mean, logvar
-
-def get_vae_model(input_dim, deepset_latent_dim, hidden_dims_ing, activation,
-                  hidden_dims_cocktail, hidden_dims_decoder, num_ingredients, latent_dim, aggregation, dropout, auxiliaries_dict,
-                  filter_decoder_output):
-    # encoder = DeepsetCocktailEncoder(input_dim, deepset_latent_dim, hidden_dims_ing, activation,
-    #                                  hidden_dims_cocktail, latent_dim, aggregation, dropout)
-    encoder = SimpleEncoder(num_ingredients, hidden_dims_cocktail, latent_dim, activation, dropout)
-    decoder = Decoder(latent_dim, hidden_dims_decoder, num_ingredients, activation, dropout, filter_output=filter_decoder_output)
-    vae = VAEModel(encoder, decoder, auxiliaries_dict)
-    return vae

src/cocktails/utilities/analysis_utilities.py

@@ -1,189 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-
-from src.cocktails.utilities.ingredients_utilities import ingredient_list, extract_ingredients, ingredients_per_type
-
-color_codes = dict(ancestral='#000000',
-                   spirit_forward='#2320D2',
-                   duo='#6E20D2',
-                   champagne_cocktail='#25FFCA',
-                   complex_highball='#068F25',
-                   simple_highball='#25FF57',
-                   collins='#77FF96',
-                   julep='#25B8FF',
-                   simple_sour='#FBD756',
-                   complex_sour='#DCAD07',
-                   simple_sour_with_juice='#FF5033',
-                   complex_sour_with_juice='#D42306',
-                   # simple_sour_with_egg='#FF9C54',
-                   # complex_sour_with_egg='#CF5700',
-                   # almost_simple_sor='#FF5033',
-                   # almost_sor='#D42306',
-                   # almost_sor_with_egg='#D42306',
-                   other='#9B9B9B'
-                   )
-
-def get_subcategories(data):
-    subcategories = np.array(data['subcategory'])
-    sub_categories_list = sorted(set(subcategories))
-    subcat_count = dict(zip(sub_categories_list, [0] * len(sub_categories_list)))
-    for sc in data['subcategory']:
-        subcat_count[sc] += 1
-    return subcategories, sub_categories_list, subcat_count
-
-def get_ingredient_count(data):
-    ingredient_counts = dict(zip(ingredient_list, [0] * len(ingredient_list)))
-    for ing_str in data['ingredients_str']:
-        ingredients, _ = extract_ingredients(ing_str)
-        for ing in ingredients:
-            ingredient_counts[ing] += 1
-    return ingredient_counts
-
-def compute_eucl_dist(a, b):
-    return np.sqrt(np.sum((a - b)**2))
-
-def recipe_contains(ingredients, stuff):
-    if stuff in ingredient_list:
-        return stuff in ingredients
-    elif stuff == 'juice':
-        return any(['juice' in ing and 'lemon' not in ing and 'lime' not in ing for ing in ingredients])
-    elif stuff == 'bubbles':
-        return any([ing in ['soda', 'tonic', 'cola', 'sparkling wine', 'ginger beer'] for ing in ingredients])
-    elif stuff == 'acid':
-        return any([ing in ['lemon juice', 'lime juice'] for ing in ingredients])
-    elif stuff == 'vermouth':
-        return any([ing in ingredients_per_type['vermouth'] for ing in ingredients])
-    elif stuff == 'plain sweet':
-        plain_sweet = ingredients_per_type['sweeteners']
-        return any([ing in plain_sweet for ing in ingredients])
-    elif stuff == 'sweet':
-        sweet = ingredients_per_type['sweeteners'] + ingredients_per_type['liqueur'] + ['sweet vermouth', 'lillet blanc']
-        return any([ing in sweet for ing in ingredients])
-    elif stuff == 'spirit':
-        return any([ing in ingredients_per_type['liquor'] for ing in ingredients])
-    else:
-        raise ValueError
-
-
-
-def radar_factory(num_vars, frame='circle'):
-    # from stackoverflow's post? Or matplotlib's blog
-    """
-    Create a radar chart with `num_vars` axes.
-
-    This function creates a RadarAxes projection and registers it.
-
-    Parameters
-    ----------
-    num_vars : int
-        Number of variables for radar chart.
-    frame : {'circle', 'polygon'}
-        Shape of frame surrounding axes.
-
-    """
-    import numpy as np
-
-    from matplotlib.patches import Circle, RegularPolygon
-    from matplotlib.path import Path
-    from matplotlib.projections.polar import PolarAxes
-    from matplotlib.projections import register_projection
-    from matplotlib.spines import Spine
-    from matplotlib.transforms import Affine2D
-    # calculate evenly-spaced axis angles
-    theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)
-
-    class RadarAxes(PolarAxes):
-
-        name = 'radar'
-        # use 1 line segment to connect specified points
-        RESOLUTION = 1
-
-        def __init__(self, *args, **kwargs):
-            super().__init__(*args, **kwargs)
-            # rotate plot such that the first axis is at the top
-            self.set_theta_zero_location('N')
-
-        def fill(self, *args, closed=True, **kwargs):
-            """Override fill so that line is closed by default"""
-            return super().fill(closed=closed, *args, **kwargs)
-
-        def plot(self, *args, **kwargs):
-            """Override plot so that line is closed by default"""
-            lines = super().plot(*args, **kwargs)
-            for line in lines:
-                self._close_line(line)
-
-        def _close_line(self, line):
-            x, y = line.get_data()
-            # FIXME: markers at x[0], y[0] get doubled-up
-            if x[0] != x[-1]:
-                x = np.append(x, x[0])
-                y = np.append(y, y[0])
-                line.set_data(x, y)
-
-        def set_varlabels(self, labels):
-            self.set_thetagrids(np.degrees(theta), labels)
-
-        def _gen_axes_patch(self):
-            # The Axes patch must be centered at (0.5, 0.5) and of radius 0.5
-            # in axes coordinates.
-            if frame == 'circle':
-                return Circle((0.5, 0.5), 0.5)
-            elif frame == 'polygon':
-                return RegularPolygon((0.5, 0.5), num_vars,
-                                      radius=.5, edgecolor="k")
-            else:
-                raise ValueError("Unknown value for 'frame': %s" % frame)
-
-        def _gen_axes_spines(self):
-            if frame == 'circle':
-                return super()._gen_axes_spines()
-            elif frame == 'polygon':
-                # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'.
-                spine = Spine(axes=self,
-                              spine_type='circle',
-                              path=Path.unit_regular_polygon(num_vars))
-                # unit_regular_polygon gives a polygon of radius 1 centered at
-                # (0, 0) but we want a polygon of radius 0.5 centered at (0.5,
-                # 0.5) in axes coordinates.
-                spine.set_transform(Affine2D().scale(.5).translate(.5, .5)
-                                    + self.transAxes)
-                return {'polar': spine}
-            else:
-                raise ValueError("Unknown value for 'frame': %s" % frame)
-
-    register_projection(RadarAxes)
-    return theta
-
-def plot_radar_cocktail(representation, labels_dim, labels_cocktails, save_path=None, to_show=False, to_save=False):
-    assert to_show or to_save, 'either show or save'
-    assert representation.ndim == 2
-    n_data, dim_rep = representation.shape
-    assert len(labels_cocktails) == n_data
-    assert len(labels_dim) == dim_rep
-    assert n_data <= 5, 'max 5 representation_analysis please'
-
-    theta = radar_factory(dim_rep, frame='circle')
-
-
-    fig, ax = plt.subplots(figsize=(9, 9), subplot_kw=dict(projection='radar'))
-    fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05)
-
-    colors = ['b', 'r', 'g', 'm', 'y']
-    # Plot the four cases from the example data on separate axes
-    ax.set_rgrids([0.2, 0.4, 0.6, 0.8])
-    for d, color in zip(representation, colors):
-        ax.plot(theta, d, color=color)
-    for d, color in zip(representation, colors):
-        ax.fill(theta, d, facecolor=color, alpha=0.25)
-    ax.set_varlabels(labels_dim)
-
-    # add legend relative to top-left plot
-    legend = ax.legend(labels_cocktails, loc=(0.9, .95),
-                       labelspacing=0.1, fontsize='small')
-
-    if to_save:
-        plt.savefig(save_path, bbox_artists=(legend,), dpi=200)
-    else:
-        plt.show()
-

src/cocktails/utilities/cocktail_category_detection_utilities.py

@@ -1,221 +0,0 @@
-# The following functions check whether a cocktail belong to any of N categories
-import numpy as np
-from src.cocktails.utilities.ingredients_utilities import ingredient_profiles, ingredients_per_type, ingredient2ingredient_id, extract_ingredients
-
-
-def is_ancestral(n, ingredient_indexes, ingredients, quantities):
-    # ancestrals have a strong spirit and some sweetness from sugar, syrup or liqueurs, no citrus.
-    # absinthe can be added up to 3 dashes.
-    # Liqueurs are there to bring sweetness, thus must stay below 15ml (if not it's a duo)
-    if n['spirit'] > 0 and n['citrus'] == 0 and n['plain_sweet'] + n['liqueur'] <= 2:
-        if n['spirit'] > 1 and 'absinthe' in ingredients:
-            if quantities[ingredients.index('absinthe')] < 3:
-                pass
-            else:
-                return False
-        if n['sugar'] < 2 and n['liqueur'] < 3:
-            if n['all'] - n['spirit'] - n['sugar'] -n['syrup']- n['liqueur']- n['inconsequentials'] == 0:
-                if n['liqueur'] == 0:
-                    return True
-                else:
-                    q_liqueur = np.sum([quantities[i_ing]
-                                        for i_ind, i_ing in zip(ingredient_indexes, range(len(ingredients)))
-                                        if ingredient_profiles['type'][i_ind].lower() == 'liqueur'])
-                if q_liqueur <= 15:
-                    return True
-                else:
-                    return False
-    return False
-
-
-def is_simple_sour(n, ingredient_indexes, ingredients, quantities):
-    # simple sours contain a citrus, at least 1 spirit and non-alcoholic sweetness
-    if n['citrus'] + n['coffee']> 0 and n['spirit'] > 0 and n['plain_sweet'] > 0  and n['juice'] == 0:
-        if n['all'] - n['citrus'] - n['coffee'] - n['spirit'] - n['plain_sweet'] - n['juice'] -n['egg'] - n['inconsequentials'] == 0:
-            return True
-    return False
-
-def is_complex_sour(n, ingredient_indexes, ingredients, quantities):
-    # complex sours are simple sours that use alcoholic sweetness, at least in part
-    if n['citrus'] + n['coffee'] > 0 and n['all_sweet'] > 0 and n['juice'] == 0:
-        if (n['spirit'] == 0 and n['liqueur'] > 0) or n['spirit'] > 0:
-            if n['vermouth'] + n['liqueur'] <= 2 and n['vermouth'] + n['liqueur'] > 0:
-                if n['all'] -n['coffee'] - n['citrus'] - n['spirit'] - n['sugar'] - n['syrup'] \
-                        - n['liqueur'] - n['vermouth'] - n['egg'] - n['juice'] - n['inconsequentials'] == 0:
-                    return True
-    return False
-
-def is_spirit_forward(n, ingredient_indexes, ingredients, quantities):
-    # spirit forward contain at least a spirit and vermouth, no citrus. Can contain sweet (sugar, syrups, liqueurs)
-    if n['spirit'] > 0 and n['citrus'] == 0 and n['vermouth'] > 0:
-        if n['all'] - n['spirit'] - n['sugar'] - n['syrup'] - n['liqueur'] -n['egg'] - n['vermouth'] - n['inconsequentials']== 0:
-            return True
-    return False
-
-def is_duo(n, ingredient_indexes, ingredients, quantities):
-    # duos are made of one spirit and one liqueur (above 15ml), under it's an ancestral, no citrus.
-    if n['spirit'] >= 1 and n['citrus'] == 0 and n['sugar']==0 and n['liqueur'] > 0 and n['vermouth'] == 0:
-        if n['all'] - n['spirit'] - n['sugar'] - n['liqueur'] - n['vermouth'] - n['inconsequentials'] == 0:
-            q_liqueur = np.sum([quantities[i_ing]
-                                for i_ind, i_ing in zip(ingredient_indexes, range(len(ingredients)))
-                                if ingredient_profiles['type'][i_ind].lower() == 'liqueur'])
-            if q_liqueur > 15:
-                return True
-            else:
-                return False
-    return False
-
-def is_champagne_cocktail(n, ingredient_indexes, ingredients, quantities):
-    if n['sparkling'] > 0:
-        return True
-    else:
-        return False
-
-def is_simple_highball(n, ingredient_indexes, ingredients, quantities):
-    # simple highballs have one alcoholic ingredient and bubbles
-    if n['alcoholic'] == 1 and n['bubbles'] > 0:
-        if n['all'] - n['alcoholic'] - n['bubbles'] - n['inconsequentials']== 0:
-            return True
-    return False
-
-def is_complex_highball(n, ingredient_indexes, ingredients, quantities):
-    # complex highballs have at least one alcoholic ingredient and bubbles (possibly alcoholic). They also contain extra sugar under any form and juice
-    if n['alcoholic'] > 0 and (n['bubbles'] + n['sparkling']) == 1 and n['juice'] + n['all_sweet'] + n['sugar_bubbles']> 0:
-        if n['all'] - n['spirit'] - n['bubbles'] - n['sparkling'] - n['citrus'] - n['juice'] - n['liqueur'] \
-                - n['syrup'] - n['sugar'] -n['vermouth'] -n['egg'] - n['inconsequentials'] == 0:
-            if not is_collins(n, ingredient_indexes, ingredients, quantities) and not is_simple_highball(n, ingredient_indexes, ingredients, quantities):
-                return True
-    return False
-
-def is_collins(n, ingredient_indexes, ingredients, quantities):
-    # collins are a particular kind of highball with sugar and citrus
-    if n['alcoholic'] == 1 and n['bubbles'] == 1 and n['citrus'] > 0 and n['plain_sweet'] + n['sugar_bubbles'] > 0:
-        if n['all'] - n['spirit'] - n['bubbles'] - n['citrus'] - n['sugar'] - n['inconsequentials'] == 0:
-            return True
-    return False
-
-def is_julep(n, ingredient_indexes, ingredients, quantities):
-    # juleps involve smashd mint, sugar and a spirit, no citrus.
-    if 'mint' in ingredients and n['sugar'] > 0 and n['spirit'] > 0 and n['vermouth'] == 0 and n['citrus'] == 0:
-        return True
-    return False
-
-def is_simple_sour_with_juice(n, ingredient_indexes, ingredients, quantities):
-    # almost sours are sours with juice
-    if n['juice'] > 0 and n['spirit'] > 0 and n['plain_sweet'] > 0:
-        if n['all'] - n['citrus'] - n['coffee'] - n['juice'] - n['spirit'] - n['sugar'] - n['syrup'] - n['egg'] - n['inconsequentials'] == 0:
-            return True
-    return False
-
-
-def is_complex_sour_with_juice(n, ingredient_indexes, ingredients, quantities):
-    # almost sours are sours with juice
-    if n['juice'] > 0 and n['all_sweet'] > 0:
-        if (n['spirit'] == 0 and n['liqueur'] > 0) or n['spirit'] > 0:
-            if n['vermouth'] + n['liqueur'] <= 2 and n['vermouth'] + n['liqueur'] > 0:
-                if n['all'] -n['coffee'] - n['citrus'] - n['spirit'] - n['sugar'] - n['syrup'] \
-                        - n['liqueur'] - n['vermouth'] - n['egg'] - n['juice'] - n['inconsequentials'] == 0:
-                    return True
-    return False
-
-
-is_sub_category = [is_ancestral, is_complex_sour, is_simple_sour, is_duo, is_champagne_cocktail,
-                   is_spirit_forward, is_simple_highball, is_complex_highball, is_collins,
-                   is_julep, is_simple_sour_with_juice, is_complex_sour_with_juice]
-sub_categories = ['ancestral', 'complex_sour', 'simple_sour', 'duo', 'champagne_cocktail',
-                  'spirit_forward', 'simple_highball', 'complex_highball', 'collins',
-                  'julep', 'simple_sour_with_juice', 'complex_sour_with_juice']
-
-
-# compute cocktail category as a function of ingredients and quantities, uses name to check match between name and cat (e.g. XXX Collins should be collins..)
-# Categories definitions are based on https://www.seriouseats.com/cocktail-style-guide-categories-of-cocktails-glossary-families-of-drinks
-def find_cocktail_sub_category(ingredients, quantities, name=None):
-    ingredient_indexes = [ingredient2ingredient_id[ing] for ing in ingredients]
-    n_spirit = np.sum([ingredient_profiles['type'][i].lower() == 'liquor' for i in ingredient_indexes ])
-    n_citrus = np.sum([ingredient_profiles['type'][i].lower()== 'acid' for i in ingredient_indexes])
-    n_sugar = np.sum([ingredient_profiles['ingredient'][i].lower() in ['double syrup', 'simple syrup', 'honey syrup'] for i in ingredient_indexes])
-    plain_sweet = ingredients_per_type['sweeteners']
-    all_sweet = ingredients_per_type['sweeteners'] + ingredients_per_type['liqueur'] + ['sweet vermouth', 'lillet blanc']
-    n_plain_sweet = np.sum([ingredient_profiles['ingredient'][i].lower() in plain_sweet for i in ingredient_indexes])
-    n_all_sweet = np.sum([ingredient_profiles['ingredient'][i].lower() in all_sweet for i in ingredient_indexes])
-    n_sugar_bubbles = np.sum([ingredient_profiles['ingredient'][i].lower() in ['cola', 'ginger beer', 'tonic'] for i in ingredient_indexes])
-    n_juice = np.sum([ingredient_profiles['type'][i].lower() == 'juice' for i in ingredient_indexes])
-    n_liqueur = np.sum([ingredient_profiles['type'][i].lower() == 'liqueur' for i in ingredient_indexes])
-    alcoholic = ingredients_per_type['liquor'] + ingredients_per_type['liqueur'] + ingredients_per_type['vermouth']
-    n_alcoholic = np.sum([ingredient_profiles['ingredient'][i].lower() in alcoholic for i in ingredient_indexes])
-    n_bitter = np.sum([ingredient_profiles['type'][i].lower() == 'bitters' for i in ingredient_indexes])
-    n_egg = np.sum([ingredient_profiles['ingredient'][i].lower() == 'egg' for i in ingredient_indexes])
-    n_vermouth = np.sum([ingredient_profiles['type'][i].lower() == 'vermouth' for i in ingredient_indexes])
-    n_sparkling = np.sum([ingredient_profiles['ingredient'][i].lower() == 'sparkling wine' for i in ingredient_indexes])
-    n_bubbles = np.sum([ingredient_profiles['ingredient'][i].lower() in ['soda', 'tonic', 'cola', 'ginger beer'] for i in ingredient_indexes])
-    n_syrup = np.sum([ingredient_profiles['ingredient'][i].lower() in ['grenadine', 'raspberry syrup'] for i in ingredient_indexes])
-    n_coffee = np.sum([ingredient_profiles['ingredient'][i].lower() == 'espresso' for i in ingredient_indexes])
-    inconsequentials = ['water', 'salt', 'angostura', 'orange bitters', 'mint']
-    n_inconsequentials = np.sum([ingredient_profiles['ingredient'][i].lower() in inconsequentials for i in ingredient_indexes])
-    n = dict(all=len(ingredients),
-             inconsequentials=n_inconsequentials,
-             sugar_bubbles=n_sugar_bubbles,
-             bubbles=n_bubbles,
-             plain_sweet=n_plain_sweet,
-             all_sweet=n_all_sweet,
-             coffee=n_coffee,
-             alcoholic=n_alcoholic,
-             syrup=n_syrup,
-             sparkling=n_sparkling,
-             sugar=n_sugar,
-             spirit=n_spirit,
-             citrus=n_citrus,
-             juice=n_juice,
-             liqueur=n_liqueur,
-             bitter=n_bitter,
-             egg=n_egg,
-             vermouth=n_vermouth)
-
-    sub_cats = [c for c, test_c in zip(sub_categories, is_sub_category) if test_c(n, ingredient_indexes, ingredients, quantities)]
-    if name != None:
-        name = name.lower()
-        keywords_to_test = ['julep', 'collins', 'highball', 'sour', 'champagne']
-        for k in keywords_to_test:
-            if k in name and not any([k in cat for cat in sub_cats]):
-                print(k)
-                for ing, q in zip(ingredients, quantities):
-                    print(f'{ing}: {q} ml')
-                print(n)
-                break
-    if sorted(sub_cats) == ['champagne_cocktail', 'complex_highball']:
-        sub_cats = ['champagne_cocktail']
-    elif sorted(sub_cats) == ['collins', 'complex_highball']:
-        sub_cats = ['collins']
-    elif sorted(sub_cats) ==  ['champagne_cocktail', 'complex_highball', 'julep']:
-        sub_cats = ['champagne_cocktail']
-    elif sorted(sub_cats) ==  ['ancestral', 'julep']:
-        sub_cats = ['julep']
-    elif sorted(sub_cats) ==  ['complex_highball', 'julep']:
-        sub_cats = ['complex_highball']
-    elif sorted(sub_cats) ==  ['julep', 'simple_sour_with_juice']:
-        sub_cats = ['simple_sour_with_juice']
-    elif sorted(sub_cats) == ['complex_sour_with_juice', 'julep']:
-        sub_cats = ['complex_sour_with_juice']
-    if len(sub_cats) != 1:
-        # print(sub_cats)
-        # for ing, q in zip(ingredients, quantities):
-        #     print(f'{ing}: {q} ml')
-        # print(n)
-        # if len(sub_cats) == 0:
-        sub_cats = ['other']
-    assert len(sub_cats) == 1, sub_cats
-    return sub_cats[0], n
-
-def get_cocktails_attributes(ing_strs):
-    attributes = dict()
-    cats = []
-    for ing_str in ing_strs:
-        ingredients, quantities = extract_ingredients(ing_str)
-        cat, atts = find_cocktail_sub_category(ingredients, quantities)
-        for k in atts.keys():
-            if k not in attributes.keys():
-                attributes[k] = [atts[k]]
-            else:
-                attributes[k].append(atts[k])
-        cats.append(cat)
-    return cats, attributes

src/cocktails/utilities/cocktail_generation_utilities/individual.py

@@ -1,587 +0,0 @@
-from src.cocktails.utilities.ingredients_utilities import get_ingredients_info, format_ingredients, extract_ingredients, ingredients_per_type, bubble_ingredients
-import numpy as np
-from src.cocktails.utilities.other_scrubbing_utilities import print_recipe
-from src.cocktails.utilities.cocktail_utilities import get_cocktail_rep, get_profile, get_bunch_of_rep_keys
-from src.cocktails.utilities.glass_and_volume_utilities import glass_volume
-from src.cocktails.representation_learning.run import get_model
-from src.cocktails.pipeline.get_cocktail2affective_cluster import get_cocktail2affective_cluster
-from src.cocktails.config import COCKTAILS_CSV_DATA, FULL_COCKTAIL_REP_PATH, REPO_PATH, COCKTAIL_REP_CHKPT_PATH, RECIPE2FEATURES_PATH
-from src.cocktails.representation_learning.run_without_vae import get_model
-from src.cocktails.utilities.cocktail_category_detection_utilities import find_cocktail_sub_category
-
-import pandas as pd
-import torch
-import time
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-density_ingredients = np.loadtxt(COCKTAIL_REP_CHKPT_PATH + 'density_ingredients.txt')
-max_ingredients, ingredient_list, ind_alcohol = get_ingredients_info()
-min_ingredients = 2
-factor_max = 1.2  # generated recipes can go up to 1.2 times the max quantity of the ingredient found in the dataset
-
-prep_model = get_model(RECIPE2FEATURES_PATH + 'multi_predictor/')[0]
-
-all_rep_path = FULL_COCKTAIL_REP_PATH
-all_reps = np.loadtxt(all_rep_path)
-experiment_dir = REPO_PATH + '/experiments/cocktails/'
-rep_keys = get_bunch_of_rep_keys()['custom']
-dict_weights_mse_computation = {'end volume': .1, 'end sour': 2, 'end sweet': 2, 'end booze': 4, 'end bitter': 2, 'end fruit': 1, 'end herb': 1,
-                                'end complex': 1, 'end spicy': 5, 'end oaky': 1, 'end fizzy': 10, 'end colorful': 1, 'end eggy': 10}
-assert sorted(dict_weights_mse_computation.keys()) == sorted(rep_keys)
-weights_mse_computation = np.array([dict_weights_mse_computation[k] for k in rep_keys])
-weights_mse_computation /= weights_mse_computation.sum()
-data = pd.read_csv(COCKTAILS_CSV_DATA)
-preparation_list = sorted(set(data['category']))
-glasses_list = sorted(set(data['glass']))
-
-weights_perf_n_ing = {2:0.71, 3:0.81, 4:0.93, 5:1., 6:1.03, 7:1.08, 8:1.05}
-
-# weights_perf_n_ing = {2:0.75, 3:0.8, 4:0.95, 5:1.05, 6:1.05, 7:1.05, 8:1.05}
-min_ingredients_quantities_when_present = np.loadtxt(COCKTAIL_REP_CHKPT_PATH +'ingredients_min_quantities_when_present.txt')
-min_ingredients_quantities = np.loadtxt(COCKTAIL_REP_CHKPT_PATH +'ingredients_min_quantities.txt')
-max_ingredients_quantities = np.loadtxt(COCKTAIL_REP_CHKPT_PATH + 'ingredients_max_quantities.txt')
-min_cocktail_rep, max_cocktail_rep = np.loadtxt(COCKTAIL_REP_CHKPT_PATH +'cocktail_minmax_dim13_customkeys.txt')
-distrib_nb_ings_2_8 = np.loadtxt(COCKTAIL_REP_CHKPT_PATH + 'distrib_nb_ing.txt')[2:]
-def normalize_cocktail(cocktail_rep):
-    return ((cocktail_rep - min_cocktail_rep) / (max_cocktail_rep - min_cocktail_rep) - 0.5) * 2
-
-def denormalize_cocktail(cocktail_rep):
-    return (cocktail_rep / 2 + 0.5) * (max_cocktail_rep - min_cocktail_rep) + min_cocktail_rep
-
-def normalize_ingredient_q_rep(ingredients_q):
-    return (ingredients_q - min_ingredients_quantities_when_present) / (max_ingredients_quantities * factor_max - min_ingredients_quantities_when_present)
-
-COCKTAIL_REPS = normalize_cocktail(np.array([data[k] for k in rep_keys]).transpose())
-assert np.abs(COCKTAIL_REPS - all_reps).sum() < 1e-8
-
-cocktail2affective_cluster = get_cocktail2affective_cluster()
-
-original_affective_keys = get_bunch_of_rep_keys()['affective']
-def sigmoid(x, shift, beta):
-    return (1 / (1 + np.exp(-(x + shift) * beta)) - 0.5) * 2
-
-def get_normalized_affective_cocktail_rep_from_normalized_cocktail_rep(cocktail_rep):
-    indexes = np.array([rep_keys.index(key) for key in original_affective_keys])
-    cocktail_rep = cocktail_rep[indexes]
-    cocktail_rep[0] = sigmoid(cocktail_rep[0], shift=0.05, beta=4)
-    cocktail_rep[1] = sigmoid(cocktail_rep[1], shift=0.3, beta=5)
-    cocktail_rep[2] = sigmoid(cocktail_rep[2], shift=0.15, beta=3)
-    cocktail_rep[3] = sigmoid(cocktail_rep[3], shift=0.9, beta=20)
-    cocktail_rep[4] = sigmoid(cocktail_rep[4], shift=0, beta=4)
-    cocktail_rep[5] = sigmoid(cocktail_rep[5], shift=0.2, beta=3)
-    cocktail_rep[6] = sigmoid(cocktail_rep[6], shift=0.5, beta=5)
-    cocktail_rep[7] = sigmoid(cocktail_rep[7], shift=0.2, beta=6)
-    return cocktail_rep
-
-class IndividualCocktail():
-    def __init__(self, pop_params, target, target_affective_cluster, genes_presence=None, genes_quantity=None,
-                 compute_perf=True, known_target_dict=None, run_hard_check=False):
-
-        self.pop_params = pop_params
-        self.n_genes = len(ingredient_list)
-        self.max_ingredients = max_ingredients
-        self.min_ingredients = min_ingredients
-        self.mutation_params = pop_params['mutation_params']
-        self.dist = pop_params['dist']
-        self.target = target
-        self.is_known = known_target_dict is not None
-        self.known_target_dict = known_target_dict
-        self.perf = None
-        self.cocktail_rep = None
-        self.affective_cluster = None
-        self.target_affective_cluster = target_affective_cluster
-        self.ing_list = np.array(ingredient_list)
-        self.ing_set = set(ingredient_list)
-
-        self.ing_ids_per_cat = dict(bubbles=set(self.get_ingredients_ids_from_list(bubble_ingredients)),
-                                    liquor=set(self.get_ingredients_ids_from_list(ingredients_per_type['liquor'])),
-                                    liqueur=set(self.get_ingredients_ids_from_list(ingredients_per_type['liqueur'])),
-                                    citrus=set(self.get_ingredients_ids_from_list(ingredients_per_type['acid'] + ['orange juice'])),
-                                    alcohol=set(ind_alcohol),
-                                    sweeteners=set(self.get_ingredients_ids_from_list(ingredients_per_type['sweeteners'])),
-                                    vermouth=set(self.get_ingredients_ids_from_list(ingredients_per_type['vermouth'])),
-                                    bitters=set(self.get_ingredients_ids_from_list(ingredients_per_type['bitters'])),
-                                    juice=set(self.get_ingredients_ids_from_list(ingredients_per_type['juice'])),
-                                    acid=set(self.get_ingredients_ids_from_list(ingredients_per_type['acid'])),
-                                    egg=set(self.get_ingredients_ids_from_list(['egg']))
-                                    )
-
-        if genes_presence is not None:
-            assert len(genes_presence) == self.n_genes
-            assert len(genes_quantity) == self.n_genes
-            self.genes_presence = genes_presence
-            self.genes_quantity = genes_quantity
-            if compute_perf:
-                self.compute_cocktail_rep()
-                self.compute_perf()
-        else:
-            self.sample_initial_genes()
-            self.compute_cocktail_rep()
-            # self.make_recipe_fit_the_glass()
-            self.compute_perf()
-
-
-    # # # # # # # # # # # # # # # # # # # # # # # #
-    # Sample initial genes with smart rules
-    # # # # # # # # # # # # # # # # # # # # # # # #
-
-    def sample_initial_genes(self):
-        # rules:
-        # - between min_ingredients and max_ingredients
-        # - at most one type of bubbles
-        # - at least one alcohol
-        # - no egg without lime or lemon
-        # - at most two liqueurs
-        # - at most three liquors
-        # - at most two sweetener
-        self.genes_quantity = np.random.uniform(0, 1, size=self.n_genes)  # holds quantities for each ingredient
-        n_ingredients = np.random.choice(np.arange(min_ingredients, max_ingredients + 1), p=distrib_nb_ings_2_8)
-        self.genes_presence = np.zeros(self.n_genes)
-        # add one alchohol
-        self.genes_presence[np.random.choice(ind_alcohol)] = 1
-        while self.get_ing_count() < n_ingredients:
-            candidate_ids = self.get_candidate_ingredients_ids(self.genes_presence)
-            probas = density_ingredients[candidate_ids] / np.sum(density_ingredients[candidate_ids])
-            self.genes_presence[np.random.choice(candidate_ids, p=probas)] = 1
-
-    def get_candidate_ingredients_ids(self, genes_presence):
-        candidates = set(np.argwhere(genes_presence==0).flatten())
-        present_ids = set(np.argwhere(genes_presence==1).flatten())
-
-        if self.count_in_genes(present_ids, 'bubbles') >= 1:  # at most one type of bubbles
-            candidates = candidates - self.ing_ids_per_cat['bubbles']
-        if self.count_in_genes(present_ids, 'liquor')  >= 3:  # at most three liquors
-            candidates = candidates - self.ing_ids_per_cat['liquor']
-        if self.count_in_genes(present_ids, 'liqueur')  >= 2:  # at most two liqueurs
-            candidates = candidates - self.ing_ids_per_cat['liqueur']
-        if self.count_in_genes(present_ids, 'sweeteners')  >= 2:  # at most two sweetener
-            candidates = candidates - self.ing_ids_per_cat['sweeteners']
-        if self.count_in_genes(present_ids, 'citrus')  == 0:  # no egg without lime or lemon
-            candidates = candidates - self.ing_ids_per_cat['egg']
-        return np.array(sorted(candidates))
-
-    def count_in_genes(self, present_ids, keyword):
-        if keyword == 'citrus': return len(present_ids & self.ing_ids_per_cat['citrus'])
-        elif keyword == 'bubbles': return len(present_ids & self.ing_ids_per_cat['bubbles'])
-        elif keyword == 'liquor': return len(present_ids & self.ing_ids_per_cat['liquor'])
-        elif keyword == 'liqueur': return len(present_ids & self.ing_ids_per_cat['liqueur'])
-        elif keyword == 'alcohol': return len(present_ids & self.ing_ids_per_cat['alcohol'])
-        elif keyword == 'sweeteners': return len(present_ids & self.ing_ids_per_cat['sweeteners'])
-        else: raise ValueError
-
-    def get_ingredients_ids_from_list(self, ing_list):
-        return [ingredient_list.index(ing) for ing in ing_list]
-
-    def get_ing_count(self):
-        return np.sum(self.genes_presence)
-
-    # # # # # # # # # # # # # # # # # # # # # # # #
-    # Compute cocktail representations
-    # # # # # # # # # # # # # # # # # # # # # # # #
-
-    def get_absent_ing(self):
-        return np.argwhere(self.genes_presence==0).flatten()
-
-    def get_present_ing(self):
-        return np.argwhere(self.genes_presence==1).flatten()
-
-    def get_ingredient_quantities(self):
-        # unnormalize quantities to get real ones
-        return (self.genes_quantity * (max_ingredients_quantities * factor_max - min_ingredients_quantities_when_present) + min_ingredients_quantities_when_present) * self.genes_presence
-
-    def get_ing_and_q_from_genes(self):
-        present_ings = self.get_present_ing()
-        ing_quantities = self.get_ingredient_quantities()
-        ingredients, quantities = [], []
-        for i_ing in present_ings:
-            ingredients.append(ingredient_list[i_ing])
-            quantities.append(ing_quantities[i_ing])
-        return ingredients, quantities, ing_quantities
-
-    def compute_cocktail_rep(self):
-        # only call when genes have changes
-        init_time = time.time()
-        ingredients, quantities, ing_quantities = self.get_ing_and_q_from_genes()
-        # compute cocktail category
-        self.category = find_cocktail_sub_category(ingredients, quantities)[0]
-        # print(f't1: {time.time() - init_time}')
-        init_time = time.time()
-        self.prep_type = self.get_prep_type(ing_quantities)
-        # print(f't2: {time.time() - init_time}')
-        init_time = time.time()
-        cocktail_rep, self.end_volume, self.end_alcohol = get_cocktail_rep(self.prep_type, ingredients, quantities, keys=rep_keys[1:]) # volume is added later
-        # print(f't3: {time.time() - init_time}')
-        init_time = time.time()
-        self.cocktail_rep = normalize_cocktail(cocktail_rep)
-        # print(f't4: {time.time() - init_time}')
-        init_time = time.time()
-        self.glass = self.get_glass_type(ing_quantities)
-        # print(f't5: {time.time() - init_time}')
-        init_time = time.time()
-        if self.is_known:
-            assert np.abs(self.cocktail_rep - self.target).sum() < 1e-6
-        return self.cocktail_rep
-
-    def get_prep_type(self, quantities=None):
-        if self.is_known: return self.known_target_dict['prep_type']
-        else:
-            if quantities is None:
-                quantities = self.get_ingredient_quantities()
-            if quantities[ingredient_list.index('egg')] > 0:
-                prep_cat = 'egg_shaken'
-            elif self.category in ['spirit_forward', 'simple_sour_with_juice', 'julep', 'duo', 'ancestral', 'complex_sour_with_juice']:
-                # use hard coded rules for most obvious cases determined with the correlations_glass_cat_prep_script
-                if self.category in ['ancestral', 'spirit_forward', 'duo']:
-                    prep_cat = 'stirred'
-                elif self.category in ['complex_sour_with_juice', 'julep', 'simple_sour_with_juice']:
-                    prep_cat = 'shaken'
-                else:
-                    raise ValueError
-            else:
-                output = prep_model(quantities, aux_str='prep_type').flatten()
-                output[preparation_list.index('egg_shaken')] = -np.inf
-                prep_cat = preparation_list[np.argmax(output)]
-        return prep_cat
-
-    def get_glass_type(self, quantities=None):
-        if self.is_known: return self.known_target_dict['glass']
-        else:
-            if self.category in ['collins', 'complex_highball', 'simple_highball', 'champagne_cocktail', 'complex_sour']:
-                # use hard coded rules for most obvious cases determined with the correlations_glass_cat_prep_script
-                if self.category in ['collins', 'complex_highball', 'simple_highball']:
-                    glass = 'collins'
-                elif self.category in ['champagne_cocktail', 'complex_sour']:
-                    glass = 'coupe'
-            else:
-                if quantities is None:
-                    quantities = self.get_ingredient_quantities()
-                output = prep_model(quantities, aux_str='glasses').flatten()
-                glass = glasses_list[np.argmax(output)]
-        return glass
-
-    # # # # # # # # # # # # # # # # # # # # # # # #
-    # Adapt recipe to fit the glass
-    # # # # # # # # # # # # # # # # # # # # # # # #
-
-    def is_too_large_for_glass(self):
-        return self.end_volume > glass_volume[self.glass] * 0.80
-
-    def is_too_small_for_glass(self):
-        return self.end_volume < glass_volume[self.glass] * 0.3
-
-    def scale_ing_quantities(self, present_ings, factor):
-        qs = self.get_ingredient_quantities().copy()
-        qs[present_ings] *= factor
-        self.set_genes_from_quantities(present_ings, qs)
-
-    def set_genes_from_quantities(self, present_ings, quantities):
-        genes_quantity = np.clip((quantities - min_ingredients_quantities_when_present) /
-                                 (factor_max * max_ingredients_quantities - min_ingredients_quantities_when_present), 0, 1)
-        self.genes_quantity[present_ings] = genes_quantity[present_ings]
-
-    def make_recipe_fit_the_glass(self):
-        # check if citrus, if not remove egg
-        present_ids = np.argwhere(self.genes_presence == 1).flatten()
-        ing_list = self.ing_list[present_ids]
-        present_ids = set(present_ids)
-        if self.count_in_genes(present_ids, 'citrus') == 0 and 'egg' in ing_list:
-            if self.genes_presence.sum() > 2:
-                i_egg = ingredient_list.index('egg')
-                self.genes_presence[i_egg] = 0.
-                self.compute_cocktail_rep()
-
-
-        i_trial = 0
-        present_ings = self.get_present_ing()
-        while self.is_too_large_for_glass():
-            i_trial += 1
-            end_volume = self.end_volume
-            desired_volume = glass_volume[self.glass] * 0.80
-            ratio = desired_volume / end_volume
-            self.scale_ing_quantities(present_ings, factor=ratio)
-            self.compute_cocktail_rep()
-            if end_volume == self.end_volume: break
-            if i_trial == 10: break
-        while self.is_too_small_for_glass():
-            i_trial += 1
-            end_volume = self.end_volume
-            desired_volume = glass_volume[self.glass] * 0.80
-            ratio = desired_volume / end_volume
-            self.scale_ing_quantities(present_ings, factor=ratio)
-            self.compute_cocktail_rep()
-            if end_volume == self.end_volume: break
-            if i_trial == 10: break
-
-    # # # # # # # # # # # # # # # # # # # # # # # #
-    # Compute performance
-    # # # # # # # # # # # # # # # # # # # # # # # #
-
-    def passes_checks(self):
-        present_ids = np.argwhere(self.genes_presence==1).flatten()
-        # ing_list = self.ing_list[present_ids]
-        present_ids = set(present_ids)
-        if len(present_ids) < 2 or len(present_ids) > 8: return False
-        # if self.is_too_large_for_glass(): return False
-        # if self.is_too_small_for_glass(): return False
-        if self.end_alcohol < 0.05 or self.end_alcohol > 0.31: return False
-        if self.count_in_genes(present_ids, 'sweeteners')  > 2: return False
-        if self.count_in_genes(present_ids, 'liqueur')  > 2: return False
-        if self.count_in_genes(present_ids, 'liquor')  > 3: return False
-        # if self.count_in_genes(present_ids, 'citrus') == 0 and 'egg' in ing_list: return False
-        if self.count_in_genes(present_ids, 'bubbles') > 1: return False
-        else: return True
-
-    def get_affective_cluster(self):
-        cocktail_rep_affective = get_normalized_affective_cocktail_rep_from_normalized_cocktail_rep(self.cocktail_rep)
-        self.affective_cluster = cocktail2affective_cluster(cocktail_rep_affective)[0]
-        return self.affective_cluster
-
-    def does_affective_cluster_match(self):
-        return True#self.get_affective_cluster() == self.target_affective_cluster
-
-    def compute_perf(self):
-        if not self.passes_checks(): self.perf = -100
-        else:
-            if self.dist == 'mse':
-                # self.perf = - np.sqrt(((self.cocktail_rep - self.target)**2).mean())
-                self.perf = - np.sqrt(np.dot((self.cocktail_rep - self.target)**2, weights_mse_computation))
-                self.perf *= weights_perf_n_ing[int(self.genes_presence.sum())]
-                if not self.does_affective_cluster_match():
-                    self.perf *= 2
-            else: raise NotImplemented
-
-
-    # # # # # # # # # # # # # # # # # # # # # # # #
-    # Mutations and crossover
-    # # # # # # # # # # # # # # # # # # # # # # # #
-
-    def get_child(self):
-        time_dict = dict()
-        init_time = time.time()
-        child = IndividualCocktail(pop_params=self.pop_params, target_affective_cluster=self.target_affective_cluster,
-                                   target=self.target, genes_presence=self.genes_presence.copy(),
-                                   genes_quantity=self.genes_quantity.copy(), compute_perf=False)
-        time_dict['    asexual child creation'] = [time.time() - init_time]
-        init_time = time.time()
-        this_time_dict = child.mutate()
-        time_dict = self.update_time_dict(time_dict, this_time_dict)
-        time_dict['    asexual child mutation'] = [time.time() - init_time]
-        return child, time_dict
-
-    def get_child_with(self, other_parent):
-        time_dict = dict()
-        init_time = time.time()
-        new_genes_presence = np.zeros(self.n_genes)
-        present_ing = self.get_present_ing()
-        other_present_ing = other_parent.get_present_ing()
-        new_genes_quantity = np.random.uniform(0, 1, size=self.n_genes)
-        shared_ingredients = sorted(set(present_ing) & set(other_present_ing))
-        unique_ingredients_one = sorted(set(present_ing) - set(other_present_ing))
-        unique_ingredients_two = sorted(set(other_present_ing) - set(present_ing))
-        for i in shared_ingredients:
-            new_genes_presence[i] = 1
-            new_genes_quantity[i] = (self.genes_quantity[i] + other_parent.genes_quantity[i]) / 2
-        time_dict['    crossover child creation'] = [time.time() - init_time]
-        init_time = time.time()
-        # add one alcohol if none present
-        if len(set(np.argwhere(new_genes_presence==1).flatten()).intersection(ind_alcohol)) == 0:
-            new_genes_presence[np.random.choice(ind_alcohol)] = 1
-        # up to here, we respect the constraints (assuming both parents do).
-        candidate_genes = np.array(unique_ingredients_one + unique_ingredients_two)
-        candidate_quantities = np.array([self.genes_quantity[i] for i in unique_ingredients_one] + [other_parent.genes_quantity[i] for i in unique_ingredients_two])
-        indexes = np.arange(len(candidate_genes))
-        np.random.shuffle(indexes)
-        candidate_genes = candidate_genes[indexes]
-        candidate_quantities = candidate_quantities[indexes]
-        time_dict['    crossover prepare selection'] = [time.time() - init_time]
-        init_time = time.time()
-        # now let's try to add each of them while respecting the constraints
-        for i in range(len(indexes)):
-            if np.random.rand() < 0.5 or np.sum(new_genes_presence) < self.min_ingredients:  # only try to add one every two ingredient
-                ing_id = candidate_genes[i]
-                q = candidate_quantities[i]
-                new_genes_presence[ing_id] = 1
-                new_genes_quantity[ing_id] = q
-                if np.sum(new_genes_presence) == self.max_ingredients:
-                    break
-        time_dict['    crossover do selection'] = [time.time() - init_time]
-        init_time = time.time()
-        # create new child
-        child = IndividualCocktail(pop_params=self.pop_params, target_affective_cluster=self.target_affective_cluster, target=self.target,
-                                   genes_presence=new_genes_presence.copy(), genes_quantity=new_genes_quantity.copy(), compute_perf=False)
-        time_dict['    crossover create child'] = [time.time() - init_time]
-        init_time = time.time()
-        this_time_dict = child.mutate()
-        time_dict = self.update_time_dict(time_dict, this_time_dict)
-        time_dict['    crossover child mutation'] = [time.time() - init_time]
-        init_time = time.time()
-        return child, time_dict
-
-    def mutate(self):
-        # self.print_recipe()
-        time_dict = dict()
-        # remove an ingredient
-        init_time = time.time()
-        present_ids = set(np.argwhere(self.genes_presence==1).flatten())
-
-        if np.random.rand() < self.mutation_params['p_remove_ing']:
-            if self.get_ing_count() > self.min_ingredients:
-                candidate_ings = self.get_present_ing()
-                if self.count_in_genes(present_ids, 'alcohol') == 1:  # make sure we keep at least one liquor
-                    candidate_ings = np.array(sorted(set(candidate_ings) - set(ind_alcohol)))
-                index_to_remove = np.random.choice(candidate_ings)
-                self.genes_presence[index_to_remove] = 0
-            time_dict['      mutation remove ing'] = [time.time() - init_time]
-        init_time = time.time()
-        # add an ingredient
-        if np.random.rand() < self.mutation_params['p_add_ing']:
-            if self.get_ing_count() < self.max_ingredients:
-                candidate_ings = self.get_candidate_ingredients_ids(self.genes_presence.copy())
-                index_to_add = np.random.choice(candidate_ings, p=density_ingredients[candidate_ings] / np.sum(density_ingredients[candidate_ings]))
-                self.genes_presence[index_to_add] = 1
-                time_dict['      mutation add ing'] = [time.time() - init_time]
-
-        init_time = time.time()
-        # replace ings by others from the same family
-        if np.random.rand() < self.mutation_params['p_switch_ing']:
-            i = np.random.choice(self.get_present_ing())
-            ing_str = ingredient_list[i]
-            if ing_str not in ['sparkling wine', 'orange juice']:
-                if ing_str in bubble_ingredients:
-                    candidates_ids = np.array(sorted(self.ing_ids_per_cat['bubbles'] - set([i])))
-                    new_bubble = np.random.choice(candidates_ids, p=density_ingredients[candidates_ids] / np.sum(density_ingredients[candidates_ids]))
-                    self.genes_presence[i] = 0
-                    self.genes_presence[new_bubble] = 1
-                    self.genes_quantity[new_bubble] = self.genes_quantity[i] # copy quantity
-                categories = ['acid', 'bitters', 'juice', 'liqueur', 'liquor', 'sweeteners', 'vermouth']
-                for cat in categories:
-                    if ing_str in ingredients_per_type[cat]:
-                        present_ings = self.get_present_ing()
-                        candidates_ids = np.array(sorted(self.ing_ids_per_cat[cat] - set([i]) - set(present_ings)))
-                        if len(candidates_ids) > 0:
-                            replacing_ing = np.random.choice(candidates_ids, p=density_ingredients[candidates_ids] / np.sum(density_ingredients[candidates_ids]))
-                            self.genes_presence[i] = 0
-                            self.genes_presence[replacing_ing] = 1
-                            self.genes_quantity[replacing_ing] = self.genes_quantity[i]  # copy quantity
-                        break
-        time_dict['      mutation switch ing'] = [time.time() - init_time]
-        init_time = time.time()
-        # add noise on ing quantity
-        for i in self.get_present_ing():
-            if np.random.rand() < self.mutation_params['p_change_q']:
-                self.genes_quantity[i] += np.random.randn() * self.mutation_params['delta_change_q']
-        self.genes_quantity = np.clip(self.genes_quantity, 0, 1)
-        time_dict['      mutation change quantity'] = [time.time() - init_time]
-
-        init_time = time.time()
-        self.compute_cocktail_rep()
-        time_dict['      mutation compute cocktail rep'] = [time.time() - init_time]
-        init_time = time.time()
-        # self.make_recipe_fit_the_glass()
-        time_dict['      mutation check glass fit'] = [time.time() - init_time]
-        init_time = time.time()
-        self.compute_perf()
-        time_dict['      mutation compute perf'] = [time.time() - init_time]
-        init_time = time.time()
-        stop = 1
-        return time_dict
-
-
-    def update_time_dict(self, main_dict, new_dict):
-        for k in new_dict.keys():
-            if k in main_dict.keys():
-                main_dict[k].append(np.sum(new_dict[k]))
-            else:
-                main_dict[k] = [np.sum(new_dict[k])]
-        return main_dict
-
-    # # # # # # # # # # # # # # # # # # # # # # # #
-    # Get recipe and print
-    # # # # # # # # # # # # # # # # # # # # # # # #
-
-    def get_recipe(self, unit='mL', name=None):
-        ing_quantities = self.get_ingredient_quantities()
-        ingredients, quantities = [], []
-        for i_ing, q_ing in enumerate(ing_quantities):
-            if q_ing > 0.8:
-                ingredients.append(ingredient_list[i_ing])
-                quantities.append(round(q_ing))
-        recipe_str = format_ingredients(ingredients, quantities)
-        recipe_str_readable = print_recipe(unit=unit, ingredient_str=recipe_str, name=name, to_print=False)
-        return ingredients, quantities, recipe_str, recipe_str_readable
-
-    def get_instructions(self):
-        ing_quantities = self.get_ingredient_quantities()
-        ingredients, quantities = [], []
-        for i_ing, q_ing in enumerate(ing_quantities):
-            if q_ing > 0.8:
-                ingredients.append(ingredient_list[i_ing])
-                quantities.append(round(q_ing))
-        str_out = 'Instructions:\n   '
-
-        if 'mint' in ingredients:
-            i_mint = ingredients.index('mint')
-            n_leaves = quantities[i_mint]
-            str_out += f'Add {n_leaves} mint leaves to a shaker, followed by an ice cube.\n   Muddle the mint and ice together with a muddler.\n   '
-        bubbles = ['sparkling wine', 'tonic', 'soda', 'ginger beer']
-        other_ings = [ing for ing in ingredients if ing not in ['egg', 'angostura', 'orange bitters'] + bubbles]
-
-        if self.prep_type == 'built':
-            str_out += 'Add a large ice cube in the glass.\n   '
-        # add ingredients to pour
-        str_out += 'Pour'
-        for i, ing in enumerate(other_ings):
-            if i == len(other_ings) - 2:
-                str_out += f' {ing} and'
-            elif i == len(other_ings) - 1:
-                str_out += f' {ing}'
-            else:
-                str_out += f' {ing},'
-
-        if self.prep_type in ['built'] and 'mint' not in ingredients:
-            str_out += ' into the glass.\n   '
-        else:
-            str_out += ' into the shaker.\n   '
-
-        if self.prep_type == 'egg_shaken' and 'egg' in ingredients:
-            str_out += 'Add the egg white.\n   Dry-shake for 15s (without ice), then fill with ice and shake for another 15s.\n   Serve into the glass through a strainer.\n   '
-        elif 'shaken' in self.prep_type:
-            str_out += 'Fill with ice and shake for 15s.\n   Serve into the glass through a strainer.\n   '
-        elif self.prep_type == 'stirred':
-            str_out += 'Add ice and stir the cocktail with a spoon for 15s.\n   Serve into the glass through a strainer.\n   '
-        elif self.prep_type == 'built':
-            str_out += 'Stir two turns with a spoon.\n   '
-
-        bubble_ing = [ing for ing in ingredients if ing in bubbles]
-        if len(bubble_ing) > 0:
-            str_out += f'Top up with '
-            for ing in bubble_ing:
-                str_out += f'{ing}, '
-            str_out = str_out[:-2] + '.\n   '
-        bitter_ing = [ing for ing in ingredients if ing in ['angostura', 'orange bitters']]
-        if len(bitter_ing) > 0:
-            if len(bitter_ing) == 1:
-                q = quantities[ingredients.index(bitter_ing[0])]
-                n_dashes = max(1, int(q / 0.6))
-                str_out += f'Add {n_dashes} dash'
-                if n_dashes > 1:
-                    str_out += 'es'
-                str_out += f' of {bitter_ing[0]}.\n   '
-            elif len(bitter_ing) == 2:
-                q = quantities[ingredients.index(bitter_ing[0])]
-                n_dashes = max(1, int(q / 0.6))
-                str_out += f'Add {n_dashes} dash'
-                if n_dashes > 1:
-                    str_out += 'es'
-                str_out += f' of {bitter_ing[0]} and '
-                q = quantities[ingredients.index(bitter_ing[1])]
-                n_dashes = max(1, int(q / 0.6))
-                str_out += f'{n_dashes} dash'
-                if n_dashes > 1:
-                    str_out += 'es'
-                str_out += f' of {bitter_ing[1]}.\n   '
-        str_out += 'Enjoy!'
-        return str_out
-
-    def print_recipe(self, name=None):
-        print(self.get_recipe(name)[3])

src/cocktails/utilities/cocktail_generation_utilities/population.py

@@ -1,213 +0,0 @@
-from src.cocktails.utilities.cocktail_generation_utilities.individual import *
-from sklearn.neighbors import NearestNeighbors
-import time
-import pickle
-from src.cocktails.config import COCKTAIL_NN_PATH, COCKTAILS_CSV_DATA
-
-class Population:
-    def __init__(self, target, pop_params, target_affective_cluster=None, known_target_dict=None):
-        self.pop_params = pop_params
-        self.pop_size = pop_params['pop_size']
-        self.nb_elite = pop_params['nb_elites']
-        self.nb_generations = pop_params['nb_generations']
-        self.target = target
-        self.mutation_params = pop_params['mutation_params']
-        self.dist = pop_params['dist']
-        self.n_neighbors = pop_params['n_neighbors']
-        self.known_target_dict = known_target_dict
-
-
-        with open(COCKTAIL_NN_PATH, 'rb') as f:
-            data = pickle.load(f)
-        self.nn_model_cocktail = data['nn_model']
-        self.dim_rep_cocktail = data['dim_rep_cocktail']
-        self.n_cocktails = data['n_cocktails']
-        self.cocktail_data = pd.read_csv(COCKTAILS_CSV_DATA)
-
-        if target_affective_cluster is None:
-            cocktail_rep_affective = get_normalized_affective_cocktail_rep_from_normalized_cocktail_rep(target)
-            self.target_affective_cluster = cocktail2affective_cluster(cocktail_rep_affective)[0]
-        else:
-            self.target_affective_cluster = target_affective_cluster
-
-        self.pop_elite = []
-        self.pop = []
-        self.add_target_individual()  # create a target individual (not in pop)
-        self.add_nearest_neighbors_in_pop()  # add nearest neighbor from dataset into the population
-
-        # fill population
-        while self.get_pop_size() < self.pop_size:
-            self.add_individual()
-        while len(self.pop_elite) < self.nb_elite:
-            self.pop_elite.append(IndividualCocktail(pop_params=self.pop_params,
-                                                     target=self.target.copy(),
-                                                     target_affective_cluster=self.target_affective_cluster))
-        self.update_elite_and_get_next_pop()
-
-    def add_target_individual(self):
-        if self.known_target_dict is not None:
-            genes_presence, genes_quantity = self.get_q_rep(*extract_ingredients(self.known_target_dict['ing_str']))
-            self.target_individual = IndividualCocktail(pop_params=self.pop_params,
-                                                        target=self.target.copy(),
-                                                        known_target_dict=self.known_target_dict,
-                                                        target_affective_cluster=self.target_affective_cluster,
-                                                        genes_presence=genes_presence,
-                                                        genes_quantity=genes_quantity
-                                                        )
-        else:
-            self.target_individual = None
-
-
-    def add_nearest_neighbors_in_pop(self):
-        # add nearest neighbor from dataset into the population
-        if self.n_neighbors > 0:
-            dists, indexes = self.nn_model_cocktail.kneighbors(self.target.reshape(1, -1))
-            dists, indexes = dists.flatten(), indexes.flatten()
-            first = 1 if dists[0] == 0 else 0  # avoid taking the target when testing with known targets from the dataset
-            indexes = indexes[first:first + self.n_neighbors]
-            self.ing_strs = np.array(self.cocktail_data['ingredients_str'])[indexes]
-            recipes = [extract_ingredients(ing_str) for ing_str in self.ing_strs]
-            for r in recipes:
-                genes_presence, genes_quantity = self.get_q_rep(r[0], r[1])
-                genes_presence[-1] = 0  # remove water ingredient
-                self.add_individual(genes_presence=genes_presence.copy(), genes_quantity=genes_quantity.copy())
-            self.nn_recipes = [ind.get_recipe()[3] for ind in self.pop]
-            self.nn_scores = [ind.perf for ind in self.pop]
-        else:
-            self.ing_strs = None
-
-    def add_individual(self, genes_presence=None, genes_quantity=None):
-        self.pop.append(IndividualCocktail(pop_params=self.pop_params,
-                                           target=self.target.copy(),
-                                           target_affective_cluster=self.target_affective_cluster,
-                                           genes_presence=genes_presence,
-                                           genes_quantity=genes_quantity))
-
-    def get_elite_perf(self):
-        return np.array([e.perf for e in self.pop_elite])
-
-    def get_pop_perf(self):
-        return np.array([ind.perf for ind in self.pop])
-
-
-    def update_elite_and_get_next_pop(self):
-        time_dict = dict()
-        init_time = time.time()
-        elite_perfs = self.get_elite_perf()
-        pop_perfs = self.get_pop_perf()
-        all_perfs = np.concatenate([elite_perfs, pop_perfs])
-        temp_list = self.pop_elite + self.pop
-        time_dict['  get pop perfs'] = [time.time() - init_time]
-        init_time = time.time()
-        # update elite  population with new bests
-        indexes_sorted = np.flip(np.argsort(all_perfs))
-        new_pop_elite = [IndividualCocktail(pop_params=self.pop_params,
-                                            target=self.target.copy(),
-                                            target_affective_cluster=self.target_affective_cluster,
-                                            genes_presence=temp_list[i_new_e].genes_presence.copy(),
-                                            genes_quantity=temp_list[i_new_e].genes_quantity.copy()) for i_new_e in indexes_sorted[:self.nb_elite]]
-        time_dict['  recreate elite individuals'] = [time.time() - init_time]
-        init_time = time.time()
-        # select parents
-        rank_perfs = np.flip(np.arange(len(temp_list)))
-        sampling_probs = rank_perfs / np.sum(rank_perfs)
-        if self.mutation_params['asexual_rep'] and not self.mutation_params['crossover']:
-            new_pop_indexes = np.random.choice(indexes_sorted, p=sampling_probs, size=self.pop_size)
-            self.pop = [temp_list[i].get_child() for i in new_pop_indexes]
-        elif self.mutation_params['crossover'] and not self.mutation_params['asexual_rep']:
-            self.pop = []
-            while len(self.pop) < self.pop_size:
-                parents = np.random.choice(indexes_sorted, p=sampling_probs, size=2, replace=False)
-                self.pop.append(temp_list[parents[0]].get_child_with(temp_list[parents[1]]))
-        elif self.mutation_params['crossover'] and self.mutation_params['asexual_rep']:
-            new_pop_indexes = np.random.choice(indexes_sorted, p=sampling_probs, size=self.pop_size//2)
-            time_dict['  choose asexual parent indexes'] = [time.time() - init_time]
-            init_time = time.time()
-            self.pop = []
-            for i in new_pop_indexes:
-                child, this_time_dict = temp_list[i].get_child()
-                self.pop.append(child)
-                time_dict = self.update_time_dict(time_dict, this_time_dict)
-            time_dict['  get asexual children'] = [time.time() - init_time]
-            init_time = time.time()
-            while len(self.pop) < self.pop_size:
-                parents = np.random.choice(indexes_sorted, p=sampling_probs, size=2, replace=False)
-                child, this_time_dict = temp_list[parents[0]].get_child_with(temp_list[parents[1]])
-                self.pop.append(child)
-                time_dict = self.update_time_dict(time_dict, this_time_dict)
-            time_dict['  get sexual children'] = [time.time() - init_time]
-        self.pop_elite = new_pop_elite
-        return time_dict
-
-    def get_pop_size(self):
-        return len(self.pop)
-
-    def get_q_rep(self, ingredients, quantities):
-        ingredient_q_rep = np.zeros([len(ingredient_list)])
-        genes_presence = np.zeros([len(ingredient_list)])
-        for ing, q in zip(ingredients, quantities):
-            ingredient_q_rep[ingredient_list.index(ing)] = q
-            genes_presence[ingredient_list.index(ing)] = 1
-        return genes_presence.copy(), normalize_ingredient_q_rep(ingredient_q_rep)
-
-    def get_best_score(self, affective_cluster_check=False):
-        elite_perfs = self.get_elite_perf()
-        pop_perfs = self.get_pop_perf()
-        all_perfs = np.concatenate([elite_perfs, pop_perfs])
-        temp_list = self.pop_elite + self.pop
-        if affective_cluster_check:
-            indexes = np.array([i for i in range(len(temp_list)) if temp_list[i].does_affective_cluster_match()])
-            if indexes.size > 0:
-                temp_list = np.array(temp_list)[indexes]
-                all_perfs = all_perfs[indexes]
-        indexes_best = np.flip(np.argsort(all_perfs))
-        return np.array(all_perfs)[indexes_best], np.array(temp_list)[indexes_best]
-
-    def update_time_dict(self, main_dict, new_dict):
-        for k in new_dict.keys():
-            if k in main_dict.keys():
-                main_dict[k].append(np.sum(new_dict[k]))
-            else:
-                main_dict[k] = [np.sum(new_dict[k])]
-        return main_dict
-
-    def run_one_generation(self, verbose=True, affective_cluster_check=False):
-        time_dict = dict()
-        init_time = time.time()
-        this_time_dict = self.update_elite_and_get_next_pop()
-        time_dict['update_elite_and_pop'] = [time.time() - init_time]
-        time_dict = self.update_time_dict(time_dict, this_time_dict)
-        init_time = time.time()
-        best_perfs, best_individuals = self.get_best_score(affective_cluster_check)
-        time_dict['get best scores'] = [time.time() - init_time]
-        return best_perfs[0], time_dict
-
-    def run_evolution(self, verbose=False, print_every=10, affective_cluster_check=False, level=0):
-        best_score = -np.inf
-        time_dict = dict()
-        init_time = time.time()
-        for i in range(self.nb_generations):
-            best_score, this_time_dict = self.run_one_generation(verbose, affective_cluster_check=affective_cluster_check)
-            time_dict = self.update_time_dict(time_dict, this_time_dict)
-            if verbose and (i+1) % print_every == 0:
-                print(' ' * level + f'Gen #{i+1} - Current best perf: {best_score:.2f}, time: {time.time() - init_time:.4f}')
-                init_time = time.time()
-                #
-                # to_print = time_dict.copy()
-                # keys = sorted(to_print.keys())
-                # values = []
-                # for k in keys:
-                #     to_print[k] = np.sum(to_print[k])
-                #     values.append(to_print[k])
-                # sorted_inds = np.flip(np.argsort(values))
-                # for i in sorted_inds:
-                #     print(f'{keys[i]}: {values[i]:.4f}')
-        if verbose: print(' ' * level + f'Evolution over, best perf: {best_score:.2f}')
-        return self.get_best_score()
-
-    def print_results(self, n=3):
-        best_scores, best_ind = self.get_best_score()
-        for i in range(n):
-            best_ind[i].print_recipe(f'Candidate #{i+1}, Score: {best_scores[i]:.2f}')
-
-

src/cocktails/utilities/cocktail_utilities.py

@@ -1,220 +0,0 @@
-import numpy as np
-from src.cocktails.utilities.ingredients_utilities import ingredient2ingredient_id, ingredient_profiles, ingredients_per_type, ingredient_list, find_ingredient_from_str
-from src.cocktails.utilities.cocktail_category_detection_utilities import *
-import time
-
-# representation_keys = ['pH', 'sour', 'sweet', 'booze', 'bitter', 'fruit', 'herb',
-#                        'complex', 'spicy', 'strong', 'oaky', 'fizzy', 'colorful', 'eggy']
-representation_keys = ['sour', 'sweet', 'booze', 'bitter', 'fruit', 'herb',
-                       'complex', 'spicy', 'oaky', 'fizzy', 'colorful', 'eggy']
-representation_keys_linear = list(set(representation_keys) - set(['pH', 'complex']))
-
-ing_reps = np.array([[ingredient_profiles[k][ing_id] for ing_id in ingredient2ingredient_id.values()] for k in representation_keys]).transpose()
-
-
-def compute_cocktail_representation(profile, ingredients, quantities):
-    # computes representation of a cocktail from the recipe (ingredients, quantities) and volume
-    n = len(ingredients)
-    assert n == len(quantities)
-    quantities = np.array(quantities)
-
-    weights = quantities / np.sum(quantities)
-    rep = dict()
-
-    ing_ids = np.array([ingredient2ingredient_id[ing] for ing in ingredients])
-    # compute features as linear combination of ingredient features
-    for k in representation_keys_linear:
-        k_ing = np.array([ingredient_profiles[k][ing_id] for ing_id in ing_ids])
-        rep[k] = np.dot(weights, k_ing)
-
-    # for ph
-    # ph = - log10 x
-    phs = np.array([ingredient_profiles['pH'][ing_id] for ing_id in ing_ids])
-    concentrations = 10 ** (- phs)
-    mix_c = np.dot(weights, concentrations)
-
-    rep['pH'] = - np.log10(mix_c)
-
-    rep['complex'] = np.mean([ingredient_profiles['complex'][ing_id] for ing_id in ing_ids]) + len(ing_ids)
-
-    # compute profile after dilution
-    volume_ratio = profile['mix volume'] / profile['end volume']
-    for k in representation_keys:
-        rep['end ' + k] = rep[k] * volume_ratio
-    concentration = 10 ** (-rep['pH'])
-    end_concentration = concentration * volume_ratio
-    rep['end pH'] = - np.log10(end_concentration)
-    return rep
-
-def get_alcohol_profile(ingredients, quantities):
-    ingredients = ingredients.copy()
-    quantities = quantities.copy()
-    assert len(ingredients) == len(quantities)
-    if 'mint' in ingredients:
-        mint_ind = ingredients.index('mint')
-        ingredients.pop(mint_ind)
-        quantities.pop(mint_ind)
-    alcohol = []
-    volume_mix = np.sum(quantities)
-    weights = quantities / volume_mix
-    assert np.abs(np.sum(weights) - 1) < 1e-4
-    ingredients_list = [ing.lower() for ing in ingredient_list]
-    for ing, q in zip(ingredients, quantities):
-        id = ingredients_list.index(ing)
-        alcohol.append(ingredient_profiles['ethanol'][id])
-    alcohol = np.dot(alcohol, weights)
-    return alcohol, volume_mix
-
-def get_mix_profile(ingredients, quantities):
-    ingredients = ingredients.copy()
-    quantities = quantities.copy()
-    assert len(ingredients) == len(quantities)
-    if 'mint' in ingredients:
-        mint_ind = ingredients.index('mint')
-        ingredients.pop(mint_ind)
-        quantities.pop(mint_ind)
-    alcohol, sugar, acid = [], [], []
-    volume_mix = np.sum(quantities)
-    weights = quantities / volume_mix
-    assert np.abs(np.sum(weights) - 1) < 1e-4
-    ingredients_list = [ing.lower() for ing in ingredient_list]
-    for ing, q in zip(ingredients, quantities):
-        id = ingredients_list.index(ing)
-        sugar.append(ingredient_profiles['sugar'][id])
-        alcohol.append(ingredient_profiles['ethanol'][id])
-        acid.append(ingredient_profiles['acid'][id])
-    sugar = np.dot(sugar, weights)
-    acid = np.dot(acid, weights)
-    alcohol = np.dot(alcohol, weights)
-    return alcohol, sugar, acid
-
-
-def extract_preparation_type(instructions, recipe):
-    flag = False
-    instructions = instructions.lower()
-    egg_in_recipe = any([find_ingredient_from_str(ing_str)[1]=='egg' for ing_str in recipe[1]])
-    if 'shake' in instructions:
-        if egg_in_recipe:
-            prep_type = 'egg_shaken'
-        else:
-            prep_type = 'shaken'
-    elif 'stir' in instructions:
-        prep_type = 'stirred'
-    elif 'blend' in instructions:
-        prep_type = 'blended'
-    elif any([w in instructions for w in ['build', 'mix', 'pour', 'combine', 'place']]):
-        prep_type = 'built'
-    else:
-        prep_type = 'built'
-    if egg_in_recipe and 'shaken' not in prep_type:
-        stop = 1
-    return flag, prep_type
-
-def get_dilution_ratio(category, alcohol):
-    # formulas from the Liquid Intelligence book
-    # The formula for built was invented
-    if category == 'stirred':
-        return -1.21 * alcohol**2 + 1.246 * alcohol + 0.145
-    elif category in ['shaken', 'egg_shaken']:
-        return -1.567 * alcohol**2 + 1.742 * alcohol + 0.203
-    elif category == 'built':
-        return (-1.21 * alcohol**2 + 1.246 * alcohol + 0.145) /2
-    else:
-        return 1
-
-def get_cocktail_rep(category, ingredients, quantities, keys):
-    ingredients = ingredients.copy()
-    quantities = quantities.copy()
-    assert len(ingredients) == len(quantities)
-
-    volume_mix = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] != 'mint'])
-
-    # compute alcohol content without mint ingredient
-    ingredients2 = [ing for ing in ingredients if ing != 'mint']
-    quantities2 = [q for ing, q in zip(ingredients, quantities) if ing != 'mint']
-    weights2 = quantities2 / np.sum(quantities2)
-    assert np.abs(np.sum(weights2) - 1) < 1e-4
-    ing_ids2 = np.array([ingredient2ingredient_id[ing] for ing in ingredients2])
-    alcohol = np.array([ingredient_profiles['ethanol'][ing_id] for ing_id in ing_ids2])
-    alcohol = np.dot(alcohol, weights2)
-    dilution_ratio = get_dilution_ratio(category, alcohol)
-    end_volume = volume_mix + volume_mix * dilution_ratio
-    volume_ratio = volume_mix / end_volume
-    end_alcohol = alcohol * volume_ratio
-
-    # computes representation of a cocktail from the recipe (ingredients, quantities) and volume
-    weights = quantities / np.sum(quantities)
-    assert np.abs(np.sum(weights) - 1) < 1e-4
-    ing_ids = np.array([ingredient2ingredient_id[ing] for ing in ingredients])
-    reps = ing_reps[ing_ids]
-    cocktail_rep = np.dot(weights, reps)
-    i_complex = keys.index('end complex')
-    cocktail_rep[i_complex] = np.mean(reps[:, i_complex]) + len(ing_ids)  # complexity increases with number of ingredients
-
-    # compute profile after dilution
-    cocktail_rep = cocktail_rep * volume_ratio
-    cocktail_rep = np.concatenate([[end_volume], cocktail_rep])
-    return cocktail_rep, end_volume, end_alcohol
-
-def get_profile(category, ingredients, quantities):
-
-    volume_mix = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] != 'mint'])
-    alcohol, sugar, acid = get_mix_profile(ingredients, quantities)
-    dilution_ratio = get_dilution_ratio(category, alcohol)
-    end_volume = volume_mix + volume_mix * dilution_ratio
-    volume_ratio = volume_mix / end_volume
-    profile = {'mix volume': volume_mix,
-               'mix alcohol': alcohol,
-               'mix sugar': sugar,
-               'mix acid': acid,
-               'dilution ratio': dilution_ratio,
-               'end volume': end_volume,
-               'end alcohol': alcohol * volume_ratio,
-               'end sugar': sugar * volume_ratio,
-               'end acid': acid * volume_ratio}
-    cocktail_rep = compute_cocktail_representation(profile, ingredients, quantities)
-    profile.update(cocktail_rep)
-    return profile
-
-profile_keys = ['mix volume', 'end volume',
-                'dilution ratio',
-                'mix alcohol', 'end alcohol',
-                'mix sugar', 'end sugar',
-                'mix acid', 'end acid'] \
-               + representation_keys \
-               + ['end ' + k for k in representation_keys]
-
-def update_profile_in_datapoint(datapoint, category, ingredients, quantities):
-    profile = get_profile(category, ingredients, quantities)
-    for k in profile_keys:
-        datapoint[k] = profile[k]
-    return datapoint
-
-# define representation keys
-def get_bunch_of_rep_keys():
-    dict_rep_keys = dict()
-    # all
-    rep_keys = profile_keys
-    dict_rep_keys['all'] = rep_keys
-    # only_end
-    rep_keys = [k for k in profile_keys if 'end' in k ]
-    dict_rep_keys['only_end'] = rep_keys
-    # except_end
-    rep_keys = [k for k in profile_keys if 'end' not in k ]
-    dict_rep_keys['except_end'] = rep_keys
-    # custom
-    to_remove = ['end alcohol', 'end sugar', 'end acid', 'end pH', 'end strong']
-    rep_keys = [k for k in profile_keys if 'end' in k ]
-    for k in to_remove:
-        if k in rep_keys:
-            rep_keys.remove(k)
-    dict_rep_keys['custom'] = rep_keys
-    # custom restricted
-    to_remove = ['end alcohol', 'end sugar', 'end acid', 'end pH', 'end strong', 'end spicy', 'end oaky']
-    rep_keys = [k for k in profile_keys if 'end' in k ]
-    for k in to_remove:
-        if k in rep_keys:
-            rep_keys.remove(k)
-    dict_rep_keys['restricted'] = rep_keys
-    dict_rep_keys['affective'] = ['end booze', 'end sweet', 'end sour', 'end fizzy', 'end complex', 'end bitter', 'end spicy', 'end colorful']
-    return dict_rep_keys

src/cocktails/utilities/glass_and_volume_utilities.py

@@ -1,42 +0,0 @@
-
-
-glass_conversion = {'coupe':'coupe',
-                    'martini': 'martini',
-                    'collins': 'collins',
-                    'oldfashion': 'oldfashion',
-                    'Coupe glass': 'coupe',
-                    'Old-fashioned glass': 'oldfashion',
-                    'Martini glass': 'martini',
-                    'Nick & Nora glass': 'coupe',
-                    'Julep tin': 'oldfashion',
-                    'Collins or Pineapple shell glass': 'collins',
-                    'Collins glass': 'collins',
-                    'Rocks glass': 'oldfashion',
-                    'Highball (max 10oz/300ml)': 'collins',
-                    'Wine glass': 'coupe',
-                    'Flute glass': 'coupe',
-                    'Double old-fashioned': 'oldfashion',
-                    'Copa glass': 'coupe',
-                    'Toddy glass': 'oldfashion',
-                    'Sling glass': 'collins',
-                    'Goblet glass': 'oldfashion',
-                    'Fizz or Highball (8oz to 10oz)': 'collins',
-                    'Copper mug or Collins glass': 'collins',
-                    'Tiki mug or collins': 'collins',
-                    'Snifter glass': 'oldfashion',
-                    'Coconut shell or Collins glass': 'collins',
-                    'Martini (large 10oz) glass': 'martini',
-                    'Hurricane glass': 'collins',
-                    'Absinthe glass or old-fashioned glass': 'oldfashion'
-                    }
-glass_volume = dict(coupe = 200,
-                    collins=350,
-                    martini=200,
-                    oldfashion=320)
-assert set(glass_conversion.values()) == set(glass_volume.keys())
-
-volume_ranges = dict(stirred=(90, 97),
-                     built=(70, 75),
-                     shaken=(98, 112),
-                     egg_shaken=(130, 143),
-                     carbonated=(150, 150))

src/cocktails/utilities/ingredients_utilities.py

@@ -1,209 +0,0 @@
-# This script loads the list and profiles of our ingredients selection.
-# It defines rules to recognize ingredients from the list in recipes and the function to extract that information from ingredient strings.
-
-import pandas as pd
-from src.cocktails.config import INGREDIENTS_LIST_PATH, COCKTAILS_CSV_DATA
-import numpy as np
-
-ingredient_profiles = pd.read_csv(INGREDIENTS_LIST_PATH)
-ingredient_list = [ing.lower() for ing in ingredient_profiles['ingredient']]
-n_ingredients = len(ingredient_list)
-ingredient2ingredient_id = dict(zip(ingredient_list, range(n_ingredients)))
-
-ingredients_types = sorted(set(ingredient_profiles['type']))
-# for each type, get all ingredients
-ing_per_type = [[ing for ing in ingredient_list if ingredient_profiles['type'][ingredient_list.index(ing)] == type] for type in ingredients_types]
-ingredients_per_type = dict(zip(ingredients_types, ing_per_type))
-
-bubble_ingredients =  ['soda', 'ginger beer', 'tonic', 'sparkling wine']
-# rules to recognize ingredients in recipes.
-# in [] are separate rules with an OR relation: only one needs to be satisfied
-# within [], rules apply with and AND relation: all rules need to be satisfied.
-# ~ indicates that the following expression must NOT appear
-# simple expression indicate that the expression MUST appear.
-ingredient_search = {#'salt': ['salt'],
-                     'lime juice': [['lime', '~soda', '~lemonade', '~cordial']],
-                     'lemon juice': [['lemon', '~soda', '~lemonade']],
-                     'angostura': [['angostura', '~orange'],
-                                   ['bitter', '~campari', '~orange', '~red', '~italian', '~fernet']],
-                     'orange bitters': [['orange', 'bitter', '~bittersweet']],
-                     'orange juice': [['orange', '~bitter', '~jam', '~marmalade', '~liqueur', '~water'],
-                                      ['orange', 'squeeze']],
-                     'pineapple juice': [['pineapple']],
-                     # 'apple juice': [['apple', 'juice', '~pine']],
-                     'cranberry juice': [['cranberry', 'juice']],
-                     'cointreau': ['cointreau', 'triple sec', 'grand marnier', 'curaçao', 'curacao'],
-                     'luxardo maraschino': ['luxardo', 'maraschino', 'kirsch'],
-                     'amaretto': ['amaretto'],
-                     'benedictine': ['benedictine', 'bénédictine', 'bénedictine', 'benédictine'],
-                     'campari': ['campari', ['italian', 'red', 'bitter'], 'aperol', 'bittersweet', 'aperitivo', 'orange-red'],
-                     # 'campari': ['campari', ['italian', 'red', 'bitter']],
-                     # 'crème de violette': [['violette', 'crème'], ['crême', 'violette'], ['liqueur', 'violette']],
-                     # 'aperol': ['aperol', 'bittersweet', 'aperitivo', 'orange-red'],
-                     'green chartreuse': ['chartreuse'],
-                     'black raspberry liqueur': [['cassis', 'liqueur'],
-                                                 ['black raspberry', 'liqueur'],
-                                                 ['raspberry', 'liqueur'],
-                                                 ['strawberry', 'liqueur'],
-                                                 ['blackberry', 'liqueur'],
-                                                 ['violette', 'crème'], ['crême', 'violette'], ['liqueur', 'violette']],
-                     # 'simple syrup': [],
-                     # 'drambuie': ['drambuie'],
-                     # 'fernet branca': ['fernet', 'branca'],
-                     'gin': [['gin', '~sloe', '~ginger']],
-                     'vodka': ['vodka'],
-                     'cuban rum': [['rum', 'puerto rican'], ['light', 'rum'], ['white', 'rum'], ['rum', 'havana', '~7'], ['rum', 'bacardi']],
-                     'cognac': [['cognac', '~grand marnier', '~cointreau', '~orange']],
-                     # 'bourbon': [['bourbon', '~liqueur']],
-                     # 'tequila': ['tequila', 'pisco'],
-                     # 'tequila': ['tequila'],
-                     'scotch': ['scotch'],
-                     'dark rum': [['rum', 'age', '~bacardi', '~havana'],
-                                  ['rum', 'dark', '~bacardi', '~havana'],
-                                  ['rum', 'old', '~bacardi', '~havana'],
-                                  ['rum', 'old', '7'],
-                                  ['rum', 'havana', '7'],
-                                  ['havana', 'rum', 'especial']],
-                     'absinthe': ['absinthe'],
-                     'rye whiskey': ['rye', ['bourbon', '~liqueur']],
-                     # 'rye whiskey': ['rye'],
-                     'apricot brandy': [['apricot', 'brandy']],
-                     # 'pisco': ['pisco'],
-                     # 'cachaça': ['cachaça', 'cachaca'],
-                     'egg': [['egg', 'white', '~yolk', '~whole']],
-                     'soda': [['soda', 'water', '~lemon', '~lime']],
-                     'mint': ['mint'],
-                     'sparkling wine': ['sparkling wine', 'prosecco', 'champagne'],
-                     'ginger beer': [['ginger', 'beer'], ['ginger', 'ale']],
-                     'tonic': [['tonic'], ['7up'], ['sprite']],
-                     # 'espresso': ['espresso', 'expresso', ['café', '~liqueur', '~cream'],
-                     #              ['cafe', '~liqueur', '~cream'],
-                     #              ['coffee', '~liqueur', '~cream']],
-                     # 'southern comfort': ['southern comfort'],
-                     # 'cola': ['cola', 'coke', 'pepsi'],
-                     'double syrup': [['sugar','~raspberry'], ['simple', 'syrup'], ['double', 'syrup']],
-                     # 'grenadine': ['grenadine', ['pomegranate', 'syrup']],
-                     'grenadine': ['grenadine', ['pomegranate', 'syrup'], ['raspberry', 'syrup', '~black']],
-                     'honey syrup': ['honey', ['maple', 'syrup']],
-                     # 'raspberry syrup': [['raspberry', 'syrup', '~black']],
-                     'dry vermouth': [['vermouth', 'dry'], ['vermouth', 'white'], ['vermouth', 'french'], 'lillet'],
-                     'sweet vermouth': [['vermouth', 'sweet'], ['vermouth', 'red'], ['vermouth', 'italian']],
-                     # 'lillet blanc': ['lillet'],
-                     'water': [['water', '~sugar', '~coconut', '~soda', '~tonic', '~honey', '~orange', '~melon']]
-                     }
-# check that there is a rule for all ingredients in the list
-assert sorted(ingredient_list) == sorted(ingredient_search.keys()), 'ing search dict keys do not match ingredient list'
-
-def get_ingredients_info():
-    data = pd.read_csv(COCKTAILS_CSV_DATA)
-    max_ingredients, ingredient_set, liquor_set, liqueur_set, vermouth_set = get_max_n_ingredients(data)
-    ingredient_list = sorted(ingredient_set)
-    alcohol = sorted(liquor_set.union(liqueur_set).union(vermouth_set).union(set(['sparkling wine'])))
-    ind_alcohol = [i for i in range(len(ingredient_list)) if ingredient_list[i] in alcohol]
-    return max_ingredients, ingredient_list, ind_alcohol
-
-def get_max_n_ingredients(data):
-    max_count = 0
-    ingredient_set = set()
-    alcohol_set = set()
-    liqueur_set = set()
-    vermouth_set = set()
-    ing_str = np.array(data['ingredients_str'])
-    for i in range(len(data['names'])):
-        ingredients, quantities = extract_ingredients(ing_str[i])
-        max_count = max(max_count, len(ingredients))
-        for ing in ingredients:
-            ingredient_set.add(ing)
-            if ing in ingredients_per_type['liquor']:
-                alcohol_set.add(ing)
-            if ing in ingredients_per_type['liqueur']:
-                liqueur_set.add(ing)
-            if ing in ingredients_per_type['vermouth']:
-                vermouth_set.add(ing)
-    return max_count, ingredient_set, alcohol_set, liqueur_set, vermouth_set
-
-def find_ingredient_from_str(ing_str):
-    # function that assigns an ingredient string to one of the ingredient if possible, following the rules defined above.
-    # return a flag and the ingredient string. When flag is false, the ingredient has not been found and the cocktail is rejected.
-    ing_str = ing_str.lower()
-    flags = []
-    for k in ingredient_list:
-        or_flags = [] # get flag for each of several conditions
-        for i_p, pattern in enumerate(ingredient_search[k]):
-            or_flags.append(True)
-            if isinstance(pattern, str):
-                if pattern[0] == '~' and pattern[1:] in ing_str:
-                    or_flags[-1] = False
-                elif pattern[0] != '~' and pattern not in ing_str:
-                    or_flags[-1] = False
-            elif isinstance(pattern, list):
-                for element in pattern:
-                    if element[0] == '~':
-                        or_flags[-1] = or_flags[-1] and not element[1:] in ing_str
-                    else:
-                        or_flags[-1] = or_flags[-1] and element in ing_str
-            else:
-                raise ValueError
-        flags.append(any(or_flags))
-    if sum(flags) > 1:
-        print(ing_str)
-        for i_f, f in enumerate(flags):
-            if f:
-                print(ingredient_list[i_f])
-        stop = 1
-        return True, ingredient_list[flags.index(True)]
-    elif sum(flags) == 0:
-        # if 'grape' not in ing_str:
-        #     print('\t\t Not found:', ing_str)
-        return True, None
-    else:
-        return False, ingredient_list[flags.index(True)]
-
-def get_cocktails_per_ingredient(ing_strs):
-    cocktails_per_ing = dict(zip(ingredient_list, [[] for _ in range(len(ingredient_list))]))
-    for i_ing, ing_str in enumerate(ing_strs):
-        ingredients, _ = extract_ingredients(ing_str)
-        for ing in ingredients:
-            cocktails_per_ing[ing].append(i_ing)
-    return cocktails_per_ing
-
-def extract_ingredients(ingredient_str):
-    # extract list of ingredients and quantities from an formatted ingredient string (reverse of format_ingredients)
-    ingredient_str = ingredient_str[1: -1]
-    words = ingredient_str.split(',')
-    ingredients = []
-    quantities = []
-    for i in range(len(words)//2):
-        ingredients.append(words[2 * i][1:])
-        quantities.append(float(words[2 * i + 1][:-1]))
-    return ingredients, quantities
-
-def format_ingredients(ingredients, quantities):
-    # format an ingredient string from the lists of ingredients and quantities (reverse of extract_ingredients)
-    out = '['
-    for ing, q in zip(ingredients, quantities):
-        if ing[-1] == ' ':
-            ingre = ing[:-1]
-        else:
-            ingre = ing
-        out += f'({ingre},{q}),'
-    out = out[:-1] + ']'
-    return out
-
-
-def get_ingredient_count(data):
-    # get count of ingredients in the whole dataset
-    ingredient_counts = dict(zip(ingredient_list, [0] * len(ingredient_list)))
-    for i in range(len(data['names'])):
-        if data['to_keep'][i]:
-            ingredients, _ = extract_ingredients(data['ingredients_str'][i])
-            for i in ingredients:
-                ingredient_counts[i] += 1
-    return ingredient_counts
-
-def add_counts_to_ingredient_list(data):
-    # update the list of ingredients to add their count of occurence in dataset.
-    ingredient_counts = get_ingredient_count(data)
-    counts = [ingredient_counts[k] for k in ingredient_list]
-    ingredient_profiles['counts'] = counts
-    ingredient_profiles.to_csv(INGREDIENTS_LIST_PATH, index=False)

src/cocktails/utilities/other_scrubbing_utilities.py

@@ -1,240 +0,0 @@
-import numpy as np
-import pickle
-from src.cocktails.utilities.cocktail_utilities import get_profile, profile_keys
-from src.cocktails.utilities.ingredients_utilities import extract_ingredients, ingredient_list, ingredient_profiles
-from src.cocktails.utilities.glass_and_volume_utilities import glass_volume, volume_ranges
-
-one_dash = 1
-one_splash = 6
-one_tablespoon = 15
-one_barspoon = 5
-fill_rate = 0.8
-quantity_factors ={'ml':1,
-                   'cl':10,
-                   'splash':one_splash,
-                   'splashes':one_splash,
-                   'dash':one_dash,
-                   'dashes':one_dash,
-                   'spoon':one_barspoon,
-                   'spoons':one_barspoon,
-                   'tablespoon':one_tablespoon,
-                   'barspoons':one_barspoon,
-                   'barspoon':one_barspoon,
-                   'bar spoons': one_barspoon,
-                   'bar spoon': one_barspoon,
-                   'tablespoons':one_tablespoon,
-                   'teaspoon':5,
-                   'teaspoons':5,
-                   'drop':0.05,
-                   'drops':0.05}
-quantitiy_keys = sorted(quantity_factors.keys())
-indexes_keys = np.flip(np.argsort([len(k) for k in quantitiy_keys]))
-quantity_factors_keys = list(np.array(quantitiy_keys)[indexes_keys])
-
-keys_to_track = ['names', 'urls', 'glass', 'garnish', 'recipe', 'how_to', 'review', 'taste_rep', 'valid']
-keys_to_add = ['category', 'subcategory', 'ingredients_str', 'ingredients', 'quantities', 'to_keep']
-keys_to_update = ['glass']
-keys_for_csv = ['names', 'category', 'subcategory', 'ingredients_str', 'urls', 'glass', 'garnish', 'how_to', 'review', 'taste_rep'] + profile_keys
-
-to_replace_q = {' fresh': ''}
-to_replace_ing = {'maple syrup': 'honey syrup',
-                  'agave syrup': 'honey syrup',
-                  'basil': 'mint'}
-
-def print_recipe(unit='mL', ingredient_str=None, ingredients=None, quantities=None, name='', cat='', to_print=True):
-    str_out = ''
-    if ingredient_str is None:
-        assert len(ingredients) == len(quantities), 'provide either ingredient_str, or list ingredients and quantities'
-    else:
-        assert ingredients is None and quantities is None, 'provide either ingredient_str, or list ingredients and quantities'
-        ingredients, quantities = extract_ingredients(ingredient_str)
-
-    str_out += f'\nRecipe:'
-    if name != '' and name is not None: str_out += f' {name}'
-    if cat != '': str_out += f' ({cat})'
-    str_out += '\n'
-    for i in range(len(ingredients)):
-        # get quantifier
-        if ingredients[i] == 'egg':
-            quantities[i] = 1
-            ingredients[i] = 'egg white'
-            if unit == 'mL':
-                quantifier = ' (30 mL)'
-            elif unit == 'oz':
-                quantifier = ' (1 fl oz)'
-            else:
-                raise ValueError
-        elif ingredients[i] in ['angostura', 'orange bitters']:
-            quantities[i] = max(1, int(quantities[i] / 0.6))
-            quantifier = ' dash'
-            if quantities[i] > 1: quantifier += 'es'
-        elif ingredients[i] == 'mint':
-            if quantities[i] > 1: quantifier = ' leaves'
-            else: quantifier = ' leaf'
-        else:
-            if unit == "oz":
-                quantities[i] = float(f"{quantities[i] * 0.033814:.3f}")  # convert to fl oz
-                quantifier = ' fl oz'
-            else:
-                quantifier = ' mL'
-        str_out += f'   {quantities[i]}{quantifier} - {ingredients[i]}\n'
-
-    if to_print:
-        print(str_out)
-    return str_out
-
-
-def test_datapoint(datapoint, category, ingredients, quantities):
-    # run checks
-    ingredient_indexes = [ingredient_list.index(ing) for ing in ingredients]
-    profile = get_profile(category, ingredients, quantities)
-    volume = profile['end volume']
-    alcohol = profile['end alcohol']
-    acid = profile['end acid']
-    sugar = profile['end sugar']
-    # check volume
-    if datapoint['glass'] != None:
-        if volume > glass_volume[datapoint['glass']] * fill_rate:
-            # recompute quantities for it to match
-            ratio = fill_rate *  glass_volume[datapoint['glass']] / volume
-            for i_q in range(len(quantities)):
-                quantities[i_q] = float(f'{quantities[i_q] * ratio:.2f}')
-    # check alcohol
-    assert alcohol < 30, 'too boozy'
-    assert alcohol < 5, 'not boozy enough'
-    assert acid < 2, 'too much acid'
-    assert sugar < 20, 'too much sugar'
-    assert len(ingredients) > 1, 'only one ingredient'
-    if len(set(ingredients)) != len(ingredients):
-        i_doubles = []
-        s_ing = set()
-        for i, ing in enumerate(ingredients):
-            if ing in s_ing:
-                i_doubles.append(i)
-            else:
-                s_ing.add(ing)
-        ingredient_double_ok = ['mint', 'cointreau', 'lemon juice', 'cuban rum', 'double syrup']
-        if len(i_doubles) == 1 and ingredients[i_doubles[0]] in ingredient_double_ok:
-            ing_double = ingredients[i_doubles[0]]
-            double_q = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] == ing_double])
-            ingredients.pop(i_doubles[0])
-            quantities.pop(i_doubles[0])
-            quantities[ingredients.index(ing_double)] = double_q
-        else:
-            assert False, f'double ingredient, not {ingredient_double_ok}'
-    lemon_lime_q = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] in ['lime juice', 'lemon juice']])
-    assert lemon_lime_q <= 45, 'too much lemon and lime'
-    salt_q = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] == 'salt'])
-    assert salt_q <= 8, 'too much salt'
-    bitter_q = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] in ['angostura', 'orange bitters']])
-    assert bitter_q <= 5 * one_dash, 'too much bitter'
-    absinthe_q = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] == 'absinthe'])
-    if absinthe_q > 4 * one_dash:
-        mix_volume = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] != 'mint'])
-        assert absinthe_q < 0.5 * mix_volume, 'filter absinthe glasses'
-    if any([w in datapoint['how_to'] or any([w in ing.lower() for ing in datapoint['recipe'][1]]) for w in ['warm', 'boil', 'hot']]) and 'shot' not in datapoint['how_to']:
-        assert False
-    water_q = np.sum([quantities[i] for i in range(len(ingredients)) if ingredients[i] == 'water'])
-    assert water_q < 40
-    # n_liqueur = np.sum([ingredient_profiles['type'][i].lower() == 'liqueur' for i in ingredient_indexes])
-    # assert n_liqueur <= 2
-    n_liqueur_and_vermouth = np.sum([ingredient_profiles['type'][i].lower() in ['liqueur', 'vermouth'] for i in ingredient_indexes])
-    assert n_liqueur_and_vermouth <= 3
-    return ingredients, quantities
-
-def run_battery_checks_difford(datapoint, category, ingredients, quantities):
-    flag = False
-    try:
-        ingredients, quantities = test_datapoint(datapoint, category, ingredients, quantities)
-    except:
-        flag = True
-        print(datapoint["names"])
-        print(datapoint["urls"])
-        ingredients, quantities = None, None
-
-    return flag, ingredients, quantities
-
-def tambouille(q, ingredients_scrubbed, quantities_scrubbed, cat):
-    # ugly
-    ing_scrubbed = ingredients_scrubbed[len(quantities_scrubbed)]
-    if q == '4 cube' and ing_scrubbed == 'pineapple juice':
-        q = '20 ml'
-    elif 'top up with' in q:
-        volume_so_far = np.sum([quantities_scrubbed[i] for i in range(len(quantities_scrubbed)) if ingredients_scrubbed[i] != 'mint'])
-        volume_mix = np.sum(volume_ranges[cat]) / 2
-        if (volume_mix - volume_so_far) < 15:
-            q = '15 ml'#
-        else:
-            q = str(int(volume_mix - volume_so_far)) + ' ml'
-    elif q == '1 pinch' and ing_scrubbed == 'salt':
-        q = '2 drops'
-    elif 'cube' in q and ing_scrubbed == 'double syrup':
-        q = f'{float(q.split(" ")[0]) * 2 * 1.7:.2f} ml'  #2g per cube, 1.7 is ratio solid / syrup
-    elif 'wedge' in q:
-        if ing_scrubbed == 'orange juice':
-            vol = 70
-        elif ing_scrubbed == 'lime juice':
-            vol = 30
-        elif ing_scrubbed == 'lemon juice':
-            vol = 45
-        elif ing_scrubbed == 'pineapple juice':
-            vol = 140
-        factor = float(q.split(' ')[0]) * 0.15 # consider a wedge to be 0.15*the fruit.
-        q = f'{factor * vol:.2f} ml'
-    elif 'slice' in q:
-        if ing_scrubbed == 'orange juice':
-            vol = 70
-        elif ing_scrubbed == 'lime juice':
-            vol = 30
-        elif ing_scrubbed == 'lemon juice':
-            vol = 45
-        elif ing_scrubbed == 'pineapple juice':
-            vol = 140
-        f = q.split(' ')[0]
-        if len(f.split('⁄')) > 1:
-            frac = f.split('⁄')
-            factor = float(frac[0]) / float(frac[1])
-        else:
-            factor = float(f)
-        factor *= 0.1 # consider a slice to be 0.1*the fruit.
-        q = f'{factor * vol:.2f} ml'
-    elif q == '1 whole' and ing_scrubbed == 'luxardo maraschino':
-        q = '10 ml'
-    elif ing_scrubbed == 'egg' and 'ml' not in q:
-        q = f'{float(q) * 30:.2f} ml'  # 30 ml per egg
-    return q
-
-
-def compute_eucl_dist(a, b):
-    return np.sqrt(np.sum((a - b)**2))
-
-def evaluate_with_quadruplets(representations, strategy='all'):
-    with open(QUADRUPLETS_PATH, 'rb') as f:
-        data = pickle.load(f)
-    data = list(data.values())
-    quadruplets = []
-    if strategy != 'all':
-        for d in data:
-            if d[0] == strategy:
-                quadruplets.append(d[1:])
-    elif strategy == 'all':
-        for d in data:
-            quadruplets.append(d[1:])
-    else:
-        raise ValueError
-
-    scores = []
-    for q in quadruplets:
-        close = q[0]
-        if len(close) == 2:
-            far = q[1]
-            distance_close = compute_eucl_dist(representations[close[0]], representations[close[1]])
-            distances_far = [compute_eucl_dist(representations[far[i][0]], representations[far[i][1]]) for i in range(len(far))]
-            scores.append(distance_close < np.min(distances_far))
-    if len(scores) == 0:
-        score = np.nan
-    else:
-        score = np.mean(scores)
-    return score
-
-

src/debugger.py

@@ -1,180 +0,0 @@
-import os.path
-
-# from src.music.data_collection.is_audio_solo_piano import calculate_piano_solo_prob
-from src.music.utils import load_audio
-from src.music.config import FPS
-import pretty_midi as pm
-import numpy as np
-from src.music.config import MUSIC_REP_PATH, MUSIC_NN_PATH
-from sklearn.neighbors import NearestNeighbors
-from src.cocktails.config import FULL_COCKTAIL_REP_PATH, COCKTAIL_NN_PATH, COCKTAILS_CSV_DATA
-# from src.cocktails.pipeline.get_affect2affective_cluster import get_affective_cluster_centers
-from src.cocktails.utilities.other_scrubbing_utilities import print_recipe
-from src.music.utils import get_all_subfiles_with_extension
-import os
-import pickle
-import pandas as pd
-import time
-
-keyword = 'b256_r128_represented'
-def load_reps(rep_path, sample_size=None):
-    if sample_size:
-        with open(rep_path + f'all_reps_unnormalized_sample{sample_size}.pickle', 'rb') as f:
-            data = pickle.load(f)
-    else:
-        with open(rep_path + f'music_reps_unnormalized.pickle', 'rb') as f:
-            data = pickle.load(f)
-    reps = data['reps']
-    # playlists = [r.split(f'_{keyword}')[0].split('/')[-1] for r in data['paths']]
-    playlists = [r.split(f'{keyword}')[1].split('/')[1] for r in data['paths']]
-    n_data, dim_data = reps.shape
-    return reps, data['paths'], playlists, n_data, dim_data
-
-class Debugger():
-    def __init__(self, verbose=True):
-
-        if verbose: print('Setting up debugger.')
-        if not os.path.exists(MUSIC_NN_PATH):
-            reps_path = MUSIC_REP_PATH + 'music_reps_unnormalized.pickle'
-            if not os.path.exists(reps_path):
-                all_rep_path = get_all_subfiles_with_extension(MUSIC_REP_PATH, max_depth=3, extension='.txt', current_depth=0)
-                all_data = []
-                new_all_rep_path = []
-                for i_r, r in enumerate(all_rep_path):
-                    if 'mean_std' not in r:
-                        all_data.append(np.loadtxt(r))
-                        assert len(all_data[-1]) == 128
-                        new_all_rep_path.append(r)
-                data = np.array(all_data)
-                to_save = dict(reps=data,
-                               paths=new_all_rep_path)
-                with open(reps_path, 'wb') as f:
-                    pickle.dump(to_save, f)
-
-            reps, self.rep_paths, playlists, n_data, self.dim_rep_music = load_reps(MUSIC_REP_PATH)
-            self.nn_model_music = NearestNeighbors(n_neighbors=6, metric='cosine')
-            self.nn_model_music.fit(reps)
-            to_save = dict(nn_model=self.nn_model_music,
-                           rep_paths=self.rep_paths,
-                           dim_rep_music=self.dim_rep_music)
-            with open(MUSIC_NN_PATH, 'wb') as f:
-                pickle.dump(to_save, f)
-        else:
-            with open(MUSIC_NN_PATH, 'rb') as f:
-                data = pickle.load(f)
-            self.nn_model_music = data['nn_model']
-            self.rep_paths = data['rep_paths']
-            self.dim_rep_music = data['dim_rep_music']
-        if verbose: print(f'  {len(self.rep_paths)} songs, representation dim: {self.dim_rep_music}')
-        self.rep_paths = np.array(self.rep_paths)
-        if not os.path.exists(COCKTAIL_NN_PATH):
-            cocktail_reps = np.loadtxt(FULL_COCKTAIL_REP_PATH)
-            # cocktail_reps = (cocktail_reps - cocktail_reps.mean(axis=0)) / cocktail_reps.std(axis=0)
-            self.nn_model_cocktail = NearestNeighbors(n_neighbors=6)
-            self.nn_model_cocktail.fit(cocktail_reps)
-            self.dim_rep_cocktail = cocktail_reps.shape[1]
-            self.n_cocktails = cocktail_reps.shape[0]
-            to_save = dict(nn_model=self.nn_model_cocktail,
-                           dim_rep_cocktail=self.dim_rep_cocktail,
-                           n_cocktails=self.n_cocktails)
-            with open(COCKTAIL_NN_PATH, 'wb') as f:
-                pickle.dump(to_save, f)
-        else:
-            with open(COCKTAIL_NN_PATH, 'rb') as f:
-                data = pickle.load(f)
-            self.nn_model_cocktail = data['nn_model']
-            self.dim_rep_cocktail = data['dim_rep_cocktail']
-            self.n_cocktails = data['n_cocktails']
-        if verbose: print(f'  {self.n_cocktails} cocktails, representation dim: {self.dim_rep_cocktail}')
-
-        self.cocktail_data = pd.read_csv(COCKTAILS_CSV_DATA)
-        # self.affective_cluster_centers = get_affective_cluster_centers()
-        self.keys_to_print = ['mse_reconstruction', 'nearest_cocktail_recipes', 'nearest_cocktail_urls',
-                              'nn_music_dists', 'nn_music', 'dim_rep', 'nb_notes', 'audio_len', 'piano_solo_prob', 'recipe_score', 'cocktail_rep']
-        # 'affect', 'affective_cluster_id', 'affective_cluster_center',
-
-
-    def get_nearest_songs(self, music_rep):
-        dists, indexes = self.nn_model_music.kneighbors(music_rep.reshape(1, -1))
-        indexes = indexes.flatten()[:5]
-        rep_paths = [r.split('/')[-1] for r in self.rep_paths[indexes[:5]]]
-        return rep_paths, dists.flatten().tolist()
-
-    def get_nearest_cocktails(self, cocktail_rep):
-        dists, indexes = self.nn_model_cocktail.kneighbors(cocktail_rep.reshape(1, -1))
-        indexes = indexes.flatten()
-        nn_names = np.array(self.cocktail_data['names'])[indexes].tolist()
-        nn_urls = np.array(self.cocktail_data['urls'])[indexes].tolist()
-        nn_recipes = [print_recipe(ingredient_str=ing_str, to_print=False) for ing_str in np.array(self.cocktail_data['ingredients_str'])[indexes]]
-        nn_ing_strs = np.array(self.cocktail_data['ingredients_str'])[indexes].tolist()
-        return indexes, nn_names, nn_urls, nn_recipes, nn_ing_strs
-
-    def extract_info(self, all_paths, affective_cluster_id, affect, cocktail_rep, music_reconstruction, recipe_score, verbose=False, level=0):
-        if verbose: print(' ' * level + 'Extracting debug info..')
-        init_time = time.time()
-        debug_dict = dict()
-        debug_dict['all_paths'] = all_paths
-        debug_dict['recipe_score'] = recipe_score
-
-        if all_paths['audio_path'] != None:
-            # is it piano?
-            debug_dict['piano_solo_prob'] = None#float(calculate_piano_solo_prob(all_paths['audio_path'])[0])
-            # how long is the audio
-            (audio, _) = load_audio(all_paths['audio_path'], sr=FPS, mono=True)
-            debug_dict['audio_len'] = int(len(audio) / FPS)
-        else:
-            debug_dict['piano_solo_prob'] = None
-            debug_dict['audio_len'] = None
-
-        # how many notes?
-        midi = pm.PrettyMIDI(all_paths['processed_path'])
-        debug_dict['nb_notes'] = len(midi.instruments[0].notes)
-
-        # dimension of music rep
-        representation = np.loadtxt(all_paths['representation_path'])
-        debug_dict['dim_rep'] = representation.shape[0]
-
-        # closest songs in dataset
-        debug_dict['nn_music'], debug_dict['nn_music_dists'] = self.get_nearest_songs(representation)
-
-        # get affective cluster info
-        # debug_dict['affective_cluster_id'] = affective_cluster_id[0]
-        # debug_dict['affective_cluster_center'] = self.affective_cluster_centers[affective_cluster_id].flatten().tolist()
-        # debug_dict['affect'] = affect.flatten().tolist()
-        indexes, nn_names, nn_urls, nn_recipes, nn_ing_strs = self.get_nearest_cocktails(cocktail_rep)
-        debug_dict['cocktail_rep'] = cocktail_rep.copy().tolist()
-        debug_dict['nearest_cocktail_indexes'] = indexes.tolist()
-        debug_dict['nn_ing_strs'] = nn_ing_strs
-        debug_dict['nearest_cocktail_names'] = nn_names
-        debug_dict['nearest_cocktail_urls'] = nn_urls
-        debug_dict['nearest_cocktail_recipes'] = nn_recipes
-
-        debug_dict['music_reconstruction'] = music_reconstruction.tolist()
-        debug_dict['mse_reconstruction'] = ((music_reconstruction - representation) ** 2).mean()
-        self.debug_dict = debug_dict
-        if verbose: print(' ' * (level + 2) + f'Debug info extracted in {int(time.time() - init_time)} seconds.')
-
-        return self.debug_dict
-
-    def print_debug(self, level=0):
-        print(' ' * level + '__DEBUGGING INFO__')
-        for k in self.keys_to_print:
-            to_print = self.debug_dict[k]
-            if k == 'nearest_cocktail_recipes':
-                to_print = self.debug_dict[k].copy()
-                for i in range(len(to_print)):
-                    to_print[i] = to_print[i].replace('\n', '').replace('\t', '').replace('()', '')
-            if k == "nn_music":
-                to_print = self.debug_dict[k].copy()
-                for i in range(len(to_print)):
-                    to_print[i] = to_print[i].replace('encoded_new_structured_', '').replace('_represented.txt', '')
-            to_print_str = f'{to_print}'
-            if isinstance(to_print, float):
-                to_print_str = f'{to_print:.2f}'
-            elif isinstance(to_print, list):
-                if isinstance(to_print[0], float):
-                    to_print_str = '['
-                    for element in to_print:
-                        to_print_str += f'{element:.2f}, '
-                    to_print_str = to_print_str[:-2] + ']'
-            print(' ' * (level + 2) + f'{k} : ' + to_print_str)

src/music/config.py

@@ -1,72 +0,0 @@
-import numpy as np
-import os
-
-REPO_PATH = '/'.join(os.path.abspath(__file__).split('/')[:-3]) + '/'
-AUDIO_PATH = REPO_PATH + 'data/music/audio/'
-MIDI_PATH = REPO_PATH + 'data/music/midi/'
-MUSIC_PATH = REPO_PATH + 'data/music/'
-PROCESSED_PATH = REPO_PATH + 'data/music/processed/'
-ENCODED_PATH = REPO_PATH + 'data/music/encoded/'
-HANDCODED_REP_PATH = MUSIC_PATH + 'handcoded_reps/'
-DATASET_PATH = REPO_PATH + 'data/music/encoded_new_structured/diverse_piano/'
-SYNTH_RECORDED_AUDIO_PATH = AUDIO_PATH + 'synth_audio_recorded/'
-SYNTH_RECORDED_MIDI_PATH = MIDI_PATH + 'synth_midi_recorded/'
-CHECKPOINTS_PATH = REPO_PATH + 'checkpoints/'
-EXPERIMENT_PATH = REPO_PATH + 'experiments/'
-SEED = 0
-
-# params for data download
-ALL_URL_PATH = REPO_PATH + 'data/music/audio/all_urls.pickle'
-ALL_FAILED_URL_PATH = REPO_PATH + 'data/music/audio/all_failed_urls.pickle'
-RATE_AUDIO_SAVE = 16000
-FROM_URL_PATH = AUDIO_PATH + 'from_url/'
-
-# params transcription
-CHKPT_PATH_TRANSCRIPTION = REPO_PATH + 'checkpoints/piano_transcription/note_F1=0.9677_pedal_F1=0.9186.pth'  # transcriptor chkpt path
-FPS = 16000
-RANDOM_CROP = True  # whether to use random crops in case of cropped audio
-CROP_LEN = 26 * 60
-
-# params midi scrubbing and processing
-MAX_DEPTH = 5  # max depth when searching in folders for audio files
-MAX_GAP_IN_SONG = 10 # in secs
-MIN_LEN = 20  # actual min len could go down to MIN_LEN - 2 * (REMOVE_FIRST_AND_LAST / 5)
-MAX_LEN = 25 * 60  # maximum audio len for playlist downloads, and maximum audio length for transcription (in sec)
-MIN_NB_NOTES = 80  # min nb of notes per minute of recording
-REMOVE_FIRST_AND_LAST = 10  # will be divided by 5 if cutting this makes the song fall below min len
-
-# parameters encoding
-NOISE_INJECTED = True
-AUGMENTATION = True
-NB_AUG = 4 if AUGMENTATION else 0
-RANGE_NOTE_ON = 128
-RANGE_NOTE_OFF = 128
-RANGE_VEL = 32
-RANGE_TIME_SHIFT = 100
-MAX_EMBEDDING = RANGE_VEL + RANGE_NOTE_OFF + RANGE_TIME_SHIFT + RANGE_NOTE_ON
-MAX_TEST_SIZE = 1000
-CHECKSUM_PATH = REPO_PATH + 'data/music/midi/checksum.pickle'
-CHUNK_SIZE = 512
-
-ALL_AUGMENTATIONS = []
-for p in [-3, -2, -1, 1, 2, 3]:
-    ALL_AUGMENTATIONS.append((p))
-ALL_AUGMENTATIONS = np.array(ALL_AUGMENTATIONS)
-
-ALL_NOISE = []
-for s in [-5, -2.5, 0, 2.5, 5]:
-    for p in np.arange(-6, 7):
-        if not ((s == 0) and (p==0)):
-            ALL_NOISE.append((s, p))
-ALL_NOISE = np.array(ALL_NOISE)
-
-# music transformer params
-REP_MODEL_NAME = REPO_PATH + "checkpoints/music_representation/sentence_embedding/smallbert_b256_r128_1/best_model"
-MUSIC_REP_PATH = REPO_PATH + "checkpoints/b256_r128_represented/"
-MUSIC_NN_PATH = REPO_PATH + "checkpoints/music_representation/b256_r128_represented/nn_model.pickle"
-
-TRANSLATION_VAE_CHKP_PATH = REPO_PATH + "checkpoints/music2cocktails/music2flavor/b256_r128_classif001_ld40_meanstd_regground2.5_egg_bubbles/"
-
-# piano solo evaluation
-# META_DATA_PIANO_EVAL_PATH = REPO_PATH + 'data/music/audio/is_piano.csv'
-# CHKPT_PATH_PIANO_EVAL = REPO_PATH + 'data/checkpoints/piano_detection/piano_solo_model_32k.pth'

src/music/pipeline/audio2midi.py

@@ -1,52 +0,0 @@
-import torch
-import piano_transcription_inference
-import numpy as np
-import os
-import sys
-sys.path.append('../../')
-from src.music.utils import get_out_path, load_audio
-from src.music.config import CHKPT_PATH_TRANSCRIPTION, FPS, MIN_LEN, CROP_LEN
-# import librosa
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-TRANSCRIPTOR = piano_transcription_inference.PianoTranscription(device=device,
-                                                                checkpoint_path=CHKPT_PATH_TRANSCRIPTION)
-
-def audio2midi(audio_path, midi_path=None, crop=CROP_LEN, random_crop=True, verbose=False, level=0):
-    if verbose and crop < MIN_LEN + 2:
-        print('crop is inferior to the minimal length of a tune')
-    assert '.mp3' == audio_path[-4:]
-    if midi_path is None:
-        midi_path, _, _ = get_out_path(in_path=audio_path, in_word='audio', out_word='midi', out_extension='.mid')
-
-    if verbose: print(' ' * level + f'Transcribing {audio_path}.')
-    if os.path.exists(midi_path):
-        if verbose: print(' ' * (level + 2) + 'Midi file already exists.')
-        return midi_path, ''
-
-    error_msg = 'Error in transcription. '
-    try:
-        error_msg += 'Maybe in audio loading?'
-        (audio, _) = load_audio(audio_path,
-                                sr=FPS,
-                                mono=True)
-        error_msg += ' Nope. Cropping?'
-        if isinstance(crop, int) and len(audio) > FPS * crop:
-            rc_str = ' (random crop)' if random_crop else ' (start crop)'
-            if verbose: print(' ' * (level + 2) + f'Cropping the song to {crop}s before transcription{rc_str}. ')
-            size_crop = FPS * crop
-            if random_crop:
-                index_begining = np.random.randint(len(audio) - size_crop - 1)
-            else:
-                index_begining = 0
-            audio = audio[index_begining: index_begining + size_crop]
-        error_msg += ' Nope. Transcription?'
-        TRANSCRIPTOR.transcribe(audio, midi_path)
-        error_msg += ' Nope.'
-        extra = f' Saved to {midi_path}' if midi_path else ''
-        if verbose: print(' ' * (level + 2) + f'Success! {extra}')
-        return midi_path, ''
-    except:
-        if verbose: print(' ' * (level + 2) + 'Transcription failed.')
-        if os.path.exists(midi_path):
-            os.remove(midi_path)
-        return None, error_msg + ' Yes.'

src/music/pipeline/audio2piano_solo_prob.py

@@ -1,47 +0,0 @@
-import numpy as np
-import librosa
-import sys
-sys.path.append('../../../data/')
-from src.music.utilities.processing_models import piano_detection_model
-from src.music.config import CHKPT_PATH_PIANO_EVAL
-
-PIANO_SOLO_DETECTOR = piano_detection_model.PianoSoloDetector(CHKPT_PATH_PIANO_EVAL)
-exclude_playlist_folders = ['synth_audio_recorded', 'from_url']
-
-def clean_start_and_end_blanks(probs):
-    if len(probs) > 20:
-        # clean up to 10s in each direction
-        n_zeros_start = 0
-        for i in range(10):
-            if probs[i] <= 0.001:
-                n_zeros_start += 1
-            else:
-                break
-        n_zeros_end = 0
-        for i in range(10):
-            if probs[-(i + 1)] <= 0.001:
-                n_zeros_end += 1
-            else:
-                break
-        if n_zeros_end == 0:
-            return probs[n_zeros_start:]
-        else:
-            return probs[n_zeros_start:-n_zeros_end]
-    else:
-        return probs
-
-def calculate_piano_solo_prob(audio_path, verbose=False):
-    """Calculate the piano solo probability of all downloaded mp3s, and append
-    the probability to the meta csv file. Code from https://github.com/bytedance/GiantMIDI-Piano
-    """
-    try:
-        error_msg = 'Error in audio loading?'
-        (audio, _) = librosa.core.load(audio_path, sr=piano_detection_model.SR, mono=True)
-        error_msg += ' Nope. Error in solo prediction?'
-        probs = PIANO_SOLO_DETECTOR.predict(audio)
-        # probs = clean_start_and_end_blanks(probs)  # remove blanks at start and end (<=10s each way). If not piano, the rest of the song will be enough to tell.
-        piano_solo_prob = np.mean(probs)
-        error_msg += ' Nope. '
-        return piano_solo_prob, ''
-    except:
-        return None, error_msg + 'Yes.'

src/music/pipeline/encoded2rep.py

@@ -1,88 +0,0 @@
-from src.music.utilities.representation_learning_utilities.constants import *
-from src.music.config import REP_MODEL_NAME
-from src.music.utils import  get_out_path
-import pickle
-import numpy as np
-# from transformers import AutoModel, AutoTokenizer
-from torch import nn
-from src.music.representation_learning.sentence_transfo.sentence_transformers import SentenceTransformer
-
-class Argument(object):
-    def __init__(self, adict):
-        self.__dict__.update(adict)
-
-class RepModel(nn.Module):
-    def __init__(self, model, model_name):
-        super().__init__()
-        if 't5' in model_name:
-            self.model = model.get_encoder()
-        else:
-            self.model = model
-        self.model.eval()
-
-    def forward(self, inputs):
-        with torch.no_grad():
-            out = self.model(inputs, output_hidden_states=True)
-        embeddings = out.hidden_states[-1]
-        return torch.mean(embeddings[0], dim=0)
-
-# def get_trained_music_LM(model_name):
-#     tokenizer = AutoTokenizer.from_pretrained(model_name, use_auth_token=True)
-#     model = RepModel(AutoModel.from_pretrained(model_name, use_auth_token=True), model_name)
-#
-#     return model, tokenizer
-
-def get_trained_sentence_embedder(model_name):
-    model = SentenceTransformer(model_name)
-    return model
-
-MODEL = get_trained_sentence_embedder(REP_MODEL_NAME)
-
-def encoded2rep(encoded_path, rep_path=None, return_rep=False, verbose=False, level=0):
-    if not rep_path:
-        rep_path, _, _ = get_out_path(in_path=encoded_path, in_word='encoded', out_word='represented', out_extension='.txt')
-
-    error_msg = 'Error in music transformer mapping.'
-    if verbose: print(' ' * level + 'Mapping to final music representations')
-    try:
-        error_msg += ' Error in encoded file loading?'
-        with open(encoded_path, 'rb') as f:
-            data = pickle.load(f)
-        performance = [str(w) for w in data['main'] if w != 1]
-        assert len(performance) % 5 == 0
-        if(len(performance) == 0):
-            error_msg += " Error: No midi messages in primer file"
-            assert False
-        error_msg += ' Nope, error in tokenization?'
-        perf = ' '.join(performance)
-        # tokenized = torch.IntTensor(TOKENIZER.encode(perf)).unsqueeze(dim=0)
-        error_msg += ' Nope. Maybe in performance encoding?'
-        # reps = []
-        # for i_chunk in range(min(tokenized.shape[1] // 510 - 1, 8)):
-        #     chunk_tokenized = tokenized[:, i_chunk * 510: (i_chunk + 1) * 510 + 2]
-        #     rep = MODEL(chunk_tokenized)
-        #     reps.append(rep.detach().numpy())
-        # representation = np.mean(reps, axis=0)
-        p = [int(p) for p in perf.split(' ')]
-        print('PERF:', np.sum(p), perf)
-        representation = MODEL.encode(perf)
-        print('model weights sum: ', torch.sum(torch.Tensor([param.sum() for param in list(MODEL.parameters())])))
-        print('reprep', representation)
-        error_msg += ' Nope. Saving performance?'
-        np.savetxt(rep_path, representation)
-        error_msg += ' Nope.'
-        if verbose: print(' ' * (level + 2) + 'Success.')
-        if return_rep:
-            return rep_path, representation, ''
-        else:
-            return rep_path, ''
-    except:
-        if verbose: print(' ' * (level + 2) + f'Failed with error: {error_msg}')
-        if return_rep:
-            return None, None, error_msg
-        else:
-            return None, error_msg
-
-if __name__ == "__main__":
-    representation = encoded2rep("/home/cedric/Documents/pianocktail/data/music/encoded/single_videos_midi_processed_encoded/chris_dawson_all_of_me_.pickle")
-    stop = 1

src/music/pipeline/midi2processed.py

@@ -1,152 +0,0 @@
-import time
-import os
-import sys
-sys.path.append('../../')
-import pretty_midi as pm
-import numpy as np
-
-from src.music.utils import  get_out_path
-from src.music.config import MIN_LEN, MIN_NB_NOTES, MAX_GAP_IN_SONG, REMOVE_FIRST_AND_LAST
-
-
-def sort_notes(notes):
-    starts = np.array([n.start for n in notes])
-    index_sorted = np.argsort(starts)
-    return [notes[i] for i in index_sorted].copy()
-
-
-def delete_notes_end_after_start(notes):
-    indexes_to_keep = [i for i, n in enumerate(notes) if n.start < n.end]
-    return [notes[i] for i in indexes_to_keep].copy()
-
-def compute_largest_gap(notes):
-    gaps = []
-    latest_note_end_so_far = notes[0].end
-    for i in range(len(notes) - 1):
-        note_start = notes[i + 1].start
-        if latest_note_end_so_far < note_start:
-            gaps.append(note_start - latest_note_end_so_far)
-        latest_note_end_so_far = max(latest_note_end_so_far, notes[i+1].end)
-    if len(gaps) > 0:
-        largest_gap = np.max(gaps)
-    else:
-        largest_gap = 0
-    return largest_gap
-
-def analyze_instrument(inst):
-    # test that piano plays throughout
-    init = time.time()
-    notes = inst.notes.copy()
-    nb_notes = len(notes)
-    start = notes[0].start
-    end = inst.get_end_time()
-    duration = end - start
-    largest_gap = compute_largest_gap(notes)
-    return nb_notes, start, end, duration, largest_gap
-
-def remove_beginning_and_end(midi, end_time):
-    notes = midi.instruments[0].notes.copy()
-    new_notes = [n for n in notes if n.start > REMOVE_FIRST_AND_LAST and n.end < end_time - REMOVE_FIRST_AND_LAST]
-    midi.instruments[0].notes = new_notes
-    return midi
-
-def remove_blanks_beginning_and_end(midi):
-    # remove blanks and the beginning and the end
-    shift = midi.instruments[0].notes[0].start
-    for n in midi.instruments[0].notes:
-        n.start = max(0, n.start - shift)
-        n.end = max(0, n.end - shift)
-    for ksc in midi.key_signature_changes:
-        ksc.time = max(0, ksc.time - shift)
-    for tsc in midi.time_signature_changes:
-        tsc.time = max(0, tsc.time - shift)
-    for pb in midi.instruments[0].pitch_bends:
-        pb.time = max(0, pb.time - shift)
-    for cc in midi.instruments[0].control_changes:
-        cc.time = max(0, cc.time - shift)
-    return midi
-
-def is_valid_inst(largest_gap, duration, nb_notes, gap_counts=True):
-    error_msg = ''
-    valid = True
-    if largest_gap > MAX_GAP_IN_SONG and gap_counts:
-        valid = False
-        error_msg += f'wide gap ({largest_gap:.2f} secs), '
-    if duration < (MIN_LEN + 2 * REMOVE_FIRST_AND_LAST):
-        valid = False
-        error_msg += f'too short ({duration:.2f} secs), '
-    if nb_notes < MIN_NB_NOTES * duration / 60:  # nb of notes needs to be superior to the minimum number / min * the duration in minute
-        valid = False
-        error_msg += f'too few notes ({nb_notes}), '
-    return valid, error_msg
-
-def midi2processed(midi_path, processed_path=None, apply_filtering=True, verbose=False, level=0):
-    assert midi_path.split('.')[-1] in ['mid', 'midi']
-    if not processed_path:
-        processed_path, _, _ = get_out_path(in_path=midi_path, in_word='midi', out_word='processed', out_extension='.mid')
-
-    if verbose: print(' ' * level + f'Processing {midi_path}.')
-
-    if os.path.exists(processed_path):
-        if verbose: print(' ' * (level + 2) + 'Processed midi file already exists.')
-        return processed_path, ''
-    error_msg = 'Error in scrubbing. '
-   # try:
-    inst_error_msg = ''
-    # load mid file
-    error_msg += 'Error in midi loading?'
-    midi = pm.PrettyMIDI(midi_path)
-    error_msg += ' Nope. Removing invalid notes?'
-    midi.remove_invalid_notes()  # filter invalid notes
-    error_msg += ' Nope. Filtering instruments?'
-    # filter instruments
-    instruments = midi.instruments.copy()
-    new_instru = []
-    instruments_data = []
-    for i_inst, inst in enumerate(instruments):
-        if inst.program <= 7 and not inst.is_drum and len(inst.notes) > 5:
-            # inst is a piano
-            # check data
-            inst.notes = sort_notes(inst.notes)  # sort notes
-            inst.notes = delete_notes_end_after_start(inst.notes)  # delete invalid notes
-            nb_notes, start, end, duration, largest_gap = analyze_instrument(inst)
-            is_valid, err_msg = is_valid_inst(largest_gap=largest_gap, duration=duration, nb_notes=nb_notes, gap_counts='maestro' not in midi_path)
-            if is_valid or not apply_filtering:
-                new_instru.append(inst)
-                instruments_data.append([nb_notes, start, end, duration, largest_gap])
-            else:
-                inst_error_msg += 'inst1: ' + err_msg + '\n'
-    instruments_data = np.array(instruments_data)
-    error_msg += ' Nope. Taking one instrument?'
-
-    if len(new_instru) == 0:
-        error_msg = f'No piano instrument. {inst_error_msg}'
-        assert False
-    elif len(new_instru) > 1:
-        # take instrument playing the most notes
-        instrument = new_instru[np.argmax(instruments_data[:, 0])]
-    else:
-        instrument = new_instru[0]
-    instrument.program = 0  # set the instrument to Grand Piano.
-    midi.instruments = [instrument]  # put instrument in midi file
-    error_msg += ' Nope. Removing blanks?'
-    # remove first and last REMOVE_FIRST_AND_LAST seconds (avoid clapping and jingles)
-    end_time = midi.get_end_time()
-    if apply_filtering: midi = remove_beginning_and_end(midi, end_time)
-
-    # remove beginning and end
-    midi = remove_blanks_beginning_and_end(midi)
-    error_msg += ' Nope. Saving?'
-
-    # save midi file
-    midi.write(processed_path)
-    error_msg += ' Nope.'
-    if verbose:
-        extra = f' Saved to {processed_path}' if midi_path else ''
-        print(' ' * (level + 2) + f'Success! {extra}')
-    return processed_path, ''
-    #except:
-     #   if verbose: print(' ' * (level + 2) + 'Scrubbing failed.')
-      #  if os.path.exists(processed_path):
-       #     os.remove(processed_path)
-      #  return None, error_msg + ' Yes.'

src/music/pipeline/music_pipeline.py

@@ -1,86 +0,0 @@
-from src.music.pipeline.url2audio import url2audio
-from src.music.pipeline.audio2midi import audio2midi
-from src.music.pipeline.midi2processed import midi2processed
-from src.music.pipeline.processed2encoded import processed2encoded
-from src.music.pipeline.encoded2rep import encoded2rep
-from src.music.config import RANDOM_CROP, NB_AUG, FROM_URL_PATH
-# from src.music.pipeline.synth2audio import AudioRecorder
-# from src.music.pipeline.processed2handcodedrep import processed2handcodedrep
-import time
-import hashlib
-
-VERBOSE = True
-AUGMENTATION, NOISE_INJECTED = False, False
-CROP = 10# crop 30s before transcription
-
-# AUDIO_RECORDER = AudioRecorder(place='home')
-
-def encode_music(url=None,
-                 audio_path=None,
-                 midi_path=None,
-                 processed_path=None,
-                 record=False,
-                 crop=CROP,
-                 random_crop=RANDOM_CROP,
-                 augmentation=AUGMENTATION,
-                 noise_injection=NOISE_INJECTED,
-                 apply_filtering=True,
-                 nb_aug=NB_AUG,
-                 level=0,
-                 verbose=VERBOSE):
-    if not record:  assert url is not None or audio_path is not None or midi_path is not None or processed_path is not None
-    init_time = time.time()
-    error = ''
-    try:
-        if record:
-            assert audio_path is None and midi_path is None
-            if verbose: print(' ' * level + 'Processing music, recorded from mic.')
-            audio_path = AUDIO_RECORDER.record_one()
-            error = ''
-        if processed_path is None:
-            if midi_path is None:
-                if audio_path is None:
-                    if verbose and not record: print(' ' * level + 'Processing music, from audio source.')
-                    init_t = time.time()
-                    audio_path, _, error = url2audio(playlist_path=FROM_URL_PATH, video_url=url, verbose=verbose, level=level+2)
-                    if verbose: print(' ' * (level + 4) + f'Audio downloaded in {int(time.time() - init_t)} seconds.')
-                else:
-                    if verbose and not record: print(' ' * level + 'Processing music, from midi source.')
-                init_t = time.time()
-                midi_path, error = audio2midi(audio_path, crop=crop, random_crop=random_crop, verbose=verbose, level=level+2)
-                if verbose: print(' ' * (level + 4) + f'Audio transcribed to midi in {int(time.time() - init_t)} seconds.')
-            init_t = time.time()
-            processed_path, error = midi2processed(midi_path, apply_filtering=apply_filtering, verbose=verbose, level=level+2)
-            if verbose: print(' ' * (level + 4) + f'Midi preprocessed in {int(time.time() - init_t)} seconds.')
-        init_t = time.time()
-        encoded_path, error = processed2encoded(processed_path, augmentation=augmentation, nb_aug=nb_aug, noise_injection=noise_injection, verbose=verbose, level=level+2)
-        if verbose: print(' ' * (level + 4) + f'Midi encoded in {int(time.time() - init_t)} seconds.')
-        init_t = time.time()
-        representation_path, representation, error = encoded2rep(encoded_path, return_rep=True, level=level+2, verbose=verbose)
-        if verbose: print(' ' * (level + 4) + f'Music representation computed in {int(time.time() - init_t)} seconds.')
-        init_t = time.time()
-        handcoded_rep_path, handcoded_rep, error = None, None, ''
-        # handcoded_rep_path, handcoded_rep, error = processed2handcodedrep(processed_path, return_rep=True, level=level+2, verbose=verbose)
-        if verbose: print(' ' * (level + 4) + f'Music handcoded representation computed in {int(time.time() - init_t)} seconds.')
-        # assert handcoded_rep_path is not None and representation_path is not None
-        all_paths = dict(url=url, audio_path=audio_path, midi_path=midi_path, processed_path=processed_path, encoded_path=encoded_path,
-                         representation_path=representation_path, handcoded_rep_path=handcoded_rep_path)
-        print('audio hash: ', hashlib.md5(open(audio_path, 'rb').read()).hexdigest())
-        print('midi hash: ', hashlib.md5(open(midi_path, 'rb').read()).hexdigest())
-        print('processed hash: ', hashlib.md5(open(processed_path, 'rb').read()).hexdigest())
-        print('encoded hash: ', hashlib.md5(open(encoded_path, 'rb').read()).hexdigest())
-        print('rep hash: ', hashlib.md5(open(representation_path, 'rb').read()).hexdigest())
-        print("rep:", representation[:10])
-        if verbose: print(' ' * (level + 2) + f'Music processed in {int(time.time() - init_time)} seconds.')
-    except Exception as err:
-        print(err, error)
-        if verbose: print(' ' * (level + 2) + f'Music FAILED to process in {int(time.time() - init_time)} seconds.')
-        representation = None
-        handcoded_rep = None
-        all_paths = dict()
-
-    return representation, handcoded_rep, all_paths, error
-
-if __name__ == '__main__':
-    representation = encode_music(url="https://www.youtube.com/watch?v=a2LFVWBmoiw")[0]
-    # representation = encode_music(record=True)[0]

src/music/pipeline/processed2encoded.py

@@ -1,52 +0,0 @@
-import os
-import sys
-import numpy as np
-import pickle
-sys.path.append('../../')
-
-from src.music.utils import  get_out_path
-from src.music.config import ALL_NOISE, ALL_AUGMENTATIONS, NB_AUG, NOISE_INJECTED
-from src.music.utilities.midi_processor import encode_midi_structured, encode_midi_chunks_structured
-
-nb_noise = ALL_NOISE.shape[0]
-nb_aug = ALL_AUGMENTATIONS.shape[0]
-
-def sample_augmentations(n):
-    return ALL_AUGMENTATIONS[np.random.choice(np.arange(nb_aug), size=n, replace=False)]
-
-def sample_noise():
-    return ALL_NOISE[np.random.choice(np.arange(nb_noise))]
-
-def processed2encoded(processed_path, encoded_path=None, augmentation=False, nb_aug=None, noise_injection=False, verbose=False, level=0):
-    assert processed_path.split('.')[-1] in ['mid', 'midi']
-    if not encoded_path:
-        encoded_path, _, _ = get_out_path(in_path=processed_path, in_word='processed', out_word='encoded', out_extension='.pickle')
-
-    if verbose: print(' ' * level + f'Encoding {processed_path}')
-    if os.path.exists(encoded_path):
-        if verbose: print(' ' * (level + 2) + 'Midi file is already encoded.')
-        return encoded_path, ''
-
-    if augmentation:
-        assert isinstance(nb_aug, int)
-    error_msg = 'Error in encoding. '
-    try:
-        error_msg = 'Error in encoding midi?'
-        nb_noise = 1 if noise_injection else 0
-        encoded_main, encoded_aug, encoded_noisy = encode_midi_structured(processed_path, nb_aug, nb_noise)
-
-        # make sure augmentations are not out of bounds
-        error_msg = ' Nope. Error in saving encoding?'
-        with open(encoded_path, 'wb') as f:
-            pickle.dump(dict(main=encoded_main, aug=encoded_aug, noisy=encoded_noisy), f)
-        error_msg = ' Nope.'
-        if verbose:
-            extra = f' Saved to {encoded_path}' if encoded_path else ''
-            print(' ' * (level + 2) + f'Success! {extra}')
-        return encoded_path, ''
-    except:
-        if verbose: print(' ' * (level + 2) + 'Transcription failed.')
-        if os.path.exists(encoded_path):
-            os.remove(encoded_path)
-        return None, error_msg + ' Yes.'
-

src/music/pipeline/processed2handcodedrep.py

@@ -1,343 +0,0 @@
-import numpy as np
-from music21 import *
-from music21.features import native, jSymbolic, DataSet
-import pretty_midi as pm
-from src.music.utils import  get_out_path
-from src.music.utilities.handcoded_rep_utilities.tht import tactus_hypothesis_tracker, tracker_analysis
-from src.music.utilities.handcoded_rep_utilities.loudness import get_loudness, compute_total_loudness, amplitude2db, velocity2amplitude, get_db_of_equivalent_loudness_at_440hz, pitch2freq
-import json
-import os
-environment.set('musicxmlPath', '/home/cedric/Desktop/test/')
-midi_path = "/home/cedric/Documents/pianocktail/data/music/processed/doug_mckenzie_processed/allthethings_reharmonized_processed.mid"
-
-FEATURES_DICT_SCORE = dict(
-    # strongest pulse: measures how fast the melody is
-    # stronger_pulse=jSymbolic.StrongestRhythmicPulseFeature,
-    # weights of the two strongest pulse, measures rhythmic consistency: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#combinedstrengthoftwostrongestrhythmicpulsesfeature
-    pulse_strength_two=jSymbolic.CombinedStrengthOfTwoStrongestRhythmicPulsesFeature,
-    # weights of the strongest pulse, measures rhythmic consistency: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#combinedstrengthoftwostrongestrhythmicpulsesfeature
-    pulse_strength = jSymbolic.StrengthOfStrongestRhythmicPulseFeature,
-    # variability of attacks: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#variabilityoftimebetweenattacksfeature
-
-)
-FEATURES_DICT = dict(
-    # bass register importance:  https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#importanceofbassregisterfeature
-    # bass_register=jSymbolic.ImportanceOfBassRegisterFeature,
-    # high register importance: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#importanceofbassregisterfeature
-    # high_register=jSymbolic.ImportanceOfHighRegisterFeature,
-    # medium register importance: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#importanceofbassregisterfeature
-    # medium_register=jSymbolic.ImportanceOfMiddleRegisterFeature,
-    # number of common pitches (at least 9% of all): https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#numberofcommonmelodicintervalsfeature
-    # common_pitches=jSymbolic.NumberOfCommonPitchesFeature,
-    # pitch class variety (used at least once): https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#pitchvarietyfeature
-    # pitch_variety=jSymbolic.PitchVarietyFeature,
-    # attack_variability = jSymbolic.VariabilityOfTimeBetweenAttacksFeature,
-    # staccato fraction: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#staccatoincidencefeature
-    # staccato_score = jSymbolic.StaccatoIncidenceFeature,
-    # mode analysis: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesNative.html
-    av_melodic_interval = jSymbolic.AverageMelodicIntervalFeature,
-    # chromatic motion: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#chromaticmotionfeature
-    chromatic_motion = jSymbolic.ChromaticMotionFeature,
-    # direction of motion (fraction of rising intervals: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#directionofmotionfeature
-    motion_direction = jSymbolic.DirectionOfMotionFeature,
-    # duration of melodic arcs: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#durationofmelodicarcsfeature
-    melodic_arcs_duration = jSymbolic.DurationOfMelodicArcsFeature,
-    # melodic arcs size: https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#sizeofmelodicarcsfeature
-    melodic_arcs_size = jSymbolic.SizeOfMelodicArcsFeature,
-    # number of common melodic interval (at least 9% of all): https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#numberofcommonmelodicintervalsfeature
-    # common_melodic_intervals = jSymbolic.NumberOfCommonMelodicIntervalsFeature,
-    # https://web.mit.edu/music21/doc/moduleReference/moduleFeaturesJSymbolic.html#amountofarpeggiationfeature
-    # arpeggiato=jSymbolic.AmountOfArpeggiationFeature,
-)
-
-
-
-
-
-
-def compute_beat_info(onsets):
-    onsets_in_ms = np.array(onsets) * 1000
-
-    tht = tactus_hypothesis_tracker.default_tht()
-    trackers = tht(onsets_in_ms)
-    top_hts = tracker_analysis.top_hypothesis(trackers, len(onsets_in_ms))
-    beats = tracker_analysis.produce_beats_information(onsets_in_ms, top_hts, adapt_period=250 is not None,
-                                                       adapt_phase=tht.eval_f, max_delta_bpm=250, avoid_quickturns=None)
-    tempo = 1 / (np.mean(np.diff(beats)) / 1000) * 60 # in bpm
-    conf_values = tracker_analysis.tht_tracking_confs(trackers, len(onsets_in_ms))
-    pulse_clarity = np.mean(np.array(conf_values), axis=0)[1]
-    return tempo, pulse_clarity
-
-def dissonance_score(A):
-    """
-    Given a piano-roll indicator matrix representation of a musical work (128 pitches x beats),
-    return the dissonance as a function of beats.
-    Input:
-        A  - 128 x beats indicator matrix of MIDI pitch number
-
-    """
-    freq_rats = np.arange(1, 7) # Harmonic series ratios
-    amps = np.exp(-.5 * freq_rats) # Partial amplitudes
-    F0 = 8.1757989156 # base frequency for MIDI (note 0)
-    diss = [] # List for dissonance values
-    thresh = 1e-3
-    for beat in A.T:
-        idx = np.where(beat>thresh)[0]
-        if len(idx):
-            freqs, mags = [], [] # lists for frequencies, mags
-            for i in idx:
-                freqs.extend(F0*2**(i/12.0)*freq_rats)
-                mags.extend(amps)
-            freqs = np.array(freqs)
-            mags = np.array(mags)
-            sortIdx = freqs.argsort()
-            d = compute_dissonance(freqs[sortIdx],mags[sortIdx])
-            diss.extend([d])
-        else:
-            diss.extend([-1]) # Null value
-    diss = np.array(diss)
-    return diss[np.where(diss != -1)]
-
-def compute_dissonance(freqs, amps):
-    """
-    From https://notebook.community/soundspotter/consonance/week1_consonance
-    Compute dissonance between partials with center frequencies in freqs, uses a model of critical bandwidth.
-    and amplitudes in amps. Based on Sethares "Tuning, Timbre, Spectrum, Scale" (1998) after Plomp and Levelt (1965)
-
-    inputs:
-        freqs - list of partial frequencies
-        amps - list of corresponding amplitudes [default, uniformly 1]
-    """
-    b1, b2, s1, s2, c1, c2, Dstar = (-3.51, -5.75, 0.0207, 19.96, 5, -5, 0.24)
-    f = np.array(freqs)
-    a = np.array(amps)
-    idx = np.argsort(f)
-    f = f[idx]
-    a = a[idx]
-    N = f.size
-    D = 0
-    for i in range(1, N):
-        Fmin = f[ 0 : N - i ]
-        S = Dstar / ( s1 * Fmin + s2)
-        Fdif = f[ i : N ] - f[ 0 : N - i ]
-        am = a[ i : N ] * a[ 0 : N - i ]
-        Dnew = am * (c1 * np.exp (b1 * S * Fdif) + c2 * np.exp(b2 * S * Fdif))
-        D += Dnew.sum()
-    return D
-
-
-
-
-def store_new_midi(notes, out_path):
-    midi = pm.PrettyMIDI()
-    midi.instruments.append(pm.Instrument(program=0, is_drum=False))
-    midi.instruments[0].notes = notes
-    midi.write(out_path)
-    return midi
-
-
-def processed2handcodedrep(midi_path, handcoded_rep_path=None, crop=30, verbose=False, save=True, return_rep=False, level=0):
-    try:
-        if not handcoded_rep_path:
-            handcoded_rep_path, _, _ = get_out_path(in_path=midi_path, in_word='processed', out_word='handcoded_reps', out_extension='.mid')
-        features = dict()
-        if verbose: print(' ' * level + 'Computing handcoded representations')
-        if os.path.exists(handcoded_rep_path):
-            with open(handcoded_rep_path.replace('.mid', '.json'), 'r') as f:
-                features = json.load(f)
-            rep = np.array([features[k] for k in sorted(features.keys())])
-            if rep.size == 49:
-                os.remove(handcoded_rep_path)
-            else:
-                if verbose: print(' ' * (level + 2) + 'Already computed.')
-                if return_rep:
-                    return handcoded_rep_path, np.array([features[k] for k in sorted(features.keys())]), ''
-                else:
-                    return handcoded_rep_path, ''
-        midi = pm.PrettyMIDI(midi_path)  # load midi with pretty midi
-        notes = midi.instruments[0].notes  # get notes
-        notes.sort(key=lambda x: (x.start, x.pitch))  # sort notes per start and pitch
-        onsets, offsets, pitches, durations, velocities = [], [], [], [], []
-        n_notes_cropped = len(notes)
-        for i_n, n in enumerate(notes):
-            onsets.append(n.start)
-            offsets.append(n.end)
-            durations.append(n.end-n.start)
-            pitches.append(n.pitch)
-            velocities.append(n.velocity)
-            if crop is not None:  # find how many notes to keep
-                if n.start > crop and n_notes_cropped == len(notes):
-                    n_notes_cropped = i_n
-                    break
-        notes = notes[:n_notes_cropped]
-        midi = store_new_midi(notes, handcoded_rep_path)
-        # pianoroll = midi.get_piano_roll()  # extract piano roll representation
-
-        # compute loudness
-        amplitudes = velocity2amplitude(np.array(velocities))
-        power_dbs = amplitude2db(amplitudes)
-        frequencies = pitch2freq(np.array(pitches))
-        loudness_values = get_loudness(power_dbs, frequencies)
-        # compute average perceived loudness
-        # for each power, compute loudness, then compute power such that the loudness at 440 Hz would be equivalent.
-        # equivalent_powers_dbs = get_db_of_equivalent_loudness_at_440hz(frequencies, power_dbs)
-        # then get the corresponding amplitudes
-        # equivalent_amplitudes = 10 ** (equivalent_powers_dbs / 20)
-        # not use a amplitude model across the sample to compute the instantaneous amplitude, turn it back to dbs, then to perceived loudness with unique freq 440 Hz
-        # av_total_loudness, std_total_loudness = compute_total_loudness(equivalent_amplitudes, onsets, offsets)
-
-        end_time = np.max(offsets)
-        start_time = notes[0].start
-
-
-        score = converter.parse(handcoded_rep_path)
-        score.chordify()
-        notes_without_chords = stream.Stream(score.flatten().getElementsByClass('Note'))
-
-        velocities_wo_chords, pitches_wo_chords, amplitudes_wo_chords, dbs_wo_chords = [], [], [], []
-        frequencies_wo_chords, loudness_values_wo_chords, onsets_wo_chords, offsets_wo_chords, durations_wo_chords = [], [], [], [], []
-        for i_n in range(len(notes_without_chords)):
-            n = notes_without_chords[i_n]
-            velocities_wo_chords.append(n.volume.velocity)
-            pitches_wo_chords.append(n.pitch.midi)
-            onsets_wo_chords.append(n.offset)
-            offsets_wo_chords.append(onsets_wo_chords[-1] + n.seconds)
-            durations_wo_chords.append(n.seconds)
-
-        amplitudes_wo_chords = velocity2amplitude(np.array(velocities_wo_chords))
-        power_dbs_wo_chords = amplitude2db(amplitudes_wo_chords)
-        frequencies_wo_chords = pitch2freq(np.array(pitches_wo_chords))
-        loudness_values_wo_chords = get_loudness(power_dbs_wo_chords, frequencies_wo_chords)
-        # compute average perceived loudness
-        # for each power, compute loudness, then compute power such that the loudness at 440 Hz would be equivalent.
-        # equivalent_powers_dbs_wo_chords = get_db_of_equivalent_loudness_at_440hz(frequencies_wo_chords, power_dbs_wo_chords)
-        # then get the corresponding amplitudes
-        # equivalent_amplitudes_wo_chords = 10 ** (equivalent_powers_dbs_wo_chords / 20)
-        # not use a amplitude model across the sample to compute the instantaneous amplitude, turn it back to dbs, then to perceived loudness with unique freq 440 Hz
-        # av_total_loudness_wo_chords, std_total_loudness_wo_chords = compute_total_loudness(equivalent_amplitudes_wo_chords, onsets_wo_chords, offsets_wo_chords)
-
-        ds = DataSet(classLabel='test')
-        f = list(FEATURES_DICT.values())
-        ds.addFeatureExtractors(f)
-        ds.addData(notes_without_chords)
-        ds.process()
-        for k, f in zip(FEATURES_DICT.keys(), ds.getFeaturesAsList()[0][1:-1]):
-            features[k] = f
-
-        ds = DataSet(classLabel='test')
-        f = list(FEATURES_DICT_SCORE.values())
-        ds.addFeatureExtractors(f)
-        ds.addData(score)
-        ds.process()
-        for k, f in zip(FEATURES_DICT_SCORE.keys(), ds.getFeaturesAsList()[0][1:-1]):
-            features[k] = f
-
-        # # # # #
-        # Register features
-        # # # # #
-
-        # features['av_pitch'] = np.mean(pitches)
-        # features['std_pitch'] = np.std(pitches)
-        # features['range_pitch'] = np.max(pitches) - np.min(pitches)  # aka ambitus
-
-        # # # # #
-        # Rhythmic features
-        # # # # #
-
-        # tempo, pulse_clarity = compute_beat_info(onsets[:n_notes_cropped])
-        # features['pulse_clarity'] = pulse_clarity
-        # features['tempo'] = tempo
-        features['tempo_pm'] = midi.estimate_tempo()
-
-        # # # # #
-        # Temporal features
-        # # # # #
-
-        features['av_duration'] = np.mean(durations)
-        # features['std_duration'] = np.std(durations)
-        features['note_density'] = len(notes) / (end_time - start_time)
-        # intervals_wo_chords = np.diff(onsets_wo_chords)
-        # articulations = [max((i-d)/i, 0) for d, i in zip(durations_wo_chords, intervals_wo_chords) if i != 0]
-        # features['articulation'] = np.mean(articulations)
-        # features['av_duration_wo_chords'] = np.mean(durations_wo_chords)
-        # features['std_duration_wo_chords'] = np.std(durations_wo_chords)
-
-        # # # # #
-        # Dynamics features
-        # # # # #
-        features['av_velocity'] = np.mean(velocities)
-        features['std_velocity'] = np.std(velocities)
-        features['av_loudness'] = np.mean(loudness_values)
-        # features['std_loudness'] = np.std(loudness_values)
-        features['range_loudness'] = np.max(loudness_values) - np.min(loudness_values)
-        # features['av_integrated_loudness'] = av_total_loudness
-        # features['std_integrated_loudness'] = std_total_loudness
-        # features['av_velocity_wo_chords'] = np.mean(velocities_wo_chords)
-        # features['std_velocity_wo_chords'] = np.std(velocities_wo_chords)
-        # features['av_loudness_wo_chords'] = np.mean(loudness_values_wo_chords)
-        # features['std_loudness_wo_chords'] = np.std(loudness_values_wo_chords)
-        features['range_loudness_wo_chords'] = np.max(loudness_values_wo_chords) - np.min(loudness_values_wo_chords)
-        # features['av_integrated_loudness'] = av_total_loudness_wo_chords
-        # features['std_integrated_loudness'] = std_total_loudness_wo_chords
-        # indices_with_intervals = np.where(intervals_wo_chords > 0.01)
-        # features['av_loudness_change'] = np.mean(np.abs(np.diff(np.array(loudness_values_wo_chords)[indices_with_intervals]))) # accentuation
-        # features['av_velocity_change'] = np.mean(np.abs(np.diff(np.array(velocities_wo_chords)[indices_with_intervals]))) # accentuation
-
-        # # # # #
-        # Harmony features
-        # # # # #
-
-        # get major_minor score: https://web.mit.edu/music21/doc/moduleReference/moduleAnalysisDiscrete.html
-        music_analysis = score.analyze('key')
-        major_score = None
-        minor_score = None
-        for a in [music_analysis] + music_analysis.alternateInterpretations:
-            if 'major' in a.__str__() and a.correlationCoefficient > 0:
-                major_score = a.correlationCoefficient
-            elif 'minor' in a.__str__() and a.correlationCoefficient > 0:
-                minor_score = a.correlationCoefficient
-            if major_score is not None and minor_score is not None:
-                break
-        features['major_minor'] = major_score / (major_score + minor_score)
-        features['tonal_certainty'] = music_analysis.tonalCertainty()
-        # features['av_sensory_dissonance'] = np.mean(dissonance_score(pianoroll))
-        #TODO only works for chords, do something with melodic intervals: like proportion that is not third, fifth or sevenths?
-
-        # # # # #
-        # Interval features
-        # # # # #
-        #https://web.mit.edu/music21/doc/moduleReference/moduleAnalysisPatel.html
-        # features['melodic_interval_variability'] = analysis.patel.melodicIntervalVariability(notes_without_chords)
-
-        # # # # #
-        # Suprize features
-        # # # # #
-        # https://web.mit.edu/music21/doc/moduleReference/moduleAnalysisMetrical.html
-        # analysis.metrical.thomassenMelodicAccent(notes_without_chords)
-        # melodic_accents = [n.melodicAccent for n in notes_without_chords]
-        # features['melodic_accent'] = np.mean(melodic_accents)
-
-        if save:
-            for k, v in features.items():
-                features[k] = float(features[k])
-            with open(handcoded_rep_path.replace('.mid', '.json'), 'w') as f:
-                json.dump(features, f)
-        else:
-            print(features)
-            if os.path.exists(handcoded_rep_path):
-                os.remove(handcoded_rep_path)
-        if verbose: print(' ' * (level + 2) + 'Success.')
-        if return_rep:
-            return handcoded_rep_path, np.array([features[k] for k in sorted(features.keys())]), ''
-        else:
-            return handcoded_rep_path, ''
-    except:
-        if verbose: print(' ' * (level + 2) + 'Failed.')
-        if return_rep:
-            return None, None, 'error'
-        else:
-            return None, 'error'
-
-
-if __name__ == '__main__':
-    processed2handcodedrep(midi_path, '/home/cedric/Desktop/test.mid', save=False)

src/music/pipeline/synth2audio.py

@@ -1,170 +0,0 @@
-import pynput
-import sys
-sys.path.append('../../')
-from src.music.config import SYNTH_RECORDED_AUDIO_PATH, RATE_AUDIO_SAVE
-from datetime import datetime
-import numpy as np
-import os
-import wave
-
-from ctypes import *
-from contextlib import contextmanager
-import pyaudio
-
-ERROR_HANDLER_FUNC = CFUNCTYPE(None, c_char_p, c_int, c_char_p, c_int, c_char_p)
-
-def py_error_handler(filename, line, function, err, fmt):
-    pass
-c_error_handler = ERROR_HANDLER_FUNC(py_error_handler)
-
-@contextmanager
-def noalsaerr():
-    asound = cdll.LoadLibrary('libasound.so')
-    asound.snd_lib_error_set_handler(c_error_handler)
-    yield
-    asound.snd_lib_error_set_handler(None)
-
-global KEY_PRESSED
-KEY_PRESSED = None
-
-def on_press(key):
-    global KEY_PRESSED
-    try:
-        KEY_PRESSED = key.name
-    except:
-        pass
-
-def on_release(key):
-    global KEY_PRESSED
-    KEY_PRESSED = None
-
-
-def is_pressed(key):
-    global KEY_PRESSED
-    return KEY_PRESSED == key
-
-# keyboard listener
-listener = pynput.keyboard.Listener(on_press=on_press, on_release=on_release)
-listener.start()
-
-LEN_RECORDINGS = 40
-class AudioRecorder:
-    def __init__(self, chunk=2**10, rate=44100, place='', len_recording=LEN_RECORDINGS, drop_beginning=0.5):
-        self.chunk = chunk
-        self.rate = rate
-        with noalsaerr():
-            self.audio = pyaudio.PyAudio()
-        self.channels = 1
-        self.format = pyaudio.paInt16
-        self.stream = self.audio.open(format=self.format,
-                                      channels=self.channels,
-                                      rate=rate,
-                                      input=True,
-                                      frames_per_buffer=chunk)
-        self.stream.stop_stream()
-        self.drop_beginning_chunks = int(drop_beginning * self.rate / self.chunk)
-        self.place = place
-        self.len_recordings = len_recording
-
-    def get_filename(self):
-        now = datetime.now()
-        return self.place + '_' + now.strftime("%b_%d_%Y_%Hh%Mm%Ss") + '.mp3'
-
-    def read_last_chunk(self):
-        return self.stream.read(self.chunk)
-
-    def live_read(self):
-        if self.stream.is_stopped():
-            self.stream.start_stream()
-        i = 0
-        while not is_pressed('esc'):
-            data = np.frombuffer(self.stream.read(self.chunk), dtype=np.int16)
-            peak = np.average(np.abs(data)) * 2
-            bars = "#"*int(50 * peak / 2 ** 16)
-            i += 1
-            print("%04d %05d %s"%(i,peak,bars))
-        self.stream.stop_stream()
-
-    def record_next_N_seconds(self, n=None, saving_path=None):
-        if saving_path is None:
-            saving_path = SYNTH_RECORDED_AUDIO_PATH + self.get_filename()
-        if n is None:
-            n = self.len_recordings
-
-        print(f'Recoding the next {n} secs.'
-              # f'\n\tRecording starts when the first key is pressed;'
-              f'\n\tPress Enter to end the recording;'
-              f'\n\tPress BackSpace (<--) to cancel the recording;'
-              f'\n\tSaving to {saving_path}')
-        try:
-            self.stream.start_stream()
-            backspace_pressed = False
-            self.recording = []
-            i_chunk = 0
-            while not is_pressed('enter') and self.chunk / self.rate * i_chunk < n:
-                self.recording.append(self.read_last_chunk())
-                i_chunk += 1
-                if is_pressed('backspace'):
-                    backspace_pressed = True
-                    print('\n \t--> Recording cancelled! (you pressed BackSpace)')
-                    break
-            self.stream.stop_stream()
-
-            # save the file
-            if not backspace_pressed:
-                self.recording = self.recording[self.drop_beginning_chunks:] # drop first chunks to remove keyboard sound
-                with wave.open(saving_path[:-4] + '.wav', 'wb') as waveFile:
-                    waveFile.setnchannels(self.channels)
-                    waveFile.setsampwidth(self.audio.get_sample_size(self.format))
-                    waveFile.setframerate(self.rate)
-                    waveFile.writeframes(b''.join(self.recording))
-                os.system(f'ffmpeg -i "{saving_path[:-4] + ".wav"}" -vn -loglevel panic -y -ac 1 -ar {int(RATE_AUDIO_SAVE)} -b:a 320k "{saving_path}" ')
-                os.remove(saving_path[:-4] + '.wav')
-                print(f'\n--> Recording saved, duration: {self.chunk / self.rate * i_chunk:.2f} secs.')
-            return saving_path
-        except:
-            print('\n --> The recording failed.')
-            return None
-
-    def record_one(self):
-        ready_msg = False
-        print('Starting the recording loop!\n\tPress BackSpace to cancel the current recording;\n\tPress Esc to quit the loop (only works while not recording)')
-        while True:
-            if not ready_msg:
-                print('-------\nReady to record!')
-                print('Press space to start a recording\n')
-                ready_msg = True
-
-            if is_pressed('space'):
-                saving_path = self.record_next_N_seconds()
-                break
-        return saving_path
-
-    def run(self):
-        # with pynput.Listener(
-        #         on_press=self.on_press) as listener:
-        #     listener.join()
-        ready_msg = False
-        print('Starting the recording loop!\n\tPress BackSpace to cancel the current recording;\n\tPress Esc to quit the loop (only works while not recording)')
-        while True:
-            if not ready_msg:
-                print('-------\nReady to record!')
-                print('Press space to start a recording\n')
-                ready_msg = True
-
-            if is_pressed('space'):
-                self.record_next_N_seconds()
-                ready_msg = False
-            if is_pressed('esc'):
-                print('End of the recording session. See you soon!')
-                self.close()
-                break
-
-    def close(self):
-        self.stream.close()
-        self.audio.terminate()
-
-if __name__ == '__main__':
-    audio_recorder = AudioRecorder(place='home')
-    audio_recorder.record_one()
-

src/music/pipeline/synth2midi.py

@@ -1,146 +0,0 @@
-import mido
-mido.set_backend('mido.backends.pygame')
-from mido import Message, MidiFile, MidiTrack
-import time
-import pynput
-import sys
-sys.path.append('../../')
-from src.music.config import SYNTH_RECORDED_MIDI_PATH
-from datetime import datetime
-
-#TODO: debug this with other cable, keyboard and sound card
-global KEY_PRESSED
-KEY_PRESSED = None
-
-def on_press(key):
-    global KEY_PRESSED
-    try:
-        KEY_PRESSED = key.name
-    except:
-        pass
-
-def on_release(key):
-    global KEY_PRESSED
-    KEY_PRESSED = None
-
-
-def is_pressed(key):
-    global KEY_PRESSED
-    return KEY_PRESSED == key
-
-# keyboard listener
-listener = pynput.keyboard.Listener(on_press=on_press, on_release=on_release)
-listener.start()
-
-LEN_MIDI_RECORDINGS = 30
-class MidiRecorder:
-    def __init__(self, place='', len_midi_recordings=LEN_MIDI_RECORDINGS):
-        self.place = place
-        self.len_midi_recordings = len_midi_recordings
-        self.port = mido.open_input(mido.get_input_names()[0])
-
-    def get_filename(self):
-        now = datetime.now()
-        return self.place + '_' + now.strftime("%b_%d_%Y_%Hh%Mm%Ss") + '.mid'
-
-    def read_last_midi_msgs(self):
-        return list(self.port.iter_pending())
-
-    def live_read(self):
-        while not is_pressed('esc'):
-            for msg in self.read_last_midi_msgs():
-                print(msg)
-
-    def check_if_recording_started(self, msgs, t_init):
-        started = False
-        if len(msgs) > 0:
-            for m in msgs:
-                if m.type == 'note_on':
-                    started = True
-                    t_init = time.time()
-        return started, t_init
-
-    def create_empty_midi(self):
-        mid = MidiFile()
-        track = MidiTrack()
-        mid.tracks.append(track)
-        track.append(Message('program_change', program=0, time=0))
-        return mid, track
-
-    def record_next_N_seconds(self, n=None, saving_path=None):
-        if saving_path is None:
-            saving_path = SYNTH_RECORDED_PATH + self.get_filename()
-        if n is None:
-            n = self.len_midi_recordings
-
-        print(f'Recoding the next {n} secs.'
-              f'\n\tRecording starts when the first key is pressed;'
-              f'\n\tPress Enter to end the recording;'
-              f'\n\tPress BackSpace (<--) to cancel the recording;'
-              f'\n\tSaving to {saving_path}')
-        try:
-            mid, track = self.create_empty_midi()
-            started = False
-            backspace_pressed = False
-            t_init = time.time()
-            while not is_pressed('enter') and (time.time() - t_init) < n:
-                msgs = self.read_last_midi_msgs()
-                if not started:
-                    started, t_init = self.check_if_recording_started(msgs, t_init)
-                    if started:
-                        print("\n\t--> First note pressed, it's on!")
-                for m in msgs:
-                    print(m)
-                    if m.type == 'note_on' and m.velocity == 0:
-                        m_off = Message(type='note_off', velocity=127, note=m.note, channel=m.channel, time=m.time)
-                        track.append(m_off)
-                    track.append(m)
-                if is_pressed('backspace'):
-                    backspace_pressed = True
-                    print('\n \t--> Recording cancelled! (you pressed BackSpace)')
-                    break
-            # save the file
-            if not backspace_pressed and len(mid.tracks[0]) > 0:
-                mid.save(saving_path)
-                print(f'\n--> Recording saved, duration: {mid.length:.2f} secs, {len(mid.tracks[0])} events.')
-        except:
-            print('\n --> The recording failed.')
-
-
-    def run(self):
-        # with pynput.Listener(
-        #         on_press=self.on_press) as listener:
-        #     listener.join()
-        ready_msg = False
-        print('Starting the recording loop!\n\tPress BackSpace to cancel the current recording;\n\tPress Esc to quit the loop (only works while not recording)')
-        while True:
-            if not ready_msg:
-                print('-------\nReady to record!')
-                print('Press space to start a recording\n')
-                ready_msg = True
-
-            if is_pressed('space'):
-                self.record_next_N_seconds()
-                ready_msg = False
-            if is_pressed('esc'):
-                print('End of the recording session. See you soon!')
-                break
-
-
-midi_recorder = MidiRecorder(place='home')
-midi_recorder.live_read()
-# midi_recorder.run()
-
-
-#     try:
-#         controls[msg.control] = msg.value
-#     except:
-#         notes.append(msg.note)
-# port = mido.open_input()
-# while True:
-#     for msg in port.iter_pending():
-#         print(msg)
-#
-#     print('start pause')
-#     time.sleep(5)
-#     print('stop pause')

src/music/pipeline/url2audio.py

@@ -1,119 +0,0 @@
-import os
-from pytube import YouTube
-from src.music.utils import RATE_AUDIO_SAVE, slugify
-from src.music.config import MAX_LEN
-
-# define filtering keyworfds
-start_keywords = [' ', '(', ',', ':']
-end_keywords = [')', ' ', '.', ',', '!', ':']
-def get_all_keywords(k):
-    all_keywords = []
-    for s in start_keywords:
-        for e in end_keywords:
-            all_keywords.append(s + k + e)
-    return all_keywords
-filtered_keywords = ['duet', 'duo', 'quartet', 'orchestre', 'orchestra',
-                     'quintet', 'sixtet', 'septet', 'octet', 'backing track', 'accompaniment', 'string',
-                     'contrebrasse', 'drums', 'guitar'] + get_all_keywords('live') + get_all_keywords('trio')
-
-# list of playlist for which no filtering should occur on keywords (they were prefiltered already, it's supposed to be only piano)
-playlist_and_channel_not_to_filter = ["https://www.youtube.com/c/MySheetMusicTranscriptions",
-                                      "https://www.youtube.com/c/PianoNotion",
-                                      "https://www.youtube.com/c/PianoNotion",
-                                      "https://www.youtube.com/watch?v=3F5glYefwio&list=PLFv3ZQw-ZPxi2DH3Bau7lBC5K6zfPJZxc",
-                                      "https://www.youtube.com/user/Mercuziopianist",
-                                      "https://www.youtube.com/channel/UCy6NPK6-xeX7MZLaMARa5qg",
-                                      "https://www.youtube.com/channel/UCKMRNFV2dWTWIJnymtA9_Iw",
-                                      "https://www.youtube.com/c/pianomaedaful",
-                                      "https://www.youtube.com/c/FrancescoParrinoMusic",
-                                      "https://www.youtube.com/c/itsremco"]
-playlist_ok = "https://www.youtube.com/watch?v=sYv_vk6bJtk&list=PLO9E3V4rGLD9-0BEd3t-AvvMcVF1zOJPj"
-
-
-def should_be_filtered(title, length, url, playlist_url, max_length):
-    to_filter = False
-    reason = ''
-    lower_title = title.lower()
-    if length > max_length:
-        reason += f'it is too long (>{max_length/60:.1f} min), '
-        to_filter = True
-    if any([f in lower_title for f in filtered_keywords]) \
-            and playlist_url not in playlist_and_channel_not_to_filter \
-            and 'to live' not in lower_title and 'alive' not in lower_title \
-            and url not in playlist_ok:
-        reason += 'it contains a filtered keyword, '
-        to_filter = True
-    return to_filter, reason
-
-def convert_mp4_to_mp3(path, verbose=True):
-    if verbose: print(f"Converting mp4 to mp3, in {path}\n")
-    assert '.mp4' == path[-4:]
-    os.system(f'ffmpeg -i "{path}" -loglevel panic -y -ac 1 -ar {int(RATE_AUDIO_SAVE)} "{path[:-4] + ".mp3"}" ')
-    os.remove(path)
-    if verbose: print('\tDone.')
-
-def pipeline_video(video, playlist_path, filename):
-    # extract best stream for this video
-    stream, kbps = extract_best_stream(video.streams)
-    stream.download(output_path=playlist_path, filename=filename + '.mp4')
-    # convert to mp3
-    convert_mp4_to_mp3(playlist_path + filename + '.mp4', verbose=False)
-    return kbps
-
-def extract_best_stream(streams):
-    # extract best audio stream
-    stream_out = streams.get_audio_only()
-    kbps = int(stream_out.abr[:-4])
-    return stream_out, kbps
-
-def get_title_and_length(video):
-    title = video.title
-    filename = slugify(title)
-    length = video.length
-    return title, filename, length, video.metadata
-
-
-def url2audio(playlist_path, video_url=None, video=None, playlist_url='', apply_filters=False, verbose=False, level=0):
-    assert video_url is not None or video is not None, 'needs either video or url'
-    error_msg = 'Error in loading video?'
-    try:
-        if not video:
-            video = YouTube(video_url)
-        error_msg += ' Nope. In extracting title and length?'
-        title, filename, length, video_meta_data = get_title_and_length(video)
-        if apply_filters:
-            to_filter, reason = should_be_filtered(title, length, video_url, playlist_url, MAX_LEN)
-        else:
-            to_filter = False
-        if not to_filter:
-            audio_path = playlist_path + filename + ".mp3"
-            if verbose: print(' ' * level + f'Downloading {title}, Url: {video_url}')
-            if not os.path.exists(audio_path):
-                if length > MAX_LEN and verbose: print(' ' * (level + 2) + f'Long video ({int(length/60)} min), will be cut after {int(MAX_LEN/60)} min.')
-                error_msg += ' Nope. In pipeline video?'
-                kbps = None
-                for _ in range(5):
-                    try:
-                        kbps = pipeline_video(video, playlist_path, filename)
-                        break
-                    except:
-                        pass
-                assert kbps is not None
-                error_msg += ' Nope. In dict filling?'
-                data = dict(title=title, filename=filename, length=length, kbps=kbps, url=video_url, meta=video_meta_data)
-                error_msg += ' Nope. '
-            else:
-                if verbose: print(' ' * (level + 2) + 'Song already downloaded')
-                data = None
-            return audio_path, data, ''
-        else:
-            return None, None, f'Filtered because {reason}'
-    except:
-        if verbose: print(' ' * (level + 2) + f'Download failed with error {error_msg}')
-        if os.path.exists(audio_path):
-            os.remove(audio_path)
-        return None, None, error_msg + ' Yes.'
-
-
-
-

src/music/representation_analysis/analyze_rep.py

@@ -1,146 +0,0 @@
-import numpy as np
-from sklearn.cluster import KMeans
-from sklearn.neighbors import NearestNeighbors
-from sklearn.manifold import TSNE
-from src.music.utils import get_all_subfiles_with_extension
-import matplotlib.pyplot as plt
-import pickle
-import random
-# import umap
-import os
-from shutil import copy
-# install numba =numba==0.51.2
-# keyword = '32_represented'
-# rep_path = f"/home/cedric/Documents/pianocktail/data/music/{keyword}/"
-# plot_path = '/home/cedric/Documents/pianocktail/data/music/representation_analysis/plots/'
-# neighbors_path = '/home/cedric/Documents/pianocktail/data/music/representation_analysis/neighbors/'
-interpolation_path = '/home/cedric/Documents/pianocktail/data/music/representation_analysis/interpolation/'
-keyword = 'b256_r128_represented'
-rep_path = f"/home/cedric/Documents/pianocktail/data/music/dataset_exploration/dataset_representation/{keyword}/"
-plot_path = '/home/cedric/Documents/pianocktail/data/music/dataset_exploration/dataset_representation/analysis/plots/'
-neighbors_path = f'/home/cedric/Documents/pianocktail/data/music/dataset_exploration/dataset_representation/analysis/neighbors_{keyword}/'
-os.makedirs(neighbors_path, exist_ok=True)
-def extract_all_reps(rep_path):
-    all_rep_path = get_all_subfiles_with_extension(rep_path, max_depth=3, extension='.txt', current_depth=0)
-    all_data = []
-    new_all_rep_path = []
-    for i_r, r in enumerate(all_rep_path):
-        if 'mean_std' not in r:
-            all_data.append(np.loadtxt(r))
-            assert len(all_data[-1]) == 128
-            new_all_rep_path.append(r)
-    data = np.array(all_data)
-    to_save = dict(reps=data,
-                   paths=new_all_rep_path)
-    with open(rep_path + 'music_reps_unnormalized.pickle', 'wb') as f:
-        pickle.dump(to_save, f)
-    for sample_size in [100, 200, 500, 1000, 2000, 5000]:
-        if sample_size < len(data):
-            inds = np.arange(len(data))
-            np.random.shuffle(inds)
-            to_save = dict(reps=data[inds[:sample_size]],
-                           paths=np.array(all_rep_path)[inds[:sample_size]])
-            with open(rep_path + f'all_reps_unnormalized_sample{sample_size}.pickle', 'wb') as f:
-                pickle.dump(to_save, f)
-
-def load_reps(rep_path, sample_size=None):
-    if sample_size:
-        with open(rep_path + f'all_reps_unnormalized_sample{sample_size}.pickle', 'rb') as f:
-            data = pickle.load(f)
-    else:
-        with open(rep_path + f'music_reps_unnormalized.pickle', 'rb') as f:
-            data = pickle.load(f)
-    reps = data['reps']
-    # playlists = [r.split(f'_{keyword}')[0].split('/')[-1] for r in data['paths']]
-    playlists = [r.split(f'{keyword}')[1].split('/')[1] for r in data['paths']]
-    n_data, dim_data = reps.shape
-    return reps, data['paths'], playlists, n_data, dim_data
-
-
-def plot_tsne(reps, playlist_indexes, playlist_colors):
-    tsne_reps = TSNE(n_components=2, learning_rate='auto', init='random').fit_transform(reps)
-    plt.figure()
-    keys_to_print = ['spot_piano_solo_blues', 'itsremco', 'piano_solo_classical',
-                     'piano_solo_pop', 'piano_jazz_unspecified','spot_piano_solo_jazz_1', 'piano_solo_jazz_latin']
-    keys_to_print = playlist_indexes.keys()
-    for k in sorted(keys_to_print):
-        if k in playlist_indexes.keys():
-            # plt.scatter(tsne_reps[playlist_indexes[k], 0], tsne_reps[playlist_indexes[k], 1], s=100, label=k, alpha=0.5)
-            plt.scatter(tsne_reps[playlist_indexes[k], 0], tsne_reps[playlist_indexes[k], 1], s=100, c=playlist_colors[k], label=k, alpha=0.5)
-    plt.legend()
-    plt.savefig(plot_path + f'tsne_{keyword}.png')
-    fig = plt.gcf()
-    plt.close(fig)
-    # umap_reps = umap.UMAP().fit_transform(reps)
-    # plt.figure()
-    # for k in sorted(keys_to_print):
-    #     if k in playlist_indexes.keys():
-    #         plt.scatter(umap_reps[playlist_indexes[k], 0], tsne_reps[playlist_indexes[k], 1], s=100, c=playlist_colors[k], label=k, alpha=0.5)
-    # plt.legend()
-    # plt.savefig(plot_path + f'umap_{keyword}.png')
-    # fig = plt.gcf()
-    # plt.close(fig)
-    return tsne_reps#, umap_reps
-
-def get_playlist_indexes(playlists):
-    playlist_indexes = dict()
-    for i in range(n_data):
-        if playlists[i] not in playlist_indexes.keys():
-            playlist_indexes[playlists[i]] = [i]
-        else:
-            playlist_indexes[playlists[i]].append(i)
-    for k in playlist_indexes.keys():
-        playlist_indexes[k] = np.array(playlist_indexes[k])
-    set_playlists = sorted(set(playlists))
-    playlist_colors = dict(zip(set_playlists, ['#%06X' % random.randint(0, 0xFFFFFF) for _ in range(len(set_playlists))]))
-    return set_playlists, playlist_indexes, playlist_colors
-
-def convert_rep_path_midi_path(rep_path):
-    # playlist = rep_path.split(f'_{keyword}/')[0].split('/')[-1]
-    playlist = rep_path.split(f'{keyword}')[1].split('/')[1].replace('_represented', '')
-    midi_path = "/home/cedric/Documents/pianocktail/data/music/dataset_exploration/dataset_representation/processed/" + playlist + '_processed/'
-    filename = rep_path.split(f'{keyword}')[1].split(f'/')[2].split('_represented.txt')[0] + '_processed.mid'
-    # filename = rep_path.split(f'_{keyword}/')[-1].split(f'_{keyword}')[0] + '_processed.mid'
-    midi_path = midi_path + filename
-    assert os.path.exists(midi_path), midi_path
-    return midi_path
-
-def sample_nn(reps, rep_paths, playlists, n_samples=30):
-    nn_model = NearestNeighbors(n_neighbors=6, metric='cosine')
-    nn_model.fit(reps)
-    indexes = np.arange(len(reps))
-    np.random.shuffle(indexes)
-    for i, ind in enumerate(indexes[:n_samples]):
-        out = nn_model.kneighbors(reps[ind].reshape(1, -1))[1][0][1:]
-        midi_path = convert_rep_path_midi_path(rep_paths[ind])
-        copy(midi_path, neighbors_path + f'sample_{i}_playlist_{playlists[ind]}_target.mid')
-        for i_n, neighbor in enumerate(out):
-            midi_path = convert_rep_path_midi_path(rep_paths[neighbor])
-            copy(midi_path, neighbors_path + f'sample_{i}_playlist_{playlists[neighbor]}_neighbor_{i_n}.mid')
-
-def interpolate(reps, rep_paths, path):
-    files = os.listdir(path)
-    bounds = [f for f in files if 'interpolation' not in f]
-    b_reps = [np.loadtxt(path + f) for f in bounds]
-    nn_model = NearestNeighbors(n_neighbors=6)
-    nn_model.fit(reps)
-    reps = [alpha * b_reps[0] + (1 - alpha) * b_reps[1] for alpha in np.linspace(0, 1., 5)]
-    copy(convert_rep_path_midi_path(path + bounds[1]), path + 'interpolation_0.mid')
-    copy(convert_rep_path_midi_path(path + bounds[0]), path + 'interpolation_1.mid')
-    for alpha, rep in zip(np.linspace(0, 1, 5)[1:-1], reps[1: -1]):
-        dists, indexes = nn_model.kneighbors(rep.reshape(1, -1))
-        if dists.flatten()[0] == 0:
-            nn = indexes.flatten()[1]
-        else:
-            nn = indexes.flatten()[0]
-        midi_path = convert_rep_path_midi_path(rep_paths[nn])
-        copy(midi_path, path + f'interpolation_{alpha}.mid')
-
-if __name__ == '__main__':
-    extract_all_reps(rep_path)
-    reps, rep_paths, playlists, n_data, dim_data = load_reps(rep_path)
-    set_playlists, playlist_indexes, playlist_colors = get_playlist_indexes(playlists)
-    # interpolate(reps, rep_paths, interpolation_path + 'trial_1/')
-    sample_nn(reps, rep_paths, playlists)
-    tsne_reps, umap_reps = plot_tsne(reps, playlist_indexes, playlist_colors)
-

src/music/representation_learning/mlm_pretrain/data_collators.py

@@ -1,180 +0,0 @@
-from typing import Any, Dict, List, Optional, Tuple, Union
-from transformers.data.data_collator import DataCollatorForLanguageModeling, PreTrainedTokenizerBase, BatchEncoding, DataCollatorForPermutationLanguageModeling
-from dataclasses import dataclass
-
-
-def _torch_collate_batch(examples, tokenizer, pad_to_multiple_of: Optional[int] = None):
-    """Collate `examples` into a batch, using the information in `tokenizer` for padding if necessary."""
-    import numpy as np
-    import torch
-
-    # Tensorize if necessary.
-    if isinstance(examples[0], (list, tuple, np.ndarray)):
-        examples = [torch.tensor(e, dtype=torch.long) for e in examples]
-
-    length_of_first = examples[0].size(0)
-
-    # Check if padding is necessary.
-
-    are_tensors_same_length = all(x.size(0) == length_of_first for x in examples)
-    if are_tensors_same_length and (pad_to_multiple_of is None or length_of_first % pad_to_multiple_of == 0):
-        return torch.stack(examples, dim=0)
-
-    # If yes, check if we have a `pad_token`.
-    if tokenizer._pad_token is None:
-        raise ValueError(
-            "You are attempting to pad samples but the tokenizer you are using"
-            f" ({tokenizer.__class__.__name__}) does not have a pad token."
-        )
-
-    # Creating the full tensor and filling it with our data.
-    max_length = max(x.size(0) for x in examples)
-    if pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
-        max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of
-    result = examples[0].new_full([len(examples), max_length], tokenizer.pad_token_id)
-    for i, example in enumerate(examples):
-        if tokenizer.padding_side == "right":
-            result[i, : example.shape[0]] = example
-        else:
-            result[i, -example.shape[0] :] = example
-    return result
-
-
-@dataclass
-class DataCollatorForMusicModeling(DataCollatorForLanguageModeling):
-    """
-    Data collator used for language modeling. Inputs are dynamically padded to the maximum length of a batch if they
-    are not all of the same length.
-    Args:
-        tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
-            The tokenizer used for encoding the data.
-        mlm (`bool`, *optional*, defaults to `True`):
-            Whether or not to use masked language modeling. If set to `False`, the labels are the same as the inputs
-            with the padding tokens ignored (by setting them to -100). Otherwise, the labels are -100 for non-masked
-            tokens and the value to predict for the masked token.
-        mlm_probability (`float`, *optional*, defaults to 0.15):
-            The probability with which to (randomly) mask tokens in the input, when `mlm` is set to `True`.
-        pad_to_multiple_of (`int`, *optional*):
-            If set will pad the sequence to a multiple of the provided value.
-        return_tensors (`str`):
-            The type of Tensor to return. Allowable values are "np", "pt" and "tf".
-    <Tip>
-    For best performance, this data collator should be used with a dataset having items that are dictionaries or
-    BatchEncoding, with the `"special_tokens_mask"` key, as returned by a [`PreTrainedTokenizer`] or a
-    [`PreTrainedTokenizerFast`] with the argument `return_special_tokens_mask=True`.
-    </Tip>"""
-
-
-    def torch_call(self, examples: List[Union[List[int], Any, Dict[str, Any]]]) -> Dict[str, Any]:
-        # Handle dict or lists with proper padding and conversion to tensor.
-        if isinstance(examples[0], (dict, BatchEncoding)):
-            batch = self.tokenizer.pad(examples, return_tensors="pt", pad_to_multiple_of=self.pad_to_multiple_of)
-        else:
-            batch = {
-                "input_ids": _torch_collate_batch(examples, self.tokenizer, pad_to_multiple_of=self.pad_to_multiple_of)
-            }
-
-        # If special token mask has been preprocessed, pop it from the dict.
-        special_tokens_mask = batch.pop("special_tokens_mask", None)
-        if self.mlm:
-            batch["input_ids"], batch["labels"] = self.torch_mask_tokens(
-                batch["input_ids"], special_tokens_mask=special_tokens_mask
-            )
-        else:
-            labels = batch["input_ids"].clone()
-            if self.tokenizer.pad_token_id is not None:
-                labels[labels == self.tokenizer.pad_token_id] = -100
-            batch["labels"] = labels
-        return batch
-
-    def torch_mask_tokens(self, inputs: Any, special_tokens_mask: Optional[Any] = None) -> Tuple[Any, Any]:
-        """
-        Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original.
-        """
-        import torch
-
-        labels = inputs.clone()
-        # We sample a few tokens in each sequence for MLM training (with probability `self.mlm_probability`)
-        notes_shape = (labels.shape[0], labels.shape[1] // 5)
-        probability_matrix = torch.full(notes_shape, self.mlm_probability)
-        # if special_tokens_mask is None:
-        #     special_tokens_mask = [
-        #         self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()
-        #     ]
-        #     special_tokens_mask = torch.tensor(special_tokens_mask, dtype=torch.bool)
-        # else:
-        #     special_tokens_mask = special_tokens_mask.bool()
-
-        # probability_matrix.masked_fill_(special_tokens_mask, value=0.0)
-        masked_notes_indices = torch.bernoulli(probability_matrix).bool()
-        masked_indices = torch.repeat_interleave(masked_notes_indices, repeats=5, dim=1)
-        labels[~masked_indices] = -100  # We only compute loss on masked tokens
-
-        # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])
-        indices_notes_replaced = torch.bernoulli(torch.full(notes_shape, 0.8)).bool() & masked_notes_indices
-        indices_replaced = torch.repeat_interleave(indices_notes_replaced, repeats=5, dim=1)
-        inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)
-
-        # 10% of the time, we replace masked input tokens with random word
-        indices_notes_random = torch.bernoulli(torch.full(notes_shape, 0.5)).bool() & masked_notes_indices & ~indices_notes_replaced
-        indices_random = torch.repeat_interleave(indices_notes_random, repeats=5, dim=1)
-        random_words = torch.randint(3, len(self.tokenizer), labels.shape, dtype=torch.long)
-        inputs[indices_random] = random_words[indices_random]
-
-        # The rest of the time (10% of the time) we keep the masked input tokens unchanged
-        return inputs, labels
-
-
-
-@dataclass
-class DataCollatorForSpanMusicModeling(DataCollatorForLanguageModeling):
-    """
-    Data collator used for permutation language modeling.
-    - collates batches of tensors, honoring their tokenizer's pad_token
-    - preprocesses batches for permutation language modeling with procedures specific to XLNet
-    """
-
-
-    def torch_mask_tokens(self, inputs: Any, special_tokens_mask: Optional[Any] = None) -> Tuple[Any, Any]:
-        """
-        The masked tokens to be predicted for a particular sequence are determined by the following algorithm:
-            0. Start from the beginning of the sequence by setting `cur_len = 0` (number of tokens processed so far).
-            1. Sample a `span_length` from the interval `[1, max_span_length]` (length of span of tokens to be masked)
-            2. Reserve a context of length `context_length = span_length / plm_probability` to surround span to be
-               masked
-            3. Sample a starting point `start_index` from the interval `[cur_len, cur_len + context_length -
-               span_length]` and mask tokens `start_index:start_index + span_length`
-            4. Set `cur_len = cur_len + context_length`. If `cur_len < max_len` (i.e. there are tokens remaining in the
-               sequence to be processed), repeat from Step 1.
-        """
-
-        import torch
-
-        labels = inputs.clone()
-        # We sample a few tokens in each sequence for MLM training (with probability `self.mlm_probability`)
-        notes_shape = (labels.shape[0], labels.shape[1] // 5)
-        masked_notes_indices = torch.full(notes_shape, 0, dtype=torch.bool)
-
-        for i in range(labels.size(0)):
-            # Start from the beginning of the sequence by setting `cur_len = 0` (number of tokens processed so far).
-            cur_len = 0
-            max_len = notes_shape[1]
-
-            while cur_len < max_len:
-                # Sample a `span_length` from the interval `[1, max_span_length]` (length of span of tokens to be masked)
-                span_length = torch.randint(1, 5 + 1, (1,)).item()
-                # Reserve a context of length `context_length = span_length / plm_probability` to surround the span to be masked
-                context_length = int(span_length / self.mlm_probability)
-                # Sample a starting point `start_index` from the interval `[cur_len, cur_len + context_length - span_length]` and mask tokens `start_index:start_index + span_length`
-                start_index = cur_len + torch.randint(context_length - span_length + 1, (1,)).item()
-                masked_notes_indices[i, start_index: start_index + span_length] = 1
-                # Set `cur_len = cur_len + context_length`
-                cur_len += context_length
-
-        masked_indices = torch.repeat_interleave(masked_notes_indices, repeats=5, dim=1)
-        labels[~masked_indices] = -100  # We only compute loss on masked tokens
-
-        inputs[masked_indices] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)
-
-        return inputs, labels
-

src/music/representation_learning/mlm_pretrain/models/music-bert/config.json

@@ -1,20 +0,0 @@
-{
-  "attention_probs_dropout_prob": 0.1,
-  "gradient_checkpointing": false,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "layer_norm_eps": 1e-12,
-  "max_position_embeddings": 512,
-  "model_type": "bert",
-  "num_attention_heads": 12,
-  "num_hidden_layers": 12,
-  "pad_token_id": 0,
-  "position_embedding_type": "relative_key_query",
-  "transformers_version": "4.8.2",
-  "type_vocab_size": 2,
-  "use_cache": true,
-  "vocab_size": 30522
-}

src/music/representation_learning/mlm_pretrain/models/music-bert/tokenizer.json

@@ -1 +0,0 @@
-{"version":"1.0","truncation":null,"padding":null,"added_tokens":[],"normalizer":{"type":"Lowercase"},"pre_tokenizer":{"type":"Whitespace"},"post_processor":null,"decoder":null,"model":{"type":"WordLevel","vocab":{"[PAD]":0,"[MASK]":1,"[UNK]":2,"2":3,"3":4,"4":5,"5":6,"6":7,"7":8,"8":9,"9":10,"10":11,"11":12,"12":13,"13":14,"14":15,"15":16,"16":17,"17":18,"18":19,"19":20,"20":21,"21":22,"22":23,"23":24,"24":25,"25":26,"26":27,"27":28,"28":29,"29":30,"30":31,"31":32,"32":33,"33":34,"34":35,"35":36,"36":37,"37":38,"38":39,"39":40,"40":41,"41":42,"42":43,"43":44,"44":45,"45":46,"46":47,"47":48,"48":49,"49":50,"50":51,"51":52,"52":53,"53":54,"54":55,"55":56,"56":57,"57":58,"58":59,"59":60,"60":61,"61":62,"62":63,"63":64,"64":65,"65":66,"66":67,"67":68,"68":69,"69":70,"70":71,"71":72,"72":73,"73":74,"74":75,"75":76,"76":77,"77":78,"78":79,"79":80,"80":81,"81":82,"82":83,"83":84,"84":85,"85":86,"86":87,"87":88,"88":89,"89":90,"90":91,"91":92,"92":93,"93":94,"94":95,"95":96,"96":97,"97":98,"98":99,"99":100,"100":101,"101":102,"102":103,"103":104,"104":105,"105":106,"106":107,"107":108,"108":109,"109":110,"110":111,"111":112,"112":113,"113":114,"114":115,"115":116,"116":117,"117":118,"118":119,"119":120,"120":121,"121":122,"122":123,"123":124,"124":125,"125":126,"126":127,"127":128,"128":129,"129":130,"130":131,"131":132,"132":133,"133":134,"134":135,"135":136,"136":137,"137":138,"138":139,"139":140,"140":141,"141":142,"142":143,"143":144,"144":145,"145":146,"146":147,"147":148,"148":149,"149":150,"150":151,"151":152,"152":153,"153":154,"154":155,"155":156,"156":157,"157":158,"158":159,"159":160,"160":161,"161":162,"162":163,"163":164,"164":165,"165":166,"166":167,"167":168,"168":169,"169":170,"170":171,"171":172,"172":173,"173":174,"174":175,"175":176,"176":177,"177":178,"178":179,"179":180,"180":181,"181":182,"182":183},"unk_token":"[UNK]"}}

src/music/representation_learning/mlm_pretrain/models/music-spanbert/config.json

@@ -1,20 +0,0 @@
-{
-  "attention_probs_dropout_prob": 0.1,
-  "gradient_checkpointing": false,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "layer_norm_eps": 1e-12,
-  "max_position_embeddings": 512,
-  "model_type": "bert",
-  "num_attention_heads": 12,
-  "num_hidden_layers": 12,
-  "pad_token_id": 0,
-  "position_embedding_type": "relative_key_query",
-  "transformers_version": "4.8.2",
-  "type_vocab_size": 2,
-  "use_cache": true,
-  "vocab_size": 30522
-}

src/music/representation_learning/mlm_pretrain/models/music-spanbert/tokenizer.json

@@ -1 +0,0 @@
-{"version":"1.0","truncation":null,"padding":null,"added_tokens":[],"normalizer":{"type":"Lowercase"},"pre_tokenizer":{"type":"Whitespace"},"post_processor":null,"decoder":null,"model":{"type":"WordLevel","vocab":{"[PAD]":0,"[MASK]":1,"[UNK]":2,"2":3,"3":4,"4":5,"5":6,"6":7,"7":8,"8":9,"9":10,"10":11,"11":12,"12":13,"13":14,"14":15,"15":16,"16":17,"17":18,"18":19,"19":20,"20":21,"21":22,"22":23,"23":24,"24":25,"25":26,"26":27,"27":28,"28":29,"29":30,"30":31,"31":32,"32":33,"33":34,"34":35,"35":36,"36":37,"37":38,"38":39,"39":40,"40":41,"41":42,"42":43,"43":44,"44":45,"45":46,"46":47,"47":48,"48":49,"49":50,"50":51,"51":52,"52":53,"53":54,"54":55,"55":56,"56":57,"57":58,"58":59,"59":60,"60":61,"61":62,"62":63,"63":64,"64":65,"65":66,"66":67,"67":68,"68":69,"69":70,"70":71,"71":72,"72":73,"73":74,"74":75,"75":76,"76":77,"77":78,"78":79,"79":80,"80":81,"81":82,"82":83,"83":84,"84":85,"85":86,"86":87,"87":88,"88":89,"89":90,"90":91,"91":92,"92":93,"93":94,"94":95,"95":96,"96":97,"97":98,"98":99,"99":100,"100":101,"101":102,"102":103,"103":104,"104":105,"105":106,"106":107,"107":108,"108":109,"109":110,"110":111,"111":112,"112":113,"113":114,"114":115,"115":116,"116":117,"117":118,"118":119,"119":120,"120":121,"121":122,"122":123,"123":124,"124":125,"125":126,"126":127,"127":128,"128":129,"129":130,"130":131,"131":132,"132":133,"133":134,"134":135,"135":136,"136":137,"137":138,"138":139,"139":140,"140":141,"141":142,"142":143,"143":144,"144":145,"145":146,"146":147,"147":148,"148":149,"149":150,"150":151,"151":152,"152":153,"153":154,"154":155,"155":156,"156":157,"157":158,"158":159,"159":160,"160":161,"161":162,"162":163,"163":164,"164":165,"165":166,"166":167,"167":168,"168":169,"169":170,"170":171,"171":172,"172":173,"173":174,"174":175,"175":176,"176":177,"177":178,"178":179,"179":180,"180":181,"181":182,"182":183},"unk_token":"[UNK]"}}

src/music/representation_learning/mlm_pretrain/models/music-t5-small/config.json

@@ -1,56 +0,0 @@
-{
-  "architectures": [
-    "T5WithLMHeadModel"
-  ],
-  "d_ff": 2048,
-  "d_kv": 64,
-  "d_model": 512,
-  "decoder_start_token_id": 0,
-  "dropout_rate": 0.1,
-  "eos_token_id": 1,
-  "feed_forward_proj": "relu",
-  "gradient_checkpointing": false,
-  "initializer_factor": 1.0,
-  "is_encoder_decoder": true,
-  "layer_norm_epsilon": 1e-06,
-  "model_type": "t5",
-  "n_positions": 512,
-  "num_decoder_layers": 6,
-  "num_heads": 8,
-  "num_layers": 6,
-  "output_past": true,
-  "pad_token_id": 0,
-  "relative_attention_num_buckets": 32,
-  "task_specific_params": {
-    "summarization": {
-      "early_stopping": true,
-      "length_penalty": 2.0,
-      "max_length": 200,
-      "min_length": 30,
-      "no_repeat_ngram_size": 3,
-      "num_beams": 4,
-      "prefix": "summarize: "
-    },
-    "translation_en_to_de": {
-      "early_stopping": true,
-      "max_length": 300,
-      "num_beams": 4,
-      "prefix": "translate English to German: "
-    },
-    "translation_en_to_fr": {
-      "early_stopping": true,
-      "max_length": 300,
-      "num_beams": 4,
-      "prefix": "translate English to French: "
-    },
-    "translation_en_to_ro": {
-      "early_stopping": true,
-      "max_length": 300,
-      "num_beams": 4,
-      "prefix": "translate English to Romanian: "
-    }
-  },
-  "transformers_version": "4.8.2",
-  "use_cache": true,
-  "vocab_size": 32128
-}