Ship Detection Satellite Ai | AI Final Year Project Report

Complete Technical Paper Content — Ship Detection Satellite Ai

1. Executive Abstract, Problem Formulation & Background

🚢 Ship Detection using SAR (Synthetic Aperture Radar) Images for Maritime Vigilance This repository contains the full implementation and research code for the project titled "Ship Detection using SAR Images for Maritime Vigilance" . The aim is to develop a deep learning-based framework optimized for accurate ship detection in Synthetic Aperture Radar (SAR) images — addressing key challenges like small targets, cluttered backgrounds, and high noise levels. This project was presented at the International Conference on Data Science, Agents, and Artificial Intelligence (ICDSAAI 2025) and was conducted under the guidance of Dr. Poonkodi M from Vellore Institute of Technology, Chennai. 📚 Publication 📝 Paper Title : Ship Detection using SAR Images for Maritime Vigilance 🧠 Authors : Rithvika T, Monish P, Dr. Poonkodi M 🎓 Guided & Contributed by : Dr. Poonkodi M 🏫 Affiliation : Vellore Institute of Technology, Chennai 📍 Conference : International Conference on Data Science, Agents, and Artificial Intelligence (ICDSAAI 2025) 📅 Date : March 29, 2025 🔗 DOI : 10.1109/ICDSAAI65575.2025.11011861 🔬 Abstract Maritime surveillance is crucial for national security, illegal shipping detection, and disaster response. Traditional detection techniques such as CFAR or threshold-based methods result in high false positives, especially in noisy SAR images. Deep learning models like Faster R-CNN and YOLO perform well on natural images but struggle with SAR's grayscale format and environmental noise. To solve this, we propose a custom-optimized ResNet50 framework integrated with: Region of Interest (ROI) and corner detection Feature extraction using ResNet50 + Feature Pyramid Networks (FPN) Weight mapping and entropy-based filtering Swish & Tanh activation functions Hyperparameter tuning using Particle Swarm Optimization (PSO) 🧠 Model Architecture Architecture Overview: The architecture utilizes ResNet50 and FPN for multi-scale feature extraction, enhanced by weight mapping and corner-aware ROIs. Activations are refined using Swish + Tanh, and the final layer detects and classifies ships in SAR scenes. 🧪 Results and Discussion Performance Visuals: Detection Rate : High accuracy for small and partially occluded ships Real-time Capability : Moderate FPS for real-time monitoring tasks Comparative Advantage : Outperforms traditional and basic deep learning models (Faster R-CNN, Mask R-CNN, YOLOv2, FCOS) in both accuracy and SAR-noise robustness ⚙️ Methodology Data Preprocessing Augmentation: Rotation, flipping, zooming Noise reduction: Median filtering Edge enhancement: Sobel filters Region of Interest & Corner Detection Highlights ship-likely regions Boosts shape awareness and boundary clarity Feature Extraction ResNet50 + FPN (U-Net-inspired) for multi-scale feature fusion Robust against cluttered backgrounds Weight Map & Activation Optimization Swish & Tanh activations for better gradient flow Weight maps emphasize ship regions, suppress noise Pixel Filtering & Invalid Region Removal Filters based on Euclidean distance and color difference Removes unlikely ship regions to reduce false positives Hyperparameter Optimization Particle Swarm Optimization (PSO) dynamically tunes the model for optimal balance between speed and accuracy Final Detection & Classification Detection: Ships located in refined ROIs Classification: Ships categorized by structure and size 🗃️ Dataset Source : Ship Detection Dataset Image Type : SAR (Synthetic Aperture Radar) Labels : Run-Length Encoded (RLE) binary segmentation masks Resolution : 768 × 768 pixels per image 🛠️ Technologies Used 🧠 Deep Learning Frameworks: TensorFlow, Keras 🖼️ Image Processing: OpenCV, scikit-image 🧪 Model Backbone: ResNet50, Feature Pyramid Network (FPN) ⚙️ Optimization: Particle Swarm Optimization (PSO) 📊 Visualization: Matplotlib, Seaborn 🚀 How to Run Clone the repository git clone https://github.com/yourusername/ship-detection-sar.git cd ship-detection-sar Install dependencies pip install -r requirements.txt Update dataset paths in the notebook train_image_dir = "path/to/train_v2" test_image_dir = "path/to/test_v2" csv_path = "train_ship_segmentations_v2.csv" Run the notebook jupyter notebook " ship_detection using satellite imagery.ipynb " 🙏 Acknowledgments We would like to express our sincere gratitude to Dr. Poonkodi M for her unwavering guidance and mentorship throughout the project. We also thank VIT, Chennai for supporting and providing a platform for research. 🧾 License This project is intended for academic and research use only . For commercial use, please contact the authors. 🔗 Citation R. Tiruveedhula and M. P, "Ship Detection using SAR Images for Maritime Vigilance," 2025 International Conference on Data Science, Agents & Artificial Intelligence (ICDSAAI), Chennai, India, 2025, pp. 1-6, doi: 10.1109/ICDSAAI65575.2025.11011861. keywords: {Surveillance;Image edge detection;Feature extraction;Real-time systems;Radar polarimetry;Security;Marine vehicles;Particle swarm optimization;Synthetic aperture radar;Synthetic aperture radar (SAR);Edge Detection;Feature Extraction Algorithm;Euclidian Distance},

