multipers 2.7.0b4__tar.gz → 2.7.0b5__tar.gz

{multipers-2.7.0b4 → multipers-2.7.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.7.0b4
+Version: 2.7.0b5
 Summary: Multiparameter Topological Persistence for Machine Learning
 Keywords: TDA,Persistence,Multiparameter,sklearn,autodiff
 Author-Email: David Loiseaux <david.lapous@proton.me>, Hannah Schreiber <hannah.schreiber@inria.fr>
@@ -84,22 +84,25 @@ This library features a bunch of different functions and helpers. See below for
 <br>Filled box refers to implemented or interfaced code.
  - [x] [[Multiparameter Module Approximation, JACT]](https://doi.org/10.1007/s41468-025-00222-y) provides the multiparameter simplicial structure, as well as technics for approximating modules, via interval-decomposable modules. It is also very useful for visualization.
  - [x] [[Stable Vectorization of Multiparameter Persistent Homology using Signed Barcodes as Measures, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/d75c474bc01735929a1fab5d0de3b189-Abstract-Conference.html) provides fast representations of multiparameter persistence modules, by using their signed barcodes decompositions encoded into signed measures. Implemented decompositions : Euler surfaces, Hilbert function, rank invariant (i.e. rectangles). It also provides representation technics for Machine Learning, i.e., Sliced Wasserstein kernels, and Vectorizations.
- - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Currently implemented as an extension of MMA.
+ - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Implemented as an extension of MMA.
  - [x] [[Differentiability and Optimization of Multiparameter Persistent Homology, ICML2024]](https://proceedings.mlr.press/v235/scoccola24a.html) An approach to compute a (clarke) gradient for any reasonable multiparameter persistent invariant. Currently, any `multipers` computation is auto-differentiable using this strategy, provided that the input are pytorch gradient capable tensor.
  - [x] [[Multiparameter Persistence Landscapes, JMLR]](https://jmlr.org/papers/v21/19-054.html) A vectorization technic for multiparameter persistence modules.
  - [x] [[Filtration-Domination in Bifiltered Graphs, ALENEX2023]](https://doi.org/10.1137/1.9781611977561.ch3) Allows for 2-parameter edge collapses for 1-critical clique complexes. Very useful to speed up, e.g., Rips-Codensity bifiltrations.
  - [x] [[Fast free resolutions of bifiltered chain complexes]](https://arxiv.org/abs/2512.08652) One-critical representation of multicritical filtrations, using [multi_critical](https://bitbucket.org/mkerber/multi_critical).
  - [x] [[Chunk Reduction for Multi-Parameter Persistent Homology, SoCG2019]](https://doi.org/10.4230/LIPIcs.SoCG.2019.37) Multi-filtration preprocessing algorithm for homology computations.
  - [x] [[Computing Minimal Presentations and Bigraded Betti Numbers of 2-Parameter Persistent Homology, JAAG]](https://doi.org/10.1137/20M1388425) Minimal presentation of multiparameter persistence modules, using [mpfree](https://bitbucket.org/mkerber/mpfree/src/master/). Hilbert, Rank Decomposition Signed Measures, and MMA decompositions can be computed using the mpfree backend.
- - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances.
+ - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances ([[paper]](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.SoCG.2020.53))
  - [x] [[Decomposing Multiparameter Persistence Modules, SoCG2025]](https://doi.org/10.4230/LIPIcs.SoCG.2025.41) Using the [AIDA](https://github.com/JanJend/AIDA) and [Persistence-Algebra](https://github.com/JanJend/Persistence-Algebra/) libraries.
  - [x] [[Delaunay Bifiltrations of Functions on Point Clouds, SODA2024]](https://epubs.siam.org/doi/10.1137/1.9781611977912.173) Provides an alternative to function rips bifiltrations, using Delaunay complexes. Very good alternative to Rips-Density like bifiltrations.
- - [x] [[Delaunay Core Bifiltration]](https://arxiv.org/abs/2405.01214) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
+ - [x] [[Delaunay Core Bifiltration, JACT]](https://doi.org/10.1007/s41468-025-00226-8) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
  - [x] [[Computing the Multicover Bifiltration, SOCG2021]](https://doi.org/10.4230/LIPIcs.SoCG.2021.27) Rhomboid Tiling bifiltration. Equivalent to the multicover bifiltration, using [rhomboidtiling](https://github.com/geoo89/rhomboidtiling).
- - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence
+ - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence. 
  - [x] [[Kernel Operations on the GPU, with Autodiff, without Memory Overflows, JMLR]](http://jmlr.org/papers/v22/20-275.html) Although not linked, at first glance, to persistence in any way, this library allows computing blazingly fast signed measures convolutions (and more!) with custom kernels. 
- - [x] [[Projected distances for multi-parameter persistence modules]](https://arxiv.org/abs/2206.08818) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes. Implementation is a WIP.
+ - [x] [[Projected distances for multi-parameter persistence modules, Institut Fourier]](https://aif.centre-mersenne.org/articles/10.5802/aif.3752/) and [[Computation of $\gamma$-linear projected barcodes, JACT]](https://doi.org/10.1007/s41468-025-00209-9) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes.
  - [x] [[Efficient Two-Parameter Persistence Computation via Cohomology, SoCG2023]](https://doi.org/10.4230/LIPIcs.SoCG.2023.15) Minimal presentations for 2-parameter persistence algorithm.
+ - [x] [[deg_rips]](https://bitbucket.org/mkerber/deg_rips) Efficient implementation of the DegreeRips bifiltration. Alternative to the multipers-native one.
+ - [ ] [[Multiscale Clusterings BiFiltration, ICLR2026]](https://openreview.net/forum?id=E7D6uybODJ) WIP implementation. 
+
 
 If I missed something, or you want to add something, feel free to open an issue.
 

{multipers-2.7.0b4 → multipers-2.7.0b5}/README.md

@@ -45,22 +45,25 @@ This library features a bunch of different functions and helpers. See below for
 <br>Filled box refers to implemented or interfaced code.
  - [x] [[Multiparameter Module Approximation, JACT]](https://doi.org/10.1007/s41468-025-00222-y) provides the multiparameter simplicial structure, as well as technics for approximating modules, via interval-decomposable modules. It is also very useful for visualization.
  - [x] [[Stable Vectorization of Multiparameter Persistent Homology using Signed Barcodes as Measures, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/d75c474bc01735929a1fab5d0de3b189-Abstract-Conference.html) provides fast representations of multiparameter persistence modules, by using their signed barcodes decompositions encoded into signed measures. Implemented decompositions : Euler surfaces, Hilbert function, rank invariant (i.e. rectangles). It also provides representation technics for Machine Learning, i.e., Sliced Wasserstein kernels, and Vectorizations.
- - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Currently implemented as an extension of MMA.
+ - [x] [[A Framework for Fast and Stable Representations of Multiparameter Persistent Homology Decompositions, NeurIPS2023]](https://proceedings.neurips.cc/paper_files/paper/2023/hash/702b67152ec4435795f681865b67999c-Abstract-Conference.html) Provides a vectorization framework for interval decomposable modules, for Machine Learning. Implemented as an extension of MMA.
  - [x] [[Differentiability and Optimization of Multiparameter Persistent Homology, ICML2024]](https://proceedings.mlr.press/v235/scoccola24a.html) An approach to compute a (clarke) gradient for any reasonable multiparameter persistent invariant. Currently, any `multipers` computation is auto-differentiable using this strategy, provided that the input are pytorch gradient capable tensor.
  - [x] [[Multiparameter Persistence Landscapes, JMLR]](https://jmlr.org/papers/v21/19-054.html) A vectorization technic for multiparameter persistence modules.
  - [x] [[Filtration-Domination in Bifiltered Graphs, ALENEX2023]](https://doi.org/10.1137/1.9781611977561.ch3) Allows for 2-parameter edge collapses for 1-critical clique complexes. Very useful to speed up, e.g., Rips-Codensity bifiltrations.
  - [x] [[Fast free resolutions of bifiltered chain complexes]](https://arxiv.org/abs/2512.08652) One-critical representation of multicritical filtrations, using [multi_critical](https://bitbucket.org/mkerber/multi_critical).
  - [x] [[Chunk Reduction for Multi-Parameter Persistent Homology, SoCG2019]](https://doi.org/10.4230/LIPIcs.SoCG.2019.37) Multi-filtration preprocessing algorithm for homology computations.
  - [x] [[Computing Minimal Presentations and Bigraded Betti Numbers of 2-Parameter Persistent Homology, JAAG]](https://doi.org/10.1137/20M1388425) Minimal presentation of multiparameter persistence modules, using [mpfree](https://bitbucket.org/mkerber/mpfree/src/master/). Hilbert, Rank Decomposition Signed Measures, and MMA decompositions can be computed using the mpfree backend.
- - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances.
+ - [x] [[Hera]](https://github.com/anigmetov/hera) Matching distance between 2-parameter presentations, 1-parameter bottleneck/wasserstein distances ([[paper]](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.SoCG.2020.53))
  - [x] [[Decomposing Multiparameter Persistence Modules, SoCG2025]](https://doi.org/10.4230/LIPIcs.SoCG.2025.41) Using the [AIDA](https://github.com/JanJend/AIDA) and [Persistence-Algebra](https://github.com/JanJend/Persistence-Algebra/) libraries.
  - [x] [[Delaunay Bifiltrations of Functions on Point Clouds, SODA2024]](https://epubs.siam.org/doi/10.1137/1.9781611977912.173) Provides an alternative to function rips bifiltrations, using Delaunay complexes. Very good alternative to Rips-Density like bifiltrations.
- - [x] [[Delaunay Core Bifiltration]](https://arxiv.org/abs/2405.01214) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
+ - [x] [[Delaunay Core Bifiltration, JACT]](https://doi.org/10.1007/s41468-025-00226-8) Bifiltration for point clouds, taking into account the density. Similar to Rips-Density. 
  - [x] [[Computing the Multicover Bifiltration, SOCG2021]](https://doi.org/10.4230/LIPIcs.SoCG.2021.27) Rhomboid Tiling bifiltration. Equivalent to the multicover bifiltration, using [rhomboidtiling](https://github.com/geoo89/rhomboidtiling).
- - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence
+ - [x] [[Rivet]](https://github.com/rivetTDA/rivet) Interactive two parameter persistence. 
  - [x] [[Kernel Operations on the GPU, with Autodiff, without Memory Overflows, JMLR]](http://jmlr.org/papers/v22/20-275.html) Although not linked, at first glance, to persistence in any way, this library allows computing blazingly fast signed measures convolutions (and more!) with custom kernels. 
- - [x] [[Projected distances for multi-parameter persistence modules]](https://arxiv.org/abs/2206.08818) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes. Implementation is a WIP.
+ - [x] [[Projected distances for multi-parameter persistence modules, Institut Fourier]](https://aif.centre-mersenne.org/articles/10.5802/aif.3752/) and [[Computation of $\gamma$-linear projected barcodes, JACT]](https://doi.org/10.1007/s41468-025-00209-9) Provides a strategy to estimate the convolution distance between multiparameter persistence module using projected barcodes.
  - [x] [[Efficient Two-Parameter Persistence Computation via Cohomology, SoCG2023]](https://doi.org/10.4230/LIPIcs.SoCG.2023.15) Minimal presentations for 2-parameter persistence algorithm.
+ - [x] [[deg_rips]](https://bitbucket.org/mkerber/deg_rips) Efficient implementation of the DegreeRips bifiltration. Alternative to the multipers-native one.
+ - [ ] [[Multiscale Clusterings BiFiltration, ICLR2026]](https://openreview.net/forum?id=E7D6uybODJ) WIP implementation. 
+
 
 If I missed something, or you want to add something, feel free to open an issue.
 

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/_hera_interface.cpp

@@ -95,10 +95,8 @@ diagram_t diagram_from_handle(nb::handle h, bool drop_diagonal = false) {
   diagram_t out;
   out.reserve(static_cast<std::size_t>(diagram.shape(0)));
 
-  const auto row_stride = static_cast<std::ptrdiff_t>(diagram.stride(0)) /
-                          static_cast<std::ptrdiff_t>(sizeof(double));
-  const auto col_stride = static_cast<std::ptrdiff_t>(diagram.stride(1)) /
-                          static_cast<std::ptrdiff_t>(sizeof(double));
+  const auto row_stride = static_cast<std::ptrdiff_t>(diagram.stride(0));
+  const auto col_stride = static_cast<std::ptrdiff_t>(diagram.stride(1));
   const auto* values = diagram.data();
   for (std::ptrdiff_t i = 0; i < static_cast<std::ptrdiff_t>(diagram.shape(0)); ++i) {
     const double birth = values[i * row_stride];

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/_mma_nanobind.cpp

@@ -80,17 +80,55 @@ nb::tuple dump_summand(const Gudhi::multi_persistence::Summand<T>& summand) {
 }
 
 template <typename T>
-nb::tuple barcode_to_python(
-    const std::vector<std::vector<typename Gudhi::multi_persistence::Module<T>::Bar>>& barcode) {
-  return tuple_from_size(barcode.size(), [&](size_t dim) -> nb::object {
-    const auto& bars = barcode[dim];
+nb::tuple batched_barcode_to_python(
+    const std::vector<std::vector<typename Gudhi::multi_persistence::Module<T>::Bar>>& barcodes,
+    size_t num_lines,
+    bool keep_inf) {
+  constexpr T inf = std::numeric_limits<T>::infinity();
+  return tuple_from_size(barcodes.size(), [&](size_t dim) -> nb::object {
+    const auto& bars = barcodes[dim];
+    if (num_lines == 0) {
+      auto split_indices = owned_array<uint64_t>(std::vector<uint64_t>{}, {size_t(0)});
+      if (keep_inf) {
+        return nb::make_tuple(owned_array<T>(std::vector<T>{}, {size_t(0), size_t(0), size_t(2)}), split_indices);
+      }
+      return nb::make_tuple(owned_array<T>(std::vector<T>{}, {size_t(0), size_t(2)}), split_indices);
+    }
+    if (bars.size() % num_lines != 0) {
+      throw std::runtime_error("Barcodes along different lines do not have a consistent shape.");
+    }
+
+    const size_t bars_per_line = bars.size() / num_lines;
     std::vector<T> flat;
-    flat.reserve(bars.size() * 2);
-    for (const auto& bar : bars) {
-      flat.push_back(bar[0]);
-      flat.push_back(bar[1]);
+    if (keep_inf) {
+      flat.reserve(bars.size() * 2);
+      for (const auto& bar : bars) {
+        flat.push_back(bar[0]);
+        flat.push_back(bar[1]);
+      }
+      return nb::make_tuple(owned_array<T>(std::move(flat), {num_lines, bars_per_line, size_t(2)}),
+                            owned_array<uint64_t>(std::vector<uint64_t>{}, {size_t(0)}));
+    }
+
+    std::vector<uint64_t> split_indices;
+    split_indices.reserve(num_lines > 0 ? num_lines - 1 : 0);
+    uint64_t kept_count = 0;
+    for (size_t line = 0; line < num_lines; ++line) {
+      const size_t line_offset = line * bars_per_line;
+      for (size_t j = 0; j < bars_per_line; ++j) {
+        const auto& bar = bars[line_offset + j];
+        if (bar[0] < inf) {
+          flat.push_back(bar[0]);
+          flat.push_back(bar[1]);
+          ++kept_count;
+        }
+      }
+      if (line + 1 < num_lines) {
+        split_indices.push_back(kept_count);
+      }
     }
-    return nb::cast(owned_array<T>(std::move(flat), {bars.size(), size_t(2)}));
+    return nb::make_tuple(owned_array<T>(std::move(flat), {static_cast<size_t>(kept_count), size_t(2)}),
+                          owned_array<uint64_t>(std::move(split_indices), {num_lines - 1}));
   });
 }
 
@@ -142,23 +180,30 @@ Gudhi::multi_persistence::Box<T> box_from_array(nb::ndarray<nb::numpy, const T,
 }
 
 template <typename T>
-Gudhi::multi_persistence::Line<T> line_from_vectors(const std::vector<T>& basepoint, const std::vector<T>* direction) {
-  return direction == nullptr ? Gudhi::multi_persistence::Line<T>(basepoint)
-                              : Gudhi::multi_persistence::Line<T>(basepoint, *direction);
-}
+nb::tuple barcodes_from_lines_impl(Gudhi::multi_persistence::Module<T>& self,
+                                   const std::vector<std::vector<T>>& basepoints,
+                                   const std::vector<std::vector<T>>& directions,
+                                   int degree,
+                                   bool keep_inf) {
+  if (basepoints.size() != directions.size()) {
+    throw std::runtime_error("Basepoints and directions must contain the same number of lines.");
+  }
 
-template <typename T>
-nb::tuple barcode_from_line_impl(Gudhi::multi_persistence::Module<T>& self,
-                                 const std::vector<T>& basepoint,
-                                 const std::vector<T>* direction,
-                                 int degree) {
-  auto line = line_from_vectors(basepoint, direction);
-  decltype(self.get_barcode_from_line(line, degree)) barcode;
+  std::vector<Gudhi::multi_persistence::Line<T>> lines;
+  lines.reserve(basepoints.size());
+  for (size_t i = 0; i < basepoints.size(); ++i) {
+    if (basepoints[i].size() != directions[i].size()) {
+      throw std::runtime_error("Basepoints and directions must have the same number of parameters.");
+    }
+    lines.emplace_back(basepoints[i], directions[i]);
+  }
+
+  decltype(self.get_barcodes_from_set_of_lines(lines, degree)) barcodes;
   {
     nb::gil_scoped_release release;
-    barcode = self.get_barcode_from_line(line, degree);
+    barcodes = self.get_barcodes_from_set_of_lines(lines, degree);
   }
-  return barcode_to_python<T>(barcode);
+  return batched_barcode_to_python<T>(barcodes, lines.size(), keep_inf);
 }
 
 template <typename T, class GridRange>
@@ -483,22 +528,19 @@ void bind_float_module_methods(Class& cls) {
     using Module = Gudhi::multi_persistence::Module<T>;
 
     cls.def(
-           "_get_barcode_from_line",
-           [](Module& self,
-              nb::ndarray<nb::numpy, const T, nb::ndim<1>, nb::c_contig> basepoint,
-              nb::object direction,
-              int degree) -> nb::tuple {
-             auto basepoint_values = vector_from_array(basepoint);
-             if (direction.is_none()) {
-               return barcode_from_line_impl<T>(self, basepoint_values, nullptr, degree);
-             }
-             auto direction_array = nb::cast<nb::ndarray<nb::numpy, const T, nb::ndim<1>, nb::c_contig>>(direction);
-             auto direction_values = vector_from_array(direction_array);
-             return barcode_from_line_impl<T>(self, basepoint_values, &direction_values, degree);
-           },
-           "basepoint"_a,
-           "direction"_a = nb::none(),
-           "degree"_a = -1)
+            "_get_barcodes_from_lines",
+            [](Module& self,
+               nb::ndarray<nb::numpy, const T, nb::ndim<2>, nb::c_contig> basepoints,
+               nb::ndarray<nb::numpy, const T, nb::ndim<2>, nb::c_contig> directions,
+               int degree,
+               bool keep_inf) -> nb::tuple {
+              return barcodes_from_lines_impl<T>(
+                  self, matrix_from_array(basepoints), matrix_from_array(directions), degree, keep_inf);
+            },
+            "basepoints"_a,
+            "directions"_a,
+            "degree"_a = -1,
+            "keep_inf"_a = true)
         .def(
             "evaluate_in_grid",
             [](Module& self, nb::handle grid_handle) -> Module& {

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/_signed_measure_meta.py

@@ -46,8 +46,8 @@ def signed_measure(
     Computes the signed measures given by the decomposition of the hilbert
     function or the euler characteristic, or the rank invariant.
 
-    Input
-    -----
+    Parameters
+    ----------
      - filtered_complex: given by a simplextree or a slicer.
      - degree:int|None / degrees:list[int] the degrees to compute.
        None represents the euler characteristic.
@@ -83,6 +83,17 @@ def signed_measure(
     `[signed_measure_of_degree for degree in degrees]`
     with `signed_measure_of_degree` of the form `(dirac location, dirac weights)`.
 
+    References
+    ----------
+    Loiseaux, Carrière, Botnan, Oudot, and Scoccola, "Stable Vectorization of
+    Multiparameter Persistent Homology using Signed Barcodes as Measures",
+    Advances in Neural Information Processing Systems, 2023.
+
+    Scoccola, Setlur, Loiseaux, Carrière, and Oudot, "Differentiability and
+    Optimization of Multiparameter Persistent Homology", Proceedings of the
+    41st International Conference on Machine Learning, PMLR 235:43986-44011,
+    2024.
+
     Notes on computational backends
     -------------------------------
     There are several backends for each of these computations.

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/array_api/jax.py

@@ -75,6 +75,12 @@ def logsumexp(x, axis=None, dim=None, keepdims=False, keepdim=None):
     return _jsp_special.logsumexp(x, axis=axis, keepdims=keepdim)
 
 
+def cumsum(x, axis=None, dim=None, **kwargs):
+    if axis is None:
+        axis = dim
+    return _jnp.cumsum(x, axis=axis, **kwargs)
+
+
 def norm(x, axis=None, dim=None, **kwargs):
     if axis is None:
         axis = dim

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/array_api/numpy.py

@@ -142,6 +142,12 @@ def logsumexp(x, axis=None, dim=None, keepdims=False, keepdim=None):
     return _sp_logsumexp(x, axis=axis, keepdims=keepdim)
 
 
+def cumsum(x, axis=None, dim=None, **kwargs):
+    if axis is None:
+        axis = dim
+    return _np.cumsum(x, axis=axis, **kwargs)
+
+
 def norm(x, axis=None, dim=None, **kwargs):
     if axis is None:
         axis = dim
@@ -233,7 +239,7 @@ def set_at(x, idx, y):
 
 
 def add_at(x, idx, y):
-    x[idx] += y
+    _np.add.at(x, idx, y)
     return x
 
 

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/array_api/torch.py

@@ -96,6 +96,12 @@ def logsumexp(x, axis=None, dim=None, keepdims=False, keepdim=None):
     return _torch.logsumexp(x, dim=dim, keepdim=keepdim)
 
 
+def cumsum(x, axis=None, dim=None, **kwargs):
+    if dim is None:
+        dim = axis
+    return _torch.cumsum(x, dim=dim, **kwargs)
+
+
 def norm(x, axis=None, dim=None, **kwargs):
     if dim is None:
         dim = axis
@@ -184,6 +190,10 @@ def set_at(x, idx, y):
 
 
 def add_at(x, idx, y):
+    if not isinstance(idx, tuple):
+        idx = (idx,)
+    if all(isinstance(i, _torch.Tensor) for i in idx):
+        return x.index_put_(idx, y, accumulate=True)
     x[idx] += y
     return x
 

{multipers-2.7.0b4 → multipers-2.7.0b5}/multipers/data/MOL2.py

@@ -1,4 +1,5 @@
 import os
+import warnings
 from os import listdir
 from os.path import expanduser
 from typing import Iterable
@@ -8,7 +9,8 @@ import MDAnalysis as mda
 import numpy as np
 import pandas as pd
 from joblib import Parallel, delayed
-from MDAnalysis.topology.guessers import guess_masses
+from MDAnalysis.exceptions import NoDataError
+from MDAnalysis.guesser import tables as mda_tables
 from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.preprocessing import LabelEncoder
 
@@ -22,6 +24,60 @@ JC_path = DATASET_PATH + "Cleves-Jain/"
 DUDE_path = DATASET_PATH + "DUD-E/"
 
 
+def _load_molecule(path: str | mda.Universe):
+    if isinstance(path, mda.Universe):
+        return path
+
+    kwargs = {"to_guess": ()} if path.lower().endswith(".mol2") else {}
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message=r"Unknown elements found for some atoms: .*",
+            category=UserWarning,
+            module=r"MDAnalysis\.topology\.MOL2Parser",
+        )
+        return mda.Universe(path, **kwargs)
+
+
+def _mass_labels(molecule: mda.Universe):
+    labels = np.asarray(molecule.atoms.types, dtype=object).copy()
+    try:
+        elements = np.asarray(molecule.atoms.elements, dtype=object)
+    except NoDataError:
+        elements = None
+
+    if elements is not None:
+        has_element = elements != ""
+        labels[has_element] = elements[has_element]
+
+    return np.asarray(
+        [label.split(".", 1)[0] if isinstance(label, str) else label for label in labels],
+        dtype=object,
+    )
+
+
+def _lookup_masses(labels):
+    masses = np.zeros(len(labels), dtype=np.float64)
+    for i, label in enumerate(labels):
+        label = str(label)
+        masses[i] = mda_tables.masses.get(
+            label, mda_tables.masses.get(label.upper(), 0.0)
+        )
+    return masses
+
+
+def _atom_masses(molecule: mda.Universe):
+    try:
+        masses = molecule.atoms.masses.copy()
+    except NoDataError:
+        masses = np.zeros(molecule.atoms.n_atoms, dtype=np.float64)
+
+    null_indices = masses == 0
+    if np.any(null_indices):
+        masses[null_indices] = _lookup_masses(_mass_labels(molecule)[null_indices])
+    return masses
+
+
 # pathes = get_data_path()
 # imgs = apply_pipeline(pathes=pathes, pipeline=pipeline_img)
 # distances_to_letter, ytest = img_distances(imgs)
@@ -253,7 +309,8 @@ def lines2bonds(
 
 
 def lines2bonds_MOL2(mol: mda.Universe):
-    _lines = open(mol.filename, "r").readlines()
+    with open(mol.filename, "r") as molecule_file:
+        _lines = molecule_file.readlines()
     out = []
     index = 0
     while index < len(_lines) and _lines[index].strip() != "@<TRIPOS>BOND":
@@ -281,7 +338,7 @@ def lines2bonds_PDB(mol: mda.Universe):
 def _mol2graphst(
     path: str | mda.Universe, filtrations: Iterable[str], molecule_format=None
 ):
-    molecule = path if isinstance(path, mda.Universe) else mda.Universe(path)
+    molecule = _load_molecule(path)
 
     num_filtrations = len(filtrations)
     nodes = molecule.atoms.indices.reshape(1, -1)
@@ -320,12 +377,7 @@ def _mol2graphst(
                 charges = molecule.atoms.charges
                 st.fill_lowerstar(charges, parameter=i)
             case "atomic_mass":
-                masses = molecule.atoms.masses
-                null_indices = masses == 0
-                if np.any(null_indices):  # guess if necessary
-                    masses[null_indices] = guess_masses(molecule.atoms.types)[
-                        null_indices
-                    ]
+                masses = _atom_masses(molecule)
                 st.fill_lowerstar(-masses, parameter=i)
             case _:
                 pass
@@ -342,7 +394,7 @@ def _mol2ripsst(
     import gudhi as gd
 
     assert "bond_length" == filtrations[0], "Bond length has to be first for rips."
-    molecule = path if isinstance(path, mda.Universe) else mda.Universe(path)
+    molecule = _load_molecule(path)
     num_parameters = len(filtrations)
     st_rips = gd.RipsComplex(
         points=molecule.atoms.positions, max_edge_length=threshold
@@ -391,12 +443,7 @@ def _mol2ripsst(
                 charges = molecule.atoms.charges
                 st.fill_lowerstar(charges, parameter=i)
             case "atomic_mass":
-                masses = molecule.atoms.masses
-                null_indices = masses == 0
-                if np.any(null_indices):  # guess if necessary
-                    masses[null_indices] = guess_masses(molecule.atoms.types)[
-                        null_indices
-                    ]
+                masses = _atom_masses(molecule)
                 # print(masses)
                 st.fill_lowerstar(-masses, parameter=i)
             case _:
@@ -442,7 +489,7 @@ class Molecule2SimplexTree(BaseEstimator, TransformerMixin):
     def fit(self, X: Iterable[str], y=None):
         if len(X) == 0:
             return self
-        test_mol = mda.Universe(X[0])
+        test_mol = _load_molecule(X[0])
         self._molecule_format = test_mol.filename.split(".")[-1].lower()
         return self