scikit-network 0.33.3__cp313-cp313-macosx_10_13_x86_64.whl

sknetwork/utils/values.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in April 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import warnings
+from typing import Optional, Union
+
+import numpy as np
+
+
+def get_values(shape: tuple, values: Union[np.ndarray, list, dict], default_value: float = -1) -> np.ndarray:
+    """Get values as array."""
+    n = shape[0]
+    if isinstance(values, list):
+        values = np.array(values)
+    if isinstance(values, np.ndarray):
+        if len(values) != n:
+            raise ValueError('Dimensions mismatch between adjacency and values.')
+        else:
+            values = values.astype(float)
+    elif isinstance(values, dict):
+        keys, values_ = np.array(list(values.keys())), np.array(list(values.values()))
+        if np.min(values_) < 0:
+            warnings.warn(Warning("Negative values will not be taken into account."))
+        values = default_value * np.ones(n)
+        values[keys] = values_
+    else:
+        values = np.ones(n)
+    return values
+
+
+def stack_values(shape: tuple, values_row: Optional[Union[np.ndarray, list, dict]],
+                 values_col: Optional[Union[np.ndarray, list, dict]] = None, default_value: float = -1) -> np.ndarray:
+    """Process values for rows and columns and stack the results into a single vector."""
+    n_row, n_col = shape
+    if values_row is None and values_col is None:
+        values_row = np.ones(n_row)
+        values_col = default_value * np.ones(n_col)
+    elif values_row is None:
+        values_row = default_value * np.ones(n_row)
+    elif values_col is None:
+        values_col = default_value * np.ones(n_col)
+    values_row = get_values(shape, values_row, default_value)
+    values_col = get_values((n_col,), values_col, default_value)
+    return np.hstack((values_row, values_col))
+
+
+def values2prob(n: int, values: np.ndarray = None) -> np.ndarray:
+    """Transform seed values into probability vector.
+
+    Parameters
+    ----------
+    n : int
+        Number of nodes.
+    values :
+        If ``None``, the uniform distribution is used.
+        Otherwise, a non-negative, non-zero vector or a dictionary must be provided.
+
+    Returns
+    -------
+    probs: np.ndarray
+        A probability vector.
+    """
+    if values is None:
+        return np.ones(n) / n
+    else:
+        values = get_values((n,), values)
+        probs = np.zeros_like(values, dtype=float)
+        ix = (values > 0)
+        probs[ix] = values[ix]
+        if probs.sum() > 0:
+            return probs / probs.sum()
+        else:
+            raise ValueError('At least one value must be positive.')

sknetwork/visualization/__init__.py

@@ -0,0 +1,4 @@
+"""Visualization module."""
+
+from sknetwork.visualization.dendrograms import visualize_dendrogram, svg_dendrogram
+from sknetwork.visualization.graphs import visualize_graph, visualize_bigraph, svg_graph, svg_bigraph

