HuggingFace Transformers Guide 2026 — NLP, Vision, and Audio

pip install transformers datasets accelerate tokenizers
pip install torch  # or tensorflow, or jax

from transformers import pipeline
 
# Sentiment analysis
classifier = pipeline("sentiment-analysis")
result = classifier("HuggingFace Transformers makes NLP easy!")
# [{'label': 'POSITIVE', 'score': 0.9998}]
 
# Named Entity Recognition
ner = pipeline("ner", grouped_entities=True)
entities = ner("Apple Inc. was founded by Steve Jobs in Cupertino, California.")
# [{'entity_group': 'ORG', 'word': 'Apple Inc.'},
#  {'entity_group': 'PER', 'word': 'Steve Jobs'}, ...]
 
# Summarization
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
summary = summarizer(long_article, max_length=130, min_length=30)
 
# Translation
translator = pipeline("translation_en_to_fr", model="Helsinki-NLP/opus-mt-en-fr")
result = translator("Machine learning is transforming every industry.")
 
# Question Answering
qa = pipeline("question-answering")
result = qa(
    question="What year was Python created?",
    context="Python was created by Guido van Rossum and first released in 1991."
)
# {'answer': '1991', 'score': 0.998}

from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from datasets import load_dataset
import numpy as np
from sklearn.metrics import accuracy_score
 
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
 
dataset = load_dataset("imdb")
 
def tokenize(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)
 
tokenized = dataset.map(tokenize, batched=True)
 
def compute_metrics(pred):
    labels = pred.label_ids
    preds = np.argmax(pred.predictions, axis=-1)
    return {"accuracy": accuracy_score(labels, preds)}
 
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)
 
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized["train"].select(range(5000)),
    eval_dataset=tokenized["test"].select(range(1000)),
    compute_metrics=compute_metrics,
)
 
trainer.train()
trainer.save_model("./my-sentiment-model")

from sentence_transformers import SentenceTransformer
import numpy as np
 
model = SentenceTransformer("all-MiniLM-L6-v2")  # Fast, accurate, 22MB
 
sentences = [
    "Machine learning algorithms improve with more data",
    "Deep learning uses neural networks with many layers",
    "Python is the most popular language for data science",
    "The stock market closed higher today",
]
 
embeddings = model.encode(sentences, normalize_embeddings=True)
 
def semantic_search(query: str, corpus_embeddings: np.ndarray, sentences: list, top_k: int = 3):
    query_embedding = model.encode([query], normalize_embeddings=True)
    scores = np.dot(corpus_embeddings, query_embedding.T).flatten()
    top_indices = np.argsort(scores)[::-1][:top_k]
    return [(sentences[i], float(scores[i])) for i in top_indices]
 
results = semantic_search("neural network training", embeddings, sentences)
for sentence, score in results:
    print(f"{score:.3f}: {sentence}")

from transformers import ViTForImageClassification, ViTImageProcessor
from PIL import Image
import torch
 
model_name = "google/vit-base-patch16-224"
processor = ViTImageProcessor.from_pretrained(model_name)
model = ViTForImageClassification.from_pretrained(model_name)
 
def classify_image(image_path: str) -> list[dict]:
    image = Image.open(image_path).convert("RGB")
    inputs = processor(images=image, return_tensors="pt")
 
    with torch.no_grad():
        outputs = model(**inputs)
 
    probs = torch.softmax(outputs.logits, dim=-1)[0]
    top5 = torch.topk(probs, 5)
 
    return [
        {"label": model.config.id2label[idx.item()], "confidence": round(prob.item(), 4)}
        for prob, idx in zip(top5.values, top5.indices)
    ]
 
results = classify_image("dog.jpg")
# [{'label': 'golden retriever', 'confidence': 0.9834}, ...]

from transformers import pipeline
import torch
 
pipe = pipeline(
    "automatic-speech-recognition",
    model="openai/whisper-base",
    device="cuda" if torch.cuda.is_available() else "cpu",
    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
)
 
result = pipe("audio.mp3", return_timestamps=True)
print(result["text"])
 
# For audio files longer than 30 seconds
result = pipe("long_lecture.mp3", chunk_length_s=30, batch_size=8, return_timestamps=True)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import pipeline
import torch
 
app = FastAPI(title="NLP API")
models = {}
 
@app.on_event("startup")
async def load_models():
    device = 0 if torch.cuda.is_available() else -1
    models["sentiment"] = pipeline("sentiment-analysis", device=device)
    models["ner"] = pipeline("ner", grouped_entities=True, device=device)
    models["summarize"] = pipeline("summarization", model="facebook/bart-large-cnn", device=device)
 
class TextRequest(BaseModel):
    text: str
 
@app.post("/sentiment")
async def sentiment(req: TextRequest):
    return models["sentiment"](req.text[:512])[0]
 
@app.post("/ner")
async def ner(req: TextRequest):
    return models["ner"](req.text[:512])
 
@app.post("/summarize")
async def summarize(req: TextRequest):
    if len(req.text) < 50:
        raise HTTPException(400, "Text too short to summarize")
    result = models["summarize"](req.text[:1024], max_length=130, min_length=30)
    return {"summary": result[0]["summary_text"]}