2. Text Cleaning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width: 100%; overflow: hidden;\">\n",
    "    <div style=\"width: 150px; float: left;\"> <img src=\"data/D4Sci_logo_ball.png\" alt=\"Data For Science, Inc\" align=\"left\" border=\"0\" width=160px> </div>\n",
    "    <div style=\"float: left; margin-left: 10px;\"> <h1>Natural Language Processing</h1>\n",
    "<h1>Text Cleaning</h1>\n",
    "        <p>Bruno Gonçalves<br/>\n",
    "        <a href=\"http://www.data4sci.com/\">www.data4sci.com</a><br/>\n",
    "            @bgoncalves, @data4sci</p></div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "from pprint import pprint\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "import re\n",
    "\n",
    "import tqdm as tq\n",
    "from tqdm import tqdm\n",
    "\n",
    "import string\n",
    "import nltk\n",
    "\n",
    "import watermark\n",
    "\n",
    "%load_ext watermark\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by print out the versions of the libraries we're using for future reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python implementation: CPython\n",
      "Python version       : 3.8.5\n",
      "IPython version      : 7.19.0\n",
      "\n",
      "Compiler    : Clang 10.0.0 \n",
      "OS          : Darwin\n",
      "Release     : 20.5.0\n",
      "Machine     : x86_64\n",
      "Processor   : i386\n",
      "CPU cores   : 16\n",
      "Architecture: 64bit\n",
      "\n",
      "Git hash: ada0d41c33546e250d7a5ace74624d6ece6f91ef\n",
      "\n",
      "tqdm      : 4.62.0\n",
      "json      : 2.0.9\n",
      "re        : 2.2.1\n",
      "numpy     : 1.19.2\n",
      "matplotlib: 3.3.2\n",
      "nltk      : 3.5\n",
      "pandas    : 1.1.3\n",
      "watermark : 2.1.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%watermark -n -v -m -g -iv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load default figure style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('./d4sci.mplstyle')\n",
    "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stemming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = ['playing', 'loved', 'ran', 'river', 'friendships', \n",
    "         'misunderstanding', 'trouble', 'troubling']\n",
    "\n",
    "stemmers = { \n",
    "    'LancasterStemmer' : nltk.stem.LancasterStemmer(),\n",
    "    'PorterStemmer' : nltk.stem.PorterStemmer(),\n",
    "    'RegexpStemmer' : nltk.stem.RegexpStemmer('ing$|s$|e$|able$'),\n",
    "    'SnowballStemmer' : nltk.stem.SnowballStemmer('english')\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = []\n",
    "\n",
    "for word in words:\n",
    "    row = []\n",
    "    for stemmer in stemmers:\n",
    "        stem = stemmers[stemmer]\n",
    "        row.append(stem.stem(word))\n",
    "        \n",
    "    matrix.append(row)\n",
    "\n",
    "comparison = pd.DataFrame(matrix, index=words, columns=stemmers.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>LancasterStemmer</th>\n",
       "      <th>PorterStemmer</th>\n",
       "      <th>RegexpStemmer</th>\n",
       "      <th>SnowballStemmer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>playing</th>\n",
       "      <td>play</td>\n",
       "      <td>play</td>\n",
       "      <td>play</td>\n",
       "      <td>play</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>loved</th>\n",
       "      <td>lov</td>\n",
       "      <td>love</td>\n",
       "      <td>loved</td>\n",
       "      <td>love</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ran</th>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>river</th>\n",
       "      <td>riv</td>\n",
       "      <td>river</td>\n",
       "      <td>river</td>\n",
       "      <td>river</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>friendships</th>\n",
       "      <td>friend</td>\n",
       "      <td>friendship</td>\n",
       "      <td>friendship</td>\n",
       "      <td>friendship</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>misunderstanding</th>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstand</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>trouble</th>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>troubling</th>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 LancasterStemmer  PorterStemmer  RegexpStemmer  \\\n",
       "playing                      play           play           play   \n",
       "loved                         lov           love          loved   \n",
       "ran                           ran            ran            ran   \n",
       "river                         riv          river          river   \n",
       "friendships                friend     friendship     friendship   \n",
       "misunderstanding    misunderstand  misunderstand  misunderstand   \n",
       "trouble                    troubl         troubl         troubl   \n",
       "troubling                  troubl         troubl         troubl   \n",
       "\n",
       "                 SnowballStemmer  \n",
       "playing                     play  \n",
       "loved                       love  \n",
       "ran                          ran  \n",
       "river                      river  \n",
       "friendships           friendship  \n",
       "misunderstanding   misunderstand  \n",
       "trouble                   troubl  \n",
       "troubling                 troubl  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lemmatization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "wordnet = nltk.stem.WordNetLemmatizer()\n",
    "\n",
    "results_n = [wordnet.lemmatize(word, 'n') for word in words]\n",
    "results_v = [wordnet.lemmatize(word, 'v') for word in words]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "comparison['WordNetLemmatizer Noun'] = results_n\n",
    "comparison['WordNetLemmatizer Verb'] = results_v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>LancasterStemmer</th>\n",
       "      <th>PorterStemmer</th>\n",
       "      <th>RegexpStemmer</th>\n",
       "      <th>SnowballStemmer</th>\n",
       "      <th>WordNetLemmatizer Noun</th>\n",
       "      <th>WordNetLemmatizer Verb</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>playing</th>\n",
       "      <td>play</td>\n",
       "      <td>play</td>\n",
       "      <td>play</td>\n",
       "      <td>play</td>\n",
       "      <td>playing</td>\n",
       "      <td>play</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>loved</th>\n",
       "      <td>lov</td>\n",
       "      <td>love</td>\n",
       "      <td>loved</td>\n",
       "      <td>love</td>\n",
       "      <td>loved</td>\n",
       "      <td>love</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ran</th>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "      <td>ran</td>\n",
       "      <td>run</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>river</th>\n",
       "      <td>riv</td>\n",
       "      <td>river</td>\n",
       "      <td>river</td>\n",
       "      <td>river</td>\n",
       "      <td>river</td>\n",
       "      <td>river</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>friendships</th>\n",
       "      <td>friend</td>\n",
       "      <td>friendship</td>\n",
       "      <td>friendship</td>\n",
       "      <td>friendship</td>\n",
       "      <td>friendship</td>\n",
       "      <td>friendships</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>misunderstanding</th>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstand</td>\n",
       "      <td>misunderstanding</td>\n",
       "      <td>misunderstand</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>trouble</th>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>trouble</td>\n",
       "      <td>trouble</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>troubling</th>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubl</td>\n",
       "      <td>troubling</td>\n",
       "      <td>trouble</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 LancasterStemmer  PorterStemmer  RegexpStemmer  \\\n",
       "playing                      play           play           play   \n",
       "loved                         lov           love          loved   \n",
       "ran                           ran            ran            ran   \n",
       "river                         riv          river          river   \n",
       "friendships                friend     friendship     friendship   \n",
       "misunderstanding    misunderstand  misunderstand  misunderstand   \n",
       "trouble                    troubl         troubl         troubl   \n",
       "troubling                  troubl         troubl         troubl   \n",
       "\n",
       "                 SnowballStemmer WordNetLemmatizer Noun WordNetLemmatizer Verb  \n",
       "playing                     play                playing                   play  \n",
       "loved                       love                  loved                   love  \n",
       "ran                          ran                    ran                    run  \n",
       "river                      river                  river                  river  \n",
       "friendships           friendship             friendship            friendships  \n",
       "misunderstanding   misunderstand       misunderstanding          misunderstand  \n",
       "trouble                   troubl                trouble                trouble  \n",
       "troubling                 troubl              troubling                trouble  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regular Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step is to compile the pattern we're interested in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "regex = re.compile(r'\\d+')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"The Earth is estimated to be 4.54 billion years old, plus or minus about 50 million years.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Match tries to look for values at the start of the string and fails to find any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "res = regex.match(sentence)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Search will scan the sentence until the first match is found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(29, 30), match='4'>\n"
     ]
    }
   ],
   "source": [
    "res = regex.search(sentence)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily extract information from the resulting match object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(29, 30)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.span()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The match was found in position 29 and ended before position 30. Now we can slice the original string using __start()__ and __end()__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence[res.start():res.end()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find all will return all matching substrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "res_lst = regex.findall(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We found 3 results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(res_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That are returned as a list of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 4\n",
      "1 54\n",
      "2 50\n"
     ]
    }
   ],
   "source": [
    "for i, res in enumerate(res_lst):\n",
    "    print(i, res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll note that our regex matched only decimal digits, so the value 4.54 got split in two as '.' didn't match. If we want to return floating point values we must use instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "regex = re.compile(r'\\d+\\.?\\d+')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Where we are now allowing for an optional . surrounded by decimals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<re.Match object; span=(29, 33), match='4.54'>,\n",
       " <re.Match object; span=(73, 75), match='50'>]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[match for match in regex.finditer(sentence)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can refer to the match in a previous group by it's number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the the'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex = re.compile(r'\\b(\\w+)\\s+\\1\\b')\n",
    "regex.search('Paris in the the spring').group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll note that this different from just duplicating the pattern as then the result might be different :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Paris', 'in'), ('the', 'the')]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex = re.compile(r'\\b(\\w+)\\s+(\\w+)\\b')\n",
    "regex.findall('Paris in the the spring')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since here we're allowing any word to follow any word and not just a repetition. Also, regex matches are non-overlapping so we can't match spring unless there was another word following it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Paris', 'in'), ('the', 'the'), ('spring', 'weather')]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex = re.compile(r'\\b(\\w+)\\s+(\\w+)\\b')\n",
    "regex.findall('Paris in the the spring weather')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use __.sub()__ to replace any matches with a pre-defined string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'colour socks and colour shoes'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex = re.compile('(blue|white|red)')\n",
    "regex.sub('colour', 'blue socks and red shoes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The count argument specifies how many replacments we allow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'colour socks and red shoes'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex.sub('colour', 'blue socks and red shoes', count=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly, within the replacement string we can also refer to the match results with group numbers, so if we just want to add quotation marks to our matches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\"blue\" socks and \"red\" shoes'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regex.sub(r'\"\\1\"', 'blue socks and red shoes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width: 100%; overflow: hidden;\">\n",
    "     <img src=\"data/D4Sci_logo_full.png\" alt=\"Data For Science, Inc\" align=\"center\" border=\"0\" width=300px> \n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}