Hackathon Problem Statement: Cloud-Native Application Load Balancer on OpenStack

**Background **

In cloud computing environments, the ability to efficiently distribute incoming network traffic across multiple servers is crucial for ensuring high availability, reliability, and scalability of applications. Application Load Balancers (ALBs) play a vital role in managing this traffic, intelligently routing requests based on various factors such as server health, request type, and geographical location. While several cloud platforms offer built-in load balancing solutions, there is a growing need for custom, cloud-native load balancers that can be tailored to specific operational requirements. 

Challenge

Develop a cloud-native Application Load Balancer (ALB) on the OpenStack platform with features of dynamic traffic distribution, High Availability, fault tolerance and health monitoring. 

Objectives

The ALB should be capable of dynamically distributing incoming traffic across a pool of backend servers, ensuring high availability and fault tolerance with following features:-

• Traffic Distribution: Implement a robust algorithm to distribute incoming requests across multiple backend servers, optimizing for load, latency, and server health.
• Health Monitoring: Develop a health monitoring system that continuously checks the status of backend servers, automatically rerouting traffic away from unhealthy instances.
• Scalability: Ensure that the ALB can automatically scale up or down based on traffic load, maintaining performance and minimizing resource usage.

Deliverables:

• Application Load Balancer Implementation: A fully functional ALB deployed on OpenStack, capable of handling real-world traffic scenarios.
• User Interface or API: A user-friendly interface or API that allows administrators to configure backend pools, routing rules, SSL certificates, and monitoring settings.
• Technical Documentation: A detailed report outlining the architecture, algorithms used, configuration options, and deployment instructions for the ALB.
• Performance Metrics: An analysis of the ALB's performance, including load distribution efficiency, response times, and fault tolerance under different traffic conditions.
• Demo Video: A video demonstrating the ALB in action, showing how it handles traffic distribution, health monitoring, and routing configurations.

Judging Criteria:

• Completeness: The extent to which the ALB meets the core objectives of traffic distribution, health monitoring, and scalability.
• Innovation: The creativity and effectiveness of the routing algorithms, health monitoring techniques, and any additional features implemented.
• Documentation: The clarity, thoroughness, and practicality of the technical documentation provided.
• Performance: The efficiency and scalability of the ALB, including its ability to handle high traffic volumes and adapt to changing conditions.

Bonus Achievements: Any additional features or enhancements, such as advanced routing options or multi-region support, that demonstrate advanced problem-solving and innovation.

1. Problem Statement 2 - Drone Swarm Coordination - https://docs.google.com/document/d/1YJ9aowKRq2dsFdSICJJ9Pi917qoGUG6eSuK6s6jKaNM/edit?usp=sharing

Problem Statement: Decentralised AI based Drone Swarm Coordination System

Challenge:

Create a decentralised AI system to coordinate a swarm of autonomous drones for reconnaissance and surveillance missions. The system should optimize the drones’ flight paths, distribute tasks efficiently and maintain communication even in contested environments. 

Objectives:

• Implement swarm intelligence algorithms for coordinated movement and task allocation
• Develop a robust communication protocol that works in low bandwidth or intermittent connectivity scenarios
• Create a simulation environment to test and visualise swarm behaviour
• Implement adaptive mission planning based on real-time data and changing objectives

Deliverables:

• Codebase: A working implementation of the swarm intelligence algorithm the communication protocol. The code should be well-documented and capable of running on typical hardware.

• Technical Documentation: Detailed documentation explaining the methodology, algorithms used, and the steps taken to achieve swarm intelligence including the communication protocol.

• Simulation environment: The simulation environment used to test and visualise swarm behaviour.

• Performance Metrics: Quantitative analysis showing the accuracy, robustness, and computational efficiency of the algorithm across different test scenarios.

Judging Criteria:

Submissions will be evaluated based on the following:

• Accuracy: The precision of the algorithm in undertaking coordinated movement and task allocation.
• Robustness: The algorithm’s ability to handle varying conditions
• Performance: Real-time processing capability o
• Innovation: Novelty and creativity in the approach taken to solve the problem.
• Documentation: Clarity and thoroughness of the technical documentation.
• Impact: Potential applications of the developed solution in real-world autonomous systems.

Tools and Technologies:

• Swarm Algorithms – e.g. Particle Swarm Optimization
• Mesh networking Protocols
• 3D visualisation Tools – e.g. Unity, Unreal Engine
• AI planning libraries – e.g. PDDL

