GRU for text in NLP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the GRU layer from TensorFlow Keras.

NLP

from tensorflow.keras.layers import [1]

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

ALSTM

BGRU

CConv2D

DDense

Attempts:

3 left

💡 Hint

Common Mistakes

Importing LSTM instead of GRU

Importing Dense or Conv2D by mistake

The GRU layer is imported from tensorflow.keras.layers as GRU.

2fill in blank

medium

Complete the code to create a GRU layer with 64 units and return sequences.

NLP

gru_layer = GRU([1], return_sequences=True)

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

A256

B32

C128

D64

Attempts:

3 left

💡 Hint

Common Mistakes

Using too few units like 32 which may underfit

Using too many units like 256 which may overfit or slow training

The GRU layer is created with 64 units to capture features from the input sequence.

3fill in blank

hard

Fix the error in the code to compile the model with Adam optimizer and categorical crossentropy loss.

NLP

model.compile(optimizer='[1]', loss='categorical_crossentropy', metrics=['accuracy'])

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

Aadam

Badagrad

Crmsprop

Dsgd

Attempts:

3 left

💡 Hint

Common Mistakes

Using SGD which may require more tuning

Using RMSprop or Adagrad without understanding their effects

The Adam optimizer is commonly used for training GRU models on text classification tasks.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps words to their lengths only if length is greater than 3.

NLP

{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 word itself as value instead of its length

Using less than operator instead of greater than

The dictionary comprehension maps each word to its length if the length is greater than 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase words to their counts if count is greater than 0.

NLP

result = [1]: [2] for word, count in word_counts.items() if count [3] 0}

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

Aword.upper()

Bcount

C>

Dword.lower()

Attempts:

3 left

💡 Hint

Common Mistakes

Using word.lower() instead of word.upper()

Using less than operator instead of greater than

The comprehension maps uppercase words to their counts only if the count is positive.

Practice

1. What is the main advantage of using a GRU (Gated Recurrent Unit) in text processing tasks?

easy

A. It helps the model remember important information over time while ignoring less important details.

B. It increases the size of the input text automatically.

C. It converts text into images for better analysis.

D. It removes all punctuation from the text before processing.

Solution

1. Step 1: Understand GRU's role in memory

   GRU units are designed to keep important information from previous steps and forget irrelevant data, helping with sequence tasks like text.

2. Step 2: Compare options to GRU function

   Only It helps the model remember important information over time while ignoring less important details. correctly describes this memory feature; others describe unrelated or incorrect functions.

3. Final Answer:

   It helps the model remember important information over time while ignoring less important details. -> Option A

4. Quick Check:

   GRU memory feature = A [OK]

Hint: GRU remembers key info, forgets noise in sequences [OK]

Common Mistakes:

• Thinking GRU changes input size
• Confusing GRU with data preprocessing
• Assuming GRU outputs images

2. Which of the following is the correct way to define a GRU layer in Python using PyTorch for text input with embedding size 100 and hidden size 50?

easy

A. nn.GRU(hidden_size=100, input_size=50)

B. nn.GRU(50, 100)

C. nn.GRU(input_size=100, hidden_size=50)

D. nn.GRU(100)

Solution

1. Step 1: Recall PyTorch GRU parameters

   PyTorch GRU expects input_size first (embedding size), then hidden_size (number of features in hidden state).

2. Step 2: Match parameters to given sizes

   Embedding size is 100, hidden size is 50, so nn.GRU(input_size=100, hidden_size=50) is correct.

3. Final Answer:

   nn.GRU(input_size=100, hidden_size=50) -> Option C

4. Quick Check:

   input_size=100, hidden_size=50 = B [OK]

Hint: Input size first, hidden size second in nn.GRU() [OK]

Common Mistakes:

• Swapping input_size and hidden_size
• Using positional args incorrectly
• Omitting required parameters

3. Given the following PyTorch code snippet, what will be the shape of the output tensor after passing input through the GRU?

import torch
import torch.nn as nn

gru = nn.GRU(input_size=10, hidden_size=20, batch_first=True)
input = torch.randn(5, 7, 10)  # batch=5, seq_len=7, input_size=10
output, hidden = gru(input)
print(output.shape)

medium

A. (7, 5, 20)

B. (5, 7, 20)

C. (5, 20, 7)

D. (5, 7, 10)

Solution

1. Step 1: Understand GRU output shape with batch_first=true

   Output shape is (batch_size, sequence_length, hidden_size) when batch_first=true.

2. Step 2: Match given input sizes

   Input batch=5, seq_len=7, hidden_size=20, so output shape is (5, 7, 20).

3. Final Answer:

   (5, 7, 20) -> Option B

4. Quick Check:

   Output shape = (batch, seq_len, hidden_size) = A [OK]

Hint: With batch_first=true, output shape is (batch, seq_len, hidden) [OK]

Common Mistakes:

• Confusing batch and sequence dimensions
• Ignoring batch_first=true effect
• Assuming output shape equals input shape

4. You wrote this code to create a GRU for text classification but get a runtime error:

gru = nn.GRU(input_size=50, hidden_size=100)
input = torch.randn(32, 10, 100)  # batch=32, seq_len=10, input_size=100
output, hidden = gru(input)

What is the likely cause of the error?

medium

A. Input size 100 does not match GRU input_size 50

B. Batch size 32 is too large for GRU

C. Sequence length 10 is invalid for GRU

D. GRU requires input to be 2D tensor, not 3D

Solution

1. Step 1: Check GRU input_size vs input tensor last dimension

   GRU expects input_size=50, but input tensor last dimension is 100, causing mismatch.

2. Step 2: Understand tensor shape requirements

   GRU input shape should be (batch, seq_len, input_size). Here input_size dimension must match GRU's input_size parameter.

3. Final Answer:

   Input size 100 does not match GRU input_size 50 -> Option A

4. Quick Check:

   Input size mismatch = C [OK]

Hint: Match input tensor last dim to GRU input_size [OK]

Common Mistakes:

• Blaming batch size for error
• Thinking sequence length is invalid
• Assuming GRU only accepts 2D input

5. You want to build a GRU-based model to classify movie reviews as positive or negative. Your dataset has variable-length reviews. Which approach best handles variable-length sequences with a GRU in PyTorch?

hard

A. Convert text to images and use CNN instead of GRU.

B. Truncate all sequences to length 1 and feed to GRU.

C. Feed raw sequences directly without padding or packing.

D. Pad all sequences to the same length and use pack_padded_sequence before GRU.

Solution

1. Step 1: Understand variable-length sequence handling

   GRU requires fixed-length inputs or packed sequences to handle variable lengths efficiently.

2. Step 2: Use padding and packing for variable-length inputs

   Padding sequences to max length and using pack_padded_sequence lets GRU ignore padded parts during processing.

3. Final Answer:

   Pad all sequences to the same length and use pack_padded_sequence before GRU. -> Option D

4. Quick Check:

   Padding + pack_padded_sequence = D [OK]

Hint: Pad sequences and pack before GRU for variable lengths [OK]

Common Mistakes:

• Truncating sequences too short loses info
• Feeding raw variable-length sequences causes errors
• Switching to CNN ignores GRU benefits