Mentors: Teodor Minev <teodorminev98@gmail.com>, Dimiter Prodanov <dimiterpp@gmail.com>
Skill level: Advanced
Required skills: Java, Machine learning
Time commitment: Full time or part time (350 hours)
Forum for discussion
About: The Active Segmentation platform for ImageJ (ASP/IJ)[2] was developed in the scope of GSOC 2016 - 2024. The plugin provides a general-purpose environment that allows biologists and other domain experts to use transparently state-of-the-art techniques in machine learning to achieve excellent image segmentation and classification. ImageJ [1] is a public-domain Java image processing program extensively used in life and material sciences. The program was designed with an open architecture and is extensible via plugins. Recent years have experienced explosive development in the GPU-accelerated computing. The project will explore some of established Java-based GPU computing frameworks [4,5,6,7] and port the convolution engine used by the ASP/IJ to parallel implementation.
Aims: The project will port convolution engine used by the ASP/IJ to parallel implementation:
- Fix existing issues and bugs
- GPU computing frameworks evaluation and testing
- Implementation and profiling of selected convolution filters
Minimal set of deliverables:
- Requirement specification - Prepared by the candidate after understanding the functionality
- System Design - Detailed plan for development of the plugin and test cases
- Implementation and testing - Details of implementation and testing of the platform
Website/references:
Tech keywords: Java, ImageJ, CUDA, OpenGL, Parallel
1 Like
I am interested in working on the ‘Parallel Filter Implementation for the Active Segmentation Platform for ImageJ (ASP/IJ)’ project. My focus will be on optimizing the convolution engine by implementing parallel processing using GPU frameworks like jCUDA, JavaCL, and OpenCL. This will significantly improve image filtering performance for segmentation tasks. Looking forward to contributing and collaborating with the community!
Dear Teodor and @dprodanov ,
Thank you for your time and guidance regarding the Active Segmentation Plugin (ASP/IJ) project. I’ve been exploring the ASP/IJ repository and learning more about the convolution engine used in the platform. I’m particularly excited about the opportunity to port the convolution engine to a parallel GPU implementation to enhance performance and scalability.
I’ve also started familiarizing myself with:
- jCUDA and JavaCL – Understanding Java bindings for CUDA and OpenCL.
- Rootbeer GPU Compiler – Exploring Java-to-GPU compilation.
- ND4J and Deeplearning4j – To strengthen my knowledge of Java-based ML frameworks.
Additionally, I’m diving deeper into the ImageJ API and experimenting with creating small plugins to better understand the architecture.
To ensure a smooth workflow, I’d love your insights on:
- Key issues/bugs to focus on while understanding the convolution engine.
- Suggestions for evaluating and profiling different GPU computing frameworks.
- Any relevant documentation or examples that could help me get up to speed quickly.
I’m excited about contributing to this project and eager to collaborate with you throughout this journey. Looking forward to hearing your thoughts!
Best regards,
Sayan Hasan Mandal
Email: sayanjones77@gmail.com
GitHub: Sayanjones (Sayan Mandal) · GitHub
Dear Sayan,
Thank you very much for your interest! Deeplearning4j has a large number of dependencies, so this should be addressed during the deployment. We have compiled a standalone distribution of ImageJ + Active Segmentation to facilitate installation. The ImageJ API does not support parallelization. You can take a look at the convolution engine of the Active Segmentation.
You can look at the tests namespace where we are experimenting before introducing changes in the main codebase.
kind regards,
Dimiter
1 Like
Hi @dprodanov,
Went through Active segmentation repository, convolution engine has various filters that can be parallelized, for example Gaussian filter which can be implemented using JavaCL. Is this the correct approach for the aim asked, as we want to enhance performance using GPUs.
Also I would love to know more on Active segmentation, so are there any good first tasks to do on that?
Thanks and regards
Yash Kodwani
Email : yashkodwani2003@gmail.com
Dear @dprodanov ,
Thank you for your response and helpful insights! I appreciate the heads-up regarding the dependencies in Deeplearning4j and the standalone distribution of ImageJ + Active Segmentation. I’ll make sure to address the deployment challenges while considering any framework integrations.
I’ve started reviewing the convolution engine in the Active Segmentation codebase and will explore the tests namespace to better understand the ongoing experiments before introducing changes to the main codebase.
To proceed efficiently, I’d love to know:
- Are there any specific test cases or scenarios that you’d recommend focusing on in the test namespace?
- Would it be beneficial to benchmark the current convolution engine to establish a baseline before implementing the parallel version?
I’m excited to dive deeper into the project and will keep you updated on my progress. Thanks again for your guidance!
Kind regards,
Sayan
Dear Yash,
Trying out with the Gaussian filter can be a good option.
You can take a look at the dsp.Cov class. This is the main convolution engine.
There is also some code in ijaux.parallel but it is not used so far.
The filters are run from the FilterManager.
kind regards,
Dimiter
Dear Sayan,
The filters are applied one frame at a time by the FilterManager. applyFilters. The convolution engine is in dsp.Cov class.
You can benchmark a specific filter as a test case. The largest speedup is expected for the non-separable filters. A separable filter is effectively a sequence of 2 1D convolutions (across rows + across columns).
kind regards,
Dimiter
1 Like
Dear @dprodanov ,
Thank you for your continued guidance! I noticed that Yash is exploring parallelizing the Gaussian filter with JavaCL, which sounds like a great approach. Since the Gaussian filter is a separable filter, I’ll focus on benchmarking and parallelizing non-separable filters where the largest speedup is expected.
I’ve started analyzing the dsp.Cov class and will also review the code in ijaux.parallel to see if any existing parallelization approaches can be leveraged.
To align with the project goals, I’m planning to:
- Benchmark non-separable filters to compare CPU and GPU performance.
- Experiment with different GPU frameworks (like JavaCL and jCUDA) to evaluate their effectiveness for these filters.
Please let me know if this approach aligns with the project’s goals or if you have any additional suggestions. I’m excited to dive deeper and will share my findings soon!
Kind regards,
Sayan
Email: sayanjones77@gmail.com
GitHub: Sayanjones
Dear Sayan,
The deadline is tomorrow. You should upload your proposal ASAP.
kind regards,
Dimiter
1 Like
@dprodanov I’ll submit my proposal ASAP.