Part 1: Introduction to Transformers and Pipelines

Part of the Hugging Face Transformers 101 Series

The Day I Stopped Building NLP from Scratch

I was building a customer feedback analysis system. Requirements: classify sentiment, extract key topics, identify complaints. My approach? Train custom models from scratch: gather data, label thousands of examples, build neural networks, train for days, iterate endlessly.

Three weeks in: 72% accuracy. Not good enough.

Then a colleague showed me Hugging Face Transformers:

from transformers import pipeline

classifier = pipeline("sentiment-analysis")
result = classifier("The product quality is excellent but shipping was slow")
print(result)
# [{'label': 'POSITIVE', 'score': 0.9245}]

3 minutes. 94% accuracy. State-of-the-art BERT model, pretrained on millions of examples, ready to use.

That's when I realized: don't build what already exists. Stand on the shoulders of giants.

In this article, I'll show you everything I wish I knew when I started with Hugging Face Transformers.

What Are Transformers?

Before diving into code, let me explain what transformers actually are (without unnecessary math).

Transformers are a neural network architecture introduced in the 2017 paper "Attention Is All You Need". They revolutionized NLP and beyond.

Why Transformers Changed Everything

Before transformers (RNNs, LSTMs):

• Process text sequentially (word by word)

• Struggle with long sequences

• Hard to parallelize

• Limited context understanding

With transformers:

• Process entire sequences at once

• Handle long context effectively

• Massively parallelizable (fast training)

• Better understanding of relationships

The key innovation: Attention mechanisms. The model learns which parts of the input to focus on when processing each part.

Real-World Impact

Transformers power:

• ChatGPT (GPT-3, GPT-4)

• Google Search (BERT)

• GitHub Copilot (Codex/GPT)

• Translation (Google Translate, DeepL)

• Image generation (DALL-E, Stable Diffusion)

You don't need to understand the math to use them effectively.

Installing Transformers

Basic Installation

# Install transformers
pip install transformers

# Install PyTorch (recommended)
pip install torch torchvision torchaudio

# Optional: acceleration
pip install accelerate

My Recommended Setup

# Create virtual environment
python3 -m venv venv-transformers
source venv-transformers/bin/activate  # On Windows: venv-transformers\Scripts\activate

# Install core dependencies
pip install --upgrade pip
pip install transformers torch datasets
pip install sentencepiece protobuf  # For some tokenizers

# Optional but useful
pip install accelerate  # Training optimization
pip install evaluate  # Model evaluation
pip install tensorboard  # Training visualization

Verify Installation

import transformers
import torch

print(f"Transformers version: {transformers.__version__}")
print(f"PyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")

My output:

Transformers version: 4.37.0
PyTorch version: 2.2.0
CUDA available: True

Don't have a GPU? No problem. Most inference tasks work fine on CPU for personal projects.

Pipelines: The Fastest Way to Results

Pipelines are the easiest way to use Transformers. They handle:

• Model loading

• Tokenization

• Inference

• Post-processing

One line of code, production-ready results.

Sentiment Analysis

The example that hooked me:

from transformers import pipeline

# Load sentiment analysis pipeline
classifier = pipeline("sentiment-analysis")

# Analyze text
texts = [
    "I absolutely love this product!",
    "This is the worst experience ever.",
    "It's okay, nothing special.",
    "Amazing quality, fast shipping, highly recommend!"
]

results = classifier(texts)
for text, result in zip(texts, results):
    print(f"{text[:50]:50} -> {result['label']:8} ({result['score']:.4f})")

Output:

I absolutely love this product!                    -> POSITIVE (0.9998)
This is the worst experience ever.                 -> NEGATIVE (0.9997)
It's okay, nothing special.                        -> NEGATIVE (0.5234)
Amazing quality, fast shipping, highly recommend!  -> POSITIVE (0.9999)

What just happened?

1. Loaded pretrained DistilBERT model

2. Tokenized text automatically

3. Ran inference

4. Returned human-readable results

I use this daily for quick text analysis.

Named Entity Recognition (NER)

Extract people, organizations, locations from text:

from transformers import pipeline

ner = pipeline("ner", aggregation_strategy="simple")

text = """
Elon Musk announced that Tesla will open a new factory in Austin, Texas.
The company plans to hire 10,000 employees by 2025.
"""

entities = ner(text)

for entity in entities:
    print(f"{entity['word']:20} -> {entity['entity_group']:10} ({entity['score']:.4f})")

Output:

Elon Musk            -> PER        (0.9996)
Tesla                -> ORG        (0.9989)
Austin               -> LOC        (0.9994)
Texas                -> LOC        (0.9991)

