| Name | torchCompactRadius JSON |
| Version |
0.2.1
JSON |
| download |
| home_page | None |
| Summary | Compact Hashing based radius search for pyTorch using C++/CUDA backends. |
| upload_time | 2024-08-20 09:16:03 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.10 |
| license | MIT License Copyright (c) 2024 Rene Winchenbach 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. |
| keywords |
sph
radius
pytorch
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# pyTorch Compact Radius
This repository contains an implementation of a compact hashing based neighborhood search for 1D, 2D and 3D data for pyTorch using a C++/CUDA backend.
Requirements:
> pyTorch >= 2.0
numpy (not used in the computations)
subprocess (for compilation)
The module is built just-in-time on first import in a given python environment and this build process may take a few (<5) minutes. Note that for MacOS based systems an external clang compiler installed via homebrew is required for openMP support.
## Usage
This package provices two primary functions `radius` and `radiusSearch`. `radius` is designed as a drop-in replacement of torch cluster's radius function, whereas radiusSearch is the preferred usage. __Important:__ `radius` and `radiusSearch` return index pairs in flipped order!
The `radiusSearch` method is defined as follows (`radius` adds an additional `batch_x` and `batch_y` argument after support for compatibility)
```py
def radiusSearch(
queryPositions : torch.Tensor,
referencePositions : Optional[torch.Tensor],
support : Union[float, torch.Tensor,Tuple[torch.Tensor, torch.Tensor]],
mode : str = 'gather',
domainMin : Optional[torch.Tensor] = None,
domainMax : Optional[torch.Tensor] = None,
periodicity : Optional[Union[bool, List[bool]]] = None,
hashMapLength = 4096,
algorithm: str = 'naive',
verbose: bool = False,
returnStructure : bool = False
)
```
- `queryPositions` is an $n_x xd$ Tensor that contains the set of points that are related to the other set
- `referencePositions` is an $n_y xd$ Tensor that contains the reference set of points, i.e., the points for which relations are queried
- `support` determines the cut-off radius for the radius search. This value is either a scalar float, i.e., every point has an identical cut-off radius, a single Tensor of size $n$ that contains a different cut-off radius for every point in `queryPositions` or a tuple of Tensors, one for each point set.
- `mode` determines the method used to compute the cut-off radius of point to point interactions. Options are (a) `gather`, which uses only the cut-off radius for the `queryPositions`, (b) `scatter`, which uses only the cut-off radius for the `referencePositions` and (c) `symmetric`, which uses the mean cut-off radius.
- `domainMin` and `domainMax` are required for periodic neighborhood searches to define the coordinates at which point the positions wrap around
- `periodicity` indicates if a periodic neighborhood search is to be performed as either a bool (applied to all dimensions) or a list of bools (one per dimension)
- `hashMapLength` is used to determine the internal length of the hash map used in the compact data structure, should be close to $n_x$
- `verbose` prints additional logging information on the console
- `returnStructure` decides if the `compact` algorithm should return its datastructure for reuse in later searches
For the algorithm the following 4 options exist:
- `naive`: This algorithm computes a dense distance matrix of size $n_x \times n_y \times d$ and performs the adjacency computations on this dense representation. This requires significant amounts of memory but is very straight forward and potentially differentiable. Complexity: $\mathcal{O}\left(n^2\right)$
- `cluster`: This is a wrapper around torch_cluster's `radius` search and only available if that package is installed. Note that this algorithm does not support periodic neighbor searches and does not support non-uniform cut-off radii with a complexity of $\mathcal{O}\left(n^2\right)$. This algorithm is also limited to a fixed number of maximum neighbors ($256$).
- `small`: This algorithm is similar to `cluster` in its implementation and computes an everything against everything distance on-the-fly, i.e., it does not require intermediate large storage, and first computes the number of neighbors per particle and then allocates the according memory. Accordingly, this approach is slower than `cluster` but more versatile. Complexity: $\mathcal{O}\left(n^2\right)$
- `compact`: The primary algorithm of this library. This approach uses compact hashing and a cell-based datastructure to compute neighborhoods in $\mathcal{O}\left(n\log n\right)$. The idea is based on [A parallel sph implementation on multi-core cpus](https://cg.informatik.uni-freiburg.de/publications/2011_CGF_dataStructuresSPH.pdf) and the GPU approach is based on [Multi-Level Memory Structures for Simulating and Rendering SPH](https://onlinelibrary.wiley.com/doi/full/10.1111/cgf.14090). Note that this implementation is not optimized for adaptive simulations.
## Example: [Open in Google Colab](https://colab.research.google.com/drive/1vKJV_8iPoMRXNRymCX0h1E72M_wRAwWU?usp=sharing)
For this example we generate two separate point clouds $X\in[-1,1]^3$ and $y\in[-0.5,0.5]^3$ with a point spacing of $\Delta x = \frac{2}{32}$. This results in $32^3 = 32768$ points for set $X$ and $16^3 = 4096$ points for set $Y$. We then perform a neighbor search with a cutoff radius of $h_x$ such that points in $x$ would have $50$ neighbors on average (computed using `volumeToSupport`) and $h_y$ with twice the search radius. For the neighbor computation we then utilize the mean point spacing $h_{ij} = \frac{h_i + h_j}{2}$, resulting in $171$ neighbors per particle in $Y$:
```py
from torchCompactRadius import radiusSearch, volumeToSupport
from torchCompactRadius.util import countUniqueEntries
import torch
import platform
# Paramaters for data generation
dim = 3
periodic = True
nx = 32
targetNumNeighbors = 50
# Choose accelerator
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if platform.system() == 'Darwin':
device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu')
# bounds for data
minDomain = torch.tensor([-1] * dim, dtype = torch.float32, device = device)
maxDomain = torch.tensor([ 1] * dim, dtype = torch.float32, device = device)
periodicity = [periodic] * dim
extent = maxDomain - minDomain
shortExtent = torch.min(extent, dim = 0)[0].item()
dx = (shortExtent / nx)
h = volumeToSupport(dx**dim, targetNumNeighbors, dim)
dy = dx
# generate particle set x
positions = [torch.linspace(minDomain[d] + dx / 2, maxDomain[d] - dx / 2, int((extent[d] - dx) / dx) + 1, device = device) for d in range(dim)]
x = torch.stack(torch.meshgrid(*positions, indexing = 'xy'), dim = -1).reshape(-1,dim).to(device)
xSupport = torch.ones(x.shape[0], device = device) * h
# generate particle set y
ypositions = [torch.linspace(-0.5 + dx / 2, 0.5 - dx / 2, int(1 // dx), device = device) for d in range(dim)]
y = torch.stack(torch.meshgrid(*ypositions, indexing = 'xy'), dim = -1).reshape(-1,dim).to(device)
ySupport = torch.ones(y.shape[0], device = device) * h * 2
i, j = radiusSearch(x, y, (xSupport, ySupport), algorithm = 'compact', periodicity = periodic, domainMin = minDomain, domainMax = maxDomain, mode = 'symmetric')
ii, ni = countUniqueEntries(i, x)
jj, nj = countUniqueEntries(j, y)
print('i:', i.shape, i.device, i.dtype)
print('ni:', ni.shape, ni.device, ni.dtype, ni)
print('j:', j.shape, j.device, j.dtype)
print('nj:', nj.shape, nj.device, nj.dtype, nj)
```
This should output:
> i: torch.Size([700416]) cuda:0 torch.int64
ni: torch.Size([32768]) cuda:0 torch.int64 tensor([0, 0, 0, ..., 0, 0, 0], device='cuda:0')
j: torch.Size([700416]) cuda:0 torch.int64
nj: torch.Size([4096]) cuda:0 torch.int64 tensor([171, 171, 171, ..., 171, 171, 171], device='cuda:0')
## Performance
If you want to evaluate the performance on your system simply run `scripts/benchmark.py`, which will generate a `Benchmark.png` for various numbers of point counts algorithms and dimensions.
Compute Performance on GPUs for small scale problems:
3090 | A5000
---|---
<img src="https://github.com/wi-re/torchCompactRadius/blob/main/figures/Benchmark_3090.png?raw=true">| <img src="https://github.com/wi-re/torchCompactRadius/blob/main/figures/Benchmark_A5000.png?raw=true">
CPU perforamnce:
<img src="https://github.com/wi-re/torchCompactRadius/blob/main/figures/Benchmark_CPU.png?raw=true">
Overall GPU based performance for larger scale problems:
<img src="https://github.com/wi-re/torchCompactRadius/blob/main/figures/Overall.png?raw=true">
## Testing
If you want to check if your version of this library works correctly simply run `python scripts/test.py`. This simple test function runs a variety of configurations and the output will appear like this:
```
periodic = True, reducedSet = True, algorithm = naive device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = True, reducedSet = True, algorithm = small device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = True, reducedSet = True, algorithm = cluster device = cpu ❌❌❌❌❌❌ device = cuda ❌❌❌❌❌❌
periodic = True, reducedSet = True, algorithm = compact device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = True, reducedSet = False, algorithm = naive device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = True, reducedSet = False, algorithm = small device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = True, reducedSet = False, algorithm = cluster device = cpu ❌❌❌❌❌❌ device = cuda ❌❌❌❌❌❌
periodic = True, reducedSet = False, algorithm = compact device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = False, reducedSet = True, algorithm = naive device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = False, reducedSet = True, algorithm = small device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = False, reducedSet = True, algorithm = cluster device = cpu ✅❌❌❌❌❌ device = cuda ✅❌❌❌❌❌
periodic = False, reducedSet = True, algorithm = compact device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = False, reducedSet = False, algorithm = naive device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = False, reducedSet = False, algorithm = small device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
periodic = False, reducedSet = False, algorithm = cluster device = cpu ✅❌❌❌❌❌ device = cuda ✅❌❌❌❌❌
periodic = False, reducedSet = False, algorithm = compact device = cpu ✅✅✅✅✅✅ device = cuda ✅✅✅✅✅✅
```
The `cluster` algorithm failing is due to a lack of support of torch_cluster`s implementation for periodic neighborhood searches as well as searches with non-uniform cut-off radii.
## TODO:
> Add AMD Support
Wrap periodic neighborhood search and non symmetric neighborhoods around torch cluster
Add automatic choice of algorithm based on performance
Add binary distributions
Raw data
{
"_id": null,
"home_page": null,
"name": "torchCompactRadius",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": "Rene Winchenbach <contact@fluids.dev>",
"keywords": "sph, radius, pytorch",
"author": null,
"author_email": "Rene Winchenbach <contact@fluids.dev>",
"download_url": "https://files.pythonhosted.org/packages/d0/62/cc931ba6cea1c855cebe45ee1610551aa34cf356f9d335ebc0bfa58e6d65/torchcompactradius-0.2.1.tar.gz",
"platform": null,
"description": "# pyTorch Compact Radius\n\nThis repository contains an implementation of a compact hashing based neighborhood search for 1D, 2D and 3D data for pyTorch using a C++/CUDA backend. \n\nRequirements:\n> pyTorch >= 2.0\nnumpy (not used in the computations)\nsubprocess (for compilation)\n\nThe module is built just-in-time on first import in a given python environment and this build process may take a few (<5) minutes. Note that for MacOS based systems an external clang compiler installed via homebrew is required for openMP support.\n\n\n## Usage\n\nThis package provices two primary functions `radius` and `radiusSearch`. `radius` is designed as a drop-in replacement of torch cluster's radius function, whereas radiusSearch is the preferred usage. __Important:__ `radius` and `radiusSearch` return index pairs in flipped order!\n\nThe `radiusSearch` method is defined as follows (`radius` adds an additional `batch_x` and `batch_y` argument after support for compatibility)\n```py\ndef radiusSearch( \n queryPositions : torch.Tensor,\n referencePositions : Optional[torch.Tensor],\n support : Union[float, torch.Tensor,Tuple[torch.Tensor, torch.Tensor]],\n mode : str = 'gather',\n domainMin : Optional[torch.Tensor] = None,\n domainMax : Optional[torch.Tensor] = None,\n periodicity : Optional[Union[bool, List[bool]]] = None,\n hashMapLength = 4096,\n algorithm: str = 'naive',\n verbose: bool = False,\n returnStructure : bool = False\n )\n```\n\n- `queryPositions` is an $n_x xd$ Tensor that contains the set of points that are related to the other set\n- `referencePositions` is an $n_y xd$ Tensor that contains the reference set of points, i.e., the points for which relations are queried\n- `support` determines the cut-off radius for the radius search. This value is either a scalar float, i.e., every point has an identical cut-off radius, a single Tensor of size $n$ that contains a different cut-off radius for every point in `queryPositions` or a tuple of Tensors, one for each point set.\n- `mode` determines the method used to compute the cut-off radius of point to point interactions. Options are (a) `gather`, which uses only the cut-off radius for the `queryPositions`, (b) `scatter`, which uses only the cut-off radius for the `referencePositions` and (c) `symmetric`, which uses the mean cut-off radius.\n- `domainMin` and `domainMax` are required for periodic neighborhood searches to define the coordinates at which point the positions wrap around\n- `periodicity` indicates if a periodic neighborhood search is to be performed as either a bool (applied to all dimensions) or a list of bools (one per dimension)\n- `hashMapLength` is used to determine the internal length of the hash map used in the compact data structure, should be close to $n_x$\n- `verbose` prints additional logging information on the console\n- `returnStructure` decides if the `compact` algorithm should return its datastructure for reuse in later searches\n\nFor the algorithm the following 4 options exist:\n- `naive`: This algorithm computes a dense distance matrix of size $n_x \\times n_y \\times d$ and performs the adjacency computations on this dense representation. This requires significant amounts of memory but is very straight forward and potentially differentiable. Complexity: $\\mathcal{O}\\left(n^2\\right)$\n- `cluster`: This is a wrapper around torch_cluster's `radius` search and only available if that package is installed. Note that this algorithm does not support periodic neighbor searches and does not support non-uniform cut-off radii with a complexity of $\\mathcal{O}\\left(n^2\\right)$. This algorithm is also limited to a fixed number of maximum neighbors ($256$).\n- `small`: This algorithm is similar to `cluster` in its implementation and computes an everything against everything distance on-the-fly, i.e., it does not require intermediate large storage, and first computes the number of neighbors per particle and then allocates the according memory. Accordingly, this approach is slower than `cluster` but more versatile. Complexity: $\\mathcal{O}\\left(n^2\\right)$\n- `compact`: The primary algorithm of this library. This approach uses compact hashing and a cell-based datastructure to compute neighborhoods in $\\mathcal{O}\\left(n\\log n\\right)$. The idea is based on [A parallel sph implementation on multi-core cpus](https://cg.informatik.uni-freiburg.de/publications/2011_CGF_dataStructuresSPH.pdf) and the GPU approach is based on [Multi-Level Memory Structures for Simulating and Rendering SPH](https://onlinelibrary.wiley.com/doi/full/10.1111/cgf.14090). Note that this implementation is not optimized for adaptive simulations.\n\n\n## Example: [Open in Google Colab](https://colab.research.google.com/drive/1vKJV_8iPoMRXNRymCX0h1E72M_wRAwWU?usp=sharing)\n\nFor this example we generate two separate point clouds $X\\in[-1,1]^3$ and $y\\in[-0.5,0.5]^3$ with a point spacing of $\\Delta x = \\frac{2}{32}$. This results in $32^3 = 32768$ points for set $X$ and $16^3 = 4096$ points for set $Y$. We then perform a neighbor search with a cutoff radius of $h_x$ such that points in $x$ would have $50$ neighbors on average (computed using `volumeToSupport`) and $h_y$ with twice the search radius. For the neighbor computation we then utilize the mean point spacing $h_{ij} = \\frac{h_i + h_j}{2}$, resulting in $171$ neighbors per particle in $Y$:\n\n```py\nfrom torchCompactRadius import radiusSearch, volumeToSupport\nfrom torchCompactRadius.util import countUniqueEntries\nimport torch\nimport platform\n# Paramaters for data generation\ndim = 3\nperiodic = True\nnx = 32\ntargetNumNeighbors = 50\n# Choose accelerator\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\nif platform.system() == 'Darwin':\n device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu')\n# bounds for data\nminDomain = torch.tensor([-1] * dim, dtype = torch.float32, device = device)\nmaxDomain = torch.tensor([ 1] * dim, dtype = torch.float32, device = device)\nperiodicity = [periodic] * dim\nextent = maxDomain - minDomain\nshortExtent = torch.min(extent, dim = 0)[0].item()\ndx = (shortExtent / nx)\nh = volumeToSupport(dx**dim, targetNumNeighbors, dim)\ndy = dx\n# generate particle set x\npositions = [torch.linspace(minDomain[d] + dx / 2, maxDomain[d] - dx / 2, int((extent[d] - dx) / dx) + 1, device = device) for d in range(dim)]\nx = torch.stack(torch.meshgrid(*positions, indexing = 'xy'), dim = -1).reshape(-1,dim).to(device)\nxSupport = torch.ones(x.shape[0], device = device) * h\n# generate particle set y\nypositions = [torch.linspace(-0.5 + dx / 2, 0.5 - dx / 2, int(1 // dx), device = device) for d in range(dim)]\ny = torch.stack(torch.meshgrid(*ypositions, indexing = 'xy'), dim = -1).reshape(-1,dim).to(device)\nySupport = torch.ones(y.shape[0], device = device) * h * 2\n\ni, j = radiusSearch(x, y, (xSupport, ySupport), algorithm = 'compact', periodicity = periodic, domainMin = minDomain, domainMax = maxDomain, mode = 'symmetric')\nii, ni = countUniqueEntries(i, x)\njj, nj = countUniqueEntries(j, y)\n\nprint('i:', i.shape, i.device, i.dtype)\nprint('ni:', ni.shape, ni.device, ni.dtype, ni)\nprint('j:', j.shape, j.device, j.dtype)\nprint('nj:', nj.shape, nj.device, nj.dtype, nj)\n```\n\nThis should output:\n> i: torch.Size([700416]) cuda:0 torch.int64\nni: torch.Size([32768]) cuda:0 torch.int64 tensor([0, 0, 0, ..., 0, 0, 0], device='cuda:0')\nj: torch.Size([700416]) cuda:0 torch.int64\nnj: torch.Size([4096]) cuda:0 torch.int64 tensor([171, 171, 171, ..., 171, 171, 171], device='cuda:0')\n\n\n\n## Performance\n\nIf you want to evaluate the performance on your system simply run `scripts/benchmark.py`, which will generate a `Benchmark.png` for various numbers of point counts algorithms and dimensions.\n\nCompute Performance on GPUs for small scale problems:\n\n3090 | A5000\n---|---\n<img src=\"https://github.com/wi-re/torchCompactRadius/blob/main/figures/Benchmark_3090.png?raw=true\">| <img src=\"https://github.com/wi-re/torchCompactRadius/blob/main/figures/Benchmark_A5000.png?raw=true\">\n\nCPU perforamnce:\n\n<img src=\"https://github.com/wi-re/torchCompactRadius/blob/main/figures/Benchmark_CPU.png?raw=true\">\n\nOverall GPU based performance for larger scale problems:\n\n<img src=\"https://github.com/wi-re/torchCompactRadius/blob/main/figures/Overall.png?raw=true\">\n\n## Testing\n\nIf you want to check if your version of this library works correctly simply run `python scripts/test.py`. This simple test function runs a variety of configurations and the output will appear like this:\n```\nperiodic = True, reducedSet = True, algorithm = naive device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = True, reducedSet = True, algorithm = small device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = True, reducedSet = True, algorithm = cluster device = cpu \u274c\u274c\u274c\u274c\u274c\u274c device = cuda \u274c\u274c\u274c\u274c\u274c\u274c\nperiodic = True, reducedSet = True, algorithm = compact device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = True, reducedSet = False, algorithm = naive device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = True, reducedSet = False, algorithm = small device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = True, reducedSet = False, algorithm = cluster device = cpu \u274c\u274c\u274c\u274c\u274c\u274c device = cuda \u274c\u274c\u274c\u274c\u274c\u274c\nperiodic = True, reducedSet = False, algorithm = compact device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = False, reducedSet = True, algorithm = naive device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = False, reducedSet = True, algorithm = small device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = False, reducedSet = True, algorithm = cluster device = cpu \u2705\u274c\u274c\u274c\u274c\u274c device = cuda \u2705\u274c\u274c\u274c\u274c\u274c\nperiodic = False, reducedSet = True, algorithm = compact device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = False, reducedSet = False, algorithm = naive device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = False, reducedSet = False, algorithm = small device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\nperiodic = False, reducedSet = False, algorithm = cluster device = cpu \u2705\u274c\u274c\u274c\u274c\u274c device = cuda \u2705\u274c\u274c\u274c\u274c\u274c\nperiodic = False, reducedSet = False, algorithm = compact device = cpu \u2705\u2705\u2705\u2705\u2705\u2705 device = cuda \u2705\u2705\u2705\u2705\u2705\u2705\n```\n\nThe `cluster` algorithm failing is due to a lack of support of torch_cluster`s implementation for periodic neighborhood searches as well as searches with non-uniform cut-off radii.\n\n## TODO:\n\n> Add AMD Support\nWrap periodic neighborhood search and non symmetric neighborhoods around torch cluster\nAdd automatic choice of algorithm based on performance\nAdd binary distributions\n",
"bugtrack_url": null,
"license": "MIT License Copyright (c) 2024 Rene Winchenbach 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. ",
"summary": "Compact Hashing based radius search for pyTorch using C++/CUDA backends.",
"version": "0.2.1",
"project_urls": {
"Issues": "https://github.com/wi-re/torchCompactRadius/issues",
"Repository": "https://github.com/wi-re/torchCompactRadius"
},
"split_keywords": [
"sph",
" radius",
" pytorch"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "430d941e63fdc408ca0acd5e73c11375af788292f55b4aef33f289ca6cbcb631",
"md5": "bf811ea4a7827eae95985316580b72cf",
"sha256": "0d1303ea319727f517201e9ec1737e4a4c31e5be2d92048b5b3b09bf398c0bcb"
},
"downloads": -1,
"filename": "torchCompactRadius-0.2.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "bf811ea4a7827eae95985316580b72cf",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 11661069,
"upload_time": "2024-08-20T09:16:00",
"upload_time_iso_8601": "2024-08-20T09:16:00.335185Z",
"url": "https://files.pythonhosted.org/packages/43/0d/941e63fdc408ca0acd5e73c11375af788292f55b4aef33f289ca6cbcb631/torchCompactRadius-0.2.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d062cc931ba6cea1c855cebe45ee1610551aa34cf356f9d335ebc0bfa58e6d65",
"md5": "13704949bc244aafe11f6f1a24280b83",
"sha256": "3b89e2656e961281d28dadca87823a14306f9a98ff628b0c00094fd36b61b575"
},
"downloads": -1,
"filename": "torchcompactradius-0.2.1.tar.gz",
"has_sig": false,
"md5_digest": "13704949bc244aafe11f6f1a24280b83",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 11354890,
"upload_time": "2024-08-20T09:16:03",
"upload_time_iso_8601": "2024-08-20T09:16:03.861072Z",
"url": "https://files.pythonhosted.org/packages/d0/62/cc931ba6cea1c855cebe45ee1610551aa34cf356f9d335ebc0bfa58e6d65/torchcompactradius-0.2.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-08-20 09:16:03",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "wi-re",
"github_project": "torchCompactRadius",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "torchcompactradius"
}
