synkit 0.0.1__py3-none-any.whl

synkit/Vis/chemical_graph_visualizer.py

@@ -0,0 +1,378 @@
+import random
+import networkx as nx
+import matplotlib.pyplot as plt
+import seaborn as sns
+from typing import Optional, Dict
+import logging
+
+color_scheme = {
+    "H": "#FFFFFF",  # White
+    "C": "#909090",  # Gray
+    "N": "#3050F8",  # Blue
+    "O": "#FF0D0D",  # Red
+    "F": "#90E050",  # Green
+    "Cl": "#1FF01F",  # Green
+    "Br": "#A62929",  # Dark Red/Brown
+    "I": "#940094",  # Purple
+    "P": "#FF8000",  # Orange
+    "S": "#FFFF30",  # Yellow
+    "Na": "#E0E0E0",  # Light Gray
+    "K": "#8F40D4",  # Light Purple
+    "Ca": "#3DFF00",  # Light Green
+    "Mg": "#8AFF00",  # Light Green
+    "Fe": "#B7410E",  # Rust Red
+    "Zn": "#7D80B0",  # Light Blue
+    "Cu": "#C88033",  # Copper Red/Orange
+    "Ag": "#C0C0C0",  # Light Gray
+    "Au": "#FFD123",  # Gold Yellow
+    "Hg": "#B8B8D0",  # Silver Gray
+    "Pb": "#575961",  # Dark Gray
+    "Al": "#BFA6A6",  # Light Gray
+    "Si": "#F0C8A0",  # Light Brown
+    "B": "#FFA1A1",  # Pink
+    "As": "#BD80E3",  # Light Gray
+    "Sb": "#9E63B5",  # Dark Gray
+    "Se": "#FFA100",  # Light Pink
+    "Te": "#D47A00",  # Gray
+    "Cd": "#FFD98F",  # Light Blue/Gray
+    "Ti": "#BFC2C7",  # Light Gray
+    "V": "#A6A6AB",  # Light Gray/Blue
+    "Cr": "#8A99C7",  # Steel Gray
+    "Mn": "#9C7AC7",  # Gray
+    "Co": "#FF7A00",  # Light Pink
+    "Ni": "#4DFF4D",  # Light Green
+}
+
+
+class ChemicalGraphVisualizer:
+    def __init__(
+        self,
+        seed: Optional[int] = None,
+        element_colors: Optional[Dict[str, str]] = color_scheme,
+    ):
+        """
+        Initialize the visualizer with optional seed and color scheme.
+
+        Parameters:
+        seed (int, optional): Seed for random number generator for reproducibility.
+        element_colors (dict, optional): Dictionary mapping elements to their color codes.
+        """
+        # Define a popular color scheme in chemistry if not provided
+        if element_colors is None:
+            self.element_colors = {
+                "H": "#FFFFFF",  # White
+                "C": "#909090",  # Gray
+                "N": "#3050F8",  # Blue
+                "O": "#FF0D0D",  # Red
+                "F": "#90E050",  # Green
+                "Cl": "#1FF01F",  # Green
+                # Additional elements can be added here
+            }
+        else:
+            self.element_colors = element_colors
+        self.seed = seed
+
+    def graph_vis(
+        self,
+        G: nx.Graph,
+        node_size: int = 100,
+        visualize_edge_weight: bool = False,
+        edge_font_size: int = 10,
+        show_node_labels: bool = False,
+        node_label_font_size: int = 12,
+        ax: Optional[plt.Axes] = None,
+    ) -> None:
+        """
+        Visualize a NetworkX graph with standard representation.
+
+        Parameters:
+        G (nx.Graph): The graph to visualize.
+        node_size (int): The size of the nodes.
+        visualize_edge_weight (bool): Whether to display edge weights.
+        edge_font_size (int): Font size for edge labels.
+        show_node_labels (bool): Whether to show labels on the nodes.
+        node_label_font_size (int): Font size for node labels.
+        """
+        # Set random seed for reproducibility
+        if self.seed is not None:
+            random.seed(self.seed)
+
+        # Get colors for each node
+        node_colors = [
+            self.element_colors.get(G.nodes[node]["element"], "#000000")
+            for node in G.nodes()
+        ]
+
+        # Draw the graph
+        pos = nx.spring_layout(G, seed=self.seed)  # Use spring layout
+
+        if ax is None:
+            ax = plt.gca()  # Get current axes if not provided
+
+        if show_node_labels:
+            node_labels = {node: G.nodes[node]["element"] for node in G.nodes()}
+            nx.draw(
+                G,
+                pos,
+                ax=ax,
+                with_labels=True,
+                labels=node_labels,
+                node_color=node_colors,
+                node_size=node_size,
+                font_size=node_label_font_size,
+                # font_weight="semi-bold",
+            )
+        else:
+            nx.draw(
+                G,
+                pos,
+                ax=ax,
+                with_labels=False,
+                node_color=node_colors,
+                node_size=node_size,
+                # font_weight="bold",
+            )
+
+        # Get edge labels if needed
+        if visualize_edge_weight:
+            edge_labels = {(u, v): G.edges[u, v]["order"] for u, v in G.edges()}
+            nx.draw_networkx_edge_labels(
+                G, pos, ax=ax, edge_labels=edge_labels, font_size=edge_font_size
+            )
+
+    def its_vis(
+        self,
+        G: nx.Graph,
+        node_size: int = 100,
+        show_node_labels: bool = False,
+        node_label_font_size: int = 12,
+        ax: Optional[plt.Axes] = None,
+    ) -> None:
+        """
+        Visualize a NetworkX graph with edge colors indicating bond changes.
+
+        Parameters:
+        G (nx.Graph): The graph to visualize.
+        node_size (int): The size of the nodes.
+        show_node_labels (bool): Whether to show labels on the nodes.
+        node_label_font_size (int): Font size for node labels.
+        """
+        # Set random seed for reproducibility
+        if self.seed is not None:
+            random.seed(self.seed)
+
+        # Draw the graph
+        pos = nx.spring_layout(G, seed=self.seed)  # Use spring layout
+        # Get colors for each node
+        node_colors = [
+            self.element_colors.get(G.nodes[node]["element"], "#000000")
+            for node in G.nodes()
+        ]
+
+        # Determine edge colors based on 'order'
+        edge_colors = []
+        for u, v, data in G.edges(data=True):
+            order = data.get("standard_order", 0)
+            # order = tuple(0 if isinstance(x, str) else float(x) for x in order)
+            if order == 0:
+                edge_colors.append("black")  # Normal bond
+            elif order < 0:
+                edge_colors.append("blue")  # Increasing bond
+            else:
+                edge_colors.append("red")  # Breaking bond
+
+        if ax is None:
+            ax = plt.gca()  # Get current axes if not provided
+
+        if show_node_labels:
+            node_labels = {node: G.nodes[node]["element"] for node in G.nodes()}
+            nx.draw(
+                G,
+                pos,
+                ax=ax,
+                with_labels=True,
+                labels=node_labels,
+                node_color=node_colors,
+                node_size=node_size,
+                font_size=node_label_font_size,
+                # font_weight="bold",
+                edge_color=edge_colors,
+            )
+        else:
+            nx.draw(
+                G,
+                pos,
+                ax=ax,
+                with_labels=False,
+                node_color=node_colors,
+                node_size=node_size,
+                font_weight="bold",
+                edge_color=edge_colors,
+            )
+
+    def vis_three_graph(
+        self,
+        graph_tuple,
+        figsize=(15, 5),
+        left_graph_title="Reactants",
+        k_graph_title="ITS Graph",
+        right_graph_title="Products",
+        show_node_labels=True,
+        title_fontsize=24,
+        title_weight="bold",
+        save_path=None,
+        display_inline=False,
+        log=False,
+    ):
+        """
+        Visualize reactants, ITS graph, and products in one figure.
+
+        Parameters:
+            graph_tuple (tuple): Tuple of NetworkX graphs (reactants, ITS graph, products).
+            figsize (tuple): Figure size in inches (width, height).
+            left_graph_title (str): Title for the left subplot.
+            k_graph_title (str): Title for the middle subplot.
+            right_graph_title (str): Title for the right subplot.
+            show_node_labels (bool): If True, show node labels on the graphs.
+            title_fontsize (int): Font size for subplot titles.
+            title_weight (str): Font weight for subplot titles.
+            save_path (str, optional): Path to save the figure to file.
+            display_inline (bool): If True, display the figure inline in the notebook.
+            log (bool): If True, enable logging of function progress.
+        """
+        if log:
+            logging.basicConfig(level=logging.INFO)
+
+        try:
+            # Unpack the tuple
+            reactants_graph, products_graph, its_graph = graph_tuple
+
+            # Create a figure with subplots
+            fig, axs = plt.subplots(1, 3, figsize=figsize)
+
+            # Visualize each graph on its respective subplot
+            self.graph_vis(
+                reactants_graph, ax=axs[0], show_node_labels=show_node_labels
+            )
+            self.its_vis(its_graph, ax=axs[1], show_node_labels=show_node_labels)
+            self.graph_vis(products_graph, ax=axs[2], show_node_labels=show_node_labels)
+
+            # Set titles for subplots
+            axs[0].set_title(
+                left_graph_title, fontsize=title_fontsize, weight=title_weight
+            )
+            axs[1].set_title(
+                k_graph_title, fontsize=title_fontsize, weight=title_weight
+            )
+            axs[2].set_title(
+                right_graph_title, fontsize=title_fontsize, weight=title_weight
+            )
+
+            plt.tight_layout()
+
+            if save_path is not None:
+                plt.savefig(save_path, dpi=600)
+                if log:
+                    logging.info(f"Figure saved to {save_path}")
+
+            if display_inline:
+                plt.show()
+            else:
+                plt.close(fig)
+
+            return fig
+        except Exception as e:
+            if log:
+                logging.error("Failed to visualize graphs: ", exc_info=True)
+            raise RuntimeError("Error in graph visualization: ") from e
+
+    def visualize_all(
+        self,
+        graph_tuple_row1,
+        graph_tuple_row2,
+        figsize=(15, 10),
+        titles_row1=("A. Reactant Graph", "B. ITS Graph", "C Products"),
+        titles_row2=("D. L Graph", "E. K Graph", "D. R Graph"),
+        show_node_labels=True,
+        show_grid=True,
+        grid_style="--",
+        title_fontsize=24,
+        title_weight="bold",
+        save_path=None,
+        display_inline=False,
+        log=False,
+    ):
+        """
+        Visualize two rows of graphs, each with three graphs, optionally displaying a
+        grid.
+
+        Parameters:
+            graph_tuple_row1 (tuple): Tuple of NetworkX graphs for the first row
+            (reactants, ITS graph, products).
+            graph_tuple_row2 (tuple): Tuple of NetworkX graphs for the second row (L, K,
+            R).
+            figsize (tuple): Figure size in inches (width, height).
+            titles_row1 (tuple): Titles for the first row subplots.
+            titles_row2 (tuple): Titles for the second row subplots.
+            show_node_labels (bool): If True, show node labels on the graphs.
+            show_grid (bool): If True, display grid lines on the plots.
+            grid_style (str): Style of the grid lines.
+            title_fontsize (int): Font size for subplot titles.
+            title_weight (str): Font weight for subplot titles.
+            save_path (str, optional): Path to save the figure to file.
+            display_inline (bool): If True, display the figure inline in the notebook.
+            log (bool): If True, enable logging of function progress.
+        """
+        if log:
+            logging.basicConfig(level=logging.INFO)
+
+        try:
+            sns.set_theme(style="darkgrid")  # Set the Seaborn style
+            reactants_graph, products_graph, its_graph = graph_tuple_row1
+            l_graph, r_graph, k_graph = graph_tuple_row2
+
+            # Create a figure with subplots
+            fig, axs = plt.subplots(2, 3, figsize=figsize)
+
+            # Visualize each graph on its respective subplot (first row)
+            self.graph_vis(
+                reactants_graph, ax=axs[0, 0], show_node_labels=show_node_labels
+            )
+            self.its_vis(its_graph, ax=axs[0, 1], show_node_labels=show_node_labels)
+            self.graph_vis(
+                products_graph, ax=axs[0, 2], show_node_labels=show_node_labels
+            )
+
+            # Visualize each graph on its respective subplot (second row)
+            self.graph_vis(l_graph, ax=axs[1, 0], show_node_labels=show_node_labels)
+            self.its_vis(k_graph, ax=axs[1, 1], show_node_labels=show_node_labels)
+            self.graph_vis(r_graph, ax=axs[1, 2], show_node_labels=show_node_labels)
+
+            # Set titles and enable grid for subplots
+            for ax, title in zip(axs[0], titles_row1):
+                ax.set_title(title, fontsize=title_fontsize, weight=title_weight)
+                if show_grid:
+                    ax.grid(True, linestyle=grid_style, which="both")
+
+            for ax, title in zip(axs[1], titles_row2):
+                ax.set_title(title, fontsize=title_fontsize, weight=title_weight)
+                if show_grid:
+                    ax.grid(True, linestyle=grid_style, which="both")
+
+            plt.tight_layout()
+
+            if save_path is not None:
+                plt.savefig(save_path, dpi=600)
+                if log:
+                    logging.info(f"Figure saved to {save_path}")
+
+            if display_inline:
+                plt.show()
+            else:
+                plt.close(fig)
+
+            return fig
+        except Exception as e:
+            if log:
+                logging.error("Failed to visualize graphs: ", exc_info=True)
+            raise RuntimeError("Error in graph visualization: ") from e

