Ch_2_Your_First_NLP_Example.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNE+BfWvnLQfCHlRE6NIVPz"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Notes from Ch. 2 Your first NLP example, Getting Started with Natural Language Processing \n",
        "## by Ekaterina Kochmar (2022)\n",
        "### https://livebook.manning.com/book/getting-started-with-natural-language-processing/chapter-2/v-10/"
      ],
      "metadata": {
        "id": "6NH1UO60aSFD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2.1 Introducing NLP in practice: spam filtering"
      ],
      "metadata": {
        "id": "g9HAsCiAa-K0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classification\n",
        "**Classification** refers to the process of identifying which category or class among the set of categories (classes) an observation belongs to based on its properties. In machine learning terms, such properties are called features and the class names are called class labels. If you classify observations into two classes, you are dealing with binary classification; tasks with more than two classes are examples of multi-class classification.\n",
        "\n",
        "**binary classifications** allows us to organize items into to groups (e.g., motorized vs not) </br> \n",
        "**multi-class catagorization**: two-wheeled unmotorized vehicles, two-wheeled motorized vehicles, three-wheeled unmotorized vehicles, and so on \n"
      ],
      "metadata": {
        "id": "C00TX1OtKHS_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can have computers make classifications. For examples, we can create a function that prints out a warning that water is hot based on a simple threshold of 45&deg;C (113&deg;F). "
      ],
      "metadata": {
        "id": "KZoKnY_WOBlj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def print_warning(temperature):\n",
        "    if temperature>=45:\n",
        "        print (\"Caution: Hot water!\")\n",
        "    else:\n",
        "        print (\"You may use water as usual\")\n",
        "print_warning(46)\n",
        " "
      ],
      "metadata": {
        "id": "Zjf2c7cLa9en",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0be7d59f-76b2-4c3b-c149-ba58d8d6270f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Caution: Hot water!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "However, when there are multiple factors to take into account and these multiple factors may interact in various ways, a better strategy is to make the machine learn such rules and infer their correspondences from the data rather than hard-code them. \n",
        "\n",
        "This type of machine learning approach, when we supervise the machine while it is learning by providing it with the labeled data, is called supervised machine learning. This is what machine learning is about: it states that machines can learn to solve the task if they are provided with a sufficient number of examples and with the general outline of the task. For example, if we define the classes, labels, and features for the machine, it can then learn to assign concepts to the predefined classes based on these features. "
      ],
      "metadata": {
        "id": "naAZseBjTD6B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####SUPERVISED MACHINE LEARNING\n",
        "Supervised machine learning refers to a family of machine learning tasks in which the algorithm learns the correspondences between an input and an output based on the provided labeled input-output examples. Classification is an example of a supervised machine learning task, where the algorithm tries to learn the mapping between the input data and the output class label."
      ],
      "metadata": {
        "id": "RTzv8Hw9TtAF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Understanding the Task \n",
        "\n",
        " Five steps of a machine learning-based text classification project: </br> \n",
        " Define Classes -> Split into Words -> Extract Features -> Train Classifer -> Test and Evaluate "
      ],
      "metadata": {
        "id": "eQnevVfr44nZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Define the Data and Classes \n",
        "Define which data represents “ham” class and which data represents “spam” class for the machine learning algorithm.\n",
        "2.  Split the text into words\n"
      ],
      "metadata": {
        "id": "3uQbFBIo5PnC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Define which data represents each class for the machine learning algorithm\"\n",
        "text.split(\" \")\n",
        "# type(text)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GA88UaCH6cVI",
        "outputId": "a670fb05-739b-4666-ebff-2837bafe6d42"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Define',\n",
              " 'which',\n",
              " 'data',\n",
              " 'represents',\n",
              " 'each',\n",
              " 'class',\n",
              " 'for',\n",
              " 'the',\n",
              " 'machine',\n",
              " 'learning',\n",
              " 'algorithm']"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "So far, so good. However, what happens to this strategy when we have punctuation marks?"
      ],
      "metadata": {
        "id": "nwD83a_U7ORG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "text = 'Define which data represents \"ham\" class and which data represents \"spam\" class for the machine learning algorithm.'\n",
        "delimiters = ['/', \".\"]\n",
        "words = []\n",
        "current_word = \"\"\n",
        " \n",
        "for char in text:\n",
        "    if char==\" \":\n",
        "        if not current_word==\"\":\n",
        "            words.append(current_word)\n",
        "            current_word = \"\"\n",
        "    elif char in delimiters:\n",
        "        if current_word==\"\":\n",
        "            words.append(char)\n",
        "        else:\n",
        "            words.append(current_word)\n",
        "            words.append(char)\n",
        "            current_word = \"\"\n",
        "    else:\n",
        "        current_word += char\n",
        " \n",
        "print(words) \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YeCja4-V7Nro",
        "outputId": "18436023-ed60-4744-8818-16267f5b5d88"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Define', 'which', 'data', 'represents', '\"ham\"', 'class', 'and', 'which', 'data', 'represents', '\"spam\"', 'class', 'for', 'the', 'machine', 'learning', 'algorithm', '.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tokenizer\n",
        "\n",
        "While the above is a helpful exercise, it is more pargmatic to use a tokenizer from NNLPTK: NLP toolkits. These tokenizers are highly optimized for the task, and they not only perform splitting by whitespaces and punctuation marks, but also keep track of the cases that should not be split by such methods. This helps make sure that the tokenization step results in a list of appropriate English words."
      ],
      "metadata": {
        "id": "oJR9UPwmLETM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "**Tokenization** is the process of word token identification or extraction from the running text. It is often the first step in text preprocessing. Whitespaces and punctuation marks often serve as reliable word separators; however, simple approaches are likely to run into exceptions like “U.S.A.” and similar. Tokenizers are NLP tools highly optimized for the task of word tokenization, and they may rely on carefully crafted regular expressions or trained using machine learning algorithms."
      ],
      "metadata": {
        "id": "sGyG8tNULneU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os \n",
        "import codecs \n",
        "\n",
        "def read_in(folder): \n",
        "  files = oslistdir(folder)\n",
        "  a_list = []\n",
        "  for a_file in files:\n",
        "    if not a_file.startswith(\".\"):\n",
        "      f = codecs.open(folder + a_file,\n",
        "                      \"r\", encoding = \"ISO-8859-1\", errors=\"ignore\")\n",
        "      a_list.append(f.read())\n",
        "      f.close()\n",
        "    return a_list\n",
        "\n"
      ],
      "metadata": {
        "id": "wMXY90VI8Qfi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# lists are really large - will update with Anaconda/local instructions (taking too long in Drive/Colabratory)\n",
        "\n",
        "spam_list = read_in(\"enron1/spam/\") \n",
        "ham_list = read_in(\"enron1/ham/\")\n",
        "print(len(spam_list)) \n",
        "print(len(ham_list))\n",
        "print(spam_list[0])\n",
        "print(ham_list[0])\n",
        "\n"
      ],
      "metadata": {
        "id": "XBHHY9qROCEc"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}