What's the difference between the Hub, Spaces, and Inference Endpoints?

The Hub is the central registry of model, dataset, and Space repos. Spaces are hosted apps (Gradio, Streamlit, Docker, or static) that demo a model with a public URL. Inference Endpoints are dedicated GPU or CPU instances you provision to serve a specific model with predictable latency, private networking, and org-level access control.

What is ZeroGPU and who can use it?

ZeroGPU is a shared H100 pool available to Hugging Face Pro subscribers. You attach it to a Space by decorating an inference function with `@spaces.GPU` — the GPU is only allocated during the call, so it is dramatically cheaper than renting a dedicated H100. Free-tier users cannot use ZeroGPU; upgrading to Pro is required.

Why should I use safetensors instead of .bin files?

safetensors is a zero-copy, mmap-friendly weight format with no arbitrary code execution risk. Legacy .bin files are pickled Python objects that execute arbitrary code on load — a supply-chain security concern the community solved by moving to safetensors. safetensors is now the default across the Hub and loads 2–4x faster in most cases.

What does 'estimated_time' mean in a 503 response?

The Serverless Inference API lazy-loads models on first request. If the model is not warm, the API returns HTTP 503 with an `estimated_time` field (in seconds) telling the client when to retry. Warm calls return in well under a second. The huggingface_hub Python client honors this automatically; hand-rolled clients must implement the retry loop.

Do I need an HF_TOKEN to download every model?

No. Most models are public and downloadable anonymously. You need an HF_TOKEN for gated models (Llama, some vision models, licensed research checkpoints), for private repos in your account or organization, and for any Serverless Inference or Endpoints call that counts against your quota.

What's the difference between PEFT and TRL?

PEFT (Parameter-Efficient Fine-Tuning) provides adapter-based training methods like LoRA and QLoRA that fine-tune only a small subset of weights. TRL (Transformer Reinforcement Learning) provides reinforcement learning and preference-optimization methods like PPO, DPO, and ORPO. They compose — you can fine-tune with a LoRA adapter under DPO in TRL.

What's GGUF and when should I care about it?

GGUF is the quantized weight format used by llama.cpp, Ollama, and other local inference runtimes. If you plan to run a model on a laptop, a Mac Mini, or a small on-prem box without a GPU, you want a GGUF variant. Many HF model repos ship both safetensors (for GPU inference) and GGUF (for local inference) side by side.

How do I pin a specific version of a model?

Use the `revision` argument in transformers (`from_pretrained(repo_id, revision='abc123')`) or the corresponding argument in huggingface_hub. Revisions can be commit SHAs, branches, or tags. For production, always pin to a commit SHA — branches and tags can be moved by the model author, which will silently change your inference behavior.

Hugging Face glossary: 30 terms every ML developer should know

How to read this glossary

Hugging Face has grown from a Python library into a full platform, and its vocabulary now spans model formats, hosting SKUs, fine-tuning techniques, and enterprise controls. This glossary defines the terms you will most often hit while reading model cards, pricing pages, Discord threads, and support tickets. Entries are alphabetized so you can scan straight to the term you need, and each definition is two to four sentences of plain language with a Hugging Face-specific example where it helps. Nothing here is a full tutorial — the goal is to give you enough shared context that the linked docs stop feeling like jargon soup. If a term is missing, it is almost always either a specific `transformers` class name or a generic ML acronym that Hugging Face uses without translating.

A — Accelerate, Autoscaling

Accelerate is the Hugging Face library that abstracts away device placement, mixed precision, and multi-GPU orchestration so the same training script runs on a laptop CPU, a single A100, or an eight-GPU node. You wrap your model and optimizer in an `Accelerator` object and it handles DDP, FSDP, DeepSpeed, and bf16/fp16 casting behind one API. Autoscaling on Inference Endpoints means the platform adds or removes replicas of your model based on request volume. You set a minimum and maximum replica count plus an idle timeout; below the minimum you can scale to zero, which stops billing at the cost of a cold start on the next request.

C — Cold start

A cold start is the first-request latency you pay after a container has been shut down or evicted. On Spaces this is the 20-90 second window when a sleeping Space wakes up: the runtime pulls the image, mounts the repo, loads weights into VRAM, and only then serves the request. On Inference Endpoints with scale-to-zero the same mechanic applies. Warm requests skip all of that and typically return in tens of milliseconds for small models. Cold starts are the single biggest reason teams keep a minimum of one replica running for user-facing traffic.

D — Datasets, Dedicated Endpoints, Diffusers

Datasets refers to both the `datasets` Python library and the dataset repos on the Hub. The library gives you a unified `load_dataset()` call with streaming, memory-mapped Arrow storage, and a `.map()` API for parallel preprocessing; the Hub hosts hundreds of thousands of dataset repos in Parquet, JSONL, CSV, WebDataset, and other formats. Dedicated Endpoints is the marketing name for Inference Endpoints — instances you provision yourself, as opposed to the shared Serverless Inference pool. Diffusers is the counterpart of `transformers` for diffusion models: Stable Diffusion, SDXL, Flux, and text-to-video pipelines all load through a `DiffusionPipeline.from_pretrained()` call that mirrors the transformers API.

E — Enterprise Hub

Enterprise Hub is the paid organizational tier that adds SSO (SAML and OIDC), audit logs, resource groups, storage region controls, and higher rate limits on top of the standard Hub. Storage regions let an enterprise pin their private repos to a specific AWS region — currently US-East and EU-West — for data-residency compliance. Inference for Enterprise is the companion product that gives the same organization private, higher-quota access to Serverless Inference and dedicated capacity on Inference Endpoints with a single billing contract.

