PyTorch Interview Questions Hindi mein

जवाब: Each operation executes immediately as Python reaches it, so you can print and debug normally

In eager mode every line runs as soon as Python executes it. That is why you can use print, debuggers and ordinary control flow inside a model.

जवाब: A compatible NVIDIA driver

The wheels bundle the CUDA runtime and cuDNN libraries. The one thing they cannot ship is the kernel driver, so a compatible NVIDIA driver must be installed.

जवाब: The size of each parameter update step

The update is `w - lr * grad`. The gradient gives the direction; the learning rate scales how far you move.

जवाब: torch.int64

Python integers are inferred as `torch.int64`. Python floats would give `torch.float32`.

जवाब: (32,)

`dim=1` (the features) collapses, leaving one value per example: shape `(32,)`. With `keepdim=True` it would be `(32, 1)`.

जवाब: `view` never copies and errors if it cannot, while `reshape` copies when a view is impossible

`view` is strict: same storage or an error. `reshape` is flexible: it returns a view when the layout allows and a copy otherwise.

जवाब: (4, 5, 3)

Align from the right: 3 vs 1 gives 3, 1 vs 5 gives 5, and 4 vs missing gives 4. The result is `(4, 5, 3)`.

जवाब: The sum of the gradients from both calls

Backward adds into `.grad`. Each graph is used once, so no error is raised, and with no clearing, `x.grad` holds the sum. That is why training loops call `optimizer.zero_grad()`.

जवाब: Leaf tensors that have `requires_grad=True`

Intermediate gradients are discarded to save memory unless you call `retain_grad()`. Leaves with requires_grad, such as model parameters, keep theirs in `.grad`.

जवाब: `loss.item()`

`loss.item()` returns a plain Python float with no link to the graph. Storing the tensor keeps the whole graph and its memory alive.

जवाब: `model(x)` runs registered hooks around `forward`, which calling `forward` directly skips

`nn.Module.__call__` handles hooks and then calls `forward`. Calling `forward` directly bypasses that machinery; gradients and devices are unaffected.

जवाब: Without them, stacked Linear layers are equivalent to a single Linear layer

A composition of linear maps is linear, so depth would add nothing. Activations make the network able to represent non-linear functions.

जवाब: `nn.CrossEntropyLoss` on the raw logits with `int64` labels

CrossEntropyLoss expects raw logits and class-index targets; it applies log_softmax itself. Adding softmax first double-applies it and weakens gradients.

जवाब: AdamW applies weight decay directly to the weights instead of adding it to the gradient

AdamW decouples weight decay from the adaptive gradient update. Momentum-like running averages and scheduling work the same as in Adam.

जवाब: `zero_grad()`, forward and loss, `backward()`, `step()`

Clear gradients, compute the loss, back-propagate, then update. Any other order either uses stale gradients or wipes the new ones before they are used.

जवाब: The behaviour of layers such as Dropout and BatchNorm

`eval()` flips the training flag that Dropout and BatchNorm read. Gradient tracking needs `no_grad()` or `inference_mode()` separately.

जवाब: `__len__` and `__getitem__`

Map-style datasets are indexed: `__len__` gives the size and `__getitem__` returns one sample. `__iter__` belongs to `IterableDataset`.

जवाब: Loads samples in four background processes while the main process trains

Workers are separate processes that run `__getitem__` and collation in parallel, so the next batches are ready when the training step needs them.

जवाब: Validation must be deterministic so scores are comparable and reflect real inputs

Augmentation is a training-time regulariser. Validation should measure the model on consistent, unaltered inputs.

जवाब: It makes the head independent of the input image size

Global average pooling always outputs one value per channel, so the Linear layer's input size stays the same whatever the height and width of the input.

जवाब: Freeze a pretrained backbone and train a new 5-class head

With little data, feature extraction is fast and resists overfitting. The head must be replaced to output 5 classes.

जवाब: An integer tensor of token indices

An embedding is a lookup table indexed by integer ids. Passing floats raises an error; one-hot vectors are unnecessary.

जवाब: It fails with a device mismatch, because `x` itself is still on the CPU

`tensor.to()` returns a new tensor. Without reassignment, `x` stays on the CPU and the forward pass mixes devices.

जवाब: Small gradient values can underflow to zero in float16, and scaling the loss keeps them representable

float16's limited range flushes tiny values to zero. Scaling the loss scales every gradient up; they are unscaled before the step.

जवाब: Speed up data loading, for example with more `num_workers` and `pin_memory=True`

An idle GPU is usually waiting for the input pipeline. Parallel loading and pinned memory keep batches ready; extra synchronisation would slow things further.

जवाब: `torch.save(model.state_dict(), path)`, then rebuild the class and call `load_state_dict`

A state dict holds only tensors keyed by name, so it survives refactoring. Pickling the whole model ties the file to your exact class and module path.

जवाब: Try to overfit a single small batch to near-zero loss

A correct model and loss can memorise one batch. If it cannot, something in the code is broken; the other options assume the code already works.

जवाब: Raises an error naming the operation

It raises a RuntimeError so you know reproducibility cannot be guaranteed, instead of quietly running nondeterministic code.

जवाब: Compare its outputs with the original eager model on sample inputs

Export can change behaviour (for example through unsupported operations or mode mistakes). Comparing outputs with `torch.testing.assert_close` catches that early.

जवाब: `model.eval()` together with `torch.inference_mode()` (or `no_grad()`)

`eval()` fixes Dropout and BatchNorm behaviour; `inference_mode()` or `no_grad()` stops graph building. You need both.

जवाब: It applies log_softmax internally, so an extra softmax distorts the loss and weakens gradients

CrossEntropyLoss combines log_softmax and negative log-likelihood. Feeding probabilities applies softmax twice.

जवाब: `x.to("cuda")` without reassigning `x`

`x` stays on the CPU while the model is on the GPU, so the first forward pass fails with a device mismatch. The other bugs run silently and only hurt results.

जवाब: Convert the tensor with `.float()` before passing it to the model

The data is float64 while the model's weights are float32. Converting the input with `.float()` is the standard fix; switching the whole model to float64 is slower and rarely needed.