Bidirectional LSTM in NLP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Bidirectional layer from Keras.

NLP

from tensorflow.keras.layers import [1]

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

ABidirectional

BDense

CConv2D

DDropout

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Dense or Conv2D instead of Bidirectional.

Forgetting to import Bidirectional layer.

The Bidirectional layer wraps an RNN to make it process input in both forward and backward directions.

2fill in blank

medium

Complete the code to create a Bidirectional LSTM layer with 64 units.

NLP

model.add(Bidirectional([1](64)))

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

ADense

BLSTM

CGRU

DConv1D

Attempts:

3 left

💡 Hint

Common Mistakes

Using Dense or Conv1D inside Bidirectional, which is incorrect.

Using GRU instead of LSTM if the question specifically asks for LSTM.

The Bidirectional wrapper is used with recurrent layers like LSTM to process sequences forward and backward.

3fill in blank

hard

Fix the error in the code to correctly compile the model with categorical crossentropy loss.

NLP

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

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

Acategorical_crossentropy

Bmean_squared_error

Cbinary_crossentropy

Dhinge

Attempts:

3 left

💡 Hint

Common Mistakes

Using mean_squared_error for classification.

Using binary_crossentropy for multi-class problems.

For multi-class classification, categorical_crossentropy is the correct loss function.

4fill in blank

hard

Fill both blanks to create a Bidirectional LSTM layer that returns sequences and uses 128 units.

NLP

model.add(Bidirectional([1](128, [2]=True)))

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

ALSTM

Breturn_sequences

Cactivation

Dunits

Attempts:

3 left

💡 Hint

Common Mistakes

Using activation or units as keyword argument instead of return_sequences.

Not setting return_sequences when needed.

The LSTM layer inside Bidirectional should have return_sequences=True to output the full sequence.

5fill in blank

hard

Fill all three blanks to build a simple Bidirectional LSTM model for text classification.

NLP

model = Sequential()
model.add(Embedding(input_dim=[1], output_dim=[2], input_length=100))
model.add(Bidirectional(LSTM([3])))
model.add(Dense(5, activation='softmax'))

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

A10000

B64

C128

D32

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing input_dim and output_dim values.

Using too small or too large numbers for embedding or LSTM units.

The Embedding layer needs input_dim=10000 for vocabulary size, output_dim=64 for embedding size, and the LSTM layer uses 128 units inside Bidirectional.

Practice

1. What is the main advantage of using a Bidirectional LSTM compared to a standard LSTM?

easy

A. It only reads the sequence backward for better performance.

B. It uses fewer parameters, making the model faster to train.

C. It processes the input sequence in both forward and backward directions to capture more context.

D. It replaces LSTM cells with simpler RNN cells.

Solution

1. Step 1: Understand LSTM directionality

   A standard LSTM reads the input sequence only in the forward direction, from start to end.

2. Step 2: Analyze Bidirectional LSTM behavior

   A Bidirectional LSTM reads the sequence both forward and backward, capturing information from past and future context.

3. Final Answer:

   It processes the input sequence in both forward and backward directions to capture more context. -> Option C

4. Quick Check:

   Bidirectional means forward + backward = C [OK]

Hint: Bidirectional means reading sequence both ways [OK]

Common Mistakes:

• Thinking it only reads backward
• Assuming it reduces parameters
• Confusing it with simpler RNNs

2. Which of the following is the correct way to add a Bidirectional LSTM layer in Keras?

easy

A. model.add(Bidirectional(LSTM(units=64)))

B. model.add(LSTM(Bidirectional(units=64)))

C. model.add(Bidirectional(units=64, LSTM()))

D. model.add(LSTM(units=64, bidirectional=True))

Solution

1. Step 1: Recall Keras Bidirectional syntax

   In Keras, the Bidirectional wrapper takes an RNN layer like LSTM as its argument.

2. Step 2: Check each option

   model.add(Bidirectional(LSTM(units=64))) correctly wraps LSTM inside Bidirectional. The other options misuse the syntax or parameters.

3. Final Answer:

   model.add(Bidirectional(LSTM(units=64))) -> Option A

4. Quick Check:

   Bidirectional wraps LSTM layer = A [OK]

Hint: Bidirectional wraps LSTM layer, not the other way [OK]

Common Mistakes:

• Putting Bidirectional inside LSTM
• Passing units to Bidirectional instead of LSTM
• Using bidirectional=True parameter in LSTM

