scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/utils/tests/test_projection_simplex.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for simplex.py"""
+
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import is_proba_array
+from sknetwork.utils.simplex import projection_simplex
+
+
+class TestProjSimplex(unittest.TestCase):
+
+    def test_array(self):
+        x = np.random.rand(5)
+        proj = projection_simplex(x)
+        self.assertTrue(is_proba_array(proj))
+
+        x = np.random.rand(4, 3)
+        proj = projection_simplex(x)
+        self.assertTrue(is_proba_array(proj))
+
+    def test_csr(self):
+        x = sparse.csr_matrix(np.ones((3, 3)))
+        proj1 = projection_simplex(x)
+        proj2 = projection_simplex(x.astype(bool))
+        self.assertEqual(0, (proj1-proj2).nnz)
+
+    def test_other(self):
+        with self.assertRaises(TypeError):
+            projection_simplex('toto')

sknetwork/utils/tests/test_seeds.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for seeds.py"""
+
+import unittest
+
+import numpy as np
+
+from sknetwork.utils.seeds import get_seeds, stack_seeds, seeds2probs
+
+
+class TestSeeds(unittest.TestCase):
+
+    def test_get_seeds(self):
+        n = 10
+        seeds_array = -np.ones(n)
+        seeds_array[:2] = np.arange(2)
+        seeds_dict = {0: 0, 1: 1}
+        labels_array = get_seeds((n,), seeds_array)
+        labels_dict = get_seeds((n,), seeds_dict)
+
+        self.assertTrue(np.allclose(labels_array, labels_dict))
+        with self.assertRaises(ValueError):
+            get_seeds((5,), labels_array)
+        self.assertRaises(TypeError, get_seeds, 'toto', 3)
+        with self.assertWarns(Warning):
+            seeds_dict[0] = -1
+            get_seeds((n,), seeds_dict)
+
+    def test_seeds2probs(self):
+        n = 4
+        seeds_array = np.array([0, 1, -1, 0])
+        seeds_dict = {0: 0, 1: 1, 3: 0}
+
+        probs1 = seeds2probs(n, seeds_array)
+        probs2 = seeds2probs(n, seeds_dict)
+        self.assertTrue(np.allclose(probs1, probs2))
+
+        bad_input = np.array([0, 0, -1, 0])
+        with self.assertRaises(ValueError):
+            seeds2probs(n, bad_input)
+
+    def test_stack_seeds(self):
+        shape = 4, 3
+        seeds_row_array = np.array([0, 1, -1, 0])
+        seeds_row_dict = {0: 0, 1: 1, 3: 0}
+        seeds_col_array = np.array([0, 1, -1])
+        seeds_col_dict = {0: 0, 1: 1}
+
+        seeds1 = stack_seeds(shape, seeds_row_array, seeds_col_array)
+        seeds2 = stack_seeds(shape, seeds_row_dict, seeds_col_dict)
+        seeds3 = stack_seeds(shape, seeds_row_array, seeds_col_dict)
+        seeds4 = stack_seeds(shape, seeds_row_dict, seeds_col_array)
+
+        self.assertTrue(np.allclose(seeds1, seeds2))
+        self.assertTrue(np.allclose(seeds2, seeds3))
+        self.assertTrue(np.allclose(seeds3, seeds4))
+
+        seeds1 = stack_seeds(shape, seeds_row_array, None)
+        seeds2 = stack_seeds(shape, seeds_row_dict, None)
+
+        self.assertTrue(np.allclose(seeds1, seeds2))
+
+        seeds1 = stack_seeds(shape, None, seeds_col_array)
+        seeds2 = stack_seeds(shape, None, seeds_col_dict)
+
+        self.assertTrue(np.allclose(seeds1, seeds2))