I used this to extract company names and locations from thousands of news articles.

Question Answering

Answer questions based on context:

from transformers import pipeline

qa = pipeline("question-answering")

context = """
Hugging Face is a company that develops tools for building machine learning applications.
Founded in 2016, it has become the leading platform for sharing and using AI models.
The company is headquartered in New York City.
"""

questions = [
    "When was Hugging Face founded?",
    "Where is Hugging Face headquartered?",
    "What does Hugging Face develop?"
]

for question in questions:
    result = qa(question=question, context=context)
    print(f"Q: {question}")
    print(f"A: {result['answer']} (score: {result['score']:.4f})\n")

Output:

Q: When was Hugging Face founded?
A: 2016 (score: 0.9823)

Q: Where is Hugging Face headquartered?
A: New York City (score: 0.9912)

Q: What does Hugging Face develop?
A: tools for building machine learning applications (score: 0.8654)

Real use case: I built a document QA system for internal knowledge base. Users ask questions, system finds answers in documentation.

Text Generation

Generate text continuations:

from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

prompts = [
    "The future of artificial intelligence is",
    "In the year 2030, technology will"
]

results = generator(
    prompts,
    max_length=50,
    num_return_sequences=1,
    temperature=0.7
)

for prompt, result in zip(prompts, results):
    print(f"Prompt: {prompt}")
    print(f"Generated: {result[0]['generated_text']}\n")

Output (varies each run):

Prompt: The future of artificial intelligence is
Generated: The future of artificial intelligence is likely to be shaped by advances in machine learning and neural networks. As these technologies continue to evolve, we can expect to see more sophisticated systems that can...

Prompt: In the year 2030, technology will
Generated: In the year 2030, technology will have transformed the way we live and work. Self-driving cars will be commonplace, virtual reality will be ubiquitous, and AI assistants will help us with daily tasks...