G — Gated models, GGUF

A gated model is a Hub repo that requires you to accept a license or usage agreement before downloading. Llama, Gemma, and many research checkpoints are gated: you click Accept on the model page, and from then on any download or inference call using your `HF_TOKEN` succeeds. Without the token, or from an unauthorized account, you get a 401. GGUF is the quantized weight format used by llama.cpp, Ollama, LM Studio, and every other local-inference runtime. If you plan to run a model on a laptop or a Mac Mini without a discrete GPU, you want the GGUF variant; many popular models ship both safetensors (for GPU serving) and GGUF (for local inference) in the same repo.

I — Inference Endpoints, Inference for Enterprise

Inference Endpoints are dedicated CPU or GPU instances you provision to serve one specific model with predictable latency, private networking, and org-level access control. You pick a hardware SKU (for example `nvidia-l4` or `nvidia-a100-80gb`), the platform builds a container, and you get an HTTPS URL that stays exclusively yours. Billing is per second the instance is running. Inference for Enterprise is the same product bundled into an enterprise contract with committed capacity, higher quotas, and consolidated billing across Serverless and Endpoints.

M — Model cards, Model Hub

The Model Hub is huggingface.co itself — the central registry of over a million model, dataset, and Space repos backed by git and Git LFS. A model card is the README.md at the root of a model repo, and it is where the community documents intended use, training data, evaluation numbers, known biases, and license. Well-run repos treat the model card as a first-class deliverable; the Hub UI renders its YAML frontmatter into structured metadata that powers search filters, badges, and license enforcement.

P — PEFT and LoRA, Private repos

PEFT stands for Parameter-Efficient Fine-Tuning and is both a technique family and a Hugging Face library. LoRA (Low-Rank Adaptation) is the most common member: instead of updating all seven billion parameters of a 7B base model, you train a pair of small low-rank matrices that get added to specific layers, cutting training cost by ten to a hundred times. QLoRA extends that to 4-bit quantized base weights so you can fine-tune 70B models on a single 48GB GPU. Private repos are Hub repos that only members of your account or organization can see; combined with fine-grained tokens they are how teams ship internal models without exposing weights to the public.

R — Replicas

A replica is one running instance of your model on Inference Endpoints. Requests are load-balanced across all healthy replicas of an endpoint, so doubling replicas roughly doubles throughput. Autoscaling policies operate on the replica count: you set `min_replica` and `max_replica`, and the platform adds instances when queue depth crosses a threshold and removes them after an idle timeout. Scale-to-zero simply means `min_replica = 0`.

S — Safetensors, Serverless Inference API, Spaces, Spaces hardware tiers, Storage regions

Safetensors is a zero-copy, memory-mappable weight format that replaced pickled `.bin` files across the Hub. Because it does not execute arbitrary code on load it removed a large supply-chain risk, and it loads two to four times faster than the legacy format in most cases. The Serverless Inference API (also called Inference API) is the shared, rate-limited HTTPS endpoint at `api-inference.huggingface.co` that lets you call thousands of Hub models without provisioning anything; free-tier users get a modest monthly quota, Pro and Enterprise raise it. Spaces are hosted apps — Gradio, Streamlit, Docker, or static — that give a model a public URL for demos, evaluation, and lightweight production. Spaces hardware tiers span CPU basic (free), CPU upgrade, Nvidia T4 small, T4 medium, L4, A10G small and large, A100 40GB and 80GB, and H100; each has a documented hourly rate and is billed per second the Space is running. Storage regions let Enterprise Hub orgs pin private repos to US or EU storage for compliance.

T — TEI, TGI, Tokens, Transformers

TGI is Text Generation Inference, Hugging Face's production LLM serving container. It bundles continuous batching, paged attention, tensor parallelism, quantization support, and an OpenAI-compatible `/v1/chat/completions` route, and it is what powers Inference Endpoints' `text-generation` task by default. TEI is Text Embeddings Inference, the equivalent optimized server for embedding and reranker models. Tokens on the Hub come in three flavors: read tokens (download and inference), write tokens (upload and repo admin), and fine-grained tokens where you check individual scopes and pin the token to specific repos or organizations. Transformers is the flagship Python library that gave the company its name and remains the standard way to load and run BERT, GPT, Llama, and every other Transformer-family model.

Z — ZeroGPU

ZeroGPU is a shared H100 pool available to Hugging Face Pro subscribers and to Enterprise orgs. Instead of renting a dedicated H100 you decorate a function inside your Space with `@spaces.GPU`; the GPU is attached only for the duration of that call and released immediately, so you effectively pay for GPU-seconds instead of GPU-hours. It is ideal for demos and low-QPS workloads where a full dedicated H100 would be idle most of the time, and it has become the default way to ship image, video, and small-LLM Spaces without an enterprise budget.

How to use this glossary

Treat this page as a lookup, not a reading list. When you hit a term in a Hugging Face doc or model card, jump straight to its entry, absorb the two to four sentences, and go back to what you were doing. If you are onboarding onto the platform, the two clusters that pay off first are the platform terms (Hub, Spaces, Inference Endpoints, Serverless Inference API) and the format terms (safetensors, GGUF, Parquet) — everything else layers on top of those. When a term is missing, search the `transformers` and `huggingface_hub` repositories on GitHub before assuming it is undocumented; nine times out of ten it is a class name defined there. Bookmark this page and revisit it whenever Hugging Face ships new hardware tiers or launches a new library, because the vocabulary evolves faster than the docs do.