sknetwork/utils/tests/test_verbose.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for verbose.py"""
+
+import unittest
+
+from sknetwork.utils.verbose import VerboseMixin
+
+
+class TestVerbose(unittest.TestCase):
+
+    def test_prints(self):
+        verbose = VerboseMixin(verbose=True)
+        verbose.log.print('There are', 4, 'seasons in a year')
+        self.assertEqual(str(verbose.log), 'There are 4 seasons in a year\n')

sknetwork/utils/tests/test_ward.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import unittest
+
+import numpy as np
+
+from sknetwork.utils import WardDense
+
+
+class TestKMeans(unittest.TestCase):
+
+    def test_kmeans(self):
+        x = np.random.randn(10, 3)
+        ward = WardDense()
+        dendrogram = ward.fit_transform(x)
+        self.assertEqual(dendrogram.shape, (x.shape[0] - 1, 4))

sknetwork/utils/timeout.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+import contextlib
+import signal
+import warnings
+
+
+class TimeOut(contextlib.ContextDecorator):
+    """
+    Timeout context manager/decorator.
+
+    Adapted from https://gist.github.com/TySkby/143190ad1b88c6115597c45f996b030c on 12/10/2020.
+
+    Examples
+    --------
+    >>> from time import sleep
+    >>> try:
+    ...     with TimeOut(1):
+    ...         sleep(10)
+    ... except TimeoutError:
+    ...     print("Function timed out")
+    Function timed out
+    """
+    def __init__(self, seconds: float):
+        self.seconds = seconds
+
+    def _timeout_handler(self, signum, frame):
+        raise TimeoutError("Code timed out.")
+
+    def __enter__(self):
+        if hasattr(signal, "SIGALRM"):
+            signal.signal(signal.SIGALRM, self._timeout_handler)
+            signal.alarm(self.seconds)
+        else:
+            warnings.warn("SIGALRM is unavailable on Windows. Timeouts are not functional.")
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if hasattr(signal, "SIGALRM"):
+            signal.alarm(0)

sknetwork/utils/verbose.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in December 2019
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+
+
+class Log:
+    """Log class for easier verbosity features"""
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.log = ''
+
+    def print(self, *args):
+        """Fill log with text."""
+        if self.verbose:
+            print(*args)
+        self.log += ' '.join(map(str, args)) + '\n'
+
+    def __repr__(self):
+        return self.log
+
+
+class VerboseMixin:
+    """Mixin class for verbosity"""
+    def __init__(self, verbose: bool = False):
+        self.log = Log(verbose)
+
+    def _scipy_solver_info(self, info: int):
+        """Fill log with scipy info."""
+        if info == 0:
+            self.log.print('Successful exit.')
+        elif info > 0:
+            self.log.print('Convergence to tolerance not achieved.')
+        else:
+            self.log.print('Illegal input or breakdown.')

sknetwork/utils/ward.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on October 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+"""
+import numpy as np
+from scipy.cluster.hierarchy import ward
+
+from sknetwork.utils.base import Algorithm
+
+
+class WardDense(Algorithm):
+    """Hierarchical clustering by the Ward method based on SciPy.
+
+    Attributes
+    ----------
+    dendrogram_ : np.ndarray (n - 1, 4)
+        Dendrogram.
+
+    References
+    ----------
+    * Ward, J. H., Jr. (1963). Hierarchical grouping to optimize an objective function.
+      Journal of the American Statistical Association, 58, 236–244.
+
+    * Murtagh, F., & Contreras, P. (2012). Algorithms for hierarchical clustering: an overview.
+      Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 2(1), 86-97.
+    """
+    def __init__(self):
+        self.dendrogram_ = None
+
+    def fit(self, x: np.ndarray) -> 'WardDense':
+        """Apply algorithm to a dense matrix.
+
+        Parameters
+        ----------
+        x:
+            Data to cluster.
+
+        Returns
+        -------
+        self: :class:`WardDense`
+        """
+        self.dendrogram_ = ward(x)
+        return self
+
+    def fit_transform(self, x: np.ndarray) -> np.ndarray:
+        """Apply algorithm to a dense matrix and return the dendrogram.
+
+        Parameters
+        ----------
+        x:
+            Data to cluster.
+
+        Returns
+        -------
+        dendrogram: np.ndarray
+        """
+        self.fit(x)
+        return self.dendrogram_

sknetwork/visualization/__init__.py

@@ -0,0 +1,4 @@
+"""Visualization module."""
+
+from sknetwork.visualization.dendrograms import svg_dendrogram
+from sknetwork.visualization.graphs import 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,229 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on 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 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 SVG image of a 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).
+
+    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