DEV Community: Mohd Uwaish

FairSample: Because Class Overlap Is Harder Than Class Imbalance

Mohd Uwaish — Tue, 10 Feb 2026 21:06:58 +0000

The Overlooked Problem in Classification

Everyone talks about class imbalance. But there's a more insidious problem lurking in your data: class overlap.

Santos et al. argue that class overlap is a more significant impediment to classifier performance than imbalance alone. Yet most practitioners don't have tools to diagnose or address it.

During my research on overlap-handling techniques, I investigated how different methods affect global structural complexity. The findings led me to build FairSample—a package specifically designed for the class overlap problem.

What Is Class Overlap?

Class overlap occurs when instances from different classes share similar feature values. Your classifier sees:

Instance A: [feature1=5.2, feature2=3.1, feature3=1.4] → Class 0
Instance B: [feature1=5.1, feature2=3.2, feature3=1.3] → Class 1

These look almost identical, but belong to different classes. This confuses classifiers and degrades performance—even when your classes are perfectly balanced.

Why Overlap Is Harder Than Imbalance

Imbalance: You have 100 instances of Class A, 10 of Class B

Solution: Sample to balance the ratio
Outcome: Classifier sees both classes equally

Overlap: Classes share the same feature space

Solution: Not straightforward—you're changing data structure
Outcome: Depends on how you handle it

This is why overlap requires more sophisticated analysis.

FairSample's Approach

1. Quantify Overlap First

Before fixing anything, measure the problem:

from fairsample.complexity import ComplexityMeasures

cm = ComplexityMeasures(X, y)

# Get comprehensive overlap analysis
all_measures = cm.get_all_complexity_measures(measures='all')

# Focus on instance overlap
instance_overlap = cm.get_all_complexity_measures(
    measures=['N3', 'N4', 'kDN', 'CM']
)

# Structural complexity
structural = cm.get_all_complexity_measures(
    measures=['T1', 'LSC', 'DBC']
)

Why this matters: Different overlap patterns require different solutions.

2. 14+ Overlap-Handling Techniques

FairSample implements algorithms specifically designed for overlap:

EHSO - Evolutionary Hybrid Sampling in Overlap
RFCL - Repetitive Forward Class Learning
NBUS - Neighbourhood-Based Undersampling
URNS - Undersampling by Removing Noisy Samples
SVDDWSMOTE - Support Vector Data Description-based oversampling
OSM - Overlap-based Sampling Method
And more...

All from peer-reviewed research (2014-2024).

3. Multi-Dimensional Evaluation

Evaluate how techniques affect your overlap:

from fairsample.utils import compare_techniques

# Compare multiple overlap-handling techniques
results = compare_techniques(
    X, y,
    techniques=['RFCL', 'EHSO', 'NBUS'],
    complexity_measures='basic'
)

# See impact on overlap metrics
print(results[['technique', 'N3', 'T1', 'training_time']])

4. Before/After Validation

Verify that overlap actually reduced:

from fairsample import EHSO
from fairsample.complexity import compare_pre_post_overlap

# Apply overlap-handling technique
sampler = EHSO(random_state=42)
X_resampled, y_resampled = sampler.fit_resample(X, y)

# Measure structural changes
comparison = compare_pre_post_overlap(X, y, X_resampled, y_resampled)
print("Overlap Reduction:")
print(comparison['improvements'])

Research Insights Applied

My research investigated how overlap-handling techniques affect data structure. Key insights:

Insight 1: Reducing overlap doesn't always improve classification

Some techniques reduce overlap but fragment class structure
Always validate with classification metrics

Insight 2: Different techniques, different structural effects

Some improve instance overlap but worsen structural complexity
Others balance both
Trade-offs vary by dataset

Insight 3: Context matters

No universal solution exists
Measure your specific overlap profile first

These insights shaped FairSample's design—diagnostic tools before treatment.

Practical Example: Medical Diagnosis

