Why RNNs handle sequences in PyTorch - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple RNN layer in PyTorch.

PyTorch

rnn = torch.nn.RNN(input_size=10, hidden_size=20, num_layers=[1])

Drag options to blanks, or click blank then click option'

A1

B0

C-1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Setting num_layers to 0 or negative values causes errors.

The num_layers parameter specifies how many stacked RNN layers to use. A value of 1 creates a single RNN layer.

2fill in blank

medium

Complete the code to initialize the hidden state for an RNN with batch size 5 and hidden size 20.

PyTorch

hidden = torch.zeros([1], 5, 20)

Drag options to blanks, or click blank then click option'

A1

B0

C2

D20

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up batch size and hidden size dimensions.

The first dimension is the number of layers, here 1. The batch size is 5 and hidden size is 20.

3fill in blank

hard

Fix the error in the code to process a sequence input through the RNN.

PyTorch

output, hidden = rnn([1], hidden)

Drag options to blanks, or click blank then click option'

Aoutput

Binput_seq

Chidden

Drnn

Attempts:

3 left

💡 Hint

Common Mistakes

Passing hidden state as first argument causes errors.

The RNN expects the input sequence tensor as the first argument, followed by the hidden state.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps each word to its length if the length is greater than 3.

PyTorch

{word: [1] for word in words if len(word) [2] 3}

Drag options to blanks, or click blank then click option'

Alen(word)

B>

C<

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong comparison operator or mapping to the word itself.

The dictionary maps each word to its length, but only if the length is greater than 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each uppercase word to its length if the length is greater than 4.

PyTorch

result = [1]: [2] for word in words if len(word) [3] 4

Drag options to blanks, or click blank then click option'

Aword.upper()

Blen(word)

C>

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using the original word as key or wrong comparison operator.

This comprehension creates a dictionary where keys are uppercase words and values are their lengths, but only for words longer than 4 characters.

Practice

1. Why are RNNs especially good at handling sequence data like sentences or time series?

easy

A. Because they use convolution to detect patterns

B. Because they keep a memory of previous inputs using a hidden state

C. Because they process all inputs at once without order

D. Because they ignore past inputs to focus on current data

Solution

1. Step 1: Understand RNN memory mechanism

   RNNs keep a hidden state that stores information from previous inputs, acting like memory.

2. Step 2: Relate memory to sequence handling

   This memory lets RNNs understand order and context in sequences like sentences or time series.

3. Final Answer:

   Because they keep a memory of previous inputs using a hidden state -> Option B

4. Quick Check:

   RNN memory = sequence understanding [OK]

Hint: RNNs remember past inputs to handle sequences [OK]

Common Mistakes:

• Thinking RNNs process all inputs at once
• Confusing RNNs with convolutional networks
• Assuming RNNs ignore past data

2. Which of the following is the correct way to initialize a simple RNN layer in PyTorch?

easy

A. rnn = torch.nn.RNN(input_size=10, hidden_size=20, num_layers=1)

B. rnn = torch.nn.RNNLayer(10, 20)

C. rnn = torch.nn.SimpleRNN(10, 20)

D. rnn = torch.nn.RNN(input_size=20, 10)

Solution

1. Step 1: Recall PyTorch RNN syntax

   PyTorch uses torch.nn.RNN with parameters input_size and hidden_size.

2. Step 2: Check options for correct parameter order and names

   rnn = torch.nn.RNN(input_size=10, hidden_size=20, num_layers=1) correctly uses input_size=10 and hidden_size=20 with num_layers=1.

3. Final Answer:

   rnn = torch.nn.RNN(input_size=10, hidden_size=20, num_layers=1) -> Option A

4. Quick Check:

   Correct PyTorch RNN init = rnn = torch.nn.RNN(input_size=10, hidden_size=20, num_layers=1) [OK]

Hint: Use torch.nn.RNN(input_size, hidden_size) to initialize [OK]

Common Mistakes:

• Using non-existent classes like RNNLayer or SimpleRNN
• Swapping input_size and hidden_size
• Missing required parameters

3. Given the following PyTorch code, what is the shape of the output tensor?

import torch
rnn = torch.nn.RNN(input_size=5, hidden_size=3, num_layers=1)
input_seq = torch.randn(4, 2, 5)  # seq_len=4, batch=2, input_size=5
output, hidden = rnn(input_seq)

medium

A. (4, 3, 2)

B. (2, 4, 3)

C. (4, 2, 3)

D. (2, 3, 4)

Solution

1. Step 1: Understand RNN input and output shapes

   Input shape is (seq_len=4, batch=2, input_size=5). Output shape is (seq_len, batch, hidden_size).

2. Step 2: Apply hidden_size to output shape

   Hidden size is 3, so output shape is (4, 2, 3).

3. Final Answer:

   (4, 2, 3) -> Option C

4. Quick Check:

   Output shape = (seq_len, batch, hidden_size) = (4, 2, 3) [OK]

Hint: Output shape = (seq_len, batch, hidden_size) in PyTorch RNN [OK]

Common Mistakes:

• Mixing batch and sequence dimensions
• Confusing hidden_size with input_size
• Assuming output shape swaps batch and seq_len

4. Identify the error in this PyTorch RNN usage:

rnn = torch.nn.RNN(input_size=8, hidden_size=4)
input_seq = torch.randn(5, 3, 10)  # seq_len=5, batch=3, input_size=10
output, hidden = rnn(input_seq)

medium

A. input_seq has wrong input_size dimension

B. RNN missing num_layers parameter

C. Output unpacking is incorrect

D. RNN hidden_size should be larger than input_size

Solution

1. Step 1: Check input_size consistency

   RNN expects input_size=8 but input_seq has last dimension 10, which is incorrect.

2. Step 2: Verify other parameters

   num_layers is optional and defaults to 1, output unpacking is correct, hidden_size can be smaller than input_size.

3. Final Answer:

   input_seq has wrong input_size dimension -> Option A

4. Quick Check:

   Input size mismatch causes error [OK]

Hint: Input tensor last dim must match RNN input_size [OK]

Common Mistakes:

• Assuming num_layers is mandatory
• Thinking hidden_size must be bigger than input_size
• Misunderstanding output unpacking

5. You want to build an RNN model in PyTorch to predict the next word in a sentence. Which approach best uses RNNs' sequence handling ability?

hard

A. Feed the entire sentence as one vector without sequence order to the RNN

B. Ignore the hidden state and predict next word only from the last input word

C. Use a convolutional layer before the RNN to remove sequence order

D. Feed the sentence word by word to the RNN, updating hidden state each step, then predict the next word from the final output

Solution

1. Step 1: Understand RNN sequence processing

   RNNs process inputs step-by-step, keeping hidden state to remember past words.

2. Step 2: Apply this to next word prediction

   Feeding words one by one and using the final output leverages RNN memory to predict the next word.

3. Final Answer:

   Feed the sentence word by word to the RNN, updating hidden state each step, then predict the next word from the final output -> Option D

4. Quick Check:

   Stepwise input + hidden state = best sequence use [OK]

Hint: Feed sequence stepwise, use hidden state for prediction [OK]

Common Mistakes:

• Feeding entire sentence as one vector loses order
• Ignoring hidden state loses sequence memory
• Using convolution to remove sequence order