This repository contains the full implementation and research code for the project titled "Ship Detection using SAR Images for Maritime Vigilance" . The aim is to develop a deep learning-based framework optimized for accurate ship detection in Synthetic Aperture Radar (SAR) images — addressing key challenges like small targets, cluttered backgrounds, and high noise levels.

This project was presented at the International Conference on Data Science, Agents, and Artificial Intelligence (ICDSAAI 2025) and was conducted under the guidance of Dr. Poonkodi M from Vellore Institute of Technology, Chennai.

Maritime surveillance is crucial for national security, illegal shipping detection, and disaster response. Traditional detection techniques such as CFAR or threshold-based methods result in high false positives, especially in noisy SAR images. Deep learning models like Faster R-CNN and YOLO perform well on natural images but struggle with SAR's grayscale format and environmental noise.

The architecture utilizes ResNet50 and FPN for multi-scale feature extraction, enhanced by weight mapping and corner-aware ROIs. Activations are refined using Swish + Tanh, and the final layer detects and classifies ships in SAR scenes.

git clone https://github.com/yourusername/ship-detection-sar.git cd ship-detection-sar

train_image_dir = "path/to/train_v2" test_image_dir = "path/to/test_v2" csv_path = "train_ship_segmentations_v2.csv"

We would like to express our sincere gratitude to Dr. Poonkodi M for her unwavering guidance and mentorship throughout the project. We also thank VIT, Chennai for supporting and providing a platform for research.

This project is intended for academic and research use only . For commercial use, please contact the authors.

2. Related Work, Literature Survey & Algorithmic Foundations

R. Tiruveedhula and M. P, "Ship Detection using SAR Images for Maritime Vigilance," 2025 International Conference on Data Science, Agents & Artificial Intelligence (ICDSAAI), Chennai, India, 2025, pp. 1-6, doi: 10.1109/ICDSAAI65575.2025.11011861. keywords: {Surveillance;Image edge detection;Feature extraction;Real-time systems;Radar polarimetry;Security;Marine vehicles;Particle swarm optimization;Synthetic aperture radar;Synthetic aperture radar (SAR);Edge Detection;Feature Extraction Algorithm;Euclidian Distance},

This project aims to detect ships in SAR Images using advanced image processing techniques and neural networks.