synkit/Vis/chemical_reaction_visualizer.py

@@ -0,0 +1,133 @@
+from typing import List, Dict
+from IPython.display import display, HTML, SVG
+from rdkit.Chem.Draw import rdMolDraw2D
+from rdkit.Chem import rdChemReactions
+
+
+class ChemicalReactionVisualizer:
+    @staticmethod
+    def create_html_table_with_svgs(
+        svg_list: List[str],
+        titles: List[str],
+        num_cols: int = 2,
+        orientation: str = "vertical",
+        title_size: int = 16,
+    ) -> HTML:
+        """
+        Creates an HTML table to display SVG images with titles in
+        a structured 'subplot-like' layout.
+
+        Parameters:
+        - svg_list (List[str]): List of SVG content strings.
+        - titles (List[str]): Corresponding titles for each SVG image.
+        - num_cols (int): Defines the number of columns for the
+                        'vertical' layout or rows for 'horizontal' layout.
+        - orientation (str): Layout orientation of images ('vertical' or 'horizontal').
+        - title_size (int): Font size of the titles displayed above each image.
+
+        Returns:
+        - HTML: HTML object to be displayed within an IPython notebook environment.
+        """
+        html = "<table>"
+        title_style = f"font-size:{title_size}px;"  # CSS to control title size
+        if orientation == "vertical":
+            for i in range(0, len(svg_list), num_cols):
+                html += "<tr>"
+                for j in range(num_cols):
+                    if i + j < len(svg_list):
+                        html += f"<td style='border:1px solid black; padding:10px'><b style='{title_style}'>{titles[i+j]}</b><br>{svg_list[i+j]}</td>"
+                html += "</tr>"
+        else:
+            for j in range(num_cols):
+                html += "<tr>"
+                for i in range(j, len(svg_list), num_cols):
+                    html += f"<td style='border:1px solid black; padding:10px'><b style='{title_style}'>{titles[i]}</b><br>{svg_list[i]}</td>"
+                html += "</tr>"
+        html += "</table>"
+        return HTML(html)
+
+    @staticmethod
+    def visualize_reaction(
+        reaction_smiles: str,
+        img_size: tuple = (600, 200),
+        highlight_by_reactant: bool = True,
+        mol_scale: float = 0.9,
+        bond_line_width: float = 2.0,
+        atom_label_font_size: int = 12,
+        padding: float = 0.01,
+        show_atom_map: bool = False,
+    ) -> SVG:
+        """
+        Visualizes a chemical reaction using RDKit and generates an SVG image for display.
+
+        Parameters:
+        - reaction_smiles (str): SMILES string representing the chemical reaction.
+        - img_size (tuple): Dimensions of the output image (width, height).
+        - highlight_by_reactant (bool): Whether to highlight reactants in the image.
+        - mol_scale (float): Scale factor for the size of the molecules in the image.
+        - bond_line_width (float): Line width for the bonds in the drawing.
+        - atom_label_font_size (int): Font size for the atom labels in the drawing.
+        - padding (float): Padding around the image in the SVG.
+        - show_atom_map (bool): Whether to display atom mapping numbers on the atoms.
+
+        Returns:
+        - SVG: An SVG object containing the rendered reaction.
+        """
+        reaction = rdChemReactions.ReactionFromSmarts(reaction_smiles, useSmiles=True)
+        rdChemReactions.PreprocessReaction(reaction)
+        if show_atom_map:
+            for mol in list(reaction.GetReactants()) + list(reaction.GetProducts()):
+                for atom in mol.GetAtoms():
+                    if atom.HasProp("molAtomMapNumber"):
+                        atom.SetProp("atomLabel", atom.GetProp("molAtomMapNumber"))
+
+        drawer = rdMolDraw2D.MolDraw2DSVG(img_size[0], img_size[1])
+        opts = drawer.drawOptions()
+        opts.scale = mol_scale
+        opts.bondLineWidth = bond_line_width
+        opts.atomLabelFontSize = atom_label_font_size
+        opts.padding = padding
+
+        drawer.DrawReaction(reaction, highlightByReactant=highlight_by_reactant)
+        drawer.FinishDrawing()
+        return SVG(drawer.GetDrawingText())
+
+    @staticmethod
+    def visualize_and_compare_reactions(
+        input_dict: Dict[str, str],
+        id_col: str = "R-id",
+        img_size: tuple = (1000, 600),
+        num_cols: int = 2,
+        orientation: str = "vertical",
+        show_atom_map: bool = False,
+    ) -> None:
+        """
+        Visualizes and compares multiple chemical reactions,
+        displaying them side by side in an HTML table.
+
+        Parameters:
+        - input_dict (Dict[str, str]): Dictionary with reaction
+            identifiers as keys and SMILES strings as values.
+        - id_col (str): A dictionary key to exclude
+                        from visualization (typically metadata).
+        - img_size (tuple): size if image.
+        - num_cols (int): Number of columns in the display table.
+        - orientation (str): vertically or horizontally.
+        """
+        svg_list = []
+        titles = []
+        for key, reaction_str in input_dict.items():
+            if key != id_col:
+                svg = ChemicalReactionVisualizer.visualize_reaction(
+                    reaction_str,
+                    img_size=img_size,
+                    highlight_by_reactant=True,
+                    show_atom_map=show_atom_map,
+                )
+                svg_list.append(svg.data)
+                titles.append(key)
+        display(
+            ChemicalReactionVisualizer.create_html_table_with_svgs(
+                svg_list, titles, num_cols, orientation
+            )
+        )

