morphml 1.0.0__py3-none-any.whl

morphml/visualization/architecture_diagrams.py

@@ -0,0 +1,353 @@
+"""Professional architecture diagram generation for MorphML.
+
+Generate publication-quality diagrams of neural architectures.
+
+Example:
+    >>> from morphml.visualization.architecture_diagrams import ArchitectureDiagramGenerator
+    >>> generator = ArchitectureDiagramGenerator()
+    >>> generator.generate_svg(graph, "architecture.svg")
+"""
+
+from typing import Dict, Optional
+
+try:
+    import graphviz
+
+    GRAPHVIZ_AVAILABLE = True
+except ImportError:
+    GRAPHVIZ_AVAILABLE = False
+    graphviz = None
+
+from morphml.core.graph import GraphNode, ModelGraph
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class ArchitectureDiagramGenerator:
+    """
+    Generate professional architecture diagrams.
+
+    Creates publication-quality visualizations of neural architectures
+    using Graphviz with custom styling.
+
+    Example:
+        >>> generator = ArchitectureDiagramGenerator()
+        >>> generator.generate_svg(graph, "output.svg")
+        >>> generator.generate_png(graph, "output.png", dpi=300)
+    """
+
+    # Color scheme for different operations
+    OPERATION_COLORS = {
+        "input": "#90EE90",  # Light green
+        "output": "#FFB6C1",  # Light pink
+        "conv2d": "#FF6B6B",  # Red
+        "dense": "#4ECDC4",  # Teal
+        "maxpool": "#45B7D1",  # Blue
+        "avgpool": "#5DADE2",  # Light blue
+        "relu": "#96CEB4",  # Green
+        "sigmoid": "#FFEAA7",  # Yellow
+        "tanh": "#DFE6E9",  # Gray
+        "softmax": "#FD79A8",  # Pink
+        "batchnorm": "#A29BFE",  # Purple
+        "dropout": "#FDCB6E",  # Orange
+        "flatten": "#E17055",  # Dark orange
+    }
+
+    def __init__(self, style: str = "modern"):
+        """
+        Initialize diagram generator.
+
+        Args:
+            style: Visual style ('modern', 'classic', 'minimal')
+        """
+        if not GRAPHVIZ_AVAILABLE:
+            raise ImportError(
+                "Graphviz is required for architecture diagrams. "
+                "Install with: pip install graphviz"
+            )
+
+        self.style = style
+        logger.info(f"Initialized ArchitectureDiagramGenerator with style: {style}")
+
+    def generate_svg(self, graph: ModelGraph, output_path: str, title: Optional[str] = None):
+        """
+        Generate SVG diagram.
+
+        Args:
+            graph: ModelGraph to visualize
+            output_path: Output file path (without extension)
+            title: Optional diagram title
+
+        Example:
+            >>> generator.generate_svg(graph, "architecture")
+            # Creates architecture.svg
+        """
+        dot = self._create_graphviz_graph(graph, title)
+        dot.render(output_path, format="svg", cleanup=True)
+        logger.info(f"Generated SVG diagram: {output_path}.svg")
+
+    def generate_png(
+        self, graph: ModelGraph, output_path: str, dpi: int = 300, title: Optional[str] = None
+    ):
+        """
+        Generate PNG diagram.
+
+        Args:
+            graph: ModelGraph to visualize
+            output_path: Output file path (without extension)
+            dpi: Resolution in DPI
+            title: Optional diagram title
+
+        Example:
+            >>> generator.generate_png(graph, "architecture", dpi=300)
+            # Creates architecture.png
+        """
+        dot = self._create_graphviz_graph(graph, title)
+        dot.graph_attr["dpi"] = str(dpi)
+        dot.render(output_path, format="png", cleanup=True)
+        logger.info(f"Generated PNG diagram: {output_path}.png")
+
+    def generate_pdf(self, graph: ModelGraph, output_path: str, title: Optional[str] = None):
+        """
+        Generate PDF diagram.
+
+        Args:
+            graph: ModelGraph to visualize
+            output_path: Output file path (without extension)
+            title: Optional diagram title
+
+        Example:
+            >>> generator.generate_pdf(graph, "architecture")
+            # Creates architecture.pdf
+        """
+        dot = self._create_graphviz_graph(graph, title)
+        dot.render(output_path, format="pdf", cleanup=True)
+        logger.info(f"Generated PDF diagram: {output_path}.pdf")
+
+    def _create_graphviz_graph(
+        self, graph: ModelGraph, title: Optional[str] = None
+    ) -> "graphviz.Digraph":
+        """
+        Create Graphviz graph from ModelGraph.
+
+        Args:
+            graph: ModelGraph to convert
+            title: Optional title
+
+        Returns:
+            Graphviz Digraph
+        """
+        dot = graphviz.Digraph(comment="Neural Architecture")
+
+        # Set graph attributes based on style
+        if self.style == "modern":
+            dot.attr(
+                rankdir="TB",
+                bgcolor="white",
+                fontname="Arial",
+                fontsize="12",
+                splines="ortho",
+                nodesep="0.5",
+                ranksep="0.8",
+            )
+        elif self.style == "classic":
+            dot.attr(rankdir="TB", bgcolor="white", fontname="Times", fontsize="11")
+        else:  # minimal
+            dot.attr(
+                rankdir="TB", bgcolor="white", fontname="Helvetica", fontsize="10", splines="line"
+            )
+
+        # Add title if provided
+        if title:
+            dot.attr(label=title, labelloc="t", fontsize="16")
+
+        # Add nodes
+        for _node_id, node in graph.nodes.items():
+            self._add_node(dot, node)
+
+        # Add edges
+        for _edge_id, edge in graph.edges.items():
+            self._add_edge(dot, edge)
+
+        return dot
+
+    def _add_node(self, dot: "graphviz.Digraph", node: GraphNode):
+        """
+        Add node to Graphviz graph.
+
+        Args:
+            dot: Graphviz graph
+            node: GraphNode to add
+        """
+        operation = node.operation
+
+        # Get color
+        color = self.OPERATION_COLORS.get(operation, "#CCCCCC")
+
+        # Create label
+        label = self._create_node_label(node)
+
+        # Node attributes
+        node_attrs = {
+            "label": label,
+            "shape": "box",
+            "style": "filled,rounded",
+            "fillcolor": color,
+            "fontname": "Arial",
+            "fontsize": "10",
+            "margin": "0.2,0.1",
+        }
+
+        # Special styling for input/output
+        if operation == "input":
+            node_attrs["shape"] = "ellipse"
+            node_attrs["style"] = "filled"
+        elif operation == "output":
+            node_attrs["shape"] = "ellipse"
+            node_attrs["style"] = "filled"
+
+        dot.node(str(node.id), **node_attrs)
+
+    def _create_node_label(self, node: GraphNode) -> str:
+        """
+        Create formatted label for node.
+
+        Args:
+            node: GraphNode
+
+        Returns:
+            Formatted label string
+        """
+        operation = node.operation
+        params = node.params
+
+        # Base label
+        label = f"{operation}"
+
+        # Add key parameters
+        if operation == "conv2d":
+            filters = params.get("filters", "?")
+            kernel = params.get("kernel_size", "?")
+            label += f"\n{filters} filters\n{kernel}x{kernel} kernel"
+
+        elif operation == "dense":
+            units = params.get("units", "?")
+            label += f"\n{units} units"
+
+        elif operation in ["maxpool", "avgpool"]:
+            pool_size = params.get("pool_size", "?")
+            label += f"\n{pool_size}x{pool_size} pool"
+
+        elif operation == "dropout":
+            rate = params.get("rate", "?")
+            label += f"\nrate={rate}"
+
+        elif operation == "input":
+            shape = params.get("shape", "?")
+            label += f"\nshape={shape}"
+
+        return label
+
+    def _add_edge(self, dot: "graphviz.Digraph", edge):
+        """
+        Add edge to Graphviz graph.
+
+        Args:
+            dot: Graphviz graph
+            edge: GraphEdge to add
+        """
+        dot.edge(
+            str(edge.source.id),
+            str(edge.target.id),
+            color="#2C3E50",
+            penwidth="1.5",
+            arrowsize="0.8",
+        )
+
+    def generate_comparison_diagram(
+        self, graphs: Dict[str, ModelGraph], output_path: str, format: str = "svg"
+    ):
+        """
+        Generate side-by-side comparison of multiple architectures.
+
+        Args:
+            graphs: Dict mapping names to ModelGraphs
+            output_path: Output file path (without extension)
+            format: Output format ('svg', 'png', 'pdf')
+
+        Example:
+            >>> generator.generate_comparison_diagram({
+            ...     'Architecture A': graph_a,
+            ...     'Architecture B': graph_b
+            ... }, "comparison")
+        """
+        # Create compound graph
+        dot = graphviz.Digraph(comment="Architecture Comparison")
+        dot.attr(rankdir="LR", compound="true")
+
+        # Add subgraphs for each architecture
+        for i, (name, graph) in enumerate(graphs.items()):
+            with dot.subgraph(name=f"cluster_{i}") as sub:
+                sub.attr(label=name, style="rounded", color="gray")
+
+                # Add nodes
+                for _node_id, node in graph.nodes.items():
+                    self._add_node(sub, node)
+
+                # Add edges
+                for _edge_id, edge in graph.edges.items():
+                    self._add_edge(sub, edge)
+
+        # Render
+        dot.render(output_path, format=format, cleanup=True)
+        logger.info(f"Generated comparison diagram: {output_path}.{format}")
+
+    def generate_layer_statistics_diagram(self, graph: ModelGraph, output_path: str):
+        """
+        Generate diagram with layer statistics.
+
+        Args:
+            graph: ModelGraph to visualize
+            output_path: Output file path (without extension)
+
+        Example:
+            >>> generator.generate_layer_statistics_diagram(graph, "stats")
+        """
+        dot = graphviz.Digraph(comment="Architecture with Statistics")
+        dot.attr(rankdir="TB", bgcolor="white")
+
+        # Calculate statistics
+        total_params = graph.estimate_parameters()
+        depth = graph.estimate_depth()
+        width = graph.estimate_width()
+
+        # Add info box
+        info_label = (
+            f"Total Parameters: {total_params:,}\\n"
+            f"Depth: {depth}\\n"
+            f"Width: {width}\\n"
+            f"Nodes: {len(graph.nodes)}"
+        )
+
+        dot.node(
+            "info",
+            label=info_label,
+            shape="box",
+            style="filled",
+            fillcolor="#E8F4F8",
+            fontname="Courier",
+            fontsize="10",
+        )
+
+        # Add architecture nodes
+        for _node_id, node in graph.nodes.items():
+            self._add_node(dot, node)
+
+        # Add edges
+        for _edge_id, edge in graph.edges.items():
+            self._add_edge(dot, edge)
+
+        # Render
+        dot.render(output_path, format="svg", cleanup=True)
+        logger.info(f"Generated statistics diagram: {output_path}.svg")