🚢 Ship Detection in Satellite Imagery This repository contains a comprehensive deep learning project aimed at detecting ships in satellite imagery. The project leverages advanced techniques such as data augmentation, class balancing, and transfer learning to achieve high precision and recall for detecting ships. 🌟 Key Features Deep Learning Models : Iteratively developed four models, culminating in the best-performing Model 4 using MobileNetV2 and transfer learning. Advanced Data Augmentation : Applied techniques like rotations, zooms, brightness adjustments, and cropping to enhance model generalization. Class Imbalance Handling : Addressed imbalance through class weighting to emphasize the minority Ship class. Visualization : Detailed training progress visualizations and confusion matrices to evaluate model performance. 📂 Repository Structure ├── datasets/ # Dataset directory (not included due to size) ├── notebook.ipynb # Main Jupyter Notebook for the project ├── final_model_4.keras # Saved best-performing model ├── images/ # Visual assets for documentation │ ├── training_progress.png # Training progress visualization │ ├── confusion_matrix.png # Confusion matrix example │ ├── banner.png # Project banner ├── README.md # Project overview and documentation 📊 Results Model 4 Performance Validation Accuracy : 96.75% Validation Loss : 0.0971 Precision (Ship) : 89.19% Recall (Ship) : 99.00% Model 4 demonstrated strong generalization and balanced performance between precision and recall, making it suitable for real-world applications. 🛠️ Techniques Used Framework : TensorFlow/Keras Architecture : MobileNetV2 for feature extraction Optimization : Adam optimizer with a learning rate of 0.00005 Metrics : Accuracy, Precision, Recall, F1-Score 🚀 How to Use Clone the Repository : git clone https://github.com/ENKI0311/ship-detection.git cd ship-detection Run the Notebook : Open notebook.ipynb in Jupyter Notebook or Google Colab. Ensure the dataset is properly linked before running. Test the Model : Load the saved model ( final_model_4.keras ) and test it on your own satellite imagery. 📈 Visual Examples Training Progress Confusion Matrix 🛠️ Future Work Extend to multi-class object detection in satellite imagery (e.g., ports, airplanes). Deploy the model as a web API using Flask or FastAPI. Explore larger and more diverse datasets for further refinement. 🙌 Acknowledgments The dataset used for this project is sourced from Ships in Satellite Imagery on Kaggle . 📝 License This project is licensed under the MIT License. Feel free to use and modify it for your own purposes. 📧 Contact For questions or suggestions, feel free to reach out: Email : your_email@example.com GitHub : YourUsername

This repository contains a comprehensive deep learning project aimed at detecting ships in satellite imagery. The project leverages advanced techniques such as data augmentation, class balancing, and transfer learning to achieve high precision and recall for detecting ships.

├── datasets/ # Dataset directory (not included due to size) ├── notebook.ipynb # Main Jupyter Notebook for the project ├── final_model_4.keras # Saved best-performing model ├── images/ # Visual assets for documentation │ ├── training_progress.png # Training progress visualization │ ├── confusion_matrix.png # Confusion matrix example │ ├── banner.png # Project banner ├── README.md # Project overview and documentation

Model 4 demonstrated strong generalization and balanced performance between precision and recall, making it suitable for real-world applications.

This project is licensed under the MIT License. Feel free to use and modify it for your own purposes.

A deep learning project for detecting ships in satellite imagery using advanced data augmentation, class balancing, and transfer learning techniques.

