Built a COVID-19 data dashboard with Streamlit and Kaggle

📚🌃 Continuing my dive into data structures and algorithms. 🙂 🃏↪️🃏Tonight’s focus: Chapter 23: Insertion Sort Insertion Sort is like organizing cards 🃏 in your hand one at a time, you compare and place each card in its correct spot. ⚙️ How Insertion Sort Works -Start with the second item in the list (the first item is considered sorted). -Mark it as the active item. 📌 -Compare the active item to the items on its left (aka the sorted region). -Keep shifting left until you find a value smaller than the active item, then insert it to the right. -Repeat for each item in the unsorted region, reassigning the active item 📌 each time. ✅ Key Notes -Follows a “look left” approach: each new active item 📌 is compared to those before it, one by one, moving toward the first index, until it finds a value that is less than itself. ⚡ Performance -Time: O(n²) in the average and worst case. Best case (already sorted): O(n). -Space: Uses constant memory, no extra space needed. -Not ideal for large datasets, but useful when memory is limited, the list is mostly sorted. -Ok for small data sets. If you're learning too, or just love a good emoji-powered breakdown, follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes

Hey everyone! 👋 I built a Machine Learning model to predict customer risk and used Streamlit to create a simple web app. Now you can enter customer details and see if they’re High Risk or Low Risk. Here’s what I did step by step: 1️⃣ Data Cleaning & Checks Removed duplicates, null values, and outliers Checked target distribution to handle class imbalance 2️⃣ Exploratory Data Analysis (EDA) Visualized the data using Matplotlib & Seaborn Used histograms, boxplots, countplots, heatmaps, scatterplots, violin plots, and barplots 3️⃣ Handling Categorical Data Used Label Encoding for categorical columns Saved encoders as pickle files to reuse in the app 4️⃣ Model Training Tried DecisionTree, RandomForest, ExtraTrees, and XGBoost Built a function with GridSearchCV to tune hyperparameters and measure accuracy Chose XGBoost because it gave the best results 5️⃣ Streamlit App Loaded the trained model and encoders Designed input fields using number_input and selectbox Converted user inputs into a DataFrame and applied the same encodings Predicted and displayed High Risk / Low Risk instantly Try the live app here: https://lnkd.in/gkU6ZQpk Check the code on GitHub: Jupyter Notebook for model training: https://lnkd.in/gYzgucRX Streamlit app code: https://lnkd.in/gGRC2ZPY Shout-out to Onur Baltacı for the tutorial that inspired me: https://lnkd.in/gtgmeZCZ #MachineLearning #DataScience #Python #XGBoost #Streamlit #MLProject #Deployment #GitHub

🚀 DSA Challenge – Day 93 Problem: Find Median from Data Stream 📊⚙️ This was an exciting deep dive into data structures and real-time computation — maintaining the median efficiently while continuously adding numbers from a stream. 🧠 Problem Summary: You need to design a class MedianFinder that can: ✅ Add numbers dynamically from a data stream. ✅ Return the median at any point in time. If the total number of elements is even → median = mean of the two middle values. If odd → median = middle value. ⚙️ My Approach: 1️⃣ Use two heaps to maintain balance: A max heap (maxHeap) for the smaller half of numbers. A min heap (minHeap) for the larger half. 2️⃣ Whenever a new number arrives: Push it into the maxHeap (inverted to simulate max behavior). Balance both heaps so that their size difference is never more than 1. 3️⃣ Ensure heap order: the maximum in maxHeap ≤ minimum in minHeap. 4️⃣ The median is: The top of the larger heap (if odd count). The average of both tops (if even count). 📈 Complexity: Time: O(log n) → For insertion and heap balancing. Space: O(n) → To store all elements in heaps. ✨ Key Takeaway: This problem highlights how heaps can turn complex real-time median calculations into a smooth, efficient process — a great example of data structure synergy in action. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Heaps #PriorityQueue #DataStructures #Algorithms #Median #Python #CodingChallenge #InterviewPrep #EfficientCode #DynamicProgramming #TechCommunity #LearningByBuilding #CodeEveryday

