Hugging Face Transformers Interview Questions Hindi mein

जवाब: datasets

`datasets` loads data from the Hub or local files into Arrow-backed tables and provides `map`, `filter` and splits. transformers runs models, accelerate handles devices and peft handles adapter fine-tuning.

जवाब: So that each token can only attend to itself and earlier tokens while generating

Generation predicts the next token, so a position must not peek at future tokens. The causal mask hides them; it does not change the quadratic cost.

जवाब: The files are reused from the local Hugging Face cache

Downloaded files are stored in the local cache (by default under ~/.cache/huggingface, or HF_HOME), so later loads read from disk.

जवाब: Postprocessing

The model returns logits. Postprocessing applies softmax and maps the highest index to a label name from the model config.

जवाब: zero-shot-classification

Zero-shot classification accepts candidate labels at call time and needs no task-specific training data.

जवाब: Places model layers across the available GPUs and CPU memory automatically

device_map="auto" uses accelerate to place layers on available devices. Quantisation and remote inference are separate features.

जवाब: Merges the most frequent adjacent pair of symbols into a new token

BPE training starts from small units and keeps merging the most frequent adjacent pair until the vocabulary reaches its target size.

जवाब: It marks which positions are real tokens (1) and which are padding (0)

attention_mask is an input, not an output: 1 means attend to this position, 0 means it is padding and should be ignored.

जवाब: The length of the longest sequence in the batch

padding=True means padding="longest": rows are padded to the longest sequence in that batch. Use padding="max_length" for a fixed size.

जवाब: AutoModelForSequenceClassification

Sequence classification puts a head on the pooled sentence representation. Token classification produces one prediction per token, and AutoModel has no head at all.

जवाब: It stops PyTorch from recording operations for gradients, saving memory and time

These context managers disable gradient tracking. Dropout is controlled by model.eval(), and softmax is a separate step.

जवाब: AutoModelForCausalLM

Decoder-only models are causal language models. Seq2SeqLM is for encoder-decoder models such as T5 and BART.

जवाब: To avoid recomputing keys and values for earlier tokens at every step

Each step only adds one token, so cached keys and values of earlier positions are reused instead of recomputed.

जवाब: The distribution sharpens, so the most likely tokens are chosen far more often

Dividing logits by a small temperature widens the gaps between them, so softmax concentrates probability on the top tokens.

जवाब: The marker that starts the assistant's turn, so the model replies instead of continuing the user

It appends the assistant-turn header defined by the template, cueing the model to answer.

जवाब: So your code keeps loading exactly the weights you tested even if the repo is updated

A commit hash is immutable, so the same files are loaded every time. Branch names such as main can move.

जवाब: They used a different tokenizer than the one the model was trained with

Ids only make sense with the matching vocabulary. Always save and load the tokenizer together with the model.

जवाब: Arrow files are memory-mapped from disk, so rows are read on demand

Datasets are stored as Arrow files and memory-mapped. Streaming is a separate, optional mode.

जवाब: A dictionary whose values are lists, one list per column for a batch of rows

In batched mode each column arrives as a list covering the batch, which is what fast tokenizers process efficiently.

जवाब: Fine-tune a small pretrained encoder such as a DistilBERT or BERT checkpoint

A small pretrained encoder fine-tuned on a few thousand examples is fast, cheap and typically strong for fixed-label classification.

जवाब: The model's forward pass computes it and returns it in the outputs

Task models compute an appropriate loss (cross-entropy for classification) when labels are passed, and Trainer backpropagates it.

जवाब: Recall (or F1) on the spam class

A model that predicts "not spam" for everything is also 98% accurate. Recall and F1 on the minority class show whether spam is caught.

जवाब: accelerator.backward(loss)

accelerator.backward handles scaling for mixed precision and distributed gradient synchronisation.

जवाब: Only the small low-rank matrices added to selected layers

LoRA freezes the base model and trains the low-rank A and B matrices, which is why memory use and file size drop so much.

जवाब: About 14 GB

bfloat16 uses 2 bytes per parameter: 7e9 x 2 bytes is 14 GB, about 13 GiB, before activations and KV cache.

जवाब: The frozen base model weights

The frozen base model is quantized to 4-bit to save memory; the small adapters are trained in higher precision.

जवाब: Using a smaller model fine-tuned for the task

A small task-specific model does far less computation per request. float32 is slower than bfloat16, and turning off batching reduces throughput.

जवाब: Adding new requests to a running batch as soon as other sequences finish

Continuous batching keeps the GPU busy by swapping finished sequences out and new requests in at each generation step.

जवाब: It only stores tensors and metadata, so loading cannot execute arbitrary code

Pickle can encode code that runs on load. safetensors is a simple tensor format with no code execution path.

जवाब: Duplicate or near-duplicate examples shared between train and test splits

Leakage between splits makes the test set measure memorisation. Deduplicate before splitting.

जवाब: Chat with a decoder-only model -> AutoModelForCausalLM

Decoder-only chat models are causal LMs. T5 uses Seq2SeqLM, sentence classification uses SequenceClassification and NER uses TokenClassification.

जवाब: The model id pointed to a branch that moved; pinning a commit revision would have kept the old weights

Loading by name tracks the main branch. Pinning a commit hash keeps the exact files and makes runs reproducible.

जवाब: Load it in 4-bit and train LoRA adapters (QLoRA), then evaluate on held-out FAQs

4-bit weights for a 7B model take a few GB, leaving room for LoRA training. Full float32 fine-tuning needs many times more memory.