from fairsample import RFCL
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Dataset with overlapping symptoms
# Different diseases, similar presentations

# Step 1: Quantify overlap
from fairsample.complexity import ComplexityMeasures
cm = ComplexityMeasures(X_train, y_train)
print(f"Instance Overlap (N3): {cm.analyze_overlap()['N3']:.4f}")

# Step 2: Handle overlap
sampler = RFCL(random_state=42)
X_resampled, y_resampled = sampler.fit_resample(X_train, y_train)

# Step 3: Train classifier
clf = RandomForestClassifier()
clf.fit(X_resampled, y_resampled)

# Step 4: Evaluate
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))

40+ Complexity Measures

FairSample provides comprehensive overlap quantification:

Feature Overlap:

F1, F1v, F2, F3, F4 - How much features discriminate between classes

Instance Overlap:

N3, N4, kDN, CM, R-value - How much instances overlap in feature space

Structural Complexity:

T1, LSC, DBC - How complex the decision boundary needs to be

Multiresolution:

Purity, MRCA, C1, C2 - Multi-scale overlap analysis

Each reveals different aspects of your overlap problem.

Installation & Quick Start

pip install fairsample

Complete workflow:

from fairsample import EHSO
from fairsample.complexity import ComplexityMeasures
import pandas as pd

# Load data with class overlap
df = pd.read_csv('overlapping_data.csv')
X = df.drop('target', axis=1)
y = df['target']

# Diagnose overlap
cm = ComplexityMeasures(X, y)
print("Overlap Analysis:")
print(f"  Instance Overlap (N3): {cm.analyze_overlap()['N3']:.4f}")

# Handle overlap
sampler = EHSO(random_state=42)
X_resampled, y_resampled = sampler.fit_resample(X, y)

# Validate reduction
from fairsample.complexity import compare_pre_post_overlap
comparison = compare_pre_post_overlap(X, y, X_resampled, y_resampled)
print("\nOverlap Reduction:")
print(comparison['improvements'])

# Use in classification
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier()
clf.fit(X_resampled, y_resampled)

When Overlap Matters Most

Class overlap is particularly problematic in:

Domain	Why Overlap Occurs
Medical Diagnosis	Overlapping symptoms between diseases
Fraud Detection	Fraudsters mimic legitimate behavior
Software Defect Prediction	Similar code metrics for faulty/non-faulty modules
Network Intrusion	Attacks disguised as normal traffic
Image Classification	Visually similar objects in different categories

In these domains, addressing overlap is crucial for performance.

Overlap vs. Imbalance: A Comparison

# Scenario 1: Only Imbalance (No Overlap)
# Class 0: 1000 instances, features [0-5]
# Class 1: 100 instances, features [10-15]
# Solution: Simple resampling works well ✓

# Scenario 2: Only Overlap (Balanced)
# Class 0: 500 instances, features [0-10]
# Class 1: 500 instances, features [5-15]
# Solution: Need overlap-handling techniques ⚠️

# Scenario 3: Both Imbalance + Overlap
# Class 0: 1000 instances, features [0-10]
# Class 1: 100 instances, features [5-15]
# Solution: FairSample's specialized techniques ✓✓

The Research Foundation

FairSample implements techniques from:

Vuttipittayamongkol & Elyan (2020) - EHSO, NBUS - Information Sciences
Das et al. (2014) - RFCL - IEEE TKDE
Santos et al. (2023) - Overlap analysis framework - Artificial Intelligence Review
Lorena et al. (2019) - Complexity measures - ACM Computing Surveys

Full citations: CITATIONS.md

Resources

📖 Documentation: https://mohduwaish59.github.io/fairsample/
💻 GitHub: https://github.com/mohdUwaish59/fairsample
📝 Issues: Report bugs or request features
🔧 PRs: Contribute techniques or improvements

The Bottom Line

