Merge pull request #20 from saibalmars/forman_fix

Forman fix

Author: saibalmars

.travis.yml

@@ -93,6 +93,7 @@ install:
       pip install cython;
       pip install numpy;
     fi
+  - pip install cython
   - pip install .
 
 before_cache:

GraphRicciCurvature/FormanRicci.py

@@ -12,18 +12,31 @@
 #     Sreejith, R. P., Karthikeyan Mohanraj, Jürgen Jost, Emil Saucan, and Areejit Samal. 2016.
 #         “Forman Curvature for Complex Networks.” Journal of Statistical Mechanics: Theory and Experiment 2016 (6).
 #         IOP Publishing: 063206.
+#     Samal, A., Sreejith, R.P., Gu, J. et al.
+#         "Comparative analysis of two discretizations of Ricci curvature for complex networks."
+#         Scientific Report 8, 8650 (2018).
 
+
+import networkx as nx
+import math
 from .util import logger, set_verbose
 
 
 class FormanRicci:
-    def __init__(self, G, verbose="ERROR"):
+    def __init__(self, G: nx.Graph, weight="weight", method="augmented", verbose="ERROR"):
         """A class to compute Forman-Ricci curvature for all nodes and edges in G.
 
         Parameters
         ----------
         G : NetworkX graph
             A given NetworkX graph, unweighted graph only for now, edge weight will be ignored.
+        weight : str
+            The edge weight used to compute Ricci curvature. (Default value = "weight")
+        method : {"1d", "augmented"}
+            The method used to compute Forman-Ricci curvature. (Default value = "augmented")
+
+            - "1d": Computed with 1-dimensional simplicial complex (vertex, edge).
+            - "augmented": Computed with 2-dimensional simplicial complex, length <=3 (vertex, edge, face).
         verbose: {"INFO","DEBUG","ERROR"}
             Verbose level. (Default value = "ERROR")
                 - "INFO": show only iteration process log.
@@ -32,6 +45,22 @@ def __init__(self, G, verbose="ERROR"):
         """
 
         self.G = G.copy()
+        self.weight = weight
+        self.method = method
+
+        if not nx.get_edge_attributes(self.G, self.weight):
+            logger.info('Edge weight not detected in graph, use "weight" as default edge weight.')
+            for (v1, v2) in self.G.edges():
+                self.G[v1][v2][self.weight] = 1.0
+        if not nx.get_node_attributes(self.G, self.weight):
+            logger.info('Node weight not detected in graph, use "weight" as default node weight.')
+            for v in self.G.nodes():
+                self.G.nodes[v][self.weight] = 1.0
+        if self.G.is_directed():
+            logger.info("Forman-Ricci curvature is not supported for directed graph yet, "
+                        "covert input graph to undirected.")
+            self.G = self.G.to_undirected()
+
         set_verbose(verbose)
 
     def compute_ricci_curvature(self):
@@ -45,34 +74,67 @@ def compute_ricci_curvature(self):
 
         Examples
         --------
-        To compute the Forman-Ricci curvature for karate club graph::
+        To compute the Forman-Ricci curvature for karate club graph:
 
             >>> G = nx.karate_club_graph()
             >>> frc = FormanRicci(G)
             >>> frc.compute_ricci_curvature()
