You have a tensor x = torch.tensor([1, 2, 3, 4]). You perform stacked_x_dim0 = torch.stack([x, x, x], dim=0) And stacked_x_dim1 = torch.stack([x, x, x], dim=1) What will be the shapes of stacked_x_dim0 and stacked_x_dim1 respectively?

(C) stacked_x_dim0: [3, 4], stacked_x_dim1: [4, 3]

(A) stacked_x_dim0: [3, 3], stacked_x_dim1: [4, 4]

(B) stacked_x_dim0: [4, 3], stacked_x_dim1: [3, 4]

(D) stacked_x_dim0: [4, 4], stacked_x_dim1: [3, 3]

A student is trying to write the Generator training loop and is confused about the order of operations. Their code is: # --- Training the Generator --- # 1. Generate fakes and get D's output z = torch.randn(batch_size, latent_size).to(device) fake_images = G(z) d_out_fake = D(fake_images) # 2. Calculate loss g_loss = criterion(d_out_fake, real_labels) # 3. Update weights G_optimizer.step() # Line 3a g_loss.backward() # Line 3b G.zero_grad() # Line 3c This code is completely broken. What is the correct, functional order for lines 3a, 3b, and 3c?

(C) Option figure from the original question paper

(A) Option figure from the original question paper

(B) Option figure from the original question paper

(D) Option figure from the original question paper

Figure from the original question paper

(A) Option figure from the original question paper

(C) Option figure from the original question paper

(E) Option figure from the original question paper

(B) Option figure from the original question paper

(D) Option figure from the original question paper

Figure from the original question paper

(C) Option figure from the original question paper

(A) Option figure from the original question paper

(B) Option figure from the original question paper

(D) Option figure from the original question paper

Figure from the original question paper

(A) It specifies how many epochs with no improvement in the monitored metric are tolerated beforereducing the learning rate.

(B) It automatically restarts training after the learning rate is reduced.

(C) It determines the number of epochs required for validation loss to reach the minimum.

(D) It defines how many epochs the learning rate should remain frozen after being reduced.

The LSTM (Long Short-Term Memory) network uses several gates to control information flow. Here are the key equations with a placeholder [?] for a missing operator: Gate Computations: 1. Forget gate: f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) 2. Input gate: i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) 3. Candidate values: \tilde{c}_t = tanh(W_c \cdot [h_{t-1}, x_t] + b_c) 4. Output gate: o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) Memory Update Equations (with placeholder): 5. Cell state update: c_t = f_t[?]c_{t-1} + i_t[?]\tilde{c}_t 6. Hidden state update: h_t = o_t[?]tanh(c_t) Which operator should replace [?] in the LSTM memory update equations (5 and 6) above?

(B) Element-wise multiplication (⊙)

You are training an RNN-based text classification model with the following three sequences: Sequence 1: "I love deep learning" → 4 tokens Sequence 2: "NLP is great" → 3 tokens Sequence 3: "AI" → 1 token Under which training scenario is padding NOT strictly required for processing these sequences?

(B) Using stochastic gradient descent (SGD) with batch size = 1

(A) Using mini-batch gradient descent with batch size = 32

(C) Using batch gradient descent processing all samples at once

(D) Using mini-batch gradient descent with batch size = 16

September 2025 term · Introduction to Deep Learning and Generative AI · BSDA2001

Introduction to Deep Learning and Generative AI Quiz 2: 23 November 2025 (September 2025 term)

The IIT Madras BS Introduction to Deep Learning and Generative AI (Deep Learning and GenAI) Quiz 2 paper sat on 23 Nov 2025, in the September 2025 term: 25 questions for 50 marks in 120 minutes. Every question is below with its answer. Take it as a timed mock test to be marked, or read it through first.

Questions: 25
Marks: 50
Duration: 120 min
MCQ: 17
Numerical: 7
MSQ: 1

Take as mock test Practise with answers

Updated 25 Sept 2026

Official paper: IIT M DIPLOMA AN EXAM QDD2 23 Nov 2025 NEW · No negative marking.

