| Name | pylibcugraphops-cu11 JSON |
| Version |
24.12.0
JSON |
| download |
| home_page | None |
| Summary | pylibcugraphops - GPU Graph Neural Network operations |
| upload_time | 2024-12-12 16:54:55 |
| maintainer | None |
| docs_url | None |
| author | NVIDIA Corporation |
| requires_python | >=3.10 |
| license | Apache 2.0 |
| keywords |
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# pylibcugraphops
**pylibcugraphops** is a wrapper around **cugraph-ops** and provides framework-agnostic and lightweight Python-bindings for the custom graph operators of cugraph-ops. For more information on the implemented functionality, check the corresponding documentations.
## Structure
In terms of structure, the bindings somewhat follow the guidelines of cugraph-ops. The main difference is that pylibcugraphops is more focused on providing reasonable submodules and thus the overall structure is rather flat. The core functionality is placed under `pylibcugraphops.operators` similar to the C++ API with the `<cugraph-ops/operators>` namespace. This includes basic aggregation operators (e.g. for GraphSAGE), specialized operators (e.g. for RGCN), and operators performing pooling-like operations (e.g. readout operations aggregating from a graph-to-scalar level). While the C++ API has a further distinction into operators for message flow graphs and other kinds of graphs which can be represented through CSC, the `pylibcugraphops.operators` is kept as a flat submodule with the function names making the disctiontion.
## Naming Convention
The name of exposed operators and corresponding files should be self-explanatory to provide an easy overview of all relevant charateristics. Therefore, we adopt the following naming convention for operators.
`<operator family>_<graph type>_<"direction">_(<operator specification>_)<[fwd|bwd|bwd_rev|...]`
Examples
- `agg_simple_csc_bwd`
- `pool_csc_n2s_bwd`
- `agg_hg_basis_mfg_n2n_post_bwd`
Support for different datatypes is achieved through overloading and thus usually not explicitly part of operator names.
### Explanation of Individual Parts
- `<operator family>` denotes the underlying operator, we currently have
- `agg_simple`: basic aggregator performing a mean/sum/min/max reduction of the specified set
- `agg_concat`: like `agg_simple` but additionally concatenates the self representation of each set member
- `agg_dmpnn`: implmements the DMPNN edge-to-edge aggregation
- `pool`: sum/mean/min/max pooling, e.g. node-to-scalar readout
- `hg_basis`: heterogenous aggregation using different edge types and potentially using a basis decomposition
- `mha_gat`: multi-headed attention aggregation, in this case GAT as specific variant
- `<graph type>` which graph type the operator is intended for
- `csc`: simple csc representation of a graph
- `bipartite`: simple csc representation of a bipartite graph
- `mfg`: message flow graph
- `<"direction">`: for easier overview of which operators we already have, multiple directions are combined and separated through underscores (e.g. `e2n_n2n`)
- `n2n`: node-to-node (basic aggregation)
- `e2n`: edge-to-node
- `e2e`: edge-to-edge
- `n2s`: node-to-scalar
- `<operator specification>`: some operators define different kinds of "flavors", e.g. the "pre" and the "post" variant of the `hg_basis` operators
## Function Signatures
The following pattern should be used
```
func(output_vector_arg_0, ..., output_vector_arg_n,
input_vector_arg_0, ..., input_vector_arg_n,
graph_structure_arg_0, ..., graph_structure_arg_n,
*args,
**kwargs,
cuda_stream=None)
```
- `*args`: arguments necessary for `func` but neither a buffer nor a graph structure
- `**kwargs`: optional arguments or arguments with default values
- `cuda_stream` should be the last argument in a binding if applicable and defaulted to the null stream
Example for RGCN (hg_basis_pre):
```python
def agg_hg_basis_mfg_n2n_pre_bwd(output_gradient,
input_gradient,
input_embedding,
message_flow_graph_hg_csc_int32 graph,
output_weight_gradient=None,
weights_combination=None,
concat_own=False,
norm_by_degree=False,
cuda_stream=None):
```
Raw data
{
"_id": null,
"home_page": null,
"name": "pylibcugraphops-cu11",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": null,
"author": "NVIDIA Corporation",
"author_email": null,
"download_url": "https://files.pythonhosted.org/packages/22/38/2f623f13f1f5fddd1335120213ed2ad6947aaf2d70a9c3746c3003b6b3c0/pylibcugraphops_cu11-24.12.0.tar.gz",
"platform": null,
"description": "# pylibcugraphops\n\n**pylibcugraphops** is a wrapper around **cugraph-ops** and provides framework-agnostic and lightweight Python-bindings for the custom graph operators of cugraph-ops. For more information on the implemented functionality, check the corresponding documentations.\n\n## Structure\nIn terms of structure, the bindings somewhat follow the guidelines of cugraph-ops. The main difference is that pylibcugraphops is more focused on providing reasonable submodules and thus the overall structure is rather flat. The core functionality is placed under `pylibcugraphops.operators` similar to the C++ API with the `<cugraph-ops/operators>` namespace. This includes basic aggregation operators (e.g. for GraphSAGE), specialized operators (e.g. for RGCN), and operators performing pooling-like operations (e.g. readout operations aggregating from a graph-to-scalar level). While the C++ API has a further distinction into operators for message flow graphs and other kinds of graphs which can be represented through CSC, the `pylibcugraphops.operators` is kept as a flat submodule with the function names making the disctiontion.\n\n## Naming Convention\nThe name of exposed operators and corresponding files should be self-explanatory to provide an easy overview of all relevant charateristics. Therefore, we adopt the following naming convention for operators.\n\n`<operator family>_<graph type>_<\"direction\">_(<operator specification>_)<[fwd|bwd|bwd_rev|...]`\n\nExamples\n- `agg_simple_csc_bwd`\n- `pool_csc_n2s_bwd`\n- `agg_hg_basis_mfg_n2n_post_bwd`\n\nSupport for different datatypes is achieved through overloading and thus usually not explicitly part of operator names.\n\n### Explanation of Individual Parts\n\n- `<operator family>` denotes the underlying operator, we currently have\n - `agg_simple`: basic aggregator performing a mean/sum/min/max reduction of the specified set\n - `agg_concat`: like `agg_simple` but additionally concatenates the self representation of each set member\n - `agg_dmpnn`: implmements the DMPNN edge-to-edge aggregation\n - `pool`: sum/mean/min/max pooling, e.g. node-to-scalar readout\n - `hg_basis`: heterogenous aggregation using different edge types and potentially using a basis decomposition\n - `mha_gat`: multi-headed attention aggregation, in this case GAT as specific variant\n- `<graph type>` which graph type the operator is intended for\n - `csc`: simple csc representation of a graph\n - `bipartite`: simple csc representation of a bipartite graph\n - `mfg`: message flow graph\n- `<\"direction\">`: for easier overview of which operators we already have, multiple directions are combined and separated through underscores (e.g. `e2n_n2n`)\n - `n2n`: node-to-node (basic aggregation)\n - `e2n`: edge-to-node\n - `e2e`: edge-to-edge\n - `n2s`: node-to-scalar\n- `<operator specification>`: some operators define different kinds of \"flavors\", e.g. the \"pre\" and the \"post\" variant of the `hg_basis` operators\n\n\n## Function Signatures\n\nThe following pattern should be used\n```\nfunc(output_vector_arg_0, ..., output_vector_arg_n,\n input_vector_arg_0, ..., input_vector_arg_n,\n graph_structure_arg_0, ..., graph_structure_arg_n,\n *args,\n **kwargs,\n cuda_stream=None)\n```\n- `*args`: arguments necessary for `func` but neither a buffer nor a graph structure\n- `**kwargs`: optional arguments or arguments with default values\n- `cuda_stream` should be the last argument in a binding if applicable and defaulted to the null stream\n\nExample for RGCN (hg_basis_pre):\n```python\ndef agg_hg_basis_mfg_n2n_pre_bwd(output_gradient,\n input_gradient,\n input_embedding,\n message_flow_graph_hg_csc_int32 graph,\n output_weight_gradient=None,\n weights_combination=None,\n concat_own=False,\n norm_by_degree=False,\n cuda_stream=None):\n```\n",
"bugtrack_url": null,
"license": "Apache 2.0",
"summary": "pylibcugraphops - GPU Graph Neural Network operations",
"version": "24.12.0",
"project_urls": {
"Documentation": "https://docs.rapids.ai/api/cugraph/stable/api_docs/cugraph-ops/",
"Homepage": "https://github.com/rapidsai/cugraph-ops"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "22382f623f13f1f5fddd1335120213ed2ad6947aaf2d70a9c3746c3003b6b3c0",
"md5": "69956e1d9a32a6d41e7db45cd82c81e9",
"sha256": "e02f096d381b367bb0fdc1234fda6eb4bbb7c036e2e088db3e71ab9537e9d72e"
},
"downloads": -1,
"filename": "pylibcugraphops_cu11-24.12.0.tar.gz",
"has_sig": false,
"md5_digest": "69956e1d9a32a6d41e7db45cd82c81e9",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 2406,
"upload_time": "2024-12-12T16:54:55",
"upload_time_iso_8601": "2024-12-12T16:54:55.065146Z",
"url": "https://files.pythonhosted.org/packages/22/38/2f623f13f1f5fddd1335120213ed2ad6947aaf2d70a9c3746c3003b6b3c0/pylibcugraphops_cu11-24.12.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-12-12 16:54:55",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "rapidsai",
"github_project": "cugraph-ops",
"github_not_found": true,
"lcname": "pylibcugraphops-cu11"
}