1. Dataset - Maritime Situational Awareness - https://docs.google.com/document/d/1pfsv-84ljrJ-4GDLliLnu6X05dIrm9FSXLan6nZAQCI/edit?usp=sharing

Problem Statement: Textual Intelligence for Maritime Situational Awareness

Challenge:

Develop a software solution that uses OCR (Optical Character Recognition) combined with Retrieval-Augmented Generation (RAG) to scan and analyse textual maritime reports (such as surveillance logs, reconnaissance notes or communication messages) and extract details about potential contacts (ships, submarines, aircraft or other entities). The software should then plot these identified contacts on a radar/map interface to provide naval personnel with real-time situational awareness.

Objectives:

• Text Extraction.     Use OCR to scan handwritten or printed reports, extracting relevant information about geographical coordinates, headings, speeds and types of vessels or objects detected.

• RAG for Information Retrieval.     Implement an API based RAG model that intelligently extracts and structures information such as locations, time of sighting and object descriptions from the scanned text. It should cross-reference the reports with existing databases or contextual information (e.g. previous sightings or known entities).

• Contact Mapping.   Use the extracted data to plot contacts (ships, submarines, aircraft or other objects) on a radar-style or map-based interface. The map should update dynamically as new reports are scanned and processed.

• User Interface.     Develop a user-friendly interface that displays the radar/map, allowing naval officers to see the plotted contacts with additional metadata (e.g. speed, direction, type of vessel, time of report).

• Automated Alerts.     If potential threats are identified (e.g. an unidentified object or a vessel in restricted waters), the system should trigger alerts for naval operators.

Bonus Features

• Historical Report Integration.     Allow users to scan historical reports and compare movements of the same contact over time to predict future behavior.

• Speech-to-Text.   Extend the software to transcribe spoken reports into text (e.g. from radio communications) and process them in a similar manner.

Deliverables:

• Codebase: A working implementation of the solution iro problem statement. The code should be well-documented and capable of running on typical hardware.

• Technical Documentation: Detailed documentation explaining the methodology, algorithms used, and the steps taken to achieve the solution.

• Performance Metrics: Quantitative analysis showing the accuracy, robustness, and computational efficiency of the solution different test scenarios.

Judging Criteria

• Expected features

• Text Parsing.     The software should intelligently parse sentences like "At 05.30 UTC, an unidentified vessel was sighted at latitude 12.34 N, longitude 45.67 E, moving at 12 knots towards the northeast."

• Real-time Updating.  As new reports are scanned and processed, the system updates the radar/map interface in real-time, showing the latest positions and statuses of the identified contacts. It should update a contact position if previously reported.

• Visualization.    The plotted contacts should include details like type (e.g. cargo ship, patrol boat), current location, direction, time of detection, MLA and speed. It should offer options to zoom in/out and filter based on threat level or type of object.

• Accuracy

• Performance

• Documentation: Clarity and thoroughness of the technical documentation.

Tools/Tech Stack

• OCR.  Tesseract OCR or equivalent offline toll to convert printed/handwritten reports into digital text.
• RAG.     Hugging Face's RAG model (or similar) to retrieve relevant context from the extracted text and generate structured data (such as coordinates, speed, and vessel type).
• Map Visualization.     Leaflet.js or equivalent software to create the map interface, D3.js for radar visualization.
• Backend.      Python (Flask/Django), FastAPI for API creation.

Database can be accessed from above link contains Offline storage of historical data and report entries.

Hackathon Problem Statement: Sub-Pixel Precision Optical Flow Tracker for Autonomous Navigation and Flying Object Tracking in Dynamic Environments

Background:

In autonomous systems, such as drones and self-driving vehicles, accurate motion detection and tracking are essential for navigating dynamic environments and avoiding obstacles. Additionally, tracking flying objects (e.g., birds, other drones, UAVs) in real-time is crucial for collision avoidance and situational awareness. Optical flow is a key computer vision technique used to estimate the motion of objects and surfaces between consecutive image frames. Achieving high precision at a sub-pixel level is challenging but vital for real-time tracking and navigation.

Challenge:

Develop an optical flow tracking algorithm capable of achieving sub-pixel accuracy for enhanced navigation and real-time tracking of flying objects in dynamic environments. The solution should be robust to varying lighting conditions, rapid movements, and complex textures, and must operate efficiently on resource-constrained hardware such as drones or embedded systems.

Objectives:

• Develop a Real-Time Optical Flow Algorithm: Create an optical flow tracker that can process video frames in real-time with high accuracy for both navigation and tracking flying objects.

