cuslines 2.0.0__tar.gz

cuslines-2.0.0/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cuslines-2.0.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: cuslines
+Version: 2.0.0
+Summary: GPU-accelerated tractography package
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: tqdm
+Requires-Dist: dipy
+Requires-Dist: trx-python
+Requires-Dist: cuda-python
+Requires-Dist: cuda-core
+Requires-Dist: cuda-cccl
+Dynamic: license-file
+
+# GPUStreamlines
+
+## Installation
+To install, simply run `pip install .` in the top-level repository directory.
+
+## Running the examples
+This repository contains several example usage scripts.
+
+The script `run_gpu_streamlines.py` demonstrates how to run any diffusion MRI dataset on the GPU. It can also run on the CPU for reference, if the argument `--device=cpu` is used. If not data is passed, it will donaload and use the HARDI dataset.
+
+To run the baseline CPU example on a random set of 1000 seeds, this is the command and example output:
+```
+$ python run_gpu_streamlines.py --device=cpu --output-prefix small --nseeds 1000
+parsing arguments
+Fitting Tensor
+Computing anisotropy measures (FA,MD,RGB)
+slowadcodf
+Bootstrap direction getter
+streamline gen
+Generated 2746 streamlines from 1000 seeds, time: 6.713643550872803 s
+Saved streamlines to small.1_1.trk, time 0.22669768333435059 s
+Completed processing 1000 seeds.
+Initialization time: 12.355878829956055 sec
+Streamline generation total time: 6.9404990673065186 sec
+        Streamline processing: 6.713643550872803 sec
+        File writing: 0.22669768333435059 sec
+```
+
+To run the same case on a single GPU, this is the command and example output:
+```
+$ python run_gpu_streamlines.py --output-prefix small --nseeds 1000 --ngpus 1
+parsing arguments
+Fitting Tensor
+Computing anisotropy measures (FA,MD,RGB)
+slowadcodf
+Bootstrap direction getter
+streamline gen
+Creating GPUTracker with 1 GPUs...
+Generated 2512 streamlines from 1000 seeds, time: 0.21228599548339844 s
+Saved streamlines to small.1_1.trk, time 0.17112255096435547 s
+Completed processing 1000 seeds.
+Initialization time: 14.81659483909607 sec
+Streamline generation total time: 0.3834989070892334 sec
+        Streamline processing: 0.21228599548339844 sec
+        File writing: 0.17112255096435547 sec
+Destroy GPUTracker...
+```
+
+Note that if you experience memory errors, you can adjust the `--chunk-size` flag.
+
+To run on more seeds, we suggest setting the `--write-method trx` flag in the GPU script to not get bottlenecked by writing files.
+
+## Running on AWS with Docker
+First, set up an AWS instance with GPU and ssh into it (we recommend a P3 instance with at least 1 V100 16 GB GPU and a Deep Learning AMI Ubuntu 18.04 v 33.0.). Then do the following:
+1. Log in to GitHub docker registry:
+```
+$ docker login -u <github id> docker.pkg.github.com
+```
+2. Enter your GitHub access token. If you do not have one, create it on the GitHub general security settings page and enable package read access for that token.
+3. Pull the container:
+```
+$ docker pull docker.pkg.github.com/dipy/gpustreamlines/gpustreamlines:latest
+```
+4. Run the code, mounting the current directory into the container for easy result retrieval:
+```
+$ docker run --gpus=all -v ${PWD}:/opt/exec/output:rw -it docker.pkg.github.com/dipy/gpustreamlines/gpustreamlines:latest \
+ python run_gpu_streamlines.py --ngpus 1 --output-prefix output/hardi_gpu_full --use-fast-write
+```
+5. The code produces a number of independent track files (one per processed "chunk"), but we have provided a merge script to combine them into a single trk file. To merge files, run:
+```
+$ docker run --gpus=all -v ${PWD}:/opt/exec/output:rw -it docker.pkg.github.com/dipy/gpustreamlines/gpustreamlines:latest \
+ ./merge_trk.sh -o output/hardi_tracks.trk output/hardi_gpu_full*
+```

cuslines-2.0.0/README.md