-            >>> frc.G[0][1]
-            {'formanCurvature': 0}
+            >>> frc.G[0][2]
+            {'weight': 1.0, 'formanCurvature': -7.0}
         """
 
-        # Edge Forman curvature
-        for (v1, v2) in self.G.edges():
-            if self.G.is_directed():
-                v1_nbr = set(list(self.G.predecessors(v1)) + list(self.G.successors(v1)))
-                v2_nbr = set(list(self.G.predecessors(v2)) + list(self.G.successors(v2)))
-            else:
+        if self.method == "1d":
+            # Edge Forman curvature
+            for (v1, v2) in self.G.edges():
+                v1_nbr = set(self.G.neighbors(v1))
+                v1_nbr.remove(v2)
+                v2_nbr = set(self.G.neighbors(v2))
+                v2_nbr.remove(v1)
+
+                w_e = self.G[v1][v2][self.weight]
+                w_v1 = self.G.nodes[v1][self.weight]
+                w_v2 = self.G.nodes[v2][self.weight]
+                ev1_sum = sum([w_v1 / math.sqrt(w_e * self.G[v1][v][self.weight]) for v in v1_nbr])
+                ev2_sum = sum([w_v2 / math.sqrt(w_e * self.G[v2][v][self.weight]) for v in v2_nbr])
+
+                self.G[v1][v2]["formanCurvature"] = w_e * (w_v1 / w_e + w_v2 / w_e - (ev1_sum + ev2_sum))
+
+                logger.debug("Source: %s, target: %d, Forman-Ricci curvature = %f  " % (
+                    v1, v2, self.G[v1][v2]["formanCurvature"]))
+
+        elif self.method == "augmented":
+            # Edge Forman curvature
+            for (v1, v2) in self.G.edges():
                 v1_nbr = set(self.G.neighbors(v1))
                 v1_nbr.remove(v2)
                 v2_nbr = set(self.G.neighbors(v2))
                 v2_nbr.remove(v1)
-            face = v1_nbr & v2_nbr
-            # G[v1][v2]["face"]=face
-            prl_nbr = (v1_nbr | v2_nbr) - face
-            # G[v1][v2]["prl_nbr"]=prl_nbr
 
-            self.G[v1][v2]["formanCurvature"] = len(face) + 2 - len(prl_nbr)
+                face = v1_nbr & v2_nbr
+                # prl_nbr = (v1_nbr | v2_nbr) - face
+
+                w_e = self.G[v1][v2][self.weight]
+                w_f = 1  # Assume all face have weight 1
+                w_v1 = self.G.nodes[v1][self.weight]
+                w_v2 = self.G.nodes[v2][self.weight]
+
+                sum_ef = sum([w_e / w_f for _ in face])
+                sum_ve = sum([w_v1 / w_e + w_v2 / w_e])
 
-            logger.debug("Source: %s, target: %d, Forman-Ricci curvature = %f  " % (
-                v1, v2, self.G[v1][v2]["formanCurvature"]))
+                # sum_ehef = sum([math.sqrt(w_e*self.G[v1][v][self.weight])/w_f +
+                #                 math.sqrt(w_e*self.G[v2][v][self.weight])/w_f
+                #                 for v in face])
+                sum_ehef = 0  # Always 0 for cycle = 3 case.
+                sum_veeh = sum([w_v1 / math.sqrt(w_e * self.G[v1][v][self.weight]) for v in (v1_nbr - face)] +
+                               [w_v2 / math.sqrt(w_e * self.G[v2][v][self.weight]) for v in (v2_nbr - face)])
+
+                self.G[v1][v2]["formanCurvature"] = w_e * (sum_ef + sum_ve - math.fabs(sum_ehef - sum_veeh))
+
+                logger.debug("Source: %s, target: %d, Forman-Ricci curvature = %f  " % (
+                    v1, v2, self.G[v1][v2]["formanCurvature"]))
+
+        else:
+            assert True, 'Method %s not available. Support methods: {"1d","augmented"}' % self.method
 
         # Node Forman curvature
         for n in self.G.nodes():
@@ -84,6 +146,8 @@ def compute_ricci_curvature(self):
 
                 # assign the node Forman curvature to be the average of node's adjacency edges
                 self.G.nodes[n]['formanCurvature'] = fcsum / self.G.degree(n)
+            else:
+                self.G.nodes[n]['formanCurvature'] = fcsum
 
             logger.debug("node %d, Forman Curvature = %f" % (n, self.G.nodes[n]['formanCurvature']))
-        print("Forman curvature computation done.")
+        print("Forman curvature (%s) computation done." % self.method)

GraphRicciCurvature/OllivierRicci.py

@@ -500,16 +500,6 @@ def _compute_ricci_curvature(G: nx.Graph, weight="weight", **kwargs):
         A NetworkX graph with "ricciCurvature" on nodes and edges.
     """
 