SAR Ship Detection Project Overview The SAR Ship Detection Project is an end-to-end system designed for the automated detection and tracking of maritime vessels using Synthetic Aperture Radar (SAR) imagery. This project leverages advanced deep learning models to process SAR data, primarily from Sentinel-1 satellites, providing crucial insights for maritime domain awareness, safety, and security. A key focus of this project is the detection of "dark vessels," by integrating AIS (Automatic Identification System) data with SAR observations to identify vessels that are not broadcasting their location. Optimized for efficient inference on edge devices like the NVIDIA Jetson Nano, this solution aims to bridge the gap between powerful machine learning and deployable satellite-based applications. This project is still a Work In Progress, so you may see a few placeholders. 🚀 Features Automated Ship Detection: Utilizes state-of-the-art deep learning models (e.g., YOLOv8) for accurate ship identification in complex SAR environments. Dark Vessel Detection: Integrates AIS data with SAR detections to identify vessels not transmitting their position, crucial for illegal activity monitoring. SAR Data Preprocessing Pipeline: Includes essential steps like speckle noise reduction, land-sea segmentation, and radiometric correction. Edge Device Optimization: Models are optimized for high-performance, low-latency inference on resource-constrained hardware (e.g., NVIDIA Jetson Nano). Versatile Interfaces: Designed for integration into various operational modalities, including edge deployment, web-based map interfaces, and direct image upload for processing. Applications: Supports maritime surveillance, illegal activity monitoring (e.g., illegal fishing, smuggling), search and rescue operations, and general maritime intelligence. 💻 Getting Started The project supports two setup methods: Docker (Recommended) for production-ready deployment and Local Installation for development. 🐳 Quick Start with Docker (Recommended) Docker provides a consistent, isolated environment that eliminates dependency conflicts. The project uses a dual-container architecture: Prerequisites Docker Engine (20.10.0+) and Docker Compose (2.0.0+) Git NVIDIA Docker runtime (for Jetson AGX Orin edge deployment) Installation & Launch # Clone the repository git clone https://github.com/ioEclipse/SAR-SHIP-DETECTION.git cd SAR-SHIP-DETECTION # Build and start web application docker compose up web_app -d --build # Access the application at http://localhost:8501 # Optional: Start Jetson AGX Orin edge container (requires NVIDIA GPU) docker compose up jetson_app -d --build Container Architecture web_app : Complete Streamlit application with full functionality jetson_app : GPU-optimized edge processing for NVIDIA Jetson AGX Orin Docker Troubleshooting # Check container status docker compose ps # View detailed logs docker compose logs web # Complete rebuild docker compose down --rmi local docker compose up -d --build 🔧 Local Installation (Development) For developers who need direct Python environment access. Prerequisites Python 3.8+ Git NVIDIA GPU (for training and optimized inference) NVIDIA Jetson Nano (for edge deployment testing) Conda or venv for virtual environment management Installation Steps Clone the repository: git clone https://github.com/ioEclipse/SAR-SHIP-DETECTION.git cd SAR-SHIP-DETECTION Set up a Python virtual environment: python3 -m venv venv_sardetection source venv_sardetection/bin/activate # OR using Conda: conda create -n sardetection python=3.8 Install dependencies: pip install -r requirements.txt Ensure NVIDIA drivers and CUDA toolkit are installed for GPU acceleration. Create config.json IMPORTANT WILL NOT WORK WITHOUT CONFIG Copy the example config below to config.json : { "google-earth" : { "service_account" : { "type" : " service_account " , "project_id" : " PUT_PROJECT_ID_HERE " , "private_key_id" : " PUT_PRIVATE_KEY_ID_HERE " , "private_key" : " PUT_PRIVATE_KEY_HERE " , "client_email" : " PUT_SERVICE_ACCOUNT_EMAIL_HERE " , "client_id" : " PUT_CLIENT_ID_HERE " , "auth_uri" : " https://accounts.google.com/o/oauth2/auth " , "token_uri" : " https://oauth2.googleapis.com/token " , "auth_provider_x509_cert_url" : " https://www.googleapis.com/oauth2/v1/certs " , "client_x509_cert_url" : " PUT_CLIENT_CERT_URL_HERE " } }, "ais_data" : { "base_url" : " https://coast.noaa.gov/htdata/CMSP/AISDataHandler/2024/ " , "url_pattern" : " AIS_2024_{date}.zip " , "year" : 2024 } } Run the application: cd FullApp streamlit run home.py Access at http://localhost:8501 Download pre-trained models: Detailed instructions for downloading and placing pre-trained model weights will be provided here. YOLOv11m folder contains the weights. 📦 Application Overview The FullApp directory encapsulates a comprehensive Synthetic Aperture Radar (SAR) ship detection application, integrating all functionalities developed throughout this project. This application provides an end-to-end pipeline for processing, tracking, and analyzing ships using radar imagery. It enables users to upload raw SAR data, explore Google Earth Engine SAR collections, and leverage cloud-based AI for robust inference. The system features an intuitive web-based dashboard for visualizing detailed reports, including global annotated images, sub-images of detected ships, and ship metadata (e.g., pixel area and surface area in square meters). Additionally, it supports export of results and is optimized for edge deployment on platforms like NVIDIA Jetson Nano, facilitating real-time inference without requiring prior land-ocean segmentation. This dual-targeted architecture ensures both operational efficiency in edge environments and user-friendly interaction for maritime surveillance. 🛠️ Environment Setup Choose your preferred setup method: Docker Setup (Recommended) docker-compose up -d --build # Application available at http://localhost:8501 Local Environment Setup # Create and activate virtual environment python -m venv .venv # Windows: .venv\Scripts\activate # macOS/Linux: source .venv/bin/activate # Install dependencies pip install -r requirements.txt 🚀 Launching the Application Launch Options Docker (Recommended): docker-compose up -d # Access at http://localhost:8501 Local: cd FullApp streamlit run home.py 📂 Directory Structure and File Descriptions The project is organized with the following key structure: SAR-SHIP-DETECTION/ ├── config.json # System configuration (Google Earth Engine, AIS data) ├── FullApp/ # Streamlit web application (main system) │ ├── home.py # Landing page entry point │ ├── functions.py # Core backend functions │ ├── engineAPI1.py # Google Earth Engine integration │ ├── local_inference.py # Local YOLO model inference │ ├── assets/ # Static UI assets (logos, backgrounds, etc.) │ ├── pages/ # Streamlit pages │ │ ├── main.py # Mode selection page │ │ ├── app.py # SAR file upload interface │ │ ├── earthEngine.py # Google Earth Engine interface │ │ └── insights.py # Statistical insights page │ └── images/ # Generated output images and results ├── Jetson AGX Orin/ # Edge deployment container (GPU-optimized) │ ├── Final_function.py # Complete edge processing pipeline │ ├── best1.pt # Optimized model weights for Jetson │ ├── inference_with_ONNX.py # GPU-accelerated ONNX inference │ └── ourmodel_inference_function.py # Edge-optimized inference ├── preprocessing/ # Image preprocessing modules ├── tracking/ # Ship tracking algorithms (development) ├── utilities/ # Utility scripts (model conversion, testing, image slicing) ├── YOLOv11m/ # Trained model weights and metrics ├── debug_images/ # Organized debug and test images └── Ais_data/ # Downloaded AIS data (auto-managed) Key Components: FullApp/ : Complete Streamlit web application with all user interfaces Jetson AGX Orin/ : Self-contained edge processing optimized for NVIDIA Jetson AGX Orin with GPU acceleration config.json : Centralized configuration for Google Earth Engine and AIS data sources preprocessing/ : Advanced SAR image preprocessing pipeline with land-sea segmentation utilities/ : Utility scripts for model conversion, testing, and large image processing YOLOv11m/ : Contains trained model weights (best.pt) and performance metrics debug_images/ : Organized storage for debugging and test images (previously cluttering root directory) ✅ Features Included The application offers a comprehensive set of functionalities for SAR ship detection and analysis: Raw SAR Image Processing : Supports upload and processing of raw SAR images in .png or .jpg formats for ship detection. Interactive Dashboard : Provides a user-friendly Streamlit interface for visualizing global annotated images, individual ship sub-images, and metadata tables. Automatic Sub-Image Cropping : Extracts sub-images around detected ships with configurable margins, facilitating detailed inspection. Ship Characteristics Analysis : Computes and displays metadata, including ship ID, pixel area, and surface area in square meters, presented in an interactive table with a "See More" option for extended results. Google Earth Engine Integration : Enables access to SAR data collections for advanced data exploration and analysis. Export Capabilities : Allows downloading of annotated images, sub-images, and ship metadata for further analysis or reporting. Persistent Session State : Maintains user interactions across sessions, ensuring a seamless experience. Edge Deployment Support : Optimized for deployment on NVIDIA Jetson Nano, enabling real-time inference on raw SAR imagery without requiring land-ocean segmentation. 📊 Dataset The primary dataset used for training and evaluation can be downloaded from: Google Drive Dataset Download This link will be updated with the actual dataset download location once available. Currently contains the SSDD Dataset. 💡 Usage Detailed instructions on how to run the detection and tracking pipeline, including command-line arguments and configuration options, will be provided in the full documentation. Example (placeholder): python run_pipeline.py --input_dir ./data/raw_sar_images --output_dir ./results --model_path ./models/yolov8_sardetect.pt 📖 Documentation & Project Roadmap Project Documentation: PDF Document - A detailed guide covering the project's architecture, methodology, and technical specifications. Project Task List: Google Sheet - Track the project's progress, upcoming tasks, and assigned responsibilities. 🤝 Contributing We welcome contributions to the SAR Ship Detection Project! Please see our CONTRIBUTING.md for guidelines on how to submit pull requests, report issues, and contribute to the development. 📄 License This project is licensed under the MIT License - see the LICENSE file for details.

