Hugging Face Cheat Sheet

Hugging Face is the most widely used AI platform today, powering NLP, Vision, Speech, and Generative AI applications. Many newcomers struggle to use pre-trained models, tokenizers, datasets, and training workflows properly. This cheat sheet simplifies everything you need, from installation to fine-tuning, quantization, diffusion, and deployment.

This guide is designed to help learners and working professionals build Hugging Face projects confidently. Whether you are analyzing text, generating summaries, developing speech models, or producing Stable Diffusion images, this cheat sheet gives you the exact commands and workflows you need.

Installing Hugging Face Libraries

Installing Hugging Face correctly sets the foundation for using pretrained models, datasets, pipelines, and diffusion systems. These packages enable NLP processing, accelerated GPU training, image generation, and tokenizer handling. Whether you're running local prototypes or large-scale AI pipelines, these commands ensure your environment is ready to execute all operations smoothly.

pip install transformers

pip install datasets

pip install diffusers

pip install accelerate

pip install tokenizers

pip install sentencepiece

pip install torch

pip install tensorflow

pip install huggingface-hub

pip install huggingface-cli

Pipeline-Based Quick Usage

Pipelines offer the fastest way to start using Hugging Face models. They wrap tokenization, model loading, and formatting in a single call. Pipelines are ideal for prototyping, demos, automated text analysis, research, and real-world applications where you need results instantly without diving deep into architectures or custom training loops.

pipeline("sentiment-analysis")("I like HuggingFace")

pipeline("text-classification")("Hello")

pipeline("question-answering")({"context":..., "question":...})

pipeline("summarization")("Long article…")

pipeline("translation_en_to_fr")("Hello")

pipeline("text-generation", model="gpt2")("AI is")

pipeline("ner")("Hugging Face Inc. is in NY")

Loading Pre-trained Models & Tokenizers

Hugging Face enables seamless loading of pre-trained models and tokenizers from the Model Hub or offline storage. This is essential for fine-tuning, inference, and experimentation. You can load large language models, classification heads, image models, and tokenizers with just a few commands, allowing efficient reuse across multiple workflows.

AutoTokenizer.from_pretrained("bert-base-uncased")

AutoModel.from_pretrained("bert-base-uncased")

AutoModelForSeqClassification

AutoModelForCausalLM

model.save_pretrained("path")

tokenizer.save_pretrained("path")

from_pretrained("./local_dir")

Tokenization & Data Encoding

Tokenization converts raw text into machine-friendly token IDs, attention masks, and tensors. Correct tokenization is essential for both training and inference. Hugging Face makes tokenization efficient with batch support, padding, truncation, and easy decoding, ensuring models receive consistent input formats regardless of text length.

tokenizer("text")

tokenizer(text, return_tensors="pt")

tokenizer.batch_encode_plus(list)

return_attention_mask=True

padding="max_length"

truncation=True

tokenizer.decode(token_ids)

Working with Hugging Face Datasets

The Datasets library offers thousands of datasets optimized for speed and memory efficiency. Using Arrow-based storage allows fast mapping, filtering, splitting, and preprocessing without loading full datasets into memory. This makes it ideal for large language model fine-tuning, benchmarking, and real-world training workloads.

from datasets import load_dataset

load_dataset("imdb")

dataset["train"], dataset["test"]

dataset.shuffle()

dataset.map(fn)

dataset.filter(fn)

train_test_split(test_size=0.2)

Training / Fine-Tuning with Trainer API

The Trainer API automates training pipelines by handling gradient updates, evaluation, checkpoint saving, and logging without manually writing PyTorch loops. It is widely used for classification, summarization, translation, and embedding generation workflows. Trainer simplifies development and accelerates experimentation.

TrainingArguments()

Trainer(model, args, train_dataset)

trainer.train()

trainer.evaluate()

per_device_batch_size

logging_steps

save_steps

gradient_accumulation_steps

PyTorch Manual Training (Barebones)

Advanced users sometimes need full control over training logic beyond the Trainer API. Manual training loops allow custom loss functions, experimental techniques, and alternate optimization strategies. The commands below show the core steps in PyTorch-based Hugging Face fine-tuning workflows.

