Embedded AI • Underwater Computer Vision • Resource-Aware Perception • Explainable Leak Monitoring
★ Pipeline Perception · ★ Bubble Monitoring · ★ Leak Confirmation · ★ Research Poster ★ Framework Simulation ★ C++ Runtime Skeleton
A research-oriented embedded perception framework for underwater gas pipeline inspection.
NeptuNet is a lightweight hierarchical vision-based perception framework for underwater gas pipeline inspection.
The framework connects three complementary perception levels:
| Level | Module | Role | Main Outputs |
|---|---|---|---|
| Level 1 | Pipeline Geometric Perception | Continuous infrastructure awareness | Pipeline center, orientation, direction |
| Level 2 | Bubble-Based Early Warning | Lightweight temporal leak suspicion | Suspicion score, temporal bubble descriptors, SHAP explanations |
| Level 3 | Leak Confirmation | Conditional gas plume analysis | Plume mask, probable source, propagation direction |
NeptuNet is designed around a resource-aware perception philosophy: instead of running all inspection models continuously, perception is organized according to inspection context. Pipeline perception remains continuously active, bubble analysis provides lightweight early warning, and leak confirmation is activated when suspicious activity is detected.
This repository serves as the central project hub for NeptuNet. Detailed source code, datasets, models, demos, and experiments are maintained inside the corresponding module repositories.
Conventional subsea pipeline inspection remains costly, intermittent, and difficult to scale over long distances. Underwater visual perception is also affected by turbidity, scattering, illumination variation, low contrast, biofouling, and domain shifts between controlled and real underwater environments.
These constraints motivate embedded perception systems that can extract inspection-relevant information directly from underwater imagery while remaining lightweight enough for deployment-oriented robotic platforms.
NeptuNet addresses this challenge by combining:
- segmentation-based pipeline geometry,
- physics-inspired bubble plume monitoring,
- explainable machine learning,
- physics-guided gas plume representation,
- lightweight instance segmentation,
- ONNX and INT8 deployment workflows,
- and CPU/NPU-aware perception organization.
The project positions underwater inspection as an embedded perception problem, not as a complete closed-loop AUV autonomy system.
NeptuNet follows a context-suspicion-confirmation structure:
Continuous Pipeline Monitoring
↓
Bubble-Based Suspicion
↓
Conditional Leak Confirmation
Each level answers a different inspection question:
| Question | NeptuNet Level |
|---|---|
| Where is the pipeline and how is it oriented? | Level 1 |
| Is there suspicious bubble activity near the inspection context? | Level 2 |
| Is there a visible gas plume and where is its probable source? | Level 3 |
Level 1 provides continuous pipeline-centered perception from monocular underwater imagery.
It estimates:
- pipeline segmentation mask,
- image-plane center offset,
- dominant pipeline orientation,
- directional alignment cue:
LEFT,STRAIGHT, orRIGHT.
This module uses lightweight instance segmentation and PCA-based geometric extraction to transform segmentation masks into navigation-relevant geometric cues.
- YOLOv8n-seg instance segmentation
- ONNX deployment-oriented inference
- prototype-mask reconstruction
- bounding-box-guided mask cropping
- PCA-based center and orientation estimation
- INT8 NPU benchmarking
Underwater-Pipeline-Geometric-Perception
Datasets, model details, evaluation scripts, inference demos, and benchmark tables are provided inside the module repository.
Level 2 analyzes temporal bubble plume behavior to identify leak-suspicious activity.
Instead of relying only on frame-level detection, this module encodes short-term bubble dynamics into physics-inspired descriptors. These descriptors capture density, temporal stability, vertical structure, and short-term persistence. A tree-based classifier then produces interpretable leak-suspicion predictions.
- adaptive underwater preprocessing
- bubble candidate detection
- spatial filtering
- temporal windowing
- physics-inspired feature extraction
- Random Forest and XGBoost comparison
- SHAP-based explainability
- bubble activity descriptor vector,
- leak-suspicion score,
- interpretable feature attributions,
- lightweight early-warning signal.
Datasets, windowing scripts, feature extraction code, trained classifiers, SHAP analysis, and evaluation details are provided inside the module repository.
Level 3 performs conditional gas plume segmentation and geometric leak characterization.
This module uses Physics-Guided Diffuse-Texture Separation (PDTS) to enhance diffuse plume structures while suppressing high-frequency underwater background texture. The resulting representation is processed using a lightweight segmentation model, and the predicted mask is converted into geometric leak descriptors.
- Physics-Guided Diffuse-Texture Separation
- YOLOv8n-seg plume segmentation
- ONNX deployment-oriented mask reconstruction
- INT8 quantization
- plume centroid estimation
- probable image-plane source localization
- plume direction estimation
- gas plume segmentation mask,
- plume centroid,
- probable leak source location,
- dominant plume propagation direction.
Underwater-Leak-Geometric-Perception
Datasets, PDTS implementation, segmentation training, deployment evaluation, geometry extraction, and result analysis are provided inside the module repository.
NeptuNet is designed around conditional computational activation.
Normal Inspection
↓
Level 1 remains active for pipeline context
↓
Bubble activity is observed
↓
Level 2 evaluates temporal bubble behavior
↓
Suspicion score exceeds threshold
↓
Level 3 performs gas plume confirmation
This strategy avoids treating underwater inspection as a single monolithic detection problem. Instead, each level contributes a different type of information:
| Level | Information Type | Computational Role |
|---|---|---|
| Level 1 | Infrastructure geometry | Continuous NPU-oriented perception |
| Level 2 | Temporal bubble suspicion | Lightweight CPU-oriented monitoring |
| Level 3 | Spatial leak confirmation | Conditional NPU-oriented segmentation |
NeptuNet includes a lightweight framework-level simulation demo that illustrates how the three perception levels interact during underwater inspection.
The demo uses predefined inspection scenarios to simulate module-level outputs and show how NeptuNet coordinates:
- Level 1 — continuous pipeline geometric perception,
- Level 2 — bubble-based early-warning analysis,
- Level 3 — conditional leak confirmation.
This simulation is intentionally limited to perception-level coordination and does not claim full underwater robotic autonomy, closed-loop AUV control, underwater SLAM, or real-time onboard deployment.
Scenario JSON files
↓
NeptuNet orchestrator
↓
Perception-level state decisions
↓
Notebook tables, timelines, and CSV outputs
The orchestrator follows the NeptuNet resource-aware logic:
Level 1 is always active
↓
If the pipeline is detected, Level 2 monitors bubble activity
↓
If bubble suspicion exceeds the threshold, Level 3 is activated
↓
The system reports normal monitoring, pipeline search, unconfirmed suspicion, or confirmed leak
Each scenario contains 10 inspection windows, representing approximately 10 seconds of inspection.
| Scenario | Purpose | File |
|---|---|---|
| Normal inspection | Pipeline visible, bubble monitoring active, no leak suspicion | scenarios/scenario_01_normal_inspection.json |
| False anomaly return | Suspicious bubbles activate leak confirmation, but no plume is confirmed | scenarios/scenario_02_false_anomaly_return.json |
| Pipeline reacquisition | Pipeline is initially not visible, then detected and monitoring resumes | scenarios/scenario_03_pipeline_reacquisition.json |
| Confirmed leak event | Bubble suspicion triggers leak confirmation and a plume is confirmed | scenarios/scenario_04_confirmed_leak.json |
The following plots summarize the activation behavior of the three NeptuNet levels across the four scenarios.
Clone the repository and open the notebook:
git clone https://github.com/7amzaGH/NeptuNet-AUV-Intelligent-System.git
cd NeptuNet-AUV-Intelligent-System
jupyter notebook notebooks/01_neptunet_framework_simulation.ipynbOr run one scenario directly from the command line:
python integration/neptunet_orchestrator.py \
--scenario scenarios/scenario_04_confirmed_leak.json \
--output outputs/scenario_04_confirmed_leak.jsonThe notebook generates structured CSV outputs in the outputs/ directory for documentation and further analysis.
| Artifact | Location |
|---|---|
| Orchestrator script | integration/neptunet_orchestrator.py |
| Scenario JSON files | scenarios/ |
| Notebook demo | notebooks/01_neptunet_framework_simulation.ipynb |
| CSV simulation outputs | outputs/ |
| Module activation screenshots | assets/simulation/ |
Open the full simulation notebook: NeptuNet Framework Simulation Demo
This demo connects the independent NeptuNet modules at the framework level while keeping each module repository responsible for its own models, datasets, experiments, and evaluation.
NeptuNet also includes a lightweight C++ embedded runtime skeleton that demonstrates how the framework-level coordination logic can be expressed in a deployment-oriented structure.
This component reproduces the same perception-level state machine used in the Python simulation:
CSV scenario input
↓
C++ NeptuNet state machine
↓
Level 1 / Level 2 / Level 3 activation logic
↓
Perception-level system state output
The C++ runtime does not perform neural network inference, underwater robot control, SLAM, underwater physics simulation, or full onboard AUV deployment. It is provided only as a clean embedded-style prototype for the NeptuNet coordination logic.
Each CSV scenario contains 10 inspection windows, representing approximately 10 seconds of perception-level inspection behavior.
| Scenario | Purpose | File |
|---|---|---|
| Normal inspection | Pipeline visible, bubble monitoring active, no leak suspicion | cpp_runtime/examples/scenario_01_normal_inspection.csv |
| False anomaly return | Suspicious bubbles activate Level 3, but no plume is confirmed | cpp_runtime/examples/scenario_02_false_anomaly_return.csv |
| Pipeline reacquisition | Pipeline is initially not visible, then detected and monitoring resumes | cpp_runtime/examples/scenario_03_pipeline_reacquisition.csv |
| Confirmed leak event | Bubble suspicion activates Level 3 and a plume is confirmed | cpp_runtime/examples/scenario_04_confirmed_leak.csv |
cd cpp_runtime
mkdir build
cd build
cmake ..
cmake --build .Run a scenario on Linux or Makefile-based builds as:
./neptunet_runtime ../examples/scenario_04_confirmed_leak.csvRun with a custom suspicion threshold:
./neptunet_runtime ../examples/scenario_04_confirmed_leak.csv 0.75| Artifact | Location |
|---|---|
| C++ runtime documentation | cpp_runtime/README.md |
| CMake build file | cpp_runtime/CMakeLists.txt |
| State-machine header | cpp_runtime/include/neptunet_state_machine.hpp |
| State-machine implementation | cpp_runtime/src/neptunet_state_machine.cpp |
| Runtime entry point | cpp_runtime/src/main.cpp |
| Example CSV scenarios | cpp_runtime/examples/ |
This C++ runtime skeleton complements the Python notebook demo by showing how NeptuNet’s perception coordination logic can be represented in a lightweight embedded-friendly form.
A hierarchical embedded perception architecture for underwater gas pipeline inspection, combining infrastructure context, temporal anomaly suspicion, and spatial leak confirmation.
A lightweight segmentation-based perception module that estimates image-plane pipeline center, orientation, and direction using YOLOv8n-seg and PCA-based geometry extraction.
A physics-inspired temporal bubble monitoring module that uses structured descriptors, tree-based machine learning, and SHAP explainability to identify leak-suspicious bubble behavior.
A gas plume segmentation and localization module based on Physics-Guided Diffuse-Texture Separation and lightweight instance segmentation.
A deployment-oriented evaluation workflow using ONNX export, INT8 quantization, post-processing analysis, and Qualcomm RB3 Gen 2 NPU benchmarking.
A connected research ecosystem including module repositories, public datasets, reproducible experiments, research papers, thesis material, and visual project documentation.
| Metric | Result |
|---|---|
| Best mask mAP@0.5:0.95 | 0.946 |
| Best center error | 1.71 px |
| Best orientation error | 0.54° |
| INT8 NPU latency | 8.8 ms |
| Embedded throughput | 113.6 FPS |
| Metric | Result |
|---|---|
| Main classifier | Random Forest |
| F1-score | 0.9888 |
| ROC-AUC | 0.9991 |
| Runtime on embedded CPU | 140 ms |
| Explainability method | SHAP |
| Metric | Result |
|---|---|
| Main representation | PDTS |
| Segmentation model | YOLOv8n-seg |
| Mask mAP@0.5 on real ROV evaluation | 0.993 |
| INT8 NPU latency | 10.7 ms |
| Embedded throughput | 93.5 FPS |
NeptuNet follows a deployment-oriented embedded AI workflow.
Model Training
↓
ONNX Export
↓
Deployment-Side Post-Processing
↓
INT8 Quantization
↓
NPU Benchmarking
↓
Framework-Level Integration Analysis
The framework separates tasks according to their computational profile:
| Component | Preferred Runtime | Reason |
|---|---|---|
| Pipeline perception | NPU | Continuous segmentation and geometry extraction |
| Bubble monitoring | CPU | Lightweight structured features and tree-based inference |
| Leak confirmation | NPU | Conditional plume segmentation and geometry extraction |
This CPU/NPU-aware organization is central to the NeptuNet design philosophy.
NeptuNet produced and organized multiple datasets for underwater pipeline perception, bubble plume monitoring, and gas plume leak analysis.
To keep this framework repository clean, datasets are documented and linked inside the corresponding module repositories:
| Dataset Category | Location |
|---|---|
| Pipeline training and external evaluation datasets | Pipeline Perception Repository |
| Bubble plume temporal window datasets | TUBLEX Bubble Monitoring Repository |
| Gas plume training and real evaluation datasets | PDTS Leak Confirmation Repository |
This organization avoids duplication and keeps each dataset connected to its code, experiments, and evaluation protocol.
NeptuNet was developed as a Master's thesis project and expanded into multiple research outputs.
| Work | Focus |
|---|---|
| Master Thesis | Complete NeptuNet framework and system-level analysis |
| Pipeline Paper | Lightweight underwater pipeline geometric perception |
| Bubble Paper | Explainable physics-inspired bubble plume analysis |
| Leak Paper | Embedded underwater gas leak segmentation using PDTS |
| NeptuNet Technical Supplement | Framework-level technical magazine supplement |
The thesis PDF is provided as a direct research reference:
Publication links and paper-specific citation entries are maintained inside the related module repositories when public release is permitted.
NeptuNet was awarded the Innovative Project Label in Algeria, recognizing its innovation potential in underwater AI, embedded perception, and intelligent inspection technologies.
This recognition was granted through the national innovation and startup support framework under the Ministry of Knowledge Economy, Startups and Micro-enterprises.
The label supports the project identity beyond the Master's thesis by positioning NeptuNet as both a research-oriented embedded perception framework and a potential applied technology direction for underwater infrastructure inspection.
NeptuNet-AUV-Intelligent-System/
│
├── README.md
├── LICENSE
│
├── assets/<- Figures and media for this README
│
├── integration/
│ ├── neptunet_orchestrator.py
│ └── README.md
│
├── scenarios/
│ ├── scenario_01_normal_inspection.json
│ ├── scenario_02_false_anomaly_return.json
│ ├── scenario_03_pipeline_reacquisition.json
│ └── scenario_04_confirmed_leak.json
│
├── cpp_runtime/
│ ├── README.md
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── neptunet_state_machine.hpp
│ ├── src/
│ │ ├── neptunet_state_machine.cpp
│ │ └── main.cpp
│ └── examples/ <- Scenarios csv files
│
├── notebooks/
│ └── neptunet_framework_simulation.ipynb
│
├── outputs/
│ ├── scenario_01_normal_inspection.csv
│ ├── scenario_02_false_anomaly_return.csv
│ ├── scenario_03_pipeline_reacquisition.csv
│ └── scenario_04_confirmed_leak.csv
│
├── poster/
│ ├── neptunet_poster.pdf
│ └── neptunet_poster.png
│
└── docs/
├── NeptuNet_Master_Thesis.pdf
├── neptunet_innovative_project_label.pdf
├── neptunet_technical_magazinesupplement.pdf
└── limitations.md
This repository intentionally remains lightweight. Detailed code, datasets, models, demos, and experiments are maintained inside the corresponding module repositories.
NeptuNet focuses on perception-side underwater inspection.
- underwater visual perception,
- segmentation-based pipeline geometry extraction,
- bubble temporal feature analysis,
- explainable machine learning for leak suspicion,
- gas plume segmentation,
- image-plane source and direction estimation,
- ONNX deployment workflow,
- INT8 quantization,
- NPU benchmarking,
- cross-domain visual evaluation.
- framework-level perception coordination simulation.
- C++ embedded-style state-machine prototype for perception-level coordination.
- closed-loop AUV control,
- underwater SLAM,
- acoustic localization,
- full mission autonomy,
- hydrodynamic vehicle modeling,
- long-duration offshore deployment,
- complete onboard robotic system integration.
This distinction is intentional. NeptuNet is a perception framework and research foundation for future underwater robotic inspection systems.
If you use the NeptuNet framework, please cite the project and the corresponding module papers.
@software{ghitri2026neptunet,
title = {NeptuNet: A Lightweight Vision-Based Perception Framework for Underwater Gas Pipeline Inspection},
author = {Ghitri, Hamza},
year = {2026},
url = {https://github.com/7amzaGH/NeptuNet-AUV-Intelligent-System},
note = {Research-oriented embedded perception framework for underwater gas pipeline inspection}
}he original academic thesis that introduced the NeptuNet framework can be cited as:
@mastersthesis{ghitri2025neptunet_thesis,
title = {NeptuNet: A Lightweight Vision-Based Perception System for Underwater Gas Pipeline Inspection},
author = {Ghitri, Hamza},
school = {University of Ain Temouchent Belhadj Bouchaib},
year = {2025},
type = {Master's Thesis}
}For module-specific methods, datasets, or experiments, please cite the corresponding pipeline, bubble-monitoring, and leak-confirmation papers when they are available.
NeptuNet was developed as part of a Master's thesis in Cybersecurity and Artificial Intelligence at the University of Ain Temouchent Belhadj Bouchaib, where the thesis was awarded the full mark of 20/20.
The thesis was supervised by:
- Dr. BELGRANA Fatima Zohra
- Dr. BEMMOUSSAT Chemseddine
NeptuNet was also awarded the Innovative Startup Project Label under Ministerial Decision 1275 in Algeria.
- EL HADJ MIMOUNE Mourad was part of the startup project team.
The project also benefited from research experience at the Silesian University of Technology and from open-source tools and datasets used for underwater computer vision, embedded AI, and explainable machine learning.
The source code in this repository is released under the MIT License.
Project documents, thesis material, posters, official recognition documents, logos, datasets, and third-party resources are not automatically covered by the MIT software license. Their reuse may require proper citation, permission, or respect of the license stated in the corresponding source.
See LICENSE for details.
NeptuNet : Lightweight embedded perception Framework for Underwater Gas Pipeline Inspection