diff --git a/02_activities/assignments/assignment_2.ipynb b/02_activities/assignments/assignment_2.ipynb index df7d7710..a5289b9c 100644 --- a/02_activities/assignments/assignment_2.ipynb +++ b/02_activities/assignments/assignment_2.ipynb @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "id": "9c28c497f620b775", "metadata": { "ExecuteTime": { @@ -76,7 +76,7 @@ " 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", + "dataset = 'mark_twain.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", @@ -84,6 +84,21 @@ "text = load_dataset(dataset, fraction=0.1)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7dc7333b", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = 'downloaded_books/mark_twain.txt'\n", + "\n", + "fraction = 0.1\n", + "with open(dataset, 'r', encoding='utf-8') as file:\n", + " raw_text = file.read()\n", + "text = raw_text[:int(fraction * len(raw_text))]" + ] + }, { "cell_type": "markdown", "id": "dab51c764031e606", @@ -103,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "id": "BunkZmdkl0Wn", "metadata": { "colab": { @@ -112,9 +127,69 @@ "id": "BunkZmdkl0Wn", "outputId": "e429a49a-9334-4484-bd6b-2ce40c8298c1" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 1000 characters of the dataset:\n", + "\n", + "The Project Gutenberg EBook of The Prince and The Pauper, Complete by\n", + "Mark Twain (Samuel Clemens)\n", + "\n", + "This eBook is for the use of anyone anywhere at no cost and with almost\n", + "no restrictions whatsoever. You may copy it, give it away or re-use\n", + "it under the terms of the Project Gutenberg License included with this\n", + "eBook or online at www.gutenberg.org\n", + "\n", + "Title: The Prince and The Pauper, Complete\n", + "\n", + "Author: Mark Twain (Samuel Clemens)\n", + "\n", + "Release Date: August 20, 2006 [EBook #1837]\n", + "Last Updated: February 19, 2018\n", + "\n", + "Language: English\n", + "\n", + "Character set encoding: UTF-8\n", + "\n", + "*** START OF THIS PROJECT GUTENBERG EBOOK PRINCE AND THE PAUPER ***\n", + "\n", + "Produced by David Widger. The earliest PG edition was prepared by Les\n", + "Bowler\n", + "\n", + "\n", + "\n", + "\n", + "THE PRINCE AND THE PAUPER\n", + "\n", + "by Mark Twain\n", + "\n", + "The Great Seal\n", + "\n", + "I will set down a tale as it was told to me by one who had it of his\n", + "father, which latter had it of HIS father, this last having in like\n", + "manner had it of HIS father--and so on, back and still back, three\n", + "hundred years and more, the fat\n", + "Dataset size (in characters): 1267477\n", + "Number of unique characters: 90\n" + ] + } + ], "source": [ - "# Your code here" + "# Your code here\n", + "# Print the first 1000 characters\n", + "print(\"First 1000 characters of the dataset:\")\n", + "print(text[:1000])\n", + "\n", + "# Report the dataset's size\n", + "dataset_size = len(text)\n", + "print(f\"Dataset size (in characters): {dataset_size}\")\n", + "\n", + "# Count the number of unique characters\n", + "unique_characters = set(text)\n", + "num_unique_characters = len(unique_characters)\n", + "print(f\"Number of unique characters: {num_unique_characters}\")" ] }, { @@ -139,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 14, "id": "4d0d30cd98ea453c", "metadata": { "id": "4d0d30cd98ea453c" @@ -149,10 +224,17 @@ "from keras.preprocessing.text import Tokenizer\n", "\n", "# Your code here\n", - "VOCAB_SIZE = None\n", - "OOV_TOKEN = None\n", + "VOCAB_SIZE = 10000 # Example size, can be adjusted\n", + "OOV_TOKEN = \"\"\n", + "\n", + "# Initialize the Tokenizer\n", + "tokenizer = Tokenizer(num_words=VOCAB_SIZE, oov_token=OOV_TOKEN)\n", "\n", - "tokenizer = None" + "# Fit the tokenizer on the text\n", + "tokenizer.fit_on_texts([text])\n", + "\n", + "# Convert text to sequences\n", + "sequences = tokenizer.texts_to_sequences([text])\n" ] }, { @@ -168,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "id": "6a7cd547a19feece", "metadata": { "colab": { @@ -182,16 +264,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tokenizer has not been initialized. Possible issue: Complete the relevant section of the assignment to initialize it.\n" + "[('', 1), ('the', 2), ('and', 3), ('of', 4), ('a', 5), ('to', 6), ('in', 7), ('was', 8), ('he', 9), ('it', 10)]\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" + "print(list(tokenizer.word_index.items())[:10])" ] }, { @@ -212,22 +290,30 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 17, "id": "4ff5fc8d0273709c", "metadata": { "id": "4ff5fc8d0273709c" }, "outputs": [], "source": [ - "SEQ_LENGTH = None # Choose an appropriate sequence length\n", + "import numpy as np\n", + "SEQ_LENGTH = 50 # Choose an appropriate sequence length\n", "\n", "# Convert the text to a list of sequences of numbers\n", - "sequences = None\n", + "sequences = sequences = tokenizer.texts_to_sequences([text])[0]\n", "\n", "# Generate the training sequences\n", "X = []\n", "y = []\n", - "# Your code here" + "# Your code here\n", + "for i in range(len(sequences) - SEQ_LENGTH):\n", + " X.append(sequences[i:i + SEQ_LENGTH])\n", + " y.append(sequences[i + SEQ_LENGTH])\n", + "\n", + "# Convert to numpy arrays for compatibility with Keras models\n", + "X = np.array(X)\n", + "y = np.array(y)" ] }, { @@ -243,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 18, "id": "a495cab04001ce92", "metadata": { "colab": { @@ -257,7 +343,12 @@ "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" + "Sequence: [ 2 163 151 929 4 2 84 3 2 627 1216 24 582 776\n", + " 2261 2747 22 929 20 16 2 327 4 1866 1443 23 46 826\n", + " 3 14 318 46 3108 2513 28 154 930 10 248 10 86 36\n", + " 2514 327 10 157 2 518 4 2]\n", + "Target: 163\n", + "Translated back to words: ['the', 'project', 'gutenberg', 'ebook', 'of', 'the', 'prince', 'and', 'the', 'pauper', 'complete', 'by', 'mark', 'twain', 'samuel', 'clemens', 'this', 'ebook', 'is', 'for', 'the', 'use', 'of', 'anyone', 'anywhere', 'at', 'no', 'cost', 'and', 'with', 'almost', 'no', 'restrictions', 'whatsoever', 'you', 'may', 'copy', 'it', 'give', 'it', 'away', 'or', 're', 'use', 'it', 'under', 'the', 'terms', 'of', 'the'] -> project\n" ] } ], @@ -282,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 19, "id": "3a929b2e6c2cc921", "metadata": { "colab": { @@ -296,7 +387,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tokenizer has not been initialized. Please initialize it and load the vocabulary before continuing.\n" + "X_train shape: (181554, 50)\n", + "y_train shape: (181554, 10000)\n" ] } ], @@ -352,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 21, "id": "9fdfaad93818fc8d", "metadata": { "colab": { @@ -366,7 +458,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "No layers have been added to the model. Please complete the assignment by adding the required layers.\n" + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " embedding_1 (Embedding) (None, 50, 128) 1280000 \n", + " \n", + " lstm_1 (LSTM) (None, 128) 131584 \n", + " \n", + " dense_1 (Dense) (None, 10000) 1290000 \n", + " \n", + "=================================================================\n", + "Total params: 2,701,584\n", + "Trainable params: 2,701,584\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" ] } ], @@ -374,10 +480,25 @@ "from keras.models import Sequential\n", "from keras.layers import Embedding, LSTM, Dense\n", "\n", + "# Define model parameters\n", + "VOCAB_SIZE = 10000 # Size of the vocabulary\n", + "EMBEDDING_DIM = 128 # Size of the dense representation\n", + "SEQ_LENGTH = 50 # Length of input sequences\n", + "NUM_CLASSES = VOCAB_SIZE # Number of output classes (same as vocabulary size)\n", + "\n", + "# Initialize the model\n", "model = Sequential([\n", - " # Your code here\n", + " # Embedding layer\n", + " Embedding(input_dim=VOCAB_SIZE, output_dim=EMBEDDING_DIM, input_length=SEQ_LENGTH),\n", + " \n", + " # LSTM layer\n", + " LSTM(units=128, return_sequences=False), # Adjust units as needed\n", + " \n", + " # Dense layer with softmax activation\n", + " Dense(NUM_CLASSES, activation='softmax')\n", "])\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", @@ -399,19 +520,36 @@ "\n", "Give a short explanation of your choice of loss function and optimizer:\n", "\n", - "_your explanation here_" + "_your explanation here_\n", + "\n", + "*Loss Function: categorical_crossentropy*\n", + "\n", + "Reason: The categorical_crossentropy loss function is appropriate for multi-class classification problems where the target is one of several classes. In this case, our model is predicting the next word in a sequence from a vocabulary of possible words. Each word in the vocabulary represents a class, so this loss function helps the model minimize the error between the predicted probabilities for each word and the actual word in the sequence. It's particularly suited for problems where the target labels are one-hot encoded, as is the case here.\n", + "\n", + "*Optimizer: adam*\n", + "\n", + "Reason: The adam optimizer is a popular choice for training deep learning models due to its adaptive learning rate properties. It combines the benefits of two other extensions of stochastic gradient descent: AdaGrad and RMSProp. Adam adapts the learning rate for each parameter individually, which often leads to faster convergence and better performance. It is computationally efficient and requires minimal tuning of hyperparameters, making it a robust choice for a wide range of problems.\n", + "\n", + "*Metrics: accuracy*\n", + "\n", + "Reason: Tracking accuracy as a metric provides a straightforward way to evaluate how well the model is performing in terms of correctly predicting the next word in the sequence. Accuracy is a useful metric for classification problems because it shows the proportion of correctly predicted tokens out of the total tokens. Monitoring this metric during training helps us gauge the effectiveness of the model and its ability to generalize to new data." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, "id": "ae4ca7a12051b1fd", "metadata": { "id": "ae4ca7a12051b1fd" }, "outputs": [], "source": [ - "# Your code here" + "# Your code here\n", + "model.compile(\n", + " optimizer='adam', # Optimizer\n", + " loss='categorical_crossentropy', # Loss function for multi-class classification\n", + " metrics=['accuracy'] # Metrics to track\n", + ")" ] }, { @@ -432,7 +570,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 23, "id": "256b1ea138c67ef7", "metadata": { "colab": { @@ -441,9 +579,34 @@ "id": "256b1ea138c67ef7", "outputId": "fba36993-0bf3-472e-f1c3-1da548c12ead" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5\n", + "1419/1419 [==============================] - 107s 74ms/step - loss: 6.7005 - accuracy: 0.0762 - val_loss: 6.3688 - val_accuracy: 0.0966\n", + "Epoch 2/5\n", + "1419/1419 [==============================] - 107s 75ms/step - loss: 6.0732 - accuracy: 0.1122 - val_loss: 6.0005 - val_accuracy: 0.1200\n", + "Epoch 3/5\n", + "1419/1419 [==============================] - 108s 76ms/step - loss: 5.6569 - accuracy: 0.1333 - val_loss: 5.7443 - val_accuracy: 0.1348\n", + "Epoch 4/5\n", + "1419/1419 [==============================] - 104s 73ms/step - loss: 5.2956 - accuracy: 0.1520 - val_loss: 5.5598 - val_accuracy: 0.1464\n", + "Epoch 5/5\n", + "1419/1419 [==============================] - 97s 69ms/step - loss: 4.9810 - accuracy: 0.1694 - val_loss: 5.4226 - val_accuracy: 0.1540\n" + ] + } + ], "source": [ - "# Your code here" + "# Your code here\n", + "# Train the model\n", + "history = model.fit(\n", + " X_train, \n", + " y_train, \n", + " epochs=5, \n", + " batch_size=128, \n", + " validation_data=(X_val, y_val)\n", + ")\n" ] }, { @@ -458,16 +621,42 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 24, "id": "9e8cacec70d8f313", "metadata": { "id": "9e8cacec70d8f313" }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", - "# Your code here" + "# Your code here\n", + "\n", + "# Extract loss values from the history\n", + "train_loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "# Plot the training and validation loss\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(train_loss, label='Training Loss')\n", + "plt.plot(val_loss, label='Validation Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training and Validation Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" ] }, { @@ -503,14 +692,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 28, "id": "d73dbf278a1265ef", "metadata": { "collapsed": false }, "outputs": [], "source": [ - "from keras.preprocessing.sequence import pad_sequences\n", + "from tensorflow.keras.preprocessing.sequence import pad_sequences\n", "\n", "def get_predicted_word(model, sequence):\n", " \"\"\"\n", @@ -527,23 +716,56 @@ "\n", " return yhat\n", "\n", - "def generate_text(model, tokenizer, seed_text, max_sequence_len):\n", + "def generate_text(model, tokenizer, seed_text, max_sequence_len, num_words_to_generate=50):\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" + " token_list = tokenizer.texts_to_sequences([seed_text])[0]\n", + " token_list = pad_sequences([token_list], maxlen=max_sequence_len, padding='pre')\n", + " \n", + " # Generate text\n", + " generated_text = seed_text\n", + " for _ in range(num_words_to_generate):\n", + " # Predict the next token\n", + " predicted_id = get_predicted_word(model, token_list)\n", + " \n", + " # Convert the token ID to a word\n", + " predicted_word = tokenizer.index_word.get(predicted_id, '')\n", + " \n", + " if predicted_word == '':\n", + " break\n", + " \n", + " # Append the predicted word to the generated text\n", + " generated_text += ' ' + predicted_word\n", + " \n", + " # Update the sequence\n", + " token_list = np.roll(token_list, shift=-1, axis=1)\n", + " token_list[0, -1] = predicted_id\n", + " \n", + " return generated_text\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 29, "id": "f463b0c3df49e2c", "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'hamlet new enough more in the ohio for my place and another pilot is wanted up like i took that a terror is crooked in a place but he joined in him \\xa0now you are worn they does well else i should presently villages dropped in further goodwife alone but you'" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Test the text generation function\n", "generate_text(model, tokenizer, 'hamlet', SEQ_LENGTH)" @@ -571,12 +793,23 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 30, "id": "dda8b0f845c20862", "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "'wget' is not recognized as an internal or external command,\n", + "operable program or batch file.\n", + "'unzip' is not recognized as an internal or external command,\n", + "operable program or batch file.\n" + ] + } + ], "source": [ "!wget https://downloads.cs.stanford.edu/nlp/data/glove.6B.zip\n", "!unzip glove.6B.zip" @@ -584,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 32, "id": "e8b777220505635", "metadata": { "collapsed": false @@ -615,20 +848,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 33, "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" - ] - } - ], + "outputs": [], "source": [ "# Check if VOCAB_SIZE is set\n", "if VOCAB_SIZE is None:\n", @@ -645,20 +870,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 34, "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" - ] - } - ], + "outputs": [], "source": [ "# Check if VOCAB_SIZE is set\n", "if VOCAB_SIZE is None:\n", @@ -671,16 +888,133 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 36, "id": "236cb723e4e5b3fc", "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_2\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " embedding_2 (Embedding) (None, 50, 100) 1000000 \n", + " \n", + " lstm_3 (LSTM) (None, 50, 128) 117248 \n", + " \n", + " dropout (Dropout) (None, 50, 128) 0 \n", + " \n", + " lstm_4 (LSTM) (None, 128) 131584 \n", + " \n", + " dense_2 (Dense) (None, 10000) 1290000 \n", + " \n", + "=================================================================\n", + "Total params: 2,538,832\n", + "Trainable params: 1,538,832\n", + "Non-trainable params: 1,000,000\n", + "_________________________________________________________________\n", + "Epoch 1/15\n", + "2837/2837 [==============================] - 199s 69ms/step - loss: 6.7181 - accuracy: 0.0742 - val_loss: 6.4170 - val_accuracy: 0.0866\n", + "Epoch 2/15\n", + "2837/2837 [==============================] - 193s 68ms/step - loss: 6.1655 - accuracy: 0.0971 - val_loss: 6.0831 - val_accuracy: 0.1058\n", + "Epoch 3/15\n", + "2837/2837 [==============================] - 192s 68ms/step - loss: 5.7733 - accuracy: 0.1119 - val_loss: 5.8156 - val_accuracy: 0.1176\n", + "Epoch 4/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 5.4481 - accuracy: 0.1202 - val_loss: 5.6535 - val_accuracy: 0.1240\n", + "Epoch 5/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 5.1651 - accuracy: 0.1273 - val_loss: 5.5375 - val_accuracy: 0.1297\n", + "Epoch 6/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 4.9236 - accuracy: 0.1344 - val_loss: 5.4731 - val_accuracy: 0.1314\n", + "Epoch 7/15\n", + "2837/2837 [==============================] - 194s 68ms/step - loss: 4.7116 - accuracy: 0.1459 - val_loss: 5.4168 - val_accuracy: 0.1352\n", + "Epoch 8/15\n", + "2837/2837 [==============================] - 195s 69ms/step - loss: 4.5287 - accuracy: 0.1617 - val_loss: 5.3956 - val_accuracy: 0.1420\n", + "Epoch 9/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 4.3721 - accuracy: 0.1782 - val_loss: 5.3520 - val_accuracy: 0.1494\n", + "Epoch 10/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 4.2359 - accuracy: 0.1924 - val_loss: 5.3276 - val_accuracy: 0.1578\n", + "Epoch 11/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 4.1175 - accuracy: 0.2055 - val_loss: 5.3131 - val_accuracy: 0.1672\n", + "Epoch 12/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 4.0148 - accuracy: 0.2172 - val_loss: 5.3135 - val_accuracy: 0.1712\n", + "Epoch 13/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 3.9260 - accuracy: 0.2284 - val_loss: 5.3036 - val_accuracy: 0.1794\n", + "Epoch 14/15\n", + "2837/2837 [==============================] - 191s 67ms/step - loss: 3.8439 - accuracy: 0.2383 - val_loss: 5.2959 - val_accuracy: 0.1836\n", + "Epoch 15/15\n", + "2837/2837 [==============================] - 192s 68ms/step - loss: 3.7668 - accuracy: 0.2492 - val_loss: 5.3071 - val_accuracy: 0.1868\n" + ] + } + ], "source": [ "# Define a new model and train it\n", "\n", - "# Your code here" + "# Your code here\n", + "from tensorflow.keras.layers import Dropout\n", + "# Define a new model architecture\n", + "model = Sequential([\n", + " embedding_layer,\n", + " LSTM(units=128, return_sequences=True), # Using LSTM layer\n", + " Dropout(0.2), # Add dropout for regularization\n", + " LSTM(units=128), # Another LSTM layer\n", + " Dense(NUM_CLASSES, activation='softmax') # Dense output layer\n", + "])\n", + "\n", + "# Compile the model\n", + "model.compile(\n", + " optimizer='adam',\n", + " loss='categorical_crossentropy',\n", + " metrics=['accuracy']\n", + ")\n", + "\n", + "# Print the model summary\n", + "model.summary()\n", + "\n", + "# Train the model with updated architecture\n", + "history = model.fit(\n", + " X_train, y_train,\n", + " epochs=15, # Increase the number of epochs\n", + " batch_size=64, # Adjust batch size if needed\n", + " validation_data=(X_val, y_val)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "e8dbac78", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract loss values from the history\n", + "train_loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "# Plot the training and validation loss\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(train_loss, label='Training Loss')\n", + "plt.plot(val_loss, label='Validation Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training and Validation Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" ] }, { @@ -746,7 +1080,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.9.15" } }, "nbformat": 4,