02_activities/assignments/assignment_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7c6788aef474ca12",
   "metadata": {
    "collapsed": false,
    "id": "7c6788aef474ca12"
   },
   "source": [
    "# Text Generation with Recurrent Neural Networks (RNNs)\n",
    "\n",
    "In this assignment, you'll build upon your understanding of RNNs and Keras to develop a word-level text generation model.  Your goal is to train a model that learns the stylistic nuances of a chosen corpus and generates new, original text segments that echo the source material's essence.\n",
    "\n",
    "**Datasets**\n",
    "\n",
    "We've provided several intriguing text corpora to get you started:\n",
    "\n",
    "*   Mark Twain\n",
    "*   Charles Dickens\n",
    "*   William Shakespeare\n",
    "\n",
    "**Feel free to explore!**  If you have a particular passion for another author, genre, or a specific text, you're encouraged to use your own dataset of raw text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2d0bfedcfe52aedc",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2d0bfedcfe52aedc",
    "outputId": "eef898b3-cf85-43d1-9715-30194b9932d3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No GPU available. If you're on Colab, go to Runtime > Change runtime and select a GPU hardware accelerator.\n"
     ]
    }
   ],
   "source": [
    "# Check if we have a GPU available\n",
    "import tensorflow as tf\n",
    "if tf.test.gpu_device_name():\n",
    "    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))\n",
    "else:\n",
    "    print(\"No GPU available. If you're on Colab, go to Runtime > Change runtime and select a GPU hardware accelerator.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9c28c497f620b775",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-08T21:30:44.959803Z",
     "start_time": "2024-02-08T21:30:44.701343Z"
    },
    "id": "9c28c497f620b775"
   },
   "outputs": [],
   "source": [
    "def download_file(url, file_path):\n",
    "    import requests\n",
    "    r = requests.get(url)\n",
    "    with open(file_path, 'wb') as f:\n",
    "        f.write(r.content)\n",
    "\n",
    "def load_dataset(file_path, fraction=1.0):\n",
    "    with open(file_path, 'r', encoding='utf-8') as f:\n",
    "        raw_text = f.read()\n",
    "    return raw_text[:int(fraction * len(raw_text))]\n",
    "\n",
    "dataset = 'shakespeare.txt' # Other options are mark_twain.txt, charles_dickens.txt\n",
    "\n",
    "download_file(f'https://github.com/UofT-DSI/deep_learning/raw/main/assignments/downloaded_books/' + dataset, dataset)\n",
    "\n",
    "# Load chosen dataset. NOTE: If Colab is running out of memory, change the `fraction` parameter to a value between 0 and 1 to load less data.\n",
    "text = load_dataset(dataset, fraction=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dab51c764031e606",
   "metadata": {
    "collapsed": false,
    "id": "dab51c764031e606"
   },
   "source": [
    "# 1. Data Preparation (Complete or Incomplete)\n",
    "\n",
    "Before we can begin training an RNN model, we need to prepare the dataset. This involves cleaning the text, tokenizing words, and creating sequences the model can be trained on.\n",
    "\n",
    "## 1.1 Data Exploration\n",
    "\n",
    "Print the first 1000 characters of the dataset. Report the dataset's size and the number of unique characters it contains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "BunkZmdkl0Wn",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BunkZmdkl0Wn",
    "outputId": "e429a49a-9334-4484-bd6b-2ce40c8298c1"
   },
   "outputs": [],
   "source": [
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae1639f5ecfe587",
   "metadata": {
    "collapsed": false,
    "id": "3ae1639f5ecfe587"
   },
   "source": [
    "## 1.2 Text Pre-Processing\n",
    "\n",
    "To prepare the dataset for training, we need to clean the text and create a numerical representation the model can interpret. Perform the following pre-processing steps:\n",
    "\n",
    "*   Convert the entire text to lowercase.\n",
    "*   Use the `Tokenizer` class from the `keras.preprocessing.text` module to tokenize the text. You should fit the tokenizer on the text and then convert the text to a sequence of numbers. You can use the `texts_to_sequences` method to do this.\n",
    "\n",
    "**Note**:\n",
    "* You'll need to specify an appropriate size for the vocabulary. The number of words in the list of most common words can serve as a guide - does it seem like a reasonable vocabulary size?\n",
    "* Some of the words will be excluded from the vocabulary, as they don't appear often enough. It's important to provide a value for `oov_token` when creating the Tokenizer instance, so that these words can be represented as \"unknown\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4d0d30cd98ea453c",
   "metadata": {
    "id": "4d0d30cd98ea453c"
   },
   "outputs": [],
   "source": [
    "from keras.preprocessing.text import Tokenizer\n",
    "\n",
    "# Your code here\n",
    "VOCAB_SIZE = None\n",
    "OOV_TOKEN = None\n",
    "\n",
    "tokenizer = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89d32bb9356f711",
   "metadata": {
    "collapsed": false,
    "id": "89d32bb9356f711"
   },
   "source": [
    "If everything worked, the following line should show you the first 10 words in the vocabulary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6a7cd547a19feece",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6a7cd547a19feece",
    "outputId": "1f52c24c-fe9d-4074-a6b9-2be1b36a172e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokenizer has not been initialized. Possible issue: Complete the relevant section of the assignment to initialize it.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(list(tokenizer.word_index.items())[:10])\n",
    "except AttributeError:\n",
    "    print(\"Tokenizer has not been initialized. Possible issue: Complete the relevant section of the assignment to initialize it.\"\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da504e4bc6617613",
   "metadata": {
    "collapsed": false,
    "id": "da504e4bc6617613"
   },
   "source": [
    "## 1.3 Sequence Generation\n",
    "\n",
    "Now that the text has been tokenized, we need to create sequences the model can be trained on. There are two parts to this:\n",
    "\n",
    "*   Use the `texts_to_sequences` method from the tokenizer to convert the text to a list of sequences of numbers.\n",
    "*   Generate the training sequences. Each training sequence should contain `SEQ_LENGTH` token IDs from the text. The target token for each sequence should be the word that follows the sequence in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4ff5fc8d0273709c",
   "metadata": {
    "id": "4ff5fc8d0273709c"
   },
   "outputs": [],
   "source": [
    "SEQ_LENGTH = None # Choose an appropriate sequence length\n",
    "\n",
    "# Convert the text to a list of sequences of numbers\n",
    "sequences = None\n",
    "\n",
    "# Generate the training sequences\n",
    "X = []\n",
    "y = []\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b6bdc0deb930df1",
   "metadata": {
    "collapsed": false,
    "id": "3b6bdc0deb930df1"
   },
   "source": [
    "Assuming your sequences are stored in `X` and the corresponding targets in `y`, the following line should print the first training sequence and its target:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a495cab04001ce92",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a495cab04001ce92",
    "outputId": "ecc2c1f4-81d5-4edb-ba86-8c53f86df70b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training sequences have not been generated. Possible issue: Complete the relevant section of the assignment to initialize it.\n"
     ]
    }
   ],
   "source": [
    "if len(X) > 0 and len(y) > 0:\n",
    "    print(f'Sequence: {X[0]}\\nTarget: {y[0]}')\n",
    "    print(f'Translated back to words: {[tokenizer.index_word[i] for i in X[0]]} -> {tokenizer.index_word[y[0]]}')\n",
    "else:\n",
    "    print(\"Training sequences have not been generated. Possible issue: Complete the relevant section of the assignment to initialize it.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5bb2c55da17aaa0",
   "metadata": {
    "collapsed": false,
    "id": "d5bb2c55da17aaa0"
   },
   "source": [
    "And the following code will transform y into a one-hot encoded matrix, and split everything into training and validation sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3a929b2e6c2cc921",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3a929b2e6c2cc921",
    "outputId": "bbac2f5d-5ec3-40d0-fdd7-c567088569d7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokenizer has not been initialized. Please initialize it and load the vocabulary before continuing.\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from keras.utils import to_categorical\n",
    "import numpy as np\n",
    "\n",
    "# Ensure that tokenizer has been initialized\n",
    "if tokenizer is not None:\n",
    "    # Convert X and y to numpy arrays\n",
    "    X = np.array(X)\n",
    "    y = np.array(y)\n",
    "\n",
    "    # One last thing: let's drop any examples where the target is the OOV token - we don't want our model to predict that (boring!)\n",
    "    if OOV_TOKEN in tokenizer.word_index:\n",
    "        mask = y != tokenizer.word_index[OOV_TOKEN]\n",
    "        X = X[mask]\n",
    "        y = y[mask]\n",
    "\n",
    "    # One-hot encode the target token\n",
    "    y = to_categorical(y, num_classes=VOCAB_SIZE)\n",
    "\n",
    "    # Split the data into training and validation sets\n",
    "    X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "    print(f'X_train shape: {X_train.shape}')\n",
    "    print(f'y_train shape: {y_train.shape}')\n",
    "else:\n",
    "    print(\"Tokenizer has not been initialized. Please initialize it and load the vocabulary before continuing.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6e4161897210434",
   "metadata": {
    "collapsed": false,
    "id": "b6e4161897210434"
   },
   "source": [
    "# 2. Model Development (Complete or Incomplete)\n",
    "\n",
    "With the dataset prepared, it's time to develop the RNN model. You'll need to define the architecture of the model, compile it, and prepare it for training.\n",
    "\n",
    "## 2.1 Model Architecture\n",
    "\n",
    "Define the architecture of your RNN model. You can design it however you like, but there are a few features that it's important to include:\n",
    "\n",
    "*   An embedding layer that learns a dense representation of the input tokens. You'll need to specify the input dimension (the size of the vocabulary) and the output dimension (the size of the dense representation). Remember, you can look at the documentation [here](https://keras.io/api/layers/core_layers/embedding/).\n",
    "*   At least one recurrent layer. We have learned how to use LSTM layers in class, but you can use other types of recurrent layers if you prefer. You can find the documentation [here](https://keras.io/api/layers/recurrent_layers/lstm/).\n",
    "*   A dense layer with a softmax activation function. This layer will output a probability distribution over the vocabulary, so that the model can make predictions about the next token."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9fdfaad93818fc8d",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9fdfaad93818fc8d",
    "outputId": "ae02a273-ab37-4274-d41c-b2c0c80350d6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No layers have been added to the model. Please complete the assignment by adding the required layers.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Embedding, LSTM, Dense\n",
    "\n",
    "model = Sequential([\n",
    "    # Your code here\n",
    "])\n",
    "\n",
    "# Check if the model has layers before trying to print the summary\n",
    "if len(model.layers) > 0:\n",
    "    model.summary()\n",
    "else:\n",
    "    print(\"No layers have been added to the model. Please complete the assignment by adding the required layers.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fafd2dbb0d589fc",
   "metadata": {
    "collapsed": false,
    "id": "2fafd2dbb0d589fc"
   },
   "source": [
    "## 2.2 Model Compilation\n",
    "\n",
    "Compile the model with an appropriate loss function and optimizer. You might also want to track additional metrics, such as accuracy.\n",
    "\n",
    "Give a short explanation of your choice of loss function and optimizer:\n",
    "\n",
    "_your explanation here_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ae4ca7a12051b1fd",
   "metadata": {
    "id": "ae4ca7a12051b1fd"
   },
   "outputs": [],
   "source": [
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2f0b90a448c4f4b",
   "metadata": {
    "collapsed": false,
    "id": "c2f0b90a448c4f4b"
   },
   "source": [
    "## 2.3 Model Training\n",
    "\n",
    "Train the model on the training data you've prepared.\n",
    "\n",
    "* Train your model for 5 epochs with a batch size of 128. Use the validation data for validation.\n",
    "* Store the training history in a variable called `history`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "256b1ea138c67ef7",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "256b1ea138c67ef7",
    "outputId": "fba36993-0bf3-472e-f1c3-1da548c12ead"
   },
   "outputs": [],
   "source": [
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "195c59bf80d2a2c4",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Plot the training history to visualize the model's learning progress. Your plot should include the training and validation loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e8cacec70d8f313",
   "metadata": {
    "id": "9e8cacec70d8f313"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d9ed71305787aed",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 3. Text Generation (Complete or Incomplete)\n",
    "\n",
    "Write a method called `generate_text` that uses the trained model to generate new text. The method should take the following parameters:\n",
    "\n",
    "*   `model`: The trained RNN model.\n",
    "*   `tokenizer`: The tokenizer used to pre-process the text data.\n",
    "*   `seed_text`: The seed text the model will use to generate new text.\n",
    "*   `max_sequence_len`: The maximum length of the sequence used to generate new text.\n",
    "\n",
    "The method should return the generated text.\n",
    "\n",
    "An overview of the text generation process you should follow:\n",
    "\n",
    "1. Tokenize the seed text using the tokenizer we built before.\n",
    "2. Pad the sequences to the same length as the training sequences - you can use the `pad_sequences` method from the `keras.preprocessing.sequence` module, which is documented [here](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/sequence/pad_sequences).\n",
    "3. Use the model to predict the next token in the sequence. Remember that the model will output a probability distribution over the vocabulary, so you'll need to use `np.argmax` to find the token with the highest probability.\n",
    "4. Add the predicted token to the sequence and remove the first token.\n",
    "5. Repeat steps 3-4 until you have generated the desired number of tokens.\n",
    "6. Convert the generated token IDs back to words and return the combined result as a single string.\n",
    "\n",
    "This is a challenging task, so don't hesitate to ask for help if you need it. It's okay if the generated text doesn't make much sense yet - we'll work on improving the model next.\n",
    "As a bonus, you can make your method generate \"gpt-style\" by having it print out each word as it's generated, so you can see the text being generated in real time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d73dbf278a1265ef",
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "def get_predicted_word(model, sequence):\n",
    "    \"\"\"\n",
    "    Get the predicted word from the model.\n",
    "    This helper function uses a concept we haven't covered in class yet: temperature.\n",
    "    In essence, a little bit of randomness in what word we predict can make the text more interesting.\n",
    "    \"\"\"\n",
    "\n",
    "    # Use the model to predict the next token in the sequence\n",
    "    yhat = model.predict(sequence, verbose=0)\n",
    "\n",
    "    # Get the index of the predicted word, according to the probabilities\n",
    "    yhat = np.random.choice(range(VOCAB_SIZE), p=yhat.ravel())\n",
    "\n",
    "    return yhat\n",
    "\n",
    "def generate_text(model, tokenizer, seed_text, max_sequence_len):\n",
    "    \"\"\"\n",
    "    Generate new text using the trained model.\n",
    "    You can use the `get_predicted_word` helper function to help you with this.\n",
    "    \"\"\"\n",
    "    \n",
    "    return None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f463b0c3df49e2c",
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Test the text generation function\n",
    "generate_text(model, tokenizer, 'hamlet', SEQ_LENGTH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5871d836a0135c41",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "It's likely that the text generated by your model doesn't make much sense yet. This is because the model hasn't been trained for very long, and the training dataset is relatively small. \n",
    "\n",
    "# 4. Model Refinement (Complete or Incomplete)\n",
    "\n",
    "In this last section, you'll work on improving your model. There are many ways to do this, but here are a few ideas to get you started:\n",
    "\n",
    "* Use pre-trained embeddings: the code below will help you to load pre-trained embeddings through Keras. \n",
    "* Experiment with different model architectures, including the number of layers, the number of units in each layer, and the use of dropout layers.\n",
    "* Train your model for longer. You can also experiment with different batch sizes.\n",
    "\n",
    "Implement and test out at least one of these ideas. If you have other ideas for improving the model, feel free to try them out as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dda8b0f845c20862",
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!wget https://downloads.cs.stanford.edu/nlp/data/glove.6B.zip\n",
    "!unzip glove.6B.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e8b777220505635",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 400000 word vectors.\n"
     ]
    }
   ],
   "source": [
    "# Load the pre-trained embeddings\n",
    "embeddings_index = {}\n",
    "try:\n",
    "    with open('glove.6B.100d.txt', encoding='utf-8') as f:\n",
    "        for line in f:\n",
    "            values = line.split()\n",
    "            word = values[0]\n",
    "            coefs = np.asarray(values[1:], dtype='float32')\n",
    "            embeddings_index[word] = coefs\n",
    "    print(f'Found {len(embeddings_index)} word vectors.')\n",
    "except FileNotFoundError:\n",
    "    print(\"'glove.6B.100d.txt' File not found. Please make sure you have ran the previous cell.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d3e48ff004757cf2",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You need to complete the previous parts of your assignment in order for this to work.\n"
     ]
    }
   ],
   "source": [
    "# Check if VOCAB_SIZE is set\n",
    "if VOCAB_SIZE is None:\n",
    "    print(\"You need to complete the previous parts of your assignment in order for this to work.\")\n",
    "else:\n",
    "    # Create an embedding matrix\n",
    "    embedding_matrix = np.zeros((VOCAB_SIZE, 100))\n",
    "    for word, i in tokenizer.word_index.items():\n",
    "        if i < VOCAB_SIZE:\n",
    "            embedding_vector = embeddings_index.get(word)\n",
    "            if embedding_vector is not None:\n",
    "                embedding_matrix[i] = embedding_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e3d21d5dbbbcf9f9",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You need to complete the previous parts of your assignment in order for this to work.\n"
     ]
    }
   ],
   "source": [
    "# Check if VOCAB_SIZE is set\n",
    "if VOCAB_SIZE is None:\n",
    "    print(\"You need to complete the previous parts of your assignment in order for this to work.\")\n",
    "else:\n",
    "    embedding_layer = Embedding(\n",
    "        VOCAB_SIZE, 100, weights=[embedding_matrix], input_length=SEQ_LENGTH, trainable=False\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "236cb723e4e5b3fc",
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Define a new model and train it\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "742095fb",
   "metadata": {},
   "source": [
    "## Criteria\n",
    "\n",
    "|Criteria|Complete|Incomplete|\n",
    "|----|----|----|\n",
    "|Task 1|The task has been completed successfully and there are no errors.|The task is still incomplete and there is at least one error.|\n",
    "|Task 2|The task has been completed successfully and there are no errors.|The task is still incomplete and there is at least one error.|\n",
    "|Task 3|The task has been completed successfully and there are no errors.|The task is still incomplete and there is at least one error.|\n",
    "|Task 4|The task has been completed successfully and there are no errors.|The task is still incomplete and there is at least one error.|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1990e2d2",
   "metadata": {},
   "source": [
    "## Submission Information\n",
    "\n",
    "🚨**Please review our [Assignment Submission Guide](https://github.com/UofT-DSI/onboarding/blob/main/onboarding_documents/submissions.md)**🚨 for detailed instructions on how to format, branch, and submit your work. Following these guidelines is crucial for your submissions to be evaluated correctly.\n",
    "\n",
    "### Submission Parameters:\n",
    "* Submission Due Date: `HH:MM AM/PM - DD/MM/YYYY`\n",
    "* The branch name for your repo should be: `assignment-2`\n",
    "* What to submit for this assignment:\n",
    "    * This Jupyter Notebook (assignment_2.ipynb) should be populated and should be the only change in your pull request.\n",
    "* What the pull request link should look like for this assignment: `https://github.com/<your_github_username>/deep_learning/pull/<pr_id>`\n",
    "    * Open a private window in your browser. Copy and paste the link to your pull request into the address bar. Make sure you can see your pull request properly. This helps the technical facilitator and learning support staff review your submission easily.\n",
    "\n",
    "Checklist:\n",
    "- [ ] Created a branch with the correct naming convention.\n",
    "- [ ] Ensured that the repository is public.\n",
    "- [ ] Reviewed the PR description guidelines and adhered to them.\n",
    "- [ ] Verify that the link is accessible in a private browser window.\n",
    "\n",
    "If you encounter any difficulties or have questions, please don't hesitate to reach out to our team via our Slack at `#cohort-3-help`. Our Technical Facilitators and Learning Support staff are here to help you navigate any challenges."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}