Class overlap is often more harmful than class imbalance. Yet most tools focus solely on balancing class ratios.

FairSample provides:

Diagnostic tools - Quantify overlap with 40+ measures
Treatment options - 14+ research-backed techniques
Validation methods - Verify overlap reduction

All specifically designed for the overlap problem.

Have overlap problems in your data? Try FairSample and share your results!

What domains have you encountered severe class overlap? Drop a comment below 👇

python #machinelearning #datascience #opensource #classoverlap

I Built a Chrome Extension to Extract YouTube Transcripts in Bulk

Mohd Uwaish — Mon, 24 Nov 2025 21:19:45 +0000

Hey folks! 👋

So, I had this problem. I was working on a personal project where I wanted to develop an information retrieval system from transcripts from about 300 YouTube videos. Sounds fun, right? Wrong. Try manually clicking "Show transcript" → Copy → Paste → Save as file... 300 times. Yeah, I made it through about 5 videos before I said "nope, there's gotta be a better way."

Spoiler alert: there wasn't. At least not one that did exactly what I needed. So I built one.

The Problem Was Real

Here's the thing - YouTube has transcripts for most videos (thank you, auto-captions!), but getting them out is... tedious. Sure, you can click and copy one at a time, but when you're dealing with:

An entire playlist of educational content
All videos from a specific channel
A curated list of videos for research

...you're looking at hours of repetitive clicking. And let's be honest, we became developers specifically to avoid repetitive clicking.

What I Built

Meet the YouTube Transcript Extractor - a Chrome extension that does three main things:

Single video extraction - One click, get a JSON file with the transcript
Playlist/Channel scraping - Grab all video IDs from a playlist or channel
Batch processing - Process dozens (or hundreds) of videos automatically

The best part? It handles all the annoying stuff automatically:

Clicks the "Show transcript" button for you
Waits for transcripts to load
Adds smart delays to avoid rate limiting
Retries failed extractions
Gives you real-time progress updates

How It Actually Works

For a Single Video

It's stupid simple:

You're on a YouTube video
Click the extension icon
Click "Extract Transcript"
Boom - JSON file downloads

The output looks like this:

{
  "channel_username": "veritasium",
  "video_id": "dQw4w9WgXcQ",
  "transcript": "Full transcript text here..."
}

Perfect for feeding into your text analysis pipeline, building datasets, or just archiving content you care about.

For Entire Playlists

This is where it gets fun. You give it a playlist URL:

https://www.youtube.com/playlist?list=PLxxxxxx

The extension:

Auto-scrolls through the entire playlist
Extracts all video IDs
Saves them to your browser storage
Lets you download them as a text file

Then you can either process them immediately or save them for later. I've found this super useful for tracking new uploads from channels I follow.

Batch Processing (The Real MVP)

Here's the workflow that saves hours:

Load your video IDs (from playlist extraction or manual paste)
Set your batch size (I usually go with 15-20 videos)
Click "Start Batch Process"
Go grab coffee ☕

The extension will:

Navigate to each video automatically
Extract the transcript
Download it as JSON
Wait 5-15 seconds (random delay to be nice to YouTube)
Move to the next one

You get real-time updates like:

Processing video 23/150 (Batch 2/10)
✅ Success: 22 | ⏭️ Skipped: 1 | ❌ Failed: 0

The Technical Bits (For Fellow Nerds)

Built with:

Manifest V3 (because V2 is being phased out)
Chrome's Side Panel API (way better UX than popups)
Content Scripts for DOM manipulation
Chrome Storage API for persistence
Vanilla JavaScript (keeping it simple)

Some challenges I ran into:

Challenge 1: The Transcript Button

YouTube doesn't always show transcripts immediately. Sometimes you need to click a button first. My solution? The extension automatically finds and clicks it:

const transcriptButton = document.querySelector('[aria-label*="transcript"]');
if (transcriptButton) {
  transcriptButton.click();
  // Wait for transcript to load
  await sleep(2000);
}