Note: GPT-2 is smaller and older. For better results, use newer models (we'll cover in later parts).

Translation

Translate between languages:

from transformers import pipeline

# English to French
translator_en_fr = pipeline("translation", model="Helsinki-NLP/opus-mt-en-fr")

# English to German
translator_en_de = pipeline("translation", model="Helsinki-NLP/opus-mt-en-de")

text = "Hello, how are you today?"

fr_result = translator_en_fr(text)[0]['translation_text']
de_result = translator_en_de(text)[0]['translation_text']

print(f"English: {text}")
print(f"French:  {fr_result}")
print(f"German:  {de_result}")

Output:

English: Hello, how are you today?
French:  Bonjour, comment allez-vous aujourd'hui?
German:  Hallo, wie geht es dir heute?

I used this to auto-translate API responses for multi-language support.

Summarization

Summarize long text:

from transformers import pipeline

summarizer = pipeline("summarization", model="facebook/bart-large-cnn")

article = """
Climate change is one of the most pressing challenges facing humanity today.
Rising global temperatures are causing melting ice caps, rising sea levels,
and more frequent extreme weather events. Scientists warn that without immediate
action, the consequences will be catastrophic. Governments worldwide are being
urged to reduce carbon emissions and transition to renewable energy sources.
The Paris Agreement set targets for limiting global warming, but many countries
are not on track to meet their commitments. Individual actions, while important,
are not sufficient without systemic change at government and corporate levels.
"""

summary = summarizer(article, max_length=60, min_length=30, do_sample=False)
print(summary[0]['summary_text'])

Output:

Climate change is one of the most pressing challenges facing humanity. Rising global temperatures are causing melting ice caps, rising sea levels, and more frequent extreme weather events. Scientists warn that without immediate action, the consequences will be catastrophic.

Real use case: Summarizing customer support tickets for quick review.

Zero-Shot Classification

Classify text without training on specific labels:

from transformers import pipeline

classifier = pipeline("zero-shot-classification")

text = "This new phone has an amazing camera and lightning-fast processor."

candidate_labels = ["technology", "sports", "politics", "food", "entertainment"]

result = classifier(text, candidate_labels)

print("Text:", text)
print("\nClassification:")
for label, score in zip(result['labels'], result['scores']):
    print(f"{label:15} -> {score:.4f}")

Output:

Text: This new phone has an amazing camera and lightning-fast processor.

Classification:
technology      -> 0.9847
entertainment   -> 0.0089
sports          -> 0.0034
politics        -> 0.0017
food            -> 0.0013

This is magical: No training required. Just provide labels, it classifies.

I used this when I needed to categorize text but didn't have labeled training data.

Image Tasks

Transformers aren't just for text. They work with images too.

Image Classification

from transformers import pipeline

classifier = pipeline("image-classification")

# Classify image from URL
result = classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")

for item in result:
    print(f"{item['label']:30} -> {item['score']:.4f}")

Output:

Egyptian cat                   -> 0.4526
tabby, tabby cat              -> 0.3012
tiger cat                      -> 0.1854
lynx, catamount               -> 0.0298

Object Detection

from transformers import pipeline

detector = pipeline("object-detection")

# Detect objects in image
results = detector("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")

for result in results:
    print(f"{result['label']:15} -> score: {result['score']:.4f}, box: {result['box']}")

I used this for automated product image tagging in an e-commerce system.

Audio Tasks

Automatic Speech Recognition

from transformers import pipeline

transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base")

# Transcribe audio file
result = transcriber("audio.mp3")
print(result['text'])

Real use case: Transcribing meeting recordings for searchable archives.

Audio Classification

from transformers import pipeline

classifier = pipeline("audio-classification", model="superb/hubert-base-superb-ks")

# Classify audio (keyword spotting)
result = classifier("audio.wav")

for item in result[:5]:
    print(f"{item['label']:20} -> {item['score']:.4f}")

Choosing the Right Model

Pipelines use default models, but you can specify:

# Default sentiment analysis (DistilBERT)
classifier = pipeline("sentiment-analysis")

# Specific model
classifier = pipeline("sentiment-analysis", model="nlptown/bert-base-multilingual-uncased-sentiment")

# Local model
classifier = pipeline("sentiment-analysis", model="/path/to/my/model")

How to find models: Browse Hugging Face Hub

Filter by:

• Task (sentiment analysis, NER, etc.)

• Language (English, French, multilingual)

• Size (for performance trade-offs)

• Popularity (downloads, likes)

Pipeline Parameters

Common Parameters

classifier = pipeline(
    "sentiment-analysis",
    model="distilbert-base-uncased-finetuned-sst-2-english",
    device=0,  # Use GPU 0 (or -1 for CPU)
    batch_size=32,  # Process 32 samples at once
    truncation=True,  # Truncate long inputs
    padding=True  # Pad to same length
)

Task-Specific Parameters

Text generation:

generator = pipeline("text-generation", model="gpt2")

result = generator(
    "The future of AI is",
    max_length=100,  # Maximum tokens to generate
    num_return_sequences=3,  # Generate 3 variations
    temperature=0.8,  # Creativity (0.0 = deterministic, 1.0+ = creative)
    top_k=50,  # Consider top 50 tokens
    top_p=0.95,  # Nucleus sampling
    do_sample=True  # Use sampling instead of greedy
)

Summarization:

summarizer = pipeline("summarization")

summary = summarizer(
    text,
    max_length=150,  # Max summary length
    min_length=50,  # Min summary length
    do_sample=False,  # Deterministic
    num_beams=4  # Beam search width
)

Performance Considerations

CPU vs GPU

# CPU (default)
classifier = pipeline("sentiment-analysis", device=-1)

# GPU 0
classifier = pipeline("sentiment-analysis", device=0)

# Specific GPU
classifier = pipeline("sentiment-analysis", device=1)

Benchmark (on my machine, 1000 texts):

• CPU: 45 seconds

• GPU (RTX 3090): 3 seconds

For production: Use GPU if processing high volume. CPU fine for small-scale.

Batch Processing

Slow (one at a time):

for text in texts:
    result = classifier(text)

Fast (batched):

results = classifier(texts, batch_size=32)

Benchmark:

• Single: 50 seconds for 1000 texts

• Batched (32): 8 seconds

Always batch when possible.

Model Size Trade-offs

Larger models:

• Higher accuracy

• Slower inference

• More memory

Smaller models (DistilBERT, TinyBERT):

• Faster inference

• Less memory

• Slightly lower accuracy

Example comparison (sentiment analysis):

Model	Size	Speed (CPU)	Accuracy
BERT-base	110M	100ms/text	94%
DistilBERT	66M	60ms/text	92%
TinyBERT	14M	20ms/text	88%

I choose based on requirements: Accuracy-critical → BERT. High-volume → TinyBERT.

My First Real Project: Customer Feedback Analyzer

Let me show you the complete system I built.

Requirements:

• Classify sentiment

• Extract topics

• Identify complaints

• Process 10K reviews/day

Solution:

from transformers import pipeline
import pandas as pd

# Load pipelines
sentiment_classifier = pipeline("sentiment-analysis")
ner = pipeline("ner", aggregation_strategy="simple")
zero_shot = pipeline("zero-shot-classification")

# Define complaint categories
complaint_categories = [
    "product quality",
    "shipping",
    "customer service",
    "pricing",
    "other"
]

def analyze_feedback(text):
    """Analyze a single feedback text."""
    
    # Sentiment
    sentiment = sentiment_classifier(text)[0]
    
    # Extract entities (products, brands)
    entities = ner(text)
    products = [e['word'] for e in entities if e['entity_group'] == 'MISC']
    
    # Classify complaint type (if negative)
    complaint_type = None
    if sentiment['label'] == 'NEGATIVE':
        classification = zero_shot(text, complaint_categories)
        complaint_type = classification['labels'][0]
    
    return {
        'sentiment': sentiment['label'],
        'confidence': sentiment['score'],
        'products': products,
        'complaint_type': complaint_type
    }

# Process reviews
reviews = [
    "The product quality is excellent but shipping was extremely slow.",
    "Customer service was rude and unhelpful. Very disappointed.",
    "Amazing product, fast delivery, highly recommend!",
    "Too expensive for what you get. Not worth the price."
]

results = []
for review in reviews:
    result = analyze_feedback(review)
    result['review'] = review
    results.append(result)

# Create DataFrame
df = pd.DataFrame(results)
print(df)

# Save results
df.to_csv('feedback_analysis.csv', index=False)

# Summary statistics
print("\nSummary:")
print(f"Total reviews: {len(df)}")
print(f"Positive: {len(df[df['sentiment']== 'POSITIVE'])}")
print(f"Negative: {len(df[df['sentiment'] == 'NEGATIVE'])}")
print("\nTop complaints:")
print(df[df['complaint_type'].notna()]['complaint_type'].value_counts())

Output:

                                              review sentiment  confidence                   products  complaint_type
0  The product quality is excellent but shipping...  POSITIVE      0.9245                         []        shipping
1  Customer service was rude and unhelpful. Very...  NEGATIVE      0.9987                         []  customer service
2  Amazing product, fast delivery, highly recomm...  POSITIVE      0.9999                         []            None
3  Too expensive for what you get. Not worth the...  NEGATIVE      0.9876                         []         pricing

Summary:
Total reviews: 4
Positive: 2
Negative: 2

Top complaints:
shipping            1
customer service    1
pricing             1

This ran in production for months, processing thousands of reviews daily. Simple, effective, maintainable.

Common Pitfalls and Solutions

Pitfall 1: Not Handling Long Texts

Problem:

classifier = pipeline("sentiment-analysis")
long_text = "word " * 1000  # 1000 words
result = classifier(long_text)  # Error! Max 512 tokens

Solution: Truncate or chunk:

# Truncate
classifier = pipeline("sentiment-analysis", truncation=True)
result = classifier(long_text)

# Or chunk manually
def chunk_text(text, max_words=400):
    words = text.split()
    return [' '.join(words[i:i+max_words]) for i in range(0, len(words), max_words)]

chunks = chunk_text(long_text)
results = classifier(chunks)

Pitfall 2: Ignoring Model Size

Problem: Loading huge model on small machine → OOM error

Solution: Check model size before loading:

# Small devices - use distilled models
classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

# Or check available memory first
import torch
print(f"Available GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")

Pitfall 3: Processing One Item at a Time

Problem: Slow processing

Solution: Always batch:

# Batch processing
results = classifier(texts, batch_size=32)

Best Practices

From my experience:

1. Start with pipelines: Don't overcomplicate. Use pipelines for 90% of tasks.

2. Choose the right model size: Balance accuracy vs. speed for your use case.

3. Batch process: Always process in batches for better performance.

4. Cache models: Load once, reuse many times:

# Bad - loads model each time
def analyze(text):
    classifier = pipeline("sentiment-analysis")  # Slow!
    return classifier(text)

# Good - load once
classifier = pipeline("sentiment-analysis")
def analyze(text):
    return classifier(text)

5. Handle errors gracefully:

try:
    result = classifier(text)
except Exception as e:
    print(f"Error processing text: {e}")
    result = {'label': 'UNKNOWN', 'score': 0.0}

6. Monitor memory: Large models can exhaust memory. Monitor and optimize:

import psutil
print(f"Memory usage: {psutil.Process().memory_info().rss / 1e9:.2f} GB")

What's Next?

We've covered pipelines - the easiest way to use Transformers. But pipelines are just the beginning. In Part 2, we'll dive deeper into:

• How tokenizers actually work

• Understanding model architectures

• Manual processing without pipelines

• Customizing models for specific needs

Next: Part 2 - Understanding Models, Tokenizers, and Preprocessing

---

This article is part of the Hugging Face Transformers 101 series. Check out the series overview for more content.