3. Dataset Ingestion, Preprocessing & Stochastic Augmentations

The SAR Ship Detection Project is an end-to-end system designed for the automated detection and tracking of maritime vessels using Synthetic Aperture Radar (SAR) imagery. This project leverages advanced deep learning models to process SAR data, primarily from Sentinel-1 satellites, providing crucial insights for maritime domain awareness, safety, and security. A key focus of this project is the detection of "dark vessels," by integrating AIS (Automatic Identification System) data with SAR observations to identify vessels that are not broadcasting their location. Optimized for efficient inference on edge devices like the NVIDIA Jetson Nano, this solution aims to bridge the gap between powerful machine learning and deployable satellite-based applications.

The project supports two setup methods: Docker (Recommended) for production-ready deployment and Local Installation for development.

Docker provides a consistent, isolated environment that eliminates dependency conflicts. The project uses a dual-container architecture:

# Clone the repository git clone https://github.com/ioEclipse/SAR-SHIP-DETECTION.git cd SAR-SHIP-DETECTION # Build and start web application docker compose up web_app -d --build # Access the application at http://localhost:8501 # Optional: Start Jetson AGX Orin edge container (requires NVIDIA GPU) docker compose up jetson_app -d --build

# Check container status docker compose ps # View detailed logs docker compose logs web # Complete rebuild docker compose down --rmi local docker compose up -d --build