• Achieve Sub-Pixel Precision: Implement techniques to refine the optical flow vectors to sub-pixel accuracy, enabling precise motion estimation and tracking.

• Flying Object Detection and Tracking: Integrate object detection algorithms with the optical flow tracker to detect and track flying objects, ensuring that the system can handle rapid and unpredictable movements.

• Robustness in Dynamic Environments: Ensure that the algorithm can handle scenarios with rapid movements, varying light conditions, and complex textures.

• Resource Efficiency: Optimize the solution to run efficiently on resource-constrained hardware, such as drones or embedded systems, without sacrificing performance.

• Evaluation and Testing: Demonstrate the effectiveness of the algorithm through a series of predefined tests, including synthetic and real-world datasets that simulate dynamic environments and flying objects.

Deliverables:

• Code Implementation: A fully functional optical flow tracker with sub-pixel accuracy, capable of detecting and tracking flying objects in real-time.

• Technical Documentation: Detailed documentation explaining the methodology, algorithms used, and the steps taken to achieve sub-pixel accuracy and robust object tracking.

• Performance Metrics: Quantitative analysis showing the accuracy, robustness, and computational efficiency of the tracker across different test scenarios, particularly focusing on flying object tracking.

• Demo Video (optopnal): A short video demonstrating the tracker in action, highlighting its real-time performance in both navigation and flying object tracking.

Judging Criteria:

• Accuracy: The precision of the optical flow vectors, particularly at sub-pixel levels, and the accuracy of flying object detection and tracking.

• Robustness: The algorithm’s ability to handle varying conditions, including rapid and unpredictable movements of flying objects and lighting condition.

• Performance: Real-time processing capability on resource-constrained hardware.

• Innovation: Novelty and creativity in the approach taken to solve the problem, especially in flying object tracking.

• Documentation: Clarity and thoroughness of the technical documentation.

• Impact: Potential applications of the developed solution in real-world autonomous systems and scenarios involving tracking flying objects.

Tools and Technologies:

• Programming Languages: Python, C++, etc.

• Libraries: OpenCV, PyTorch/TensorFlow (for machine learning enhancements), CUDA (for GPU acceleration), YOLO (for object detection).

• Hardware: Raspberry Pi, NVIDIA Jetson, or any other resource-constrained embedded system.

• Datasets: KITTI, Middlebury, or custom datasets for flying object tracking.

Problem Statement: Speech Separation from a Group of Four to Seven People with Background Noise Removal

Background:

In environments like meetings, conferences, or social gatherings, multiple people often speak at the same time, making it difficult to isolate individual voices. 

Challenge:

The challenge is to develop an AI/ML-based solution that can separate and identify speech from 4 to 7 people who are speaking simultaneously or concurrently, while also removing background noise. 

Objectives:

Your solution should:

• Effectively separate voices even when multiple people are speaking at the same time.
• Accurately identify each speaker’s voice.
• Suppress background noise without degrading the quality of the speech.

This system should be robust enough to handle real-world noisy environments and provide clear and distinct voice outputs for each speaker.

Deliverables:

• Codebase: A working implementation of the speech separation algorithm. The code should be well-documented and capable of running on typical hardware.

• Model: A trained model (if using ML/DL techniques) that can handle simultaneous speech separation in real-time or near-real-time, with instructions on how to use it.

• Documentation: Clear and concise documentation explaining:

• The approach taken to separate simultaneously speaking voices.

• How background noise was removed while preserving voice quality.

• Challenges faced and how they were overcome.

• Demo: A short video or audio demo showing how the system successfully separates speakers who are speaking at the same time, and how it removes background noise.

3. Judging Criteria:

Submissions will be evaluated based on the following:

• Simultaneous Speaker Separation Accuracy: How well does the solution separate voices when multiple people are speaking concurrently? This is the most important criterion.

• Speaker Identification: Correct identification of each speaker.

• Noise Suppression: Effectiveness in removing background noise without distorting the speakers' voices.

• Scalability: The solution’s ability to handle different numbers of speakers (between 4 and 7) and varying background noise conditions.

• Real-time Performance: Whether the system can work in real-time or near-real-time, making it practical for real-world applications.

• Innovation: Creativity and uniqueness in the approach to speech separation and noise reduction.

• Usability: How easy the solution is to use, including clear instructions and user-friendly interfaces.

• Efficiency: Computational and energy efficiency.

Tools and Technologies:

• Programming Languages: Python, C++, etc.
• Libraries: PyTorch/TensorFlow (for machine learning enhancements), CUDA (for GPU acceleration).
• Datasets: Any Custom/ opensource datasets