pyfglt 0.3.0__cp39-cp39-win_amd64.whl

pyfglt/fglt.py

@@ -0,0 +1,201 @@
+import numpy
+import scipy.sparse as sp
+from scipy.sparse import csc_matrix, issparse
+
+import networkx as nx
+import numpy as np
+from typeguard import typechecked
+from typing import Union
+
+from pyfglt import _fglt_c
+
+import pandas as pd
+
+COLUMNS = [
+    "[0] vertex (==1)",
+    "[1] degree",
+    "[2] 2-path",
+    "[3] bifork",
+    "[4] 3-cycle",
+    "[5] 3-path, end",
+    "[6] 3-path, interior",
+    "[7] claw, leaf",
+    "[8] claw, root",
+    "[9] paw, handle",
+    "[10] paw, base",
+    "[11] paw, center",
+    "[12] 4-cycle",
+    "[13] diamond, off-cord",
+    "[14] diamond, on-cord",
+    "[15] 4-clique",
+]
+
+@typechecked
+def compute(A: Union[nx.Graph, csc_matrix], raw: bool = False) -> Union[pd.DataFrame, tuple[pd.DataFrame, pd.DataFrame]]:
+    """Compute the counts fo the Fast Graphlet Transform.
+
+    Args:
+        A (Union[nx.Graph, csc_matrix]): Either the graph as a `networkx.Graph` object 
+                                         or the adjacency matrix of the graph in `scipy.sparse.csc_matrix` format.
+        raw (bool): If True, return both the raw and the net counts of the graphlets. 
+                    If False, then return only the normalized counts. 
+                    Defaults to False.
+
+    Accepts either an undirected, unweighted NetworkX graph or a CSC sparse matrix.
+    If a NetworkX graph is provided, converts it to a CSC adjacency matrix.
+    If a CSC matrix is provided, verifies that it is unweighted and symmetric.
+
+    Returns:
+        F (DataFrame): A dataframe with the net counts of the graphlets.
+        F_raw (DataFrame): A dataframe with the raw counts of the graphlets (if raw=True).
+    """
+
+    # If input is a NetworkX graph
+    if isinstance(A, nx.Graph):
+        # Ensure it's undirected
+        if A.is_directed():
+            raise ValueError("Graph must be undirected.")
+        
+        # Convert to adjacency matrix in CSC format
+        adj_matrix = nx.adjacency_matrix(A)
+        csc_adj = adj_matrix.tocsc()
+
+    # If input is already a CSC matrix
+    elif issparse(A) and isinstance(A, csc_matrix):
+        csc_adj = A  # Use directly
+
+        # Ensure symmetry (A == A.T)
+        if not (abs(csc_adj - csc_adj.T)).nnz == 0:
+            raise ValueError("CSC matrix must be symmetric (undirected graph).")
+
+        # Ensure unweighted (all elements are 0 or 1)
+        if not np.all(np.isin(csc_adj.data, [0, 1])):
+            raise ValueError("CSC matrix must be unweighted (contain only 0s and 1s).")
+        
+    else:
+        raise TypeError("Input must be either a NetworkX undirected graph or a CSC matrix.")
+
+    f, fn = _fglt_c.count(csc_adj)
+
+    # cast f and fn to int64
+    f = f.astype(numpy.int64)
+    fn = fn.astype(numpy.int64)
+
+    # transpose f and fn
+    f = f.T
+    fn = fn.T
+
+    # transform to dataframe
+    F  = pd.DataFrame(f, columns=COLUMNS)
+    FN = pd.DataFrame(fn, columns=COLUMNS)
+
+    # set index name to "Node id (0-based)"
+    F.index.name = "Node id (0-based)"
+    FN.index.name = "Node id (0-based)"
+
+    if raw:
+        return FN, F
+    else:
+        return FN
+
+@typechecked
+def compute_rgf_distance(df_g1:pd.DataFrame, df_g2:pd.DataFrame) -> float:
+    """Relative Graphlet Frequency (RGF)
+
+    Args:
+        df_g1 (pd.DataFrame): Orbit counts for Graph 1 (rows=vertices, columns=orbits).
+        df_g2 (pd.DataFrame): Orbit counts for Graph 2 (rows=vertices, columns=orbits).
+
+    Compute the Relative Graphlet Frequency (RGF) distance between two graphs
+    represented by DataFrames of orbit counts.
+        
+    Returns:
+        d (float): The RGF distance between the two graphs.
+    """
+
+    # Sum of orbit counts across all vertices for each orbit
+    orbit_sums_g1 = df_g1.sum(axis=0)  # Series of length = number_of_orbits
+    orbit_sums_g2 = df_g2.sum(axis=0)
+
+    # Compute total counts
+    total_g1 = orbit_sums_g1.sum()
+    total_g2 = orbit_sums_g2.sum()
+
+    # Relative frequencies for each orbit
+    rel_freq_g1 = orbit_sums_g1 / total_g1 if total_g1 != 0 else orbit_sums_g1 * 0
+    rel_freq_g2 = orbit_sums_g2 / total_g2 if total_g2 != 0 else orbit_sums_g2 * 0
+
+    # RGF distance = sum of absolute differences
+    rgf_distance = np.sum(np.abs(rel_freq_g1 - rel_freq_g2))
+    return rgf_distance
+
+
+@typechecked
+def compute_graphlet_correlation_matrix(df_g:pd.DataFrame, method='spearman'):
+    """
+    Compute the Graphlet Correlation Matrix (GCM) for a single graph.
+
+    Args:
+        df_g (pd.DataFrame): Orbit counts for a graph (rows=vertices, columns=orbits).
+        method (str) Correlation method. Can be 'pearson', 'spearman', or 'kendall'.
+
+    Returns:
+        C (pd.DataFrame): Correlation matrix of shape (n_orbits, n_orbits).
+    """
+    return df_g.iloc[:,1:].corr(method=method)
+
+
+@typechecked
+def gcm_distance(gcm1:pd.DataFrame, gcm2:pd.DataFrame):
+    """
+    Compute a simple distance between two correlation matrices.
+    For instance, the sum of absolute differences (L1 distance).
+
+    Args:
+        gcm1 (pd.DataFrame): GCM of the first graph
+        gcm2 (pd.DataFrame): GCM of the second graph
+
+    Returns:
+        d (float): A distance measure between the two GCMs.
+    """
+    diff = gcm1.values - gcm2.values
+    return np.sum(np.abs(diff))
+
+
+@typechecked
+def compute_gdd_agreement(df_g1: pd.DataFrame, df_g2:pd.DataFrame, bins=None):
+    """
+    Compute Graphlet Degree Distribution (GDD) agreement between two graphs.
+
+    Args:
+        df_g1 (pd.DataFrame): Orbit counts for Graph 1 (rows=vertices, columns=orbits).
+        df_g2 (pd.DataFrame): Orbit counts for Graph 2 (rows=vertices, columns=orbits).
+        bins (Union[int, sequence]): Bins for histogram. If None, will try an automatic approach.
+
+    Returns:
+        s (float): The GDD agreement in [0, 1].
+    """
+    n_orbits = df_g1.shape[1]
+    # We assume df_g1 and df_g2 have the same shape: #orbits = n_orbits
+
+    # We can find a reasonable range for all orbit degrees combined
+    combined_max = max(df_g1.values.max(), df_g2.values.max())
+    if bins is None:
+        # We'll bin from 0 up to the max count + 1
+        bins = np.arange(0, combined_max + 2) - 0.5  # so that each integer is its own bin
+
+    overlaps = []
+    
+    for orbit_col in df_g1.columns:
+        # Distribution for Graph 1, orbit_col
+        hist_g1, _ = np.histogram(df_g1[orbit_col], bins=bins, density=True)
+        # Distribution for Graph 2, orbit_col
+        hist_g2, _ = np.histogram(df_g2[orbit_col], bins=bins, density=True)
+        
+        # Overlap for this orbit
+        overlap = np.sum(np.minimum(hist_g1, hist_g2))
+        overlaps.append(overlap)
+    
+    # Average overlap across orbits
+    gdd_agreement = np.mean(overlaps)
+    return gdd_agreement

