---
# System prepended metadata

title: Recurrent Neural Network

---

**Recurrent Neural Network (RNN) Overview:**

Recurrent Neural Networks (RNNs) are a class of deep learning models designed for sequential data, making them suitable for tasks like natural language processing, time series analysis, and sequence prediction. RNNs have an internal state that allows them to process sequences of varying lengths.

In this example, we'll use a dataset to demonstrate an RNN for sequence classification.

**Example Using a Dataset:**

**Step 1: Import Libraries**
```python
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Dense
```

**Step 2: Load and Prepare the Dataset**
```python
# Load the IMDb movie reviews dataset
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=10000)

# Pad sequences to ensure equal length
X_train = pad_sequences(X_train, maxlen=100)
X_test = pad_sequences(X_test, maxlen=100)
```

**Step 3: Create and Train the RNN Model**
```python
# Create a Sequential model
rnn_model = Sequential()

# Add an embedding layer
rnn_model.add(Embedding(input_dim=10000, output_dim=32, input_length=100))

# Add a SimpleRNN layer
rnn_model.add(SimpleRNN(units=32, return_sequences=False))

# Add a Dense layer for binary classification
rnn_model.add(Dense(1, activation='sigmoid'))

# Compile the model
rnn_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model on the training data
rnn_model.fit(X_train, y_train, epochs=5, batch_size=64, validation_split=0.2)
```

**Params That Can Be Changed**
1. **Embedding layer parameters**:
   - `input_dim`: Specifies the size of the vocabulary (number of unique words).
   - `output_dim`: Defines the dimension of the embedding vectors.
   - `input_length`: Specifies the length of input sequences.

2. **SimpleRNN layer parameters**:
   - `units`: Specifies the number of RNN units (neurons) in the layer.
   - `return_sequences`: Determines whether the layer should return sequences (True) or a single output (False).

3. **Dense layer parameters**:
   - `units`: Specifies the number of neurons in the layer.
   - `activation`: Specifies the activation function for the layer.

4. **Compile parameters**:
   - `optimizer`: Specifies the optimization algorithm (e.g., 'adam').
   - `loss`: Defines the loss function (e.g., 'binary_crossentropy').

**Step 4: Evaluate the Model**
```python
# Evaluate the model on the test data
test_loss, test_accuracy = rnn_model.evaluate(X_test, y_test, verbose=0)
print(f"Test Accuracy: {test_accuracy * 100:.2f}%")
```

**Explanation:**

1. We import the necessary libraries, including NumPy for numerical operations, Matplotlib for visualization, TensorFlow for deep learning, and more.

2. We load the IMDb movie reviews dataset, which consists of movie reviews labeled as positive or negative. We limit the vocabulary size to 10,000 words and pad sequences to ensure they have equal lengths.

3. We create a Sequential model for the RNN.

4. We add an embedding layer that converts the input integers into dense vectors of fixed size.

5. A SimpleRNN layer is added to process sequences. The `units` parameter controls the number of recurrent units, and `return_sequences` determines whether the layer returns sequences (for stacked RNNs) or a single output.

6. A Dense layer with a sigmoid activation function is used for binary classification.

7. The model is compiled with the optimizer and loss function specified.

8. The model is trained on the training data for a specified number of epochs and batch size.

9. We evaluate the model's performance on the test data, calculating test accuracy.

RNNs are versatile for sequence-related tasks and can be customized with various parameters to suit your specific task and dataset, including vocabulary size, embedding dimensions, and the number of RNN units.