diff options
Diffstat (limited to 'src/python/gudhi/tensorflow')
| -rw-r--r-- | src/python/gudhi/tensorflow/__init__.py | 5 | ||||
| -rw-r--r-- | src/python/gudhi/tensorflow/cubical_layer.py | 82 | ||||
| -rw-r--r-- | src/python/gudhi/tensorflow/lower_star_simplex_tree_layer.py | 87 | ||||
| -rw-r--r-- | src/python/gudhi/tensorflow/perslay.py | 284 | ||||
| -rw-r--r-- | src/python/gudhi/tensorflow/rips_layer.py | 93 |
5 files changed, 551 insertions, 0 deletions
diff --git a/src/python/gudhi/tensorflow/__init__.py b/src/python/gudhi/tensorflow/__init__.py new file mode 100644 index 00000000..1599cf52 --- /dev/null +++ b/src/python/gudhi/tensorflow/__init__.py @@ -0,0 +1,5 @@ +from .cubical_layer import CubicalLayer +from .lower_star_simplex_tree_layer import LowerStarSimplexTreeLayer +from .rips_layer import RipsLayer + +__all__ = ["LowerStarSimplexTreeLayer", "RipsLayer", "CubicalLayer"] diff --git a/src/python/gudhi/tensorflow/cubical_layer.py b/src/python/gudhi/tensorflow/cubical_layer.py new file mode 100644 index 00000000..5df2c370 --- /dev/null +++ b/src/python/gudhi/tensorflow/cubical_layer.py @@ -0,0 +1,82 @@ +import numpy as np +import tensorflow as tf +from ..cubical_complex import CubicalComplex + +###################### +# Cubical filtration # +###################### + +# The parameters of the model are the pixel values. + +def _Cubical(Xflat, Xdim, dimensions, homology_coeff_field): + # Parameters: Xflat (flattened image), + # Xdim (shape of non-flattened image) + # dimensions (homology dimensions) + + # Compute the persistence pairs with Gudhi + # We reverse the dimensions because CubicalComplex uses Fortran ordering + cc = CubicalComplex(dimensions=Xdim[::-1], top_dimensional_cells=Xflat) + cc.compute_persistence(homology_coeff_field=homology_coeff_field) + + # Retrieve and output image indices/pixels corresponding to positive and negative simplices + cof_pp = cc.cofaces_of_persistence_pairs() + + L_cofs = [] + for dim in dimensions: + + try: + cof = cof_pp[0][dim] + except IndexError: + cof = np.array([]) + + L_cofs.append(np.array(cof, dtype=np.int32)) + + return L_cofs + +class CubicalLayer(tf.keras.layers.Layer): + """ + TensorFlow layer for computing the persistent homology of a cubical complex + """ + def __init__(self, homology_dimensions, min_persistence=None, homology_coeff_field=11, **kwargs): + """ + Constructor for the CubicalLayer class + + Parameters: + homology_dimensions (List[int]): list of homology dimensions + min_persistence (List[float]): minimum distance-to-diagonal of the points in the output persistence diagrams (default None, in which case 0. is used for all dimensions) + homology_coeff_field (int): homology field coefficient. Must be a prime number. Default value is 11. Max is 46337. + """ + super().__init__(dynamic=True, **kwargs) + self.dimensions = homology_dimensions + self.min_persistence = min_persistence if min_persistence != None else [0.] * len(self.dimensions) + self.hcf = homology_coeff_field + assert len(self.min_persistence) == len(self.dimensions) + + def call(self, X): + """ + Compute persistence diagram associated to a cubical complex filtered by some pixel values + + Parameters: + X (TensorFlow variable): pixel values of the cubical complex + + Returns: + List[Tuple[tf.Tensor,tf.Tensor]]: List of cubical persistence diagrams. The length of this list is the same than that of dimensions, i.e., there is one persistence diagram per homology dimension provided in the input list dimensions. Moreover, the finite and essential parts of the persistence diagrams are provided separately: each element of this list is a tuple of size two that contains the finite and essential parts of the corresponding persistence diagram, of shapes [num_finite_points, 2] and [num_essential_points, 1] respectively. Note that the essential part is always empty in cubical persistence diagrams, except in homology dimension zero, where the essential part always contains a single point, with abscissa equal to the smallest value in the complex, and infinite ordinate + """ + # Compute pixels associated to positive and negative simplices + # Don't compute gradient for this operation + Xflat = tf.reshape(X, [-1]) + Xdim, Xflat_numpy = X.shape, Xflat.numpy() + indices_list = _Cubical(Xflat_numpy, Xdim, self.dimensions, self.hcf) + index_essential = np.argmin(Xflat_numpy) # index of minimum pixel value for essential persistence diagram + # Get persistence diagram by simply picking the corresponding entries in the image + self.dgms = [] + for idx_dim, dimension in enumerate(self.dimensions): + finite_dgm = tf.reshape(tf.gather(Xflat, indices_list[idx_dim]), [-1,2]) + essential_dgm = tf.reshape(tf.gather(Xflat, index_essential), [-1,1]) if dimension == 0 else tf.zeros([0, 1]) + min_pers = self.min_persistence[idx_dim] + if min_pers >= 0: + persistent_indices = tf.where(tf.math.abs(finite_dgm[:,1]-finite_dgm[:,0]) > min_pers) + self.dgms.append((tf.reshape(tf.gather(finite_dgm, indices=persistent_indices), [-1,2]), essential_dgm)) + else: + self.dgms.append((finite_dgm, essential_dgm)) + return self.dgms diff --git a/src/python/gudhi/tensorflow/lower_star_simplex_tree_layer.py b/src/python/gudhi/tensorflow/lower_star_simplex_tree_layer.py new file mode 100644 index 00000000..5a8e5b75 --- /dev/null +++ b/src/python/gudhi/tensorflow/lower_star_simplex_tree_layer.py @@ -0,0 +1,87 @@ +import numpy as np +import tensorflow as tf + +######################################### +# Lower star filtration on simplex tree # +######################################### + +# The parameters of the model are the vertex function values of the simplex tree. + +def _LowerStarSimplexTree(simplextree, filtration, dimensions, homology_coeff_field): + # Parameters: simplextree (simplex tree on which to compute persistence) + # filtration (function values on the vertices of st), + # dimensions (homology dimensions), + # homology_coeff_field (homology field coefficient) + + simplextree.reset_filtration(-np.inf, 0) + + # Assign new filtration values + for i in range(simplextree.num_vertices()): + simplextree.assign_filtration([i], filtration[i]) + simplextree.make_filtration_non_decreasing() + + # Compute persistence diagram + simplextree.compute_persistence(homology_coeff_field=homology_coeff_field) + + # Get vertex pairs for optimization. First, get all simplex pairs + pairs = simplextree.lower_star_persistence_generators() + + L_indices = [] + for dimension in dimensions: + + finite_pairs = pairs[0][dimension] if len(pairs[0]) >= dimension+1 else np.empty(shape=[0,2]) + essential_pairs = pairs[1][dimension] if len(pairs[1]) >= dimension+1 else np.empty(shape=[0,1]) + + finite_indices = np.array(finite_pairs.flatten(), dtype=np.int32) + essential_indices = np.array(essential_pairs.flatten(), dtype=np.int32) + + L_indices.append((finite_indices, essential_indices)) + + return L_indices + +class LowerStarSimplexTreeLayer(tf.keras.layers.Layer): + """ + TensorFlow layer for computing lower-star persistence out of a simplex tree + """ + def __init__(self, simplextree, homology_dimensions, min_persistence=None, homology_coeff_field=11, **kwargs): + """ + Constructor for the LowerStarSimplexTreeLayer class + + Parameters: + simplextree (gudhi.SimplexTree): underlying simplex tree. Its vertices MUST be named with integers from 0 to n-1, where n is its number of vertices. Note that its filtration values are modified in each call of the class. + homology_dimensions (List[int]): list of homology dimensions + min_persistence (List[float]): minimum distance-to-diagonal of the points in the output persistence diagrams (default None, in which case 0. is used for all dimensions) + homology_coeff_field (int): homology field coefficient. Must be a prime number. Default value is 11. Max is 46337. + """ + super().__init__(dynamic=True, **kwargs) + self.dimensions = homology_dimensions + self.simplextree = simplextree + self.min_persistence = min_persistence if min_persistence != None else [0. for _ in range(len(self.dimensions))] + self.hcf = homology_coeff_field + assert len(self.min_persistence) == len(self.dimensions) + + def call(self, filtration): + """ + Compute lower-star persistence diagram associated to a function defined on the vertices of the simplex tree + + Parameters: + F (TensorFlow variable): filter function values over the vertices of the simplex tree. The ith entry of F corresponds to vertex i in self.simplextree + + Returns: + List[Tuple[tf.Tensor,tf.Tensor]]: List of lower-star persistence diagrams. The length of this list is the same than that of dimensions, i.e., there is one persistence diagram per homology dimension provided in the input list dimensions. Moreover, the finite and essential parts of the persistence diagrams are provided separately: each element of this list is a tuple of size two that contains the finite and essential parts of the corresponding persistence diagram, of shapes [num_finite_points, 2] and [num_essential_points, 1] respectively + """ + # Don't try to compute gradients for the vertex pairs + indices = _LowerStarSimplexTree(self.simplextree, filtration.numpy(), self.dimensions, self.hcf) + # Get persistence diagrams + self.dgms = [] + for idx_dim, dimension in enumerate(self.dimensions): + finite_dgm = tf.reshape(tf.gather(filtration, indices[idx_dim][0]), [-1,2]) + essential_dgm = tf.reshape(tf.gather(filtration, indices[idx_dim][1]), [-1,1]) + min_pers = self.min_persistence[idx_dim] + if min_pers >= 0: + persistent_indices = tf.where(tf.math.abs(finite_dgm[:,1]-finite_dgm[:,0]) > min_pers) + self.dgms.append((tf.reshape(tf.gather(finite_dgm, indices=persistent_indices),[-1,2]), essential_dgm)) + else: + self.dgms.append((finite_dgm, essential_dgm)) + return self.dgms + diff --git a/src/python/gudhi/tensorflow/perslay.py b/src/python/gudhi/tensorflow/perslay.py new file mode 100644 index 00000000..9976c5f3 --- /dev/null +++ b/src/python/gudhi/tensorflow/perslay.py @@ -0,0 +1,284 @@ +# This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT. +# See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details. +# Author(s): Mathieu Carrière +# +# Copyright (C) 2021 Inria +# +# Modification(s): +# - YYYY/MM Author: Description of the modification + +import tensorflow as tf +import math + +class GridPerslayWeight(tf.keras.layers.Layer): + """ + This is a class for computing a differentiable weight function for persistence diagram points. This function is defined from an array that contains its values on a 2D grid. + """ + def __init__(self, grid, grid_bnds, **kwargs): + """ + Constructor for the GridPerslayWeight class. + + Parameters: + grid (n x n numpy array): grid of values. + grid_bnds (2 x 2 numpy array): boundaries of the grid, of the form [[min_x, max_x], [min_y, max_y]]. + """ + super().__init__(dynamic=True, **kwargs) + self.grid = tf.Variable(initial_value=grid, trainable=True) + self.grid_bnds = grid_bnds + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply GridPerslayWeight on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + weight (n x None): ragged tensor containing the weights of the points in the n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + """ + grid_shape = self.grid.shape + indices = [] + for dim in range(2): + [m,M] = self.grid_bnds[dim] + coords = tf.expand_dims(diagrams[:,:,dim],-1) + ids = grid_shape[dim]*(coords-m)/(M-m) + indices.append(tf.cast(ids, tf.int32)) + weight = tf.gather_nd(params=self.grid, indices=tf.concat(indices, axis=2)) + return weight + +class GaussianMixturePerslayWeight(tf.keras.layers.Layer): + """ + This is a class for computing a differentiable weight function for persistence diagram points. This function is defined from a mixture of Gaussian functions. + """ + def __init__(self, gaussians, **kwargs): + """ + Constructor for the GridPerslayWeight class. + + Parameters: + gaussians (4 x n numpy array): parameters of the n Gaussian functions, of the form transpose([[mu_x^1, mu_y^1, sigma_x^1, sigma_y^1], ..., [mu_x^n, mu_y^n, sigma_x^n, sigma_y^n]]). + """ + super().__init__(dynamic=True, **kwargs) + self.W = tf.Variable(initial_value=gaussians, trainable=True) + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply GaussianMixturePerslayWeight on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + weight (n x None): ragged tensor containing the weights of the points in the n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + """ + means = tf.expand_dims(tf.expand_dims(self.W[:2,:],0),0) + variances = tf.expand_dims(tf.expand_dims(self.W[2:,:],0),0) + diagrams = tf.expand_dims(diagrams, -1) + dists = tf.math.multiply(tf.math.square(diagrams-means), 1/tf.math.square(variances)) + weight = tf.math.reduce_sum(tf.math.exp(tf.math.reduce_sum(-dists, axis=2)), axis=2) + return weight + +class PowerPerslayWeight(tf.keras.layers.Layer): + """ + This is a class for computing a differentiable weight function for persistence diagram points. This function is defined as a constant multiplied by the distance to the diagonal of the persistence diagram point raised to some power. + """ + def __init__(self, constant, power, **kwargs): + """ + Constructor for the PowerPerslayWeight class. + + Parameters: + constant (float): constant value. + power (float): power applied to the distance to the diagonal. + """ + super().__init__(dynamic=True, **kwargs) + self.constant = tf.Variable(initial_value=constant, trainable=True) + self.power = power + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply PowerPerslayWeight on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + weight (n x None): ragged tensor containing the weights of the points in the n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + """ + weight = self.constant * tf.math.pow(tf.math.abs(diagrams[:,:,1]-diagrams[:,:,0]), self.power) + return weight + + +class GaussianPerslayPhi(tf.keras.layers.Layer): + """ + This is a class for computing a transformation function for persistence diagram points. This function turns persistence diagram points into 2D Gaussian functions centered on the points, that are then evaluated on a regular 2D grid. + """ + def __init__(self, image_size, image_bnds, variance, **kwargs): + """ + Constructor for the GaussianPerslayPhi class. + + Parameters: + image_size (int numpy array): number of grid elements on each grid axis, of the form [n_x, n_y]. + image_bnds (2 x 2 numpy array): boundaries of the grid, of the form [[min_x, max_x], [min_y, max_y]]. + variance (float): variance of the Gaussian functions. + """ + super().__init__(dynamic=True, **kwargs) + self.image_size = image_size + self.image_bnds = image_bnds + self.variance = tf.Variable(initial_value=variance, trainable=True) + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply GaussianPerslayPhi on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + output (n x None x image_size x image_size x 1): ragged tensor containing the evaluations on the 2D grid of the 2D Gaussian functions corresponding to the persistence diagram points, in the form of a 2D image with 1 channel that can be processed with, e.g., convolutional layers. The second dimension is ragged since persistence diagrams can have different numbers of points. + output_shape (int numpy array): shape of the output tensor. + """ + diagrams_d = tf.concat([diagrams[:,:,0:1], diagrams[:,:,1:2]-diagrams[:,:,0:1]], axis=2) + step = [(self.image_bnds[i][1]-self.image_bnds[i][0])/self.image_size[i] for i in range(2)] + coords = [tf.range(self.image_bnds[i][0], self.image_bnds[i][1], step[i]) for i in range(2)] + M = tf.meshgrid(*coords) + mu = tf.concat([tf.expand_dims(tens, 0) for tens in M], axis=0) + for _ in range(2): + diagrams_d = tf.expand_dims(diagrams_d,-1) + dists = tf.math.square(diagrams_d-mu) / (2*tf.math.square(self.variance)) + gauss = tf.math.exp(tf.math.reduce_sum(-dists, axis=2)) / (2*math.pi*tf.math.square(self.variance)) + output = tf.expand_dims(gauss,-1) + output_shape = M[0].shape + tuple([1]) + return output, output_shape + +class TentPerslayPhi(tf.keras.layers.Layer): + """ + This is a class for computing a transformation function for persistence diagram points. This function turns persistence diagram points into 1D tent functions (linearly increasing on the first half of the bar corresponding to the point from zero to half of the bar length, linearly decreasing on the second half and zero elsewhere) centered on the points, that are then evaluated on a regular 1D grid. + """ + def __init__(self, samples, **kwargs): + """ + Constructor for the GaussianPerslayPhi class. + + Parameters: + samples (float numpy array): grid elements on which to evaluate the tent functions, of the form [x_1, ..., x_n]. + """ + super().__init__(dynamic=True, **kwargs) + self.samples = tf.Variable(initial_value=samples, trainable=True) + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply TentPerslayPhi on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + output (n x None x num_samples): ragged tensor containing the evaluations on the 1D grid of the 1D tent functions corresponding to the persistence diagram points. The second dimension is ragged since persistence diagrams can have different numbers of points. + output_shape (int numpy array): shape of the output tensor. + """ + samples_d = tf.expand_dims(tf.expand_dims(self.samples,0),0) + xs, ys = diagrams[:,:,0:1], diagrams[:,:,1:2] + output = tf.math.maximum(.5*(ys-xs) - tf.math.abs(samples_d-.5*(ys+xs)), tf.constant([0.])) + output_shape = self.samples.shape + return output, output_shape + +class FlatPerslayPhi(tf.keras.layers.Layer): + """ + This is a class for computing a transformation function for persistence diagram points. This function turns persistence diagram points into 1D constant functions (that evaluate to half of the bar length on the bar corresponding to the point and zero elsewhere), that are then evaluated on a regular 1D grid. + """ + def __init__(self, samples, theta, **kwargs): + """ + Constructor for the FlatPerslayPhi class. + + Parameters: + samples (float numpy array): grid elements on which to evaluate the constant functions, of the form [x_1, ..., x_n]. + theta (float): sigmoid parameter used to approximate the constant function with a differentiable sigmoid function. The bigger the theta, the closer to a constant function the output will be. + """ + super().__init__(dynamic=True, **kwargs) + self.samples = tf.Variable(initial_value=samples, trainable=True) + self.theta = tf.Variable(initial_value=theta, trainable=True) + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply FlatPerslayPhi on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + output (n x None x num_samples): ragged tensor containing the evaluations on the 1D grid of the 1D constant functions corresponding to the persistence diagram points. The second dimension is ragged since persistence diagrams can have different numbers of points. + output_shape (int numpy array): shape of the output tensor. + """ + samples_d = tf.expand_dims(tf.expand_dims(self.samples,0),0) + xs, ys = diagrams[:,:,0:1], diagrams[:,:,1:2] + output = 1./(1.+tf.math.exp(-self.theta*(.5*(ys-xs)-tf.math.abs(samples_d-.5*(ys+xs))))) + output_shape = self.samples.shape + return output, output_shape + +class Perslay(tf.keras.layers.Layer): + """ + This is a TensorFlow layer for vectorizing persistence diagrams in a differentiable way within a neural network. This function implements the PersLay equation, see `the corresponding article <http://proceedings.mlr.press/v108/carriere20a.html>`_. + """ + def __init__(self, weight, phi, perm_op, rho, **kwargs): + """ + Constructor for the Perslay class. + + Parameters: + weight (function): weight function for the persistence diagram points. Can be either :class:`~gudhi.tensorflow.perslay.GridPerslayWeight`, :class:`~gudhi.tensorflow.perslay.GaussianMixturePerslayWeight`, :class:`~gudhi.tensorflow.perslay.PowerPerslayWeight`, or a custom TensorFlow function that takes persistence diagrams as argument (represented as an (n x None x 2) ragged tensor, where n is the number of diagrams). + phi (function): transformation function for the persistence diagram points. Can be either :class:`~gudhi.tensorflow.perslay.GaussianPerslayPhi`, :class:`~gudhi.tensorflow.perslay.TentPerslayPhi`, :class:`~gudhi.tensorflow.perslay.FlatPerslayPhi`, or a custom TensorFlow class (that can have trainable parameters) with a method `call` that takes persistence diagrams as argument (represented as an (n x None x 2) ragged tensor, where n is the number of diagrams). + perm_op (function): permutation invariant function, such as `tf.math.reduce_sum`, `tf.math.reduce_mean`, `tf.math.reduce_max`, `tf.math.reduce_min`, or a custom TensorFlow function that takes two arguments: a tensor and an axis on which to apply the permutation invariant operation. If perm_op is the string "topk" (where k is a number), this function will be computed as `tf.math.top_k` with parameter `int(k)`. + rho (function): postprocessing function that is applied after the permutation invariant operation. Can be any TensorFlow layer. + """ + super().__init__(dynamic=True, **kwargs) + self.weight = weight + self.phi = phi + self.perm_op = perm_op + self.rho = rho + + def build(self, input_shape): + return self + + def call(self, diagrams): + """ + Apply Perslay on a ragged tensor containing a list of persistence diagrams. + + Parameters: + diagrams (n x None x 2): ragged tensor containing n persistence diagrams. The second dimension is ragged since persistence diagrams can have different numbers of points. + + Returns: + vector (n x output_shape): tensor containing the vectorizations of the persistence diagrams. + """ + vector, dim = self.phi(diagrams) + weight = self.weight(diagrams) + for _ in range(len(dim)): + weight = tf.expand_dims(weight, -1) + vector = tf.math.multiply(vector, weight) + + permop = self.perm_op + if type(permop) == str and permop[:3] == 'top': + k = int(permop[3:]) + vector = vector.to_tensor(default_value=-1e10) + vector = tf.math.top_k(tf.transpose(vector, perm=[0, 2, 1]), k=k).values + vector = tf.reshape(vector, [-1,k*dim[0]]) + else: + vector = permop(vector, axis=1) + + vector = self.rho(vector) + + return vector diff --git a/src/python/gudhi/tensorflow/rips_layer.py b/src/python/gudhi/tensorflow/rips_layer.py new file mode 100644 index 00000000..2a73472c --- /dev/null +++ b/src/python/gudhi/tensorflow/rips_layer.py @@ -0,0 +1,93 @@ +import numpy as np +import tensorflow as tf +from ..rips_complex import RipsComplex + +############################ +# Vietoris-Rips filtration # +############################ + +# The parameters of the model are the point coordinates. + +def _Rips(DX, max_edge, dimensions, homology_coeff_field): + # Parameters: DX (distance matrix), + # max_edge (maximum edge length for Rips filtration), + # dimensions (homology dimensions) + + # Compute the persistence pairs with Gudhi + rc = RipsComplex(distance_matrix=DX, max_edge_length=max_edge) + st = rc.create_simplex_tree(max_dimension=max(dimensions)+1) + st.compute_persistence(homology_coeff_field=homology_coeff_field) + pairs = st.flag_persistence_generators() + + L_indices = [] + for dimension in dimensions: + + if dimension == 0: + finite_pairs = pairs[0] + essential_pairs = pairs[2] + else: + finite_pairs = pairs[1][dimension-1] if len(pairs[1]) >= dimension else np.empty(shape=[0,4]) + essential_pairs = pairs[3][dimension-1] if len(pairs[3]) >= dimension else np.empty(shape=[0,2]) + + finite_indices = np.array(finite_pairs.flatten(), dtype=np.int32) + essential_indices = np.array(essential_pairs.flatten(), dtype=np.int32) + + L_indices.append((finite_indices, essential_indices)) + + return L_indices + +class RipsLayer(tf.keras.layers.Layer): + """ + TensorFlow layer for computing Rips persistence out of a point cloud + """ + def __init__(self, homology_dimensions, maximum_edge_length=np.inf, min_persistence=None, homology_coeff_field=11, **kwargs): + """ + Constructor for the RipsLayer class + + Parameters: + maximum_edge_length (float): maximum edge length for the Rips complex + homology_dimensions (List[int]): list of homology dimensions + min_persistence (List[float]): minimum distance-to-diagonal of the points in the output persistence diagrams (default None, in which case 0. is used for all dimensions) + homology_coeff_field (int): homology field coefficient. Must be a prime number. Default value is 11. Max is 46337. + """ + super().__init__(dynamic=True, **kwargs) + self.max_edge = maximum_edge_length + self.dimensions = homology_dimensions + self.min_persistence = min_persistence if min_persistence != None else [0. for _ in range(len(self.dimensions))] + self.hcf = homology_coeff_field + assert len(self.min_persistence) == len(self.dimensions) + + def call(self, X): + """ + Compute Rips persistence diagram associated to a point cloud + + Parameters: + X (TensorFlow variable): point cloud of shape [number of points, number of dimensions] + + Returns: + List[Tuple[tf.Tensor,tf.Tensor]]: List of Rips persistence diagrams. The length of this list is the same than that of dimensions, i.e., there is one persistence diagram per homology dimension provided in the input list dimensions. Moreover, the finite and essential parts of the persistence diagrams are provided separately: each element of this list is a tuple of size two that contains the finite and essential parts of the corresponding persistence diagram, of shapes [num_finite_points, 2] and [num_essential_points, 1] respectively + """ + # Compute distance matrix + DX = tf.norm(tf.expand_dims(X, 1)-tf.expand_dims(X, 0), axis=2) + # Compute vertices associated to positive and negative simplices + # Don't compute gradient for this operation + indices = _Rips(DX.numpy(), self.max_edge, self.dimensions, self.hcf) + # Get persistence diagrams by simply picking the corresponding entries in the distance matrix + self.dgms = [] + for idx_dim, dimension in enumerate(self.dimensions): + cur_idx = indices[idx_dim] + if dimension > 0: + finite_dgm = tf.reshape(tf.gather_nd(DX, tf.reshape(cur_idx[0], [-1,2])), [-1,2]) + essential_dgm = tf.reshape(tf.gather_nd(DX, tf.reshape(cur_idx[1], [-1,2])), [-1,1]) + else: + reshaped_cur_idx = tf.reshape(cur_idx[0], [-1,3]) + finite_dgm = tf.concat([tf.zeros([reshaped_cur_idx.shape[0],1]), tf.reshape(tf.gather_nd(DX, reshaped_cur_idx[:,1:]), [-1,1])], axis=1) + essential_dgm = tf.zeros([cur_idx[1].shape[0],1]) + min_pers = self.min_persistence[idx_dim] + if min_pers >= 0: + persistent_indices = tf.where(tf.math.abs(finite_dgm[:,1]-finite_dgm[:,0]) > min_pers) + self.dgms.append((tf.reshape(tf.gather(finite_dgm, indices=persistent_indices),[-1,2]), essential_dgm)) + else: + self.dgms.append((finite_dgm, essential_dgm)) + return self.dgms + |