pyfglt-0.3.0.data/headers/fglt.hpp

@@ -0,0 +1,70 @@
+/*!
+  \file   fglt.hpp
+  \brief  Header file containing basic function definitinos for FGlT
+
+  \author Dimitris Floros
+  \date   2020-08-18
+*/
+
+
+#ifndef FGLT_H_
+#define FGLT_H_
+
+#include <stdio.h>
+#include <cstdlib>
+#include <cmath>
+#include <ctype.h>
+
+#include <sys/time.h>
+
+// type definitions
+#ifdef MX_COMPAT_32
+typedef int mwSize;
+typedef int mwIndex;
+#else
+typedef size_t    mwSize;         /* unsigned pointer-width integer */
+typedef size_t    mwIndex;        /* unsigned pointer-width integer */
+#endif
+
+#define NGRAPHLET 16
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * \brief Get the number of parallel workers available.
+ *
+ * \return The number of workers available. Always 1 when built without Cilk support.
+ */
+int getWorkers();
+
+/*!
+ * \brief Perform the FGLT transform.
+ *
+ * \param f [out] An array-of-pointers of size (n, 16) where the raw frequencies should be stored.
+ * \param fn [out] An array-of-pointers of size (n, 16) where the net frequencies should be stored.
+ * \param ii [in] The column indices of the adjacency matrix.
+ * \param jStart [in] The first non-zero row index of each column.
+ * \param n [in] The number of columns of the adjacency matrix.
+ * \param m [in] The number of nonzero elements in the adjacency matrix.
+ * \param np [in] The number of parallel workers to use for the transform.
+ * \return status (0: success, otherwise error)
+ */
+int compute
+  (
+   double ** const f,
+   double ** const fn,
+   mwIndex *ii,
+   mwIndex *jStart,
+   mwSize n,
+   mwSize m,
+   mwSize np
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FGLT_H_ */

pyfglt-0.3.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.1
+Name: pyfglt
+Version: 0.3.0
+Summary: Python package/wrapper of Fast Graphlet Transform
+Author: Dimitris Floros
+License: Apache-2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Project-URL: Homepage, https://github.com/fcdimitr/pyfglt
+Project-URL: Changelog, https://github.com/fcdimitr/pyfglt/releases
+Project-URL: Issues, https://github.com/fcdimitr/pyfglt/issues
+Project-URL: CI, https://github.com/fcdimitr/pyfglt/actions
+Project-URL: Documentation, https://fcdimitr.github.io/pyfglt/
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.19.5
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: networkx>=3.2.1
+Requires-Dist: typeguard>=4.4.1
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5.50; extra == "docs"
+Requires-Dist: mkdocstrings>=0.27.0; extra == "docs"
+Requires-Dist: mkdocstrings-python>=1.13.0; extra == "docs"
+Requires-Dist: matplotlib>=3.10.0; extra == "docs"
+Requires-Dist: jupyter>=1.1.1; extra == "docs"
+Requires-Dist: tabulate>=0.9.0; extra == "docs"
+Requires-Dist: seaborn>=0.13.2; extra == "docs"
+Description-Content-Type: text/markdown
+
+# pyfglt
+
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg?style=flat)](https://fcdimitr.github.io/pyfglt/)
+[![PyPI](https://img.shields.io/pypi/v/pyfglt.svg)](https://pypi.org/project/pyfglt/)
+[![Tests](https://github.com/fcdimitr/pyfglt/actions/workflows/test.yml/badge.svg)](https://github.com/fcdimitr/pyfglt/actions/workflows/test.yml)
+[![Changelog](https://img.shields.io/github/v/release/fcdimitr/pyfglt?include_prereleases&label=changelog)](https://github.com/fcdimitr/pyfglt/releases)
+[![License](https://img.shields.io/github/license/fcdimitr/pyfglt)](https://github.com/fcdimitr/pyfglt/blob/main/LICENSE)
+
+Python package/wrapper of Fast Graphlet Transform. See the [documentation
+overview](https://fcdimitr.github.io/pyfglt/) for more information.
+
+## Installation
+
+Install this library using `pip`:
+```bash
+pip install pyfglt
+```
+## Usage
+
+See the examples under:
+
+- [Getting started](https://fcdimitr.github.io/pyfglt/tutorial/01-getting-started)
+- [Advanced usage](https://fcdimitr.github.io/pyfglt/tutorial/02-graphlet-based-network-properties)
+
+## Citation
+
+If you use this package, please cite this paper:
+
+```bibtex
+@article{fglt,
+    author = {Floros, Dimitris and Pitsianis, Nikos and Sun, Xiaobai},
+    journal = {IEEE HPEC},
+    pages = {1--8},
+    title = {{Fast graphlet transform of sparse graphs}},
+    year = {2020}
+}
+```
+
+## **How to Contribute?**
+If you’d like to contribute, feel free to submit a PR! 🚀
+
+
+To contribute to this library, first checkout the code. Then create a new virtual environment:
+```bash
+cd pyfglt
+python -m venv venv
+source venv/bin/activate
+```
+Now install the dependencies and test dependencies:
+```bash
+python -m pip install -e '.[test]'
+```
+To run the tests:
+```bash
+python -m pytest
+```
+
+## **Contributors**
+
+Below is a categorized list of contributors.
+
+### **Design and Development**
+
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/fcdimitr"><img src="https://github.com/fcdimitr.png" width="60px;" alt=""/><br /><sub><b>Dimitris Floros<br/>@fcdimitr</b></sub></a></td>
+    <td align="center"><a href="https://github.com/pitsianis"><img src="https://github.com/pitsianis.png" width="60px;" alt=""/><br /><sub><b>Nikos Pitsianis<br/>@pitsianis</b></sub></a></td>
+    <td align="center"><a href="https://spire.duke.edu/xiaobai-sun"><img src="https://spire.duke.edu/sites/spire.duke.edu/files/styles/square_small/public/2022-08/xiaobai%20%281%29.jpg?h=735f7c84&itok=mUth7Zqn" width="60px;" alt=""/><br /><sub><b>Xiaobai Sun<br/> _ </b></sub></a></td>
+  </tr>
+</table>
+
+---
+
+### **Development of Python & Julia Wrappers**
+
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/nsailor"><img src="https://github.com/nsailor.png" width="60px;" alt=""/><br /><sub><b>Jason Barmparesos<br/>@nsailor</b></sub></a></td>
+    <td align="center"><a href="https://github.com/kitsiosk"><img src="https://github.com/kitsiosk.png" width="60px;" alt=""/><br /><sub><b>Kitsios Konstantinos<br/>@kitsiosk</b></sub></a></td>
+  </tr>
+</table>
+
+---
+
+### **Helpful Comments and Bug Fixes**
+
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/georgebisbas"><img src="https://github.com/georgebisbas.png" width="60px;" alt=""/><br /><sub><b>George Bisbas<br/>@georgebisbas</b></sub></a></td>
+  </tr>
+</table>
+
+<!-- ---
+
+### **🫶 We Also Thank the Following People**
+We appreciate the valuable feedback, discussions, and testing provided by:
+
+- [@username7](https://github.com/username7)
+- [@username8](https://github.com/username8)
+- [@username9](https://github.com/username9) -->
+
+---

pyfglt-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyfglt-0.3.0.dist-info/METADATA,sha256=AYlqNaZIiEU6iRpepqLnLAsriYntjTaSHVVTWmsVT_k,4782
+pyfglt-0.3.0.dist-info/WHEEL,sha256=8AdrFzOtKQ6LLJ-VyqCU3y1iN8N--fMXYqrdkeTKDn0,83
+pyfglt/_fglt_c.cp39-win_amd64.pyd,sha256=4DRZAAnnK5PGtQ3uLiUxb9E40yDG37hJ8L1ZPmT5CoM,252083
+pyfglt/_fglt_c.cp39-win_amd64.dll.a,sha256=uTVkOciL9PGQZTHhucrU_n12ErSbz_ERNJIrzUNwUUg,1714
+pyfglt/fglt.py,sha256=HpfrvKVVNiNuyDCRBAN0L0DLuGSIGJZqmwEsdpaYGC0,6857
+pyfglt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyfglt-0.3.0.data/headers/fglt.hpp,sha256=y-7XcVVNLwVXY-nNQfwGGiw8QkMWQ_stgaLeDzlWzv0,1648
+pyfglt-0.3.0.dist-info/RECORD,,

pyfglt-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64