📚🌃 Continuing my dive into data structures and algorithms. 🙂 📌➗ Tonight’s focus: Chapter 21 – Quicksort Quick Recap: Quicksort is one of the fastest sorting algorithms. It’s popular because it handles large datasets efficiently using a divide-and-conquer strategy. ⚙️ How Quicksort Works -Pick a 📌 pivot element from the array -Partition the array so that: -Elements less than the pivot go to the left -Elements greater than the pivot go to the right -Recursively apply the same logic to the left and right subarrays -Repeat until all regions are sorted ✅ Key Notes -The 📌 pivot element acts as a center point, elements are thrown left or right based on comparison -Once all values around a pivot are placed, that pivot is considered sorted -Choosing a good pivot is crucial since poor choices can lead to performance issues -Not stable meaning it doesn’t guarantee that equal elements will stay in their original order after sorting ⚡ Performance -Best/Average Case: O(n log n) - when partitions are balanced -Worst Case: O(n²) - when partitions are highly unbalanced (for example already sorted data) -To avoid worst-case scenarios, it's recommended to shuffle the array before sorting -Space Complexity: O(log n) 🌍 Real-World Use -Most programming languages have their own built-in and optimized version of Quicksort -You likely won’t need to implement it from scratch unless you're working with custom data structures If you're learning too, or just love a good emoji-powered breakdown, follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes

🚀 DSA Challenge – Day 94 Problem: Design LRU (Least Recently Used) Cache ⚡📦 This was one of those classic data structure design problems that truly tests your understanding of hash maps and linked lists working together seamlessly for O(1) performance! 🧠 Problem Summary: Implement a data structure that behaves like an LRU Cache, supporting: ✅ get(key) → Retrieve value in O(1). ✅ put(key, value) → Insert/update value in O(1). ✅ Automatically evict the least recently used key when capacity is exceeded. ⚙️ My Approach: To achieve O(1) operations, I combined two powerful structures: 1️⃣ HashMap (keyMap) → For constant-time key lookups. 2️⃣ Doubly Linked List → To maintain the order of usage (most recent at the front). 🔹 When a key is accessed or updated: Move it to the front (most recent). 🔹 When inserting a new key: If full → remove the least recently used node (from the tail). Insert the new key-value pair at the front. The linked list allows O(1) addition/removal, and the hashmap ensures O(1) lookup and update. 📈 Complexity: Time: O(1) → For both get and put. Space: O(capacity) → For the hashmap and list nodes. ✨ Key Takeaway: This problem elegantly demonstrates how data structures complement each other — the linked list maintains order, and the hashmap ensures constant-time access. A perfect synergy of logic and structure! ⚙️💡 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #LRUCache #DataStructures #HashMap #LinkedList #Python #Algorithms #SystemDesign #CodingChallenge #EfficientCode #InterviewPrep #TechCommunity #CodeEveryday #LearningByBuilding

📚🌃 Continuing my dive into data structures and algorithms. 🙂 🔍 Tonight’s focus: Chapter 24: Selection Sort ⚙️ How Selection Sort Works -Assume the first item is the smallest. -Scan the entire list to find the actual smallest item. 🔎 -Swap it with the first item and add it to the sorted region. -Move to the next unsorted item and repeat: ----Assume it's the smallest. ----Compare it with the rest of the unsorted region. ----Swap the new smallest into place in the sorted region. -Continue until all items are sorted! ✅ Key Notes -Splits the list into a sorted region (usually at the front) and an unsorted region. -Swaps each new smallest item into place, expanding the sorted region one item at a time. -Simple to understand and implement, but not very efficient. ⚡ Performance -Time: O(n²) -Space: The items sort in their place, so memory usage is minimal. -Not ideal for large datasets. -Slightly less practical than Insertion Sort, but still a good learning tool. 💻 Implementation Tips -Outer loop (i): tracks the boundary between sorted and unsorted. -Inner loop (j): finds the smallest item in the unsorted region. -Swap smallest item with the first unsorted item. If you're learning too, or just love a good emoji-powered breakdown, follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes

