# Optimizing Linear Classifiers in NLP: A Systematic Pipeline for Textual Feature Engineering

Abstract

In the development of text classification models, the transition from raw unstructured data to a high-dimensional feature space requires a disciplined approach to data splitting and feature weighting. This article outlines a standardized pipeline utilizing Support Vector Machines (SVM), Porter Stemming, and TF-IDF Vectorization, with a specific focus on the programmatic prevention of Data Leakage.

1. Lexical Preprocessing: The "Stemmed" Logic

Before mathematical modeling, text must be normalized. We utilize a combination of Regular Expressions (Regex) to remove noise and the Porter Stemmer to reduce dimensionality. This ensures that variations of the same word (e.g., "running" and "run") are treated as a single feature.

Implementation:

import re
from nltk.stem.porter import PorterStemmer

port_stem = PorterStemmer()

def stemmed_content(text):
    # Remove non-alphabetic characters and lowercase
    cleaned = re.sub('[^a-zA-Z]', ' ', text).lower()
    
    # Tokenize and Stem
    words = cleaned.split()
    stemmed_words = [port_stem.stem(word) for word in words]
    
    return " ".join(stemmed_words)

2. Feature Vectorization and the Fit/Transform Protocol

Because estimators like SVM require numerical input, we employ Term Frequency-Inverse Document Frequency (TF-IDF). A critical distinction must be made between the fit() and transform() methods to ensure model integrity.

• fit(): Learns the vocabulary and Inverse Document Frequency (IDF) weights.
• transform(): Converts the text into a sparse matrix based on the learned vocabulary.
  The Danger of Data Leakage
  A common error is fitting the vectorizer on the entire dataset () before splitting. This allows information from the test set to "leak" into the training weights, resulting in artificially high accuracy. The correct systematic approach is to fit only on the training data.
  Standard Workflow:

from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer

# 1. Split data first
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)

# 2. Fit and Transform only the training set
vectorizer = TfidfVectorizer()
X_train_vectorized = vectorizer.fit_transform(X_train)

# 3. Transform the test set (using ONLY the training vocabulary)
X_test_vectorized = vectorizer.transform(X_test)

3. Classification with Linear SVM

For text data, where the number of features often exceeds the number of observations, a Linear Kernel is frequently the most robust choice. It provides a clear decision boundary (hyperplane) that separates classes while minimizing the risk of overfitting compared to more complex non-linear kernels.

Implementation:

from sklearn import svm

# Initialize and train the model on vectorized data
model = svm.SVC(kernel='linear')
model.fit(X_train_vectorized, Y_train)

# Evaluation
accuracy = model.score(X_test_vectorized, Y_test)

4. Conclusion

A professional NLP pipeline is defined by its rigor. By strictly separating the "Learning" phase (fit) from the "Application" phase (transform), and utilizing linear separators for high-dimensional text data, practitioners can build models that are both statistically valid and deployable in real-world scenarios.