Question 1

+2 marksOne correct option

You have a tensor x = torch.tensor([1, 2, 3, 4]).

You perform

python

1stacked_x_dim0 = torch.stack([x, x, x], dim=0)

And

python

1stacked_x_dim1 = torch.stack([x, x, x], dim=1)

What will be the shapes of stacked_x_dim0 and stacked_x_dim1 respectively?

A
stacked_x_dim0: [3, 3], stacked_x_dim1: [4, 4]
B
stacked_x_dim0: [4, 3], stacked_x_dim1: [3, 4]
C
stacked_x_dim0: [3, 4], stacked_x_dim1: [4, 3]
D
stacked_x_dim0: [4, 4], stacked_x_dim1: [3, 3]

Show answer

Correct answer

C
stacked_x_dim0: [3, 4], stacked_x_dim1: [4, 3]

Question 1 on its own page

Question 2

+1 markOne correct option

You have a PyTorch tensor

python

1gpu_tensor = torch.tensor([1, 2, 3]).to('cuda')

residing on the GPU. You then attempt to convert it directly to a NumPy array using

python

1numpy_array = gpu_tensor.numpy()

What will be the outcome of this operation?

A
It will successfully convert gpu_tensor to a NumPy array on the CPU.
B
It will successfully convert gpu_tensor to a NumPy array that also resides on the GPU.
C
It will raise a RuntimeError because NumPy arrays cannot directly operate on GPU memory.
D
It will create a view of the gpu_tensor on the CPU without copying data.
E
The numpy() method is not available for GPU tensors.

Show answer

Correct answer

C
It will raise a RuntimeError because NumPy arrays cannot directly operate on GPU memory.

Question 2 on its own page

Question 3

+1 markOne correct option

The Huber Loss function is introduced as a robust alternative to Mean Squared Error (MSE) and Mean Absolute Error (MAE). What is the primary characteristic of Huber Loss that makes it robust to outliers?

A
It always produces a gradient of zero for all errors, preventing large updates.
B
It exclusively uses a quadratic penalty, but only for errors exactly at the threshold.
C
It transitions from a quadratic loss for small errors to a linear loss for large errors, thereby down-weighting the impact of outliers.
D
It entirely ignores errors beyond a certain delta, considering them irrelevant.
E
It applies a logarithmic transformation to all error values before computing the loss.

Show answer

Correct answer

C
It transitions from a quadratic loss for small errors to a linear loss for large errors, thereby down-weighting the impact of outliers.

Question 3 on its own page

Question 4

+3 marksNumerical answer

A deep learning model contains a stack of three consecutive 3x3 convolutional layers, each with a stride of 1and sufficient padding to preserve spatial dimensions. What is the side length of the effective receptive field of a neuron in the third layer with respect to the input?

Show answer

Correct answer: 7

Question 4 on its own page

Question 5

+2 marksNumerical answer

Show answer

Correct answer: 348

Question 5 on its own page

Question 6

+1 markOne correct option

The Momentum optimizer helps overcome which limitation of vanilla Gradient Descent?

A
Slow convergence near the minimum due to large learning rate.
B
Zig-zag oscillations in narrow valleys due to gradient directions changing frequently.
C
Vanishing gradients caused by activation functions.
D
Overfitting due to excessive updates.

Show answer

Correct answer

B
Zig-zag oscillations in narrow valleys due to gradient directions changing frequently.

Question 6 on its own page

Question 7

+4 marksNumerical answer

Consider the RMSProp optimizer update rule:

$v_t = \beta v_{t-1} + (1 - \beta)(\nabla w_t)^2$

The algorithm runs for 10 iterations ( $t = 0, 1, 2, \ldots, 9$ ).

After 10 iterations, what multiplicative weight is applied to the very first gradient term $(\nabla w_0)^2$ in the accumulated history $v_9$ ?

Assume $v_{-1} = 0$ and $\beta = 0.9$ .

Enter the answer correct up to 3 decimal places.

Show answer

Correct answer: 0.035 (accepted within ±0.005)

