Transformers Cheatsheet: Pipelines, AutoModels and Trainer Reference

# Core + the bits you usually want
pip install -U "transformers[torch]" datasets accelerate evaluate

# Optional speedups
pip install -U flash-attn --no-build-isolation   # Ada / Hopper GPUs
pip install -U bitsandbytes                      # 4 / 8-bit weights

# Hub auth (download gated / private models, push checkpoints)
huggingface-cli login

# Sanity test the install
python - <<'PY'
import torch
from transformers import pipeline
print(torch.cuda.is_available(), torch.cuda.device_count())
print(pipeline("sentiment-analysis")("Transformers is great"))
PY

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

name = "Qwen/Qwen2.5-7B-Instruct"
tok   = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(
    name, torch_dtype=torch.bfloat16, device_map="auto",
    attn_implementation="flash_attention_2",
)

messages = [
    {"role": "system", "content": "You are a careful assistant."},
    {"role": "user",   "content": "Summarise the Transformer paper in 2 lines."},
]
inputs = tok.apply_chat_template(
    messages, add_generation_prompt=True, return_tensors="pt",
).to(model.device)

# Sampling + repetition controls + streaming
streamer = TextStreamer(tok, skip_prompt=True, skip_special_tokens=True)
out = model.generate(
    inputs,
    max_new_tokens=256,
    do_sample=True, temperature=0.7, top_p=0.9, top_k=50,
    repetition_penalty=1.1,
    eos_token_id=tok.eos_token_id,
    pad_token_id=tok.eos_token_id,
    streamer=streamer,
)

from datasets import load_dataset
from transformers import (
    AutoModelForSequenceClassification, AutoTokenizer,
    DataCollatorWithPadding, Trainer, TrainingArguments,
)
import evaluate, numpy as np

name = "bert-base-uncased"
tok   = AutoTokenizer.from_pretrained(name)
model = AutoModelForSequenceClassification.from_pretrained(name, num_labels=2)

ds = load_dataset("imdb").shuffle(seed=42)
ds["train"] = ds["train"].select(range(2000))   # subsample for speed

def tokenize(b):
    return tok(b["text"], truncation=True, max_length=256)

ds = ds.map(tokenize, batched=True)

accuracy = evaluate.load("accuracy")
def metrics(p):
    return accuracy.compute(
        predictions=np.argmax(p.predictions, axis=1), references=p.label_ids,
    )

args = TrainingArguments(
    output_dir="out", num_train_epochs=2,
    per_device_train_batch_size=16, per_device_eval_batch_size=32,
    learning_rate=2e-5, warmup_ratio=0.06, weight_decay=0.01,
    eval_strategy="epoch", save_strategy="epoch",
    load_best_model_at_end=True, metric_for_best_model="accuracy",
    bf16=True, logging_steps=20, report_to="none",
)

Trainer(
    model=model, args=args,
    train_dataset=ds["train"], eval_dataset=ds["test"],
    tokenizer=tok, data_collator=DataCollatorWithPadding(tok),
    compute_metrics=metrics,
).train()

# Local Q&A: load 4-bit -> chat-template prompt -> stream answer.
import torch
from transformers import (
    AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TextIteratorStreamer,
)
from threading import Thread

name = "meta-llama/Llama-3.1-8B-Instruct"
bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
                         bnb_4bit_compute_dtype=torch.bfloat16)

tok   = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(
    name, quantization_config=bnb, device_map="auto",
    attn_implementation="flash_attention_2",
)

def ask(question: str) -> str:
    msgs = [
        {"role": "system", "content": "Answer concisely."},
        {"role": "user",   "content": question},
    ]
    ids = tok.apply_chat_template(msgs, add_generation_prompt=True,
                                  return_tensors="pt").to(model.device)
    streamer = TextIteratorStreamer(tok, skip_prompt=True, skip_special_tokens=True)
    Thread(target=model.generate, kwargs=dict(
        input_ids=ids, streamer=streamer, max_new_tokens=400,
        do_sample=False, eos_token_id=tok.eos_token_id, pad_token_id=tok.eos_token_id,
    )).start()
    return "".join(streamer)

print(ask("Explain attention in one paragraph."))