sknetwork/visualization/colors.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on April 2020
+@authors:
+Thomas Bonald <bonald@enst.fr>
+"""
+
+import numpy as np
+
+# standard SVG colors
+STANDARD_COLORS = np.array(['blue', 'red', 'green', 'orange', 'purple', 'yellow', 'fuchsia', 'olive', 'aqua', 'brown'])
+
+# 100 RGB colors of coolwarm color map.
+COOLWARM_RGB = np.array([[58,  76, 192], [60,  79, 195], [64,  84, 199], [66,  88, 202], [70,  93, 207], [72,  96, 209],
+                         [76, 102, 214], [80, 107, 218], [82, 110, 220], [86, 115, 224], [88, 118, 226], [92, 123, 229],
+                         [96, 128, 232], [99, 131, 234], [103, 136, 237], [105, 139, 239], [109, 144, 241],
+                         [112, 147, 243], [116, 151, 245], [120, 155, 247], [123, 158, 248], [127, 162, 250],
+                         [130, 165, 251], [134, 169, 252], [138, 173, 253], [141, 175, 253], [145, 179, 254],
+                         [148, 181, 254], [152, 185, 254], [155, 187, 254], [159, 190, 254], [163, 193, 254],
+                         [166, 195, 253], [170, 198, 253], [172, 200, 252], [176, 203, 251], [180, 205, 250],
+                         [183, 207, 249], [187, 209, 247], [189, 210, 246], [193, 212, 244], [197, 213, 242],
+                         [199, 214, 240], [202, 216, 238], [205, 217, 236], [208, 218, 233], [210, 218, 231],
+                         [214, 219, 228], [217, 220, 224], [219, 220, 222], [222, 219, 218], [224, 218, 215],
+                         [227, 217, 211], [230, 215, 207], [231, 214, 204], [234, 211, 199], [236, 210, 196],
+                         [237, 207, 192], [239, 206, 188], [241, 203, 184], [242, 200, 179], [243, 198, 176],
+                         [244, 195, 171], [245, 193, 168], [246, 189, 164], [246, 186, 159], [246, 183, 156],
+                         [247, 179, 151], [247, 177, 148], [247, 173, 143], [246, 169, 138], [246, 166, 135],
+                         [245, 161, 130], [245, 158, 127], [244, 154, 123], [243, 150, 120], [242, 145, 115],
+                         [240, 141, 111], [239, 137, 108], [237, 132, 103], [236, 128, 100], [234, 123,  96],
+                         [231, 117,  92], [230, 114,  89], [227, 108,  84], [225, 104,  82], [222,  98,  78],
+                         [220,  94,  75], [217,  88,  71], [214,  82,  67], [211,  77,  64], [207,  70,  61],
+                         [205,  66,  58], [201,  59,  55], [197,  50,  51], [194,  45,  49], [190,  35,  45],
+                         [187,  26,  43], [182,  13,  40], [179,   3,  38]])

sknetwork/visualization/dendrograms.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in April 2020
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Iterable, Optional
+
+import numpy as np
+
+from sknetwork.hierarchy.postprocess import cut_straight
+from sknetwork.visualization.colors import STANDARD_COLORS
+
+
+def get_index(dendrogram, reorder=True):
+    """Index nodes for pretty dendrogram."""
+    n = dendrogram.shape[0] + 1
+    tree = {i: [i] for i in range(n)}
+    for t in range(n - 1):
+        i = int(dendrogram[t, 0])
+        j = int(dendrogram[t, 1])
+        left: list = tree.pop(i)
+        right: list = tree.pop(j)
+        if reorder and len(left) < len(right):
+            tree[n + t] = right + left
+        else:
+            tree[n + t] = left + right
+    return list(tree.values())[0]
+
+
+def svg_dendrogram_top(dendrogram, names, width, height, margin, margin_text, scale, line_width, n_clusters,
+                       color, colors, font_size, reorder, rotate_names):
+    """Dendrogram as SVG image with root on top."""
+
+    # scaling
+    height *= scale
+    width *= scale
+
+    # positioning
+    labels = cut_straight(dendrogram, n_clusters, return_dendrogram=False)
+    index = get_index(dendrogram, reorder)
+    n = len(index)
+    unit_height = height / dendrogram[-1, 2]
+    unit_width = width / n
+    height_basis = margin + height
+    position = {index[i]: (margin + i * unit_width, height_basis) for i in range(n)}
+    label = {i: l for i, l in enumerate(labels)}
+    width += 2 * margin
+    height += 2 * margin
+    if names is not None:
+        text_length = np.max(np.array([len(str(name)) for name in names]))
+        height += text_length * font_size * .5 + margin_text
+
+    svg = """<svg width="{}" height="{}"  xmlns="http://www.w3.org/2000/svg">""".format(width, height)
+
+    # text
+    if names is not None:
+        for i in range(n):
+            x, y = position[i]
+            x -= margin_text
+            y += margin_text
+            text = str(names[i]).replace('&', ' ')
+            if rotate_names:
+                svg += """<text x="{}" y="{}"  transform="rotate(60, {}, {})" font-size="{}">{}</text>""" \
+                    .format(x, y, x, y, font_size, text)
+            else:
+                y += margin_text
+                svg += """<text x="{}" y="{}"  font-size="{}">{}</text>""" \
+                    .format(x, y, font_size, text)
+
+    # tree
+    for t in range(n - 1):
+        i = int(dendrogram[t, 0])
+        j = int(dendrogram[t, 1])
+        x1, y1 = position.pop(i)
+        x2, y2 = position.pop(j)
+        l1 = label.pop(i)
+        l2 = label.pop(j)
+        if l1 == l2:
+            line_color = colors[l1 % len(colors)]
+        else:
+            line_color = color
+        x = .5 * (x1 + x2)
+        y = height_basis - dendrogram[t, 2] * unit_height
+        svg += """<path stroke-width="{}" stroke="{}" d="M {} {} {} {}" />"""\
+            .format(line_width, line_color, x1, y1, x1, y)
+        svg += """<path stroke-width="{}" stroke="{}" d="M {} {} {} {}" />"""\
+            .format(line_width, line_color, x2, y2, x2, y)
+        svg += """<path stroke-width="{}" stroke="{}" d="M {} {} {} {}" />"""\
+            .format(line_width, line_color, x1, y, x2, y)
+        position[n + t] = (x, y)
+        label[n + t] = l1
+
+    svg += '</svg>'
+    return svg
+
+
+def svg_dendrogram_left(dendrogram, names, width, height, margin, margin_text, scale, line_width, n_clusters,
+                        color, colors, font_size, reorder):
+    """Dendrogram as SVG image with root on left side."""
+
+    # scaling
+    height *= scale
+    width *= scale
+
+    # positioning
+    labels = cut_straight(dendrogram, n_clusters, return_dendrogram=False)
+    index = get_index(dendrogram, reorder)
+    n = len(index)
+    unit_height = height / n
+    unit_width = width / dendrogram[-1, 2]
+    width_basis = width + margin
+    position = {index[i]: (width_basis, margin + i * unit_height) for i in range(n)}
+    label = {i: l for i, l in enumerate(labels)}
+    width += 2 * margin
+    height += 2 * margin
+    if names is not None:
+        text_length = np.max(np.array([len(str(name)) for name in names]))
+        width += text_length * font_size * .5 + margin_text
+
+    svg = """<svg width="{}" height="{}"  xmlns="http://www.w3.org/2000/svg">""".format(width, height)
+
+    # text
+    if names is not None:
+        for i in range(n):
+            x, y = position[i]
+            x += margin_text
+            y += unit_height / 3
+            text = str(names[i]).replace('&', ' ')
+            svg += """<text x="{}" y="{}" font-size="{}">{}</text>""" \
+                .format(x, y, font_size, text)
+
+    # tree
+    for t in range(n - 1):
+        i = int(dendrogram[t, 0])
+        j = int(dendrogram[t, 1])
+        x1, y1 = position.pop(i)
+        x2, y2 = position.pop(j)
+        l1 = label.pop(i)
+        l2 = label.pop(j)
+        if l1 == l2:
+            line_color = colors[l1 % len(colors)]
+        else:
+            line_color = color
+        y = .5 * (y1 + y2)
+        x = width_basis - dendrogram[t, 2] * unit_width
+        svg += """<path stroke-width="{}" stroke="{}" d="M {} {} {} {}" />"""\
+            .format(line_width, line_color, x1, y1, x, y1)
+        svg += """<path stroke-width="{}" stroke="{}" d="M {} {} {} {}" />"""\
+            .format(line_width, line_color, x2, y2, x, y2)
+        svg += """<path stroke-width="{}" stroke="{}" d="M {} {} {} {}" />"""\
+            .format(line_width, line_color, x, y1, x, y2)
+        position[n + t] = (x, y)
+        label[n + t] = l1
+
+    svg += '</svg>'
+
+    return svg
+
+
+def visualize_dendrogram(dendrogram: np.ndarray, names: Optional[np.ndarray] = None, rotate: bool = False,
+                         width: float = 400, height: float = 300, margin: float = 10, margin_text: float = 5,
+                         scale: float = 1, line_width: float = 2, n_clusters: int = 2, color: str = 'black',
+                         colors: Optional[Iterable] = None, font_size: int = 12, reorder: bool = False,
+                         rotate_names: bool = True, filename: Optional[str] = None):
+    """Return the image of a dendrogram in SVG format.
+
+    Parameters
+    ----------
+    dendrogram :
+        Dendrogram to display.
+    names :
+        Names of leaves.
+    rotate :
+        If ``True``, rotate the tree so that the root is on the left.
+    width :
+        Width of the image (margins excluded).
+    height :
+        Height of the image (margins excluded).
+    margin :
+        Margin.
+    margin_text :
+        Margin between leaves and their names, if any.
+    scale :
+        Scaling factor.
+    line_width :
+        Line width.
+    n_clusters :
+        Number of coloured clusters to display.
+    color :
+        Default SVG color for the dendrogram.
+    colors :
+        SVG colors of the clusters of the dendrogram (optional).
+    font_size :
+        Font size.
+    reorder :
+        If ``True``, reorder leaves so that left subtree has more leaves than right subtree.
+    rotate_names :
+        If ``True``, rotate names of leaves (only valid if **rotate** is ``False``).
+    filename :
+        Filename for saving image (optional).
+
+    Example
+    -------
+    >>> dendrogram = np.array([[0, 1, 1, 2], [2, 3, 2, 3]])
+    >>> from sknetwork.visualization import svg_dendrogram
+    >>> image = svg_dendrogram(dendrogram)
+    >>> image[1:4]
+    'svg'
+    """
+    if colors is None:
+        colors = STANDARD_COLORS
+    elif isinstance(colors, dict):
+        colors = np.array(list(colors.values()))
+    elif isinstance(colors, list):
+        colors = np.array(colors)
+
+    if rotate:
+        svg = svg_dendrogram_left(dendrogram, names, width, height, margin, margin_text, scale, line_width, n_clusters,
+                                  color, colors, font_size, reorder)
+    else:
+        svg = svg_dendrogram_top(dendrogram, names, width, height, margin, margin_text, scale, line_width, n_clusters,
+                                 color, colors, font_size, reorder, rotate_names)
+
+    if filename is not None:
+        with open(filename + '.svg', 'w') as f:
+            f.write(svg)
+
+    return svg
+
+
+def svg_dendrogram(dendrogram: np.ndarray, names: Optional[np.ndarray] = None, rotate: bool = False, width: float = 400,
+                   height: float = 300, margin: float = 10, margin_text: float = 5, scale: float = 1,
+                   line_width: float = 2, n_clusters: int = 2, color: str = 'black', colors: Optional[Iterable] = None,
+                   font_size: int = 12, reorder: bool = False, rotate_names: bool = True,
+                   filename: Optional[str] = None):
+    """Return the image of a dendrogram in SVG format.
+
+    Alias for visualize_dendrogram.
+
+    Parameters
+    ----------
+    dendrogram :
+        Dendrogram to display.
+    names :
+        Names of leaves.
+    rotate :
+        If ``True``, rotate the tree so that the root is on the left.
+    width :
+        Width of the image (margins excluded).
+    height :
+        Height of the image (margins excluded).
+    margin :
+        Margin.
+    margin_text :
+        Margin between leaves and their names, if any.
+    scale :
+        Scaling factor.
+    line_width :
+        Line width.
+    n_clusters :
+        Number of coloured clusters to display.
+    color :
+        Default SVG color for the dendrogram.
+    colors :
+        SVG colors of the clusters of the dendrogram (optional).
+    font_size :
+        Font size.
+    reorder :
+        If ``True``, reorder leaves so that left subtree has more leaves than right subtree.
+    rotate_names :
+        If ``True``, rotate names of leaves (only valid if **rotate** is ``False``).
+    filename :
+        Filename for saving image (optional).
+    """
+    return visualize_dendrogram(dendrogram, names, rotate, width, height, margin, margin_text, scale, line_width,
+                                n_clusters, color, colors, font_size, reorder, rotate_names, filename)