rdf2vecgpu 0.1.0__tar.gz

rdf2vecgpu-0.1.0/.gitignore

@@ -0,0 +1,189 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc
+
+data/*
+!data/.gitkeep
+wandb/
+job/
+vector/
+walks/
+python-server/
+dask_spill/
+lightning_logs/
+.vscode/
+spark_local/
+wikidata_parquet/
+.scale*
+test.py
+*.xlsx
+wikidata*
+.uv.lock

rdf2vecgpu-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

rdf2vecgpu-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Martin Böckling
+
+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.

rdf2vecgpu-0.1.0/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: rdf2vecgpu
+Version: 0.1.0
+Summary: GPU-Accelerated RDF2Vec – A high-performance GPU implementation of RDF2Vec that uses CUDA and RAPIDS to generate scalable, embeddings for large dense knowledge graphs.
+Project-URL: Homepage, https://github.com/MartinBoeckling/rdf2vecgpu
+Project-URL: Issues, https://github.com/MartinBoeckling/rdf2vecgpu/issues
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: cudf-cu12>=25.6.0
+Requires-Dist: cugraph-cu12==25.6.*
+Requires-Dist: cupy-cuda12x>=13.5.1
+Requires-Dist: dask-cudf-cu12>=25.6.0
+Requires-Dist: dask[complete]>=2025.5.0
+Requires-Dist: lightning>=2.5.2
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: rdflib>=7.1.4
+Requires-Dist: torch>=2.7.1
+Requires-Dist: tqdm>=4.67.1
+Description-Content-Type: text/markdown
+
+## gpuRDF2Vec
+A scalable GPU based implementation of RDF2Vec embeddings for large and dense Knowledge Graphs.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+![RDF2VecGPU_Image](img/github_repo_header.png)
+
+> [!IMPORTANT]
+> This package is under active development in the beta phase. The overall class/ method design will most probably change and introduce breaking changes between releases
+
+## Table of contents
+The content of this repository readme can be found here:
+- [gpuRDF2Vec](#gpurdf2vec)
+- [Table of contents](#table-of-contents)
+- [Repository setup](#repository-setup)
+- [gpuRDF2Vec overview](#gpurdf2vec-overview)
+  - [Repository Structure](#repository-structure)
+  - [Capability overview](#capability-overview)
+- [Quick start](#quick-start)
+- [Implementation Details](#implementation-details)
+- [License](#license)
+- [Roadmap](#roadmap)
+- [Report issues and bugs](#report-issues-and-bugs)
+
+
+## Repository setup
+The repository setup builds on top of two major libraries. Both Pytorch lightning as well as the RAPIDS libraries cuDF and cuGraph. We provide the exeplanatory installation details for Cuda 12.6:
+1. Pytorch [installation page](https://pytorch.org/get-started/locally/)
+Cuda 12.6 installation
+```bash
+pip install torch torchvision torchaudio
+```
+2. Detailed cudf installation instruction [here](https://docs.rapids.ai/install/).
+Cudf Cuda 12 install
+```bash
+pip install \
+    --extra-index-url=https://pypi.nvidia.com \
+    "cudf-cu12==25.4.*" "dask-cudf-cu12==25.4.*" \
+    "cugraph-cu12==25.4.*" "nx-cugraph-cu12==25.4.*" \
+    "nx-cugraph-cu12==25.4.*"
+```
+The requirement files and conda environment files can be found here: 
+- [Conda environment](performance/env_files/rdf2vecgpu_environment.yml)
+- [Requirement file](performance/env_files/rdf2vecgpu_requirements.txt)
+## gpuRDF2Vec overview
+RDF2Vec is a powerful technique to generate vector embeddings of entities in RDF graphs via random walks and Word2Vec. This repository provides a GPU-optimized reimplementation, enabling:
+
+- **Speedups** on dense graphs with millions of nodes
+- **Scalability** to industrial-scale knowledge bases
+- **Reproducible experiments** to test and qualify the overall implementation details
+### Repository Structure
+```bash
+.
+├── README.md
+├── data
+├── data_preparation
+│   ├── converstion_to_ttl.py
+│   └── merge_text_file.py
+├── img
+│   └── github_repo_header.png
+├── jrdf2vec-1.3-SNAPSHOT.jar
+├── performance
+│   ├── env_files
+│   │   ├── jrdf2vec_environment.yml
+│   │   ├── jrdf2vec_requirements.txt
+│   │   ├── pyrdf2vec_environment.yml
+│   │   ├── pyrdf2vec_requirements.txt
+│   │   ├── rdf2vecgpu_environment.yml
+│   │   ├── rdf2vecgpu_requirements.txt
+│   │   ├── sparkrdf2vec_environment.yml
+│   │   └── sparkrdf2vec_requirements.txt
+│   ├── evaluation_parameters.py
+│   ├── gpu_rdf2vec_performance.py
+│   ├── graph_creation.py
+│   ├── graph_statistics.py
+│   ├── jrdf2vec_based_performance.py
+│   ├── pyrdf2vec_based_performance.py
+│   ├── spark_rdf2vec_performance.py
+│   └── wandb_analysis.py
+├── src
+│   ├── __init__.py
+│   ├── corpus
+│   │   ├── __init__.py
+│   │   └── walk_corpus.py
+│   ├── cpu_based_rdf2vec_approach.py
+│   ├── embedders
+│   │   ├── __init__.py
+│   │   ├── word2vec.py
+│   │   └── word2vec_loader.py
+│   ├── gpu_rdf2vec.py
+│   ├── helper
+│   │   ├── __init__.py
+│   │   └── functions.py
+│   └── reader
+│       ├── __init__.py
+│       └── kg_reader.py
+└── test
+    ├── helper
+    └── reader
+        ├── functions_test.py
+        └── kg_reader_test.py
+```
+### Capability overview
+- GPU-backed walk generation over CUDA Kernels
+- Batched Word2Vec training with Pytorch lightning
+- Pluggable rdf loaders and parquet, csv, txt integration
+- Performance comparison can be found in the following [folder](performance/)
+
+## Quick start
+```python
+from src.gpu_rdf2vec import GPU_RDF2Vec
+# Instantiate the gpu RDF2Vec library settings
+gpu_rdf2vec_model = GPU_RDF2Vec(
+    walk_strategy="random",
+    walk_depth=4,
+    walk_number=100,
+    embedding_model="skipgram",
+    epochs=5,
+    batch_size=None,
+    vector_size=100,
+    window_size=5,
+    min_count=1,
+    learning_rate=0.01,
+    negative_samples=5,
+    random_state=42,
+    reproducible=False,
+    multi_gpu=False,
+    generate_artifact=False,
+    cpu_count=20
+)
+# Path to the triple dataset
+path = "data/wikidata5m/wikidata5m_kg.parquet"
+# Load data and receive edge data
+edge_data = gpu_rdf2vec_model.load_data(path)
+# Fit the Word2Vec model and transform the dataset to an embedding
+embeddings = gpu_rdf2vec_model.fit_transform(edge_df=edge_data, walk_vertices=None)
+# Write embedding to file format. Return format is a cuDf dataframe
+embeddings.to_parquet("data/wikidata5m/wikidata5m_embeddings.parquet", index=False)
+```
+- Supported file formats:
+  - .csv
+  - .txt
+  - .parquet
+  - .nt
+  - All supported [RDFlib file formats](https://rdflib.readthedocs.io/en/stable/plugin_parsers.html)
+- gpuRDF2Vec Parameters:
+  - walk_strategy: `[random, bfs]`
+  - walk_depth: `int`
+  - walk_number: `int`
+  - embedding_model: `[skipgram, cbow]`
+  - epochs: `int`
+  - batch_size: `[None | int]` --> If the batch size is None, we guess internally the batch size based on the data loader and the number of CPU counts provided
+  - vector_size
+  - window_size: `int`
+  - min_count: `int`
+  - learning_rate: `float`
+  - negative_samples: `int`
+  - random_state: `int`
+  - reproducible: `bool`
+  - multi_gpu: `bool`
+  - generate_artifact: `bool`
+  - cpu_count: `int`
+## Implementation Details
+
+We achieve order-of-magnitude for large and dense graphs over CPU-bound RDF2Vec by engineering both the **walk extraction** and the **Word2Vec training** pipelines:
+1. **GPU-Native Walk Extraction**  
+   - All random-walk and BFS operations leverage cuDF/cuGraph kernels to avoid CPU–GPU data transfers and minimize latency.  
+   - To generate *k* walks per node in one pass, we replicate node indices in a single cuDF DataFrame rather than looping—fully utilizing GPU parallelism and eliminating Python-loop overhead (∼15× speedup).  
+   - BFS walks currently use GPU-side recursive joins; future work will reconstruct walks entirely in CUDA to remove join overhead.
+
+2. **cuDF→PyTorch Lightning Handoff**  
+   - Replaced Lightning’s default CPU-based DataLoader with a cuDF-backed pipeline: context/center columns live on GPU as DLPack tensors.  
+   - Initial deep-copy loads incur extra VRAM, but thereafter all sampling/preprocessing occurs on-device, eliminating PCIe stalls.  
+   - An “index-only” strategy (workers pull tensor indices instead of slices) uses CUDA’s pointer arithmetic for constant-time access, collapsing DataLoader overhead from ~85% of epoch time to near parity with model compute.
+
+3. **Optimized Word2Vec Training**  
+   - **Batch-Size Heuristic:** Estimate per-sample GPU footprint from cuDF loader, then set initial batch = (total VRAM) / (4 × footprint). This “divide-by-four” rule quickly homes in on a viable batch size, reducing tuning runs.  
+   - **Kernel Fusion:** All sampling and tensor transforms migrated into PyTorch’s C++ back end, removing Python loops and the GIL, for consistent high throughput.  
+
+4. **Scalable Data-Parallel Training**  
+   - We use PyTorch Distributed + NCCL: each GPU holds the same graph shard but a unique walk corpus.  
+   - Gradients are synchronized via `all_reduce` at regular intervals (~500 ms), amortizing PCIe/NVLink costs and ensuring linear scaling across nodes.
+## License
+The overview of the used MIT license can be found [here](LICENSE)
+## Roadmap
+- [ ] Order aware Word2Vec following the details of [Ling, Wang, et al. "Two/too simple adaptations of word2vec for syntax problems.](https://aclanthology.org/N15-1142.pdf). [Issue item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/2)
+- [ ] Provide spilling to single GPU training to work around potential OOM issues faced during rdf2vec training [Issue Item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/3)
+- [ ] Provide weighted walks for spatial datasets [Issue item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/4)
+- [ ] Provide logging capabilities of complete Word2Vec pipeline for [Wandb](https://wandb.ai/site/) and [mlflow](https://mlflow.org/). [Issue item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/5)
+## Report issues and bugs
+In case you have found a bug or unexpected behaviour, please reach out by opening an issue:
+1. When opening an issue, please tag the issue with the label **Bug**. Please include the following information:
+    - **Environment**: OS, Python/CUDA/PyTorch/RAPIDS versions (cuDF, cuGraph)
+    - **Reproduction steps**: Exact commands or small code snippet
+    - **Input data** graph format & size (attach a minimal sample if possible)
+    - **Observed vs. expected behavior**
+    - **Error messages/ stack traces** (copy-paste or attach logs)
+
+2. We aim to respond to open issues within 3 business days
+3. If you have identified a fix, fork the repo, branch off `main`, implement & test then open a PR referencing the issue.

rdf2vecgpu-0.1.0/README.md

@@ -0,0 +1,200 @@
+## gpuRDF2Vec
+A scalable GPU based implementation of RDF2Vec embeddings for large and dense Knowledge Graphs.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+![RDF2VecGPU_Image](img/github_repo_header.png)
+
+> [!IMPORTANT]
+> This package is under active development in the beta phase. The overall class/ method design will most probably change and introduce breaking changes between releases
+
+## Table of contents
+The content of this repository readme can be found here:
+- [gpuRDF2Vec](#gpurdf2vec)
+- [Table of contents](#table-of-contents)
+- [Repository setup](#repository-setup)
+- [gpuRDF2Vec overview](#gpurdf2vec-overview)
+  - [Repository Structure](#repository-structure)
+  - [Capability overview](#capability-overview)
+- [Quick start](#quick-start)
+- [Implementation Details](#implementation-details)
+- [License](#license)
+- [Roadmap](#roadmap)
+- [Report issues and bugs](#report-issues-and-bugs)
+
+
+## Repository setup
+The repository setup builds on top of two major libraries. Both Pytorch lightning as well as the RAPIDS libraries cuDF and cuGraph. We provide the exeplanatory installation details for Cuda 12.6:
+1. Pytorch [installation page](https://pytorch.org/get-started/locally/)
+Cuda 12.6 installation
+```bash
+pip install torch torchvision torchaudio
+```
+2. Detailed cudf installation instruction [here](https://docs.rapids.ai/install/).
+Cudf Cuda 12 install
+```bash
+pip install \
+    --extra-index-url=https://pypi.nvidia.com \
+    "cudf-cu12==25.4.*" "dask-cudf-cu12==25.4.*" \
+    "cugraph-cu12==25.4.*" "nx-cugraph-cu12==25.4.*" \
+    "nx-cugraph-cu12==25.4.*"
+```
+The requirement files and conda environment files can be found here: 
+- [Conda environment](performance/env_files/rdf2vecgpu_environment.yml)
+- [Requirement file](performance/env_files/rdf2vecgpu_requirements.txt)
+## gpuRDF2Vec overview
+RDF2Vec is a powerful technique to generate vector embeddings of entities in RDF graphs via random walks and Word2Vec. This repository provides a GPU-optimized reimplementation, enabling:
+
+- **Speedups** on dense graphs with millions of nodes
+- **Scalability** to industrial-scale knowledge bases
+- **Reproducible experiments** to test and qualify the overall implementation details
+### Repository Structure
+```bash
+.
+├── README.md
+├── data
+├── data_preparation
+│   ├── converstion_to_ttl.py
+│   └── merge_text_file.py
+├── img
+│   └── github_repo_header.png
+├── jrdf2vec-1.3-SNAPSHOT.jar
+├── performance
+│   ├── env_files
+│   │   ├── jrdf2vec_environment.yml
+│   │   ├── jrdf2vec_requirements.txt
+│   │   ├── pyrdf2vec_environment.yml
+│   │   ├── pyrdf2vec_requirements.txt
+│   │   ├── rdf2vecgpu_environment.yml
+│   │   ├── rdf2vecgpu_requirements.txt
+│   │   ├── sparkrdf2vec_environment.yml
+│   │   └── sparkrdf2vec_requirements.txt
+│   ├── evaluation_parameters.py
+│   ├── gpu_rdf2vec_performance.py
+│   ├── graph_creation.py
+│   ├── graph_statistics.py
+│   ├── jrdf2vec_based_performance.py
+│   ├── pyrdf2vec_based_performance.py
+│   ├── spark_rdf2vec_performance.py
+│   └── wandb_analysis.py
+├── src
+│   ├── __init__.py
+│   ├── corpus
+│   │   ├── __init__.py
+│   │   └── walk_corpus.py
+│   ├── cpu_based_rdf2vec_approach.py
+│   ├── embedders
+│   │   ├── __init__.py
+│   │   ├── word2vec.py
+│   │   └── word2vec_loader.py
+│   ├── gpu_rdf2vec.py
+│   ├── helper
+│   │   ├── __init__.py
+│   │   └── functions.py
+│   └── reader
+│       ├── __init__.py
+│       └── kg_reader.py
+└── test
+    ├── helper
+    └── reader
+        ├── functions_test.py
+        └── kg_reader_test.py
+```
+### Capability overview
+- GPU-backed walk generation over CUDA Kernels
+- Batched Word2Vec training with Pytorch lightning
+- Pluggable rdf loaders and parquet, csv, txt integration
+- Performance comparison can be found in the following [folder](performance/)
+
+## Quick start
+```python
+from src.gpu_rdf2vec import GPU_RDF2Vec
+# Instantiate the gpu RDF2Vec library settings
+gpu_rdf2vec_model = GPU_RDF2Vec(
+    walk_strategy="random",
+    walk_depth=4,
+    walk_number=100,
+    embedding_model="skipgram",
+    epochs=5,
+    batch_size=None,
+    vector_size=100,
+    window_size=5,
+    min_count=1,
+    learning_rate=0.01,
+    negative_samples=5,
+    random_state=42,
+    reproducible=False,
+    multi_gpu=False,
+    generate_artifact=False,
+    cpu_count=20
+)
+# Path to the triple dataset
+path = "data/wikidata5m/wikidata5m_kg.parquet"
+# Load data and receive edge data
+edge_data = gpu_rdf2vec_model.load_data(path)
+# Fit the Word2Vec model and transform the dataset to an embedding
+embeddings = gpu_rdf2vec_model.fit_transform(edge_df=edge_data, walk_vertices=None)
+# Write embedding to file format. Return format is a cuDf dataframe
+embeddings.to_parquet("data/wikidata5m/wikidata5m_embeddings.parquet", index=False)
+```
+- Supported file formats:
+  - .csv
+  - .txt
+  - .parquet
+  - .nt
+  - All supported [RDFlib file formats](https://rdflib.readthedocs.io/en/stable/plugin_parsers.html)
+- gpuRDF2Vec Parameters:
+  - walk_strategy: `[random, bfs]`
+  - walk_depth: `int`
+  - walk_number: `int`
+  - embedding_model: `[skipgram, cbow]`
+  - epochs: `int`
+  - batch_size: `[None | int]` --> If the batch size is None, we guess internally the batch size based on the data loader and the number of CPU counts provided
+  - vector_size
+  - window_size: `int`
+  - min_count: `int`
+  - learning_rate: `float`
+  - negative_samples: `int`
+  - random_state: `int`
+  - reproducible: `bool`
+  - multi_gpu: `bool`
+  - generate_artifact: `bool`
+  - cpu_count: `int`
+## Implementation Details
+
+We achieve order-of-magnitude for large and dense graphs over CPU-bound RDF2Vec by engineering both the **walk extraction** and the **Word2Vec training** pipelines:
+1. **GPU-Native Walk Extraction**  
+   - All random-walk and BFS operations leverage cuDF/cuGraph kernels to avoid CPU–GPU data transfers and minimize latency.  
+   - To generate *k* walks per node in one pass, we replicate node indices in a single cuDF DataFrame rather than looping—fully utilizing GPU parallelism and eliminating Python-loop overhead (∼15× speedup).  
+   - BFS walks currently use GPU-side recursive joins; future work will reconstruct walks entirely in CUDA to remove join overhead.
+
+2. **cuDF→PyTorch Lightning Handoff**  
+   - Replaced Lightning’s default CPU-based DataLoader with a cuDF-backed pipeline: context/center columns live on GPU as DLPack tensors.  
+   - Initial deep-copy loads incur extra VRAM, but thereafter all sampling/preprocessing occurs on-device, eliminating PCIe stalls.  
+   - An “index-only” strategy (workers pull tensor indices instead of slices) uses CUDA’s pointer arithmetic for constant-time access, collapsing DataLoader overhead from ~85% of epoch time to near parity with model compute.
+
+3. **Optimized Word2Vec Training**  
+   - **Batch-Size Heuristic:** Estimate per-sample GPU footprint from cuDF loader, then set initial batch = (total VRAM) / (4 × footprint). This “divide-by-four” rule quickly homes in on a viable batch size, reducing tuning runs.  
+   - **Kernel Fusion:** All sampling and tensor transforms migrated into PyTorch’s C++ back end, removing Python loops and the GIL, for consistent high throughput.  
+
+4. **Scalable Data-Parallel Training**  
+   - We use PyTorch Distributed + NCCL: each GPU holds the same graph shard but a unique walk corpus.  
+   - Gradients are synchronized via `all_reduce` at regular intervals (~500 ms), amortizing PCIe/NVLink costs and ensuring linear scaling across nodes.
+## License
+The overview of the used MIT license can be found [here](LICENSE)
+## Roadmap
+- [ ] Order aware Word2Vec following the details of [Ling, Wang, et al. "Two/too simple adaptations of word2vec for syntax problems.](https://aclanthology.org/N15-1142.pdf). [Issue item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/2)
+- [ ] Provide spilling to single GPU training to work around potential OOM issues faced during rdf2vec training [Issue Item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/3)
+- [ ] Provide weighted walks for spatial datasets [Issue item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/4)
+- [ ] Provide logging capabilities of complete Word2Vec pipeline for [Wandb](https://wandb.ai/site/) and [mlflow](https://mlflow.org/). [Issue item](https://github.com/MartinBoeckling/rdf2vecgpu/issues/5)
+## Report issues and bugs
+In case you have found a bug or unexpected behaviour, please reach out by opening an issue:
+1. When opening an issue, please tag the issue with the label **Bug**. Please include the following information:
+    - **Environment**: OS, Python/CUDA/PyTorch/RAPIDS versions (cuDF, cuGraph)
+    - **Reproduction steps**: Exact commands or small code snippet
+    - **Input data** graph format & size (attach a minimal sample if possible)
+    - **Observed vs. expected behavior**
+    - **Error messages/ stack traces** (copy-paste or attach logs)
+
+2. We aim to respond to open issues within 3 business days
+3. If you have identified a fix, fork the repo, branch off `main`, implement & test then open a PR referencing the issue.

rdf2vecgpu-0.1.0/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.0"
+
+__all__ = [
+    "GPU_RDF2Vec"
+]