Merge pull request #182 from lucasimi/develop

Improved class hierarchies

Author: lucasimi

src/tdamapper/cover.py

@@ -229,44 +229,7 @@ def search(self, x):
         return [x for (x, _) in neighs]
 
 
-class ProximityCubicalCover(Proximity):
-    """
-    Cover algorithm based on the `cubical proximity function`, which covers
-    data with open hypercubes of uniform size and overlap. The cubical cover is
-    obtained by selecting a subsect of all the hypercubes that intersect the
-    dataset using proximity net (see :class:`tdamapper.core.Proximity`).
-    For an open cover containing all the hypercubes interecting the dataset
-    use :class:`tdamapper.core.StandardCubicalCover`.
-
-    A hypercube is a multidimensional generalization of a square or a cube.
-    The size and overlap of the hypercubes are determined by the number of
-    intervals and the overlap fraction parameters. This class maps each point
-    to the hypercube with the nearest center.
-
-    :param n_intervals: The number of intervals to use for each dimension.
-        Must be positive and less than or equal to the length of the dataset.
-        Defaults to 1.
-    :type n_intervals: int
-    :param overlap_frac: The fraction of overlap between adjacent intervals on
-        each dimension, must be in the range (0.0, 0.5]. If not specified, the
-        overlap_frac is computed such that the volume of the overlap within
-        each hypercube is half the total volume. Defaults to None.
-    :type overlap_frac: float
-    :param kind: Specifies whether to use a flat or a hierarchical vantage
-        point tree. Acceptable values are 'flat' or 'hierarchical'. Defaults to
-        'flat'.
-    :type kind: str
-    :param leaf_capacity: The maximum number of points in a leaf node of the
-        vantage point tree. Must be a positive value. Defaults to 1.
-    :type leaf_capacity: int
-    :param leaf_radius: The radius of the leaf nodes. If not specified, it
-        defaults to the value of `radius`. Must be a positive value. Defaults
-        to None.
-    :type leaf_radius: float, optional
-    :param pivoting: The method used for pivoting in the vantage point tree.
-        Acceptable values are None, 'random', or 'furthest'. Defaults to None.
-    :type pivoting: str or callable, optional
-    """
+class BaseCubicalCover:
 
     def __init__(
         self,
@@ -284,6 +247,39 @@ def __init__(
         self.leaf_radius = leaf_radius
         self.pivoting = pivoting
 
+    def _get_center(self, x):
+        offset = self._offset(x)
+        center = self._phi(x)
+        return tuple(offset), center
+
+    def _get_overlap_frac(self, dim, overlap_vol_frac):
+        beta = math.pow(1.0 - overlap_vol_frac, 1.0 / dim)
+        return 1.0 - 1.0 / (2.0 - beta)
+
+    def _offset(self, x):
+        return np.minimum(self._n_intervals - 1, np.floor(self._gamma_n(x)))
+
+    def _phi(self, x):
+        offset = self._offset(x)
+        return self._gamma_n_inv(0.5 + offset)
+
+    def _gamma_n(self, x):
+        return self._n_intervals * (x - self._min) / self._delta
+
+    def _gamma_n_inv(self, x):
+        return self._min + self._delta * x / self._n_intervals
+
+    def _get_bounds(self, X):
+        if (X is None) or len(X) == 0:
+            return
+        _min, _max = X[0], X[0]
+        eps = np.finfo(np.float64).eps
+        _min = np.min(X, axis=0)
+        _max = np.max(X, axis=0)
+        _delta = _max - _min
+        _delta[(_delta >= -eps) & (_delta <= eps)] = self._n_intervals
+        return _min, _max, _delta
+
     def fit(self, X):
         """
         Train internal parameters.
@@ -299,30 +295,30 @@ def fit(self, X):
         X = np.asarray(X).reshape(len(X), -1).astype(float)
         if self.overlap_frac is None:
             dim = 1 if X.ndim == 1 else X.shape[1]
-            self.__overlap_frac = self._get_overlap_frac(dim, 0.5)
+            self._overlap_frac = self._get_overlap_frac(dim, 0.5)
         else:
-            self.__overlap_frac = self.overlap_frac
-        self.__n_intervals = self.n_intervals
-        if self.__overlap_frac <= 0.0:
+            self._overlap_frac = self.overlap_frac
+        self._n_intervals = self.n_intervals
+        if self._overlap_frac <= 0.0:
             raise ValueError(
                 'The parameter overlap_frac is expected to be '
                 '> 0.0'
             )
-        if self.__overlap_frac > 0.5:
+        if self._overlap_frac > 0.5:
             warn_user(
                 'The parameter overlap_frac is expected to be <= 0.5'
             )
-        self.__min, self.__max, self.__delta = self._get_bounds(X)
-        radius = 1.0 / (2.0 - 2.0 * self.__overlap_frac)
-        self.__cover = BallCover(
+        self._min, self._max, self._delta = self._get_bounds(X)
+        radius = 1.0 / (2.0 - 2.0 * self._overlap_frac)
+        self._cover = BallCover(
             radius,
             metric=_Pullback(self._gamma_n, chebyshev()),
             kind=self.kind,
             leaf_capacity=self.leaf_capacity,
             leaf_radius=self.leaf_radius,
             pivoting=self.pivoting,
         )
-        self.__cover.fit(X)
+        self._cover.fit(X)
         return self
 
     def search(self, x):
@@ -338,43 +334,68 @@ def search(self, x):
         :rtype: list[int]
         """
         center = self._phi(x)
-        return self.__cover.search(center)
-
-    def _get_center(self, x):
-        offset = self._offset(x)
-        center = self._phi(x)
-        return tuple(offset), center
+        return self._cover.search(center)
 
-    def _get_overlap_frac(self, dim, overlap_vol_frac):
-        beta = math.pow(1.0 - overlap_vol_frac, 1.0 / dim)
-        return 1.0 - 1.0 / (2.0 - beta)
-
-    def _offset(self, x):
-        return np.minimum(self.__n_intervals - 1, np.floor(self._gamma_n(x)))
 
-    def _phi(self, x):
-        offset = self._offset(x)
-        return self._gamma_n_inv(0.5 + offset)
+class ProximityCubicalCover(BaseCubicalCover, Proximity):
+    """
+    Cover algorithm based on the `cubical proximity function`, which covers
+    data with open hypercubes of uniform size and overlap. The cubical cover is
+    obtained by selecting a subsect of all the hypercubes that intersect the
+    dataset using proximity net (see :class:`tdamapper.core.Proximity`).
+    For an open cover containing all the hypercubes interecting the dataset
+    use :class:`tdamapper.core.StandardCubicalCover`.
 
-    def _gamma_n(self, x):
-        return self.__n_intervals * (x - self.__min) / self.__delta
+    A hypercube is a multidimensional generalization of a square or a cube.
+    The size and overlap of the hypercubes are determined by the number of
+    intervals and the overlap fraction parameters. This class maps each point
+    to the hypercube with the nearest center.
 
-    def _gamma_n_inv(self, x):
-        return self.__min + self.__delta * x / self.__n_intervals
+    :param n_intervals: The number of intervals to use for each dimension.
+        Must be positive and less than or equal to the length of the dataset.
+        Defaults to 1.
+    :type n_intervals: int
+    :param overlap_frac: The fraction of overlap between adjacent intervals on
+        each dimension, must be in the range (0.0, 0.5]. If not specified, the
+        overlap_frac is computed such that the volume of the overlap within
+        each hypercube is half the total volume. Defaults to None.
+    :type overlap_frac: float
+    :param kind: Specifies whether to use a flat or a hierarchical vantage
+        point tree. Acceptable values are 'flat' or 'hierarchical'. Defaults to
+        'flat'.
+    :type kind: str
+    :param leaf_capacity: The maximum number of points in a leaf node of the
+        vantage point tree. Must be a positive value. Defaults to 1.
+    :type leaf_capacity: int
+    :param leaf_radius: The radius of the leaf nodes. If not specified, it
+        defaults to the value of `radius`. Must be a positive value. Defaults
+        to None.
+    :type leaf_radius: float, optional
+    :param pivoting: The method used for pivoting in the vantage point tree.
+        Acceptable values are None, 'random', or 'furthest'. Defaults to None.
+    :type pivoting: str or callable, optional
+    """
 
-    def _get_bounds(self, X):
-        if (X is None) or len(X) == 0:
-            return
-        _min, _max = X[0], X[0]
-        eps = np.finfo(np.float64).eps
-        _min = np.min(X, axis=0)
-        _max = np.max(X, axis=0)
-        _delta = _max - _min
-        _delta[(_delta >= -eps) & (_delta <= eps)] = self.__n_intervals
-        return _min, _max, _delta
+    def __init__(
+        self,
+        n_intervals=1,
+        overlap_frac=None,
+        kind='flat',
+        leaf_capacity=1,
+        leaf_radius=None,
+        pivoting=None,
+    ):
+        super().__init__(
+            n_intervals=n_intervals,
+            overlap_frac=overlap_frac,
+            kind=kind,
+            leaf_capacity=leaf_capacity,
+            leaf_radius=leaf_radius,
+            pivoting=pivoting,
+        )
 
 
-class StandardCubicalCover(ProximityCubicalCover):
+class StandardCubicalCover(BaseCubicalCover, Cover):
     """
     Cover algorithm based on the standard open cover, which covers data with
     open hypercubes of uniform size and overlap. The standard cover is
@@ -521,7 +542,7 @@ def __init__(
         self.leaf_radius = leaf_radius
         self.pivoting = pivoting
 
-    def __get_cubical_cover(self):
+    def _get_cubical_cover(self):
         params = dict(
             n_intervals=self.n_intervals,
             overlap_frac=self.overlap_frac,
@@ -552,8 +573,8 @@ def fit(self, X):
         :return: The object itself.
         :rtype: self
         """
-        self.__cubical_cover = self.__get_cubical_cover()
-        self.__cubical_cover.fit(X)
+        self._cubical_cover = self._get_cubical_cover()
+        self._cubical_cover.fit(X)
         return self
 
     def search(self, x):
@@ -568,7 +589,7 @@ def search(self, x):
         :return: The indices of the neighbors contained in the dataset.
         :rtype: list[int]
         """
-        return self.__cubical_cover.search(x)
+        return self._cubical_cover.search(x)
 
     def apply(self, X):
         """
@@ -582,5 +603,5 @@ def apply(self, X):
         :return: A generator of lists of ids.
         :rtype: generator of lists of ints
         """
-        self.__cubical_cover = self.__get_cubical_cover()
-        return self.__cubical_cover.apply(X)
+        self._cubical_cover = self._get_cubical_cover()
+        return self._cubical_cover.apply(X)

tests/ball_tree.py

@@ -3,14 +3,39 @@
 
 class SkBallTree:
 
-    def __init__(self, X, metric='euclidean', leaf_capacity=1, leaf_radius=0.0, pivoting=None, **kwargs):
+    def __init__(
+        self,
+        X,
+        metric='euclidean',
+        leaf_capacity=1,
+        leaf_radius=0.0,
+        pivoting=None,
+        **kwargs,
+    ):
         self.__dataset = X
-        self.__ball_tree = BallTree(X, leaf_size=leaf_capacity, metric=metric, **kwargs)
+        self.__ball_tree = BallTree(
+            X,
+            leaf_size=leaf_capacity,
+            metric=metric,
+            **kwargs,
+        )
 
     def ball_search(self, point, eps, inclusive=True):
-        ids = self.__ball_tree.query_radius([point], eps, return_distance=False, count_only=False, sort_results=False)
+        ids = self.__ball_tree.query_radius(
+            [point],
+            eps,
+            return_distance=False,
+            count_only=False,
+            sort_results=False,
+        )
         return [self.__dataset[i] for i in ids[0]]
 
     def knn_search(self, point, k):
-        ids = self.__ball_tree.query([point], k=k, return_distance=False, dualtree=False, breadth_first=False)
+        ids = self.__ball_tree.query(
+            [point],
+            k=k,
+            return_distance=False,
+            dualtree=False,
+            breadth_first=False,
+        )
         return [self.__dataset[i] for i in ids[0]]