Question 7 on its own page

Question 8

+2 marksOne correct option

You are given two loss functions. Your task is to identify their nature using the second derivative test.

Function A:

$A(w) = w^2 - 6w + 10$

Function B:

$B(w) = e^w + e^{-w}$

Which statement correctly identifies the functions and provides the correct mathematical justification?

Show answer

Correct answer

Question 8 on its own page

Question 9

+1 markOne correct option

What happens if the latent space in a GAN has too few dimensions for the task complexity?

A
Training becomes faster and results improve.
B
The discriminator becomes too powerful.
C
The generator memorizes all training images.
D
Generated images lack diversity and may look similar

Show answer

Correct answer

D
Generated images lack diversity and may look similar

Question 9 on its own page

Question 10

+2 marksOne correct option

At Nash Equilibrium in a perfectly trained GAN, what is the expected output of the discriminator D(G(z)) for a generated sample?

A
0
B
0.25
C
0.5
D
1

Show answer

Correct answer

C
0.5

Question 10 on its own page

Question 11

+2 marksOne correct option

A student is trying to write the Generator training loop and is confused about the order of operations. Their code is:

python

1# --- Training the Generator ---
2
3# 1. Generate fakes and get D's output
4z = torch.randn(batch_size, latent_size).to(device)
5
6fake_images = G(z)
7d_out_fake = D(fake_images)
8
9# 2. Calculate loss
10g_loss = criterion(d_out_fake, real_labels)
11
12# 3. Update weights
13G_optimizer.step()      # Line 3a
14g_loss.backward()       # Line 3b
15G.zero_grad()           # Line 3c

This code is completely broken. What is the correct, functional order for lines 3a, 3b, and 3c?

Show answer

Correct answer

Question 11 on its own page

Question 12

+2 marksOne correct option

You've been training your GAN for 100 epochs. You notice two things:

The Generator loss (g_loss) is very low and stable, and the Discriminator loss (d_loss) is high and stable.
When you inspect the saved images, the Generator is producing the exact same (or very similar) image of a single "ankle boot" for every latent vector z you input.

What is this classic GAN failure mode called?

A
Vanishing Gradients
B
Mode Collapse
C
Overfitting
D
Discriminator Saturation

Show answer

Correct answer

B
Mode Collapse

Question 12 on its own page

Question 13

+2 marksOne or more correct options

Select all that apply.

Show answer

Correct answers

Question 13 on its own page

Question 14

+1 markNumerical answer

Show answer

Correct answer: 5

Question 14 on its own page

Question 15

+2 marksOne correct option

A
(10,8,32)
B
(10,28,8)
C
(28,10,8)
D
(8,10,28)

Show answer

Correct answer

C
(28,10,8)

Question 15 on its own page

Question 16

+3 marksNumerical answer

Consider that the following paragraph is used as the input to train a sequence language model:

"this is a great sunny day the advantage of being a sunny day is that we can indulge in many outdoor sports and activities i am not wrong when i say that it is a great sunny morning"

(Ignore the double quotes in the vocab)

No smoothing is applied.
Tokenization is done by splitting on spaces.
If a context does not appear, its conditional probability is zero.

What is the probability the model generates the following sequence ?

"a great sunny morning"

(Answer upto 3 decimals)

Show answer

Correct answer: 0.025 (accepted within ±0.005)

Question 16 on its own page

Question 17

+2 marksOne correct option

A
8.58
B
2.15
C
0.72
D
4.71

Show answer

Correct answer

A
8.58

Question 17 on its own page

Question 18

+3 marksOne correct option

You are performing Beam Search with K=2 to generate a sequence.

Step 1: The model predicts probabilities for the first word:

text

1    "A": 0.5
2
3    "The": 0.4
4
5    "It": 0.1

Step 2: You expand the K=2 hypotheses ("A" and "The").

Given "A", P(next word): {"dog": 0.6, "cat": 0.3, ...}

Given "The", P(next word): {"dog": 0.5, "cat": 0.4, ...}