3. Consider this code snippet using TensorFlow Keras:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Bidirectional, Dense

model = Sequential()
model.add(Bidirectional(LSTM(10, return_sequences=False), input_shape=(5, 8)))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy')

import numpy as np
x = np.random.random((2, 5, 8))
pred = model.predict(x)
print(pred.shape)

What will be the shape of pred?

medium

A. (2, 10)

B. (2, 1)

C. (5, 1)

D. (2, 20)

Solution

1. Step 1: Understand model output shape

   The Bidirectional LSTM with 10 units outputs 20 features (10 forward + 10 backward) per timestep. Since return_sequences=False, it outputs only the last timestep's features, shape (batch_size, 20).

2. Step 2: Dense layer output shape

   The Dense layer with 1 unit outputs shape (batch_size, 1). Input batch size is 2, so output shape is (2, 1).

3. Final Answer:

   (2, 1) -> Option B

4. Quick Check:

   Batch size 2, Dense 1 unit = (2, 1) [OK]

Hint: Dense(1) outputs shape (batch_size, 1) [OK]

Common Mistakes:

• Confusing return_sequences=True vs False
• Forgetting bidirectional doubles units
• Mixing batch and timestep dimensions

4. You wrote this code but get an error:

model = Sequential()
model.add(Bidirectional(LSTM(32), input_shape=(10, 16)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# Training data
X_train = np.random.random((100, 10, 16))
y_train = np.random.random((100,))

model.fit(X_train, y_train, epochs=5)

The error says: ValueError: Error when checking target: expected dense_1 to have shape (None, 1) but got array with shape (100,)
What is the fix?

medium

A. Change Dense layer units to 100.

B. Remove Bidirectional wrapper.

C. Set return_sequences=True in LSTM layer.

D. Change y_train shape to (100, 1) by reshaping it.

Solution

1. Step 1: Understand error message

   The model expects targets with shape (batch_size, 1) because Dense(1) outputs shape (None, 1). But y_train has shape (100,), missing the last dimension.

2. Step 2: Fix target shape

   Reshape y_train to (100, 1) to match model output shape. This fixes the mismatch error.

3. Final Answer:

   Change y_train shape to (100, 1) by reshaping it. -> Option D

4. Quick Check:

   Target shape matches output shape = B [OK]

Hint: Targets must match model output shape exactly [OK]

Common Mistakes:

• Changing model output units instead of target shape
• Setting return_sequences=True unnecessarily
• Removing Bidirectional without reason

5. You want to build a sentiment analysis model using a Bidirectional LSTM on text sequences of length 100. Which of these model designs best captures full context and outputs a fixed-size vector for classification?

hard

A. Embedding -> Bidirectional(LSTM with return_sequences=True) -> GlobalMaxPooling1D -> Dense

B. Embedding -> Bidirectional(LSTM with return_sequences=False) -> Dense

C. Embedding -> LSTM with return_sequences=False -> Dense

D. Embedding -> Bidirectional(LSTM with return_sequences=True) -> Dense

Solution

1. Step 1: Understand context capture

   Bidirectional LSTM reads sequences forward and backward, capturing full context.

2. Step 2: Fixed-size vector output

   Using return_sequences=True outputs a sequence, so applying GlobalMaxPooling1D converts it to a fixed-size vector summarizing important features.

3. Step 3: Compare options

   Embedding -> Bidirectional(LSTM with return_sequences=True) -> GlobalMaxPooling1D -> Dense uses Bidirectional LSTM with return_sequences=True plus pooling, best for full context and fixed vector. Embedding -> Bidirectional(LSTM with return_sequences=False) -> Dense skips pooling, output is last timestep only. Embedding -> LSTM with return_sequences=False -> Dense is unidirectional. Embedding -> Bidirectional(LSTM with return_sequences=True) -> Dense outputs sequence but no pooling, so Dense gets sequence input, causing shape issues.

4. Final Answer:

   Embedding -> Bidirectional(LSTM with return_sequences=True) -> GlobalMaxPooling1D -> Dense -> Option A

5. Quick Check:

   Pooling after bidirectional LSTM = A [OK]

Hint: Use pooling after return_sequences=True for fixed vector [OK]

Common Mistakes:

• Using return_sequences=False loses sequence info
• Skipping pooling leads to shape mismatch
• Using unidirectional LSTM loses backward context