@@ -0,0 +1,73 @@
+# GPUStreamlines
+
+## Installation
+To install, simply run `pip install .` in the top-level repository directory.
+
+## Running the examples
+This repository contains several example usage scripts.
+
+The script `run_gpu_streamlines.py` demonstrates how to run any diffusion MRI dataset on the GPU. It can also run on the CPU for reference, if the argument `--device=cpu` is used. If not data is passed, it will donaload and use the HARDI dataset.
+
+To run the baseline CPU example on a random set of 1000 seeds, this is the command and example output:
+```
+$ python run_gpu_streamlines.py --device=cpu --output-prefix small --nseeds 1000
+parsing arguments
+Fitting Tensor
+Computing anisotropy measures (FA,MD,RGB)
+slowadcodf
+Bootstrap direction getter
+streamline gen
+Generated 2746 streamlines from 1000 seeds, time: 6.713643550872803 s
+Saved streamlines to small.1_1.trk, time 0.22669768333435059 s
+Completed processing 1000 seeds.
+Initialization time: 12.355878829956055 sec
+Streamline generation total time: 6.9404990673065186 sec
+        Streamline processing: 6.713643550872803 sec
+        File writing: 0.22669768333435059 sec
+```
+
+To run the same case on a single GPU, this is the command and example output:
+```
+$ python run_gpu_streamlines.py --output-prefix small --nseeds 1000 --ngpus 1
+parsing arguments
+Fitting Tensor
+Computing anisotropy measures (FA,MD,RGB)
+slowadcodf
+Bootstrap direction getter
+streamline gen
+Creating GPUTracker with 1 GPUs...
+Generated 2512 streamlines from 1000 seeds, time: 0.21228599548339844 s
+Saved streamlines to small.1_1.trk, time 0.17112255096435547 s
+Completed processing 1000 seeds.
+Initialization time: 14.81659483909607 sec
+Streamline generation total time: 0.3834989070892334 sec
+        Streamline processing: 0.21228599548339844 sec
+        File writing: 0.17112255096435547 sec
+Destroy GPUTracker...
+```
+
+Note that if you experience memory errors, you can adjust the `--chunk-size` flag.
+
+To run on more seeds, we suggest setting the `--write-method trx` flag in the GPU script to not get bottlenecked by writing files.
+
+## Running on AWS with Docker
+First, set up an AWS instance with GPU and ssh into it (we recommend a P3 instance with at least 1 V100 16 GB GPU and a Deep Learning AMI Ubuntu 18.04 v 33.0.). Then do the following:
+1. Log in to GitHub docker registry:
+```
+$ docker login -u <github id> docker.pkg.github.com
+```
+2. Enter your GitHub access token. If you do not have one, create it on the GitHub general security settings page and enable package read access for that token.
+3. Pull the container:
+```
+$ docker pull docker.pkg.github.com/dipy/gpustreamlines/gpustreamlines:latest
+```
+4. Run the code, mounting the current directory into the container for easy result retrieval:
+```
+$ docker run --gpus=all -v ${PWD}:/opt/exec/output:rw -it docker.pkg.github.com/dipy/gpustreamlines/gpustreamlines:latest \
+ python run_gpu_streamlines.py --ngpus 1 --output-prefix output/hardi_gpu_full --use-fast-write
+```
+5. The code produces a number of independent track files (one per processed "chunk"), but we have provided a merge script to combine them into a single trk file. To merge files, run:
+```
+$ docker run --gpus=all -v ${PWD}:/opt/exec/output:rw -it docker.pkg.github.com/dipy/gpustreamlines/gpustreamlines:latest \
+ ./merge_trk.sh -o output/hardi_tracks.trk output/hardi_gpu_full*
+```

cuslines-2.0.0/cuslines/__init__.py

@@ -0,0 +1,13 @@
+from .cuda_python import (
+    GPUTracker,
+    ProbDirectionGetter,
+    PttDirectionGetter,
+    BootDirectionGetter
+)
+
+__all__ = [
+    "GPUTracker",
+    "ProbDirectionGetter",
+    "PttDirectionGetter",
+    "BootDirectionGetter"
+]