-    if not nx.get_edge_attributes(G, weight):
-        logger.info('Edge weight not detected in graph, use "weight" as default edge weight.')
-        for (v1, v2) in G.edges():
-            G[v1][v2][weight] = 1.0
-
-    self_loop_edges = list(nx.selfloop_edges(G))
-    if self_loop_edges:
-        logger.info('Self-loop edge detected. Removing %d self-loop edges.' % len(self_loop_edges))
-        G.remove_edges_from(self_loop_edges)
-
     # compute Ricci curvature for all edges
     edge_ricci = _compute_ricci_curvature_edges(G, weight=weight, **kwargs)
 
@@ -701,6 +691,16 @@ def __init__(self, G: nx.Graph, weight="weight", alpha=0.5, method="Sinkhorn",
         assert importlib.util.find_spec("ot"), \
             "Package POT: Python Optimal Transport is required for Sinkhorn distance."
 
+        if not nx.get_edge_attributes(self.G, weight):
+            logger.info('Edge weight not detected in graph, use "weight" as default edge weight.')
+            for (v1, v2) in self.G.edges():
+                self.G[v1][v2][weight] = 1.0
+
+        self_loop_edges = list(nx.selfloop_edges(self.G))
+        if self_loop_edges:
+            logger.info('Self-loop edge detected. Removing %d self-loop edges.' % len(self_loop_edges))
+            self.G.remove_edges_from(self_loop_edges)
+
     def set_verbose(self, verbose):
         """Set the verbose level for this process.
 

GraphRicciCurvature/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "0.5.1"
+__version__ = "0.5.2"
 __author__ = "Chien-Chun Ni"
 __email__ = "saibalmars@gmail.com"

README.md

@@ -9,24 +9,24 @@ A Python library to compute Discrete Ricci curvature, Ricci flow, and Ricci comm
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 -----
-This work computes the **Ollivier-Ricci Curvature**[Ni], **Ollivier-Ricci Flow**[Ni2,Ni3], **Forman-Ricci Curvature**(or **Forman curvature**)[Sreejith], and **Ricci community**[Ni3] detected by Ollivier-Ricci flow metric.
+This work computes the **Ollivier-Ricci Curvature**[Ni], **Ollivier-Ricci Flow**[Ni2,Ni3], **Forman-Ricci Curvature**(or **Forman curvature**)[Sreejith, Samal], and **Ricci community**[Ni3] detected by Ollivier-Ricci flow metric.
 
 <p align="center">
 <img src="https://github.com/saibalmars/GraphRicciCurvature/raw/master/doc/_static/rf-manifold.png" title="Manifold Ricci flow" width="300" >
 <img src="https://github.com/saibalmars/GraphRicciCurvature/raw/master/doc/_static/karate_demo.png" title="karate club demo" width="500" >
 </p>
 
-Curvature is a geometric property to describe the local shape of an object. If we draw two parallel paths on a surface with positive curvature like a sphere, these two paths move closer to each other while for a negatively curved surface like a saddle, these two paths tend to be apart.
+Curvature is a geometric property to describe the local shape of an object. If we draw two parallel paths on a surface with positive curvature like a sphere, these two paths move closer to each other while for a negatively curved surface like a saddle, these two paths tend to be apart. Currently there are multiple ways to discretize curvature on graph, in this library, we include two of the most frequently used discrete Ricci curvature: **Ollivier-Ricci curvature** which is based on optimal transportation theory and **Forman-Ricci curvature** which is base on CW complexes.  
 
-In [Ni], we observe that the edge Ricci curvature plays an important role in the graph structure. An edge with positive curvature represents an edge within a cluster, while a negatively curved edge tent to be a bridge within clusters. Also, negatively curved edges are highly related to graph connectivity, with negatively curved edges removed from a connected graph, the graph soon become disconnected.
+In [Ni], edge Ricci curvature is observed to play an important role in the graph structure. An edge with positive curvature represents an edge within a cluster, while a negatively curved edge tent to be a bridge within clusters. Also, negatively curved edges are highly related to graph connectivity, with negatively curved edges removed from a connected graph, the graph soon become disconnected.
 
 Ricci flow is a process to uniformized the edge Ricci curvature of the graph. For a given graph, the Ricci flow gives a "Ricci flow metric" on each edge as edge weights, such that under these edge weights, the Ricci curvature of the graph is mostly equal everywhere. In [Ni3], this "Ricci flow metric" is shown to be able to detect communities.
 
 Both Ricci curvature and Ricci flow metric can act as a graph fingerprint for graph classification. The different graph gives different edge Ricci curvature distributions and different Ricci flow metric.
 
 Video demonstration of Ricci flow for community detection:
 <p align="center">
-<a href="https://youtu.be/QlENb_XlJ_8?t=20">
+<a href="https://youtu.be/QlENb_XlJ_8">
 <img src="https://github.com/saibalmars/GraphRicciCurvature/raw/master/doc/_static/ricci_community.png" title="Ricci Community" width="600" >
 </a>
 </p>
@@ -107,14 +107,15 @@ More example in [example.py](example.py).
 
 ## Reference
 
-[Ni]: Ni, C.-C., Lin, Y.-Y., Gao, J., Gu, X., and Saucan, E. 2015. "Ricci curvature of the Internet topology" (Vol. 26, pp. 2758–2766). Presented at the 2015 IEEE Conference on Computer Communications (INFOCOM), IEEE. [arXiv](https://arxiv.org/abs/1501.04138)
+[Ni]: Ni, C.-C., Lin, Y.-Y., Gao, J., Gu, X., and Saucan, E. "Ricci curvature of the Internet topology" (Vol. 26, pp. 2758–2766). Presented at the 2015 IEEE Conference on Computer Communications (INFOCOM), IEEE. [arXiv](https://arxiv.org/abs/1501.04138)
 
-[Ni2]: Ni, C.-C., Lin, Y.-Y., Gao, J., and Gu, X. 2018. "Network Alignment by Discrete Ollivier-Ricci Flow", Graph Drawing 2018, [arXiv](https://arxiv.org/abs/1809.00320)
+[Ni2]: Ni, C.-C., Lin, Y.-Y., Gao, J., and Gu, X. "Network Alignment by Discrete Ollivier-Ricci Flow", Graph Drawing 2018, [arXiv](https://arxiv.org/abs/1809.00320)
 
-[Ni3]: Ni, C.-C., Lin, Y.-Y., Luo, F. and Gao, J. 2019. "Community Detection on Networks with Ricci Flow", Scientific Reports, [arXiv](https://arxiv.org/abs/1907.03993)
+[Ni3]: Ni, C.-C., Lin, Y.-Y., Luo, F. and Gao, J. "Community Detection on Networks with Ricci Flow", Scientific Reports 9, 9984 (2019), [arXiv](https://arxiv.org/abs/1907.03993)
 
-[Sreejith]: Sreejith, R. P., Karthikeyan Mohanraj, Jürgen Jost, Emil Saucan, and Areejit Samal. 2016. “Forman Curvature for Complex Networks.” Journal of Statistical Mechanics: Theory and Experiment 2016 (6). IOP Publishing: 063206. [arxiv](https://arxiv.org/abs/1603.00386)
+[Sreejith]: Sreejith, R. P., Karthikeyan Mohanraj, Jürgen Jost, Emil Saucan, and Areejit Samal. "Forman Curvature for Complex Networks." Journal of Statistical Mechanics: Theory and Experiment 2016 (6). IOP Publishing: 063206. [arxiv](https://arxiv.org/abs/1603.00386)
 
+[Samal]: Samal, A., Sreejith, R.P., Gu, J. et al. "Comparative analysis of two discretizations of Ricci curvature for complex networks." Scientific Report 8, 8650 (2018). [arXiv](https://arxiv.org/abs/1712.07600)
 
 ## Contact