LSTM.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Problem 1 - Execution of various methods",
   "id": "2431a4affc1762ea"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T12:58:48.196666Z",
     "start_time": "2024-12-20T12:58:32.756825Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Loading imports\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, SimpleRNN, GRU, LSTM, Dense, ConvLSTM2D, GlobalAveragePooling2D\n",
    "from tensorflow.keras.datasets import imdb\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "\n",
    "# Loading and pre-processing data\n",
    "# Load IMDB dataset\n",
    "max_features = 10000  # Use top 10k words\n",
    "maxlen = 100  # Limit each review to 100 words\n",
    "batch_size = 32\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)\n",
    "\n",
    "# Pad sequences to ensure uniform input size\n",
    "x_train = pad_sequences(x_train, maxlen=maxlen)\n",
    "x_test = pad_sequences(x_test, maxlen=maxlen)\n",
    "\n",
    "# Convert labels to categorical format (for binary classification)\n",
    "y_train = to_categorical(y_train)\n",
    "y_test = to_categorical(y_test)\n"
   ],
   "id": "26dc2410658662e7",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T12:58:48.579248Z",
     "start_time": "2024-12-20T12:58:48.501647Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Defining Model Architectures\n",
    "def create_simple_rnn_model():\n",
    "    model = Sequential()\n",
    "    model.add(Embedding(max_features, 128, input_length=maxlen))\n",
    "    model.add(SimpleRNN(128, activation='tanh'))\n",
    "    model.add(Dense(2, activation='softmax'))\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "def create_gru_model():\n",
    "    model = Sequential()\n",
    "    model.add(Embedding(max_features, 128, input_length=maxlen))\n",
    "    model.add(GRU(128, activation='tanh'))\n",
    "    model.add(Dense(2, activation='softmax'))\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "def create_lstm_model():\n",
    "    model = Sequential()\n",
    "    model.add(Embedding(max_features, 128, input_length=maxlen))\n",
    "    model.add(LSTM(128, activation='tanh'))\n",
    "    model.add(Dense(2, activation='softmax'))\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n"
   ],
   "id": "8b4a89b5f34af3f1",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T12:58:48.594978Z",
     "start_time": "2024-12-20T12:58:48.585335Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Define ConvLSTM2D Model (for Image-based or Video Tasks)\n",
    "def create_convlstm_model():\n",
    "    model = Sequential()\n",
    "    model.add(ConvLSTM2D(32, (3, 3), activation='relu', padding='same', input_shape=(maxlen, 1, 1, 1)))\n",
    "    model.add(GlobalAveragePooling2D())\n",
    "    model.add(Dense(2, activation='softmax'))\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n"
   ],
   "id": "1baef96552fd63f2",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T14:07:49.458317Z",
     "start_time": "2024-12-20T14:06:53.234549Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Training and Evaluating models\n",
    "# Create models\n",
    "simple_rnn_model = create_simple_rnn_model()\n",
    "gru_model = create_gru_model()\n",
    "lstm_model = create_lstm_model()\n",
    "\n",
    "# Train models\n",
    "epochs = 3\n",
    "\n",
    "# Train SimpleRNN\n",
    "print(\"Training SimpleRNN model...\")\n",
    "simple_rnn_model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, y_test))\n",
    "simple_rnn_accuracy = simple_rnn_model.evaluate(x_test, y_test)"
   ],
   "id": "2f112356299564cb",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training SimpleRNN model...\n",
      "Epoch 1/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m17s\u001B[0m 50ms/step - accuracy: 0.3291 - loss: 2.6836 - val_accuracy: 0.3633 - val_loss: 2.4009\n",
      "Epoch 2/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m18s\u001B[0m 65ms/step - accuracy: 0.3507 - loss: 2.4129 - val_accuracy: 0.3589 - val_loss: 2.3838\n",
      "Epoch 3/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m20s\u001B[0m 71ms/step - accuracy: 0.3679 - loss: 2.3674 - val_accuracy: 0.3758 - val_loss: 2.3829\n",
      "\u001B[1m71/71\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 15ms/step - accuracy: 0.3710 - loss: 2.3628\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T14:09:49.284348Z",
     "start_time": "2024-12-20T14:08:04.980158Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Train GRU\n",
    "print(\"Training GRU model...\")\n",
    "gru_model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, y_test))\n",
    "gru_accuracy = gru_model.evaluate(x_test, y_test)\n"
   ],
   "id": "2b260ce742a71574",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training GRU model...\n",
      "Epoch 1/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m36s\u001B[0m 114ms/step - accuracy: 0.3983 - loss: 2.4306 - val_accuracy: 0.5530 - val_loss: 1.7374\n",
      "Epoch 2/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m33s\u001B[0m 116ms/step - accuracy: 0.5748 - loss: 1.6271 - val_accuracy: 0.6073 - val_loss: 1.5876\n",
      "Epoch 3/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m34s\u001B[0m 120ms/step - accuracy: 0.6364 - loss: 1.4309 - val_accuracy: 0.6211 - val_loss: 1.5187\n",
      "\u001B[1m71/71\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 31ms/step - accuracy: 0.6392 - loss: 1.4702\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T14:15:57.103254Z",
     "start_time": "2024-12-20T14:14:02.043859Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Train LSTM\n",
    "print(\"Training LSTM model...\")\n",
    "lstm_model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, y_test))\n",
    "lstm_accuracy = lstm_model.evaluate(x_test, y_test)"
   ],
   "id": "181047c164d77e8f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training LSTM model...\n",
      "Epoch 1/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m38s\u001B[0m 123ms/step - accuracy: 0.3931 - loss: 2.4982 - val_accuracy: 0.5013 - val_loss: 1.8754\n",
      "Epoch 2/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m36s\u001B[0m 128ms/step - accuracy: 0.5392 - loss: 1.7463 - val_accuracy: 0.5583 - val_loss: 1.7284\n",
      "Epoch 3/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m38s\u001B[0m 135ms/step - accuracy: 0.5719 - loss: 1.6043 - val_accuracy: 0.6100 - val_loss: 1.5742\n",
      "\u001B[1m71/71\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 40ms/step - accuracy: 0.6237 - loss: 1.5347\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T14:23:36.580555Z",
     "start_time": "2024-12-20T14:23:36.351202Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Store accuracies for plotting\n",
    "accuracies = {\n",
    "    \"SimpleRNN\": simple_rnn_accuracy,\n",
    "    \"GRU\": gru_accuracy,\n",
    "    \"LSTM\": lstm_accuracy\n",
    "}\n",
    "\n",
    "# Debugging: print the accuracy dictionary\n",
    "print(\"Accuracies for plotting:\", accuracies)\n",
    "\n",
    "# Check if any value is None\n",
    "if any(value is None for value in accuracies.values()):\n",
    "    raise ValueError(\"One or more accuracy values are None. Ensure all models have computed accuracies.\")\n",
    "\n",
    "# Data extraction\n",
    "models = list(accuracies.keys())\n",
    "accuracy_values = [v[1] for v in accuracies.values()]  # Extract only accuracy (second value)\n",
    "\n",
    "# Plot Comparison\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.bar(models, accuracy_values, color=['magenta', 'beige', 'orange'])\n",
    "plt.xlabel('Model Type')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Model Accuracy Comparison')\n",
    "plt.show()\n"
   ],
   "id": "56b0af4913e3a990",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracies for plotting: {'SimpleRNN': [2.3828659057617188, 0.3757791519165039], 'GRU': [1.5186711549758911, 0.6211041808128357], 'LSTM': [1.5742485523223877, 0.6099733114242554]}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Problem 2 - (Advanced assignment) Comparison between multiple data sets",
   "id": "45e8d0bd523a108d"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T14:37:17.344545Z",
     "start_time": "2024-12-20T14:31:09.158633Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, SimpleRNN, GRU, LSTM, Dense, GlobalAveragePooling1D\n",
    "from tensorflow.keras.datasets import reuters\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load Reuters dataset\n",
    "max_features = 10000  # Use top 10k words\n",
    "maxlen = 100  # Limit each review to 100 words (document length)\n",
    "batch_size = 32\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = reuters.load_data(num_words=max_features)\n",
    "\n",
    "# Pad sequences to ensure uniform input size\n",
    "x_train = pad_sequences(x_train, maxlen=maxlen)\n",
    "x_test = pad_sequences(x_test, maxlen=maxlen)\n",
    "\n",
    "# Convert labels to categorical format (for multi-class classification)\n",
    "y_train = to_categorical(y_train)\n",
    "y_test = to_categorical(y_test)\n",
    "\n",
    "# Define Model Architectures\n",
    "\n",
    "def create_simple_rnn_model():\n",
    "    model = Sequential()\n",
    "    model.add(Embedding(max_features, 128, input_length=maxlen))\n",
    "    model.add(SimpleRNN(128, activation='tanh'))\n",
    "    model.add(Dense(46, activation='softmax'))  # 46 classes in Reuters dataset\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "def create_gru_model():\n",
    "    model = Sequential()\n",
    "    model.add(Embedding(max_features, 128, input_length=maxlen))\n",
    "    model.add(GRU(128, activation='tanh'))\n",
    "    model.add(Dense(46, activation='softmax'))  # 46 classes in Reuters dataset\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "def create_lstm_model():\n",
    "    model = Sequential()\n",
    "    model.add(Embedding(max_features, 128, input_length=maxlen))\n",
    "    model.add(LSTM(128, activation='tanh'))\n",
    "    model.add(Dense(46, activation='softmax'))  # 46 classes in Reuters dataset\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "# Train and Evaluate Models\n",
    "\n",
    "def train_and_evaluate_model(model, x_train, y_train, x_test, y_test, epochs=3):\n",
    "    model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, y_test))\n",
    "    return model.evaluate(x_test, y_test)[1]  # return accuracy\n",
    "\n",
    "# Create Models\n",
    "simple_rnn_model = create_simple_rnn_model()\n",
    "gru_model = create_gru_model()\n",
    "lstm_model = create_lstm_model()\n",
    "\n",
    "# Train and evaluate each model\n",
    "simple_rnn_accuracy = train_and_evaluate_model(simple_rnn_model, x_train, y_train, x_test, y_test)\n",
    "gru_accuracy = train_and_evaluate_model(gru_model, x_train, y_train, x_test, y_test)\n",
    "lstm_accuracy = train_and_evaluate_model(lstm_model, x_train, y_train, x_test, y_test)\n"
   ],
   "id": "ff7e87f619bc0830",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m23s\u001B[0m 72ms/step - accuracy: 0.3652 - loss: 2.4610 - val_accuracy: 0.4261 - val_loss: 2.1641\n",
      "Epoch 2/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m19s\u001B[0m 69ms/step - accuracy: 0.5065 - loss: 1.9435 - val_accuracy: 0.4488 - val_loss: 2.0999\n",
      "Epoch 3/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m21s\u001B[0m 76ms/step - accuracy: 0.6403 - loss: 1.4280 - val_accuracy: 0.4693 - val_loss: 2.0467\n",
      "\u001B[1m71/71\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m1s\u001B[0m 14ms/step - accuracy: 0.4726 - loss: 2.0096\n",
      "Epoch 1/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m52s\u001B[0m 166ms/step - accuracy: 0.3898 - loss: 2.4667 - val_accuracy: 0.5236 - val_loss: 1.7738\n",
      "Epoch 2/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m76s\u001B[0m 142ms/step - accuracy: 0.5706 - loss: 1.6611 - val_accuracy: 0.5922 - val_loss: 1.6708\n",
      "Epoch 3/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m37s\u001B[0m 130ms/step - accuracy: 0.6420 - loss: 1.4197 - val_accuracy: 0.6282 - val_loss: 1.4823\n",
      "\u001B[1m71/71\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 29ms/step - accuracy: 0.6352 - loss: 1.4608\n",
      "Epoch 1/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m47s\u001B[0m 154ms/step - accuracy: 0.3897 - loss: 2.4971 - val_accuracy: 0.5214 - val_loss: 1.8333\n",
      "Epoch 2/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m42s\u001B[0m 150ms/step - accuracy: 0.5333 - loss: 1.7567 - val_accuracy: 0.5922 - val_loss: 1.6346\n",
      "Epoch 3/3\n",
      "\u001B[1m281/281\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m44s\u001B[0m 155ms/step - accuracy: 0.6171 - loss: 1.4579 - val_accuracy: 0.6291 - val_loss: 1.5272\n",
      "\u001B[1m71/71\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 42ms/step - accuracy: 0.6393 - loss: 1.4914\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-12-20T14:39:07.127545Z",
     "start_time": "2024-12-20T14:39:06.890623Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Storing accuracies for plotting\n",
    "accuracies = {\n",
    "    \"SimpleRNN\": simple_rnn_accuracy,\n",
    "    \"GRU\": gru_accuracy,\n",
    "    \"LSTM\": lstm_accuracy\n",
    "}\n",
    "\n",
    "# Plot Comparison\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.bar(accuracies.keys(), accuracies.values(), color=['blue', 'yellow', 'magenta'])\n",
    "plt.xlabel('Model Type')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Model Accuracy Comparison: SimpleRNN vs GRU vs LSTM on Reuters Dataset')\n",
    "plt.ylim([0, 1])\n",
    "plt.show()\n",
    "\n",
    "# Print the results\n",
    "print(f\"SimpleRNN accuracy: {simple_rnn_accuracy:.4f}\")\n",
    "print(f\"GRU accuracy: {gru_accuracy:.4f}\")\n",
    "print(f\"LSTM accuracy: {lstm_accuracy:.4f}\")"
   ],
   "id": "e2e90f9ce141fbee",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SimpleRNN accuracy: 0.4693\n",
      "GRU accuracy: 0.6282\n",
      "LSTM accuracy: 0.6291\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Problem 3 - Explanation of other classes",
   "id": "d6f572a916a89065"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Define timesteps and features\n",
    "timesteps = 10   # Number of time steps\n",
    "features = 5     # Number of features per time step\n",
    "\n",
    "# RNN\n",
    "from tensorflow.keras.layers import RNN, SimpleRNNCell\n",
    "from tensorflow.keras.models import Sequential\n",
    "model = Sequential()\n",
    "model.add(RNN(SimpleRNNCell(64), input_shape=(timesteps, features)))\n",
    "\n",
    "# SimpleRNN Cell\n",
    "model = Sequential()\n",
    "model.add(RNN(SimpleRNNCell(64), input_shape=(timesteps, features)))\n",
    "\n",
    "# GRU Cell\n",
    "from tensorflow.keras.layers import GRUCell\n",
    "model = Sequential()\n",
    "model.add(RNN(GRUCell(64), input_shape=(timesteps, features)))\n",
    "\n",
    "# LSTM Cell\n",
    "from tensorflow.keras.layers import LSTMCell\n",
    "model = Sequential()\n",
    "model.add(RNN(LSTMCell(64), input_shape=(timesteps, features)))\n",
    "\n",
    "# StackedRNN Cells\n",
    "from tensorflow.keras.layers import StackedRNNCells\n",
    "cells = [SimpleRNNCell(64), SimpleRNNCell(64)]\n",
    "stacked_cells = StackedRNNCells(cells)\n",
    "model = Sequential()\n",
    "model.add(RNN(stacked_cells, input_shape=(timesteps, features)))\n",
    "\n",
    "# CuDNNGRU\n",
    "from tensorflow.keras.layers import GRU\n",
    "model = Sequential()\n",
    "model.add(GRU(64, input_shape=(timesteps, features)))\n",
    "\n",
    "# CuDNNLSTM\n",
    "from tensorflow.keras.layers import LSTM\n",
    "model = Sequential()\n",
    "model.add(LSTM(64, input_shape=(timesteps, features)))\n"
   ],
   "id": "2b41a140cc02633d"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Summary\n",
    "\n",
    "RNN: Typically used when you need to create a custom RNN layer by specifying the RNN cell.\n",
    "SimpleRNNCell, GRUCell, LSTMCell: Useful for custom RNN architectures, but rarely needed in practice since layers like SimpleRNN, GRU, and LSTM encapsulate these cells.\n",
    "\n",
    "StackedRNNCells: Used for stacking multiple RNN cells when you need a deep custom RNN architecture.\n",
    "\n",
    "CuDNNGRU and CuDNNLSTM: Use these if you have a GPU and want faster training times, especially for large models. Keras usually handles this automatically, so you don’t typically need to specify them manually unless you're optimizing for GPU performance.\n",
    "\n",
    "In practice, most people will rarely need to use SimpleRNNCell, GRUCell, LSTMCell, StackedRNNCells, or CuDNN layers directly. Instead, you'll typically work with high-level layers like SimpleRNN, GRU, and LSTM, as they abstract away the complexities and are easier to work with"
   ],
   "id": "a4f586944460d291"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}