Built a real-time LPR system with YOLOv8, PaddleOCR, SORT, FastAPI, Streamlit, and Docker.

While working on training models for Side Scan Sonar data, I ran into a common challenge - finding labeled datasets. There are repositories with great sonar imagery, but most lack annotations. Furthermore, the existing annotation tools I found didn't quite fit what I needed for this type of data. To tackle this problem, I built a simple tool: YOLO Annotator It's a lightweight desktop app for manually labeling images in YOLO format. I originally designed it for this specific use-case (side-scan sonar imagery), but it works perfectly for any object detection dataset. Main features: - Interactive bounding box editing with visual handles - Multi-class annotation support with custom color-coded labels - Batch processing for efficiency - Smooth navigation built for large images - Keyboard shortcuts to speed up the workflow I'm sharing it as an open source tool in case you face similar challenges. Whether you're annotating sonar data, training detection models, or building your own datasets, hopefully this saves you some time! Available on GitHub with a Windows executable ready to use. Feel free to try it and share feedback! 🔗 GitHub Repo: [https://lnkd.in/dx9hs7s3] 🚢 Dataset Credit: [https://lnkd.in/dH5z-MsD] #SideScanSonar #ObjectDetection #YOLO #ComputerVision #Python #DataAnnotation

🚀 LeetCode Challenge Complete! Just solved "Ones and Zeroes" - a brilliant 0/1 knapsack problem with TWO constraints, showcasing optimization from 3D to 2D DP! 💡 Solution Approaches: Approach 1 - 3D Memoization (Top-Down): ✅ State: dp[index][m_remaining][n_remaining] ✅ For each string: take or skip decision ✅ Count ones and zeros for each string ✅ Memoize results to avoid recomputation ✅ Space: O(len × m × n) Approach 2 - 2D Space-Optimized (Bottom-Up): ✅ State: dp[m_used][n_used] = max strings ✅ Process each string sequentially ✅ Backward iteration prevents using same string multiple times! ✅ Space: O(m × n) ✨ The key insight: This is 0/1 knapsack with TWO constraints (m zeros, n ones). Approach 1 is intuitive with explicit take/skip decisions. Approach 2 optimizes space by processing strings one at a time and iterating BACKWARD through capacities (classic knapsack trick to ensure each item used at most once). Why backward iteration? Prevents overwriting values we still need in current iteration! Time: O(len × m × n) | Space: O(len × m × n) → O(m × n) #LeetCode #DynamicProgramming #CPlusPlus #Algorithms #SoftwareEngineering #ProblemSolving #Knapsack

🚀 Day 64 of #100dasChallenge 🚀 Problem: Sum Root to Leaf Numbers ✅ Runtime: 0 ms (Beats 100%) ✅ Memory: 8.54 MB (Beats 68%+) ✅ All 108 test cases passed successfully! Concepts Practiced: Tree traversal using Depth-First Search (DFS) Recursive backtracking logic Numerical accumulation from root to leaf paths Key Takeaway: This challenge reinforced how elegant recursion can be when navigating hierarchical structures like binary trees. DFS remains one of the most powerful tools for solving tree-based problems efficiently and cleanly. Every solved problem adds another leaf to the tree of knowledge! Onward to Day 65 — consistency is the real algorithm for success! #100DaysOfLeetCode #Day64 #CProgramming #ProblemSolving #DepthFirstSearch #Recursion #LeetCode #DataStructures #Algorithms #DeveloperJourney #Consistency #KeepCoding

🚀 Daily DSA Progress: Solved Stock Span Problem! Just implemented the Stock Span Problem using Stack data structure - a classic example of how stacks can efficiently solve problems that seem complex at first glance. Key takeaways: Used stack to track previous greater elements in O(n) time complexity Learned how to optimize from brute force O(n²) to efficient stack-based solution Practical application of monotonic stack pattern This problem is a great reminder that understanding fundamental data structures helps solve real-world algorithmic challenges efficiently. #DataStructures #Algorithms #ProblemSolving #CodingJourney #Stack #DSA #Programming #TechInterviews

💡 Discover the Tidy3D Web Notebook Function — Power, Flexibility, and Simplicity Combined Step into the world of photonics simulation with the Flexcompute Python Notebook, your gateway to high-performance computing through an intuitive, web-based Python interface. No installation. No setup. Just open your browser and start creating. The Python Notebook always runs the latest version of Tidy3D, giving you instant access to cutting-edge EM simulation tools — anytime, anywhere. Whether you’re a student exploring computational photonics or a professional accelerating real-world designs, you can: ✅ Start fast with built-in Tidy3D examples or upload your own Python projects. ✅ AI-powered helper can help you quickly learn from examples, set up your own simulation, and analyze the results. ✅ Code confidently using the integrated debugger and smart editing environment. ✅ Switch between Python and GUI interfaces to verify simulation setups and results. Experience a seamless blend of Python flexibility and cloud power — and bring your photonic simulations to success with Tidy3D. Start from here 👉 Sign up for a Tidy3D free trial https://lnkd.in/gckDd_er. #PhotonicSimulation #FDTD #GUI #AIHelper #PythonNotebook #Cloud

💥 Why I Stopped Using pip for Deployment — and Moved to uv A few weeks ago, I was deploying a ML project. Everything worked perfectly on my local system… until deployment. 😅 Then came the classic Python pain: pip install -r requirements.txt took forever ⏳ Random dependency conflicts popped up 🤯 The build worked on my laptop but broke in production 💥 I realized — it wasn’t the model’s fault… It was my tooling. That’s when I discovered uv, a modern Python package manager written in Rust. And honestly — it felt like upgrading from a cycle to a supercar. 🏎️ Here’s what made me switch 👇 ⚡ 1. Speed Installation time dropped from minutes to seconds — uv is built in Rust and supports parallel downloads. 🧩 2. Smart Dependency Management No more version conflicts — uv automatically resolves dependencies like Poetry but with pip simplicity. 🧱 3. Reproducible Builds Every deployment now runs on the exact same environment — no more “it works on my machine” nightmares. 🧰 4. One Tool, Many Tasks uv isn’t just an installer — it also handles environments, dependency locking, and project initialization. 💡 If you’ve faced slow builds or broken deployments, give uv a try: pip install uv uv init uv pip install -r requirements.txt Once you experience the speed and stability, it’s hard to go back. Python development finally feels… modern. 🐍✨ #Python #uv #Rust #DataScience #MLOps #Developers #OpenSource #Productivity #pip #Deployment

🚀 Building Hasoub’s Annual Conference Automated poster Generator. I wanted to share about a simple yet powerful automation that became part of Hasoub’s Annual Conference 2025 experience. helping generate personalized visuals for nearly 10% of all conference guests 🎉 Using FastAPI, n8n, and the Hasoub App, I built a fully automated workflow that: 1️⃣ Receives guest name, photo, and email 2️⃣ Generates a personalized image using a custom Python backend 3️⃣ Sends the result directly to the guest’s inbox — all within seconds This system saved hours of manual work and added a creative digital touch to the conference. You can explore the full process in the attached PDF 📘 Hasoub #Automation #n8n #FastAPI #Hasoub #TechInnovation #DigitalTransformation #CommunityTech

Recently while learning Rust, I needed shared mutable storage across async tasks. I started with: type Storage = Arc<Mutex<HashMap<String, (String, Option<Instant>)>>>; #[tokio::main(flavor = "current_thread")] async fn main() { // ... tokio::spawn(async move { ... }) } But kept hitting compiler error. That’s when I learned that: Arc<…> = A thread-safe reference-counting pointer Rc<…> = A single-threaded reference-counting pointer The solution? Switch to `Rc<RefCell<...>>` and use `tokio::task::spawn_local` within a `LocalSet`. #Rust #SystemsProgramming #AsyncProgramming

🚀Day 68 of #100daysChallenge 🚀 Today’s challenge was about reconstructing a Binary Tree using Preorder and Inorder traversal sequences — a classic tree construction problem that strengthens recursion and traversal logic. Concepts Covered: Recursive Tree Building Understanding traversal order (Preorder vs Inorder) Memory allocation in C for dynamic tree structures ✅ Runtime: 8 ms – Beats 37.85% ✅Memory: 14.39 MB – Beats 47.24% ✅All 203 test cases passed successfully! Key Insight: The preorder array helps identify the root, while the inorder array defines the left and right subtrees — combining both gives a clear recursive construction path. #100DaysOfLeetCode #Day68 #BinaryTree #PreorderTraversal #InorderTraversal #CProgramming #DataStructures #Algorithms #ProblemSolving #KeepLearning #LeetCode

Built a small real-time flight monitoring pipeline project using the OpenSky Network API. - Ingests raw flight states every few seconds and writes them as-is to a Bronze Delta table. - Spark Structured Streaming reads from Bronze, drops bad rows, dedupes on ICAO + timestamp, adds ingestion time, and lands cleaned data in Silver (checkpoints preserved). - A 5-minute batch job enriches Silver with horizontal speed, UTC fields, phase/altitude/speed flags, and hourly aggregates by origin country, then writes to Gold. - Three Airflow DAGs keep everything alive: one runs the ingestion loop, one watches the streaming query, and one triggers the batch job. Each DAG checks its own process and restarts it if needed. - Schemas are versioned in DDL files, config lives in `config.yaml`, and a few small utils handle Spark sessions, Delta writes, and query health. It was a learning exercise, not production-grade, but the whole thing runs locally without manual babysitting. GitHub Repo: https://lnkd.in/gmdzegN7 Any pointers on keeping long-running Spark streams stable or better ways to supervise Airflow-managed processes are welcome. #DataEngineering #Spark #Airflow #DeltaLake #PySpark #Python