python3 -m venv venv_sardetection source venv_sardetection/bin/activate # OR using Conda: conda create -n sardetection python=3.8

{ "google-earth" : { "service_account" : { "type" : " service_account " , "project_id" : " PUT_PROJECT_ID_HERE " , "private_key_id" : " PUT_PRIVATE_KEY_ID_HERE " , "private_key" : " PUT_PRIVATE_KEY_HERE " , "client_email" : " PUT_SERVICE_ACCOUNT_EMAIL_HERE " , "client_id" : " PUT_CLIENT_ID_HERE " , "auth_uri" : " https://accounts.google.com/o/oauth2/auth " , "token_uri" : " https://oauth2.googleapis.com/token " , "auth_provider_x509_cert_url" : " https://www.googleapis.com/oauth2/v1/certs " , "client_x509_cert_url" : " PUT_CLIENT_CERT_URL_HERE " } }, "ais_data" : { "base_url" : " https://coast.noaa.gov/htdata/CMSP/AISDataHandler/2024/ " , "url_pattern" : " AIS_2024_{date}.zip " , "year" : 2024 } }

Download pre-trained models: Detailed instructions for downloading and placing pre-trained model weights will be provided here. YOLOv11m folder contains the weights.

The FullApp directory encapsulates a comprehensive Synthetic Aperture Radar (SAR) ship detection application, integrating all functionalities developed throughout this project. This application provides an end-to-end pipeline for processing, tracking, and analyzing ships using radar imagery. It enables users to upload raw SAR data, explore Google Earth Engine SAR collections, and leverage cloud-based AI for robust inference. The system features an intuitive web-based dashboard for visualizing detailed reports, including global annotated images, sub-images of detected ships, and ship metadata (e.g., pixel area and surface area in square meters). Additionally, it supports export of results and is optimized for edge deployment on platforms like NVIDIA Jetson Nano, facilitating real-time inference without requiring prior land-ocean segmentation. This dual-targeted architecture ensures both operational efficiency in edge environments and user-friendly interaction for maritime surveillance.

4. Neural Network Backbone, Layer Specifications & Loss Formulations

# Create and activate virtual environment python -m venv .venv # Windows: .venv\Scripts\activate # macOS/Linux: source .venv/bin/activate # Install dependencies pip install -r requirements.txt

SAR-SHIP-DETECTION/ ├── config.json # System configuration (Google Earth Engine, AIS data) ├── FullApp/ # Streamlit web application (main system) │ ├── home.py # Landing page entry point │ ├── functions.py # Core backend functions │ ├── engineAPI1.py # Google Earth Engine integration │ ├── local_inference.py # Local YOLO model inference │ ├── assets/ # Static UI assets (logos, backgrounds, etc.) │ ├── pages/ # Streamlit pages │ │ ├── main.py # Mode selection page │ │ ├── app.py # SAR file upload interface │ │ ├── earthEngine.py # Google Earth Engine interface │ │ └── insights.py # Statistical insights page │ └── images/ # Generated output images and results ├── Jetson AGX Orin/ # Edge deployment container (GPU-optimized) │ ├── Final_function.py # Complete edge processing pipeline │ ├── best1.pt # Optimized model weights for Jetson │ ├── inference_with_ONNX.py # GPU-accelerated ONNX inference │ └── ourmodel_inference_function.py # Edge-optimized inference ├── preprocessing/ # Image preprocessing modules ├── tracking/ # Ship tracking algorithms (development) ├── utilities/ # Utility scripts (model conversion, testing, image slicing) ├── YOLOv11m/ # Trained model weights and metrics ├── debug_images/ # Organized debug and test images └── Ais_data/ # Downloaded AIS data (auto-managed)

The application offers a comprehensive set of functionalities for SAR ship detection and analysis:

The primary dataset used for training and evaluation can be downloaded from: Google Drive Dataset Download

This link will be updated with the actual dataset download location once available. Currently contains the SSDD Dataset.

