import ast import colorsys import os from pathlib import Path import re from statistics import stdev import sys from IPython.display import display import matplotlib as mpl import matplotlib.colors as mcolors from matplotlib.colors import ListedColormap, LinearSegmentedColormap import matplotlib.pyplot as plt import numpy as np import pandas as pd from rdkit import Chem from rdkit.Chem import Draw from rdkit.Chem import AllChem import seaborn as sns from adjustText import adjust_text from .predictor import ScopeBO from .utils import calculate_vendi_score, obtain_full_covar_matrix # General plt parameters plt.rcParams.update({ "axes.titlesize": 20, # Subplot title "axes.labelsize": 16, # X and Y labels "figure.titlesize": 24, # Suptitle "xtick.labelsize": 14, # X tick labels "ytick.labelsize": 14, # Y tick labels "legend.fontsize": 14, # Legend text "legend.title_fontsize": 14, # Legend titles "font.family": "Helvetica" # Font }) class HiddenPrints: def __enter__(self): self._original_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') def __exit__(self, exc_type, exc_val, exc_tb): sys.stdout.close() sys.stdout = self._original_stdout class Benchmark: """ Class for running full scopes, collecting their data, and analyzing the results. Functions for data collection: collect_data: main functionality for running scopes change_featurization: recalculating Vendi scores in existing benchmark data with a different featurization (essentially creates a new scope run folde with these updated values) Functions for data analysis: heatmap plot: plot the overall results of scopes progress_plot: plot the progression of scopes with increasing scope size track_samples: visualize the selected samples on a UMAP show_scope: draw the structures of the selected compounds feature_analysis: SHAP analysis of the surrogate model for a scope objective_distribution: analyze the distribution of objective values in a scope get_metric_overview: collect the different metrics for all scopes in a benchmark folder (all random seeds) Utility functions: normalization: normalize values standardization: standardize values calculate_scope_score: calculate scope scores find_objectives: look up the objectives that were used in a scope _adjust_lightness: adjust the lightness of a color. Used for colormap definition. """ def __init__(self): # Define colormaps for plotting doyle_colors = ["#CE4C6F", "#1561C2", "#188F9D","#C4ADA2","#515798", "#CB7D85", "#A9A9A9"] # extension of palette with lighter and darker versions lighter = [self._adjust_lightness(c, 1.2) for c in doyle_colors] darker = [self._adjust_lightness(c, 0.7) for c in doyle_colors] self.all_colors = doyle_colors + darker[::-1] + lighter[::-1] # Save the categorical colormap self.cat_cmap = ListedColormap(self.all_colors, name="Doyle_cat") # Define and save a continuous colormap colors = [doyle_colors[1],"#FFFFFFD1",doyle_colors[0]] self.cont_cmap = LinearSegmentedColormap.from_list("Doyle_cont", colors) # Define and save a second continuous colormap colors = [doyle_colors[3],"#FFFFFFD1",doyle_colors[2]] self.cont_cmap2 = LinearSegmentedColormap.from_list("Doyle_cont2", colors) @staticmethod def _adjust_lightness(color, factor=1.2): """ Helper function to make colors lighter (factor > 1) or darker (factor < 1). Used for colormap definition. """ r, g, b = mcolors.to_rgb(color) h, l, s = colorsys.rgb_to_hls(r, g, b) l = max(0, min(1, l * factor)) r, g, b = colorsys.hls_to_rgb(h, l, s) return mcolors.to_hex((r, g, b)) def collect_data(self, filename_labelled, objectives, name_results, specific_seed = None, seeds = 40, idx_to_keep = None, objective_mode = {"all_obj":"max"}, init_sampling_method="random", Vendi_pruning_fractions = [13], batches=[3], budget=27, objective_weights = None, sample_threshold = None, enforce_dissimilarity=False, pruning_metric = "vendi_batch", acquisition_function_mode = 'balanced', dft_filename = None, filename_prediction = "df_benchmark.csv", directory='.'): """ Runs the ScopeBO.run function for selected parameter ranges and records the results per round for each set of parameters. Returns a number of csv files in a folder with the name name_results: Raw results: One per combination of seed, batch, and Vendi_pruning_fraction settings containing the following results: objective values for each evaluated point, grouped by round ("obj_value") Vendi score of the all evaluated points after each round ("Vendi_score") indices of evaluated samples for each round ("eval_samples") indices of samples cut by the Vendi cutoff for each round ("cut_samples") Example output (batch size 3 and 2 objectives; 5 samples were pruned from the reaction space): objective_values Vendi_score samples cut_samples 0 [[1,2,5],[1,5,12]] 43 [3,5,12] [5,3,1,35,5] 1 [[11,2,11],[16,1,4]] 37 [5,17,1] [4,9,7,24,51] Whereas the index column corresponds to the round of experiments. The raw result files are saved as [budget][acquisition_function_mode]_b[batch]_V[Vendi_pruning_fraction]_s[seed].csv They are located in a subfolder "raw_data". If specific_seed != None, the raw results are directly located in name_results. Summarized data: These files contain either objective value data (averaged for each batch round) ("obj") or Vendi score data ("vendi"). The rows correspond to the different batch sizes in batches (noted as indices). The columns correspond to the different Vendi_pruning_fractions. The entries are lists containing the results per round. There are files contain average values ("average") (across the different seeds) or the standard deviation ("stdev") (across the different seeds). In the case of multiple objectives, a separate file for each objective value as well as a file containing the combined objective values are generated. Example name for a run with the objectives "yield" and "selectivity": "benchmark_obj[yield__selectivity]_av.csv" --> average objective value data Summarized data is only generated if the variable specific_seed = None (default). ------------------------------------------------------------------------------------- filename_labelled: string name of the csv file with the labelled data objective: list list indicating the column name for the objective (string) name_results: str name of the folder in which the results will be saved specific_seed: int or None Ignored if None (default). If specified, will only run the given random seed (overwriting variable seeds). seeds: int number of different random seeds to be evaluate (will use range(seeds)) Default is 40. idx_to_keep: list or None list of indices of the labelled dataframe which won't be removed at the beginning of the scope run Enables to "hot-start" a scope with prior data. Default is None (remove all idx and start the scope from scratch). objective_mode: dict Dictionary of objective modes for objectives Provide dict with value "min" in case of a minimization task (e. g. {"cost":"min"}) Code will assume maximization for all non-listed objectives Default is {"all_obj":"max"} --> all objectives are maximized init_sampling_method: str sampling method. Options: "random": random selection (default) "cvt": CVT sampling "lhs": LHS sampling Vendi_pruning_fractions: list list of threshold values for the Vendi cutoff (ints) Default: [13] batches: list list of batch sizes (as int numbers) Default: [3] budget: int experimental budget Default: 27 objective_weights: list or None list of float weights for the scalarization of the objectives only relevant for multi-objective greedy runs, not other acquisition functions Default: None (objectives will be averaged) sample_threshold: float, tuple, or None Numeric threshold for a minimum pairwise Vendi score between two samples in a batch. If a tuple is provided, the first value is the Vendi score threshold and the second value is the minimum number of prior samples needed for the pruning to be applied. Default is None (no thresholding). This option was explored during development, but not used in the final version of ScopeBO and is only implemented for legacy reasons. enforce_dissimilarity: Boolean If True, removes all samples from the search space in each batch that have a pairwise Vendi score below 1.06 to any of the previously selected samples. Default is False. This option was explored during development, but not used in the final version of ScopeBO and is only implemented for legacy reasons. pruning_metric: str Mode used for the pruning. Options: "vendi_batch": pruning by vendi scores before every round of experiments (default - optimized settings). "vendi_sample": pruning by vendi score before every sample. "variance": pruning by surrogate model variance (implemented only for benchmarking purposes). acquisition_function_mode: str Choose the acqusition function. Options: "balanced" (Default): exploration-exploitation trade-off via qExpectedImprovement (1 objective) or qNoisyExpectedHypervolumeImprovement (multi-objective) "greedy": pure exploitative selection "explorative": pure explorative selection "random": random selection dft_filename: None or str name of the file containing the dft-featurized reaction space for the vendi score calculation only has to be given if the substrate encoding is not dft-derived (e. g. Mordred or Rdkit featurization) NOTE: only implemented for mono-objective cases Default: None filename_prediction: str name of the csv file in which the benchmark dataframe is saved Default: "df_benchmark.csv" directory: str working directory (default is current directory) """ # Create the results folder and the folder for raw results. wdir = Path(directory) if not os.path.exists(wdir.joinpath(name_results)): # Create the folder os.makedirs(wdir.joinpath(name_results)) if (not os.path.exists(wdir.joinpath(name_results+"/raw_data"))) and (specific_seed is None): # Create the folder os.makedirs(wdir.joinpath(name_results+"/raw_data")) # Read labelled data. df_labelled = pd.read_csv(wdir.joinpath(filename_labelled),index_col=0,header=0, float_precision = "round_trip") # Generate a copy of the DataFrame with labelled data and remove the objective data. df_unlabelled = df_labelled.copy(deep=True) # check if some samples should be retained for the start of the scope if idx_to_keep is not None: # delete all objective data apart from the specified ones for obj in objectives: df_unlabelled.loc[~df_unlabelled.index.isin(idx_to_keep),obj] = "PENDING" print("The scope will be hot-started with the following samples:") print(f"{df_unlabelled.index[~df_unlabelled.isin(['PENDING']).any(axis=1)].tolist()}") # also make a dummy priority column df_unlabelled["priority"] = 0 else: df_unlabelled.drop(columns=objectives,inplace=True) # Set up the Vendi pruning fraction and batch size names for the results dataframes. Vendi_names = [] for Vpf in Vendi_pruning_fractions: if type(Vpf) is list: rounded_Vpf = [round(el,1) if type(el) is float else el for el in Vpf] Vendi_names.append("-".join(map(str,rounded_Vpf))) else: Vendi_names.append(str(Vpf)) batch_names = [] for batch in batches: if type(batch) is list: batch_names.append("-".join(map(str,batch))) else: batch_names.append(str(batch)) # Instantiate empty df for the analyzed results. df_obj_av = pd.DataFrame(None,batch_names,Vendi_names) df_obj_stdev = pd.DataFrame(None,batch_names,Vendi_names) dfs_indiv_obj_av = None dfs_indiv_obj_stdev = None if len(objectives) > 1: # also make separate dfs for the individual objectives if there are multiple objectives dfs_indiv_obj_av = {} dfs_indiv_obj_stdev = {} for objective in objectives: dfs_indiv_obj_av[objective] = pd.DataFrame(None,batch_names,Vendi_names) dfs_indiv_obj_stdev[objective] = pd.DataFrame(None,batch_names,Vendi_names) df_vendi_av = pd.DataFrame(None,batch_names,Vendi_names) df_vendi_stdev = pd.DataFrame(None,batch_names,Vendi_names) # Instantiate a ScopeBO object myScopeBO = ScopeBO() # Set the name for the file used in the benchmarking runs. csv_filename_pred = wdir.joinpath(filename_prediction) # In case of non-DFT featurization, set up some other things to get a DFT-featurization-based vendi score. vendiScopeBO = None df_dft = None filename_vendi = None current_df_dft = None if dft_filename: filename_vendi = filename_prediction.replace(".csv","_vendi.csv") df_dft = pd.read_csv(wdir.joinpath(dft_filename),index_col=0,header=0, float_precision = "round_trip") df_dft[objectives[0]] = "PENDING" vendiScopeBO = ScopeBO() # Run all the requested parameter settings. run_counter = 1 # variable for feedback during run # test the number of random seeds as indicated in the variable seeds seeds_to_test = range(seeds) # if a specific seed was requested, only test that one if specific_seed is not None: seeds_to_test = [specific_seed] total_runs = len(batches) * len(Vendi_pruning_fractions) * len(seeds_to_test) # Loop through all combinations of batch sizes, Vendi pruning fractions, and random seeds. for batch in batches: for Vpf in Vendi_pruning_fractions: seeded_list_obj = [] seeded_list_vendi = [] for seed in seeds_to_test: # Reset the csv file for the campaign by removing the objective data (meaning overwriting with the unlabelled df). df_unlabelled.to_csv(csv_filename_pred, index=True, header=True) if df_dft is not None: current_df_dft = df_dft.copy(deep=True) # reset the dft-feautrized df for the vendi calculation # Set up lists to hold raw results and average results for this run. raw_results = [] run_results = [] # Determine the number of rounds of experiments for the given batch size. rounds = 0 if type(batch) is list: rounds = len(batch) else: if budget % batch != 0: rounds = int(budget/batch)+1 # extra round with reduced batch size for last run (will be reduced below) else: rounds = int(budget/batch) # Run ScopeBO for these settings. for current_round in range(rounds): # check if the batch size is dynamic (meaning different batch sizes for each rounds) current_batch = None if type(batch) is list: current_batch = batch[current_round] else: current_batch = batch # Check if this will be a run with reduced batch size (due to the set budget). if current_round+1 == rounds and budget % batch != 0: current_batch = budget % batch # Check if the Vendi_pruning_fraction is dynamic (meaning different fractions for each round) this_Vendi_pruning_fraction = Vpf if type(Vpf) is list: this_Vendi_pruning_fraction = Vpf[current_round] # assign labels for the print-out batch_label = batch Vpf_label = this_Vendi_pruning_fraction current_batch_label = current_batch print(f"Now running Batch size: {batch_label}, Vendi_pruning_fraction: {Vpf_label}, Seed: {seed}, Round: {current_round}, current batch: {current_batch_label}") with HiddenPrints(): current_df = myScopeBO.run( objectives = objectives, objective_mode= objective_mode, objective_weights = objective_weights, filename = filename_prediction, batch = current_batch, init_sampling_method = init_sampling_method, seed = seed, Vendi_pruning_fraction = this_Vendi_pruning_fraction, pruning_metric = pruning_metric, acquisition_function_mode = acquisition_function_mode, give_alternative_suggestions = False, show_suggestions=False, sample_threshold=sample_threshold, enforce_dissimilarity=enforce_dissimilarity ) current_raw_results = [] # Save indices of samples. current_idx_samples = list(current_df[current_df["priority"] == 1].index) if current_idx_samples == []: return print("The scope could not be finished because there are no samples left. Please adjust the settings.") # Update dataframe with results and save the objective values. current_obj = [] for objective in objectives: obj_list = [] for idx in current_idx_samples: current_df.loc[idx,objective] = df_labelled.loc[idx,objective] obj_list.append(df_labelled.loc[idx,objective]) current_obj.append(obj_list) # Save the dataframe for the next round of ScopeBO. current_df.to_csv(csv_filename_pred, index=True, header=True) # Calculate the Vendi score for all points that were obseved so far. if vendiScopeBO: # this is the scenario when a non-dft featurization is used in the campaign for idx in current_idx_samples: current_df_dft.loc[idx,objectives[0]] = df_labelled.loc[idx,objectives[0]] current_df_dft.to_csv(wdir.joinpath(filename_vendi),index=True,header=True) current_vendi_score = vendiScopeBO.get_vendi_score(objectives = objectives, directory = directory, filename = filename_vendi) print("Vendi score calculated via additional file with dft featurization.") else: # this is the standard case for a campaign using dft featurization current_vendi_score = myScopeBO.get_vendi_score(objectives = objectives, directory = directory, filename = filename_prediction) # Get the newly pruned samples by looking up all pruned samples and removing the ones that were already pruned. current_idx_cut = list(current_df[current_df["priority"] == -1].index) for i in range(current_round): # loop through the previously saved batches. for j in raw_results[i][3]: # cut samples are saved as the 4th entry in each current_results list current_idx_cut.remove(j) # Save results for this round in a list and append it to the overall results list. current_raw_results.append(current_obj) current_raw_results.append(current_vendi_score) current_raw_results.append(current_idx_samples) current_raw_results.append(current_idx_cut) raw_results.append(current_raw_results) # Average the objective value for all samples in this round (separately for every objective) current_obj_av = [np.mean(sublist) for sublist in current_obj] # Save the processed results for this round. run_results.append([current_obj_av,current_vendi_score]) # Save the processed results for this run. seeded_list_obj.append([run_results[i][0] for i in range(len(run_results))]) seeded_list_vendi.append([run_results[i][1] for i in range(len(run_results))]) # Save raw results as a csv. df_results = pd.DataFrame(raw_results,columns=[f"obj_values {objectives}","Vendi_score","eval_samples","cut_samples"]) if specific_seed is None: csv_filename_results = wdir.joinpath(name_results+f"/raw_data/{budget}{acquisition_function_mode}_"\ f"b{batch_names[batches.index(batch)]}_V"\ f"{Vendi_names[Vendi_pruning_fractions.index(Vpf)]}_s{seed}.csv") else: # no raw_dat subfolder if only one specific seed was requested csv_filename_results = wdir.joinpath(name_results+f"/{budget}{acquisition_function_mode}_b"\ f"{batch_names[batches.index(batch)]}_V"\ f"{Vendi_names[Vendi_pruning_fractions.index(Vpf)]}_s{seed}.csv") if len(df_results.iloc[0,0]) == 1: # flatten unnecessary list of lists for mono-objective runs for idx in df_results.index: df_results.loc[idx,f"obj_values {objectives}"] = str(df_results.loc[idx,f"obj_values {objectives}"][0]) df_results.to_csv(csv_filename_results,index=True,header=True) print (f"Finished campaign {run_counter} of {total_runs}.") run_counter+= 1 # only do summary analysis if specific seeds = None if specific_seed is None: # Calculate the averages and standard deviations across the different seeds and save the results. obj_value = [[sum(matrix[i][j] for matrix in seeded_list_obj) / len(seeded_list_obj) for j in range(len(seeded_list_obj[0][0]))] for i in range(len(seeded_list_obj[0]))] if len(obj_value[0]) == 1: # mono-objective df_obj_av.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([value for this_round in obj_value for value in this_round]) else: # multi-objective df_obj_av.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str(obj_value) # also populate the dataframes for the individual objectives for i in range(len(objectives)): dfs_indiv_obj_av[objectives[i]].loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([obj[i] for obj in obj_value]) # Standard deviation can only be calculated if there are at least 2 values. Set to zero if there is only one. if seeds > 1: obj_std = [[stdev([matrix[i][j] for matrix in seeded_list_obj]) for j in range(len(seeded_list_obj[0][0]))] for i in range(len(seeded_list_obj[0]))] if len(obj_std[0]) == 1: # mono-objective df_obj_stdev.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([value for this_round in obj_std for value in this_round]) else: # multi-objective df_obj_stdev.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str(obj_std) # also populate the dataframes for the individual objectives for i in range(len(objectives)): dfs_indiv_obj_stdev[objectives[i]].loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([obj[i] for obj in obj_std]) df_vendi_stdev.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([stdev(i) for i in zip(*seeded_list_vendi)]) else: obj_std = [[0 for j in range(len(seeded_list_obj[0][0]))] for i in range(len(seeded_list_obj[0]))] if len(obj_std[0]) == 1: # mono-objective df_obj_stdev.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([value for this_round in obj_std for value in this_round]) else: # multi-objective df_obj_stdev.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str(obj_std) # also populate the dataframes for the individual objectives for i in range(len(objectives)): dfs_indiv_obj_stdev[objectives[i]].loc[str(batch),Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([obj[i] for obj in obj_std]) df_vendi_stdev.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([0 for i in zip(*seeded_list_vendi)]) df_vendi_av.loc[batch_names[batches.index(batch)],Vendi_names[Vendi_pruning_fractions.index(Vpf)]] = str([sum(i) / len(i) for i in zip(*seeded_list_vendi)]) # Save the dataframes with the processed results as csv files (only if no specific seed). if specific_seed is None: df_obj_av.to_csv(wdir.joinpath(name_results+f"/benchmark_obj[{'__'.join(objectives)}]_av.csv"),index=True,header=True) df_obj_stdev.to_csv(wdir.joinpath(name_results+f"/benchmark_obj[{'__'.join(objectives)}]_stdev.csv"),index=True,header=True) df_vendi_av.to_csv(wdir.joinpath(name_results+"/benchmark_vendi_av.csv"),index=True,header=True) df_vendi_stdev.to_csv(wdir.joinpath(name_results+"/benchmark_vendi_stdev.csv"),index=True,header=True) if len(objectives) > 1: for objective in objectives: dfs_indiv_obj_av[objective].to_csv(wdir.joinpath(name_results+f"/benchmark_obj[{objective}]_av.csv"),index=True,header=True) dfs_indiv_obj_stdev[objective].to_csv(wdir.joinpath(name_results+f"/benchmark_obj[{objective}]_stdev.csv"),index=True,header=True) print(f"Data collection finished! Results are saved in the subfolder {name_results}.") @staticmethod def change_featurization(name_feat, filename_labelled, name_results, new_folder_name = None, cov_mat = None, directory = "."): """ Recalculate Vendi scores for scopes using an alternative featurization. Generates a new folder with recalculated raw data files containing updated ``Vendi_score`` columns. Parameters ---------- name_feat : str Name of the new featurization used in the Vendi score calculation. filename_labelled : str Path to the CSV file containing the labelled dataset with the new features. name_results : str Path to the folder containing the original results. new_folder_name: str or None Path to the folder where the results will be saved. If None is given, the folder will be named automatically (see Returns section). cov_mat : np.ndarray, optional Covariance matrix to be used for the Vendi score calculation. If None (default), the covariance matrix will be calculated from the labelled data. directory : str Working directory. Returns ------- None Saves recalculated raw data files with updated "Vendi_score" columns in a new folder named "__feat/raw_data" (or as indicated by the variable new_folder_name). """ # create a folder where the results can be saved wdir = Path(directory) results_path = wdir / name_results raw_path = results_path / "raw_data" feat_path = results_path.parent / f"{results_path.name}_{name_feat}_feat/raw_data" if new_folder_name is not None: feat_path = Path(new_folder_name) feat_path.mkdir(parents=True, exist_ok=True) # ensure that the results folder exists # read in the featurization that will be used for the Vendi score calculation df_labelled = pd.read_csv(wdir / filename_labelled,index_col=0,header=0) # sort it by index df_labelled.sort_index(inplace=True) # find the objectives objectives = Benchmark.find_objectives(name_results,directory) # calculate the covariance matrix if none was provided if cov_mat is None: cov_mat = obtain_full_covar_matrix(objectives=objectives,directory=directory,filename=filename_labelled) print(f"Recalcuting the Vendi scores for the scopes in the folder '{name_results}'.") # go through all the raw files in the original folder for file in os.listdir(raw_path): # make an unlabelled copy of the dataframe df_Vendi = df_labelled.copy(deep=True) for objective in objectives: df_Vendi[objective] = "PENDING" # read in the raw data file df_raw = pd.read_csv(raw_path / file, index_col = 0, header = 0) # convert the format of the evaluated samples from one string to a list of strings df_raw["eval_samples"] = df_raw["eval_samples"].apply(lambda x: [y.strip("'") for y in x[1:-1].split(', ')]) # reset the Vendi scores df_raw["Vendi_score"] = np.nan Vendi_scores = [] # loop through the rounds of the run for run_round in df_raw.index: # get the evaluated samples samples = df_raw.loc[run_round,"eval_samples"] # record the evaluated samples in the df of the new featurization for sample in samples: sample = str(sample.encode().decode('unicode_escape')) for objective in objectives: df_Vendi.loc[sample,objective] = df_labelled.loc[sample,objective] # sort to assert that df_Vendi has the required order as the cov_mat df_Vendi.sort_index(inplace=True) # calculate the Vendi score and save it idx_target = (df_Vendi[~df_Vendi.apply(lambda r: r.astype(str).str.contains('PENDING', case=False).any(), axis=1)]).index.values idx_num = [df_Vendi.index.get_loc(idx) for idx in idx_target] current_Vendi_score = calculate_vendi_score(idx_num=idx_num,covariance_matrix=cov_mat) Vendi_scores.append(current_Vendi_score) # overwrite the Vendi scores in the df df_raw["Vendi_score"] = Vendi_scores # save it in the new folder df_raw.to_csv(feat_path / file, index=True,header=True) print(f"Recalculated the Vendi scores in the file {file} (using {name_feat} featurization).") def heatmap_plot(self, type_results, name_results, budget, scope_method = "product", objective_mode = {"all_obj":"max"}, objective_weights = None, bounds = {"rate": (2.349,1.035), "vendi": (6.366,1.941)}, filename = None, show_plot = True, directory = '.'): """ Generates and saves a heatmap plot for the requested result type (if requested) across different batch sizes and Vendi_pruning_fractions. Options for displayed results: scope score ("scope"), vendi score ("vendi"), weighted objectives ("objectives", normalized if multiple objectives), or individual objectives displayed by their respective name. --------------------------------------------------------------------------------------------------------- Input: type_results: str Requested type of result. Options: "vendi": Vendi score "objective": average objective values "scope": scope score You can also provide the name of a specific objective for that run and then it will only analyze that one. name_results: str Name of the subfolder in which the result csv files are saved. budget: int experimental budget used in the runs scope_method: str method to calculate the scope score ("average","product" (Default),"geometric_mean") objective_mode: dict Dictionary of objective modes for objectives Provide dict with value "min" in case of a minimization task (e. g. {"cost":"min"}) Code will assume maximization for all non-listed objectives Default is {"all_obj":"max"} --> all objectives are maximized objective_weights: dict or None Weights for averaging the objective data Example: {"yield": 0.3, "ee": 0.7} Default is None --> all objectives will be averaged. bounds: dict dictionary of bounds for the individual metrics (vendi, all objectives) Default values are for the ArI dataset. filename: str or None name for the figure that is created. Default is None --> figure is not saved. show_plot: Boolean Option to show the heatmap plot (Default is True.) directory: str current directory. Default: '.' """ wdir = Path(directory) # Get the overview for the requested data dfs_scaled,_ = self.get_metric_overview(bounds, budget, name_results, type_results, scope_method, objective_mode, objective_weights, directory) means = dfs_scaled["means"] # dfs_scaled have the different conditions (batch_pruning) as columns and the scope size as indices # transform to grid with batch sizes as indices and pruning amounds as columns batch_sizes = list(set([int(col.split("_")[0][1:]) for col in means.columns])) pruning_amounts = list(set([int(col.split("_")[1][1:]) for col in means.columns])) df_heatmap = pd.DataFrame(np.nan,index=batch_sizes,columns=pruning_amounts) df_heatmap.index = sorted(df_heatmap.index) df_heatmap.columns = sorted(df_heatmap.columns) for batch in batch_sizes: for pruning in pruning_amounts: df_heatmap.loc[batch,pruning] = means.loc[budget,f"b{batch}_V{pruning}"] if show_plot: # Generate and save the heatmap plot if it was requested. plt.figure(figsize=(10,3)) if type_results == "comb_obj": type_results = "Combined objective" heatmap = sns.heatmap(df_heatmap,annot=True, fmt=".3f", linewidths=1,cmap=self.cont_cmap, cbar_kws={'label': f"{type_results} score"}) heatmap.set(xlabel="Vendi pruning fraction in %", ylabel="batch size") heatmap.tick_params(length=0) plt.show() if filename is not None: heatmap_figure = heatmap.get_figure() heatmap_figure.savefig(wdir.joinpath(filename)) return df_heatmap def progress_plot(self, budget, type_results, name_results, scope_method = "product", objective_mode = {"all_obj": "max"}, objective_weights = None, bounds = {"rate": (2.349,1.035), "vendi": (6.366,1.941)}, filename_figure = None, directory = ".", show_plot = True, show_stats = None, specified_batch_size = None): """ Generates a result(number of experiments) y(x)-plot for the requested results. Options for displayed results: scope score ("scope"), vendi score ("vendi"), weighted objectives ("objective", normalized if multiple objectives), or individual objectives requested by their respective name. Inputs: budget: int experimental budget used in the runs type_results: str Requested type of result. Options: "vendi": Vendi score "objective": average objective values "scope": scope score You can also provide the name of a specific objective for that run and then it will only analyze that one. name_results: str Name of the subfolder in which the result csv files are saved. scope_method: str method to calculate the scope score ("average","product" (Default),"geometric_mean" ) objective_mode: dict Dictionary of objective modes for objectives Provide dict with value "min" in case of a minimization task (e. g. {"cost":"min"}) Code will assume maximization for all non-listed objectives Default is {"all_obj":"max"} objective_weights: dict or None Weights for averaging the objective data Example: {"yield": 0.3, "ee": 0.7} Default is None --> all objectives will be averaged with equal weights. bounds: dict dictionary of bounds for the individual metrics (vendi, all objectives) the dict keys are the metric, the values are a tuple of max and min value Default values are for the ArI dataset. filename_figure: str or None name for the figure that is created. Default is None --> figure is not saved. directory: str current directory. Default: '.' show_plot: Boolean Option to display the generated line plot (default is True). show_stats: str or None Option to display a statistic to the metric. Options: "stdev": Standard deviation. "min-max": Max and Min values. Default is None. specified_batch_size: int or None the code normally infers the batch size from the filename. If a file is name anormal so that this is not possible, the batch size can be specified with this variable. Default is None --> infer the batch size from the filename """ wdir = Path(directory) # Get the overview for the requested data dfs_scaled,_ = self.get_metric_overview(bounds, budget, name_results, type_results, scope_method, objective_mode, objective_weights, directory, specified_batch_size) # Plot and save the figure if requested. if show_plot: means = dfs_scaled["means"] stds = dfs_scaled["stdev"] maxs = dfs_scaled["max"] mins = dfs_scaled["min"] fig, ax = plt.subplots(figsize=(6,6)) for i,col in enumerate(means.columns): x = means.index.values mean = means[col].values std = stds[col].values maxval = maxs[col].values minval = mins[col].values # mask nan values that would hinder printing mask = ~np.isnan(mean) & ~np.isnan(std) & ~np.isnan(maxval) & ~np.isnan(minval) x, mean, std, maxval, minval = x[mask], mean[mask], std[mask], maxval[mask], minval[mask] color = self.all_colors[i] ax.plot(x, mean, label=col, color=color) if show_stats == "stdev": ax.fill_between(x, mean - std, mean + std, alpha=0.1, color=color) ax.plot(x, mean + std, linestyle="--", color=color, alpha=0.3) ax.plot(x, mean - std, linestyle="--", color=color, alpha=0.3) elif show_stats == "min-max": ax.fill_between(x, minval, maxval, alpha=0.1, color=color) ax.plot(x, maxval, linestyle="--", color=color, alpha=0.3) ax.plot(x, minval, linestyle="--", color=color, alpha=0.3) ax.set_xlabel("Scope size") if type_results == "comb_obj": type_results = "Combined objective" ax.set_ylabel(f"{type_results} score") ax.legend(title="Columns") plt.tight_layout() plt.show() # save the figure if requested if filename_figure is not None: figure = fig.get_figure() figure.savefig(wdir.joinpath(filename_figure)) return dfs_scaled # return the data def track_samples(self, filename_umap, filename_data, name_results, scope_method="product", objective_mode = {"all_obj":"max"}, objective_weights = None, obj_plot_bounds = None, cbar_scaling = None, cbar_title = None, bounds = {"rate": (2.349,1.035), "vendi": (6.366,1.941)}, display_cut_samples = True, obj_to_display = None, dpi = 100, figsize = (10,8), size_scaling = 1, filename_labelled = None, show_colorbar = True, rounds_to_display = None, label_round = False, filename_figure = None, hide_axis = False, restrict_samples = None, directory='.'): """ Visually tracks the evaluated and cut samples of a single benchmarking run on a provided UMAP. Saves the generated plot. Also provides the results for the run. ------------------------------------------------------------------------------------------------ Inputs: filename_umap: str name of the file containing the UMAP coordinates filename_data: str name of the benchmarking run to be analyzed name_results: str subfolder in which the results are located scope_method: str method to calculate the scope score ("average","product" (Default),"geometric_mean") objective_mode: dict Dictionary of objective modes for objectives Provide dict with value "min" in case of a minimization task (e. g. {"cost":"min"}) Code will assume maximization for all non-listed objectives Default is {"all_obj":"max"} objective_weights: dict or None Weights for averaging the objective data Example: {"yield": 0.3, "ee": 0.7} Default is None --> all objectives will be averaged with equal weights. obj_plot_bounds: tuple or None option to provide bounds (max,min) for the color bar (default is None) cbar_scaling: int or None option to scale the values on the colorbar (e. g. if yield scale is [0,1] instead of [0,100]) cbar_title: str or None If None, the objective name will be displayed on the color bar. If a string is provided, the color bar label will be set by the variable. bounds: dict dictionary of bounds for the individual metrics (vendi, all objectives) Default values are for the ArI dataset. display_cut_samples: Boolean show the samples that have been cut by the vendi scoring or not. Default = True. If True, the samples in the plot will be colored by the round when they were selected. If False, the samples will be displayed by their objective value (default is first listed objective - can be changed in variable obj_to_display) obj_to_display: str or None color the selected points by objective values if display_cut_samples is False. Default is None (take the first listed objective). dpi: int resolution of the displayed figure Default is 100 (also matplotlib default). figsize: tuple of 2 int figure size. Default is (10,8). size_scaling: float Variable to scale the size of the displayed points (to account for different figsizes). Default is 1. filename_labelled: str or None name of the csv file containing the labelled data for the entire searchspace If specified (default is None) and display_cut_samples is False, the pending/cut samples will be colored by their theoretical performance. show_colorbar: Boolean Option to show a colorbar (default is True). rounds_to_display: int or None Specify how many rounds of the run you want to display (starting from the first one). The metrics will also only be calculate for the these rounds. E. g.: rounds_to_display=4 --> first 4 rounds will be displayed Default is None --> shows all rounds label_round: Boolean label the suggested samples by the round of selection. Default = False. filename_figure: str or None name for the figure that is generated If None, the figure will not be saved. hide_axis: Boolean hide the axis ticks if True (Default is False). restrict_samples: str Option to restrict the UMAP samples to the samples were in the actually used searchspace (e. g. when only a subset of a dataset was used for a run) The input parameter is the filename of the used searchspace (must be a subset of the one in the UMAP) Default is None (no restriction applied). directory: str current directory. Default: "." """ # Set directory. wdir = Path(directory) # Read in UMAP and data. df_umap = pd.read_csv(wdir.joinpath(filename_umap),index_col=0, float_precision = "round_trip") df_data = pd.read_csv(wdir.joinpath(name_results+"/"+filename_data),index_col=0, float_precision = "round_trip") # Chec if the UMAP samples will be restricted if restrict_samples is not None: df_space = pd.read_csv(wdir.joinpath(restrict_samples),index_col=0, float_precision = "round_trip") # Only keep the samples at are in the search space df_umap = df_umap.loc[df_umap.index.intersection(df_space.index)] # Prune the number of rounds if requested if rounds_to_display is not None: df_data = df_data.iloc[:rounds_to_display,:] df_data["eval_samples"] = df_data["eval_samples"].apply(lambda x: [y.strip("'") for y in x[1:-1].split(', ')]) df_data["cut_samples"] = df_data["cut_samples"].apply(lambda x: [y.strip("'") for y in x[1:-1].split(', ')]) # get the objectives objectives = ast.literal_eval(df_data.columns[0][11:]) # Get the overall results for this run: vendi_score = df_data['Vendi_score'].iloc[-1] dict_obj_values = {} df_data[f"obj_values {objectives}"] = df_data[f"obj_values {objectives}"].apply(ast.literal_eval) for i, obj in enumerate(objectives): # get a list with the objective values of each entry if len(objectives) > 1: dict_obj_values[obj] = [value for round_list in [df_data.loc[round,f"obj_values {objectives}"][i] for round in df_data.index] for value in round_list] else: dict_obj_values[obj] = [value for round_list in [df_data.loc[round,f"obj_values {objectives}"] for round in df_data.index] for value in round_list] # check if one of the objectives was a minimization task min_obj = [obj for obj, value in objective_mode.items() if value == "min"] # Scale the individual objective values dict_obj_scaled = {} dict_obj_av = {} for obj in dict_obj_values: dict_obj_scaled[obj] = [self.normalization(score=value, bounds=bounds[obj]) for value in dict_obj_values[obj]] # check if the objective was a minimization task and treat appropriately if so if obj in min_obj: dict_obj_scaled[obj] = [1 - value for value in dict_obj_scaled[obj]] dict_obj_av[obj] = np.mean(dict_obj_scaled[obj]) # calculate the average value for each objective (using weights if submitted) if (objective_weights is not None) and (len(objectives) > 1): # ensure that the weights sum up to 1 sum_weights = sum(objective_weights.values()) objective_weights = {obj: value/sum_weights for obj,value in objective_weights.items()} else: objective_weights = {obj: 1/len(objectives) for obj in objectives} av_obj = sum(objective_weights[obj] * dict_obj_av[obj] for obj in objectives) # Scaling the vendi data for the scope score calculation. vendi_scaled = self.normalization(score=vendi_score, bounds=bounds["vendi"]) scope_score = self.calculate_scope_score(av_obj,vendi_scaled,scope_method) print(f"Scope score: {scope_score:.3f}") if len(objectives) > 1: print(f"Average objective (scaled on [0,1]-scale): {av_obj:.3f}") for obj in objectives: print(f"Average {obj}: {np.mean(dict_obj_values[obj]):.3f}") print(f"Vendi score: {vendi_score:.3f}") # Add columns and reassign the index. df_umap["status"] = "neutral" df_umap["round"] = 0 obj_plot_name = None if obj_to_display is None: obj_plot_name = objectives[0] obj_plot = dict_obj_values[obj_plot_name] if obj_plot_bounds is None: obj_plot_bounds = (max(obj_plot),min(obj_plot)) else: obj_plot_name = obj_to_display obj_plot = dict_obj_values[obj_plot_name] if obj_plot_bounds is None: obj_plot_bounds = (max(obj_plot),min(obj_plot)) df_umap.index = df_umap.index.astype(str) # Assign the samples to the df_umap dataframe. for round in list(df_data.index): for sample in df_data.loc[round,"eval_samples"]: sample = str(sample.encode().decode('unicode_escape')) df_umap.loc[sample,"status"] = "suggested" df_umap.loc[sample,"round"] = round+1 df_umap.loc[sample,obj_plot_name] = obj_plot.pop(0) # this works because samples and objective values are in the same order if display_cut_samples: for sample in df_data.loc[round,"cut_samples"]: sample = sample.encode().decode('unicode_escape') df_umap.loc[sample,"status"] = "removed" df_umap.loc[sample,"round"] = round+1 # Sort df_umap so that important points will be plotted last and won't be covered by neutral points. df_umap.sort_values("status",inplace=True,ascending=True) # Plot the results plt.figure(figsize=figsize,dpi=dpi, constrained_layout=True) if display_cut_samples: # color by round colormap = self.cont_cmap2 norm = mpl.colors.Normalize(vmin=1, vmax=len(df_data.index)) # Normalize the colorscale df_selected =df_umap[df_umap["status"] == "suggested"] df_pending = df_umap[df_umap['round'] == 0] df_cut = df_umap[df_umap["status"] == "removed"] plt.scatter( df_pending["UMAP1"], df_pending["UMAP2"], s=40*size_scaling, linewidth=0.3*size_scaling,edgecolor="k", color=self.all_colors[6], marker="o", alpha = 0.6, zorder=1) # Plot the cut points plt.scatter( df_cut["UMAP1"], df_cut["UMAP2"], s=100*size_scaling, edgecolor="k", marker = "X", c=df_cut["round"], cmap=colormap, alpha=0.7, linewidth = 0.3*size_scaling, zorder=2) # Plot the selected points plt.scatter(df_selected["UMAP1"],df_selected["UMAP2"],c=df_selected["round"], cmap=colormap,norm=norm,s=250*size_scaling,alpha=1,edgecolor='k', linewidth=3*size_scaling, zorder=3) if show_colorbar: sm = plt.cm.ScalarMappable(cmap=colormap, norm=norm) sm.set_array([]) # Empty array for ScalarMappable cbar = plt.colorbar(sm) max_round = int(df_umap["round"].max()) cbar.set_ticks(range(1, int(max_round)+1, 2)) cbar.set_ticklabels([str(x) for x in range(1, int(max_round)+1, 2)]) cbar.set_label('Round') else: # color by obj values # Separate selected and non-selected points df_umap[obj_plot_name] = df_umap[obj_plot_name].astype(float) df_umap.index = df_umap.index.astype(str) df_selected =df_umap.loc[df_umap["status"] == "suggested"] df_pending =df_umap.loc[df_umap["status"] != "suggested"].copy() # Define colormap and normalization vmin = obj_plot_bounds[1] vmax = obj_plot_bounds[0] norm = plt.Normalize(vmin, vmax) cmap = self.cont_cmap # # Plot non-selected samples if filename_labelled is None: # grey points if no labels are provided plt.scatter(df_pending["UMAP1"], df_pending["UMAP2"], color=self.all_colors[6], s=40*size_scaling, alpha=0.6, linewidth=0.3*size_scaling, edgecolor="k") else: # color by their theoretical performance df_labelled = pd.read_csv(filename_labelled, index_col = 0, header = 0) df_labelled.index = df_labelled.index.astype(str) for idx in df_pending.index: idx = str(idx) df_pending.loc[idx,obj_plot_name] = df_labelled.loc[idx,obj_plot_name] plt.scatter(df_pending["UMAP1"], df_pending["UMAP2"], cmap=cmap,norm=norm,c=df_pending[obj_plot_name], s=40*size_scaling, alpha=0.6, linewidth=0.3*size_scaling, edgecolor="k") # Plot numeric entries scatter_numeric = plt.scatter(df_selected["UMAP1"],df_selected["UMAP2"],c=df_selected[obj_plot_name], cmap=cmap,norm=norm,s=250*size_scaling,alpha=1,edgecolor='k',linewidth=2*size_scaling) # Add colorbar if show_colorbar: cbar = plt.colorbar(scatter_numeric) if cbar_scaling is not None: tick_labels = [f"{int(t * cbar_scaling)}" for t in cbar.get_ticks()] cbar.set_ticklabels(tick_labels) if cbar_title is None: cbar_label = obj_plot_name.capitalize() if obj_plot_name.lower() == "yield": cbar_label = "Yield (%)" cbar.set_label(cbar_label) else: cbar.set_label(cbar_title) if label_round: # label the round of selection if requested texts = [] for i in df_umap[df_umap["status"]== "suggested"].index: texts.append(plt.text(df_umap.loc[i,'UMAP1'], df_umap.loc[i,'UMAP2'], int(df_umap.loc[i,'round']), size='medium', color='black', weight='semibold')) adjust_text(texts,expand_points=(1.3,1.3),force_static=(10,10),arrowprops={"arrowstyle":"-","color":"black"}) if hide_axis: plt.xticks([]) plt.yticks([]) plt.xlabel("UMAP1") plt.ylabel("UMAP2") plt.show() if filename_figure is not None: figure = plt.get_figure() figure.savefig(wdir.joinpath(filename_figure)) def show_scope(self, filename_data, name_results, by_round = True, rounds_to_display = None, common_core = None, give_data = False, suppress_figure = False, directory = '.', molsPerRow = 6, scale_values = 1, label_suffix = "", round_values = None): """ Depict the substrates that were selected for the scope. NOTE: The function is only implemented for singe-objective scenarios. ------------------------------------------------------------------------------------------------ Inputs: filename_data: str name of the benchmarking run to be analyzed name_results: str subfolder in which the results are located by_round: Boolean Select if the selected compounds are shown by round (True --> Default) or all together rounds_to_display: int or None Specify how many rounds of the run you want to display (starting from the first one). The metrics will also only be calculate for the these rounds. E. g.: rounds_to_display=5 --> first 4 rounds will be displayed Default is None --> shows all rounds common_core: str or None SMARTS string for the common core of the molecules to align them Default: None give_data: Boolean return the sample dictionary if True (default: False) suppress_figure: Boolean option to suppress printing of the scope figure (default= False) directory: str current directory. Default: "." molsPerRow: int number of molecules per row if by_round is False scale_values: int Option to scale the result values (e. g. if yields are given on a [0,1]-scale but should be displayed on [0,100]-scale) Default is 1 (no scaling). label_suffix: str label (e. g. unit) to be added to the result values Default is an empty string (no label) round_values: int or None round the objective values to the indicated number of decimal digits if variable is not None (Default). The rounding is applied after scaling. """ # Set directory. wdir = Path(directory) # Read in UMAP and data. df_data = pd.read_csv(wdir.joinpath(name_results+"/"+filename_data), index_col=0,header=0) # Prune the number of rounds if requested if rounds_to_display is not None: df_data = df_data.iloc[:rounds_to_display,:] df_data["eval_samples"] = df_data["eval_samples"].apply(lambda x: [y.strip("'") for y in x[1:-1].split(', ')]) # get the objectives objectives = ast.literal_eval(df_data.columns[0][11:]) df_data[f"obj_values {objectives}"] = df_data[f"obj_values {objectives}"].apply(ast.literal_eval) # Get a dictionary that maps the samples to the obj_values. sample_dict = {} for _, row in df_data.iterrows(): samples = row["eval_samples"] values = row[f"obj_values {objectives}"] if len(objectives) > 1: row_dict = {sample: list(vals) for sample, vals in zip(samples, zip(*values))} sample_dict.update(row_dict) else: sample_dict.update(dict(zip(samples,values))) def _generate_representation(smiles_list): """"Generate aligned 2D representations of molecules from SMILES strings.""" # Convert to molecules mol_list = [Chem.MolFromSmiles(smiles) for smiles in smiles_list] # Generate 2D coordinates for all mols for mol in mol_list: AllChem.Compute2DCoords(mol) if common_core is not None: # Define iodobenzene substructure for alignment core = Chem.MolFromSmarts(common_core) AllChem.Compute2DCoords(core) # Align each molecule to the substructure if it matches for mol in mol_list: if mol.HasSubstructMatch(core): AllChem.GenerateDepictionMatching2DStructure(mol, core) return mol_list if not suppress_figure: # only generate the figure if not suppressed if by_round: for scope_round in df_data.index: smiles_list = df_data.loc[scope_round,"eval_samples"] mol_list = _generate_representation(smiles_list) # Draw the aligned molecules print(f"Molecules selected in round {scope_round+1}:") if round_values is None: legends = [f"{sample_dict[smiles]*scale_values}"+label_suffix for smiles in smiles_list] else: legends = [f"{round(sample_dict[smiles]*scale_values,round_values)}"+label_suffix for smiles in smiles_list] depiction = Draw.MolsToGridImage( mol_list, molsPerRow=len(mol_list), subImgSize=(200, 200), legends = legends ) display(depiction) else: smiles_list = [smiles for round_list in [df_data.loc[round,"eval_samples"] for round in df_data.index] for smiles in round_list] mol_list = _generate_representation(smiles_list) if round_values is None: legends = [f"{sample_dict[smiles]*scale_values}"+label_suffix for smiles in smiles_list] else: if len(objectives) == 1: legends = [f"{round(sample_dict[smiles]*scale_values,round_values)}"+label_suffix for smiles in smiles_list] else: legends = [f"{[str(round(x*scale_values,round_values)) + label_suffix for x in sample_dict[smiles]]}" for smiles in smiles_list] depiction = Draw.MolsToGridImage( mol_list, molsPerRow=molsPerRow, subImgSize=(200, 200), legends = legends ) display(depiction) if give_data: return sample_dict @staticmethod def feature_analysis(filename, filename_labelled, objectives, objective_mode = {"all_obj":"max"}, filename_shap="df_shap.csv", plot_type=["bar"], directory="."): """ Wrapper for the ScopeBO().feature_analysis() function to get feature importance using SHAP from a Benchmark().collect_data() raw data results file. --------------------------------------------------------------------- Inputs: filename: str filename of the reaction space csv file including experimental outcomes default is reaction_space.csv filename_labelled: str filename of the fully labelled reaction space csv file objectives: list list of the objectives. E. g.: [yield,ee] objective_mode: dict Dictionary of objective modes for objectives Provide dict with value "min" in case of a minimization task (e. g. {"cost":"min"}) Code will assume maximization for all non-listed objectives Default is {"all_obj":"max"} filename_shap: str The function generates a csv file as input for the ScopeBO().feature_analysis() function. Parameter defines the name of that file. Default: "df_shap.csv" plot_type: list of str type of SHAP plot to be generated. Options: "bar" - bar plot of mean absolute SHAP values (Default) "beeswarm" - beeswarm plots of the individual SHAP values both options can be requested by using plot_type = ["bar","beeswarm"] providing an empty list supresses plotting directory: str Define working directory. Default is current directory ("."). --------------------------------------------------------------------- Returns the shap.explainer object, mean absolute SHAP values, and the requested plot of SHAP values. """ wdir = Path(directory) # Load the results file df_results = pd.read_csv(wdir.joinpath(filename),index_col=0,header=0) # Process the data df_results["eval_samples"] = df_results["eval_samples"].apply(lambda x: [y.strip("'") for y in x[1:-1].split(', ')]) # Get the selected samples idx_samples = [] for idx in df_results.index: for sample in df_results.loc[idx,"eval_samples"]: idx_samples.append(sample.encode().decode('unicode_escape')) # Load the labelled dataframe and remove the objective data for all samples that have not been selected df_shap = pd.read_csv(wdir.joinpath(filename_labelled),index_col=0,header=0) idx_pending = df_shap.index.difference(idx_samples) for objective in objectives: df_shap.loc[idx_pending, objective] = "PENDING" # Save the dataframe df_shap.to_csv(wdir.joinpath(filename_shap),index=True,header=True) # Call the ScopeBO() function for feature analysis shap_values, mean_abs_shap_values = ScopeBO().feature_analysis(objectives=objectives, objective_mode=objective_mode, filename=filename_shap, plot_type=plot_type, directory=directory) return shap_values,mean_abs_shap_values def objective_distribution(self,name_results, objective_bounds = (0,100), scale_objectives = 1, nr_bins = 10, norm_axis = None, rotation_xticks = 0, directory = ".", print_figure = True): """ Compute and visualize the distribution of objective values across the different random seeds. NOTE: Currently only supports single-objective optimization. Parameters ---------- name_results : str Path to the result folder containing the subfolder ``raw_data`` with CSV files of raw optimization data. objective_bounds : tuple of (float, float) Lower and upper bounds of the objective value range for binning. Default is (0, 100). scale_objectives: int Default = 1. Scale the objective values for the plot. nr_bins : int Number of equally spaced bins to divide the objective range into. Default is 10. norm_axis : int or None Max value for the histogram count axis. If None (Default), the axis max value is determined automatically. rotation_xticks: int Rotation angle for the x-axis tick labels. Default is 0 (no rotation). directory : str Working directory. Default is current directory. print_figure : bool If True, generate a bar plot showing the average counts per bin and error bars corresponding to the standard deviation across runs. Default is True. Returns ------- df_counts : pandas.DataFrame A dataframe where each row corresponds to one run and each column contains the counts of objective values falling into each bin. """ wdir = Path(directory) raw_path = wdir / name_results / "raw_data" # find the objectives objectives = Benchmark.find_objectives(name_results,directory) # define the bins bins = np.linspace(objective_bounds[0],objective_bounds[1],nr_bins+1) * scale_objectives # list to store the count results counts = [] # go through all the raw files in the original folder for file in os.listdir(raw_path): # read in the raw data file df_raw = pd.read_csv(raw_path / file, index_col = 0, header = 0) # get the objective values of each entry df_raw[f"obj_values {objectives}"] = df_raw[f"obj_values {objectives}"].apply(ast.literal_eval) obj_values = [value * scale_objectives for round_list in [df_raw.loc[round,f"obj_values {objectives}"] for round in df_raw.index] for value in round_list] # get the counts for the bins counts.append(np.histogram(obj_values,bins=bins)[0]) # convert to df df_counts = pd.DataFrame(counts).fillna(0) bin_centers = (bins[:-1] + bins[1:]) / 2 df_counts.columns = bin_centers # print the average distribution and its standard deviation if requested if print_figure: mean_counts = df_counts.mean() std_counts = df_counts.std(ddof=1) # using Bessel's correction plt.figure(figsize=(8,6)) plt.bar(bin_centers, mean_counts, width=(bins[1]-bins[0]), yerr=std_counts, capsize=5, alpha=1, color=self.all_colors[1], edgecolor='k',zorder =2) plt.xlabel(f'{objectives[0].capitalize()} value') plt.ylabel('Average Count') if norm_axis is not None: plt.ylim(0, norm_axis) plt.title('Average Objective Distribution with Standard Deviation') plt.xticks(bins, rotation = rotation_xticks) plt.grid(axis='y',zorder=1) plt.show() return df_counts @staticmethod def normalization(score,bounds): """ Helper function: Function to normalize Vendi scores and average objectives. Input: score: float or int result to be processed bounds: tuple upper and lower bounds (in that order) of the scores for the normalization """ return (score-bounds[1])/(bounds[0]-bounds[1]) @staticmethod def standardization(score,distr_metrics): """ Helper function: Standardizes a provided score. distr_metric: tuple (mean, stdev) --> both type float """ return (score-distr_metrics[0])/distr_metrics[1] @staticmethod def calculate_scope_score(obj_score, vendi_score, method = "product"): """ Helper function: Calculate the scope score using different calculation methods. obj_score, vendi_score: float of the respective scaled score. method: string (Options "average", "product" (default), "geometric_mean") """ scope_score = None if "av" in method.lower(): scope_score = (obj_score + vendi_score) / 2 elif "prod" in method.lower(): scope_score = obj_score * vendi_score elif "geo" in method.lower(): prod = obj_score * vendi_score # Taking the root is only possible for positive numbers. # Define the prod as 0 in case it is negative # so that the scope score will be 0 as well if isinstance(prod, pd.DataFrame): prod = prod.where( (prod > 0) | prod.isna(), 0) elif prod < 0: prod = 0 scope_score = np.sqrt(prod) return scope_score @staticmethod def find_objectives(folder_name,directory): """ Helper function to find the names of the objectives in the raw results. ------------------- Input: folder_name: path of the folder to be analzyed directory: working directory ------------------- Returns: list of the objectives that were used in this run """ wdir = Path(directory) # Get a list of the raw files of the run raw_path = wdir.joinpath(folder_name+"/raw_data/") raw_files = os.listdir(raw_path) # Load one of the files df_results = pd.read_csv(wdir.joinpath(raw_path,raw_files[0]),index_col=0,header=0) # Get the list of objectives from the column name and return it return ast.literal_eval(df_results.columns[0][11:]) @staticmethod def get_metric_overview(bounds, budget, name_results, type_results, scope_method = "product", objective_mode = {"all_obj":"max"}, objective_weights = None, directory = ".", specified_batch_size = None): """ Compute a metric summary across seeds and hyperparameter settings for use in different plotting functions. This function aggregates raw result files produced by optimization runs, groups them by hyperparameter combinations, extracts objective values and Vendi scores, converts round-level metrics into cumulative metrics, and computes mean, standard deviation, min, and max across seeds. It also constructs per-seed raw DataFrames and aligns results to the evaluation budget. Parameters ---------- bounds: dict dictionary of bounds for the individual metrics (vendi, all objectives) the dict keys are the metric, the values are a tuple of max and min values budget : int experimental budget name_results: str name of the folder in which the results will be saved type_results: str Requested type of result. Options: "vendi": Vendi score "objective": average objective values "scope": scope score You can also provide the name of a specific objective for that run and then it will only analyze that one. If multiple objectives are present and "objective" is requested, a combined objective score is computed. scope_method: str method to calculate the scope score ("average","product" (Default),"geometric_mean" ) objective_mode: dict Dictionary of objective modes for objectives Provide dict with value "min" in case of a minimization task (e. g. {"cost":"min"}) Code will assume maximization for all non-listed objectives Default is {"all_obj":"max"} --> all objectives are maximized objective_weights: list or None list of float weights for the scalarization of the objectives only relevant for multi-objective greedy runs, not other acquisition functions Default: None (objectives will be averaged) directory: str working directory (default is current directory) specified_batch_size : int or None, optional If provided, each round is assumed to use this fixed batch size. If None, batch sizes are inferred from the hyperparameter setting encoded in the filename. Returns ------- dfs_scaled : dict of pandas.DataFrame Summary dataframes for the requested metric, aggregated across seeds: - "means" (mean values) - "stdev" (standard deviation with Bessel correction) - "max" (max values) - "min" (min values) Each DataFrame has: - rows indexed by experiment number (1..budget) - columns indexed by hyperparameter combinations dict_dfs_raw_data : dict of dict of pandas.DataFrame Nested dictionary: - Outer key: hyperparameter combination - Inner key: seed index - Inner value: raw per-seed DataFrame containing cumulative objective values, Vendi scores, combined objectives, and scope scores (where applicable). NOTE: Files must follow the naming convention "___s.csv" """ # get all the raw files and sort them by hyperparameter combination wdir = Path(directory) raw_path = wdir.joinpath(name_results+"/raw_data/") setting_dict = {} for file in os.listdir(raw_path): combi = "_".join(file.split("_")[1:3]) if "low_variance" in file: # special case for low_variance acq fct that has an underscore in its name combi = "_".join(file.split("_")[2:4]) if combi not in setting_dict.keys(): setting_dict[combi] = [file] else: setting_dict[combi].append(file) # get the objective names objectives = Benchmark.find_objectives(name_results,directory) # go through all the different hyperparameter settings batch_sizes_list = [] dict_unscaled_mean = {} dict_unscaled_stdev = {} dict_unscaled_max = {} dict_unscaled_min = {} dict_dfs_raw_data = {} for combi in setting_dict.keys(): # list to store the results of all seeds for one setting seeded_list = [] seeds = len(setting_dict[combi]) # go through the different files # (sort them first so that they are saved in the correct order in the returned raw data) # Regex to extract seed number seed_pattern = re.compile(r's(\d+)\.csv$') # Sort the files by their random seed sorted_files = sorted(setting_dict[combi], key=lambda x: int(seed_pattern.search(x).group(1))) # loop through the individual seeds for seed_file in sorted_files: # get lists of the values in each round for each objective and the vendi score (for one seed) dict_raw_data = {} batch_sizes = None # read in the raw data df_raw = pd.read_csv(f"{raw_path}/{seed_file}",index_col=0,header=0) df_raw[f"obj_values {objectives}"] = df_raw[f"obj_values {objectives}"].apply(lambda x: ast.literal_eval(x)) #get the vendi data dict_raw_data["vendi"] = df_raw["Vendi_score"].to_list() # get the objective data for i,obj in enumerate(objectives): if len(objectives) > 1: # structure: [[],[]] dict_raw_data[obj] = df_raw[f"obj_values {objectives}"].apply(lambda x: np.mean(x[i])).to_list() else: # structure: [] dict_raw_data[obj] = df_raw[f"obj_values {objectives}"].apply(lambda x: np.mean(x)).to_list() # figure out the batch sizes if not specified if specified_batch_size is None: batch = combi.split("_")[0][1:] if batch.isdigit(): # case using a fixed batch size batch = int(batch) batch_sizes = [int(batch)]*len(dict_raw_data[obj]) difference = budget - sum(batch_sizes) batch_sizes[-1] += difference # reduce the last batch if it was smaller due to budget constraints else: # case using different batch sizes in each round batch_sizes = [int(el) for el in batch.split("-")] # list with the batch sizes for each round else: batch_sizes = [specified_batch_size] * len(dict_raw_data[obj]) # the obj data is the average value obtained in each round, # but we need the culmulative results until this round total_obj = [i*j for i,j in zip(batch_sizes,dict_raw_data[obj])] # batch size * average obj for each round processed_obj = [] for round in range(len(dict_raw_data[obj])): processed_result = sum(total_obj[:(round+1)]) / sum(batch_sizes[:(round+1)]) processed_obj.append(processed_result) # reassign the obj data (now with the cumulative averages) dict_raw_data[obj] = processed_obj # save the results for this seed seeded_list.append(dict_raw_data) batch_sizes_list.append(batch_sizes) # process the requested data processed_mean = [] processed_stdev = [] processed_max = [] processed_min = [] # generated a copy of the seeded_list that will not be further processed and can be returned # (can loop through a range object for the keys because the result files have been analyzed in sorted order) dfs_raw_data = { i: pd.DataFrame(seeded_list[i], index = range(len(seeded_list[i]["vendi"])), columns=seeded_list[i].keys()) for i in range(len(seeded_list)) } dict_dfs_raw_data[combi] = dfs_raw_data # case when a specific objective (or the only one) or the vendi score is requested if type_results.lower() not in ["scope","objective"] or (type_results.lower() == "objective" and len(objectives) == 1): if type_results.lower() == "objective": type_results = objectives[0] # reassign with the name of the only objective stacked = np.stack([d[type_results.lower()] for d in seeded_list], axis=0) processed_mean = np.mean(stacked, axis=0).tolist() if seeds > 1: processed_stdev = np.std(stacked, axis=0, ddof=1).tolist() # using Bessel's correction else: processed_stdev = np.std(stacked, axis=0).tolist() # no correction if single seed processed_max = np.max(stacked, axis=0).tolist() processed_min = np.min(stacked, axis=0).tolist() # combined objectives or scope score is requested else: if type_results.lower() == "objective": type_results = "comb_obj" # check for minimization objectives min_obj = [obj for obj, value in objective_mode.items() if value == "min"] # preprocess the objective weights if (objective_weights is not None): # ensure that the weights sum up to 1 sum_weights = sum(objective_weights.values()) objective_weights = {obj: value/sum_weights for obj,value in objective_weights.items()} else: objective_weights = {obj: 1/len(objectives) for obj in objectives} # process the data for the individual seeds for seed in range(len(seeded_list)): # normalize the data for metric in objectives + ["vendi"]: seeded_list[seed][metric] = [Benchmark.normalization(score=x,bounds=bounds[metric]) for x in seeded_list[seed][metric]] # invert minimization tasks if min_obj: for obj in min_obj: seeded_list[seed][obj] = [1 - x for x in seeded_list[seed][obj]] # combine the objectives seeded_list[seed]["comb_obj"] = sum(objective_weights[obj] * np.array(seeded_list[seed][obj]) for obj in objectives).tolist() # calculate the scope score if type_results.lower() == "scope": seeded_list[seed]["scope"] = [Benchmark.calculate_scope_score(comb_obj,vendi,scope_method) for comb_obj,vendi in zip(seeded_list[seed]["comb_obj"],seeded_list[seed]["vendi"])] # also record the scope score in dfs_raw_data dfs_raw_data[seed]["scope"] = seeded_list[seed]["scope"] stacked = np.stack([d[type_results.lower()] for d in seeded_list], axis=0) processed_mean = np.mean(stacked, axis=0).tolist() if seeds > 1: processed_stdev = np.std(stacked, axis=0, ddof=1).tolist() # using Bessel's correction else: processed_stdev = np.std(stacked, axis=0).tolist() # no correction if single seed processed_max = np.max(stacked, axis=0).tolist() processed_min = np.min(stacked, axis=0).tolist() dict_unscaled_mean[combi] = processed_mean dict_unscaled_stdev[combi] = processed_stdev dict_unscaled_max[combi] = processed_max dict_unscaled_min[combi] = processed_min # ensure all results lists have the same length by appending np.NaN max_len = max(len(v) for v in dict_unscaled_mean.values()) dict_unscaled_mean = {k: v + [np.nan] * (max_len - len(v)) for k, v in dict_unscaled_mean.items()} dict_unscaled_stdev = {k: v + [np.nan] * (max_len - len(v)) for k, v in dict_unscaled_stdev.items()} dict_unscaled_max = {k: v + [np.nan] * (max_len - len(v)) for k, v in dict_unscaled_max.items()} dict_unscaled_min = {k: v + [np.nan] * (max_len - len(v)) for k, v in dict_unscaled_min.items()} # convert to dfs dfs_unscaled = {} dfs_unscaled["means"] = pd.DataFrame.from_dict(dict_unscaled_mean) dfs_unscaled["stdev"] = pd.DataFrame.from_dict(dict_unscaled_stdev) dfs_unscaled["max"] = pd.DataFrame.from_dict(dict_unscaled_max) dfs_unscaled["min"] = pd.DataFrame.from_dict(dict_unscaled_min) # The data is currently shown per batch (which can be different for the different runs). Still needs to be "scaled" to the number of experiments. dfs_scaled = {} for metric,df in dfs_unscaled.items(): dfs_scaled[metric] = pd.DataFrame(np.nan,[x+1 for x in range(budget)],df.columns) # create empty dataframe with the right shape for column_nr in range(len(df.columns)): batch_sizes = batch_sizes_list[column_nr] # batch sizes for each round nr_experiments = [sum(batch_sizes[:round+1]) for round in range(len(batch_sizes))] # total number of experiments including for each round for entry in range(len(df.index)): if pd.notna(df.iloc[entry,column_nr]): # check that the value is actually numeric and not nan dfs_scaled[metric].iloc[nr_experiments[entry]-1, column_nr] = df.iloc[entry,column_nr] # -1 because iloc is 0-indexed # clean up for key in dfs_scaled.keys(): dfs_scaled[key].dropna(how="all",inplace=True) dfs_scaled[key] = dfs_scaled[key][sorted(dfs_scaled[key].columns)] return dfs_scaled, dict_dfs_raw_data