graph2emb 0.9.0__tar.gz

graph2emb-0.9.0/.gitignore

@@ -0,0 +1,8 @@
+*.pyc
+.idea
+.vscode
+dist/
+*.egg-info/
+.venv/
+.pytest_cache/
+__pycache__/

graph2emb-0.9.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018, 2025 Elior Cohen, Sangkon Han
+
+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.

graph2emb-0.9.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: graph2emb
+Version: 0.9.0
+Summary: Implementation of the graph2vec algorithm
+Project-URL: Homepage, https://github.com/sigmadream/graph2emb
+Project-URL: Repository, https://github.com/sigmadream/graph2emb
+Author-email: Sangkon Heo <sigmadream@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: joblib>=1.4.0
+Requires-Dist: networkx>=3.1.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: tqdm>=4.66.1
+Description-Content-Type: text/markdown
+
+# graph2emb
+
+> [Elior Cohen의 node2vec](https://github.com/eliorc/node2vec), [graph2vec](https://github.com/benedekrozemberczki/graph2vec)를 참고해 Node2Vec + Graph2Vec 기능을 한 프로젝트로 합친 구현체입니다.
+
+## 특징
+
+- Node2Vec: 랜덤 워크 기반 노드 임베딩
+- Edge embedding: (Hadamard/평균/L1/L2) 방식의 엣지 임베딩
+- Graph2Vec: WL(Weisfeiler–Lehman) hashing + Doc2Vec 기반 그래프 임베딩
+- uv 기반 개발/실행
+
+> 파이썬 모듈 이름은 `graph2emb` 입니다.
+
+## 빠른 시작 (sample 실행)
+
+```bash
+# 의존성/프로젝트 설치
+uv sync
+
+# Node2Vec (edge list 로드)
+uv run python sample/node2vec_from_edgelist.py
+
+# Node2Vec + edge embedding
+uv run python sample/node2vec_edge_embeddings.py
+
+# Graph2Vec
+uv run python sample/graph2vec_basic.py
+```
+
+샘플 설명은 `sample/README.md`를 참고하세요.
+
+## 사용 예시 (코드)
+
+### Node2Vec (노드 임베딩)
+
+```python
+import networkx as nx
+from graph2emb import Node2Vec
+
+g = nx.fast_gnp_random_graph(n=100, p=0.3, seed=42)
+node2vec = Node2Vec(g, dimensions=64, walk_length=30, num_walks=20, workers=1, seed=42)
+model = node2vec.fit(window=10, min_count=1, epochs=5)
+
+print(model.wv.most_similar("2", topn=5))  # 노드 id는 문자열로 조회
+```
+
+### Edge embedding (엣지 임베딩)
+
+```python
+from graph2emb.edges import HadamardEmbedder
+
+edges_embs = HadamardEmbedder(model.wv)
+print(edges_embs[("1", "2")])
+```
+
+### Graph2Vec (그래프 임베딩)
+
+```python
+import networkx as nx
+from graph2emb import Graph2Vec
+
+graphs = [
+    nx.fast_gnp_random_graph(n=12, p=0.3, seed=1),
+    nx.fast_gnp_random_graph(n=14, p=0.2, seed=2),
+]
+
+g2v = Graph2Vec(dimensions=32, workers=1, min_count=1, epochs=3, seed=42)
+g2v.fit(graphs)
+emb = g2v.get_embedding()  # shape: (len(graphs), dimensions)
+```
+
+## 개발/테스트
+
+```bash
+# 테스트 실행
+uv run pytest
+
+# 병렬 테스트
+uv run pytest -n auto
+
+# 커버리지 포함 테스트 실행
+uv run pytest --cov=graph2emb --cov-report=html
+```

graph2emb-0.9.0/README.md

@@ -0,0 +1,83 @@
+# graph2emb
+
+> [Elior Cohen의 node2vec](https://github.com/eliorc/node2vec), [graph2vec](https://github.com/benedekrozemberczki/graph2vec)를 참고해 Node2Vec + Graph2Vec 기능을 한 프로젝트로 합친 구현체입니다.
+
+## 특징
+
+- Node2Vec: 랜덤 워크 기반 노드 임베딩
+- Edge embedding: (Hadamard/평균/L1/L2) 방식의 엣지 임베딩
+- Graph2Vec: WL(Weisfeiler–Lehman) hashing + Doc2Vec 기반 그래프 임베딩
+- uv 기반 개발/실행
+
+> 파이썬 모듈 이름은 `graph2emb` 입니다.
+
+## 빠른 시작 (sample 실행)
+
+```bash
+# 의존성/프로젝트 설치
+uv sync
+
+# Node2Vec (edge list 로드)
+uv run python sample/node2vec_from_edgelist.py
+
+# Node2Vec + edge embedding
+uv run python sample/node2vec_edge_embeddings.py
+
+# Graph2Vec
+uv run python sample/graph2vec_basic.py
+```
+
+샘플 설명은 `sample/README.md`를 참고하세요.
+
+## 사용 예시 (코드)
+
+### Node2Vec (노드 임베딩)
+
+```python
+import networkx as nx
+from graph2emb import Node2Vec
+
+g = nx.fast_gnp_random_graph(n=100, p=0.3, seed=42)
+node2vec = Node2Vec(g, dimensions=64, walk_length=30, num_walks=20, workers=1, seed=42)
+model = node2vec.fit(window=10, min_count=1, epochs=5)
+
+print(model.wv.most_similar("2", topn=5))  # 노드 id는 문자열로 조회
+```
+
+### Edge embedding (엣지 임베딩)
+
+```python
+from graph2emb.edges import HadamardEmbedder
+
+edges_embs = HadamardEmbedder(model.wv)
+print(edges_embs[("1", "2")])
+```
+
+### Graph2Vec (그래프 임베딩)
+
+```python
+import networkx as nx
+from graph2emb import Graph2Vec
+
+graphs = [
+    nx.fast_gnp_random_graph(n=12, p=0.3, seed=1),
+    nx.fast_gnp_random_graph(n=14, p=0.2, seed=2),
+]
+
+g2v = Graph2Vec(dimensions=32, workers=1, min_count=1, epochs=3, seed=42)
+g2v.fit(graphs)
+emb = g2v.get_embedding()  # shape: (len(graphs), dimensions)
+```
+
+## 개발/테스트
+
+```bash
+# 테스트 실행
+uv run pytest
+
+# 병렬 테스트
+uv run pytest -n auto
+
+# 커버리지 포함 테스트 실행
+uv run pytest --cov=graph2emb --cov-report=html
+```

graph2emb-0.9.0/README_ORG.md

@@ -0,0 +1,107 @@
+# Node2Vec
+[![Downloads](http://pepy.tech/badge/node2vec)](http://pepy.tech/project/node2vec)
+
+Python3 implementation of the node2vec algorithm Aditya Grover, Jure Leskovec and Vid Kocijan.
+[node2vec: Scalable Feature Learning for Networks. A. Grover, J. Leskovec. ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 2016.](https://snap.stanford.edu/node2vec/)
+
+# Maintenance
+
+### I no longer have time to maintain this, if someone wants to pick the baton let me know
+
+## Installation
+
+`pip install node2vec`
+
+## Usage
+```python
+import networkx as nx
+from graph2emb import Node2Vec
+
+# Create a graph
+graph = nx.fast_gnp_random_graph(n=100, p=0.5)
+
+# Precompute probabilities and generate walks - **ON WINDOWS ONLY WORKS WITH workers=1**
+node2vec = Node2Vec(graph, dimensions=64, walk_length=30, num_walks=200, workers=4)  # Use temp_folder for big graphs
+
+# Embed nodes
+model = node2vec.fit(window=10, min_count=1, batch_words=4)  # Any keywords acceptable by gensim.Word2Vec can be passed, `dimensions` and `workers` are automatically passed (from the Node2Vec constructor)
+
+# Look for most similar nodes
+model.wv.most_similar('2')  # Output node names are always strings
+
+# Save embeddings for later use
+model.wv.save_word2vec_format(EMBEDDING_FILENAME)
+
+# Save model for later use
+model.save(EMBEDDING_MODEL_FILENAME)
+
+# Embed edges using Hadamard method
+from graph2emb.edges import HadamardEmbedder
+
+edges_embs = HadamardEmbedder(keyed_vectors=model.wv)
+
+# Look for embeddings on the fly - here we pass normal tuples
+edges_embs[('1', '2')]
+''' OUTPUT
+array([ 5.75068220e-03, -1.10937878e-02,  3.76693785e-01,  2.69105062e-02,
+       ... ... ....
+       ..................................................................],
+      dtype=float32)
+'''
+
+# Get all edges in a separate KeyedVectors instance - use with caution could be huge for big networks
+edges_kv = edges_embs.as_keyed_vectors()
+
+# Look for most similar edges - this time tuples must be sorted and as str
+edges_kv.most_similar(str(('1', '2')))
+
+# Save embeddings for later use
+edges_kv.save_word2vec_format(EDGES_EMBEDDING_FILENAME)
+
+```
+
+### Parameters
+
+#### `node2vec.Node2vec`
+
+- `Node2Vec` constructor:
+    1. `graph`: The first positional argument has to be a networkx graph. Node names must be all integers or all strings. On the output model they will always be strings.
+    2. `dimensions`: Embedding dimensions (default: 128)
+    3. `walk_length`: Number of nodes in each walk (default: 80)
+    4. `num_walks`: Number of walks per node (default: 10)
+    5. `p`: Return hyper parameter (default: 1)
+    6. `q`: Input parameter (default: 1)
+    7. `weight_key`: On weighted graphs, this is the key for the weight attribute (default: 'weight')
+    8. `workers`: Number of workers for parallel execution (default: 1)
+    9. `sampling_strategy`: Node specific sampling strategies, supports setting node specific 'q', 'p', 'num_walks' and 'walk_length'.
+        Use these keys exactly. If not set, will use the global ones which were passed on the object initialization`
+    10. `quiet`: Boolean controlling the verbosity. (default: False)
+    11. `temp_folder`: String path pointing to folder to save a shared memory copy of the graph - Supply when working on graphs that are too big to fit in memory during algorithm execution.
+    12. `seed`: Seed for the random number generator (default: None). Deterministic results can be obtained if seed is set and `workers=1`.
+
+- `Node2Vec.fit` method:
+    Accepts any key word argument acceptable by gensim.Word2Vec
+
+#### `node2vec.EdgeEmbedder`
+
+`EdgeEmbedder` is an abstract class which all the concrete edge embeddings class inherit from.
+The classes are `AverageEmbedder`, `HadamardEmbedder`, `WeightedL1Embedder` and `WeightedL2Embedder` which their practical definition could be found in the [paper](https://arxiv.org/pdf/1607.00653.pdf) on table 1
+Notice that edge embeddings are defined for any pair of nodes, connected or not and even node with itself.
+
+- Constructor:
+    1. `keyed_vectors`: A gensim.models.KeyedVectors instance containing the node embeddings
+    2. `quiet`: Boolean controlling the verbosity. (default: False)
+
+- `EdgeEmbedder.__getitem__(item)` method, better known as `EdgeEmbedder[item]`:
+    1. `item` - A tuple consisting of 2 nodes from the `keyed_vectors` passed in the constructor. Will return the embedding of the edge.
+
+- `EdgeEmbedder.as_keyed_vectors` method: Returns a `gensim.models.KeyedVectors` instance with all possible node pairs in a *sorted* manner as string.
+  For example, for nodes ['1', '2', '3'] we will have as keys "('1', '1')", "('1', '2')", "('1', '3')", "('2', '2')", "('2', '3')" and "('3', '3')".
+
+## Caveats
+- Node names in the input graph must be all strings, or all ints
+- Parallel execution not working on Windows (`joblib` known issue). To run non-parallel on Windows pass `workers=1` on the `Node2Vec`'s constructor
+
+## TODO
+- [x] Parallel implementation for walk generation
+- [ ] Parallel implementation for probability precomputation

graph2emb-0.9.0/graph2emb/__init__.py

@@ -0,0 +1,11 @@
+from . import edges
+from .node2vec import Node2Vec
+from .graph2vec import Graph2Vec
+from importlib import metadata
+
+try:
+    __version__ = metadata.version("graph2emb")
+except metadata.PackageNotFoundError:
+    __version__ = "0.0.0"
+
+