Improving Requirements Classification with SMOTE-Tomek Preprocessing
This study demonstrates that applying SMOTE-Tomek preprocessing combined with stratified K-fold cross-validation to the PROMISE dataset significantly improves the classification accuracy of functional and non-functional requirements, boosting logistic regression performance from a 58.31% baseline to 76.16%.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are a librarian trying to sort a massive pile of mixed-up notes into two main bins: "Things the system must do" (Functional) and "How the system should behave" (Non-functional, like being fast, secure, or easy to use).
The problem is that the pile is messy. Most of the notes are about "Security" or "Usability," but there are only a handful of notes about "Portability" (moving the system to different computers). If you just let a computer sort this pile, it will get lazy. It will guess "Security" for almost everything because that's what it sees most often. It will completely ignore the rare notes because it hasn't seen enough of them to learn what they look like.
This paper is about teaching a computer how to be a better librarian by fixing the mess in the pile before it starts sorting.
The Problem: The "Unbalanced Class"
The researchers used a famous collection of 969 software notes (the PROMISE dataset).
- The Issue: The notes are heavily unbalanced. Some categories have 125 notes, while others have only 12.
- The Result: Without help, the computer's "brain" (Machine Learning models) gets biased. It becomes an expert at spotting the common notes but terrible at spotting the rare ones. In the study, a standard computer model only got about 58% of the notes right.
The Solution: The "SMOTE-Tomek" Recipe
To fix this, the authors used a special two-step cleaning and balancing recipe called SMOTE-Tomek. Think of it like a chef preparing ingredients for a soup where some vegetables are missing.
SMOTE (The "Synthetic Chef"):
Instead of just photocopying the few rare notes (which is boring and doesn't help much), SMOTE acts like a creative chef. It looks at two similar rare notes and "cooks up" a brand new, fake note that sits right in between them.- Analogy: If you have two notes saying "The system must be fast," SMOTE creates a new note saying "The system needs to be quick and responsive." It fills the gaps so the computer sees enough examples to learn the pattern.
Tomek Links (The "Noise Filter"):
Sometimes, when you make new notes, you accidentally create some that are confusing or messy (like a note that sounds like both "Security" and "Usability"). Tomek acts like a strict editor. It finds these confusing, borderline notes and throws them away to make the categories clearer.- Analogy: If a note is so vague it could belong to two different bins, the editor removes it so the computer doesn't get confused about where it belongs.
The Experiment: The "Fair Test"
The researchers didn't just throw all the notes into a blender. They used a method called Stratified K-Fold Cross-Validation.
- Analogy: Imagine you have a deck of cards with different suits. You want to test a player's skill. You split the deck into 10 piles. You let the player practice on 9 piles (where you use the "Synthetic Chef" to add more cards) and then test them on the 10th pile (which remains untouched and pure). You rotate this so every pile gets a turn as the test.
- Why it matters: This ensures the computer isn't cheating by memorizing the test answers. It proves the computer actually learned the rules.
The Results: A Big Win for Logic
They tested many different "brains" (algorithms) on this task.
- Before the fix: The best performer (a Linear SVM) got about 71% right. A standard "Logistic Regression" (a simple, logical model) only got 58% right.
- After the fix (SMOTE-Tomek): The simple Logistic Regression model skyrocketed to 76.16% accuracy!
Why was the simple model the winner?
The paper found that the simple model became much more stable.
- Without the fix: The model was panicking. It was screaming, "This one word means 'Portability'!" and assigning it a huge weight, just because it had seen so few examples.
- With the fix: The model calmed down. It learned a balanced view. It realized, "Okay, 'Portability' usually involves words like 'browser,' 'system,' and 'run,' but no single word is the magic key."
The Takeaway
This study shows that you don't always need a super-complex, expensive "Deep Learning" brain (which requires massive amounts of data and power) to sort software requirements.
If you have a small, messy dataset, you can get excellent results by:
- Cleaning the data (removing the confusing notes).
- Synthesizing new examples (filling in the gaps for rare categories).
- Using a simple, interpretable model (like Logistic Regression) that can explain why it made a decision.
The paper concludes that this approach makes the computer a much more reliable librarian, capable of spotting even the rarest types of software requirements with high accuracy.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.