Challenge 2: Rate Limiting

YouTube isn't thrilled when you hit their servers 100 times in 5 minutes. Fair enough. So I added:

Random delays (5-15 seconds between requests)
Configurable batch sizes
Automatic retry logic with exponential backoff

Haven't been rate-limited since. 🎉

Challenge 3: Playlist Pagination

Playlists don't load all videos at once - you have to scroll to trigger lazy loading. The extension handles this:

function autoScroll() {
  return new Promise((resolve) => {
    let scrollCount = 0;
    const maxScrolls = 50; // Safety limit

    const interval = setInterval(() => {
      window.scrollBy(0, 1000);
      scrollCount++;

      // Check if we've reached the bottom
      if (scrollCount >= maxScrolls || isAtBottom()) {
        clearInterval(interval);
        resolve();
      }
    }, 1000);
  });
}

Real-World Use Cases

This can be used for:

1. Information retrieval

I personally worked on this use case. I Collected transcripts from 300+ videos. Extracted the information each transcript in question-answer format and converted them into a vector database for chatbot interface. Would have taken days manually - took 40 minutes with the extension.

2. Content Monitoring

Track new uploads from favorite tech channels. Run it once a week, compare video IDs, process only new content. Built a simple notification system around it.

3. Podcast Transcription Analysis

Many podcasts are on YouTube now. Grabbed transcripts from entire podcast series to analyze conversation patterns and topics.

4. Language Learning

Downloaded transcripts from language-learning channels in my target language. Now I have a searchable corpus of natural conversation.

The Gotchas

Not everything is perfect (yet):

Some videos don't have transcripts - The extension will skip these and note them in the log
YouTube's rate limits are real - Don't try to process 500 videos in one go
Auto-generated transcripts aren't perfect - Expect some "lol" instead of "LOL" situations
It only works in Chrome - Firefox support is on my TODO list

Want to Try It?

The extension is open source! Here's how to get started:

Installation (2 minutes)

# Clone the repo
git clone https://github.com/yourusername/youtube-transcript-extractor.git

# Open Chrome
chrome://extensions/

# Enable Developer Mode (top right)
# Click "Load unpacked"
# Select the extension folder

That's it!

Quick Test

Go to any YouTube video
Click the extension icon
Click "Extract Transcript"
Check your downloads folder

You should see a JSON file. If you do, you're ready to rock!

What's Next?

I'm actively working on:

Firefox support - Because not everyone uses Chrome
Export formats - SRT, VTT, plain text
Timestamp preservation - Keep the timing data from transcripts
Better error handling - More descriptive error messages
Progress persistence - Resume batch processing after browser crash

Contributing

This project started as a personal tool, but I'd love to make it better with your help! Whether it's:

Bug reports
Feature suggestions
Code contributions
Documentation improvements

All are welcome! Check out the GitHub repo and feel free to open issues or PRs.

Real Talk: Why Build This?

I could have probably found something that did parts of what I needed. Maybe some Python script, maybe some paid service. But here's what I learned building this:

Sometimes the best tool is the one you build - It does exactly what you need, nothing more
Side projects teach you stuff - I learned a ton about Chrome extension APIs
Automation is worth it - Even if building it takes 10 hours, saving 20 hours is worth it
Open source feels good - Knowing others might find this useful is cool

Plus, it's just satisfying watching the extension churn through 300 videos while you do literally anything else.

Wrapping Up

If you ever find yourself manually copying YouTube transcripts, give this extension a shot. It's not perfect, but it's saved me countless hours, and I hope it does the same for you.

Got questions? Drop them in the comments! Found a bug? Please let me know - I promise I don't bite. 😊

And if you build something cool with the transcripts you extract, I'd love to hear about it!

Happy automating the boring stuff! 🎬📝

P.S. - If you found this useful, a star on GitHub would make my day! ⭐