Generative Modeling & Hugging Face

So far we studied how transformers work inside. Now let us start using them. In this session you will understand the two main ways language models are trained, get to know Hugging Face (the “GitHub of AI models”), and run a real model on a free GPU.

01Autoregressive vs autoencoding

Language models learn by playing a prediction game on text. There are two main styles of game:

In maths, an autoregressive model breaks the probability of a sentence into a chain of next-token probabilities:

That is why generative models are autoregressive: to write a sentence, they keep sampling the next token and feeding it back in (Session 21). Autoencoding models cannot do this naturally, because they need to see the whole sentence at once.

02The Hugging Face ecosystem

Hugging Face is the place where the AI community shares models, datasets and demos, plus the open-source libraries to use them. The Hub hosts well over a million models.

Read the model card first

Before you use any model, open its model card and check:

• Task and language: is it trained for your task (chat, classification, embeddings) and your language (English, Hindi…)?
• Size: number of parameters decides how much GPU memory you need.
• License: Apache-2.0 and MIT are business-friendly; some models restrict commercial use or require accepting terms (“gated” models).
• Training data and limitations: known biases, safety notes and evaluation results.

03Pipelines: the 3-line shortcut

A pipeline wraps the tokenizer, model and post-processing together. Just pick a task:

# pip install transformers torch
from transformers import pipeline

sentiment = pipeline("sentiment-analysis")
print(sentiment("The new UPI app is super fast and easy to use!"))

ner = pipeline("ner", aggregation_strategy="simple")
print(ner("Priya Sharma opened an account at HDFC Bank in Pune."))

Other ready tasks include "summarization", "translation", "question-answering", "zero-shot-classification", "text-generation" and "automatic-speech-recognition". When you do not name a model, a default is downloaded; in real projects always pin the exact model name.

04Loading a model and tokenizer yourself

For more control, load the two parts directly. The Auto classes read the model’s config and pick the right architecture for you.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

name = "Qwen/Qwen2.5-0.5B-Instruct"                 # small, open, instruction-tuned
tok = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(name, torch_dtype=torch.float16, device_map="auto")

messages = [{"role": "user", "content": "Explain UPI to a 10-year-old in 2 lines."}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)

out = model.generate(inputs, max_new_tokens=80)
print(tok.decode(out[0][inputs.shape[-1]:], skip_special_tokens=True))

05Running on a free Colab GPU

1. Open Google Colab and create a new notebook.
2. Go to Runtime → Change runtime type → T4 GPU and save.
3. Check the GPU: import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))
4. Install libraries: !pip install -q transformers accelerate, then run the code above.

The free T4 has 16 GB of GPU memory. A quick rule: model weights need about parameters × bytes per parameter, plus some extra for activations and the KV cache. Try it:

06Summary

• Autoregressive models predict the next token and generate text; autoencoding models fill blanks and understand text.
• Hugging Face gives you the Hub plus Transformers, Datasets, Tokenizers and PEFT.
• Always read the model card: task, size, license, limitations.
• pipeline() is the quickest start; AutoTokenizer + AutoModel… give full control.
• Memory ≈ parameters × bytes: a 7B model needs ~14 GB in FP16 but ~3.5–4 GB in INT4.

07Quick quiz

08References

• Hugging Face LLM Course (free)
• Transformers pipelines documentation
• Chat templates guide