oineus 0.9.3__tar.gz

oineus-0.9.3/CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.14)
+
+project(oineus LANGUAGES CXX)
+
+option(oin_use_spdlog "Use spdlog" OFF)
+option(oin_use_jemalloc "Use jemalloc" OFF)
+option(oin_build_tests "Build tests" ON)
+option(oin_build_examples "Build examples" ON)
+option(oin_gather_add_stats "Gather statistics about summand sizes" OFF)
+option(oin_caliper "Enable profiling with Caliper" OFF)
+
+# Default to Release
+
+if (NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+find_package (Threads REQUIRED)
+find_package (TBB REQUIRED)
+find_package (Boost REQUIRED)
+find_package (Python3 COMPONENTS Interpreter Development REQUIRED)
+
+message(WARNING "executable ${Python3_EXECUTABLE}, ${Python_EXECUTABLE} ")
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+set (libraries ${libraries} ${CMAKE_THREAD_LIBS_INIT} TBB::tbb)
+
+if (oin_use_jemalloc)
+    set (libraries ${libraries} jemalloc)
+endif()
+
+if(oin_caliper)
+    find_package(Caliper REQUIRED)
+    add_compile_definitions (OINEUS_USE_CALIPER)
+    set(libraries ${libraries} caliper)
+endif()
+
+
+if (oin_build_examples)
+    add_subdirectory(examples)
+endif ()
+
+add_subdirectory(bindings/python)
+
+if (oin_build_tests)
+    add_subdirectory(extern/Catch2)
+    enable_testing()
+    add_subdirectory(tests)
+endif()

oineus-0.9.3/MANIFEST.in

@@ -0,0 +1,22 @@
+include CMakeLists.txt description.rst MANIFEST.in README.md licence.txt legal.txt
+include requirements.txt peru.yaml version.txt
+recursive-include bindings/python *
+recursive-exclude bindings/python/pybind11/docs *
+recursive-exclude bindings/python/pybind11/tests *
+recursive-include extern *
+recursive-include include/oineus *
+recursive-include src *
+recursive-include tests *
+recursive-include doc *
+global-exclude *.pyc *.swp
+prune .git
+recursive-exclude extern/Catch2 *
+recursive-exclude ./*venv* *
+recursive-exclude ./doc/_build *
+recursive-exclude ./dist *
+recursive-exclude *build* *
+recursive-exclude *venv* *
+recursive-exclude ./bindings/python/oineus/__pycache__ *
+recursive-exclude ./.peru *
+recursive-exclude ./.pytest_cache *
+recursive-exclude ./tests/__pycache__ *

oineus-0.9.3/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: oineus
+Version: 0.9.3
+Summary: Library for computing persistent homology
+Home-page: https://github.com/anigmetov/oineus
+Author: Arnur Nigmetov
+Author-email: anigmetov@lbl.gov
+License: BSD
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: License :: OSI Approved :: BSD License
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: eagerpy
+
+Oineus
+==========
+
+Oineus is a computational topology library that contains:
+
+* Shared-memory parallel algorithm to compute persistent homology.
+* Critical set method for topological optimization.
+* Zero-persistence diagrams.
+* Persistence kernel-image-cokernel computaton.
+
+Documentation
+-------------
+
+See docs/tutorial.md.

oineus-0.9.3/README.md

@@ -0,0 +1,89 @@
+## About
+Oineus is an implementation of shared-memory parallel
+computation of persistent homology published in
+*D. Morozov and A. Nigmetov.
+"Towards lockfree persistent homology."
+Proceedings of the 32nd ACM Symposium on Parallelism
+in Algorithms and Architectures. 2020.*
+
+It also contains an implementation of the critical set method
+from
+[*A. Nigmetov and D. Morozov,
+"Topological Optimization with Big Steps."
+arXiv preprint arXiv:2203.16748 (2022)."*](https://arxiv.org/abs/2203.16748)
+
+Currently it supports computation of lower-star persistence
+of scalar functions on regular grids or of user-defined
+filtrations (where each simplex needs to be created manually).
+It is written in C++ with python bindings (pybind11).
+
+## Compilation
+
+Oineus requires C++17 standard and python3.
+`Pybind11` is included as a submodule.
+Other dependencies are Boost and TBB,
+install them before compiling Oineus.
+E.g., on Ubuntu
+```shell
+$ sudo apt-get install libtbb-dev
+$ sudo apt-get install libboost-all-dev
+```
+
+
+After that compilation is standard:
+
+```shell
+$ git clone --recurse-submodules git@github.com:anigmetov/oineus.git
+$ cd oineus
+$ mkdir build
+$ cd build
+$ cmake ..
+$ make -j4
+```
+Compiled Oineus python package is located in `[build_directory]/python/bindings`.
+The `oineus` directory there contains the `__init__.py` and the binary
+with C++ bindings whose name is platform-dependent, say, `_oineus.cpython-311-x86_64-linux-gnu.so`.
+If you get an error similar to
+```
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "/home/narn/code/oineus/bindings/python/oineus/__init__.py", line 7, in <module>
+    from . import _oineus
+ImportError: cannot import name '_oineus' from partially initialized module 'oineus' (most likely due to a circular import) (/home/narn/code/oineus/bindings/python/oineus/__init__.py)
+```
+you are most probably trying to import Oineus from the source directory `oineus/bindings/python`,
+which contains only the `__init__.py`. Make sure that `PYTHONPATH` contains the directory `oineus/build/bindings/python`.
+
+Another possibility can be that Pybind11 did not pick up the correct Python
+executable. Suppose that you have system-wide Python, version 3.11,
+but you want to compile for your virtual environment, `venv` or `conda`,
+in which you have Python 3.9. Sometimes, even you activated your Python
+virtual environment, pybind11 chooses a different Python (you can see which one
+in the output of `cmake ..`; also, the name of the binary
+`_oineus.cpython-311-x86_64-linux-gnu.so` contains the version).
+In this case, remove CMakeCache.txt and run
+```shell
+$ cmake .. -DPYTHON_EXECUTABLE=path_to_correct_python
+```
+If the command `which python` shows you the right Python,
+   the easiest is
+```shell
+$ cmake .. -DPYTHON_EXECUTABLE=$(which python)
+```
+
+
+Python packages needed by Oineus are `numpy` and `scipy`. Some of the examples
+require `torch` for optimization and `matplotlib`, `plotly` and `dash` for
+visualization. File `requirements.txt` contains all of these; if you do not
+need to run examples, it is simpler to just `pip install numpy scipy` in your virtual
+environment.
+
+
+## Usage
+
+See [Tutorial](doc/tutorial.md).
+
+## License
+
+Oineus is a free program distributed under modified
+BSD license. See legal.txt for details.

oineus-0.9.3/bindings/python/CMakeLists.txt

@@ -0,0 +1,44 @@
+add_subdirectory(pybind11)
+
+if (CMAKE_LIBRARY_OUTPUT_DIRECTORY)        # to work with pip
+    set (MODULE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+else()
+    set (MODULE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+
+file (MAKE_DIRECTORY "${MODULE_OUTPUT_DIRECTORY}/oineus")
+file (GLOB OINEUS_PYTHON "${CMAKE_CURRENT_SOURCE_DIR}/oineus/*.py")
+
+add_custom_target           (oineus ALL ${CMAKE_COMMAND} -E copy_directory
+                                       ${CMAKE_CURRENT_SOURCE_DIR}/oineus ${MODULE_OUTPUT_DIRECTORY}/oineus
+                                       DEPENDS ${OINEUS_PYTHON})
+
+
+pybind11_add_module         (_oineus oineus.cpp
+                                     oineus_common.cpp
+                                     oineus_decomposition.cpp
+                                     oineus_index_diagram.cpp
+                                     oineus_fil_dgm_simplex_double.cpp
+                                     oineus_fil_dgm_simplex_float.cpp
+                                     oineus_functions_double.cpp
+                                     oineus_functions_float.cpp
+                                     oineus_top_optimizer.cpp
+                            )
+target_link_libraries       (_oineus PRIVATE ${libraries})
+target_include_directories  (_oineus PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../include"
+                                              "${CMAKE_CURRENT_SOURCE_DIR}/../../extern")
+set_target_properties       (_oineus PROPERTIES OUTPUT_NAME oineus/_oineus)
+
+if (oin_use_spdlog)
+    target_compile_definitions(_oineus PRIVATE -DOINEUS_USE_SPDLOG)
+endif()
+
+if (oin_gather_add_stats)
+    target_compile_definitions(_oineus PRIVATE -DOINEUS_GATHER_ADD_STATS)
+endif()
+
+if(oin_build_tests)
+    add_custom_target       (oineus_copy_to_tests ALL
+            ${CMAKE_COMMAND} -E copy_directory ${MODULE_OUTPUT_DIRECTORY}/oineus "${CMAKE_CURRENT_BINARY_DIR}/../../tests/oineus"
+            DEPENDS _oineus oineus)
+endif()

oineus-0.9.3/bindings/python/aa.py

@@ -0,0 +1,15 @@
+from icecream import ic
+import oineus as oin
+import numpy as np
+import matplotlib.pyplot as plt
+DIM = 1
+WASS_DIST_Q = 2
+max_dim = 1
+empty = oin.Diagrams_double(DIM+1)[DIM]
+Z = np.random.random((100,2))
+fil,longest_edges = oin.get_vr_filtration_and_critical_edges(Z, max_dim=2, max_radius=np.inf, n_threads=4)
+top_opt = oin.TopologyOptimizer(fil)
+diagram = top_opt.compute_diagram(include_inf_points=False)
+#Same loss as before with edges, i.e. align edges to their critical lengths
+indices, values = top_opt.match(empty, DIM, WASS_DIST_Q )
+ic(indices,values)

oineus-0.9.3/bindings/python/example.py

@@ -0,0 +1,42 @@
+#!python3
+
+import numpy as np
+import oineus as oin
+
+# scalar function on 8x8x8 grid
+np.random.seed(1)
+f = np.random.uniform(size=(8, 8, 8))
+
+# triangulate domain via Freudenthal and create lower star filtration
+# negate: set to True to get upper-star filtration
+# wrap: set to True to work on torus (periodic boundary conditions)
+fil = oin.get_freudenthal_filtration(data=f, negate=False, wrap=False, max_dim=3, n_threads=1)
+
+cells = fil.cells()
+
+# Vertices in cells are ids, not sorted_ids
+print(f"Filtration with {len(cells)} cells created,\nvertex 0: {cells[0]},\nlast simplex: {cells[-1]}")
+
+# no cohomology
+dualize = False
+# create VRU decomposition object, does not perform reduction yet
+dcmp = oin.Decomposition(fil, dualize)
+
+# reduction parameters
+# relevant members:
+# rp.clearing_opt --- whether you want to use clearing, True by default
+# rp.compute_v: True by default
+# rp.n_threads: number of threads to use, default is 1
+# rp. compute_u: False by default (cannot do it in multi-threaded mode, so switch off just to be on the safe side)
+rp = oin.ReductionParams()
+
+# perform reduction
+dcmp.reduce(rp)
+
+# now we can acess V, R and U
+# indices are sorted_ids of simplices == indices in fil.cells()
+V = dcmp.v_data
+print(f"Example of a V column: {V[-1]}, this chain contains cells:")
+for sigma_idx in V[-1]:
+    print(cells[sigma_idx])
+

oineus-0.9.3/bindings/python/example_cone.py

@@ -0,0 +1,40 @@
+#!python3
+
+from icecream import ic
+import numpy as np
+import oineus as oin
+
+n_pts = 5
+
+pts = np.random.uniform(size=n_pts * 2).reshape(n_pts, 2).astype(np.float64)
+
+fil_1 = oin.get_vr_filtration(pts, 1, 2.0, 1)
+fil_2 = oin.get_vr_filtration(pts, 1, 2.0, 1)
+
+
+simplices = fil_1.simplices()
+
+fil_min_simplices = []
+
+for sigma in simplices:
+    min_sigma = oin.Simplex_double(sigma.vertices, min(sigma.value, fil_2.simplex_value_by_vertices(sigma.vertices)))
+    fil_min_simplices.append(min_sigma)
+
+fil_min = oin.Filtration_double(fil_min_simplices)
+
+cone_v = fil_min.n_vertices()
+
+# must make copy here! otherwise iteration in for loop below will never end,
+# since we keep adding to the same list over which we iterate
+coned_simplices = simplices[:]
+simplex_id = fil_min.size()
+
+for sigma in simplices:
+    coned_sigma = sigma.join(new_vertex=cone_v, value=sigma.value, new_id=simplex_id)
+    simplex_id += 1
+    coned_simplices.append(coned_sigma)
+
+
+fil_coned = oin.Filtration_double(coned_simplices, sort_only_by_dimension=True, set_ids=False)
+
+print(fil_coned)

oineus-0.9.3/bindings/python/example_cone_diff.py

@@ -0,0 +1,110 @@
+#!python3
+
+from icecream import ic
+import numpy as np
+import oineus as oin
+import torch
+
+n_pts = 50
+
+np.random.seed(1)
+
+pts_1 = np.random.uniform(low=0.0, high=5.0, size=n_pts * 2).reshape(n_pts, 2).astype(np.float64)
+pts_2 = pts_1 + np.random.uniform(size=n_pts *2, low=-0.01, high=0.01).reshape(pts_1.shape)
+
+# input: pts
+# output: VR filtration and torch Tensor with the lengths
+# of critical edges in filtration order, that is:
+# fil.simplices()[sorted_idx].value == lengths[sorted_idx]
+def get_vr_filtration_and_vals(pts, max_dim, max_radius):
+    fil, edges = oin.get_vr_filtration_and_critical_edges(pts, max_dim=max_dim, max_radius=max_radius, n_threads=1)
+    fil.reset_ids_to_sorted_ids()
+    pts = torch.Tensor(pts)
+    edge_start, edge_end = edges[:, 0], edges[:, 1]
+    lengths = torch.sum((pts[edge_start, :] - pts[edge_end, :])**2, axis=1) ** 0.5
+
+    return fil, lengths
+
+max_dim = 2
+max_radius = 1000.0
+
+fil_1, lengths_1 = get_vr_filtration_and_vals(pts_1, max_dim, max_radius)
+fil_2, lengths_2 = get_vr_filtration_and_vals(pts_2, max_dim, max_radius)
+
+# create fil_min
+
+simplices_1 = fil_1.simplices()
+simplices_2 = fil_2.simplices()
+
+fil_min_simplices = []
+
+for sigma in simplices_1:
+    min_sigma = oin.Simplex_double(sigma.sorted_id, sigma.vertices,
+                                   min(sigma.value, fil_2.simplex_value_by_vertices(sigma.vertices)))
+    fil_min_simplices.append(min_sigma)
+
+fil_min = oin.Filtration_double(fil_min_simplices, set_ids=False)
+
+# now simplices became reshuffled
+# we must permute lengths_1 and lengths_2 accordingly
+# id of simplex in fil_min is it's sorted_id in the original filtration
+
+min_sorted_id_to_sorted_id_1 = fil_min.get_inv_sorting_permutation()
+
+lengths_1_in_min_order = lengths_1[torch.LongTensor(min_sorted_id_to_sorted_id_1)]
+
+min_simplices = fil_min.simplices()
+
+
+min_sorted_id_to_sorted_id_2 = [ fil_2.get_sorted_id_by_vertices(min_sigma.vertices) for min_sigma in min_simplices ]
+
+lengths_2_in_min_order = lengths_2[torch.LongTensor(min_sorted_id_to_sorted_id_2)]
+
+for i, sigma in enumerate(min_simplices):
+    s1 = simplices_1[fil_1.get_sorted_id_by_vertices(sigma.vertices)]
+    s2 = simplices_2[fil_2.get_sorted_id_by_vertices(sigma.vertices)]
+    assert np.abs(s1.value - lengths_1_in_min_order[i]) < 0.0001
+    assert np.abs(s2.value - lengths_2_in_min_order[i]) < 0.0001
+
+
+min_critical_values = torch.min(torch.stack((lengths_1_in_min_order, lengths_2_in_min_order)), axis=0)[0]
+
+# verify that we got the critical values correctly
+for sigma in min_simplices:
+    assert torch.abs(sigma.value - min_critical_values[sigma.sorted_id]) < 0.00001
+
+
+min_and_coned_simplices = min_simplices[:]
+cone_v = fil_min.n_vertices()
+
+# append cone vertex
+# TODO: how to ensure that cone_vertex appears first?
+# for now we can ignore it
+min_and_coned_simplices.append(oin.Simplex_double(cone_v, [cone_v], 0.0))
+
+simplex_id = len(min_and_coned_simplices)
+
+# take cones over simplices from fil_1
+for sigma in simplices_1:
+    coned_sigma = sigma.join(new_vertex=cone_v, value=sigma.value, new_id=simplex_id)
+    simplex_id += 1
+    min_and_coned_simplices.append(coned_sigma)
+
+fil_min_and_coned = oin.Filtration_double(min_and_coned_simplices, set_ids=False)
+
+# in filtration order
+min_and_coned_simplices = fil_min_and_coned.simplices()
+
+for sigma in min_and_coned_simplices:
+    if cone_v in sigma.vertices:
+        if sigma.dim() == 0:
+            continue
+        # subtract additional 1 for cone vertex
+        orig_sorted_sigma_id = sigma.id - len(fil_1) - 1
+        assert(np.abs(lengths_1[orig_sorted_sigma_id] - sigma.value) < 0.00001)
+    else:
+        orig_sigma_id = sigma.id
+        orig_sorted_sigma_id = fil_min.get_sorted_id_by_id(orig_sigma_id)
+        assert(np.abs(min_critical_values[orig_sorted_sigma_id] - sigma.value) < 0.00001)
+
+print(fil_min_and_coned)

oineus-0.9.3/bindings/python/example_manual.py

@@ -0,0 +1,62 @@
+#!python3
+
+import numpy as np
+import oineus as oin
+
+# here we create a simple example (triangle) with vertices
+# v0 (critical value 0.2)
+# v1 (critical value 0.1)
+# v3 (critical value 0.3)
+# edges: e1 = [v0, v1]
+#
+
+v0 = oin.Simplex_double([0], 0.2)
+v1 = oin.Simplex_double([1], 0.1)
+v2 = oin.Simplex_double([2], 0.3)
+
+# indices of vertices should be sorted
+e1 = oin.Simplex_double([0, 1], 0.9)
+e2 = oin.Simplex_double([0, 2], 0.5)
+e3 = oin.Simplex_double([1, 2], 0.8)
+
+t = oin.Simplex_double([0, 1, 2], 1.0)
+
+simplices = [v0, v1, v2, e1, e2, e3, t]
+
+negate = False
+n_threads = 1
+
+# constructor will sort simplices and assign sorted_ids
+fil = oin.Filtration_double(simplices, negate, n_threads)
+
+fil_simplices = fil.simplices()
+
+for sigma in fil.simplices():
+    print(sigma)
+
+# no cohomology
+dualize = False
+# create VRU decomposition object, does not perform reduction yet
+dcmp = oin.Decomposition(fil, dualize)
+
+# reduction parameters
+# relevant members:
+# rp.clearing_opt --- whether you want to use clearing, True by default
+# rp.compute_v: True by default
+# rp.n_threads: number of threads to use, default is 1
+# rp. compute_u: False by default (cannot do it in multi-threaded mode, so switch off just to be on the safe side)
+rp = oin.ReductionParams()
+
+# perform reduction
+dcmp.reduce(rp)
+
+# get diagram, including points at infinity
+include_inf_points=True
+dgm = dcmp.diagram(fil, include_inf_points)
+
+# diagram in dimension d is numpy array dgm[d], shape = (number of diagram points, 2)
+
+for dim in [0, 1]:
+    print(f"Diagram in dimension {dim}:")
+    print(dgm[dim])
+

oineus-0.9.3/bindings/python/example_opt.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+import numpy as np
+from icecream import ic
+
+import oineus as oin
+
+
+def evaluate_func(x, y, z):
+    return np.sin(x + 2 * y + 3 * z ** 2)
+
+
+# Create a 16x16x16 grid
+x = np.linspace(-np.pi, np.pi, 16)
+y = np.linspace(-np.pi, np.pi, 16)
+z = np.linspace(-np.pi, np.pi, 16)
+
+# Generate a 3D meshgrid
+X, Y, Z = np.meshgrid(x, y, z)
+
+# Evaluate the function on the grid
+f = evaluate_func(X, Y, Z)
+
+fil, max_value_vertices = oin.get_freudenthal_filtration_and_critical_vertices(f, negate=False, wrap=False, max_dim=2, n_threads=8)
+
+top_opt = oin.TopologyOptimizer(fil)
+
+dim = 1
+n = 4
+
+dgm = top_opt.compute_diagram(include_inf_points=False)
+eps = top_opt.get_nth_persistence(dim, 4)
+indices, values = top_opt.simplify(eps, oin.DenoiseStrategy.BirthBirth, dim)
+critical_sets = top_opt.singletons(indices, values)
+crit_indices, crit_values = top_opt.combine_loss(critical_sets, oin.ConflictStrategy.Max)
+
+crit_indices = np.array(crit_indices, dtype=np.int32)
+crit_vertices = max_value_vertices[crit_indices]

oineus-0.9.3/bindings/python/example_opt_vr.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import torch
+from matplotlib import pyplot as plt
+import oineus as oin
+
+def sample_data():
+    # sample points from the unit circle
+    # return points as differentiable torch tensor
+    np.random.seed(1)
+
+    num_points = 120
+    noise_std_dev = 0.1
+
+    angles = np.random.uniform(low=0, high=2*np.pi, size=num_points)
+    x = np.cos(angles)
+    y = np.sin(angles)
+
+    x += np.random.normal(loc=0, scale=noise_std_dev, size=num_points)
+    y += np.random.normal(loc=0, scale=noise_std_dev, size=num_points)
+
+    pts = np.vstack((x, y)).T
+    pts = torch.Tensor(pts)
+    pts.requires_grad_(True)
+
+    return pts
+
+
+def topological_loss(pts: torch.Tensor, dim: int=1, n: int=2):
+    pts_as_numpy = pts.clone().detach().numpy().astype(np.float64)
+    fil, longest_edges = oin.get_vr_filtration_and_critical_edges(pts_as_numpy, max_dim=2, max_radius=9.0, n_threads=1)
+    top_opt = oin.TopologyOptimizer(fil)
+
+    # dgm = top_opt.compute_diagram(include_inf_points=False)
+    # print(dgm.in_dimension(dim))
+
+    eps = top_opt.get_nth_persistence(dim, n)
+    print(f"{eps= }")
+
+    indices, values = top_opt.simplify(eps, oin.DenoiseStrategy.BirthBirth, dim)
+
+    critical_sets = top_opt.singletons(indices, values)
+    crit_indices, crit_method_values = top_opt.combine_loss(critical_sets, oin.ConflictStrategy.Max)
+
+    crit_indices = np.array(crit_indices, dtype=np.int32)
+
+    dgm_method_edges = longest_edges[indices, :]
+    dgm_method_edges_x, dgm_method_edges_y = dgm_method_edges[:, 0], dgm_method_edges[:, 1]
+
+    dgm_method_values = torch.Tensor(values)
+
+    crit_method_edges = longest_edges[crit_indices, :]
+    crit_method_edges_x, crit_method_edges_y = crit_method_edges[:, 0], crit_method_edges[:, 1]
+
+    crit_method_values = torch.Tensor(crit_method_values)
+
+    if len(crit_method_edges_x) > 0:
+        dgm_loss = torch.sum(torch.abs(torch.sum((pts[dgm_method_edges_x, :] - pts[dgm_method_edges_y, :])**2, axis=1) - dgm_method_values ** 2))
+        top_loss = torch.sum(torch.abs(torch.sum((pts[crit_method_edges_x, :] - pts[crit_method_edges_y, :])**2, axis=1) - crit_method_values ** 2))
+    else:
+        top_loss = torch.zeros(())
+        dgm_loss = torch.zeros(())
+
+        top_loss.requires_grad_(True)
+        dgm_loss.requires_grad_(True)
+    return top_loss, dgm_loss
+
+
+if __name__ == "__main__":
+    draw = False
+    use_critical_sets = False
+
+    pts = sample_data()
+
+    lr = 0.2
+
+    opt = torch.optim.SGD([pts], lr=lr)
+
+    for step_idx in range(5):
+        opt.zero_grad()
+
+        loss, dgm_loss = topological_loss(pts, dim=1, n=1)
+
+        print(f"{step_idx = }, {loss = }, {dgm_loss = }")
+
+        if draw:
+            np_pts = pts.clone().detach().numpy()
+            plt.scatter(np_pts[:, 0], np_pts[:, 1], color="green")
+
+        if loss.item() == 0:
+            break
+
+        if use_critical_sets:
+            loss.backward()
+        else:
+            dgm_loss.backward()
+
+        opt.step()
+
+        if draw:
+            np_pts = pts.clone().detach().numpy()
+            plt.scatter(np_pts[:, 0], np_pts[:, 1], color="red")
+            plt.show()
+
+
+