morphml/visualization/architecture_plot.py

@@ -0,0 +1,223 @@
+"""Architecture visualization utilities.
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+"""
+
+from typing import Optional
+
+from morphml.core.graph import ModelGraph
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def plot_architecture(
+    graph: ModelGraph, save_path: Optional[str] = None, title: str = "Neural Architecture"
+) -> None:
+    """
+    Visualize neural architecture as a graph.
+
+    Args:
+        graph: ModelGraph to visualize
+        save_path: Path to save plot (displays if None)
+        title: Plot title
+
+    Example:
+        >>> from morphml.visualization.architecture_plot import plot_architecture
+        >>> plot_architecture(best_individual.graph)
+    """
+    try:
+        import matplotlib.pyplot as plt
+        import networkx as nx
+    except ImportError:
+        logger.error("matplotlib and networkx required for architecture plotting")
+        return
+
+    # Create NetworkX graph
+    G = nx.DiGraph()
+
+    # Add nodes
+    for node_id, node in graph.nodes.items():
+        G.add_node(node_id, label=f"{node.operation}\n{node_id[:8]}")
+
+    # Add edges
+    for edge in graph.edges:
+        G.add_edge(edge.source.id, edge.target.id)
+
+    # Create layout
+    pos = nx.spring_layout(G, k=1, iterations=50)
+
+    # Create plot
+    plt.figure(figsize=(14, 10))
+
+    # Draw nodes
+    nx.draw_networkx_nodes(
+        G, pos, node_size=3000, node_color="lightblue", alpha=0.9, edgecolors="black", linewidths=2
+    )
+
+    # Draw edges
+    nx.draw_networkx_edges(
+        G, pos, edge_color="gray", arrows=True, arrowsize=20, arrowstyle="->", width=2
+    )
+
+    # Draw labels
+    labels = nx.get_node_attributes(G, "label")
+    nx.draw_networkx_labels(G, pos, labels, font_size=8)
+
+    plt.title(title, fontsize=16, fontweight="bold")
+    plt.axis("off")
+    plt.tight_layout()
+
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
+        logger.info(f"Architecture plot saved to {save_path}")
+    else:
+        plt.show()
+
+    plt.close()
+
+
+def plot_architecture_hierarchy(
+    graph: ModelGraph, save_path: Optional[str] = None, title: str = "Architecture Hierarchy"
+) -> None:
+    """
+    Visualize architecture with hierarchical layout.
+
+    Args:
+        graph: ModelGraph to visualize
+        save_path: Path to save plot
+        title: Plot title
+    """
+    try:
+        import matplotlib.pyplot as plt
+        import networkx as nx
+    except ImportError:
+        logger.error("matplotlib and networkx required")
+        return
+
+    # Create NetworkX graph
+    G = nx.DiGraph()
+
+    for node_id, node in graph.nodes.items():
+        G.add_node(node_id, label=node.operation)
+
+    for edge in graph.edges:
+        G.add_edge(edge.source.id, edge.target.id)
+
+    # Use hierarchical layout
+    try:
+        pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
+    except Exception:
+        # Fallback to spring layout if graphviz not available
+        pos = nx.spring_layout(G)
+
+    plt.figure(figsize=(12, 10))
+
+    # Color nodes by operation type
+    node_colors = []
+    for node_id in G.nodes():
+        node = graph.nodes[node_id]
+        if node.operation in ["input", "output"]:
+            node_colors.append("lightgreen")
+        elif "conv" in node.operation:
+            node_colors.append("lightblue")
+        elif "dense" in node.operation:
+            node_colors.append("lightyellow")
+        else:
+            node_colors.append("lightgray")
+
+    nx.draw(
+        G,
+        pos,
+        node_color=node_colors,
+        with_labels=False,
+        node_size=2000,
+        alpha=0.9,
+        edgecolors="black",
+        linewidths=2,
+        edge_color="gray",
+        arrows=True,
+        arrowsize=15,
+    )
+
+    # Add labels
+    labels = {node_id: graph.nodes[node_id].operation for node_id in G.nodes()}
+    nx.draw_networkx_labels(G, pos, labels, font_size=8)
+
+    plt.title(title, fontsize=16, fontweight="bold")
+    plt.axis("off")
+    plt.tight_layout()
+
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
+        logger.info(f"Architecture hierarchy plot saved to {save_path}")
+    else:
+        plt.show()
+
+    plt.close()
+
+
+def plot_architecture_stats(
+    graphs: list, save_path: Optional[str] = None, title: str = "Architecture Statistics"
+) -> None:
+    """
+    Plot statistics of multiple architectures.
+
+    Args:
+        graphs: List of ModelGraph objects
+        save_path: Path to save plot
+        title: Plot title
+    """
+    try:
+        import matplotlib.pyplot as plt
+    except ImportError:
+        logger.error("matplotlib required")
+        return
+
+    # Collect statistics
+    node_counts = [len(g.nodes) for g in graphs]
+    depths = [g.get_depth() for g in graphs]
+    params = [g.estimate_parameters() / 1e6 for g in graphs]  # In millions
+
+    # Create subplots
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+
+    # Node count distribution
+    axes[0].hist(node_counts, bins=20, edgecolor="black", alpha=0.7)
+    axes[0].set_xlabel("Number of Nodes", fontsize=12)
+    axes[0].set_ylabel("Frequency", fontsize=12)
+    axes[0].set_title("Node Count Distribution", fontsize=12, fontweight="bold")
+    axes[0].grid(True, alpha=0.3)
+
+    # Depth distribution
+    axes[1].hist(depths, bins=20, edgecolor="black", alpha=0.7, color="green")
+    axes[1].set_xlabel("Depth", fontsize=12)
+    axes[1].set_ylabel("Frequency", fontsize=12)
+    axes[1].set_title("Depth Distribution", fontsize=12, fontweight="bold")
+    axes[1].grid(True, alpha=0.3)
+
+    # Parameter count distribution
+    axes[2].hist(params, bins=20, edgecolor="black", alpha=0.7, color="orange")
+    axes[2].set_xlabel("Parameters (Millions)", fontsize=12)
+    axes[2].set_ylabel("Frequency", fontsize=12)
+    axes[2].set_title("Parameter Count Distribution", fontsize=12, fontweight="bold")
+    axes[2].grid(True, alpha=0.3)
+
+    plt.suptitle(title, fontsize=16, fontweight="bold")
+    plt.tight_layout()
+
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches="tight")
+        logger.info(f"Architecture statistics plot saved to {save_path}")
+    else:
+        plt.show()
+
+    plt.close()
+
+
+# Re-export from existing visualization module for convenience
+try:
+    pass
+except ImportError:
+    pass