synkit/Vis/chemical_space.py

@@ -0,0 +1,83 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+
+plt.rc("text", usetex=True)  # Enable LaTeX rendering
+plt.rc("font", family="serif")  # Optional: use serif font
+
+
+def scatter_plot(
+    data_train,
+    data_test,
+    size_train=10,
+    size_test=10,
+    title=None,
+    ax=None,
+    xlabel="Coordinate 1",
+    ylabel="Coordinate 2",
+):
+    # Check if data is empty
+    if data_train.empty or data_test.empty:
+        raise ValueError("Input data frames cannot be empty.")
+
+    # Check for necessary columns
+    if data_train.columns.size < 3 or data_test.columns.size < 3:
+        raise ValueError("Data frames must have at least three columns.")
+
+    # Adding 'Type' column to differentiate between train and test data
+    data_train["Type"] = "Train"
+    data_test["Type"] = "Test"
+
+    # Combine the datasets
+    data_combined = pd.concat([data_train, data_test])
+
+    # If no axes object is passed, create one
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(12, 8))
+
+    # Define a more distinct color palette
+    pastel_palette = {
+        "Train": "deepskyblue",
+        "Test": "magenta",
+    }  # Using deepskyblue and magenta for better distinction
+
+    # Create scatter plots with specified sizes
+    for dtype, color in pastel_palette.items():
+        subset = data_combined[data_combined["Type"] == dtype]
+        ax.scatter(
+            subset[subset.columns[1]],
+            subset[subset.columns[2]],
+            color=color,
+            label=dtype,
+            s=size_train if dtype == "Train" else size_test,
+            alpha=0.1,
+            edgecolor="none",
+        )
+
+    # Set the title if provided
+    if title:
+        ax.set_title(rf"{title}", fontsize=24, fontweight="bold")
+
+    # Set labels
+    ax.set_xlabel(xlabel, fontsize=18)
+    ax.set_ylabel(ylabel, fontsize=18)
+
+    # Enhance grid and layout
+    ax.grid(True, which="both", linestyle="--", linewidth=0.5)
+    ax.set_axisbelow(True)
+
+    # Get legend handles and labels for external usage
+    handles, labels = ax.get_legend_handles_labels()
+
+    # Return the axes, handles, and labels for further customization outside the function
+    return ax, handles, labels
+
+
+# Define a function that modifies the legend handles to full opacity for better visibility in the legend
+def adjust_legend_handles(handles, colors):
+    new_handles = []
+    for handle, color in zip(handles, colors):
+        # Create a new handle with the same properties but with full alpha for the legend
+        new_handle = mpatches.Patch(color=color, label=handle.get_label())
+        new_handles.append(new_handle)
+    return new_handles

