fcc_sms_text_classification.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!wget -N https://cdn.freecodecamp.org/project-data/sms/train-data.tsv\n",
        "!wget -N https://cdn.freecodecamp.org/project-data/sms/valid-data.tsv\n",
        "!pip install tensorflow-datasets\n",
        "!pip install tensorflow keras"
      ],
      "metadata": {
        "id": "StOs5lw8Hqfd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import pandas as pd\n",
        "from tensorflow import keras\n",
        "import tensorflow_datasets as tfds\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.layers import TextVectorization\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.preprocessing import sequence\n",
        "tfds.disable_progress_bar()"
      ],
      "metadata": {
        "id": "bfOQL-EQF6mW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lMHwYXHXCar3"
      },
      "outputs": [],
      "source": [
        "train_file_path = \"train-data.tsv\"\n",
        "test_file_path = \"valid-data.tsv\"\n",
        "\n",
        "train_df = pd.read_csv(test_file_path, sep=\"\\t\", header=None, names=[\"type\", \"msg\"])\n",
        "train_df.dropna()\n",
        "train_df.head()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_df = pd.read_csv(test_file_path, sep=\"\\t\", header=None, names=[\"type\", \"msg\"])\n",
        "test_df.dropna()\n",
        "train_df.head()"
      ],
      "metadata": {
        "id": "B2B1mAVNExGS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_df[\"type\"] = pd.factorize(train_df[\"type\"])[0]\n",
        "test_df[\"type\"] = pd.factorize(test_df[\"type\"])[0]\n",
        "train_df.head()"
      ],
      "metadata": {
        "id": "9cYqZwxmEylJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_labels =  train_df[\"type\"].values\n",
        "train_ds = tf.data.Dataset.from_tensor_slices(\n",
        "    (train_df[\"msg\"].values, train_labels)\n",
        ")\n",
        "test_labels =  test_df[\"type\"].values\n",
        "test_ds = tf.data.Dataset.from_tensor_slices(\n",
        "    (test_df[\"msg\"].values, test_labels)\n",
        ")\n",
        "test_ds.element_spec"
      ],
      "metadata": {
        "id": "lL0QYswtE0Pa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zOMKywn4zReN"
      },
      "outputs": [],
      "source": [
        "BUFFER_SIZE = 100\n",
        "BATCH_SIZE = 32\n",
        "train_ds = train_ds.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)\n",
        "test_ds = test_ds.batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vec = TextVectorization(\n",
        "    output_mode='int',\n",
        "    max_tokens=1000,\n",
        "    output_sequence_length=1000,\n",
        ")\n",
        "\n",
        "vec.adapt(train_ds.map(lambda text, label: text))"
      ],
      "metadata": {
        "id": "aBSW2qagE3iw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vocab = np.array(vec.get_vocabulary())\n",
        "vocab[:20]"
      ],
      "metadata": {
        "id": "e-4rlEM8E5hC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.Sequential([\n",
        "    vec,\n",
        "    tf.keras.layers.Embedding(\n",
        "        len(vec.get_vocabulary()),\n",
        "        64,\n",
        "        mask_zero=True,\n",
        "    ),\n",
        "    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64,  return_sequences=True)),\n",
        "    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),\n",
        "    tf.keras.layers.Dense(64, activation='relu'),\n",
        "    tf.keras.layers.Dropout(0.3),\n",
        "    tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "\n",
        "model.compile(\n",
        "    loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
        "    optimizer=tf.keras.optimizers.Adam(1e-4),\n",
        "    metrics=['accuracy'],\n",
        ")"
      ],
      "metadata": {
        "id": "vPglZ9jXE7AX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(\n",
        "    train_ds,\n",
        "    validation_data=test_ds,\n",
        "    validation_steps=30,\n",
        "    epochs=10,\n",
        ")"
      ],
      "metadata": {
        "id": "k4ctSGSKE8_Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_loss, test_acc = model.evaluate(test_ds)\n",
        "print('Test Loss:', test_loss)\n",
        "print('Test Accuracy:', test_acc)"
      ],
      "metadata": {
        "id": "tSe_pUUjE-hO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plot the accuracy and loss metrics\n",
        "Create a helper function to plot"
      ],
      "metadata": {
        "id": "Y7aQUJ2LFCbp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_graphs(h, metric):\n",
        "    plt.plot(h.history[metric])\n",
        "    plt.plot(h.history['val_'+metric])\n",
        "    plt.xlabel(\"Epochs\")\n",
        "    plt.ylabel(metric)\n",
        "    plt.legend([metric, 'val_'+metric])"
      ],
      "metadata": {
        "id": "HVV9_GKkFAu_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plot the graphs"
      ],
      "metadata": {
        "id": "BXv97BpQFFS-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(16, 8))\n",
        "plt.subplot(1, 2, 1)\n",
        "plot_graphs(history, 'accuracy')\n",
        "plt.ylim(None, 1)\n",
        "plt.subplot(1, 2, 2)\n",
        "plot_graphs(history, 'loss')\n",
        "plt.ylim(0, None)"
      ],
      "metadata": {
        "id": "ZwMv3WjUFHMY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "h = history.history\n",
        "print(h['loss'])\n",
        "print(h['val_loss'])\n",
        "print(h['accuracy'])\n",
        "print(h['val_accuracy'])"
      ],
      "metadata": {
        "id": "yUVIGs0wFJ8D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# function to predict messages based on model\n",
        "# (should return list containing prediction and label, ex. [0.008318834938108921, 'ham'])\n",
        "def predict_message(pred_text):\n",
        "    ps = model.predict([pred_text])\n",
        "    print(ps)\n",
        "    p = ps[0][0]\n",
        "    return [p, \"ham\" if p <0.5 else \"spam\"]\n",
        "\n",
        "pred_text = \"how are you doing today?\"\n",
        "\n",
        "prediction = predict_message(pred_text)\n",
        "print(prediction)"
      ],
      "metadata": {
        "id": "GfAXenXjM_cc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dxotov85SjsC"
      },
      "outputs": [],
      "source": [
        "# Run this cell to test your function and model. Do not modify contents.\n",
        "def test_predictions():\n",
        "  test_messages = [\"how are you doing today\",\n",
        "                   \"sale today! to stop texts call 98912460 4\",\n",
        "                   \"i dont want to go. can we try it a different day? available sat\",\n",
        "                   \"our new mobile video service is live. just install on your phone to start watching.\",\n",
        "                   \"you have won £1000 cash! call to claim your prize.\",\n",
        "                   \"i'll bring it tomorrow. don't forget the milk.\",\n",
        "                   \"wow, is your arm alright. that happened to me one time too\"\n",
        "                  ]\n",
        "\n",
        "  test_answers = [\"ham\", \"spam\", \"ham\", \"spam\", \"spam\", \"ham\", \"ham\"]\n",
        "  passed = True\n",
        "\n",
        "  for msg, ans in zip(test_messages, test_answers):\n",
        "    prediction = predict_message(msg)\n",
        "    if prediction[1] != ans:\n",
        "      passed = False\n",
        "\n",
        "  if passed:\n",
        "    print(\"You passed the challenge. Great job!\")\n",
        "  else:\n",
        "    print(\"You haven't passed yet. Keep trying.\")\n",
        "\n",
        "test_predictions()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "fcc_sms_text_classification.ipynb",
      "private_outputs": true,
      "provenance": [],
      "toc_visible": true,
      "gpuType": "T4"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {},
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}