The MMM ecosystem keeps evolving, but not all models are built alike. Some can be run in seconds by anyone with basic R or Python skills. Others require deep statistical expertise and serious data-engineering resources.   I’ve outlined five levels of MMM maturity, ranging from quick diagnostic regressions to full “superlearner” meta-models. Each level comes with trade-offs between flexibility, interpretability, implementation effort and cost efficiency (in terms of computing time and overhead).   Level 1  Basic open-source MMM Examples: Simple adstock regression, ARDL via R / Python / Stata etc   Level 2 Advanced open-source MMM Examples: Robyn, PyMC-Marketing, Meridian   Level 3 Open-source MMM ensemble Weighted stacked ensemble of basic and advanced open-source models Example: Robyn + PyMC-Marketing + ARDL   Level 4 Custom models Examples: time-varying coefficients, random walk, structural VAR models via Stan, PyMC, TensorFlow Probability   Level 5: Superlearner MMM Stacked meta-model combining multiple models from any of the above levels   When is the right time for the next level?   👉 Read the full breakdown on marketingscience.today

This is a very nice articulation. Not sure I agree with the precise laddering (I might swap levels 3 and 4, or mix them differently) but .... still nice. What it misses is that "MMM maturity" is about much more than the technical/structural form of the model. All of these levels of MMM maturity are about the structural form of the regression system. There's another swim lane for EDA, and investing in data acquisition (for example, getting an accurate read on competitive behavior). Improving your data is an important part of a mature MMM. And there's another swim lane on model alignment (if you're a mobile app, you're probably using an MMP. And you might be using interrupted time series as well. Tooling to effectively use all your sources of truth is important). And there's another swim lane on validation and incrementality. And there's another swim lane for effective forecasting tools. And there's another swim lane for ....

📚🌃 Continuing my dive into data structures and algorithms. 🙂 🫧 🔁 🫧 Tonight’s focus: Chapter 22: Bubble Sort ❌ Bubble Sort is one of the simplest sorting algorithms, but also one of the most inefficient. It’s often taught not because it’s fast, but to help you recognize and avoid sluggish 🐌 sorting patterns in your own code. ⚙️ How Bubble Sort Works -Start at the beginning of the list. -Compare each pair of adjacent elements. -If the first is greater than the second, swap them. -Move one step forward and repeat the comparison. -Once you reach the end, go back to the beginning and repeat the process. -Continue this cycle until all items are sorted. -When it runs a full pass with no swaps, the list is officially sorted. ✅ Key Notes -Its best-case scenario is a sorted list, ironically, the one time you don’t need a sort. -It’s slowest when the list is in reverse order because every element needs to be moved. ⚡🐢🐌 Performance -Time complexity: Worst and average case is O(n²). -Even small lists can take many steps, sorting 4 numbers might involve 8+ steps. -Requires multiple passes through the list. It will still pass through elements that have already been sorted, so it’s inefficient for large datasets. If you're learning too, or just love a good emoji-powered breakdown, follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes

📚🌃 Continuing my dive into data structures and algorithms. 🙂 🌳 Tonight’s Focus: Chapter 19 – Binary Tree Traversal In linear structures like arrays or linked lists, we move step-by-step: 0️⃣ ➡️ 1️⃣ ➡️ 2️⃣ ➡️ 3️⃣ But trees are hierarchical 🌳, so we use a different approach: Breadth-First 🔺 and Depth-First 🐋 Traversal ✅ FYI -Tree depth helps us understand how far a node is from the root -The goal is to visit every node and represent the full structure ⚙️ Traversal Basics Each node goes through two phases: Discovered Collection – We identify a node (starting from the root) and add it to this list as soon as it's found. Explored Collection – After a node is discovered, we examine its children. Once all its children have been discovered, we move the node to this list. 🔺 Breadth-First Traversal -Uses a queue (First In, First Out) -Visits nodes level by level, left to right, moving nodes from the discovered to explored collection as they are processed -Example order: A → B → C → D → E… 🐋 Depth-First Traversal -Uses a stack (Last In, First Out) -Nodes are discovered by traversing deep down the left-most path, then backtracked to the nearest unexplored node. During processing, nodes are moved from the discovered collection to the explored collection. ⚡ Performance Time: O(n) Space: O(n) Same across best, average, and worst cases 📚 Might just do half a chapter for the more involved chapters next. If you’re learning too (or just love emoji-powered breakdowns), follow along for more chapters in this series! 🚀 #JavaScript #Algorithms #Coding #DevNotes