synkit/Vis/embedding.py

@@ -0,0 +1,92 @@
+from typing import Any, Dict, Optional
+import numpy as np
+from sklearn.manifold import TSNE
+from joblib import Memory
+
+
+class Embedding:
+    def __init__(
+        self,
+        cache_dir: str = "./cachedir",
+        verbose: int = 0,
+        custom_tsne_params: Optional[Dict] = None,
+    ) -> None:
+        """
+        Initialize the Embedding class with options for caching directory, verbosity, and custom t-SNE parameters.
+
+        Parameters:
+            cache_dir (str): Directory where cached results are stored.
+            verbose (int): Verbosity level for the memory object.
+            custom_tsne_params (Dict, optional): Custom default parameters for t-SNE computations.
+        """
+        self.memory = Memory(cache_dir, verbose=verbose)
+        self.default_tsne_params = {
+            "n_components": 2,
+            "perplexity": 30,
+            "learning_rate": 200,
+            "max_iter": 1000,
+            "random_state": 42,
+        }
+        if custom_tsne_params:
+            self.default_tsne_params.update(custom_tsne_params)
+        self.tsne_params = self.default_tsne_params.copy()
+
+    def set_tsne_params(self, **params) -> None:
+        """
+        Sets parameters for t-SNE computations.
+
+        Parameters:
+            **params: Arbitrary number of parameters for t-SNE.
+        """
+        self.tsne_params.update(params)
+
+    def reset_tsne_params(self) -> None:
+        """
+        Resets t-SNE parameters to default values.
+        """
+        self.tsne_params = self.default_tsne_params.copy()
+
+    def _compute_tsne(self, X: np.ndarray) -> np.ndarray:
+        """
+        Direct computation of the t-SNE embedding with the current parameters.
+
+        Parameters:
+            X (np.ndarray): High-dimensional data points.
+
+        Returns:
+            np.ndarray: The 2-dimensional t-SNE embedding of the data.
+        """
+        tsne = TSNE(**self.tsne_params)
+        return tsne.fit_transform(X)
+
+    def compute_tsne(self, X: np.ndarray, cache: bool = True) -> np.ndarray:
+        """
+        Computes or retrieves the t-SNE embedding from cache.
+
+        Parameters:
+            X (np.ndarray): High-dimensional data points.
+            cache (bool): Determines whether to use caching for the computation.
+
+        Returns:
+            np.ndarray: The 2-dimensional t-SNE embedding of the data.
+        """
+        if cache:
+            return self.cache(X)
+        else:
+            return self._compute_tsne(X)
+
+    @property
+    def cache(self) -> Any:
+        """
+        Decorator for caching the compute_tsne function.
+
+        Returns:
+            Callable: Cached function.
+        """
+        return self.memory.cache(self._compute_tsne)
+
+    def clear_cache(self) -> None:
+        """
+        Clears the cache directory.
+        """
+        self.memory.clear()