From 40e221b6e001f4bbb6c3feedacd8c4500f28a2cb Mon Sep 17 00:00:00 2001 From: luislague Date: Fri, 4 Oct 2024 16:35:10 +0200 Subject: [PATCH] Solution Lab --- main.ipynb | 475 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 444 insertions(+), 31 deletions(-) diff --git a/main.ipynb b/main.ipynb index 9308e12..f63a5e1 100644 --- a/main.ipynb +++ b/main.ipynb @@ -38,8 +38,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-08-16 22:09:18.737563: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + "2024-10-04 14:09:52.649618: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-04 14:09:52.649715: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-04 14:09:52.651552: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-04 14:09:52.663393: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-04 14:09:54.427138: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" ] } ], @@ -51,7 +55,8 @@ "from tensorflow.keras.optimizers import Adam\n", "from tensorflow.keras import regularizers\n", "import tensorflow.keras.utils as ku \n", - "import numpy as np" + "import numpy as np\n", + "from tensorflow.keras.regularizers import l2\n" ] }, { @@ -93,7 +98,9 @@ "metadata": {}, "outputs": [], "source": [ - "# Your code here :" + "# Initialize tokenizer and fit the corpus\n", + "tokenizer = Tokenizer()\n", + "tokenizer.fit_on_texts(corpus)" ] }, { @@ -111,9 +118,19 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total nunber of unique words: 3375\n" + ] + } + ], "source": [ - "# Your code here :" + "# Check number of words in the corpus\n", + "total_words = len(tokenizer.word_index) + 1 # Total number of unique words\n", + "print(f\"Total nunber of unique words: {total_words}\")" ] }, { @@ -132,9 +149,26 @@ "cell_type": "code", "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total input sequences: 15484\n" + ] + } + ], "source": [ - "# Your code here :" + "# Create empty list\n", + "input_sequences = []\n", + "\n", + "for sentence in corpus:\n", + " token_list = tokenizer.texts_to_sequences([sentence])[0] # Convert each line to a sequence of integers\n", + " for i in range(1, len(token_list)):\n", + " n_gram_sequence = token_list[:i+1] # Generate n-gram sequences\n", + " input_sequences.append(n_gram_sequence) # Append to input_sequences\n", + "\n", + "print(f'Total input sequences: {len(input_sequences)}')\n" ] }, { @@ -151,9 +185,37 @@ "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max sequence length: 11\n", + "[[ 0 0 0 0 0 0 0 0 0 3 2]\n", + " [ 0 0 0 0 0 0 0 0 3 2 313]\n", + " [ 0 0 0 0 0 0 0 3 2 313 1375]\n", + " [ 0 0 0 0 0 0 3 2 313 1375 4]\n", + " [ 0 0 0 0 0 0 0 0 0 118 1376]]\n", + "[[ 0 0 0 0 0 0 0 0 0 3 2]\n", + " [ 0 0 0 0 0 0 0 0 3 2 313]\n", + " [ 0 0 0 0 0 0 0 3 2 313 1375]\n", + " [ 0 0 0 0 0 0 3 2 313 1375 4]\n", + " [ 0 0 0 0 0 0 0 0 0 118 1376]]\n" + ] + } + ], "source": [ - "# Your code here :" + "# Calculate length of the longest sequence\n", + "max_sequence_len = max([len(seq) for seq in input_sequences])\n", + "print(f\"Max sequence length: {max_sequence_len}\")\n", + "\n", + "# Pad sequences to ensure they have the same length\n", + "input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')\n", + "print(input_sequences[:5])\n", + "\n", + "# Convert sequences into a numpy array\n", + "input_sequences = np.array(input_sequences)\n", + "print(input_sequences[:5])\n" ] }, { @@ -175,9 +237,23 @@ "id": "PRnDnCW-Z7qv", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictors shape: (15484, 10)\n", + "Labels shape: (15484,)\n" + ] + } + ], "source": [ - "# Your code here :" + "# Prepare predictors and labels\n", + "predictors = input_sequences[:, :-1] # All elements except of last one in each sequence\n", + "labels = input_sequences[:, -1] # Only the las element in each sequence\n", + "\n", + "print(f'Predictors shape: {predictors.shape}')\n", + "print(f'Labels shape: {labels.shape}')" ] }, { @@ -199,9 +275,20 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Labels shape after one-hot encoding: (15484, 3375)\n" + ] + } + ], "source": [ - "# Your code here :" + "# One hot enconde the labels\n", + "labels = ku.to_categorical(labels, num_classes=total_words)\n", + "\n", + "print(f'Labels shape after one-hot encoding: {labels.shape}')\n" ] }, { @@ -231,13 +318,36 @@ "cell_type": "code", "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-04 14:09:58.129989: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:09:58.420748: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:09:58.421082: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:09:58.422949: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:09:58.423195: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:09:58.423363: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:10:00.563306: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:10:00.563627: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:10:00.563829: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 14:10:00.563961: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 7393 MB memory: -> device: 0, name: Quadro P4000, pci bus id: 0000:00:05.0, compute capability: 6.1\n" + ] + } + ], "source": [ "model = Sequential([\n", "\n", - " # Your code here :\n", + " Embedding(input_dim=total_words, output_dim=100, input_length=max_sequence_len - 1),\n", + " Bidirectional(LSTM(150, return_sequences=True)),\n", + " Dropout(0.2),\n", + " LSTM(100),\n", + " Dense(total_words // 2, activation='relu',kernel_regularizer=l2(0.01)),\n", + " Dense(total_words, activation='softmax')\n", " \n", - "])" + "])\n", + "\n" ] }, { @@ -255,7 +365,8 @@ "metadata": {}, "outputs": [], "source": [ - "# Your code here :" + "# Compile the model\n", + "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])" ] }, { @@ -271,9 +382,39 @@ "cell_type": "code", "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " embedding (Embedding) (None, 10, 100) 337500 \n", + " \n", + " bidirectional (Bidirection (None, 10, 300) 301200 \n", + " al) \n", + " \n", + " dropout (Dropout) (None, 10, 300) 0 \n", + " \n", + " lstm_1 (LSTM) (None, 100) 160400 \n", + " \n", + " dense (Dense) (None, 1687) 170387 \n", + " \n", + " dense_1 (Dense) (None, 3375) 5697000 \n", + " \n", + "=================================================================\n", + "Total params: 6666487 (25.43 MB)\n", + "Trainable params: 6666487 (25.43 MB)\n", + "Non-trainable params: 0 (0.00 Byte)\n", + "_________________________________________________________________\n" + ] + } + ], "source": [ - "# Your code here :" + "# Model summary\n", + "model.summary()" ] }, { @@ -298,9 +439,134 @@ "id": "AIg2f1HBxqof", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-04 14:10:14.323422: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8907\n", + "2024-10-04 14:10:16.390016: I external/local_xla/xla/service/service.cc:168] XLA service 0x7fb33bcdf9a0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "2024-10-04 14:10:16.390093: I external/local_xla/xla/service/service.cc:176] StreamExecutor device (0): Quadro P4000, Compute Capability 6.1\n", + "2024-10-04 14:10:16.430959: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1728051016.679395 91 device_compiler.h:186] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "484/484 [==============================] - 33s 39ms/step - loss: 6.9146 - accuracy: 0.0209\n", + "Epoch 2/50\n", + "484/484 [==============================] - 10s 20ms/step - loss: 6.5099 - accuracy: 0.0218\n", + "Epoch 3/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 6.3973 - accuracy: 0.0262\n", + "Epoch 4/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 6.2693 - accuracy: 0.0292\n", + "Epoch 5/50\n", + "484/484 [==============================] - 10s 20ms/step - loss: 6.1762 - accuracy: 0.0367\n", + "Epoch 6/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 6.0958 - accuracy: 0.0398\n", + "Epoch 7/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 6.0171 - accuracy: 0.0428\n", + "Epoch 8/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 5.9385 - accuracy: 0.0471\n", + "Epoch 9/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 5.8362 - accuracy: 0.0526\n", + "Epoch 10/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 5.7283 - accuracy: 0.0578\n", + "Epoch 11/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 5.6255 - accuracy: 0.0639\n", + "Epoch 12/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 5.5245 - accuracy: 0.0697\n", + "Epoch 13/50\n", + "484/484 [==============================] - 10s 20ms/step - loss: 5.4292 - accuracy: 0.0761\n", + "Epoch 14/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 5.3270 - accuracy: 0.0829\n", + "Epoch 15/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 5.2252 - accuracy: 0.0863\n", + "Epoch 16/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 5.1232 - accuracy: 0.0963\n", + "Epoch 17/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 5.0184 - accuracy: 0.1020\n", + "Epoch 18/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 4.9104 - accuracy: 0.1091\n", + "Epoch 19/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 4.8009 - accuracy: 0.1176\n", + "Epoch 20/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 4.6926 - accuracy: 0.1298\n", + "Epoch 21/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 4.5851 - accuracy: 0.1376\n", + "Epoch 22/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 4.4723 - accuracy: 0.1455\n", + "Epoch 23/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 4.3671 - accuracy: 0.1600\n", + "Epoch 24/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 4.2535 - accuracy: 0.1755\n", + "Epoch 25/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 4.1481 - accuracy: 0.1841\n", + "Epoch 26/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 4.0450 - accuracy: 0.2017\n", + "Epoch 27/50\n", + "484/484 [==============================] - 10s 20ms/step - loss: 3.9365 - accuracy: 0.2182\n", + "Epoch 28/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 3.8403 - accuracy: 0.2338\n", + "Epoch 29/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 3.7413 - accuracy: 0.2566\n", + "Epoch 30/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 3.6240 - accuracy: 0.2780\n", + "Epoch 31/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 3.5404 - accuracy: 0.2984\n", + "Epoch 32/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 3.4414 - accuracy: 0.3145\n", + "Epoch 33/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 3.3540 - accuracy: 0.3356\n", + "Epoch 34/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 3.2635 - accuracy: 0.3550\n", + "Epoch 35/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 3.1895 - accuracy: 0.3714\n", + "Epoch 36/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 3.1055 - accuracy: 0.3910\n", + "Epoch 37/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 3.0244 - accuracy: 0.4113\n", + "Epoch 38/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 2.9481 - accuracy: 0.4241\n", + "Epoch 39/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 2.8786 - accuracy: 0.4451\n", + "Epoch 40/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 2.8132 - accuracy: 0.4585\n", + "Epoch 41/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 2.7431 - accuracy: 0.4718\n", + "Epoch 42/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 2.6716 - accuracy: 0.4870\n", + "Epoch 43/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 2.6217 - accuracy: 0.5039\n", + "Epoch 44/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 2.5569 - accuracy: 0.5176\n", + "Epoch 45/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 2.4953 - accuracy: 0.5261\n", + "Epoch 46/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 2.4450 - accuracy: 0.5412\n", + "Epoch 47/50\n", + "484/484 [==============================] - 9s 19ms/step - loss: 2.3908 - accuracy: 0.5552\n", + "Epoch 48/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 2.3279 - accuracy: 0.5651\n", + "Epoch 49/50\n", + "484/484 [==============================] - 8s 17ms/step - loss: 2.2914 - accuracy: 0.5718\n", + "Epoch 50/50\n", + "484/484 [==============================] - 9s 18ms/step - loss: 2.2432 - accuracy: 0.5834\n" + ] + } + ], "source": [ - "# Your code here :" + "history = model.fit(predictors, labels, epochs=50, verbose=1)\n" ] }, { @@ -324,9 +590,47 @@ "id": "1fXTEO3GJ282", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Your code here :" + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot training accuracy and loss over epochs\n", + "\n", + "# Get the accuracy and loss from the history object\n", + "accuracy = history.history['accuracy']\n", + "loss = history.history['loss']\n", + "epochs = range(1, len(accuracy) + 1)\n", + "\n", + "# Plot Accuracy\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(epochs, accuracy, 'b', label='Training accuracy')\n", + "plt.title('Training Accuracy over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "\n", + "# Plot Loss\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(epochs, loss, 'r', label='Training loss')\n", + "plt.title('Training Loss over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.show()\n" ] }, { @@ -347,9 +651,43 @@ "cell_type": "code", "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Write the text you want the model to use as a starting point leaves ' acquainted dyed acquainted free gone should live young\n" + ] + } + ], "source": [ - "# Your code here :" + "def generate_text(model, tokenizer, seed_text, next_words, max_sequence_len):\n", + " for _ in range(next_words):\n", + " # Convert seed_text to a sequence of tokens\n", + " token_list = tokenizer.texts_to_sequences([seed_text])[0]\n", + " # Pad the sequence to match the input length expected by the model\n", + " token_list = pad_sequences([token_list], maxlen=max_sequence_len - 1, padding='pre')\n", + " # Predict the next word\n", + " predicted = model.predict(token_list, verbose=0)\n", + " # Get the index of the word with the highest probability\n", + " predicted_word_index = predicted.argmax(axis=-1)\n", + " # Convert the index back to a word using the tokenizer\n", + " output_word = \"\"\n", + " for word, index in tokenizer.word_index.items():\n", + " if index == predicted_word_index:\n", + " output_word = word\n", + " break\n", + " # Append the predicted word to the seed text\n", + " seed_text += \" \" + output_word\n", + " return seed_text\n", + "\n", + "# Variables\n", + "seed_text = \"Write the text you want the model to use as a starting point\"\n", + "next_words = 10 # Replace this with the number of words you want to generate\n", + "\n", + "# Generate and print the text\n", + "generated_text = generate_text(model, tokenizer, seed_text, next_words, max_sequence_len)\n", + "print(generated_text)\n" ] }, { @@ -370,9 +708,40 @@ "id": "6Vc6PHgxa6Hm", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is the beginning of something where thy praise old part write write good thine best have eye alone seem so due was true such art\n" + ] + } + ], "source": [ - "# Your code here :" + "# Create a loop based on next_words and generate new text\n", + "seed_text = \"This is the beginning of something\"\n", + "next_words = 20 # Example: Generate 20 words\n", + "\n", + "for _ in range(next_words):\n", + " # Convert seed_text to a sequence of tokens\n", + " token_list = tokenizer.texts_to_sequences([seed_text])[0]\n", + " # Pad the sequence to match the input length expected by the model\n", + " token_list = pad_sequences([token_list], maxlen=max_sequence_len - 1, padding='pre')\n", + " # Predict the next word\n", + " predicted = model.predict(token_list, verbose=0)\n", + " # Get the index of the word with the highest probability\n", + " predicted_word_index = predicted.argmax(axis=-1)\n", + " # Convert the index back to a word using the tokenizer\n", + " output_word = \"\"\n", + " for word, index in tokenizer.word_index.items():\n", + " if index == predicted_word_index:\n", + " output_word = word\n", + " break\n", + " # Append the predicted word to the seed text\n", + " seed_text += \" \" + output_word\n", + "\n", + "# Print the full generated text\n", + "print(seed_text)\n" ] }, { @@ -386,9 +755,53 @@ "cell_type": "code", "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seed text: The sun rises\n", + "Generated text: The sun rises as happier but to not untrue give sort sort done\n", + "\n", + "Seed text: Once upon a time\n", + "Generated text: Once upon a time above that dead worthless wife defaced sang sang pluck make\n", + "\n", + "Seed text: In the middle of the night\n", + "Generated text: In the middle of the night hand smell wide wide hand wide wide leaves bell compare\n", + "\n" + ] + } + ], "source": [ - "# Your code here :" + "# Function to generate text with different seed texts\n", + "def generate_text(model, tokenizer, seed_text, next_words, max_sequence_len):\n", + " for _ in range(next_words):\n", + " token_list = tokenizer.texts_to_sequences([seed_text])[0]\n", + " token_list = pad_sequences([token_list], maxlen=max_sequence_len - 1, padding='pre')\n", + " predicted = model.predict(token_list, verbose=0)\n", + " predicted_word_index = predicted.argmax(axis=-1)\n", + " output_word = \"\"\n", + " for word, index in tokenizer.word_index.items():\n", + " if index == predicted_word_index:\n", + " output_word = word\n", + " break\n", + " seed_text += \" \" + output_word\n", + " return seed_text\n", + "\n", + "# Experimenting with different seed texts\n", + "seed_texts = [\n", + " \"The sun rises\",\n", + " \"Once upon a time\",\n", + " \"In the middle of the night\"\n", + "]\n", + "\n", + "next_words = 10 # Generate 10 words for each seed text\n", + "\n", + "# Loop through each seed text and generate text\n", + "for seed in seed_texts:\n", + " print(f\"Seed text: {seed}\")\n", + " generated_text = generate_text(model, tokenizer, seed, next_words, max_sequence_len)\n", + " print(f\"Generated text: {generated_text}\\n\")\n" ] } ], @@ -414,7 +827,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" } }, "nbformat": 4,