Clean pydocstyle CI/CD

Author: pchlenski

.github/workflows/test.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Check docstrings are in Google style      
       - name: Check docstrings are in Google style
-        run: pydocstyle manify/ --convention=google
+        run: pydocstyle --add-ignore=D107 --convention=google manify/
         continue-on-error: true
 
       # Code coverage

manify/curvature_estimation/delta_hyperbolicity.py

@@ -1,4 +1,4 @@
-"""Methods for computing $\delta$-hyperbolicity of a metric space.
+r"""Methods for computing $\delta$-hyperbolicity of a metric space.
 
 The $\delta$-hyperbolicity measures how close a metric space is to a tree. The value $\delta \geq 0$ is a global
 property; smaller values indicate the space is more hyperbolic.
@@ -83,7 +83,6 @@ def delta_hyperbolicity(
     Returns:
         delta: Either the maximum $\delta$ value (if full=False) or the full $\delta$ tensor.
     """
-
     n = D.shape[0]
     w = reference_idx
 

manify/embedders/_losses.py

@@ -40,7 +40,6 @@ def distortion_loss(
         This is similar to the `square_loss` in HazyResearch hyperbolics repository:
         https://github.com/HazyResearch/hyperbolics/blob/master/pytorch/hyperbolic_models.py#L178
     """
-
     # Turn into flat vectors of pairwise distances. For pairwise distances, we only consider the upper triangle.
     if pairwise:
         n = D_true.shape[0]
@@ -67,15 +66,13 @@ def d_avg(
     r"""Computes the average relative distance error (D_avg).
 
     The average distance error is the mean relative error between the estimated and true distances:
-
     $$
         D_{\text{avg}} = \frac{1}{N} \sum_{i,j} \frac{
             |D_{\text{est}}(i,j) - D_{\text{true}}(i,j)|
         }{
             D_{\text{true}}(i,j)
         },
     $$
-
     where $N$ is the number of distances being considered. This metric provides a normalized measure of how accurately
     the embedding preserves the original distances.
 
@@ -87,7 +84,6 @@ def d_avg(
     Returns:
         d_avg: Scalar tensor representing the average relative distance error.
     """
-
     if pairwise:
         n = D_true.shape[0]
         idx = torch.triu_indices(n, n, offset=1)

manify/embedders/coordinate_learning.py

@@ -29,10 +29,11 @@
 
 
 class CoordinateLearning(BaseEmbedder):
-    """
-    This embedder implements the approach described in Gu et al., "Learning Mixed-Curvature
-    Representations in Product Spaces". It directly optimizes point coordinates to preserve
-    a given distance matrix, using Riemannian optimization techniques.
+    """Coordinate learning method class.
+
+    This embedder implements the approach described in Gu et al., "Learning Mixed-Curvature Representations in Product
+    Spaces". It directly optimizes point coordinates to preserve a given distance matrix, using Riemannian optimization
+    techniques.
 
     Trains point coordinates in a product manifold to match target distances.
 
@@ -222,8 +223,9 @@ def transform(self, X: None = None) -> Float[torch.Tensor, "n_points embedding_d
     def fit_transform(  # type: ignore[override]
         self, X: None, D: Float[torch.Tensor, "n_points n_points"], **fit_kwargs: Any
     ) -> Float[torch.Tensor, "n_points embedding_dim"]:
-        """Transform data using learned embedding based on the provided distance matrix D. Overrides the base class
-        method `BaseEmbedder.fit_transform()` to not use the input data X.
+        """Transform data using learned embedding based on the provided distance matrix D.
+
+        This method overrides the base class method `BaseEmbedder.fit_transform()` to not use the input data X.
 
         Args:
             X: Ignored.

manify/embedders/vae.py

@@ -371,7 +371,6 @@ def transform(
         Returns:
             embeddings: Learned embeddings.
         """
-
         # Set random state
         if self.random_state is not None:
             torch.manual_seed(self.random_state)

manify/manifolds.py

@@ -263,7 +263,7 @@ def log_likelihood(
         mu: Optional[Float[torch.Tensor, "n_points n_ambient_dim"]] = None,
         sigma: Optional[Float[torch.Tensor, "n_points n_dim n_dim"]] = None,
     ) -> Float[torch.Tensor, "n_points,"]:
-        """Compute probability density function for $\\mathcal{WN}(\\mathbf{z}; \\mu, \\Sigma)$ on the manifold.
+        r"""Compute probability density function for $\mathcal{WN}(\mathbf{z}; \mu, \Sigma)$ on the manifold.
 
         Args:
             z: Tensor of points on the manifold for which to compute the likelihood.
@@ -274,7 +274,6 @@ def log_likelihood(
             log_likelihoods: Tensor containing the log-likelihood of the points `z` under the distribution with mean
                 `mu` and covariance `sigma`.
         """
-
         # Default to mu=self.mu0 and sigma=I
         if mu is None:
             mu = self.mu0
@@ -364,7 +363,6 @@ def stereographic(self, *points: Float[torch.Tensor, "n_points n_dim"]) -> Tuple
             stereo_manifold: The manifold in stereographic coordinates.
             stereo_points: The provided points converted to stereographic coordinates (if any).
         """
-
         if self.is_stereographic:
             print("Manifold is already in stereographic coordinates.")
             return self, *points

manify/predictors/__init__.py

@@ -1,5 +1,4 @@
-r"""
-Initialize predictors in the product space.
+r"""Initialize predictors in the product space.
 
 Implemented predictors include:
 ## Decision Trees and Random Forests: Use geodesic splits in product manifolds via projection angles and manifold-specific geodesic midpoints.

manify/predictors/_kernel.py

@@ -1,4 +1,4 @@
-"""Implementation for kernel matrix calculation"""
+"""Implementation for kernel matrix calculation."""
 
 from __future__ import annotations
 
@@ -15,8 +15,7 @@ def compute_kernel_and_norm_manifold(
     X_source: Float[torch.Tensor, "n_points_source n_dim"],
     X_target: Optional[Float[torch.Tensor, "n_points_target n_dim"]],
 ) -> Tuple[Float[torch.Tensor, "n_points_source n_points_target"], Float[torch.Tensor, ""]]:
-    """
-    Compute the kernel matrix between two sets of points in a given manifold.
+    """Compute the kernel matrix between two sets of points in a given manifold.
 
     Args:
         manifold: The manifold in which the computation occurs.
@@ -67,8 +66,7 @@ def product_kernel(
     List[Float[torch.Tensor, "n_points_source n_points_target"]],
     List[Float[torch.Tensor, ""]],
 ]:
-    """
-    Compute the kernel matrix between two sets of points in a product manifold.
+    """Compute the kernel matrix between two sets of points in a product manifold.
 
     Args:
         pm: The product manifold in which the computation occurs.

manify/predictors/_midpoint.py

@@ -1,4 +1,4 @@
-"""Compute the angular midpoints between two angular coordinates in different geometric spaces"""
+"""Compute the angular midpoints between two angular coordinates in different geometric spaces."""
 
 from __future__ import annotations
 
@@ -9,8 +9,7 @@
 
 
 def hyperbolic_midpoint(u: float, v: float, assert_hyperbolic: bool = False) -> Float[torch.Tensor, ""]:
-    """
-    Compute the hyperbolic midpoint between two angular coordinates u and v.
+    """Compute the hyperbolic midpoint between two angular coordinates u and v.
 
     Args:
         u: The first angular coordinate.
@@ -31,8 +30,7 @@ def hyperbolic_midpoint(u: float, v: float, assert_hyperbolic: bool = False) ->
 
 
 def is_hyperbolic_midpoint(u: float, v: float, m: float) -> bool:
-    """
-    Verifies if m is the true hyperbolic midpoint between u and v.
+    r"""Verify if $\mathbf{m}$ is the true hyperbolic midpoint between $\mathbf{u}$ and $\mathbf{v}$.
 
     Args:
         u (torch.Tensor): The first angular coordinate.
@@ -48,8 +46,7 @@ def is_hyperbolic_midpoint(u: float, v: float, m: float) -> bool:
 
 
 def spherical_midpoint(u: float, v: float) -> Float[torch.Tensor, ""]:
-    """
-    Compute the spherical midpoint between two angular coordinates u and v.
+    """Compute the spherical midpoint between two angular coordinates u and v.
 
     Args:
         u (torch.Tensor): The first angular coordinate.
@@ -62,24 +59,20 @@ def spherical_midpoint(u: float, v: float) -> Float[torch.Tensor, ""]:
 
 
 def euclidean_midpoint(u: float, v: float) -> Float[torch.Tensor, ""]:
-    """
-    Compute the euclidean midpoint between two angular coordinates u and v.
+    """Compute the euclidean midpoint between two angular coordinates u and v.
 
     Args:
         u (torch.Tensor): The first angular coordinate.
         v (torch.Tensor): The second angular coordinate.
 
     Returns:
-        torch.Tensor: The computed spherical midpoint between u and v.
+        torch.Tensor: The computed euclidean midpoint between u and v.
     """
     return torch.arctan2(torch.tensor(2.0), (1.0 / torch.tan(u) + 1.0 / torch.tan(v)))
 
 
 def midpoint(
-    u: Float[torch.Tensor, ""],
-    v: Float[torch.Tensor, ""],
-    manifold: Manifold,
-    special_first: bool = False,
+    u: Float[torch.Tensor, ""], v: Float[torch.Tensor, ""], manifold: Manifold, special_first: bool = False
 ) -> Float[torch.Tensor, ""]:
     """Compute the midpoint between two angular coordinates given the manifold type.