Detailed instructions on how to run the detection and tracking pipeline, including command-line arguments and configuration options, will be provided in the full documentation.

python run_pipeline.py --input_dir ./data/raw_sar_images --output_dir ./results --model_path ./models/yolov8_sardetect.pt

We welcome contributions to the SAR Ship Detection Project! Please see our CONTRIBUTING.md for guidelines on how to submit pull requests, report issues, and contribute to the development.

An end-to-end solution for robust ship detection and tracking in Synthetic Aperture Radar (SAR) imagery. Leverages deep learning (YOLOv8, DeepSort) to process Sentinel-1 data, designed for both ground-based and potential in-orbit edge computing applications (Jetson Nano). Supports maritime surveillance, safety, and illegal activity monitoring.

5. Training Protocol, Convergence Behavior & Experimental Evaluation

Ship-Detection-Using-Satellite-Imagery The aim of this project is to build a model using Deep Learning to automatically identify whether a remotely sensed target is a ship or not. Ship detection from remote sensing imagery is a crucial application for maritime security which includes traffic surveillance, protection against illegal fisheries, oil discharge control and sea pollution monitoring. Ship detection is typically done through the use of an Automated Identification System (AIS), which uses VHF radio frequencies to wirelessly broadcast the ship’s location, destination and identity to nearby receiver devices on other ships and land based systems. This is typically done through the use of an Automated Identification System (AIS). AIS are very effective at monitoring ships but fail to detect those which are not, and those which disconnect their transponder. Satellite imagery provides unique insights into various markets, including agriculture, defense and intelligence, energy, and finance. New commercial imagery providers, such as Planet, are using constellations of small satellites to capture images of the entire Earth every day. This flood of new imagery is outgrowing the ability for organizations to manually look at each image that gets captured, and there is a need for machine learning and computer vision algorithms to help automate the analysis process. The goal is to help address the difficult task of detecting the large ships in satellite images using deep learning model. Automating this process can be applied to many issues including monitoring port activity levels, monitoring illegal activities and supply chain analysis. Dataset The dataset can be obtained from the below link https://www.kaggle.com/rhammell/ships-in-satellite-imagery

The aim of this project is to build a model using Deep Learning to automatically identify whether a remotely sensed target is a ship or not. Ship detection from remote sensing imagery is a crucial application for maritime security which includes traffic surveillance, protection against illegal fisheries, oil discharge control and sea pollution monitoring. Ship detection is typically done through the use of an Automated Identification System (AIS), which uses VHF radio frequencies to wirelessly broadcast the ship’s location, destination and identity to nearby receiver devices on other ships and land based systems. This is typically done through the use of an Automated Identification System (AIS). AIS are very effective at monitoring ships but fail to detect those which are not, and those which disconnect their transponder. Satellite imagery provides unique insights into various markets, including agriculture, defense and intelligence, energy, and finance. New commercial imagery providers, such as Planet, are using constellations of small satellites to capture images of the entire Earth every day. This flood of new imagery is outgrowing the ability for organizations to manually look at each image that gets captured, and there is a need for machine learning and computer vision algorithms to help automate the analysis process. The goal is to help address the difficult task of detecting the large ships in satellite images using deep learning model. Automating this process can be applied to many issues including monitoring port activity levels, monitoring illegal activities and supply chain analysis.

The dataset can be obtained from the below link https://www.kaggle.com/rhammell/ships-in-satellite-imagery

The aim of this project is to build a model using Deep Learning to automatically identify whether a remotely sensed target is a ship or not.

ship-detection( https://www.kaggle.com/code/sarfealam/ship-detection ) Building a machine to detect ships using the satellite data This project implements a deep learning pipeline for ship detection in satellite images using image segmentation techniques. The goal is to identify ship regions in aerial imagery, which is useful for applications such as maritime surveillance, defense, port monitoring, and environmental protection. The work is inspired by the Airbus Ship Detection Challenge (Kaggle) dataset, but the methods are general and can be applied to similar remote sensing problems.

Building a machine to detect ships using the satellite data This project implements a deep learning pipeline for ship detection in satellite images using image segmentation techniques. The goal is to identify ship regions in aerial imagery, which is useful for applications such as maritime surveillance, defense, port monitoring, and environmental protection.

The work is inspired by the Airbus Ship Detection Challenge (Kaggle) dataset, but the methods are general and can be applied to similar remote sensing problems.

arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website.

Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them.