In this article, you will learn how to benchmark three text classification approaches — from a classical TF-IDF pipeline to a zero-shot large language model — to understand when each is most appropriate.
Topics we will cover include:
- How to implement and evaluate a classical TF-IDF and logistic regression text classification pipeline.
- How to apply zero-shot classification using a transformer-based model (BART) and compare it against the classical baseline.
- How to use scikit-LLM with a Groq-hosted large language model for production-ready zero-shot classification with minimal code changes.
Introduction
In recent years, generative AI models like LLMs (large language models) have gradually taken over classical machine learning ones for addressing certain tasks, for instance, text classification. But the truth is: rather than having a one-beats-all solution, there are critical trade-offs developers need to face — should we stick with fast, battle-tested conventional models, invest in fine-tuning a transformer-based LLM, or perhaps leverage LLMs’ zero-shot reasoning potential?
In this article, we will implement a benchmarking between three distinct approaches for text classification:
- TF-IDF and logistic regression (classic baseline).
- Zero-shot classification with BART: a deep learning, transformer-based standard architecture.
- Scikit-LLM with zero-shot classification: the most modern, prompt-based approach.
The tutorial below is kept entirely free for everyone to try, with no costs or API rate limits. To do so, we will use scikit-LLM alongside a model available from Groq. You will need to register at Groq and obtain an API key for evaluating the third solution below.
Implementing the Benchmarking
First, we install all the core libraries we will need.
|
1 |
!pip install scikit-learn transformers scikit-llm scikit-ollama pandas torch |
For enabling reproducibility, we create a small, synthetic dataset containing customer support messages. The tickets are categorized into five classes. Once created, we store it in a DataFrame object and split it into training and test sets.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
import pandas as pd from sklearn.model_selection import train_test_split data = { "text": [ # Technical "My screen is completely black and won't turn on.", "The app keeps crashing every time I click save.", "The Wi-Fi module is failing to connect to the router.", "Data sync isn't working across my devices.", "My bluetooth headphones won't pair with the app.", "I keep getting an Error 404 on the login screen.", "The database connection timed out during the export.", "API rate limit exceeded even though I haven't used it.", "Profile images won't load on the dashboard.", "The software installation failed at 99%.", # Billing "I was charged twice this month, please fix this.", "How do I update my credit card information?", "My invoice for last month is missing from the portal.", "The VAT calculation on my receipt is wrong.", "My transaction was declined but I have funds.", "Can I change my billing cycle from monthly to annual?", "Where can I find my official receipt?", "My saved credit card expired and I need to swap it.", "I was overcharged on my last statement.", "Please remove my saved payment method.", # Account "My account is locked and I forgot my password.", "How do I change the email address on my profile?", "Please delete my account and all associated data.", "I want to update my profile picture.", "How do I enable two-factor authentication (2FA)?", "I didn't receive the email verification link.", "Can I merge two different accounts into one?", "Is there a way to change my username?", "I need to transfer account ownership to my manager.", "I am locked out because I lost my 2FA phone.", # Sales "Do you offer enterprise discounts for large teams?", "Do you have an annual plan with a discount?", "Can you compare the pro and basic tiers for me?", "What is the pricing for a 50-user bulk license?", "Is there a student discount available?", "Can I schedule a demo with your sales team?", "Do you sell and ship to customers in Europe?", "How does your partner and reseller program work?", "What are the usage limits on the free tier?", "I need a custom quote for a government contract.", # Refund "Can I get a refund for my last purchase? It was a mistake.", "I want my money back for the subscription.", "Accidental purchase, please reverse the charge.", "I am not satisfied with the product, need a refund.", "Cancel my subscription immediately and refund me.", "I was charged after my free trial ended.", "I need a prorated refund for the remaining months.", "What is your official refund policy?", "I was promised a refund last week but haven't received it.", "The item arrived broken, I want a full refund." ], "label": [ "Technical"] 10 + ["Billing"] 10 + ["Account"] 10 + ["Sales"] 10 + ["Refund"] * 10 } df = pd.DataFrame(data) # Stratified train-test splitting ensures all 5 categories are proportionally represented in both subsets when the dataset is small X_train, X_test, y_train, y_test = train_test_split( df["text"], df["label"], test_size=0.3, random_state=42, stratify=df["label"] ) print(f"Training rows: {len(X_train)} | Testing rows: {len(X_test)}") |
We first implement and evaluate the most classical approach: TF-IDF combined with a logistic regression classifier. The process is shown below:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import time from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.linear_model import LogisticRegression from sklearn.pipeline import make_pipeline from sklearn.metrics import classification_report start_time = time.time() # Creating and training the classical pipeline logreg_clf = make_pipeline(TfidfVectorizer(), LogisticRegression()) logreg_clf.fit(X_train, y_train) # Inference: predictions on the test examples y_pred_logreg = logreg_clf.predict(X_test) logreg_latency = time.time() - start_time # Latency is also measured to assess the model's efficiency print(f"Logistic Regression Latency: {logreg_latency:.4f} seconds") print(classification_report(y_test, y_pred_logreg, zero_division=0)) |
Output:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Logistic Regression Latency: 0.0615 seconds precision recall f1-score support Account 0.25 0.33 0.29 3 Billing 1.00 1.00 1.00 3 Refund 0.67 0.67 0.67 3 Sales 0.25 0.33 0.29 3 Technical 1.00 0.33 0.50 3 accuracy 0.53 15 macro avg 0.63 0.53 0.55 15 weighted avg 0.63 0.53 0.55 15 |
The classifier shows a mixed behavior: it performs well on categories like Billing and, to some extent, Refund, but struggles with the rest. This is the fastest approach by far; however, its classification performance is limited by its inability to capture the complex linguistic nuances that more modern language models can effectively handle. Sticking to aggregated results, we get accuracies ranging between 0.53 and 0.55 overall.
Let’s see what our second approach — zero-shot classification with facebook/bart-large-mnli
— has to offer:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from transformers import pipeline import time # Using a HuggingFace zero-shot classification pipeline as our transformer representative # We need to overload the default classifier to specify our own label set classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli") candidate_labels = ["Technical", "Billing", "Account", "Sales", "Refund"] start_time = time.time() # Inference time! bert_preds = [] for text in X_test: result = classifier(text, candidate_labels) bert_preds.append(result['labels'][0]) # Get the highest scoring label bert_latency = time.time() - start_time print(f"Transformer Inference Latency: {bert_latency:.4f} seconds") print(classification_report(y_test, bert_preds, zero_division=0)) |
These are the results:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Transformer Inference Latency: 32.2503 seconds precision recall f1-score support Account 0.40 0.67 0.50 3 Billing 1.00 0.33 0.50 3 Refund 0.75 1.00 0.86 3 Sales 1.00 0.33 0.50 3 Technical 0.75 1.00 0.86 3 accuracy 0.67 15 macro avg 0.78 0.67 0.64 15 weighted avg 0.78 0.67 0.64 15 |
Much higher latency, and only a modest improvement in accuracy: 0.64–0.67 in broad terms.
Finally, the zero-shot LLM classifier with a scikit-LLM pipeline and a Groq model:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
from skllm.config import SKLLMConfig from skllm.models.gpt.classification.zero_shot import ZeroShotGPTClassifier import getpass import time from sklearn.metrics import classification_report # 1. Securely asking for the key in a private input box: # GET YOURS AT https://console.groq.com/keys print("Get your free Groq API key here: https://console.groq.com/keys" api_key = getpass.getpass("Paste your API Key here: ") # 2. Configuring Scikit-LLM SKLLMConfig.set_openai_key(api_key) SKLLMConfig.set_gpt_url("https://api.groq.com/openai/v1/" # 3. Initializing with the latest active model for zero-shot classification # 'llama-3.3-70b-versatile' is supported by Groq at the time of writing llm_clf = ZeroShotGPTClassifier(model="custom_url::llama-3.3-70b-versatile") start_time = time.time() # 4. Running the classification task llm_clf.fit(X_train, y_train) y_pred_llm = llm_clf.predict(X_test) llm_latency = time.time() - start_time print(f"\nScikit-LLM Latency: {llm_latency:.4f} seconds") print(classification_report(y_test, y_pred_llm, zero_division=0)) |
Final results:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Scikit-LLM Latency: 2.5905 seconds precision recall f1-score support Account 0.67 0.67 0.67 3 Billing 1.00 0.67 0.80 3 Refund 1.00 1.00 1.00 3 Sales 1.00 1.00 1.00 3 Technical 0.75 1.00 0.86 3 accuracy 0.87 15 macro avg 0.88 0.87 0.86 15 weighted avg 0.88 0.87 0.86 15 |
This is by far the best result in terms of classification accuracy (0.86–0.87). And surprisingly, it is also considerably faster than the BART-based zero-shot model. This is not all that surprising: the Groq-hosted model was trained on a massive, broad dataset. It does not need to learn what a given type of customer support ticket means — it already knows, unlike the zero-shot BART model used earlier.
So, we have a clear winner!
On a final note: this is where the value of scikit-LLM lies. It bridges the gap between classical and modern AI through a standardized, production-ready interface, using scikit-learn-like syntax throughout. With this in hand, you can swap between a classical logistic regressor and a modern Groq LLM with minimal effort.
Wrapping Up
This article benchmarked, on a toy dataset, scikit-LLM’s zero-shot classification against more classical approaches — logistic regression with TF-IDF, and a zero-shot transformer model (BART) sitting somewhere in between. As for the question posed in the title, when should you use an LLM for text classification? The choice of a small, toy dataset here was deliberate. When the amount of available data is limited and the task requires deep linguistic reasoning and contextual understanding, scikit-LLM is a compelling asset: it makes it possible to instantly deploy a model’s pre-trained world knowledge into a pipeline like ours, eliminating both the time and infrastructure costs of training a model of this magnitude from scratch.
The first approach appears to rely on plain TF-IDF without stop-word removal, lemmatization, or unigram/bigram analysis. Adding these standard NLP preprocessing steps can already boost the accuracy to approximately 0.72–0.73.
def lemmatize_text(text):
tokens = word_tokenize(text.lower())
return [lemmatizer.lemmatize(token) for token in tokens]
Creating and training the classical pipeline
logreg_clf = make_pipeline(TfidfVectorizer(tokenizer=lemmatize_text, stop_words=’english’, ngram_range=(1, 2)), LogisticRegression())
logreg_clf.fit(X_train, y_train)
Hi Majkell…Thank you for your feedback and contribution to our discussions! Please keep us posted on your progress.
Facts Only
A benchmark compares three text classification methods: TF-IDF with logistic regression, zero-shot BART, and scikit-LLM with Groq's LLM.
The dataset consists of 50 synthetic customer support messages across five categories: Technical, Billing, Account, Sales, and Refund.
The classical TF-IDF pipeline achieves 53% accuracy with 0.06-second latency.
The BART zero-shot model achieves 67% accuracy with 32.25-second latency.
The scikit-LLM approach with Groq's Llama-3.3-70b model achieves 87% accuracy with 2.59-second latency.
The scikit-LLM framework requires a Groq API key for access to the hosted model.
The classical method uses scikit-learn's TfidfVectorizer and LogisticRegression.
The BART model is implemented via Hugging Face's transformers pipeline.
The scikit-LLM pipeline integrates with scikit-learn-like syntax for consistency.
The dataset is split into 70% training and 30% testing sets with stratification.
The analysis measures precision, recall, F1-score, and latency for each method.
The scikit-LLM approach demonstrates the highest accuracy and balanced latency.
Executive Summary
Full Take
This benchmark presents a thoughtful exploration of text classification trade-offs, but several methodological and contextual considerations warrant deeper scrutiny. The synthetic dataset, while useful for demonstration, lacks the noise and variability of real-world data, potentially inflating performance metrics. The classical TF-IDF baseline could be strengthened with standard NLP preprocessing (lemmatization, stop-word removal, n-grams), which might narrow the gap with LLM performance. The BART model's underwhelming results (67% accuracy) raise questions about its suitability for zero-shot classification in this context—was the model fine-tuned for this task, or is this a limitation of its pre-training?
The scikit-LLM approach's superiority (87% accuracy) is impressive but hinges on Groq's proprietary infrastructure and a massive pre-trained model (Llama-3.3-70b). This introduces dependencies on API availability, cost, and latency variability in production. The analysis rightly notes the value of scikit-LLM's scikit-learn compatibility, but the "minimal code changes" claim assumes familiarity with both frameworks—a non-trivial hurdle for some teams.
**Patterns detected: none**
Root cause: The narrative reflects a broader paradigm shift in NLP, where pre-trained LLMs are increasingly positioned as drop-in replacements for classical methods. However, the benchmark's small scale and synthetic data obscure critical real-world factors like cost, scalability, and edge-case handling. The framing of LLMs as a "clear winner" risks oversimplifying the trade-offs—latency, interpretability, and data privacy often favor classical approaches in production.
Implications: For practitioners, this underscores the need for context-specific evaluation. LLMs shine in low-data, high-context scenarios but may be overkill for structured, high-volume tasks. The scikit-LLM framework lowers the barrier to LLM adoption, but its reliance on third-party APIs introduces new risks.
Bridge questions: How would these methods perform on a larger, noisier dataset? What are the cost implications of scaling the LLM approach? Could hybrid models (e.g., LLM for edge cases, classical for bulk processing) offer a balanced solution? Would the same patterns hold in non-English or domain-specific text classification?
Sentinel — Human
Sentinel analysis incomplete — partial response from fallback model.