from pathlib import Path from IPython.display import display from matplotlib.colors import LinearSegmentedColormap import matplotlib.pyplot as plt import numpy as np import pandas as pd from rdkit import Chem from rdkit.Chem import Draw from sklearn.preprocessing import scale from umap import UMAP # 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 }) # Define a colormap for plotting doyle_colors = ["#CE4C6F", "#1561C2", "#188F9D","#C4ADA2","#515798", "#CB7D85", "#A9A9A9"] colors = [doyle_colors[1],"#FFFFFFD1",doyle_colors[0]] cont_cmap = LinearSegmentedColormap.from_list("Doyle_cont", colors) def UMAP_suggestions(filename, obj_to_show = None, obj_bounds = None, objectives = None, display_cut_samples = True, display_suggestions = True, display_alternatives = True, figsize = (10,8), dpi = 600, draw_structures = True, show_figure = True, cbar_title = None, return_dfs = False, directory = "."): """ Creates a UMAP for the search space, highlighting the picked samples. ---------- filename : str or Path Path to the CSV file containing the reaction search space. obj_to_show : str or None Name of the objective that is visualized. If None (Default), the first listed objective is used. obj_bounds : tuple or list, optional (max, min) values to manually set the colorbar range for `obj_to_show`. If None, the min/max are taken from the observed evaluated samples. objectives : list-like, optional List of column names containing objective values (including "PENDING"). If None, they are automatically inferred from columns containing "PENDING" strings. display_cut_samples : bool, default=True Whether cut samples (priority = -1) are shown as X markers. If False, they are plotted as unseen points. display_suggestions: bool, default=True Whether suggested samples (priority=1) are shown as squares. If Ffalse, they are plotted as unseen points. display_alternatives: bool, default=True Whether alternatively suggested samples (0 0) & (df_unseen["priority"] < 1) df_alt = df_unseen[mask].copy() # alternative suggestions # draw the structures if requested if draw_structures: # Extract the suggested molecules and draw them. scope_substrates = df_seen.index.to_list() scope_substrates = [str(entry.encode().decode('unicode_escape')) for entry in scope_substrates] scope_labels = df_seen[obj_name].to_list() print("Structures of the scope substrates:") try: mol_list = [Chem.MolFromSmiles(smiles) for smiles in scope_substrates] # Draw the aligned molecules depiction = Draw.MolsToGridImage( mol_list, molsPerRow=6, subImgSize=(200, 200), legends=[str(result_val) for result_val in scope_labels] ) display(depiction) except: print(f"Could not draw the molecules in {scope_substrates}.") print(f"Please label your molecules with SMILES strings to draw the results of the scope.") print("Alternatively, set draw_structures = False in the function call to avoid structure drawing.") # print the UMAP if requested if show_figure: print("UMAP projection of the reaction space:") if display_cut_samples: print("(Evaluated samples are shown as colored circles. Pruned samples are marked with X.)") else: print("(Evaluated samples are shown as colored circles.)") if display_suggestions and display_alternatives: print("(Suggested samples are marked with squares and alternative suggestions with diamonds.)") elif display_suggestions and not display_alternatives: print("(Suggested samples are marked with squares.)") elif not display_suggestions and display_alternatives: print("(Alternative suggestions are marked with diamonds.)") plt.figure(figsize=figsize, dpi = dpi, constrained_layout = True) colormap = cont_cmap if obj_bounds is None: vmin = df_seen[obj_name].min() vmax = df_seen[obj_name].max() else: vmin = obj_bounds[1] vmax = obj_bounds[0] norm = plt.Normalize(vmin,vmax) # plot the neutral points plt.scatter( df_neutral["UMAP1"], df_neutral["UMAP2"], s=40, linewidth=0.3, edgecolor="k", color=doyle_colors[6], marker="o", alpha = 0.8, label = "neutral", zorder=1) # check if cut samples should be highlighted if display_cut_samples: # plot the cut samples plt.scatter( df_cut["UMAP1"], df_cut["UMAP2"], s=100, edgecolor="k", marker = "X", color=doyle_colors[4], alpha=0.6, label = "cut", linewidth = 0.3, zorder=2) else: # plot the cut samples the same way as the neutral samples plt.scatter( df_cut["UMAP1"], df_cut["UMAP2"], s=40, edgecolor="k", marker = "o", color=doyle_colors[6], alpha=0.8, linewidth = 0.3, zorder=2) # check if suggested samples should be highlighted if display_suggestions: # plot the suggested samples plt.scatter( df_sugg["UMAP1"], df_sugg["UMAP2"], s=100, edgecolor="k", marker = "s", color=doyle_colors[2], alpha=0.8, label = "suggested", linewidth = 1.2, zorder=4) else: # plot the sugggested samples the same way as the neutral samples plt.scatter( df_sugg["UMAP1"], df_sugg["UMAP2"], s=40, edgecolor="k", marker = "o", color=doyle_colors[6], alpha=0.8, linewidth = 0.3, zorder=1) # check if alternative sugegstions should be highlighted if display_alternatives: # plot the alternative samples plt.scatter( df_alt["UMAP1"], df_alt["UMAP2"], s=100*df_alt["priority"], edgecolor="k", marker = "D", color=doyle_colors[2], alpha=0.8, label = "alt. suggestion", linewidth = 1.2, zorder=3) else: # plot the alt. sugg. samples the same way as the neutral samples plt.scatter( df_alt["UMAP1"], df_alt["UMAP2"], s=40, edgecolor="k", marker = "o", color=doyle_colors[6], alpha=0.8, linewidth = 0.3, zorder=1) # plot the selected samples scatter_numeric = plt.scatter(df_seen["UMAP1"], df_seen["UMAP2"], c=df_seen[obj_name], cmap=cont_cmap, norm=norm,s=250, alpha=1, edgecolor='k', label = "measured", linewidth=2, zorder = 5) cbar = plt.colorbar(scatter_numeric) if cbar_title is None: cbar_label = obj_name.capitalize() cbar.set_label(cbar_label) else: cbar.set_label(cbar_title) plt.legend() plt.xlabel("UMAP1") plt.ylabel("UMAP2") plt.show() if return_dfs: return {"seen": df_seen, "neutral": df_neutral, "cut": df_cut} def UMAP_predictions(filename, df_pred, obj_to_show = None, obj_bounds = None, objectives = None, pred_for_cut = False, figsize = (10,8), dpi = 600, cbar_title = None, directory = "."): """ Creates a UMAP for the search space, highlighting the picked samples. ---------- filename : str or Path Path to the CSV file containing the reaction search space. df_pred: pd.DataFrame dataframe with the predictions from either ScopeBO.expected_improvement() or ScopeBO.predict_performance() obj_to_show : str or None Name of the objective that is visualized. If None (Default), the first listed objective is used. obj_bounds : tuple or list, optional (max, min) values to manually set the colorbar range for `obj_to_show`. If None, the min/max are taken from the observed evaluated samples. objectives : list-like, optional List of column names containing objective values (including "PENDING"). If None, they are automatically inferred from columns containing "PENDING" strings. pred_for_cut: Boolean Default = False Show predictions also for cut samples if True figsize : tuple, default=(10, 8) Size of the generated UMAP figure in inches. dpi : int, default=600 Resolution of the output figure. cbar_title : str, optional Custom title for the colorbar. If None, uses the objective name. directory : str or Path, default="." Directory containing the CSV file. """ # generate a 2D and also read in the scope information df_umap, df_scope, obj_name = _UMAP_creation(filename = filename, obj_to_show = obj_to_show, objectives = objectives, directory = directory) # separate the observed, cut, and predicted samples df_seen = df_umap.loc[df_umap.index.isin(df_scope[df_scope[obj_name] != "PENDING"].index.to_list())].copy() df_seen[obj_name] = df_seen[obj_name].astype(float) prio_val = -1 # priority value corresponding to cut values if pred_for_cut: # unrealistic priority value in case predictions for cut samples are to be shown # will result in empty df for cut samples prio_val = 42 df_cut = df_umap[df_umap.index.isin(df_scope[df_scope["priority"] == prio_val].index.to_list())].copy() df_unseen = df_umap.loc[(~df_umap.index.isin(df_seen.index.to_list())) & (~df_umap.index.isin(df_cut.index.to_list()))].copy() # determine the source of the predictions (predict_performance() or expected_improvement()) # (using characteristic naming of the columns) pred_type = None if f"{obj_name}_pred" in df_pred.columns.values: pred_type = "mlr" # from predict_performance() elif f"Prediction_{obj_name}" in df_pred.columns.values: pred_type = "ei" # from expected_improvement() # assign the predicted values for idx in df_unseen.index: if pred_type == "mlr": df_unseen.loc[idx,obj_name] = df_pred.loc[idx,f"{obj_name}_pred"] elif pred_type == "ei": df_unseen.loc[idx,obj_name] = df_pred.loc[idx,f"Prediction_{obj_name}"] # plot the figure plt.figure(figsize=figsize, dpi = dpi, constrained_layout = True) colormap = cont_cmap if obj_bounds is None: vmin = df_seen[obj_name].min() vmax = df_seen[obj_name].max() else: vmin = obj_bounds[1] vmax = obj_bounds[0] norm = plt.Normalize(vmin,vmax) # set the size for predicted values based on their standard deviation if available # smaller points have a higher standad deviation (i. e. more uncertain predictions) size_vals = [40] * len(df_unseen) if pred_type == "ei": size_min, size_max = 50, 200 std_vals = [df_pred.loc[idx,f"Std. dev. of pred._{obj_name}"] for idx in df_unseen.index] std_min = np.min(std_vals) std_max = np.max(std_vals) if std_max - std_min == 0: # no standard deviation range, set a default size size_vals = [(size_min+size_max)/2] * len(df_unseen) else: size_vals = [size_min + (std_max - std_val) * (size_max - size_min) / (std_max - std_min) for std_val in std_vals] if not pred_for_cut: # plot the cut points plt.scatter(df_cut["UMAP1"], df_cut["UMAP2"], s=100, edgecolor="k", marker = "X", color=doyle_colors[4], alpha=0.6, linewidth = 0.3, zorder=0, label = "cut") # plot the predicted points plt.scatter(df_unseen["UMAP1"], df_unseen["UMAP2"], c=df_unseen[obj_name], cmap=cont_cmap, norm=norm, s= size_vals, alpha=1, edgecolor='k', linewidth=1, marker = "o", label = "predicted",zorder = 1) # plot the observed samples scatter_numeric = plt.scatter(df_seen["UMAP1"], df_seen["UMAP2"], c=df_seen[obj_name], cmap=cont_cmap, norm=norm,s=250, alpha=1, edgecolor='k', linewidth=2, label = "measured", marker = "s", zorder = 2) cbar = plt.colorbar(scatter_numeric) if cbar_title is None: cbar_label = obj_name.capitalize() cbar.set_label(cbar_label) else: cbar.set_label(cbar_title) plt.legend() plt.xlabel("UMAP1") plt.ylabel("UMAP2") plt.show() def _UMAP_creation(filename, obj_to_show = None, objectives = None, directory = "."): """ Creates a 2D UMAP for plotting. Returns a df with the compound names as index and the coordinates ("UMAP1", "UMAP2") as columns. Returns the df of the input file ("filename") after sorting the index. Returns the name of the objective that will be plotted. See function UMAP_view() for input variable information (above). """ # Set directory. wdir = Path(directory) # read the results file df_scope = pd.read_csv(wdir / filename, index_col=0, header=0) df_scope.sort_index(inplace=True) if "priority" in df_scope.columns.to_list(): df_scope["priority"] = df_scope["priority"].astype(float) # identify the objectives (containing PENDING entries) if none are given if objectives is None: objectives = df_scope.columns[df_scope.eq("PENDING").any()].to_list() if (objectives == []) and (obj_to_show is not None): print("hello") objectives = [obj_to_show] # show the first objective in the UMAP if none has been specified in the function input if obj_to_show is None: obj_to_show = objectives[0] # scale the featurization data df_scaled = df_scope.copy(deep=True) if "priority" in df_scope.columns.to_list(): df_scaled.drop(columns=objectives + ["priority"], inplace=True) else: df_scaled.drop(columns=objectives, inplace=True) df_scaled = pd.DataFrame(scale(df_scaled), df_scaled.index, df_scaled.columns) # create a UMAP fit = UMAP(n_neighbors=40, min_dist=0.7, n_components=2, metric="euclidean", random_state=42) df_umap = pd.DataFrame(fit.fit_transform(df_scaled), index = df_scaled.index, columns = ["UMAP1","UMAP2"]) df_umap.index = df_umap.index.astype(str) # add the result labels df_umap[obj_to_show] = df_scope[obj_to_show] return df_umap, df_scope, obj_to_show