Upload 59 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+GMatch4py/source/logo2.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "GMatch4py/mcp_output/start_mcp.py"]

GMatch4py/mcp_output/README_MCP.md

@@ -0,0 +1,48 @@
+# GMatch4py MCP (Model Context Protocol) Service
+
+## Project Introduction
+GMatch4py is a Python library designed for graph matching tasks. It provides a suite of tools and services to facilitate the comparison and analysis of graph structures. The library is structured to support various graph matching algorithms and is ideal for developers looking to integrate graph-based solutions into their applications.
+
+## Installation Method
+To install GMatch4py, ensure you have Python installed on your system. The library's dependencies are listed in the `requirements.txt` file. You can install the necessary packages using pip:
+
+pip install -r requirements.txt
+
+Alternatively, you can install the package directly from the source:
+
+git clone https://github.com/jacquesfize/GMatch4py.git
+cd GMatch4py
+python setup.py install
+
+## Quick Start
+To quickly get started with GMatch4py, you can use the following example to call the main functions:
+
+1. Import the library:
+
+import gmatch4py
+
+2. Use the graph matching services:
+
+# Example of using a graph matching service
+matcher = gmatch4py.SomeMatcher()
+result = matcher.compare(graph1, graph2)
+
+Replace `SomeMatcher` with the specific matcher you wish to use.
+
+## Available Tools and Endpoints List
+GMatch4py offers several services categorized under different modules:
+
+- `gmatch4py.embedding`: Services for graph embedding.
+- `gmatch4py.ged`: Services for graph edit distance calculations.
+- `gmatch4py.helpers`: Utility services to assist with graph operations.
+- `gmatch4py.kernels`: Services for graph kernel computations.
+
+Each module provides specialized functions to handle various aspects of graph matching and analysis.
+
+## Common Issues and Notes
+- Ensure all dependencies are installed as specified in `requirements.txt`.
+- The library is designed to be lightweight with a low intrusiveness risk and simple complexity.
+- Performance may vary based on the size and complexity of the graphs being processed.
+
+## Reference Links or Documentation
+For more information, visit the [GMatch4py GitHub repository](https://github.com/jacquesfize/GMatch4py). The repository contains additional documentation and resources to help you make the most of the library.

GMatch4py/mcp_output/analysis.json

@@ -0,0 +1,119 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/jacquesfize/GMatch4py",
+    "summary": "Imported via zip fallback, file count: 11",
+    "file_tree": {
+      ".travis.yml": {
+        "size": 223
+      },
+      "README.md": {
+        "size": 6332
+      },
+      "gmatch4py/__init__.py": {
+        "size": 726
+      },
+      "gmatch4py/embedding/__init__.py": {
+        "size": 0
+      },
+      "gmatch4py/ged/__init__.py": {
+        "size": 18
+      },
+      "gmatch4py/helpers/__init__.py": {
+        "size": 16
+      },
+      "gmatch4py/kernels/__init__.py": {
+        "size": 16
+      },
+      "requirements.txt": {
+        "size": 44
+      },
+      "setup.py": {
+        "size": 2812
+      },
+      "test/gmatch4py_performance_test.py": {
+        "size": 1230
+      },
+      "test/test.py": {
+        "size": 6131
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.gmatch4py",
+      "source.gmatch4py.embedding",
+      "source.gmatch4py.ged",
+      "source.gmatch4py.helpers",
+      "source.gmatch4py.kernels"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": true,
+    "pyproject": false,
+    "setup_cfg": false,
+    "setup_py": true
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "setup",
+        "module": "setup",
+        "functions": [
+          "makeExtension",
+          "scandir"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "scandir": [
+            "dir",
+            "files"
+          ],
+          "makeExtension": [
+            "extName"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.9
+    },
+    "dependencies": {
+      "required": [],
+      "optional": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "low",
+      "complexity": "simple"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/jacquesfize/GMatch4py",
+    "repo_name": "GMatch4py",
+    "content": "jacquesfize/GMatch4py\nA graph matching library for Python\nRepository Not Indexed\nThis repository hasn't been indexed yet. Indexing allows you to explore code structure, find documentation, and understand dependencies.\nIndexing typically takes 2-10 minutes to complete after it starts indexing\nOnce indexed, you'll have full access to code exploration and search functionality",
+    "model": "gpt-4o-2024-08-06",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o-2024-08-06"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "low",
+    "complexity": "simple"
+  }
+}

GMatch4py/mcp_output/diff_report.md

@@ -0,0 +1,66 @@
+# Difference Report for GMatch4py Project
+
+## Project Overview
+
+**Repository:** GMatch4py  
+**Project Type:** Python Library  
+**Main Features:** Basic Functionality  
+**Report Generated On:** 2026-02-07 13:40:57  
+
+GMatch4py is a Python library designed to provide graph matching functionalities. It is widely used in applications requiring graph comparison and analysis. The project aims to offer efficient and easy-to-use tools for researchers and developers working with graph data structures.
+
+## Difference Analysis
+
+### Summary of Changes
+
+- **New Files Added:** 8
+- **Modified Files:** 0
+- **Intrusiveness:** None
+- **Workflow Status:** Success
+- **Test Status:** Failed
+
+### New Files
+
+The addition of 8 new files suggests an expansion in the library's capabilities or the introduction of new features. However, without modifications to existing files, it appears that these changes are isolated and do not alter the core functionality of the library.
+
+### Workflow and Test Status
+
+- **Workflow Status:** The workflow has been executed successfully, indicating that the integration and deployment processes are functioning as expected.
+- **Test Status:** The test status is marked as failed, which is a critical issue that needs immediate attention. This failure suggests that the new additions may have introduced bugs or that the existing test cases are not comprehensive enough to cover the new functionalities.
+
+## Technical Analysis
+
+### New Files
+
+The introduction of new files could include additional modules, scripts, or resources that enhance the library's capabilities. A detailed review of these files is necessary to understand their purpose and integration within the existing framework.
+
+### Test Failures
+
+The failure in testing indicates potential issues in the new code. It is crucial to identify whether the failures are due to:
+- Incompatibility with existing code.
+- Insufficient or outdated test cases.
+- Bugs introduced in the new files.
+
+## Recommendations and Improvements
+
+1. **Conduct a Detailed Code Review:** Examine the new files to ensure they adhere to the project's coding standards and integrate seamlessly with existing components.
+
+2. **Enhance Test Coverage:** Update and expand the test suite to include cases for the new functionalities. Ensure that all edge cases are considered to prevent future failures.
+
+3. **Debug and Resolve Test Failures:** Identify the root cause of the test failures and implement fixes. This may involve debugging the new code or refining the test cases.
+
+4. **Documentation Update:** Ensure that the documentation reflects the new changes, providing clear guidance on how to utilize the new features.
+
+## Deployment Information
+
+The successful workflow status indicates that the deployment pipeline is operational. However, given the test failures, it is advisable to hold off on deploying the new version until all issues are resolved and the test status is marked as successful.
+
+## Future Planning
+
+- **Regular Updates:** Schedule regular updates and reviews to ensure the library remains robust and up-to-date with the latest developments in graph matching algorithms.
+- **Community Engagement:** Encourage community feedback and contributions to identify potential areas for improvement and new feature requests.
+- **Performance Optimization:** Continuously monitor and optimize the library's performance to handle larger datasets efficiently.
+
+## Conclusion
+
+The GMatch4py project has seen significant additions with the introduction of new files. However, the test failures highlight the need for immediate attention to ensure the library's reliability and functionality. By addressing the recommendations outlined in this report, the project can continue to provide valuable tools for graph analysis and maintain its reputation as a reliable Python library.

GMatch4py/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,87 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from gmatch4py.setup import makeExtension, scandir
+except ImportError as e:
+    print("Failed to import modules from gmatch4py. Ensure the source directory is correctly set.")
+    raise e
+
+class Adapter:
+    """
+    Adapter class for the MCP plugin, utilizing the GMatch4py library.
+    This class provides methods to interact with the core functionalities of the library.
+    """
+
+    def __init__(self):
+        """
+        Initialize the Adapter class with default settings.
+        """
+        self.mode = "import"
+
+    # -------------------------------------------------------------------------
+    # Function Call Methods
+    # -------------------------------------------------------------------------
+
+    def call_make_extension(self, *args, **kwargs):
+        """
+        Call the makeExtension function from gmatch4py.setup.
+
+        Parameters:
+        - args: Positional arguments for makeExtension.
+        - kwargs: Keyword arguments for makeExtension.
+
+        Returns:
+        - dict: A dictionary containing the status and result or error message.
+        """
+        try:
+            result = makeExtension(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to call makeExtension: {str(e)}"}
+
+    def call_scandir(self, *args, **kwargs):
+        """
+        Call the scandir function from gmatch4py.setup.
+
+        Parameters:
+        - args: Positional arguments for scandir.
+        - kwargs: Keyword arguments for scandir.
+
+        Returns:
+        - dict: A dictionary containing the status and result or error message.
+        """
+        try:
+            result = scandir(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to call scandir: {str(e)}"}
+
+    # -------------------------------------------------------------------------
+    # Error Handling and Fallback
+    # -------------------------------------------------------------------------
+
+    def handle_import_failure(self):
+        """
+        Handle import failures gracefully and provide guidance.
+
+        Returns:
+        - dict: A dictionary containing the status and guidance message.
+        """
+        return {
+            "status": "error",
+            "message": "Import failed. Please ensure the source directory is correctly set and all dependencies are installed."
+        }
+
+# Example usage
+if __name__ == "__main__":
+    adapter = Adapter()
+    result = adapter.call_make_extension()
+    print(result)
+    result = adapter.call_scandir()
+    print(result)

GMatch4py/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

GMatch4py/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,42 @@
+import os
+import sys
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+
+from setup import scandir, makeExtension
+
+mcp = FastMCP("unknown_service")
+
+
+@mcp.tool(name="makeExtension", description="Auto-wrapped function makeExtension")
+def makeExtension(payload: dict):
+    try:
+        if makeExtension is None:
+            return {"success": False, "result": None, "error": "Function makeExtension is not available"}
+        result = makeExtension(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="scandir", description="Auto-wrapped function scandir")
+def scandir(payload: dict):
+    try:
+        if scandir is None:
+            return {"success": False, "result": None, "error": "Function scandir is not available"}
+        result = scandir(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+
+def create_app():
+    """Create and return FastMCP application instance"""
+    return mcp
+
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=8000)

GMatch4py/mcp_output/requirements.txt

@@ -0,0 +1,9 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+decorator
+scipy
+networkx==2.1
+numpy
+cython

GMatch4py/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

GMatch4py/mcp_output/workflow_summary.json

@@ -0,0 +1,198 @@
+{
+  "repository": {
+    "name": "GMatch4py",
+    "url": "https://github.com/jacquesfize/GMatch4py",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/GMatch4py",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "simple",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1770442744.920794,
+    "end_time": 1770442802.9103656,
+    "duration": 57.989572286605835,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 5,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.gmatch4py",
+        "source.gmatch4py.embedding",
+        "source.gmatch4py.ged",
+        "source.gmatch4py.helpers",
+        "source.gmatch4py.kernels"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": true,
+      "pyproject": false,
+      "setup_cfg": false,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "low",
+      "complexity": "simple"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/jacquesfize/GMatch4py",
+      "repo_name": "GMatch4py",
+      "content": "jacquesfize/GMatch4py\nA graph matching library for Python\nRepository Not Indexed\nThis repository hasn't been indexed yet. Indexing allows you to explore code structure, find documentation, and understand dependencies.\nIndexing typically takes 2-10 minutes to complete after it starts indexing\nOnce indexed, you'll have full access to code exploration and search functionality",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/GMatch4py/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Improve test coverage by adding more unit tests",
+    "Ensure all existing tests are passing and fix any failing tests",
+    "Consider indexing the repository to enhance code exploration and search functionality",
+    "Update the README file to include detailed setup and usage instructions",
+    "Verify and update dependencies in requirements.txt to ensure compatibility",
+    "Consider adding a pyproject.toml or setup.cfg for better dependency management",
+    "Review and optimize the plugin code for performance improvements",
+    "Conduct a code review to identify potential code quality issues",
+    "Implement continuous integration to automate testing and deployment",
+    "Document the core modules and functions for better maintainability."
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Successful execution of all workflow nodes",
+      "Healthy service status of the MCP plugin"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Efficient download with no delays",
+      "analysis_time": "Completed within expected time frame",
+      "generation_time": "Code generation was swift and successful",
+      "test_time": "Testing was limited due to lack of original project test success"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Memory usage data not available",
+      "cpu_efficiency": "CPU usage data not available",
+      "disk_usage": "Disk usage was minimal due to small project size"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 75,
+    "architecture_score": 70,
+    "performance_score": 65,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 70
+  }
+}

GMatch4py/source/.travis.yml

@@ -0,0 +1,14 @@
+language: python
+python:
+  - "3.6"
+
+notifications:
+  email: false
+
+install:
+    - pip install cython numpy networkx scipy scikit-learn pandas gensim joblib gensim psutil --upgrade
+    - pip install .
+
+script:
+  - echo "1"
+

GMatch4py/source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jacques Fize
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

GMatch4py/source/README.md

@@ -0,0 +1,160 @@
+![](logo2.png)
+
+
+[![Build Status](https://travis-ci.com/Jacobe2169/GMatch4py.svg?branch=master)](https://travis-ci.com/Jacobe2169/GMatch4py)
+# GMatch4py a graph matching library for Python 
+
+
+GMatch4py is a library dedicated to graph matching. Graph structure are stored in NetworkX graph objects.
+GMatch4py algorithms were implemented with Cython to enhance performance.
+
+## Requirements
+
+ * Python 3
+ * Numpy and Cython installed (if not : `(sudo) pip(3) install numpy cython`)
+ 
+## Installation
+
+To install `GMatch4py`, run the following commands:
+
+```bash
+git clone https://github.com/Jacobe2169/GMatch4py.git
+cd GMatch4py
+(sudo) pip(3) install .
+```
+
+## Get Started
+### Graph input format
+
+In `GMatch4py`, algorithms manipulate `networkx.Graph`, a complete graph model that 
+comes with a large spectrum of parser to load your graph from various inputs : `*.graphml,*.gexf,..` (check [here](https://networkx.github.io/documentation/stable/reference/readwrite/index.html) to see all the format accepted)
+
+### Use GMatch4py
+If you want to use algorithms like *graph edit distances*, here is an example:
+
+```python
+# Gmatch4py use networkx graph 
+import networkx as nx 
+# import the GED using the munkres algorithm
+import gmatch4py as gm
+```
+
+In this example, we use generated graphs using `networkx` helpers:
+```python
+g1=nx.complete_bipartite_graph(5,4) 
+g2=nx.complete_bipartite_graph(6,4)
+```
+
+All graph matching algorithms in `Gmatch4py` work this way:
+ * Each algorithm is associated with an object, each object having its specific parameters. In this case, the parameters are the edit costs (delete a vertex, add a vertex, ...)
+ * Each object is associated with a `compare()` function with two parameters. First parameter is **a list of the graphs** you want to **compare**, i.e. measure the distance/similarity (depends on the algorithm). Then, you can specify a sample of graphs to be compared to all the other graphs. To this end, the second parameter should be **a list containing the indices** of these graphs (based on the first parameter list). If you rather compute the distance/similarity **between all graphs**, just use the `None` value.
+
+```python
+ged=gm.GraphEditDistance(1,1,1,1) # all edit costs are equal to 1
+result=ged.compare([g1,g2],None) 
+print(result)
+```
+
+The output is a similarity/distance matrix :
+```python
+array([[0., 14.],
+       [10., 0.]])
+```
+This output result is "raw", if you wish to have normalized results in terms of distance (or similarity) you can use :
+
+```python
+ged.similarity(result)
+# or 
+ged.distance(result)
+```
+
+## Exploit nodes and edges attributes
+
+In this latest version, we add the possibility to exploit graph attributes ! To do so, the `base.Base` is extended with the `set_attr_graph_used(node_attr,edge_attr)` method.
+
+```python
+import networkx as nx 
+import gmatch4py as gm
+ged = gm.GraphEditDistance(1,1,1,1)
+ged.set_attr_graph_used("theme","color") # Edge colors and node themes attributes will be used.
+```
+
+## List of algorithms
+
+ * Graph Embedding
+    * Graph2Vec [1]
+ * Node Embedding
+    * DeepWalk [7]
+    * Node2vec [8]
+ * Graph kernels
+    * Random Walk Kernel (*debug needed*) [3]
+        * Geometrical 
+        * K-Step 
+    * Shortest Path Kernel [3]
+    * Weisfeiler-Lehman Kernel [4]
+        * Subtree Kernel 
+ * Graph Edit Distance [5]
+    * Approximated Graph Edit Distance 
+    * Hausdorff Graph Edit Distance 
+    * Bipartite Graph Edit Distance 
+    * Greedy Edit Distance
+ * Vertex Ranking [2]
+ * Vertex Edge Overlap [2]
+ * Bag of Nodes (a bag of words model using nodes as vocabulary)
+ * Bag of Cliques (a bag of words model using cliques as vocabulary)
+ * MCS [6]
+    
+
+## Publications associated
+
+  * [1] Narayanan, Annamalai and Chandramohan, Mahinthan and Venkatesan, Rajasekar and Chen, Lihui and Liu, Yang. Graph2vec: Learning distributed representations of graphs. MLG 2017, 13th International Workshop on Mining and Learning with Graphs (MLGWorkshop 2017).
+  * [2] Papadimitriou, P., Dasdan, A., & Garcia-Molina, H. (2010). Web graph similarity for anomaly detection. Journal of Internet Services and Applications, 1(1), 19-30.
+  * [3] Vishwanathan, S. V. N., Schraudolph, N. N., Kondor, R., & Borgwardt, K. M. (2010). Graph kernels. Journal of Machine Learning Research, 11(Apr), 1201-1242.
+  * [4] Shervashidze, N., Schweitzer, P., Leeuwen, E. J. V., Mehlhorn, K., & Borgwardt, K. M. (2011). Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(Sep), 2539-2561.
+  * [5] Fischer, A., Riesen, K., & Bunke, H. (2017). Improved quadratic time approximation of graph edit distance by combining Hausdorff matching and greedy assignment. Pattern Recognition Letters, 87, 55-62.
+  * [6] A graph distance metric based on the maximal common subgraph, H. Bunke and K. Shearer, Pattern Recognition Letters, 1998  
+  * [7] Perozzi, B., Al-Rfou, R., & Skiena, S. (2014, August). Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 701-710). ACM.
+  * [8] node2vec: Scalable Feature Learning for Networks. Aditya Grover and Jure Leskovec. Knowledge Discovery and Data Mining, 2016.
+
+## Author(s)
+
+Jacques Fize, *jacques[dot]fize[at]cirad[dot]fr*
+
+Some algorithms from other projects were integrated to Gmatch4py. **Be assured that
+each code is associated with a reference to the original.**
+
+
+## CHANGELOG
+
+### 18.06.2022
+ * Debug the `skipgram` import
+ * Gmatch4py should work with new gensim version
+
+
+### 7.05.2019
+
+ * Debug (problems with float edge weight)
+ * Add the `AbstractEditDistance.edit_path(G,H)` method that return the edit path, the cost matrix and the selected cost index in the cost matrix
+ * Add a tqdm progress bar for the `gmatch4py.helpers.reader.import_dir()` function
+
+### 12.03.2019
+
+ * Add Node2vec
+
+### 05.03.2019
+
+ * Add Graph Embedding algorithms
+ * Remove depreciated methods and classes
+ * Add logo
+ * Update documentation
+
+
+### 25.02.2019
+ * Add New Graph Class. Features : Cython Extensions, precomputed values (degrees, neighbor info), hash representation of edges and nodes for a faster comparison
+ * Some algorithms are parallelized such as graph edit distances or Jaccard
+
+## TODO List
+
+  * Debug algorithms --> Random Walk Kernel, Deltacon
+  * Optimize algorithms --> Vertex Ranking
+

GMatch4py/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+GMatch4py Project Package Initialization File
+"""

GMatch4py/source/gmatch4py/__init__.py

@@ -0,0 +1,27 @@
+# coding = utf-8
+
+# Graph Edit Distance algorithms import
+from .ged.graph_edit_dist import *
+from .ged.greedy_edit_distance import *
+from .ged.bipartite_graph_matching_2 import *
+from .ged.hausdorff_edit_distance import *
+
+# Kernels algorithms import
+from .kernels.weisfeiler_lehman import *
+from .kernels.shortest_path_kernel import *
+
+# Graph Embedding import
+from .embedding.graph2vec import *
+from .embedding.deepwalk import *
+from .embedding.node2vec import *
+# Helpers import
+from .helpers.reader import *
+from .helpers.general import *
+
+# Basic algorithms import
+from .bag_of_cliques import *
+from .mcs import *
+from .vertex_edge_overlap import *
+from .vertex_ranking import *
+from .jaccard import *
+from .bon import *

GMatch4py/source/gmatch4py/bag_of_cliques.pyx

@@ -0,0 +1,167 @@
+# coding = utf-8
+
+import copy
+from typing import Sequence
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from scipy.sparse import csr_matrix,lil_matrix
+import sys
+
+from .base cimport Base
+
+
+cdef class BagOfCliques(Base):
+    """
+    The Bag of Cliques is representation of a graph corpus using the well-known *bag of words* model. Here, instead of
+    word, we use unique cliques found in the graphs as a vocabulary. A clique is a highly connected graph where all the vertices are connected by an edge.
+
+    The resulting representation is then use to compute similarity value between graphs. For this purpose, we use the cosine
+    similarity.
+    """
+
+    def __init__(self):
+        """
+        Constructor of Bag Of Cliques.
+        """
+        Base.__init__(self,0,True)
+
+
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        b=BagOfCliques()
+        bog=b.get_bag_of_cliques(listgs).astype(np.float32)
+        cdef int n=bog.shape[0]
+        cdef np.ndarray scores = np.zeros((n,n))
+        cdef int i
+        for i in range(len(scores)):
+            if selected:
+                if not i in selected:
+                    continue
+            bog_i=bog[i]
+            for j in range(i,len(scores)):
+                bog_j=bog[j]
+                scores[i,j]=(np.dot(bog_i,bog_j.T))/(np.sqrt(np.sum(bog_i**2))*np.sqrt(np.sum(bog_j**2))) # Can be computed in one line
+                scores[j,i]=scores[i,j]
+        return scores
+
+    def get_unique_cliques(self, graphs):
+        """
+        Return a cliques found in a set of graphs
+        Parameters
+        ----------
+        graphs: networkx.Graph array
+            list of graphs
+
+        Returns
+        -------
+        list
+            Cliques set
+        """
+        t = {}
+        c_ = 0
+        cdef list clique_vocab = []
+        cdef list cli_temp
+        cdef list cliques
+        cdef int len_graphs=len(graphs)
+        cdef int km= -1
+        for g in graphs:
+            km+=1
+            if not g:
+                continue
+            cliques = list(nx.find_cliques(nx.Graph(g)))
+            for clique in cliques:
+                cli_temp = copy.deepcopy(clique)
+                new_clique = False
+                for i in range(len(clique)):
+                    flag = False
+                    v = None  # vertex deleted
+                    for vertex in cli_temp:
+                        if vertex in t:
+                            v = vertex
+                            flag = True
+
+                    if not flag in t:
+                        v = cli_temp[0]
+                        t[v] = {}
+                        new_clique = True
+                    t = t[v]
+                    cli_temp.remove(v)
+
+                if new_clique:
+                    c_ += 1
+                    clique_vocab.append(clique)
+        return clique_vocab
+
+
+    def clique2str(self,cliques):
+        """
+        Return a "hash" string of a clique
+
+        Parameters
+        ----------
+        cliques: array
+
+        Returns
+        -------
+        str
+            hash of a clique
+        """
+        try:
+            return "".join(sorted(cliques))
+        except:
+            return "".join(sorted(list(map(str,cliques))))
+
+    def transform_clique_vocab(self,clique_vocab):
+        """
+        Transform cliques found in `get_unique_cliques()` in a proper format to build the "Bag of Cliques"
+
+        Parameters
+        ----------
+        clique_vocab : array
+            contains cliques
+        Returns
+        -------
+        dict
+            new clique vocab format
+        """
+        cdef dict new_vocab={}
+        cdef int len_voc=len(clique_vocab)
+        for c in range(len_voc):
+            #print(c)
+            new_vocab[self.clique2str(clique_vocab[c])]=c
+        return new_vocab
+
+    def get_bag_of_cliques(self, graphs):
+        """
+        Return a the Bag of Cliques representation from a graph set.
+
+        Parameters
+        ----------
+        graphs : networkx.Graph array
+            list of graphs
+
+        Returns
+        -------
+        np.ndarray
+            bag of cliques
+        """
+        cdef list clique_vocab=self.get_unique_cliques(graphs)
+        cdef dict map_str_cliques=self.transform_clique_vocab(clique_vocab)
+        cdef int l_v=len(clique_vocab)
+        boc = np.zeros((len(graphs), l_v))
+        cdef np.ndarray vector
+        cdef list cliques
+        cdef str hash
+
+        for g in range(len(graphs)):
+            #sys.stdout.write("\r{0}/{1}".format(g,len(graphs)))
+            gr = graphs[g]
+            vector = np.zeros(l_v)
+            cliques = list(nx.find_cliques(nx.Graph(gr)))
+            for clique in cliques:
+                hash=self.clique2str(clique)
+                if hash in map_str_cliques:
+                    vector[map_str_cliques[hash]] = 1
+            boc[g] = vector
+        return boc

GMatch4py/source/gmatch4py/base.pxd

@@ -0,0 +1,19 @@
+cimport numpy as np
+
+cdef class Base:
+    ## Attribute(s)
+    cdef int type_alg
+    cdef bint normalized
+    cdef int cpu_count
+    cdef str node_attr_key
+    cdef str edge_attr_key
+    ## Methods
+    cpdef np.ndarray compare(self,list graph_list, list selected)
+    cpdef np.ndarray compare_old(self,list listgs, list selected)
+    cpdef np.ndarray distance(self, np.ndarray matrix)
+    cpdef np.ndarray similarity(self, np.ndarray matrix)
+    cpdef bint isAccepted(self,G,index,selected)
+    cpdef np.ndarray get_selected_array(self,selected,size_corpus)
+
+    cpdef set_attr_graph_used(self, str node_attr_key, str edge_attr_key)
+

GMatch4py/source/gmatch4py/base.pyx

@@ -0,0 +1,218 @@
+# coding = utf-8
+
+import numpy as np
+cimport numpy as np
+import networkx as nx
+cimport cython
+import multiprocessing
+
+
+
+cpdef np.ndarray minmax_scale(np.ndarray matrix):
+    """
+    Optimize so it can works with Cython
+    :param matrix: 
+    :return: 
+    """
+    cdef double min_,max_
+    cdef np.ndarray x
+    x=np.ma.masked_invalid(matrix)
+    max_=np.max(x)
+    return x/(max_)
+
+
+cdef class Base:
+    """
+    This class define the common methods to all Graph Matching algorithm.
+
+    Attributes
+    ----------
+    type_alg : int
+        Indicate the type of measure returned by the algorithm :
+
+         * 0 : similarity
+         * 1 : distance
+    normalized : bool
+        Indicate if the algorithm return normalized results (between 0 and 1)
+
+    """
+    def __cinit__(self):
+        self.type_alg=0
+        self.normalized=False
+
+    def __init__(self,type_alg,normalized,node_attr_key="",edge_attr_key=""):
+        """
+        Constructor of Base
+
+        Parameters
+        ----------
+        type_alg : int
+            Indicate the type of measure returned by the algorithm :
+
+             * **0** : similarity
+             * **1** : distance
+        normalized : bool
+            Indicate if the algorithm return normalized results (between 0 and 1)
+        """
+        if type_alg <0:
+            self.type_alg=0
+        elif type_alg >1 :
+            self.type_alg=1
+        else:
+            self.type_alg=type_alg
+        self.normalized=normalized
+        self.cpu_count=multiprocessing.cpu_count()
+        self.node_attr_key=node_attr_key
+        self.edge_attr_key=edge_attr_key
+
+    cpdef set_attr_graph_used(self, str node_attr_key, str edge_attr_key):
+        """
+        Set graph attribute used by the algorithm to compare graphs.
+        Parameters
+        ----------
+        node_attr_key : str
+            key of the node attribute
+        edge_attr_key: str
+            key of the edge attribute
+
+        """
+        self.node_attr_key=node_attr_key
+        self.edge_attr_key=edge_attr_key
+    
+    cpdef np.ndarray get_selected_array(self,selected,size_corpus):
+        """
+        Return an array which define which graph will be compared in the algorithms.
+        Parameters
+        ----------
+        selected : list
+            indices of graphs you wish to compare
+        size_corpus : 
+            size of your dataset
+
+        Returns
+        -------
+        np.ndarray
+            selected vector (1 -> selected, 0 -> not selected)
+        """
+        cdef double[:] selected_test = np.zeros(size_corpus)
+        if not selected == None:
+            for ix in range(len(selected)):
+                selected_test[selected[ix]]=1
+            return np.array(selected_test)
+        else:
+            return np.array(selected_test)+1
+        
+
+    cpdef np.ndarray compare_old(self,list listgs, list selected):
+        """
+        Soon will be depreciated ! To store the old version of an algorithm.
+        Parameters
+        ----------
+        listgs : list
+            list of graphs
+        selected
+            selected graphs
+
+        Returns
+        -------
+        np.ndarray
+            distance/similarity matrix
+        """
+        pass
+
+    @cython.boundscheck(False) 
+    cpdef np.ndarray compare(self,list graph_list, list selected):
+        """
+        Return the similarity/distance matrix using the current algorithm.
+        
+        >>>Base.compare([nx.Graph(),nx.Graph()],None)
+        >>>Base.compare([nx.Graph(),nx.Graph()],[0,1])
+        
+        Parameters
+        ----------
+        graph_list : networkx.Graph array
+            Contains the graphs to compare
+        selected : int array
+            Sometimes, you only wants to compute similarity of some graphs to every graphs. If so, indicate their indices in
+            `graph_list`, else, put the None value. 
+            the None value
+        Returns
+        -------
+        np.ndarray
+            distance/similarity matrix
+            
+        """
+        pass
+
+    cpdef np.ndarray distance(self, np.ndarray matrix):
+        """
+        Return a normalized distance matrix
+        Parameters
+        ----------
+        matrix : np.ndarray
+            Similarity/distance matrix you wish to transform
+
+        Returns
+        -------
+        np.ndarray
+            distance matrix
+        """
+        if self.type_alg == 1:
+            if not self.normalized:
+                matrix=np.ma.getdata(minmax_scale(matrix))
+            return matrix
+        else:
+            if not self.normalized:
+                matrix=np.ma.getdata(minmax_scale(matrix))
+            return 1-matrix
+
+    cpdef np.ndarray similarity(self, np.ndarray matrix):
+        """
+        Return a normalized similarity matrix
+        Parameters
+        ----------
+        matrix : np.ndarray
+            Similarity/distance matrix you wish to transform
+
+        Returns
+        -------
+        np.array
+            similarity matrix
+        """
+        if self.type_alg == 0:
+            return matrix
+        else:
+            if not self.normalized:
+                matrix=np.ma.getdata(minmax_scale(matrix))
+            return 1-matrix
+
+
+    cpdef bint isAccepted(self,G,index,selected):
+        """
+        Indicate if the graph will be compared to the other. A graph is "accepted" if :
+            * G exists(!= None) and not empty (|vertices(G)| >0)
+            * If selected graph to compare were indicated, check if G exists in selected
+        
+        Parameters
+        ----------
+        G : networkx.Graph
+            Graph
+        index : int
+            index in the graph list parameter in `Base.compare()`
+        selected : int array
+            `selected` parameter value in `Base.compare()`
+
+        Returns
+        -------
+        bool :
+            if is accepted
+        """
+        f=True
+        if not G:
+            f=False
+        elif len(G)== 0:
+            f=False
+        if selected:
+            if not index in selected:
+                f=False
+        return f

GMatch4py/source/gmatch4py/bon.pyx

@@ -0,0 +1,40 @@
+# coding = utf-8
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+from .base cimport Base
+
+cdef class BagOfNodes(Base):
+    """
+    We could call this algorithm Bag of nodes
+    """
+    def __init__(self):
+        Base.__init__(self,0,True)
+
+    cpdef np.ndarray compare(self,list graph_list, list selected):
+        nodes = list()
+        for g in graph_list:
+            nodes.extend(list(g.nodes()))
+
+        vocabulary = list(set(nodes))
+        hash_voc = {}
+        i = 0
+        for se in vocabulary:
+            hash_voc[se] = i
+            i += 1
+        n, m = len(graph_list), len(hash_voc)
+        bow_matrix = np.zeros((n, m))
+        i = 0
+        for g in range(len(graph_list)):
+            graph = graph_list[g]
+            nodes = list(graph.nodes())
+            for nod in nodes:
+                j = hash_voc[nod]
+                bow_matrix[i, j] = 1
+            i += 1
+
+        sim_matrix = cosine_similarity(bow_matrix)
+        np.fill_diagonal(sim_matrix, 1)
+        return sim_matrix

GMatch4py/source/gmatch4py/embedding/deepwalk.pyx

@@ -0,0 +1,173 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import random
+
+from io import open
+from argparse import ArgumentParser, FileType, ArgumentDefaultsHelpFormatter
+from collections import Counter
+from concurrent.futures import ProcessPoolExecutor
+import logging
+from multiprocessing import cpu_count
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from six import text_type as unicode
+from six import iteritems
+from six.moves import range
+
+from gensim.models import Word2Vec
+from sklearn.metrics.pairwise import cosine_similarity
+from joblib import Parallel, delayed
+import psutil
+
+cimport cython
+from ..base cimport Base
+import gmatch4py.embedding.graph as graph2
+import gmatch4py.embedding.walks as serialized_walks
+from .skipgram import Skipgram
+
+
+p = psutil.Process(os.getpid())
+try:
+    p.set_cpu_affinity(list(range(cpu_count())))
+except AttributeError:
+    try:
+        p.cpu_affinity(list(range(cpu_count())))
+    except AttributeError:
+        pass
+
+
+def process(gr, number_walks = 10, walk_length = 40, window_size = 5, vertex_freq_degree = False, workers = 1, representation_size = 64, max_memory_data_size = 1000000000, seed = 0):
+    """
+    Return a DeepWalk embedding for a graph
+    
+    Parameters
+    ----------
+    gr : nx.Graph
+        graph
+    number_walks : int, optional
+        Number of walk (the default is 10)
+    walk_length : int, optional
+        Length of the random walk started at each node (the default is 40)
+    window_size : int, optional
+        Window size of skipgram model. (the default is 5)
+    vertex_freq_degree : bool, optional
+        Use vertex degree to estimate the frequency of nodes (the default is False)
+    workers : int, optional
+        Number of parallel processes (the default is 1)
+    representation_size : int, optional
+        Number of latent dimensions to learn for each node (the default is 64)
+    max_memory_data_size : int, optional
+        'Size to start dumping walks to disk, instead of keeping them in memory. (the default is 1000000000)
+    seed : int, optional
+        Seed for random walk generator (the default is 0)
+    
+    Returns
+    -------
+    np.array
+        DeepWalk embedding
+    """
+    
+    if len(gr.edges())<1:
+        return np.zeros((1,representation_size))
+    G = graph2.from_networkx(gr.copy(), undirected=gr.is_directed())
+    num_walks = len(G.nodes()) * number_walks
+
+    data_size = num_walks * walk_length
+
+    #print("Data size (walks*length): {}".format(data_size))
+
+    if data_size < max_memory_data_size:
+        #print("Walking...")
+        walks = graph2.build_deepwalk_corpus(G, num_paths=number_walks,
+                                            path_length=walk_length, alpha=0, rand=random.Random(seed))
+        #print("Training...")
+        model = Word2Vec(walks, vector_size=representation_size,
+                            window=window_size, min_count=0, sg=1, hs=1, workers=workers)
+    else:
+        #print("Data size {} is larger than limit (max-memory-data-size: {}).  Dumping walks to disk.".format(
+        #    data_size, max_memory_data_size))
+        #print("Walking...")
+
+        walks_filebase = "temp.walks"
+        walk_files = serialized_walks.write_walks_to_disk(G, walks_filebase, num_paths=number_walks,
+                                                            path_length=walk_length, alpha=0, rand=random.Random(seed),
+                                                            num_workers=workers)
+
+        #print("Counting vertex frequency...")
+        if not vertex_freq_degree:
+            vertex_counts = serialized_walks.count_textfiles(
+                walk_files, workers)
+        else:
+            # use degree distribution for frequency in tree
+            vertex_counts = G.degree(nodes=G.iterkeys())
+
+        #print("Training...")
+        walks_corpus = serialized_walks.WalksCorpus(walk_files)
+        model = Skipgram(sentences=walks_corpus, vocabulary_counts=vertex_counts,
+                            size=representation_size,
+                            window=window_size, min_count=0, trim_rule=None, workers=workers)
+
+    return model.wv.vectors
+
+
+cdef class DeepWalk(Base):
+    """
+    Based on :
+    @inproceedings{Perozzi:2014:DOL:2623330.2623732,
+        author = {Perozzi, Bryan and Al-Rfou, Rami and Skiena, Steven},
+        title = {DeepWalk: Online Learning of Social Representations},
+        booktitle = {Proceedings of the 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining},
+        series = {KDD '14},
+        year = {2014},
+        isbn = {978-1-4503-2956-9},
+        location = {New York, New York, USA},
+        pages = {701--710},
+        numpages = {10},
+        url = {http://doi.acm.org/10.1145/2623330.2623732},
+        doi = {10.1145/2623330.2623732},
+        acmid = {2623732},
+        publisher = {ACM},
+        address = {New York, NY, USA},
+        keywords = {deep learning, latent representations, learning with partial labels, network classification, online learning, social networks},
+    }
+
+    Original Code : https://github.com/phanein/deepwalk
+
+    Modified by : Jacques Fize
+    """
+
+    def __init__(self):
+        Base.__init__(self,0,False)
+
+    def extract_embedding(self, listgs):
+        """
+        Extract DeepWalk embedding of each graph in `listgs`
+        
+        Parameters
+        ----------
+        listgs : list
+            list of graphs
+        
+        Returns
+        -------
+        list
+            list of embeddings
+        """
+        
+        from tqdm import tqdm
+        models =  Parallel(n_jobs = cpu_count())(delayed(process)(nx.Graph(g)) for g in tqdm(listgs,desc="Extracting Embeddings..."))
+        return models
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        # Selected is ignored
+        models = self.extract_embedding(listgs)
+        vector_matrix = np.array([mod.mean(axis=0) for mod in models])   # Average nodes representations
+        cs = cosine_similarity(vector_matrix)
+        return cs
+

GMatch4py/source/gmatch4py/embedding/graph.pyx

@@ -0,0 +1,319 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""Graph utilities."""
+
+import logging
+import sys
+from io import open
+from os import path
+from time import time
+from glob import glob
+from six.moves import range, zip, zip_longest
+from six import iterkeys
+
+try:
+    from collections.abc import Iterable
+except ImportError:
+    from collections import Iterable
+from collections import defaultdict
+
+import random
+from random import shuffle
+from itertools import product,permutations
+from scipy.io import loadmat
+from scipy.sparse import issparse
+
+logger = logging.getLogger("deepwalk")
+
+
+__author__ = "Bryan Perozzi"
+__email__ = "bperozzi@cs.stonybrook.edu"
+
+LOGFORMAT = "%(asctime).19s %(levelname)s %(filename)s: %(lineno)s %(message)s"
+
+class Graph(defaultdict):
+  """Efficient basic implementation of nx `Graph' – Undirected graphs with self loops"""  
+  def __init__(self):
+    super(Graph, self).__init__(list)
+
+  def nodes(self):
+    return self.keys()
+
+  def adjacency_iter(self):
+    return self.iteritems()
+
+  def subgraph(self, nodes={}):
+    subgraph = Graph()
+    
+    for n in nodes:
+      if n in self:
+        subgraph[n] = [x for x in self[n] if x in nodes]
+        
+    return subgraph
+
+  def make_undirected(self):
+  
+    t0 = time()
+
+    for v in self.keys():
+      for other in self[v]:
+        if v != other:
+          self[other].append(v)
+    
+    t1 = time()
+    logger.info('make_directed: added missing edges {}s'.format(t1-t0))
+
+    self.make_consistent()
+    return self
+
+  def make_consistent(self):
+    t0 = time()
+    for k in iterkeys(self):
+      self[k] = list(sorted(set(self[k])))
+    
+    t1 = time()
+    logger.info('make_consistent: made consistent in {}s'.format(t1-t0))
+
+    self.remove_self_loops()
+
+    return self
+
+  def remove_self_loops(self):
+
+    removed = 0
+    t0 = time()
+
+    for x in self:
+      if x in self[x]: 
+        self[x].remove(x)
+        removed += 1
+    
+    t1 = time()
+
+    logger.info('remove_self_loops: removed {} loops in {}s'.format(removed, (t1-t0)))
+    return self
+
+  def check_self_loops(self):
+    for x in self:
+      for y in self[x]:
+        if x == y:
+          return True
+    
+    return False
+
+  def has_edge(self, v1, v2):
+    if v2 in self[v1] or v1 in self[v2]:
+      return True
+    return False
+
+  def degree(self, nodes=None):
+    if isinstance(nodes, Iterable):
+      return {v:len(self[v]) for v in nodes}
+    else:
+      return len(self[nodes])
+
+  def order(self):
+    "Returns the number of nodes in the graph"
+    return len(self)    
+
+  def number_of_edges(self):
+    "Returns the number of nodes in the graph"
+    return sum([self.degree(x) for x in self.keys()])/2
+
+  def number_of_nodes(self):
+    "Returns the number of nodes in the graph"
+    return self.order()
+
+  def random_walk(self, path_length, alpha=0, rand=random.Random(), start=None):
+    """ Returns a truncated random walk.
+
+        path_length: Length of the random walk.
+        alpha: probability of restarts.
+        start: the start node of the random walk.
+    """
+    G = self
+    if start:
+      path = [start]
+    else:
+      # Sampling is uniform w.r.t V, and not w.r.t E
+      path = [rand.choice(list(G.keys()))]
+
+    while len(path) < path_length:
+      cur = path[-1]
+      if len(G[cur]) > 0:
+        if rand.random() >= alpha:
+          path.append(rand.choice(G[cur]))
+        else:
+          path.append(path[0])
+      else:
+        break
+    return [str(node) for node in path]
+
+# TODO add build_walks in here
+
+def build_deepwalk_corpus(G, num_paths, path_length, alpha=0,
+                      rand=random.Random(0)):
+  walks = []
+
+  nodes = list(G.nodes())
+  
+  for cnt in range(num_paths):
+    rand.shuffle(nodes)
+    for node in nodes:
+      walks.append(G.random_walk(path_length, rand=rand, alpha=alpha, start=node))
+  
+  return walks
+
+def build_deepwalk_corpus_iter(G, num_paths, path_length, alpha=0,
+                      rand=random.Random(0)):
+  walks = []
+
+  nodes = list(G.nodes())
+
+  for cnt in range(num_paths):
+    rand.shuffle(nodes)
+    for node in nodes:
+      yield G.random_walk(path_length, rand=rand, alpha=alpha, start=node)
+
+
+def clique(size):
+    return from_adjlist(permutations(range(1,size+1)))
+
+
+# http://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks-in-python
+def grouper(n, iterable, padvalue=None):
+    "grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
+    return zip_longest(*[iter(iterable)]*n, fillvalue=padvalue)
+
+def parse_adjacencylist(f):
+  adjlist = []
+  for l in f:
+    if l and l[0] != "#":
+      introw = [int(x) for x in l.strip().split()]
+      row = [introw[0]]
+      row.extend(set(sorted(introw[1:])))
+      adjlist.extend([row])
+  
+  return adjlist
+
+def parse_adjacencylist_unchecked(f):
+  adjlist = []
+  for l in f:
+    if l and l[0] != "#":
+      adjlist.extend([[int(x) for x in l.strip().split()]])
+  
+  return adjlist
+
+def load_adjacencylist(file_, undirected=False, chunksize=10000, unchecked=True):
+
+  if unchecked:
+    parse_func = parse_adjacencylist_unchecked
+    convert_func = from_adjlist_unchecked
+  else:
+    parse_func = parse_adjacencylist
+    convert_func = from_adjlist
+
+  adjlist = []
+
+  t0 = time()
+  
+  total = 0 
+  with open(file_) as f:
+    for idx, adj_chunk in enumerate(map(parse_func, grouper(int(chunksize), f))):
+      adjlist.extend(adj_chunk)
+      total += len(adj_chunk)
+  
+  t1 = time()
+
+  logger.info('Parsed {} edges with {} chunks in {}s'.format(total, idx, t1-t0))
+
+  t0 = time()
+  G = convert_func(adjlist)
+  t1 = time()
+
+  logger.info('Converted edges to graph in {}s'.format(t1-t0))
+
+  if undirected:
+    t0 = time()
+    G = G.make_undirected()
+    t1 = time()
+    logger.info('Made graph undirected in {}s'.format(t1-t0))
+
+  return G 
+
+
+def load_edgelist(file_, undirected=True):
+  G = Graph()
+  with open(file_) as f:
+    for l in f:
+      x, y = l.strip().split()[:2]
+      x = int(x)
+      y = int(y)
+      G[x].append(y)
+      if undirected:
+        G[y].append(x)
+  
+  G.make_consistent()
+  return G
+
+
+def load_matfile(file_, variable_name="network", undirected=True):
+  mat_varables = loadmat(file_)
+  mat_matrix = mat_varables[variable_name]
+
+  return from_numpy(mat_matrix, undirected)
+
+
+def from_networkx(G_input, undirected=True):
+    G = Graph()
+
+    for _, x in enumerate(G_input):
+        for y in iterkeys(G_input[x]):
+            G[x].append(y)
+
+    if undirected:
+        G.make_undirected()
+
+    return G
+
+
+def from_numpy(x, undirected=True):
+    G = Graph()
+
+    if issparse(x):
+        cx = x.tocoo()
+        for i,j,v in zip(cx.row, cx.col, cx.data):
+            G[i].append(j)
+    else:
+      raise Exception("Dense matrices not yet supported.")
+
+    if undirected:
+        G.make_undirected()
+
+    G.make_consistent()
+    return G
+
+
+def from_adjlist(adjlist):
+    G = Graph()
+    
+    for row in adjlist:
+        node = row[0]
+        neighbors = row[1:]
+        G[node] = list(sorted(set(neighbors)))
+
+    return G
+
+
+def from_adjlist_unchecked(adjlist):
+    G = Graph()
+    
+    for row in adjlist:
+        node = row[0]
+        neighbors = row[1:]
+        G[node] = neighbors
+
+    return G
+
+

GMatch4py/source/gmatch4py/embedding/graph2vec.pyx

@@ -0,0 +1,184 @@
+import hashlib
+import json
+import glob
+
+import pandas as pd
+import networkx as nx
+from tqdm import tqdm
+cimport numpy as np
+import numpy.distutils.system_info as sysinfo
+
+from joblib import Parallel, delayed
+from gensim.models.doc2vec import Doc2Vec, TaggedDocument
+from sklearn.metrics.pairwise import cosine_similarity
+
+from ..base cimport Base
+cimport cython
+
+
+class WeisfeilerLehmanMachine:
+    """
+    Weisfeiler Lehman feature extractor class.
+    """
+    def __init__(self, graph, features, iterations):
+        """
+        Initialization method which executes feature extraction.
+        
+        Parameters
+        ----------
+        graph : nx.Graph
+            graph
+        features : dict
+            Feature hash table.
+        iterations : int
+            number of WL iteration
+        
+        """
+
+        self.iterations = iterations
+        self.graph = graph
+        self.features = features
+        self.nodes = self.graph.nodes()
+        self.extracted_features = [str(v) for k,v in features.items()]
+        self.do_recursions()
+
+    def do_a_recursion(self):
+        """
+        The method does a single WL recursion.
+        
+        Returns
+        -------
+        dict
+            The hash table with extracted WL features.
+        """
+
+        new_features = {}
+        for node in self.nodes:
+            nebs = self.graph.neighbors(node)
+            degs = [self.features[neb] for neb in nebs]
+            features = "_".join([str(self.features[node])]+list(set(sorted([str(deg) for deg in degs]))))
+            hash_object = hashlib.md5(features.encode())
+            hashing = hash_object.hexdigest()
+            new_features[node] = hashing
+        self.extracted_features = self.extracted_features + list(new_features.values())
+        return new_features
+
+    def do_recursions(self):
+        """
+        The method does a series of WL recursions.
+        """
+        for iteration in range(self.iterations):
+            self.features = self.do_a_recursion()
+        
+
+def dataset_reader(graph):
+    """
+    Function to extract features from a networkx graph
+    
+    Parameters
+    ----------
+    graph : nx.Graph
+        graph
+    
+    Returns
+    -------
+    dict
+        Features hash table.
+    """
+
+    features = dict(nx.degree(graph))
+
+    features = {k:v for k,v, in features.items()}
+    return graph, features
+
+
+def feature_extractor(graph, ix, rounds):
+    """
+    Function to extract WL features from a graph
+    
+    Parameters
+    ----------
+    graph : nx.Graph
+        graph
+    ix : int
+        index of the graph in the dataset
+    rounds : int
+        number of WL iterations
+    
+    Returns
+    -------
+    TaggedDocument 
+        random walks
+    """
+
+    graph, features = dataset_reader(graph)
+    machine = WeisfeilerLehmanMachine(graph,features,rounds)
+    doc = TaggedDocument(words = machine.extracted_features , tags = ["g_{0}".format(ix)])
+    return doc
+        
+
+
+def generate_model(graphs, iteration = 2, dimensions = 64, min_count = 5, down_sampling =  0.0001, learning_rate = 0.0001, epochs = 10, workers = 4 ):
+    """
+    Main function to read the graph list, extract features, learn the embedding and save it.
+    
+    Parameters
+    ----------
+    graphs : nx.Graph
+        Input graph
+    iteration : int, optional
+        number of iteration (the default is 2)
+    dimensions : int, optional
+        output vector dimension (the default is 64)
+    min_count : int, optional
+        min count parameter of Doc2vec model (the default is 5)
+    down_sampling : float, optional
+        Down sampling rate for frequent features. (the default is 0.0001)
+    learning_rate : float, optional
+        Initial learning rate (the default is 0.0001, which [default_description])
+    epochs : int, optional
+        Number of epochs (the default is 10)
+    workers : int, optional
+        Number of workers (the default is 4)
+    
+    Returns
+    -------
+    [type]
+        [description]
+    """
+
+    document_collections = Parallel(n_jobs = workers)(delayed(feature_extractor)(g, ix,iteration) for ix,g in tqdm(enumerate(graphs),desc="Extracting Features..."))
+    graphs=[nx.relabel_nodes(g,{node:str(node) for node in list(g.nodes)},copy=True) for g in graphs]
+    model = Doc2Vec(document_collections,
+                    vector_size = dimensions,
+                    window = 0,
+                    min_count = min_count,
+                    dm = 0,
+                    sample = down_sampling,
+                    workers = workers,
+                    epochs = epochs,
+                    alpha = learning_rate)
+    return model
+
+cdef class Graph2Vec(Base):
+    """
+    Based on :
+    graph2vec: Learning distributed representations of graphs. 
+    Narayanan, Annamalai and Chandramohan, Mahinthan and Venkatesan, Rajasekar and Chen, Lihui and Liu, Yang 
+    MLG 2017, 13th International Workshop on Mining and Learning with Graphs (MLGWorkshop 2017)
+
+    Original Code : https://github.com/benedekrozemberczki/graph2vec
+
+    Modified by : Jacques Fize
+    """
+
+    def __init__(self):
+        Base.__init__(self,0,False)
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        # Selected is ignored
+        model  = generate_model(listgs)
+        vector_matrix = model.docvecs.vectors_docs
+        cs = cosine_similarity(vector_matrix)
+        return cs

GMatch4py/source/gmatch4py/embedding/node2vec.pyx

@@ -0,0 +1,255 @@
+import random
+
+import numpy as np
+cimport numpy as np
+from gensim.models import Word2Vec
+from sklearn.metrics.pairwise import cosine_similarity
+
+from ..base cimport Base
+cimport cython
+from joblib import Parallel, delayed
+import networkx as nx
+
+class Graph():
+    def __init__(self, nx_G, is_directed, p, q):
+        self.G = nx_G
+        self.is_directed = is_directed
+        self.p = p
+        self.q = q
+
+    def node2vec_walk(self, walk_length, start_node):
+        '''
+        Simulate a random walk starting from start node.
+        '''
+        G = self.G
+        alias_nodes = self.alias_nodes
+        alias_edges = self.alias_edges
+
+        walk = [start_node]
+
+        while len(walk) < walk_length:
+            cur = walk[-1]
+            cur_nbrs = sorted(G.neighbors(cur))
+            if len(cur_nbrs) > 0:
+                if len(walk) == 1:
+                    walk.append(
+                        cur_nbrs[alias_draw(alias_nodes[cur][0], alias_nodes[cur][1])])
+                else:
+                    prev = walk[-2]
+                    next = cur_nbrs[alias_draw(alias_edges[(prev, cur)][0],
+                                               alias_edges[(prev, cur)][1])]
+                    walk.append(next)
+            else:
+                break
+
+        return walk
+
+    def simulate_walks(self, num_walks, walk_length):
+        '''
+        Repeatedly simulate random walks from each node.
+        '''
+        # sys.stdout.write("\r")
+        G = self.G
+        walks = []
+        nodes = list(G.nodes)
+        for walk_iter in range(num_walks):
+            # sys.stdout.write(
+            #     '\rWalk iteration: {0}/{1}'.format(walk_iter + 1, num_walks))
+            random.shuffle(nodes)
+            for node in nodes:
+                walks.append(self.node2vec_walk(
+                    walk_length=walk_length, start_node=node))
+
+        return walks
+
+    def get_alias_edge(self, src, dst):
+        '''
+        Get the alias edge setup lists for a given edge.
+        '''
+        G = self.G
+        p = self.p
+        q = self.q
+
+        unnormalized_probs = []
+        for dst_nbr in sorted(G.neighbors(dst)):
+            if dst_nbr == src:
+                unnormalized_probs.append(G[dst][dst_nbr]['weight'] / p)
+            elif G.has_edge(dst_nbr, src):
+                unnormalized_probs.append(G[dst][dst_nbr]['weight'])
+            else:
+                unnormalized_probs.append(G[dst][dst_nbr]['weight'] / q)
+        norm_const = sum(unnormalized_probs)
+        normalized_probs = [
+            float(u_prob) / norm_const for u_prob in unnormalized_probs]
+
+        return alias_setup(normalized_probs)
+
+    def preprocess_transition_probs(self):
+        '''
+        Preprocessing of transition probabilities for guiding the random walks.
+        '''
+        G = self.G
+        is_directed = self.is_directed
+
+        alias_nodes = {}
+        for node in list(G.nodes):
+            unnormalized_probs = [G[node][nbr]['weight']
+                                  for nbr in sorted(G.neighbors(node))]
+            norm_const = sum(unnormalized_probs)
+            normalized_probs = [
+                float(u_prob) / norm_const for u_prob in unnormalized_probs]
+            alias_nodes[node] = alias_setup(normalized_probs)
+
+        alias_edges = {}
+        triads = {}
+
+        if is_directed:
+            for edge in list(G.edges()):
+                alias_edges[edge] = self.get_alias_edge(edge[0], edge[1])
+        else:
+            for edge in list(G.edges()):
+                alias_edges[edge] = self.get_alias_edge(edge[0], edge[1])
+                alias_edges[(edge[1], edge[0])] = self.get_alias_edge(
+                    edge[1], edge[0])
+
+        self.alias_nodes = alias_nodes
+        self.alias_edges = alias_edges
+
+        return
+
+
+def alias_setup(probs):
+    '''
+    Compute utility lists for non-uniform sampling from discrete distributions.
+    Refer to https://hips.seas.harvard.edu/blog/2013/03/03/the-alias-method-efficient-sampling-with-many-discrete-outcomes/
+    for details
+    '''
+    K = len(probs)
+    q = np.zeros(K)
+    J = np.zeros(K, dtype=np.int)
+
+    smaller = []
+    larger = []
+    for kk, prob in enumerate(probs):
+        q[kk] = K * prob
+        if q[kk] < 1.0:
+            smaller.append(kk)
+        else:
+            larger.append(kk)
+
+    while len(smaller) > 0 and len(larger) > 0:
+        small = smaller.pop()
+        large = larger.pop()
+
+        J[small] = large
+        q[large] = q[large] + q[small] - 1.0
+        if q[large] < 1.0:
+            smaller.append(large)
+        else:
+            larger.append(large)
+
+    return J, q
+
+
+def alias_draw(J, q):
+    '''
+    Draw sample from a non-uniform discrete distribution using alias sampling.
+    '''
+    K = len(J)
+
+    kk = int(np.floor(np.random.rand() * K))
+    if np.random.rand() < q[kk]:
+        return kk
+    else:
+        return J[kk]
+
+
+def learn_embeddings(walks, dimensions, window_size, nb_workers, nb_iter):
+    '''
+    Learn embeddings by optimizing the Skipgram objective using SGD.
+    '''
+    walks_ = [list(map(str, walk)) for walk in walks]
+    model = Word2Vec(walks_, size=dimensions, window=window_size,
+                     min_count=0, sg=1, workers=nb_workers, iter=nb_iter)
+    return model
+
+
+def compute_graph_model(nx_graph, **kwargs):
+    '''
+    Pipeline for representational learning for all nodes in a graph.
+        @param nx_graph
+        @kwarg p: int
+        @kwarg q: int
+    '''
+    p = kwargs.get("p", 1)
+    q = kwargs.get("q", 1)
+    dimensions = kwargs.get("dimensions", 128)
+    window_size = kwargs.get("window_size", 10)
+    nb_workers = kwargs.get("nb_workers", 8)
+    nb_iter = kwargs.get("nb_iter", 1)
+    num_walks = kwargs.get("num_walks", 10)
+    walk_length = kwargs.get("walk_length", 80)
+    directed = kwargs.get("directed", False)
+
+    G = Graph(nx_graph, directed, p, q)
+    G.preprocess_transition_probs()
+    walks = G.simulate_walks(num_walks, walk_length)
+    return learn_embeddings(walks, dimensions, window_size, nb_workers, nb_iter).wv.vectors
+
+cdef class Node2Vec(Base):
+    """
+    Based on :
+    Extract Node2vec embedding of each graph in `listgs`
+        @inproceedings{Grover:2016:NSF:2939672.2939754,
+             author = {Grover, Aditya and Leskovec, Jure},
+             title = {Node2Vec: Scalable Feature Learning for Networks},
+             booktitle = {Proceedings of the 22Nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining},
+             series = {KDD '16},
+             year = {2016},
+             isbn = {978-1-4503-4232-2},
+             location = {San Francisco, California, USA},
+             pages = {855--864},
+             numpages = {10},
+             url = {http://doi.acm.org/10.1145/2939672.2939754},
+             doi = {10.1145/2939672.2939754},
+             acmid = {2939754},
+             publisher = {ACM},
+             address = {New York, NY, USA},
+             keywords = {feature learning, graph representations, information networks, node embeddings},
+        }
+
+    Original code : https://github.com/aditya-grover/node2vec
+
+    Modified by : Jacques Fize
+    """
+
+    def __init__(self):
+        Base.__init__(self,0,False)
+
+    def extract_embedding(self, listgs):
+        """
+        Extract Node2vec embedding of each graph in `listgs`
+
+        Parameters
+        ----------
+        listgs : list
+            list of graphs
+
+        Returns
+        -------
+        list
+            list of embeddings
+        """
+
+        from tqdm import tqdm
+        models =  Parallel(n_jobs = self.cpu_count)(delayed(compute_graph_model)(g,directed=g.is_directed()) for g in tqdm(listgs,desc="Extracting Embeddings..."))
+        return models
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        # Selected is ignored
+        [nx.set_edge_attributes(g,1,'weight') for g in listgs]
+        models = self.extract_embedding(listgs)
+        vector_matrix = np.array([mod.mean(axis=0) for mod in models])   # Average nodes representations
+        cs = cosine_similarity(vector_matrix)
+        return cs

GMatch4py/source/gmatch4py/embedding/skipgram.pyx

@@ -0,0 +1,26 @@
+import logging
+from multiprocessing import cpu_count
+
+from gensim.models import Word2Vec
+
+logger = logging.getLogger("deepwalk")
+
+class Skipgram(Word2Vec):
+    """A subclass to allow more customization of the Word2Vec internals."""
+
+    def __init__(self, vocabulary_counts=None, **kwargs):
+
+        self.vocabulary_counts = None
+
+        kwargs["min_count"] = kwargs.get("min_count", 0)
+        kwargs["workers"] = kwargs.get("workers", cpu_count())
+        kwargs["size"] = kwargs.get("size", 128)
+        kwargs["sentences"] = kwargs.get("sentences", None)
+        kwargs["window"] = kwargs.get("window", 10)
+        kwargs["sg"] = 1
+        kwargs["hs"] = 1
+
+        if vocabulary_counts != None:
+          self.vocabulary_counts = vocabulary_counts
+
+        super(Skipgram, self).__init__(**kwargs)

GMatch4py/source/gmatch4py/embedding/walks.pyx

@@ -0,0 +1,103 @@
+import logging
+from io import open
+from os import path
+from time import time
+from multiprocessing import cpu_count
+import random
+from concurrent.futures import ProcessPoolExecutor
+from collections import Counter
+
+from six.moves import zip
+
+from . import graph
+
+logger = logging.getLogger("deepwalk")
+
+__current_graph = None
+
+# speed up the string encoding
+__vertex2str = None
+
+def count_words(file):
+  """ Counts the word frequences in a list of sentences.
+
+  Note:
+    This is a helper function for parallel execution of `Vocabulary.from_text`
+    method.
+  """
+  c = Counter()
+  with open(file, 'r') as f:
+    for l in f:
+      words = l.strip().split()
+      c.update(words)
+  return c
+
+
+def count_textfiles(files, workers=1):
+  c = Counter()
+  with ProcessPoolExecutor(max_workers=workers) as executor:
+    for c_ in executor.map(count_words, files):
+      c.update(c_)
+  return c
+
+
+def count_lines(f):
+  if path.isfile(f):
+    num_lines = sum(1 for line in open(f))
+    return num_lines
+  else:
+    return 0
+
+def _write_walks_to_disk(args):
+  num_paths, path_length, alpha, rand, f = args
+  G = __current_graph
+  t_0 = time()
+  with open(f, 'w') as fout:
+    for walk in graph.build_deepwalk_corpus_iter(G=G, num_paths=num_paths, path_length=path_length,
+                                                 alpha=alpha, rand=rand):
+      fout.write(u"{}\n".format(u" ".join(v for v in walk)))
+  logger.debug("Generated new file {}, it took {} seconds".format(f, time() - t_0))
+  return f
+
+def write_walks_to_disk(G, filebase, num_paths, path_length, alpha=0, rand=random.Random(0), num_workers=cpu_count(),
+                        always_rebuild=True):
+  global __current_graph
+  __current_graph = G
+  files_list = ["{}.{}".format(filebase, str(x)) for x in list(range(num_paths))]
+  expected_size = len(G)
+  args_list = []
+  files = []
+
+  if num_paths <= num_workers:
+    paths_per_worker = [1 for x in range(num_paths)]
+  else:
+    paths_per_worker = [len(list(filter(lambda z: z!= None, [y for y in x])))
+                        for x in graph.grouper(int(num_paths / num_workers)+1, range(1, num_paths+1))]
+
+  with ProcessPoolExecutor(max_workers=num_workers) as executor:
+    for size, file_, ppw in zip(executor.map(count_lines, files_list), files_list, paths_per_worker):
+      if always_rebuild or size != (ppw*expected_size):
+        args_list.append((ppw, path_length, alpha, random.Random(rand.randint(0, 2**31)), file_))
+      else:
+        files.append(file_)
+
+  with ProcessPoolExecutor(max_workers=num_workers) as executor:
+    for file_ in executor.map(_write_walks_to_disk, args_list):
+      files.append(file_)
+
+  return files
+
+class WalksCorpus(object):
+  def __init__(self, file_list):
+    self.file_list = file_list
+  def __iter__(self):
+    for file in self.file_list:
+      with open(file, 'r') as f:
+        for line in f:
+          yield line.split()
+
+def combine_files_iter(file_list):
+  for file in file_list:
+    with open(file, 'r') as f:
+      for line in f:
+        yield line.split()

GMatch4py/source/gmatch4py/ged/__init__.py

@@ -0,0 +1,2 @@
+# coding = utf-8
+

GMatch4py/source/gmatch4py/ged/abstract_graph_edit_dist.pxd

@@ -0,0 +1,19 @@
+import numpy as np
+cimport numpy as np
+from ..base cimport Base
+
+cdef class AbstractGraphEditDistance(Base):
+    cdef double node_del
+    cdef double node_ins
+    cdef double edge_del
+    cdef double edge_ins
+    cdef np.ndarray cost_matrix
+    cdef bint weighted
+
+    cpdef double distance_ged(self,G,H)
+    cdef list edit_costs(self,G,H)
+    cpdef np.ndarray create_cost_matrix(self,G,H)
+    cdef double insert_cost(self, int i, int j, nodesH, H)
+    cdef double delete_cost(self, int i, int j, nodesG, G)
+    cpdef double substitute_cost(self, node1, node2, G, H)
+    

GMatch4py/source/gmatch4py/ged/abstract_graph_edit_dist.pyx

@@ -0,0 +1,197 @@
+# -*- coding: UTF-8 -*-
+from __future__ import print_function
+
+import sys
+import warnings
+
+import numpy as np
+cimport numpy as np
+import networkx as nx
+from cython.parallel cimport prange,parallel
+
+try:
+    from munkres import munkres
+except ImportError:
+    warnings.warn("To obtain optimal results install the Cython 'munkres' module at  https://github.com/jfrelinger/cython-munkres-wrapper")
+    from scipy.optimize import linear_sum_assignment as munkres
+
+from ..base cimport Base
+from ..helpers.general import parsenx2graph
+
+
+
+cdef class AbstractGraphEditDistance(Base):
+
+
+    def __init__(self, node_del,node_ins,edge_del,edge_ins):
+        Base.__init__(self,1,False)
+
+        self.node_del = node_del
+        self.node_ins = node_ins
+        self.edge_del = edge_del
+        self.edge_ins = edge_ins
+
+
+    cpdef double distance_ged(self,G,H):
+        """
+        Return the distance value between G and H
+        
+        Parameters
+        ----------
+        G : gmatch4py.Graph
+            graph
+        H : gmatch4py.Graph
+            graph
+        
+        Returns
+        -------
+        int 
+            distance
+        """
+        cdef list opt_path = self.edit_costs(G,H)
+        return np.sum(opt_path)
+
+    def edit_path(self,G,H):
+        """
+        Return  the edit path along with the cost matrix and the selected indices from the Munkres Algorithm
+        
+        Parameters
+        ----------
+        G : nx.Graph
+            first graph
+        H : nx.Graph
+            second graph
+        
+        Returns
+        -------
+        np.array(1D), np.array(2D), (np.array(2D) if munkres) or (np.array(1,2) if scipy) 
+            edit_path, cost_matrix, munkres results
+        """
+        cost_matrix = self.create_cost_matrix(G,H).astype(float)
+        index_path= munkres(cost_matrix)
+        return cost_matrix[index_path], cost_matrix, index_path
+    
+
+    cdef list edit_costs(self, G, H):
+        """
+        Return the optimal path edit cost list, to transform G into H
+        
+        Parameters
+        ----------
+        G : gmatch4py.Graph
+            graph
+        H : gmatch4py.Graph
+            graph
+        
+        Returns
+        -------
+        np.array 
+            edit path
+        """
+        cdef np.ndarray cost_matrix = self.create_cost_matrix(G,H).astype(float)
+        return cost_matrix[munkres(cost_matrix)].tolist()
+
+    cpdef np.ndarray create_cost_matrix(self, G, H):
+        """
+        Creates a |N+M| X |N+M| cost matrix between all nodes in
+        graphs G and H
+        Each cost represents the cost of substituting,
+        deleting or inserting a node
+        The cost matrix consists of four regions:
+
+        substitute 	| insert costs
+        -------------------------------
+        delete 		| delete -> delete
+
+        The delete -> delete region is filled with zeros
+        
+        Parameters
+        ----------
+        G : gmatch4py.Graph
+            graph
+        H : gmatch4py.Graph
+            graph
+        
+        Returns
+        -------
+        np.array 
+            cost matrix
+        """
+        cdef int n,m
+        try:
+            n = G.number_of_nodes()
+            m = H.number_of_nodes()
+        except:
+            n = G.size()
+            m = H.size()
+        cdef np.ndarray cost_matrix = np.zeros((n+m,n+m))
+        cdef list nodes1 = list(G.nodes())
+        cdef list nodes2 = list(H.nodes())
+        cdef int i,j
+        for i in range(n):
+            for j in range(m):
+                cost_matrix[i,j] = self.substitute_cost(nodes1[i], nodes2[j], G, H)
+
+        for i in range(m):
+            for j in range(m):
+                cost_matrix[i+n,j] = self.insert_cost(i, j, nodes2, H)
+
+        for i in range(n):
+            for j in range(n):
+                cost_matrix[j,i+m] = self.delete_cost(i, j, nodes1, G)
+
+        return cost_matrix
+
+    cdef double insert_cost(self, int i, int j, nodesH, H):
+        """
+        Return the insert cost of the ith nodes in H
+        
+        Returns
+        -------
+        int
+            insert cost
+        """
+        raise NotImplementedError
+
+    cdef double delete_cost(self, int i, int j, nodesG, G):
+        """
+        Return the delete cost of the ith nodes in H
+        
+        Returns
+        -------
+        int
+            delete cost
+        """
+        raise NotImplementedError
+
+    cpdef double substitute_cost(self, node1, node2, G, H):
+        """
+        Return the substitute cost of between the node1 in G and the node2 in H
+        
+        Returns
+        -------
+        int
+            substitution cost
+        """
+        raise NotImplementedError
+
+
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n = len(listgs)
+        cdef double[:,:] comparison_matrix = np.zeros((n, n))
+        listgs=parsenx2graph(listgs,self.node_attr_key,self.edge_attr_key)
+        cdef long[:] n_nodes = np.array([g.size() for g in listgs])
+        cdef double[:] selected_test = np.array(self.get_selected_array(selected,n))
+        cdef int i,j
+        cdef float inf=np.inf
+
+        with nogil, parallel(num_threads=self.cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(n):
+                    if n_nodes[i]>0 and n_nodes[j]>0 and selected_test[i] == 1 :
+                        with gil:
+                            comparison_matrix[i][j] = self.distance_ged(listgs[i],listgs[j])
+                    else:
+                        comparison_matrix[i][j] = inf
+                #comparison_matrix[j, i] = comparison_matrix[i, j]
+        return np.array(comparison_matrix)

GMatch4py/source/gmatch4py/ged/bipartite_graph_matching_2.pyx

@@ -0,0 +1,238 @@
+# coding = utf-8
+import numpy as np
+cimport numpy as np
+from ..base cimport Base
+from cython.parallel cimport prange,parallel
+from ..helpers.general import parsenx2graph
+cimport cython
+
+cdef class BP_2(Base):
+
+
+    cdef int node_del
+    cdef int node_ins
+    cdef int edge_del
+    cdef int edge_ins
+
+    def __init__(self, int node_del=1, int node_ins=1, int edge_del=1, int edge_ins=1):
+        """
+        BP_2 Constructor
+
+        Parameters
+        ----------
+        node_del :int
+            Node deletion cost
+        node_ins : int
+            Node insertion cost
+        edge_del : int
+            Edge Deletion cost
+        edge_ins : int
+            Edge Insertion cost
+        """
+        Base.__init__(self,1,False)
+        self.node_del = node_del
+        self.node_ins = node_ins
+        self.edge_del = edge_del
+        self.edge_ins = edge_ins
+
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n = len(listgs)
+        cdef list new_gs=parsenx2graph(listgs)
+        cdef double[:,:] comparison_matrix = np.zeros((n, n))
+        cdef double[:] selected_test = self.get_selected_array(selected,n)
+        cdef int i,j
+        cdef long[:] n_nodes = np.array([g.size() for g in new_gs])
+        cdef long[:] n_edges = np.array([g.density() for g in new_gs])
+
+        with nogil, parallel(num_threads=self.cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(i,n):
+                    if  n_nodes[i] > 0 and n_nodes[j] > 0  and selected_test[i] == 1:
+                        with gil:
+                            comparison_matrix[i, j] = self.bp2(new_gs[i], new_gs[j])
+                    else:
+                        comparison_matrix[i, j] = 0
+                    comparison_matrix[j, i] = comparison_matrix[i, j]
+
+        return np.array(comparison_matrix)
+
+
+    cdef double bp2(self, g1, g2):
+        """
+        Compute the BP2 similarity value between two `networkx.Graph`
+        
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First Graph
+        g2 : gmatch4py.Graph
+            Second Graph
+
+        Returns
+        -------
+        float 
+            similarity value
+        """
+        return np.min([self.distance_bp2(self.psi(g1,g2)),self.distance_bp2(self.psi(g2,g1))])
+
+    cdef double distance_bp2(self,e):
+        """
+        Return the distance based on the edit path found.
+        Parameters
+        ----------
+        e : list
+            Contains the edit path costs
+
+        Returns
+        -------
+        double
+            Return sum of the costs from the edit path
+        """
+        return np.sum(e)
+
+    cdef list psi(self,g1,g2):
+        """
+        Return the optimal edit path :math:`\psi` based on BP2 algorithm.
+        
+        
+        Parameters
+        ----------
+        g1 : networkx.Graph
+            First Graph
+        g2 : networkx.Graph
+            Second Graph
+
+        Returns
+        -------
+        list
+            list containing costs from the optimal edit path
+        """
+        cdef list psi_=[]
+        cdef list nodes1 = list(g1.nodes())
+        cdef list nodes2 = list(g2.nodes())
+        for u in nodes1:
+            v=None
+            for w in nodes2:
+                if 2*self.fuv(g1,g2,u,w) < self.fuv(g1,g2,u,None) + self.fuv(g1,g2,None,w)\
+                     and self.fuv(g1,g2,u,w) < self.fuv(g1,g2,u,v):
+                    v=w
+                psi_.append(self.fuv(g1,g2,u,v))
+            if u:
+                nodes1= list(set(nodes1).difference(set([u])))
+            if v:
+                nodes2= list(set(nodes2).difference(set([v])))
+        for v in nodes2:
+            psi_.append(self.fuv(g1,g2,None,v))
+        return  psi_
+
+
+
+    cdef float fuv(self, g1, g2, str n1, str n2):
+        """
+        Compute the Node Distance function
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+        n1 : int or str
+            identifier of the first node
+        n2 : int or str
+            identifier of the second node
+
+        Returns
+        -------
+        float
+            node distance
+        """
+        if n2 == None:  # Del
+            return self.node_del + ((self.edge_del / 2.) * g1.degree(n1))
+        if n1 == None:  # Insert
+            return self.node_ins + ((self.edge_ins / 2.) * g2.degree(n2))
+        else:
+            if n1 == n2:
+                return 0
+            return (self.node_del + self.node_ins + self.hed_edge(g1, g2, n1, n2)) / 2
+
+    cdef float hed_edge(self, g1, g2, str n1, str n2):
+        """
+        Compute HEDistance between edges of n1 and n2, respectively in g1 and g2
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+        n1 : int or str
+            identifier of the first node
+        n2 : int or str
+            identifier of the second node
+
+        Returns
+        -------
+        float
+            HEDistance between g1 and g2
+        """
+        return self.sum_gpq(g1, n1, g2, n2) + self.sum_gpq(g1, n1, g2, n2)
+
+
+    cdef float sum_gpq(self, g1, str n1, g2, str n2):
+        """
+        Compute Nearest Neighbour Distance between edges around n1 in G1  and edges around n2 in G2
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+        n1 : int or str
+            identifier of the first node
+        n2 : int or str
+            identifier of the second node
+
+        Returns
+        -------
+        float
+            Nearest Neighbour Distance
+        """
+
+        #if isinstance(g1, nx.MultiDiGraph):
+        cdef list edges1 = g1.get_edges_no(n1) if n1 else []
+        cdef list edges2 = g2.get_edges_no(n2) if n2 else []
+
+        cdef np.ndarray min_sum = np.zeros(len(edges1))
+        edges2.extend([None])
+        cdef np.ndarray min_i
+        for i in range(len(edges1)):
+            min_i = np.zeros(len(edges2))
+            for j in range(len(edges2)):
+                min_i[j] = self.gpq(edges1[i], edges2[j])
+            min_sum[i] = np.min(min_i)
+        return np.sum(min_sum)
+
+    cdef float gpq(self, str e1, str e2):
+        """
+        Compute the edge distance function
+        Parameters
+        ----------
+        e1 : str
+            first edge identifier
+        e2
+            second edge indentifier
+        Returns
+        -------
+        float
+            edge distance
+        """
+
+        if e2 == None:  # Del
+            return self.edge_del
+        if e1 == None:  # Insert
+            return self.edge_ins
+        else:
+            if e1 == e2:
+                return 0
+            return (self.edge_del + self.edge_ins) / 2.

GMatch4py/source/gmatch4py/ged/graph_edit_dist.pxd

@@ -0,0 +1,10 @@
+import numpy as np
+cimport numpy as np
+from .abstract_graph_edit_dist cimport AbstractGraphEditDistance
+
+
+cdef class GraphEditDistance(AbstractGraphEditDistance):
+    cpdef object relabel_cost(self, node1, node2, G, H)
+    cpdef double substitute_cost(self, node1, node2, G, H)
+    cdef double delete_cost(self, int i, int j, nodesG, G)
+    cdef double insert_cost(self, int i, int j, nodesH, H)

GMatch4py/source/gmatch4py/ged/graph_edit_dist.pyx

@@ -0,0 +1,57 @@
+# -*- coding: UTF-8 -*-
+
+import sys
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from .abstract_graph_edit_dist cimport AbstractGraphEditDistance
+
+
+
+cdef class GraphEditDistance(AbstractGraphEditDistance):
+
+    def __init__(self,node_del,node_ins,edge_del,edge_ins,weighted=False):
+        AbstractGraphEditDistance.__init__(self,node_del,node_ins,edge_del,edge_ins)
+        self.weighted=weighted
+        
+    cpdef double substitute_cost(self, node1, node2, G, H):
+        return self.relabel_cost(node1, node2, G, H)
+
+    cpdef object relabel_cost(self, node1, node2, G, H):
+        ## Si deux noeuds égaux
+        if node1 == node2 and G.degree(node1) == H.degree(node2):
+            return 0.0
+        elif node1 == node2 and G.degree(node1) != H.degree(node2):
+            #R = Graph(self.add_edges(node1,node2,G),G.get_node_key(),G.get_egde_key())
+            #R2 = Graph(self.add_edges(node1,node2,H),H.get_node_key(),H.get_egde_key())
+            #inter_= R.size_edge_intersect(R2)
+            R=set(G.get_edges_no(node1))
+            R2=set(H.get_edges_no(node2))
+            inter_=R.intersection(R2)
+            add_diff=abs(len(R2)-len(inter_))#abs(R2.density()-inter_)
+            del_diff=abs(len(R)-len(inter_))#abs(R.density()-inter_)
+            return (add_diff*self.edge_ins)+(del_diff*self.edge_del)
+
+
+        #si deux noeuds connectés
+        if  G.has_edge(node1,node2) or G.has_edge(node2,node1):
+            return self.node_ins+self.node_del
+        if not node2 in G.nodes():
+            nodesH=H.nodes()
+            index=list(nodesH).index(node2)
+            return self.node_del+self.node_ins+self.insert_cost(index,index,nodesH,H)
+        return sys.maxsize
+
+    cdef double delete_cost(self, int i, int j, nodesG, G):
+        if i == j:
+            return self.node_del+(G.degree(nodesG[i],weight=True)*self.edge_del) # Deleting a node implicate to delete in and out edges
+        return sys.maxsize
+
+    cdef double insert_cost(self, int i, int j, nodesH, H):
+        if i == j:
+            deg=H.degree(nodesH[j],weight=True)
+            if isinstance(deg,dict):deg=0
+            return self.node_ins+(deg*self.edge_ins)
+        else:
+            return sys.maxsize

GMatch4py/source/gmatch4py/ged/greedy_edit_distance.pyx

@@ -0,0 +1,30 @@
+# coding = utf-8
+import sys
+
+from .graph_edit_dist cimport GraphEditDistance
+import numpy as np
+cimport numpy as np
+from cython.parallel cimport prange,parallel
+
+cdef class GreedyEditDistance(GraphEditDistance):
+    """
+    Implementation of the Greedy Edit Distance presented in :
+
+    Improved quadratic time approximation of graph edit distance by Hausdorff matching and greedy assignement
+    Andreas Fischer, Kaspar Riesen, Horst Bunke
+    2016
+    """
+
+    def __init__(self,node_del,node_ins,edge_del,edge_ins):
+        GraphEditDistance.__init__(self,node_del,node_ins,edge_del,edge_ins)
+
+
+    cdef list edit_costs(self, G, H):
+        cdef np.ndarray cost_matrix=self.create_cost_matrix(G,H)
+        cdef np.ndarray cost_matrix_2=cost_matrix.copy().astype(np.double)
+        cdef list psi=[]
+        for i in range(len(cost_matrix)):
+            phi_i=np.argmin(cost_matrix_2[i])
+            cost_matrix_2[:,phi_i]=sys.maxsize
+            psi.append([i,phi_i]) #+i to compensate the previous column deletion
+        return [cost_matrix[psi[i][0]][psi[i][1]] for i in range(len(psi))]

GMatch4py/source/gmatch4py/ged/hausdorff_edit_distance.pyx

@@ -0,0 +1,220 @@
+# coding = utf-8
+
+import numpy as np
+cimport numpy as np
+from ..base cimport Base
+from cython.parallel cimport prange,parallel
+from ..helpers.general import parsenx2graph
+cimport cython
+
+cdef class HED(Base):
+    """
+    Implementation of Hausdorff Edit Distance described in
+
+    Improved quadratic time approximation of graph edit distance by Hausdorff matching and greedy assignement
+    Andreas Fischer, Kaspar Riesen, Horst Bunke
+    2016
+    """
+
+    cdef int node_del
+    cdef int node_ins
+    cdef int edge_del
+    cdef int edge_ins
+
+    def __init__(self, int node_del=1, int node_ins=1, int edge_del=1, int edge_ins=1):
+        """
+        HED Constructor
+
+        Parameters
+        ----------
+        node_del :int
+            Node deletion cost
+        node_ins : int
+            Node insertion cost
+        edge_del : int
+            Edge Deletion cost
+        edge_ins : int
+            Edge Insertion cost
+        """
+        Base.__init__(self,1,False)
+        self.node_del = node_del
+        self.node_ins = node_ins
+        self.edge_del = edge_del
+        self.edge_ins = edge_ins
+
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n = len(listgs)
+        cdef list new_gs=parsenx2graph(listgs,self.node_attr_key,self.edge_attr_key)
+        cdef double[:,:] comparison_matrix = np.zeros((n, n))
+        cdef double[:] selected_test = np.array(self.get_selected_array(selected,n))
+        cdef int i,j
+        cdef long[:] n_nodes = np.array([g.size() for g in new_gs])
+        cdef long[:] n_edges = np.array([g.density() for g in new_gs])
+
+        with nogil, parallel(num_threads=self.cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(i,n):
+                    if  n_nodes[i] > 0 and n_nodes[j] > 0  and selected_test[i] == True:
+                        with gil:
+                            comparison_matrix[i, j] = self.hed(new_gs[i], new_gs[j])
+                    else:
+                        comparison_matrix[i, j] = 0
+                    comparison_matrix[j, i] = comparison_matrix[i, j]
+
+        return np.array(comparison_matrix)
+
+
+    cdef float hed(self, g1, g2):
+        """
+        Compute the HED similarity value between two `gmatch4py.Graph`
+        
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First Graph
+        g2 : gmatch4py.Graph
+            Second Graph
+
+        Returns
+        -------
+        float 
+            similarity value
+        """
+        return self.sum_fuv(g1, g2) + self.sum_fuv(g2, g1)
+
+    cdef float sum_fuv(self, g1, g2):
+        """
+        Compute Nearest Neighbour Distance between G1 and G2
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+
+        Returns
+        -------
+        float
+            Nearest Neighbour Distance
+        """
+
+        cdef np.ndarray min_sum = np.zeros(g1.size())
+        cdef list nodes1 = list(g1.nodes())
+        cdef list nodes2 = list(g2.nodes())
+        nodes2.extend([None])
+        cdef np.ndarray min_i
+        for i in range(g1.size()):
+            min_i = np.zeros(g2.size())
+            for j in range(g2.size()):
+                min_i[j] = self.fuv(g1, g2, nodes1[i], nodes2[j])
+            min_sum[i] = np.min(min_i)
+        return np.sum(min_sum)
+
+    cdef float fuv(self, g1, g2, str n1, str n2):
+        """
+        Compute the Node Distance function
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+        n1 : int or str
+            identifier of the first node
+        n2 : int or str
+            identifier of the second node
+
+        Returns
+        -------
+        float
+            node distance
+        """
+        if n2 == None:  # Del
+            return self.node_del + ((self.edge_del / 2.) * g1.degree(n1))
+        if n1 == None:  # Insert
+            return self.node_ins + ((self.edge_ins / 2.) * g2.degree(n2))
+        else:
+            if n1 == n2:
+                return 0
+            return (self.node_del + self.node_ins + self.hed_edge(g1, g2, n1, n2)) / 2
+
+    cdef float hed_edge(self, g1, g2, str n1, str n2):
+        """
+        Compute HEDistance between edges of n1 and n2, respectively in g1 and g2
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+        n1 : int or str
+            identifier of the first node
+        n2 : int or str
+            identifier of the second node
+
+        Returns
+        -------
+        float
+            HEDistance between g1 and g2
+        """
+        return self.sum_gpq(g1, n1, g2, n2) + self.sum_gpq(g1, n1, g2, n2)
+
+
+    cdef float sum_gpq(self, g1, str n1, g2, str n2):
+        """
+        Compute Nearest Neighbour Distance between edges around n1 in G1  and edges around n2 in G2
+        Parameters
+        ----------
+        g1 : gmatch4py.Graph
+            First graph
+        g2 : gmatch4py.Graph
+            Second graph
+        n1 : int or str
+            identifier of the first node
+        n2 : int or str
+            identifier of the second node
+
+        Returns
+        -------
+        float
+            Nearest Neighbour Distance
+        """
+
+        #if isinstance(g1, nx.MultiDiGraph):
+        cdef list edges1 = g1.get_edges_no(n1) if n1 else [] # rename method ...
+        cdef list edges2 = g2.get_edges_no(n2) if n2 else []
+
+        cdef np.ndarray min_sum = np.zeros(len(edges1))
+        edges2.extend([None])
+        cdef np.ndarray min_i
+        for i in range(len(edges1)):
+            min_i = np.zeros(len(edges2))
+            for j in range(len(edges2)):
+                min_i[j] = self.gpq(edges1[i], edges2[j])
+            min_sum[i] = np.min(min_i)
+        return np.sum(min_sum)
+
+    cdef float gpq(self, str e1, str e2):
+        """
+        Compute the edge distance function
+        Parameters
+        ----------
+        e1 : str
+            first edge identifier
+        e2
+            second edge indentifier
+        Returns
+        -------
+        float
+            edge distance
+        """
+        if e2 == None:  # Del
+            return self.edge_del
+        if e1 == None:  # Insert
+            return self.edge_ins
+        else:
+            if e1 == e2:
+                return 0
+            return (self.edge_del + self.edge_ins) / 2.

GMatch4py/source/gmatch4py/graph.pxd

@@ -0,0 +1,122 @@
+cimport numpy as np
+
+cdef class Graph:
+    ##################################
+    #            ATTRIBUTES
+    ##################################
+
+    # GRAPH PROPERTY ATTRIBUTES
+    ###########################
+    cdef bint is_directed # If the graph is directed
+    cdef bint is_multi # If the graph is a Multi-Graph
+    cdef bint is_node_attr
+    cdef bint is_edge_attr
+
+    # ATTR VAL ATTRIBUTES
+    #####################
+    cdef str node_attr_key # Key that contains the main attr value for a node
+    cdef str edge_attr_key # Key that contains the main attr value for an edge
+    cdef set unique_node_attr_vals # list 
+    cdef set unique_edge_attr_vals # list 
+    
+
+    ## NODE ATTRIBUTES
+    #################
+
+    cdef list nodes_list # list of nodes ids
+    cdef list nodes_attr_list # list of attr value for each node (following nodes list order)
+    cdef list nodes_hash # hash representation of every node
+    cdef set nodes_hash_set # hash representation of every node (set version for intersection and union operation)
+    cdef dict nodes_idx # index of each node in `nodes_list`
+    cdef list nodes_weight # list that contains each node's weight (following nodes_list order)
+    cdef long[:] nodes_degree # degree list
+    cdef long[:] nodes_degree_in # in degree list
+    cdef long[:] nodes_degree_out # out degree list
+    cdef double[:] nodes_degree_weighted #weighted vers. of nodes_degree
+    cdef double[:] nodes_degree_in_weighted #weighted vers. of nodes_degree_in
+    cdef double[:] nodes_degree_out_weighted #weighted vers. of nodes_degree_out
+    cdef dict degree_per_attr # degree information per attr val
+    cdef dict degree_per_attr_weighted # degree information per attr val
+    cdef list attr_nodes # list of attr(dict) values for each node
+    cdef dict edges_of_nodes # list of egdes connected to each node
+
+    # EDGES ATTRIBUTES
+    ##################
+    
+    cdef list edges_list # edge list
+    cdef list edges_attr_list # list of attr value for each edge (following nodes list order)
+    cdef dict edges_hash_idx # index of hash in edges_list and edges_attr_list
+    cdef list edges_hash # hash representation of every edges ## A VOIR !
+    cdef set edges_hash_set # set of hash representation of every edges (set version for intersection and union operation)
+    cdef dict edges_weight # list that contains each node's weight (following nodes_list order)
+    cdef dict edges_hash_map #[id1,[id2,hash]] 
+    cdef list attr_edges # list of attr(dict) values for each edge 
+    
+    # SIZE ATTTRIBUTE
+    ###############
+
+    cdef long number_of_nodes  # number of nodes
+    cdef long number_of_edges # number of edges
+
+    cdef dict number_of_edges_per_attr # number of nodes per attr value
+    cdef dict number_of_nodes_per_attr # number of edges per attr value
+
+    cdef object nx_g
+
+    ##################################
+    #            METHODS
+    ##################################
+
+    # DIMENSION GETTER
+    ##################
+    cpdef long size(self)
+    cpdef int size_attr(self, attr_val)
+
+    cpdef long density(self)
+    cpdef int density_attr(self, str attr_val)
+
+    # HASH FUNCTION
+    ###############
+    cpdef str hash_node(self,str n1)
+    cpdef str hash_edge(self,str n1,str n2)
+    cpdef str hash_node_attr(self,str n1, str attr_value)
+    cpdef str hash_edge_attr(self,str n1,str n2, str attr_value)
+    
+    ## EXIST FUNCTION
+    ###############
+    cpdef bint has_node(self,str n_id)
+    cpdef bint has_edge(self,str n_id1,str n_id2)
+
+    ## LEN FUNCTION
+    ###############
+    cpdef int size_node_intersect(self,Graph G)
+    cpdef int size_node_union(self,Graph G)
+    
+    cpdef int size_edge_intersect(self,Graph G)
+    cpdef int size_edge_union(self,Graph G)
+
+    # DEGREE FUNCTION
+    #################
+    cpdef double degree(self,str n_id, bint weight=*)
+    cpdef double in_degree(self,str n_id, bint weight=*)
+    cpdef double out_degree(self,str n_id, bint weight=*)
+
+    cpdef double in_degree_attr(self,str n_id,str attr_val, bint weight=*)
+    cpdef double out_degree_attr(self,str n_id,str attr_val, bint weight=*)
+    cpdef double degree_attr(self,str n_id,str attr_val, bint weight=*)
+
+    ## GETTER
+    #########
+
+    cpdef list get_edges_ed(self,str e1, str e2)
+    cpdef list get_edges_no(self,str n)
+    cpdef set get_edges_hash(self)
+    cpdef set get_nodes_hash(self)
+    
+    cpdef str get_node_key(self)
+    cpdef str get_egde_key(self)
+
+    cpdef dict get_edge_attrs(self,edge_hash)
+    cpdef dict get_node_attrs(self, node_hash)
+    cpdef dict get_node_attr(self, node_hash)
+    cpdef dict get_edge_attr(self,edge_hash)

GMatch4py/source/gmatch4py/graph.pyx

@@ -0,0 +1,389 @@
+from libcpp.map cimport map
+from libcpp.utility cimport pair
+from libcpp.string  cimport string
+from libcpp.vector  cimport vector
+import numpy as np
+cimport numpy as np
+import networkx as nx
+
+cdef class Graph:
+
+    def __init__(self,G, node_attr_key="",edge_attr_key=""):
+        self.nx_g=G
+
+        #GRAPH PROPERTY INIT
+        self.is_directed = G.is_directed()
+        self.is_multi = G.is_multigraph()
+        self.is_node_attr=(True if node_attr_key else False)
+        self.is_edge_attr=(True if edge_attr_key else False)
+        if self.is_multi and not self.is_edge_attr:
+            if not len(nx.get_edge_attributes(G,"id")) == len(G.edges(data=True)):
+                i=0
+                for id1 in G.adj:
+                    for id2 in G.adj[id1]:
+                        for id3 in G.adj[id1][id2]:
+                            G._adj[id1][id2][id3]["id"]=str(i)
+                            i+=1
+            self.is_edge_attr = True
+            edge_attr_key = "id"  
+            
+        #    for ed in 
+
+        #len(nx.get_edge_attributes(G1,"id")) == len(G1.edges(data=True))
+
+        if len(G) ==0:
+            self.__init_empty__()    
+
+        else:
+            a,b=list(zip(*list(G.nodes(data=True))))
+            self.nodes_list,self.attr_nodes=list(a),list(b)
+            if G.number_of_edges()>0:
+                e1,e2,d=zip(*list(G.edges(data=True)))
+                self.attr_edges=list(d)
+                self.edges_list=list(zip(e1,e2))
+            else:
+                self.edges_list=[]
+                self.attr_edges=[]
+
+            if self.is_node_attr:
+                self.node_attr_key = node_attr_key
+                self.nodes_attr_list = [attr_dict[node_attr_key] for attr_dict in self.attr_nodes]
+                self.unique_node_attr_vals=set(self.nodes_attr_list)
+            
+            if self.is_edge_attr:
+                self.edge_attr_key = edge_attr_key
+                self.edges_attr_list = [attr_dict[edge_attr_key] for attr_dict in self.attr_edges]
+                self.unique_edge_attr_vals=set(self.edges_attr_list)
+
+            # NODE Information init
+            #######################
+            
+            self.nodes_hash=[self.hash_node_attr(node,self.nodes_attr_list[ix]) if self.is_node_attr else self.hash_node(node) for ix, node in enumerate(self.nodes_list) ]
+            self.nodes_hash_set=set(self.nodes_hash)
+            self.nodes_idx={node:ix for ix, node in enumerate(self.nodes_list)}
+            self.nodes_weight=[attr_dict["weight"] if "weight" in attr_dict else 1 for attr_dict in self.attr_nodes]
+            degree_all=[]
+            degree_in=[]
+            degree_out=[]
+
+            degree_all_weighted=[]
+            degree_in_weighted=[]
+            degree_out_weighted=[]
+            if self.is_edge_attr:
+                self.degree_per_attr={attr_v:{n:{"in":0,"out":0} for n in self.nodes_list} for attr_v in self.unique_edge_attr_vals}
+                self.degree_per_attr_weighted={attr_v:{n:{"in":0,"out":0} for n in self.nodes_list} for attr_v in self.unique_edge_attr_vals}
+            # Retrieving Degree Information
+            self.edges_of_nodes={}
+            for n in self.nodes_list:
+                self.edges_of_nodes[n]=[self.hash_edge_attr(e1,e2,attr_dict[self.edge_attr_key]) if self.is_edge_attr else self.hash_edge(e1,e2) for e1,e2,attr_dict in G.edges(n,data=True)]
+                degree_all.append(G.degree(n))
+                degree_all_weighted.append(G.degree(n,weight="weight"))
+                if self.is_directed:
+                    degree_in.append(G.in_degree(n))
+                    degree_in_weighted.append(G.in_degree(n,weight="weight"))
+                    degree_out.append(G.out_degree(n))
+                    degree_out_weighted.append(G.out_degree(n))
+                else:
+                    degree_in.append(degree_all[-1])
+                    degree_in_weighted.append(degree_all_weighted[-1])
+                    degree_out.append(degree_all[-1])
+                    degree_out_weighted.append(degree_all_weighted[-1])
+                if self.is_edge_attr:
+                    if self.is_directed:
+                        in_edge=list(G.in_edges(n,data=True))
+                        out_edge=list(G.out_edges(n,data=True))
+                        for n1,n2,attr_dict in in_edge:
+                            self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["in"]+=1
+                            self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["in"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+            
+                        for n1,n2,attr_dict in out_edge:
+                            self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["out"]+=1
+                            self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["out"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+        
+                    else:
+                        edges=G.edges(n,data=True)
+                        for n1,n2,attr_dict in edges:
+                            self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["in"]+=1
+                            self.degree_per_attr[attr_dict[self.edge_attr_key]][n]["out"]+=1
+                            self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["in"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+                            self.degree_per_attr_weighted[attr_dict[self.edge_attr_key]][n]["out"]+=1*(attr_dict["weight"] if "weight" in attr_dict else 1 )
+            
+            self.nodes_degree=np.array(degree_all)
+            self.nodes_degree_in=np.array(degree_in)
+            self.nodes_degree_out=np.array(degree_out)
+
+            self.nodes_degree_weighted=np.array(degree_all_weighted).astype(np.double)
+            self.nodes_degree_in_weighted=np.array(degree_in_weighted).astype(np.double)
+            self.nodes_degree_out_weighted=np.array(degree_out_weighted).astype(np.double)
+
+
+            # EDGE INFO INIT
+            #################
+            
+            self.edges_hash=[]
+            self.edges_hash_map = {}
+            self.edges_hash_idx = {}
+            for ix, ed in enumerate(self.edges_list):
+                e1,e2=ed
+                if not e1 in self.edges_hash_map:self.edges_hash_map[e1]={}
+                
+                hash_=self.hash_edge_attr(e1,e2,self.edges_attr_list[ix]) if self.is_edge_attr else self.hash_edge(e1,e2)
+                if self.is_multi and self.is_edge_attr:
+                    if not e2 in self.edges_hash_map[e1]:self.edges_hash_map[e1][e2]={}
+                    self.edges_hash_map[e1][e2][self.edges_attr_list[ix]]=hash_
+                else:
+                    self.edges_hash_map[e1][e2]=hash_
+                self.edges_hash_idx[hash_]=ix 
+                self.edges_hash.append(hash_) 
+            self.edges_hash_set=set(self.edges_hash)
+
+            self.edges_weight={}
+            for e1,e2,attr_dict in list(G.edges(data=True)):
+                hash_=self.hash_edge_attr(e1,e2,attr_dict[self.edge_attr_key]) if self.is_edge_attr else self.hash_edge(e1,e2)
+                self.edges_weight[hash_]=attr_dict["weight"] if "weight" in attr_dict else 1 
+            
+            self.number_of_edges = len(self.edges_list)
+            self.number_of_nodes = len(self.nodes_list)
+            
+            if self.is_edge_attr and self.number_of_edges >0:
+                self.number_of_edges_per_attr={attr:0 for attr in self.unique_edge_attr_vals}
+                for _,_,attr_dict in list(G.edges(data=True)):
+                    self.number_of_edges_per_attr[attr_dict[self.edge_attr_key]]+=1
+            
+            if self.is_node_attr and self.number_of_nodes >0:
+                self.number_of_nodes_per_attr={attr:0 for attr in self.unique_node_attr_vals}
+                for _,attr_dict in list(G.nodes(data=True)):
+                    self.number_of_nodes_per_attr[attr_dict[self.node_attr_key]]+=1
+
+    
+    # HASH FUNCTION
+    cpdef str hash_node(self,str n1):
+        return "{0}".format(n1)
+
+    cpdef str hash_edge(self,str n1,str n2):
+        if not self.is_directed:
+            return "_".join(sorted([n1,n2]))
+        return "_".join([n1,n2])
+
+    cpdef str hash_node_attr(self,str n1, str attr_value):
+        return "_".join([n1,attr_value])
+
+    cpdef str hash_edge_attr(self,str n1,str n2, str attr_value):
+        if self.is_directed:
+            return "_".join([n1,n2,attr_value])
+        ed=sorted([n1,n2])
+        ed.extend([attr_value])
+        return "_".join(ed)
+    
+    ## EXIST FUNCTION
+    cpdef bint has_node(self,str n_id):
+        if n_id in self.nodes_list:
+            return True
+        return False
+
+    cpdef bint has_edge(self,str n_id1,str n_id2):
+        if self.number_of_edges == 0:
+            return False
+        if self.is_directed:
+            if n_id1 in self.edges_hash_map and n_id2 in self.edges_hash_map[n_id1]:
+                return True
+        else:
+            if n_id1 in self.edges_hash_map and n_id2 in self.edges_hash_map[n_id1]:
+                return True
+            if n_id2 in self.edges_hash_map and n_id1 in self.edges_hash_map[n_id2]:
+                return True
+        return False
+
+    ## LEN FUNCTION
+    cpdef int size_node_intersect(self,Graph G):
+        if self.number_of_nodes == 0:
+            return 0
+        return len(self.nodes_hash_set.intersection(G.nodes_hash_set))
+    cpdef int size_node_union(self,Graph G):
+        return len(self.nodes_hash_set.union(G.nodes_hash_set))
+    
+    cpdef int size_edge_intersect(self,Graph G):
+        if self.number_of_edges == 0:
+            return 0
+        return len(self.edges_hash_set.intersection(G.edges_hash_set))
+    cpdef int size_edge_union(self,Graph G):
+        return len(self.edges_hash_set.union(G.edges_hash_set))
+    
+        ## GETTER
+    
+    def get_nx(self):
+        return self.nx_g
+
+    def nodes(self,data=False):
+        if data:
+            if self.number_of_nodes == 0:
+                    return [],[]
+            return self.nodes_list,self.attr_nodes
+        
+        if self.number_of_nodes == 0:
+                return []
+        return self.nodes_list
+        
+    
+    def edges(self,data=False):
+        if data:
+            if self.number_of_edges == 0:
+                    return [],[]
+            return self.edges_list,self.attr_edges
+        
+        if self.number_of_edges == 0:
+            return []
+        return self.edges_list
+    
+    cpdef list get_edges_ed(self,str e1,str e2):
+        if self.is_edge_attr:
+            hashes=self.edges_hash_map[e1][e2]
+            return [(e1,e2,self.edges_attr_list[self.edges_hash_idx[hash_]])for hash_ in hashes]
+        
+        return [(e1,e2,None)]
+            
+    cpdef list get_edges_no(self,str n):
+        return self.edges_of_nodes[n]
+
+    cpdef dict get_edge_attr(self,edge_hash):
+        return self.edges_attr_list[self.edges_hash_idx[edge_hash]]
+    
+    cpdef dict get_node_attr(self, node_hash):
+        return self.edges_attr_list[self.edges_hash_idx[node_hash]]
+
+    cpdef dict get_edge_attrs(self,edge_hash):
+        return self.attr_edges[self.edges_hash_idx[edge_hash]]
+    
+    cpdef dict get_node_attrs(self, node_hash):
+        return self.attr_nodes[self.edges_hash_idx[node_hash]]
+
+    cpdef set get_edges_hash(self):
+        return self.edges_hash_set
+
+    cpdef set get_nodes_hash(self):
+        return self.nodes_hash_set
+
+    cpdef str get_node_key(self):
+        return self.node_attr_key
+        
+    cpdef str get_egde_key(self):
+        return self.edge_attr_key
+    #####
+
+    cpdef long size(self):
+        return self.number_of_nodes
+    
+    cpdef int size_attr(self, attr_val):
+        return self.number_of_nodes_per_attr[attr_val]
+
+    cpdef long density(self):
+        return self.number_of_edges
+    
+    cpdef int density_attr(self, str attr_val):
+        return self.number_of_edges_per_attr[attr_val]
+
+    cpdef double degree(self,str n_id, bint weight=False):
+        if weight:
+            return self.nodes_degree_weighted[self.nodes_idx[n_id]]
+        return self.nodes_degree[self.nodes_idx[n_id]]
+    
+    cpdef double in_degree(self,str n_id, bint weight=False):
+        if weight:
+            return self.nodes_degree_in_weighted[self.nodes_idx[n_id]]
+        return self.nodes_degree_in[self.nodes_idx[n_id]]
+    
+    cpdef double out_degree(self,str n_id, bint weight=False):
+        if weight:
+            return self.nodes_degree_out_weighted[self.nodes_idx[n_id]]
+        return self.nodes_degree_out[self.nodes_idx[n_id]]
+
+    cpdef double in_degree_attr(self,str n_id,str attr_val, bint weight=False):
+        if not self.is_edge_attr and not self.is_directed:
+            raise AttributeError("No edge attribute have been defined")
+        if weight:
+            return self.degree_per_attr_weighted[attr_val][n_id]["in"]
+        return self.degree_per_attr[attr_val][n_id]["in"]
+
+    cpdef double out_degree_attr(self,str n_id,str attr_val, bint weight=False):
+        if not self.is_edge_attr and not self.is_directed:
+            raise AttributeError("No edge attribute have been defined")
+        if weight:
+            return self.degree_per_attr_weighted[attr_val][n_id]["out"]
+        return self.degree_per_attr[attr_val][n_id]["out"]
+
+    cpdef double degree_attr(self,str n_id,str attr_val, bint weight=False):
+        if not self.is_edge_attr:
+            raise AttributeError("No edge attribute have been defined")
+        if not self.is_directed:
+            if weight:
+                return self.degree_per_attr_weighted[attr_val][n_id]["out"]
+            return self.degree_per_attr[attr_val][n_id]["out"]
+        if weight:
+            return self.degree_per_attr_weighted[attr_val][n_id]["in"] + self.degree_per_attr_weighted[attr_val][n_id]["out"]
+        return self.degree_per_attr[attr_val][n_id]["out"] + self.degree_per_attr[attr_val][n_id]["in"]
+    
+    #GRAPH SETTER
+    def add_node(self,str id_,**kwargs):
+        if not self.node_attr_key in kwargs:
+            print("Node not added because information lacks")
+            return self
+        if id_ in self.nodes_idx:
+            print("Already in G")
+            return self
+        G=self.nx_g.copy()
+        G.add_node(id_,**kwargs)
+        return Graph(G,self.node_attr_key,self.edge_attr_key)
+    
+    
+    def add_edge(self,str n1,str n2,**kwargs):
+        G=self.nx_g.copy()
+        G.add_edge(n1,n2,**kwargs)
+        return Graph(G,self.node_attr_key,self.edge_attr_key)
+    
+    def remove_node(self,str id_):
+        if not id_ in self.nodes_idx:
+            print("Already removed in G")
+            return self
+        G=self.nx_g.copy()
+        G.remove_node(id_)
+        return Graph(G,self.node_attr_key,self.edge_attr_key)
+    
+    def remove_edge(self,str n1,str n2,**kwargs):
+        G=self.nx_g.copy()
+        edges=G.edges([n1,n2],data=True)
+        if len(edges) == 0:
+            return self
+        elif len(edges)<2:
+            G.remove_edge(n1,n2)
+        else:
+            if not self.edge_attr_key in kwargs:
+                for i in range(len(edges)):
+                    G.remove_edge(n1,n2,i)
+            else:
+                key,val,i=self.edge_attr_key, kwargs[self.edge_attr_key],0
+                for e1,ed2,attr_dict in edges:
+                    if attr_dict[key] == val:
+                        G.remove_edge(n1,n2,i)
+                        break
+                    i+=1
+                    
+        return Graph(G,self.node_attr_key,self.edge_attr_key)
+
+    def __init_empty__(self):
+        self.nodes_list,self.nodes_attr_list,self.nodes_hash,self.nodes_weight,self.attr_nodes=[],[],[],[],[]
+        self.nodes_degree,self.nodes_degree_in,self.nodes_degree_out,self.nodes_degree_weighted,self.nodes_degree_in_weighted,self.nodes_degree_out_weighted=np.array([],dtype=np.long),np.array([],dtype=np.long),np.array([],dtype=np.long),np.array([],dtype=np.double),np.array([],dtype=np.double),np.array([],dtype=np.double)
+        self.nodes_idx,self.degree_per_attr,self.degree_per_attr_weighted={},{},{}
+        self.nodes_hash_set=set([])
+        self.number_of_nodes = 0
+
+        self.number_of_edges = 0
+        self.edges_list=[]
+        self.edges_attr_list =[]
+        self.edges_hash_idx = {}
+        self.edges_hash = []
+        self.edges_hash_set= set([])
+        self.edges_weight={}
+        self.edges_hash_map={}
+        self.attr_edges=[]
+
+    

GMatch4py/source/gmatch4py/helpers/__init__.py

@@ -0,0 +1 @@
+# coding = utf-8

GMatch4py/source/gmatch4py/helpers/general.pyx

@@ -0,0 +1,23 @@
+from ..graph cimport Graph
+import networkx as nx
+
+def parsenx2graph(list_gs,node_attr_key="",edge_attr_key=""):
+    """
+    Parse list of Networkx graphs into Gmatch4py graph format
+    Parameters
+    ----------
+    list_gs : list
+        list of graph
+    node_attr_key : str
+        node attribute used for the hash
+    edge_attr_key: str
+        edge attribute used for the hash
+
+    Returns
+    -------
+    list
+        list of gmatch4py.Graph
+    """
+    new_gs=[nx.relabel_nodes(g,{node:str(node) for node in list(g.nodes)},copy=True) for g in list_gs]
+    new_gs=[Graph(g,node_attr_key,edge_attr_key) for g in new_gs]
+    return new_gs

GMatch4py/source/gmatch4py/helpers/reader.pyx

@@ -0,0 +1,79 @@
+# coding = utf-8
+import sys, os, glob, json, re
+import networkx as nx
+from tqdm import tqdm
+
+
+"""
+The reader submodule contains high-level function to read and store graphs from various files.
+"""
+
+
+
+methods_read_graph={
+        "gexf":nx.read_gexf,
+        "gml":nx.read_gml,
+        "graphml":nx.read_graphml
+    }
+
+def extract_index(fn):
+    """
+    Extract index from filename
+    Parameters
+    ----------
+    fn : str
+        filename
+
+    Returns
+    -------
+    int
+        index
+    """
+    try:
+        return int(re.findall("\d+",fn)[-1])
+    except:
+        print("No number found !")
+        return 0
+
+
+def import_dir(directory,format="gexf",numbered=True):
+    """
+    Based on a given directory, import all graphs and store them in a list/array
+
+    Parameters
+    ----------
+    directory : str
+        directory path where graphs are stored
+    format : str
+        graph file format
+    numbered
+        if graph filename are numbered
+    Returns
+    -------
+    array
+        graphs
+    """
+    if not os.path.exists(directory):
+        raise FileNotFoundError("{0} does not exists".format(directory))
+    if not format in methods_read_graph:
+        raise NotImplementedError("{0} is not implemented !".format(format))
+
+    # Retrieve filename
+    fns = glob.glob(os.path.join(directory, "*.{0}".format(format)))
+
+    graphs=[]
+    if numbered:
+        n=max([extract_index(fn) for fn in fns])
+        graphs= [nx.Graph()]*(n+1)
+
+    association_map, i = {}, 0
+    for fn in tqdm(fns,desc="Loading Graphs from {0}".format(directory)):
+        if not numbered:
+            graphs.append(methods_read_graph[format](fn))
+            association_map[fn]=i
+            i+=1
+        else:
+            graphs[extract_index(fn)]=methods_read_graph[format](fn)
+    if not numbered:
+        return association_map,graphs
+    return graphs

GMatch4py/source/gmatch4py/jaccard.pyx

@@ -0,0 +1,52 @@
+# coding = utf-8
+
+import numpy as np
+cimport numpy as np
+
+from .base cimport Base
+from .helpers.general import parsenx2graph
+from cython.parallel cimport prange,parallel
+cimport cython
+
+cdef class Jaccard(Base):
+
+    def __init__(self):
+        Base.__init__(self,0,True)
+
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n = len(listgs)
+        cdef list new_gs=parsenx2graph(listgs,self.node_attr_key,self.edge_attr_key)
+        cdef double[:,:] comparison_matrix = np.zeros((n, n))
+        cdef long[:] n_nodes = np.array([g.size() for g in new_gs])
+        cdef long[:] n_edges = np.array([g.density() for g in new_gs])
+        cdef int i,j
+
+        cdef double[:] selected_test = np.array(self.get_selected_array(selected,n))
+
+        cdef double[:,:] intersect_len_nodes = np.zeros((n, n))
+        cdef double[:,:] intersect_len_edges = np.zeros((n, n))
+        cdef double[:,:] union_len_nodes = np.zeros((n, n))
+        cdef double[:,:] union_len_edges = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i,n):
+                intersect_len_nodes[i][j]=new_gs[i].size_node_intersect(new_gs[j])
+                intersect_len_edges[i][j]=new_gs[i].size_edge_intersect(new_gs[j])#len(set(hash_edges[i]).intersection(hash_edges[j]))
+                union_len_nodes[i][j]=new_gs[i].size_node_union(new_gs[j])
+                union_len_edges[i][j]=new_gs[i].size_edge_union(new_gs[j])
+        with nogil, parallel(num_threads=self.cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(i,n):
+                    if  n_nodes[i] > 0 and n_nodes[j] > 0  and selected_test[i] == 1:
+                        if union_len_edges[i][j] >0 and union_len_nodes[i][j] >0:
+                            comparison_matrix[i][j]= \
+                                (intersect_len_edges[i][j]/union_len_edges[i][j])*\
+                                (intersect_len_nodes[i][j]/union_len_nodes[i][j])
+                        
+                        else:
+                            comparison_matrix[i][j] = 0.
+
+                        comparison_matrix[j][i] = comparison_matrix[i][j]
+
+        return np.array(comparison_matrix)

GMatch4py/source/gmatch4py/kernels/__init__.py

@@ -0,0 +1 @@
+# coding = utf-8

GMatch4py/source/gmatch4py/kernels/adjacency.pyx

@@ -0,0 +1,52 @@
+import networkx as nx
+import numpy as np
+
+def get_adjacency(G1,G2):
+    """
+    Return adjacency matrices of two graph based on nodes present in both of them.
+    
+    Parameters
+    ----------
+    G1 : nx.Graph
+        first graph
+    G2 : nx.Graph
+        second graph
+    
+    Returns
+    -------
+    tuple of np.array
+        adjacency matrices of G1 and G2
+    """
+
+    # Extract nodes
+    nodes_G1=list(G1.nodes())
+    nodes_G2=list(G2.nodes())
+
+    # Get Adjacency Matrix for each graph
+    adj_original_G1 = nx.convert_matrix.to_numpy_matrix(G1,nodes_G1)
+    adj_original_G2 = nx.convert_matrix.to_numpy_matrix(G2,nodes_G2)
+
+    # Get old index
+    index_node_G1={node: ix for ix,node in enumerate(nodes_G1)}
+    index_node_G2={node: ix for ix,node in enumerate(nodes_G2)}
+
+    # Building new indices
+    nodes_unique = list(set(nodes_G1).union(nodes_G2))
+    new_node_index = {node:i for i,node in enumerate(nodes_unique)}
+
+    n=len(nodes_unique)
+    
+    #Generate new adjacent matrices
+    new_adj_G1= np.zeros((n,n))
+    new_adj_G2= np.zeros((n,n))
+
+    # Filling old values
+    for n1 in nodes_unique:
+        for n2 in nodes_unique:
+            if n1 in G1.nodes() and n2 in G1.nodes():
+                new_adj_G1[new_node_index[n1],new_node_index[n2]]=adj_original_G1[index_node_G1[n1],index_node_G1[n2]]
+            if n1 in G2.nodes() and n2 in G2.nodes():
+                new_adj_G2[new_node_index[n1],new_node_index[n2]]=adj_original_G2[index_node_G2[n1],index_node_G2[n2]]
+
+    return new_adj_G1,new_adj_G2
+

GMatch4py/source/gmatch4py/kernels/random_walk_kernel.pyx

@@ -0,0 +1,93 @@
+# coding = utf-8
+
+import networkx as nx
+import numpy as np
+
+class GeometricRandomWalkKernel():
+    __type__ = "sim"
+    @staticmethod
+    def maxDegree(G):
+        degree_sequence = sorted(nx.degree(G).values(), reverse=True)  # degree sequence
+
+        # print "Degree sequence", degree_sequence
+        dmax = max(degree_sequence)
+        return dmax
+    @staticmethod
+    def compare(listgs):
+
+        n = len(listgs)
+        comparison_matrix=np.zeros((n,n))
+        for i in range(n):
+            for j in range(i,n):
+                if len(listgs[i]) <1 or len(listgs[j]) <1:
+                    comparison_matrix[i, j] = 0
+                    comparison_matrix[j, i] = 0
+                    continue
+                direct_product_graph=nx.tensor_product(listgs[i],listgs[j])
+                Ax = nx.adjacency_matrix(direct_product_graph).todense()
+                try:
+                    la = 1/ ((GeometricRandomWalkKernel.maxDegree(direct_product_graph)**2)+1) # lambda value
+                except:
+                    la= pow(1,-6)
+                eps = pow(10,-10)
+                I=np.identity(Ax.shape[0])
+                I_vec=np.ones(Ax.shape[0])
+                x=I_vec.copy()
+                x_pre=np.zeros(Ax.shape[0])
+                c=0
+
+                while (np.linalg.norm(x-x_pre)) > eps:
+                    if c > 100:
+                        break
+                    x_pre=x
+
+                    x= I_vec + la*np.dot(Ax,x_pre.T)
+                    c+=1
+                comparison_matrix[i,j]=np.sum(x)
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+        print(comparison_matrix)
+        for i in range(n):
+            for j in range(i,n):
+                comparison_matrix[i,j] = (comparison_matrix[i,j]/np.sqrt(comparison_matrix[i,i]*comparison_matrix[j,j]))
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+        return comparison_matrix
+
+class KStepRandomWalkKernel():
+    __type__ = "sim"
+    @staticmethod
+    def maxDegree(G):
+        degree_sequence = sorted(nx.degree(G).values(), reverse=True)  # degree sequence
+        # print "Degree sequence", degree_sequence
+        dmax = max(degree_sequence)
+        return dmax
+    @staticmethod
+    def compare(listgs,lambda_list=[1,1,1]):
+        k=len(lambda_list)
+        if not len(lambda_list) == k:
+            raise AttributeError
+        n = len(listgs)
+        comparison_matrix=np.zeros((n,n))
+        for i in range(n):
+            for j in range(i,n):
+                if len(listgs[i]) <1 or len(listgs[j]) <1:
+                    comparison_matrix[i, j] = 0
+                    comparison_matrix[j, i] = 0
+                    continue
+                direct_product_graph=nx.tensor_product(listgs[i],listgs[j])
+                Ax = nx.adjacency_matrix(direct_product_graph).todense()
+                eps = pow(10,-10)
+                I=np.identity(Ax.shape[0])
+                ax_pow = I.copy()
+                sum_ = lambda_list[0] * I
+                for kk in range(1, k):
+                    ax_pow *= Ax
+                    sum_ += lambda_list[kk] * ax_pow
+
+                comparison_matrix[i, j] = np.sum(sum_)/(len(listgs[i])**2 * len(listgs[j])**2)
+                comparison_matrix[j,i] = comparison_matrix[i,j]
+
+        for i in range(n):
+            for j in range(i,n):
+                comparison_matrix[i,j] = comparison_matrix[i,j]/np.sqrt(comparison_matrix[i,i]*comparison_matrix[j,j])
+                comparison_matrix[j,i]=comparison_matrix[i,j]
+        return comparison_matrix

GMatch4py/source/gmatch4py/kernels/shortest_path_kernel.pyx

@@ -0,0 +1,149 @@
+# coding = utf-8
+
+"""
+Shortest-Path graph kernel.
+Python implementation based on: "Shortest-path kernels on graphs", by
+Borgwardt, K.M.; Kriegel, H.-P., in Data Mining, Fifth IEEE
+International Conference on , vol., no., pp.8 pp.-, 27-30 Nov. 2005
+doi: 10.1109/ICDM.2005.132
+Author : Sandro Vega-Pons, Emanuele Olivetti
+Modified by : Jacques Fize
+"""
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from scipy.sparse.csgraph import floyd_warshall
+from .adjacency import get_adjacency
+from cython.parallel cimport prange,parallel
+from ..helpers.general import parsenx2graph
+from ..base cimport Base
+cimport cython
+
+cdef class ShortestPathGraphKernel(Base):
+    """
+    Shorthest path graph kernel.
+    """
+    def __init__(self):
+        Base.__init__(self,0,False)
+    
+    def compare_two(self,g_1, g_2):
+        """Compute the kernel value (similarity) between two graphs.
+        Parameters
+        ----------
+        g1 : networkx.Graph
+            First graph.
+        g2 : networkx.Graph
+            Second graph.
+        Returns
+        -------
+        k : The similarity value between g1 and g2.
+        """
+        # Diagonal superior matrix of the floyd warshall shortest
+        # paths:
+        if isinstance(g_1,nx.Graph) and isinstance(g_2,nx.Graph):
+            g_1,g_2= get_adjacency(g_1,g_2)
+
+        fwm1 = np.array(floyd_warshall(g_1))
+        fwm1[np.isinf(fwm1)] = 0
+        fwm1[np.isnan(fwm1)] = 0 
+        fwm1 = np.triu(fwm1, k=1)
+        bc1 = np.bincount(fwm1.reshape(-1).astype(int))
+
+        fwm2 = np.array(floyd_warshall(g_2))
+        fwm2[np.isinf(fwm2)] = 0
+        fwm2[np.isnan(fwm2)] = 0 
+        fwm2 = np.triu(fwm2, k=1)
+        bc2 = np.bincount(fwm2.reshape(-1).astype(int))
+
+        # Copy into arrays with the same length the non-zero shortests
+        # paths:
+        v1 = np.zeros(max(len(bc1), len(bc2)) - 1)
+        v1[range(0, len(bc1)-1)] = bc1[1:]
+
+        v2 = np.zeros(max(len(bc1), len(bc2)) - 1)
+        v2[range(0, len(bc2)-1)] = bc2[1:]
+
+        return np.sum(v1 * v2)
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list graph_list, list selected):
+        """Compute the all-pairs kernel values for a list of graphs.
+        This function can be used to directly compute the kernel
+        matrix for a list of graphs. The direct computation of the
+        kernel matrix is faster than the computation of all individual
+        pairwise kernel values.
+        Parameters
+        ----------
+        graph_list: list
+            A list of graphs (list of networkx graphs)
+        Return
+        ------
+        K: numpy.array, shape = (len(graph_list), len(graph_list))
+        The similarity matrix of all graphs in graph_list.
+        """
+        cdef int n = len(graph_list)
+        cdef double[:,:] k = np.zeros((n, n))
+        cdef int cpu_count = self.cpu_count
+        cdef int i,j
+        cdef list adjacency_matrices = [[None for i in range(n)]for j in range(n)]
+        
+        for i in range(n):
+            for j in range(i, n):
+                adjacency_matrices[i][j] = get_adjacency(graph_list[i],graph_list[j])
+                adjacency_matrices[j][i] = adjacency_matrices[i][j]
+        
+        with nogil, parallel(num_threads=cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(i, n):
+                    with gil:
+                        if len(graph_list[i]) > 0 and len(graph_list[j]) >0: 
+                            a,b=adjacency_matrices[i][j]
+                            k[i][j] = self.compare_two(a,b)
+                    k[j][i] = k[i][j]
+
+        k_norm = np.zeros((n,n))
+        for i in range(n):
+            for j in range(i,n):
+                k_norm[i, j] = k[i][j] / np.sqrt(k[i][i] * k[j][j])
+                k_norm[j, i] = k_norm[i, j]
+
+        return np.nan_to_num(k_norm)
+
+
+    
+cdef class ShortestPathGraphKernelDotCostMatrix(ShortestPathGraphKernel):
+    """
+    Instead of just multiply the count of distance values fou,d between nodes of each graph, this version propose to multiply the node distance matrix generated from each graph.
+    """
+    def __init__(self):
+        ShortestPathGraphKernel.__init__(self)
+    
+    def compare_two(self,g_1, g_2):
+        """Compute the kernel value (similarity) between two graphs.
+        Parameters
+        ----------
+        g1 : networkx.Graph
+            First graph.
+        g2 : networkx.Graph
+            Second graph.
+        Returns
+        -------
+        k : The similarity value between g1 and g2.
+        """
+        # Diagonal superior matrix of the floyd warshall shortest
+        # paths:
+        if isinstance(g_1,nx.Graph) and isinstance(g_2,nx.Graph):
+            g_1,g_2= get_adjacency(g_1,g_2)
+
+        fwm1 = np.array(floyd_warshall(g_1))
+        fwm1[np.isinf(fwm1)] = 0
+        fwm1[np.isnan(fwm1)] = 0 
+        fwm1 = np.triu(fwm1, k=1)
+
+        fwm2 = np.array(floyd_warshall(g_2))
+        fwm2[np.isinf(fwm2)] = 0
+        fwm2[np.isnan(fwm2)] = 0 
+        fwm2 = np.triu(fwm2, k=1)
+        
+        return np.sum(fwm1 * fwm2)

GMatch4py/source/gmatch4py/kernels/weisfeiler_lehman.pyx

@@ -0,0 +1,144 @@
+# coding = utf-8
+
+"""Weisfeiler_Lehman graph kernel.
+
+Python implementation based on: "Weisfeiler-Lehman Graph Kernels", by:
+Nino Shervashidze, Pascal Schweitzer, Erik J. van Leeuwen, Kurt
+Mehlhorn, Karsten M. Borgwardt, JMLR, 2012.
+http://jmlr.csail.mit.edu/papers/v12/shervashidze11a.html
+
+Author : Sandro Vega-Pons, Emanuele Olivetti
+Source : https://github.com/emanuele/jstsp2015/blob/master/gk_weisfeiler_lehman.py
+Modified by : Jacques Fize
+"""
+
+import copy
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from ..base cimport Base
+from ..base import minmax_scale
+from scipy.sparse import csc_matrix,lil_matrix
+
+cdef class WeisfeleirLehmanKernel(Base):
+
+    cdef int h
+
+    def __init__(self,h=2):
+        Base.__init__(self,0,True)
+        self.h=h
+
+
+    cpdef np.ndarray compare(self,list graph_list, list selected):
+        """Compute the all-pairs kernel values for a list of graphs.
+        This function can be used to directly compute the kernel
+        matrix for a list of graphs. The direct computation of the
+        kernel matrix is faster than the computation of all individual
+        pairwise kernel values.
+        Parameters
+        ----------
+        graph_list: list
+            A list of graphs (list of networkx graphs)
+        h : interger
+            Number of iterations.
+        node_label : boolean
+            Whether to use original node labels. True for using node labels
+            saved in the attribute 'node_label'. False for using the node
+            degree of each node as node attribute.
+        Return
+        ------
+        K: numpy.array, shape = (len(graph_list), len(graph_list))
+        The similarity matrix of all graphs in graph_list.
+        """
+
+        cdef int n = len(graph_list)
+        cdef int n_nodes = 0
+        cdef int n_max = 0
+        cdef int i,j
+        # Compute adjacency lists and n_nodes, the total number of
+        # nodes in the dataset.
+        for i in range(n):
+            n_nodes += graph_list[i].number_of_nodes()
+
+            # Computing the maximum number of nodes in the graphs. It
+            # will be used in the computation of vectorial
+            # representation.
+            if n_max < graph_list[i].number_of_nodes():
+                n_max = graph_list[i].number_of_nodes()
+
+        phi = np.zeros((n_nodes, n), dtype=np.uint64)
+        phi=lil_matrix(phi)
+
+        # INITIALIZATION: initialize the nodes labels for each graph
+        # with their labels or with degrees (for unlabeled graphs)
+
+        cdef list labels = [0] * n
+        cdef dict label_lookup = {}
+        cdef int label_counter = 0
+
+
+        # label_lookup is an associative array, which will contain the
+        # mapping from multiset labels (strings) to short labels
+        # (integers)
+
+        cdef list nodes
+        for i in range(n):
+            nodes = list(graph_list[i].nodes)
+            # It is assumed that the graph has an attribute
+            # 'node_label'
+            labels[i] = np.zeros(len(nodes), dtype=np.int32)
+
+            for j in range(len(nodes)):
+                if not (nodes[j] in label_lookup):
+                    label_lookup[nodes[j]] = str(label_counter)
+                    labels[i][j] = label_counter
+                    label_counter += 1
+                else:
+                    labels[i][j] = label_lookup[nodes[j]]
+                # labels are associated to a natural number
+                # starting with 0.
+
+                phi[labels[i][j], i] += 1
+
+            graph_list[i]=nx.relabel_nodes(graph_list[i],label_lookup)
+
+        # cdef np.ndarray[np.float64_t] k
+        k = np.dot(phi.transpose(), phi)
+        # MAIN LOOP
+        cdef int it = 0
+
+        new_labels = copy.deepcopy(labels) # Can't work without it !!!
+
+        while it < self.h:
+            # create an empty lookup table
+            label_lookup = {}
+            label_counter = 0
+
+            phi = np.zeros((n_nodes, n))
+            for i in range(n):
+                nodes = list(graph_list[i].nodes)
+                for v in range(len(nodes)):
+                    # form a multiset label of the node v of the i'th graph
+                    # and convert it to a string
+
+                    long_label = []
+                    long_label.extend(nx.neighbors(graph_list[i],nodes[v]))
+
+                    long_label_string = "".join(long_label)
+                    # if the multiset label has not yet occurred, add it to the
+                    # lookup table and assign a number to it
+                    if not (long_label_string in label_lookup):
+                        label_lookup[long_label_string] = str(label_counter)
+                        new_labels[i][v] = label_counter
+                        label_counter += 1
+                    else:
+                        new_labels[i][v] = label_lookup[long_label_string]
+                # fill the column for i'th graph in phi
+                aux = np.bincount(new_labels[i])
+                phi[new_labels[i], i] += aux[new_labels[i]]
+
+            k += np.dot(phi.transpose(), phi)
+            it = it + 1
+
+        return np.ma.getdata(minmax_scale(k))

GMatch4py/source/gmatch4py/mcs.pyx

@@ -0,0 +1,45 @@
+# coding = utf-8
+import numpy as np
+cimport numpy as np
+from .graph cimport Graph
+from .base cimport Base
+from cython.parallel cimport prange,parallel
+from .helpers.general import parsenx2graph
+cimport cython
+
+cdef class MCS(Base):
+    """
+    *A graph distance metric based on the maximal common subgraph, H. Bunke and K. Shearer,
+    Pattern Recognition Letters, 1998*
+    """
+    def __init__(self):
+        Base.__init__(self,0,True)
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n = len(listgs)
+        cdef double [:,:] comparison_matrix = np.zeros((n, n))
+        cdef double[:] selected_test = np.array(self.get_selected_array(selected,n))
+        cdef list new_gs=parsenx2graph(listgs,self.node_attr_key,self.edge_attr_key)
+        cdef long[:] n_nodes = np.array([g.size() for g in new_gs])
+        cdef double [:,:] intersect_len_nodes = np.zeros((n, n))
+        cdef int i,j
+        for i in range(n):
+            for j in range(i,n):
+                intersect_len_nodes[i][j]=new_gs[i].size_node_intersect(new_gs[j])
+
+        with nogil, parallel(num_threads=self.cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(i, n):
+                    if  n_nodes[i] > 0 and n_nodes[j] > 0  and selected_test[i] == 1:
+                        comparison_matrix[i][j] = intersect_len_nodes[i][j]/max(n_nodes[i],n_nodes[j])
+                    else:
+                        comparison_matrix[i][j] = 0.
+                    if i==j:
+                        comparison_matrix[i][j]=1
+                    comparison_matrix[j][i] = comparison_matrix[i][j]
+
+        
+        return np.array(comparison_matrix)
+
+

GMatch4py/source/gmatch4py/vertex_edge_overlap.pyx

@@ -0,0 +1,57 @@
+# coding = utf-8
+
+import numpy as np
+cimport numpy as np
+
+from .graph cimport Graph
+from cython.parallel cimport prange,parallel
+from .helpers.general import parsenx2graph
+cimport cython
+from .base cimport Base
+
+cdef class VertexEdgeOverlap(Base):
+
+    """
+    Vertex/Edge Overlap Algorithm
+    presented in Web graph similarity for anomaly detection, Journal of Internet Services and Applications, 2008
+    by P. Papadimitriou, A. Dasdan and H.Gracia-Molina
+
+    Code Author : Jacques Fize
+    """
+    def __init__(self):
+        Base.__init__(self,0,True)
+
+    @cython.boundscheck(False)
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n = len(listgs)
+        cdef list new_gs=parsenx2graph(listgs,self.node_attr_key,self.edge_attr_key)
+        cdef double[:,:] comparison_matrix = np.zeros((n, n))
+        cdef int denom,i,j
+        cdef long[:] n_nodes = np.array([g.size() for g in new_gs])
+        cdef long[:] n_edges = np.array([g.density() for g in new_gs])
+
+        cdef double[:] selected_test = np.array(self.get_selected_array(selected,n))
+
+        cdef double[:,:] intersect_len_nodes = np.zeros((n, n))
+        cdef double[:,:] intersect_len_edges = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i,n):
+                intersect_len_nodes[i][j]=new_gs[i].size_node_intersect(new_gs[j])
+                intersect_len_edges[i][j]=new_gs[i].size_edge_intersect(new_gs[j])#len(set(hash_edges[i]).intersection(hash_edges[j]))
+                
+        with nogil, parallel(num_threads=self.cpu_count):
+            for i in prange(n,schedule='static'):
+                for j in range(i,n):
+                    if  n_nodes[i] > 0 and n_nodes[j] > 0  and selected_test[i] == 1:
+                        denom=n_nodes[i]+n_nodes[j]+\
+                              n_edges[i]+n_edges[j]
+                        if  denom > 0:
+                            comparison_matrix[i][j]=(2*(intersect_len_nodes[i][j]
+                                                  +intersect_len_edges[i][j]))/denom # Data = True --> For nx.MultiDiGraph
+                        if i==j:
+                            comparison_matrix[i][j]=1
+                        comparison_matrix[j][i] = comparison_matrix[i][j]
+        return np.array(comparison_matrix)
+
+
+

GMatch4py/source/gmatch4py/vertex_ranking.pyx

@@ -0,0 +1,42 @@
+# coding = utf-8
+
+import networkx as nx
+import numpy as np
+cimport numpy as np
+from scipy.stats import spearmanr
+
+from .base cimport Base
+
+cdef class VertexRanking(Base):
+    """
+    Vertex Ranking
+    presented in Web graph similarity for anomaly detection, Journal of Internet Services and Applications, 2008 # Maybe not ??
+    by P. Papadimitriou, A. Dasdan and H.Gracia-Molina
+
+    Code Author : Jacques Fize
+
+    """
+    def __init__(self):
+        Base.__init__(self,0,True)
+
+    cpdef np.ndarray compare(self,list listgs, list selected):
+        cdef int n,i,j # number of graphs
+        n = len(listgs)
+
+        cdef np.ndarray comparison_matrix = np.zeros((n,n)) #similarity matrix
+        cdef list X,Y,pager_i,pager_j,page_r,node_intersection #temp data (page rank data for the most part)
+        page_r=[nx.pagerank(nx.DiGraph(g)) for g in listgs]
+        for i in range(n):
+            pager_i=list(page_r[i])
+            for j in range(i,n):
+                g1,g2=listgs[i],listgs[j]
+                f=self.isAccepted(g1,i,selected)
+                pager_j=list(page_r[j])
+                node_intersection=list(set(pager_i) & set(pager_j))
+                X,Y=[],[]
+                for node in node_intersection:
+                    X.append(page_r[i][node])
+                    Y.append(page_r[j][node])
+                comparison_matrix[i,j] = spearmanr(X,Y)[0]
+                comparison_matrix[j,i] = comparison_matrix[i,j]
+        return np.nan_to_num(comparison_matrix)