Text Classification for Cyberbullying Detection: A Practical NLP Walkthrough

import pandas as pd
import numpy as np

df = pd.read_csv("cyberbullying_tweets.csv")
print(df["cyberbullying_type"].value_counts())

import re
import string
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.metrics import (
    classification_report, confusion_matrix,
    ConfusionMatrixDisplay, f1_score
)
from sklearn.preprocessing import LabelEncoder

import nltk
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer

nltk.download("stopwords", quiet=True)
nltk.download("wordnet",   quiet=True)

SEED = 42
np.random.seed(SEED)

lemmatizer  = WordNetLemmatizer()
STOP_WORDS  = set(stopwords.words("english"))

# Keep negations — "not" flips sentiment
STOP_WORDS -= {"no", "not", "nor", "never", "neither"}

def clean_tweet(text: str) -> str:
    """
    Full preprocessing pipeline for a single tweet.
    Returns a cleaned, lemmatised string.
    """
    text = text.lower()
    text = re.sub(r"http\S+|www\S+",      "", text)   # remove URLs
    text = re.sub(r"@\w+",                "", text)   # remove @mentions
    text = re.sub(r"#(\w+)",          r"\1", text)   # keep hashtag text, drop #
    text = re.sub(r"[^a-z\s]",            "", text)   # remove punctuation + digits
    text = re.sub(r"\s+",               " ", text).strip()

    tokens = text.split()
    tokens = [lemmatizer.lemmatize(t) for t in tokens if t not in STOP_WORDS]
    return " ".join(tokens)


# Apply to full dataset
df["clean_text"] = df["tweet_text"].apply(clean_tweet)

# Quick sanity check
print(df[["tweet_text", "clean_text"]].head(3).to_string())

X = df["clean_text"]
y = df["cyberbullying_type"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=SEED,
    stratify=y          # preserve class distribution in both splits
)

print(f"Train: {len(X_train)}, Test: {len(X_test)}")

tfidf = TfidfVectorizer(
    max_features=30_000,    # vocabulary cap — filters rare/noisy tokens
    ngram_range=(1, 2),     # unigrams + bigrams: "not good" ≠ "not" + "good"
    sublinear_tf=True,      # replace tf with 1 + log(tf) — dampens high counts
    min_df=3,               # ignore tokens appearing in < 3 documents
    max_df=0.95             # ignore tokens in > 95% of documents (too common)
)

X_train_tfidf = tfidf.fit_transform(X_train)
X_test_tfidf  = tfidf.transform(X_test)

print(f"Feature matrix: {X_train_tfidf.shape}")  # (37600, 30000)

svm = LinearSVC(
    C=1.0,          # regularisation — lower C = stronger regularisation
    max_iter=2000,
    random_state=SEED
)
svm.fit(X_train_tfidf, y_train)

rf = RandomForestClassifier(
    n_estimators=200,
    max_depth=None,
    min_samples_leaf=2,
    n_jobs=-1,
    random_state=SEED
)
rf.fit(X_train_tfidf, y_train)

def evaluate_model(model, X_test, y_test, name="Model"):
    y_pred = model.predict(X_test)
    print(f"\n{'='*60}")
    print(f" {name}")
    print(f"{'='*60}")
    print(classification_report(y_test, y_pred, digits=3))
    return y_pred

svm_preds = evaluate_model(svm, X_test_tfidf, y_test, "Linear SVM")
rf_preds  = evaluate_model(rf,  X_test_tfidf, y_test, "Random Forest")

def plot_confusion_matrix(y_true, y_pred, title, labels):
    cm = confusion_matrix(y_true, y_pred, labels=labels, normalize="true")
    fig, ax = plt.subplots(figsize=(8, 6))
    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
    disp.plot(ax=ax, cmap="Blues", colorbar=False, xticks_rotation=45)
    ax.set_title(title)
    plt.tight_layout()
    plt.savefig(f"cm_{title.lower().replace(' ', '_')}.png", dpi=150)
    plt.show()

LABELS = sorted(y_test.unique())
plot_confusion_matrix(y_test, svm_preds, "Linear SVM", LABELS)

# Re-fit on raw features using a Pipeline (fits on each fold properly)
cv_pipeline = Pipeline([
    ("tfidf", TfidfVectorizer(max_features=30_000, ngram_range=(1,2),
                               sublinear_tf=True, min_df=3)),
    ("clf",   LinearSVC(C=1.0, max_iter=2000, random_state=SEED))
])

skf    = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
scores = cross_val_score(cv_pipeline, X, y, cv=skf, scoring="f1_macro", n_jobs=-1)

print(f"5-Fold CV F1 (macro): {scores.mean():.3f} ± {scores.std():.3f}")
# → 5-Fold CV F1 (macro): 0.901 ± 0.004

import joblib

full_pipeline = Pipeline([
    ("tfidf", TfidfVectorizer(
        max_features=30_000,
        ngram_range=(1, 2),
        sublinear_tf=True,
        min_df=3,
        max_df=0.95
    )),
    ("clf", LinearSVC(C=1.0, max_iter=2000, random_state=SEED))
])

full_pipeline.fit(X_train, y_train)

# Save
joblib.dump(full_pipeline, "cyberbullying_pipeline.pkl")

# Reload and predict
loaded = joblib.load("cyberbullying_pipeline.pkl")

test_inputs = [
    "You are so stupid and ugly, nobody likes you",
    "Great game everyone, well played!",
    "Go back to your country you don't belong here"
]

for text in test_inputs:
    clean = clean_tweet(text)
    pred  = loaded.predict([clean])[0]
    print(f"  [{pred:>20}]  {text}")