Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Hey All,
The Birmingham-Method is the oldest algorithm to determine the tracer location from PEPT data. Therefore it does not use state of the art libraries that provide fancy functions as HDBScan or topological functions.
As a result, the Birmingham-Method is quite simple to implement on GPU, especially because the already existing C-code does only need few modifications to be compatible with CUDA. With this pull request I offer a initial running version of the Birmingham-Method implemented in CUDA running via pyCUDA.
Minimal Documentation is provided.
This GPU-Birmingham-Method is implemented as an
Reducer
instead of aFilter
, this means that there is no implementation offit_sample
but a implementation offit
. This results in two things, first of all it is not influenced by the automatic parallelization inside a pipeline, so you can, if you want, create a single pipeline with the GPU-Birmingham-Method first then cluster the points using HDBScan and second, there is no need to stack the result after a run as it technically did not run parallel. Not sure if the implementation is correct, but i leave it for you @anicusan to decide ;-)The function is tested against the CPU-Birmingham-Method and shows minimal differences, which is to be expected considering the lower precision used on GPUs.
The errors calculated between CPU and GPU as the mean difference between each point:
This all was just a fun project to me, so I'd be careful using this before someone else did review it properly. I know there is one issue that I can't resolve right now, it has to do with overlaps so only occurs if
overlap
> 0, but i am sure we can sort that out together.Have a great holiday!