After Step 2, what are the sequences (beams) that you will keep for Step 3?

Show answer

Correct answer

Question 18 on its own page

Question 19

+2 marksOne correct option

Show answer

Correct answer

Question 19 on its own page

Question 20

+1 markOne correct option

A
It specifies how many epochs with no improvement in the monitored metric are tolerated beforereducing the learning rate.
B
It automatically restarts training after the learning rate is reduced.
C
It determines the number of epochs required for validation loss to reach the minimum.
D
It defines how many epochs the learning rate should remain frozen after being reduced.

Show answer

Correct answer

A
It specifies how many epochs with no improvement in the monitored metric are tolerated beforereducing the learning rate.

Question 20 on its own page

Question 21

+4 marksNumerical answer

Given the update rule for Adagrad

$\begin{aligned} v_t &= v_{t-1} + (\nabla w_t)^2 \\ w_{t+1} &= w_t - \frac{\eta}{\sqrt{v_t + \epsilon}} \nabla w_t \end{aligned}$

where $v_{-1}$ and $\epsilon$ are set to $0$ . The gradient for the function of single variable is $1$ at any point. The effective learning rate at timestamp $t$ is $\frac{\eta}{\sqrt{v_t}}$ .

$\beta$ lies between $0$ and $1$ .

Note: $w_0 \to w_1$ is the first update, $w_1 \to w_2$ is the second update and so on.

What is the effective learning rate for the parameter while using Adagrad at the ninth update step (to get $w_9$ ) if the initial learning rate is $1$ ? Round your answer to 2 decimal places.

Show answer

Correct answer: 0.35 (accepted within ±0.05)

Question 21 on its own page

Question 22

+1 markOne correct option

In an LSTM (Long Short-Term Memory) network, which pair of components correctly represents the short-term and long-term memory respectively?

Show answer

Correct answer

Question 22 on its own page

Question 23

+2 marksOne correct option

The LSTM (Long Short-Term Memory) network uses several gates to control information flow. Here are the key equations with a placeholder [?] for a missing operator:

Gate Computations:

Forget gate: $f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$
Input gate: $i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$
Candidate values: $\tilde{c}_t = tanh(W_c \cdot [h_{t-1}, x_t] + b_c)$
Output gate: $o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$

Memory Update Equations (with placeholder):

Cell state update: $c_t = f_t[?]c_{t-1} + i_t[?]\tilde{c}_t$
Hidden state update: $h_t = o_t[?]tanh(c_t)$

Which operator should replace [?] in the LSTM memory update equations (5 and 6) above?

A
Matrix multiplication (·)
B
Element-wise multiplication (⊙)
C
Cross product (x)
D
Element-wise addition (+)

Show answer

Correct answer

B
Element-wise multiplication (⊙)

Question 23 on its own page

Question 24

+2 marksOne correct option

You are training an RNN-based text classification model with the following three sequences:

text

1Sequence 1: "I love deep learning"     → 4 tokens
2Sequence 2: "NLP is great"             → 3 tokens
3Sequence 3: "AI"                       → 1 token

Under which training scenario is padding NOT strictly required for processing these sequences?

A
Using mini-batch gradient descent with batch size = 32
B
Using stochastic gradient descent (SGD) with batch size = 1
C
Using batch gradient descent processing all samples at once
D
Using mini-batch gradient descent with batch size = 16

Show answer

Correct answer

B
Using stochastic gradient descent (SGD) with batch size = 1

Question 24 on its own page

Question 25

+2 marksNumerical answer

Consider the following modified implementation of an RNN.

python

1        self.rnn = nn.RNN(embedding_dim, hidden_dim, n_layers,
2                          dropout=drop_prob, batch_first=True)
3
4        self.dropout = nn.Dropout(0.3) #line1
5
6        self.fc = nn.Linear(hidden_dim, output_size)

What will be the percentage reduction in the rnn parameters due to applying line one? (Answer upto one decimal)

Show answer

Correct answer: 0 (accepted within ±0.0001)

Question 25 on its own page