outputs = model(**inputs)

loss = outputs.loss

loss.backward()

optimizer.step()

Model Hub (Search, Download, Upload)

The Hugging Face Hub is where more than 500,000 pretrained models are stored. You can search, download, and upload models for inference, fine-tuning, and sharing. This simplifies collaboration across teams and ensures reproducible AI workflows

huggingface-cli login

huggingface-cli search "bert"

model.push_to_hub("name")

tokenizer.push_to_hub("name")

huggingface-cli repo create

huggingface-cli logout

Vision Models (Image Classification, Detection)

Hugging Face supports numerous vision models that help classify objects, detect entities, and extract image embeddings. This empowers developers to work on projects related to computer vision, automated inspection, image tagging, and multimodal systems without needing separate frameworks.

pipeline("image-classification")

pipeline("object-detection")

AutoProcessor

AutoModelForImageClassification

AutoModelForObjectDetection

Diffusers (Text to Image)

Diffusers allow generative image development using Stable Diffusion models. They are suitable for producing AI visuals, marketing creatives, wallpapers, design assets, and conceptual art. This section gives the essential commands to run diffusion pipelines efficiently using the GPU.

StableDiffusionPipeline

pipe = StableDiffusionPipeline.from_pretrained()

pipe.to("cuda")

img = pipe("a scenic forest").images[0]

img.save("result.png")

enable_model_cpu_offload()

Accelerate for Multi-GPU Training

Accelerate simplifies distributed and large-scale training across multiple GPUs without manually writing synchronization logic. It supports mixed precision training, deepspeed integration, and fully parallelized execution, reducing memory footprint and improving performance.

pip install accelerate

accelerate config

accelerate launch train.py

mixed_precision="fp16"

deepspeed integration

Quantization & Memory Optimization

Quantization compresses large models, reducing GPU memory usage and improving inference speed. These settings are essential when running LLMs such as GPT-Neo, GPT-J, or Stable Diffusion models on limited hardware.

torch_dtype="float16"

low_cpu_mem_usage=True

device_map="auto"

bitsandbytes quantization

flash_attention

ONNX & Deployment

Deploying Hugging Face models requires optimized execution. ONNX offers high-speed inference, while FastAPI enables cloud endpoints. SafeTensors ensures secure serialization. These deployment options help you put ML models into actual production environments.

transformers.onnx

onnxruntime

FastAPI + HF

TorchScript

safe tensors

Audio & Speech (Whisper & Wav2Vec)

Hugging Face supports automatic speech recognition (ASR) tasks including transcription, audio labeling, and speech-to-text models. Whisper and Wav2Vec are among the most accurate open-source ASR systems for multilingual speech processing.

pipeline("automatic-speech-recognition")

WhisperProcessor

WhisperForConditionalGeneration

Wav2Vec2ForCTC

CLIP Multi-Modal (Vision + Text)

CLIP connects visual and textual representations, allowing tasks such as zero-shot classification and multimodal retrieval. It enables understanding of the relationship between images and text without explicit training on the target dataset.

CLIPProcessor

CLIPModel

pipeline("zero-shot-image-classification")

Useful Troubleshooting Helpers

Debugging AI workloads requires monitoring GPU memory, freeing RAM, and preventing shape mismatch errors. These commands help diagnose system-level issues and prevent crashes during training and inference.

torch.cuda.is_available()

nvidia-smi

batch_size reduction

padding/truncation

model.eval()

del model; gc.collect()

Popular Model Examples by Task

Choosing the right model ensures efficient training and high accuracy. Hugging Face models excel in multiple domains such as NLP, vision, speech, and generative AI. This table gives quick suggestions for selecting models based on your use case.

Wrapping Up

This Hugging Face cheat sheet helps you work confidently with modern ML models across NLP, vision, speech, and image generation. Keep practicing commands, experiment with fine-tuning, and explore deployment options. Hugging Face will quickly become a powerful tool in your AI development workflow.

Course Schedule