Natural Language Processing With TextBlob.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Natural Language Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Natural Language Process == understanding(processing) everyday language.\n",
    "\n",
    "Natural language processing is a form of artificial intelligence that helps computers read and respond by simulating the human ability to understand everyday language.\n",
    "Many organizations use NLP techniques to optimize customer support,improve the efficiency of text analytics by easily finding the information they need, and enhance social media monitoring. \n",
    "For example, banks might implement NLP algorithms to optimize customer support; a large consumer products brand might combine natural language \n",
    "processing and semantic analysis to improve their knowledge management strategies and social media monitoring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Natural Language Processing With TextBlob\n",
    "+ pip install textblob\n",
    "+ + + NLTK\n",
    "+ + + SpaCy\n",
    "+ + + TextBlob\n",
    "+ + + Word2Vec,FastText,GloVe,Doc2Vec\n",
    "+ + + TextAnalysis\n",
    "#### Applications of NLP\n",
    "+ + Text Classification\n",
    "+ + Sentiment Analysis\n",
    "+ + Language Modeling\n",
    "+ + Speech Recognition\n",
    "+ + Caption Generation\n",
    "+ + Machine Translation\n",
    "+ + Document Summarization\n",
    "+ + Question Answering\n",
    "+ + Grammer correction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deriving meaning from our text\n",
    "+ Words,Sentences\n",
    "+ Language\n",
    "+ Part of Speech\n",
    "+ Content and Context\n",
    "+ Meaning of the word/Root word\n",
    "+ Frequency of words and count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tokenization\n",
    "+ Breaking /Dividing text or a sentence into a sequence of tokens, which roughly correspond to “words”. \n",
    "+ Word Tokens\n",
    "+ Sentence Tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install textblob\n",
    "from textblob import TextBlob\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = \"\"\"The best error message is the one that never shows up.\n",
    "You Learn More From Failure Than From Success. \n",
    "Don’t Let It Stop You. Failure Builds Character.\n",
    "If You Are Working On Something That You Really Care About, You Don’t Have To Be Pushed. The Vision Pulls You.\n",
    "The purpose of software engineering is to control complexity, not to create it\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "blob = TextBlob(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "textblob.blob.TextBlob"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(blob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can also use BaseBlob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from textblob.blob import BaseBlob\n",
    "# An abstract base class that all textblob classes will inherit from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_blob = BaseBlob(mystr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "textblob.blob.BaseBlob"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(base_blob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Word Tokenizing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TextBlob(\"The best error message is the one that never shows up.\n",
       "You Learn More From Failure Than From Success. \n",
       "Don’t Let It Stop You. Failure Builds Character.\n",
       "If You Are Working On Something That You Really Care About, You Don’t Have To Be Pushed. The Vision Pulls You.\n",
       "The purpose of software engineering is to control complexity, not to create it\")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "WordList(['The', 'best', 'error', 'message', 'is', 'the', 'one', 'that', 'never', 'shows', 'up', 'You', 'Learn', 'More', 'From', 'Failure', 'Than', 'From', 'Success', 'Don', '’', 't', 'Let', 'It', 'Stop', 'You', 'Failure', 'Builds', 'Character', 'If', 'You', 'Are', 'Working', 'On', 'Something', 'That', 'You', 'Really', 'Care', 'About', 'You', 'Don', '’', 't', 'Have', 'To', 'Be', 'Pushed', 'The', 'Vision', 'Pulls', 'You', 'The', 'purpose', 'of', 'software', 'engineering', 'is', 'to', 'control', 'complexity', 'not', 'to', 'create', 'it'])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blob.words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentence Tokenizing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Sentence(\"The best error message is the one that never shows up.\"),\n",
       " Sentence(\"You Learn More From Failure Than From Success.\"),\n",
       " Sentence(\"Don’t Let It Stop You.\"),\n",
       " Sentence(\"Failure Builds Character.\"),\n",
       " Sentence(\"If You Are Working On Something That You Really Care About, You Don’t Have To Be Pushed.\"),\n",
       " Sentence(\"The Vision Pulls You.\"),\n",
       " Sentence(\"The purpose of software engineering is to control complexity, not to create it\")]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sentence Tokens\n",
    "blob.sentences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'best', 'error', 'message', 'is', 'the', 'one', 'that', 'never', 'shows', 'up']\n",
      "['You', 'Learn', 'More', 'From', 'Failure', 'Than', 'From', 'Success']\n",
      "['Don', '’', 't', 'Let', 'It', 'Stop', 'You']\n",
      "['Failure', 'Builds', 'Character']\n",
      "['If', 'You', 'Are', 'Working', 'On', 'Something', 'That', 'You', 'Really', 'Care', 'About', 'You', 'Don', '’', 't', 'Have', 'To', 'Be', 'Pushed']\n",
      "['The', 'Vision', 'Pulls', 'You']\n",
      "['The', 'purpose', 'of', 'software', 'engineering', 'is', 'to', 'control', 'complexity', 'not', 'to', 'create', 'it']\n"
     ]
    }
   ],
   "source": [
    "# Words tokens\n",
    "for word_tokens in blob.sentences:\n",
    "    print(word_tokens.words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### N-Grams\n",
    "+ Combinations of multiple words\n",
    "+ Useful for creating features during language modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uni-gram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'best']\n",
      "['best', 'error']\n",
      "['error', 'message']\n",
      "['message', 'is']\n",
      "['is', 'the']\n",
      "['the', 'one']\n",
      "['one', 'that']\n",
      "['that', 'never']\n",
      "['never', 'shows']\n",
      "['shows', 'up']\n",
      "['up', 'You']\n",
      "['You', 'Learn']\n",
      "['Learn', 'More']\n",
      "['More', 'From']\n",
      "['From', 'Failure']\n",
      "['Failure', 'Than']\n",
      "['Than', 'From']\n",
      "['From', 'Success']\n",
      "['Success', 'Don']\n",
      "['Don', '’']\n",
      "['’', 't']\n",
      "['t', 'Let']\n",
      "['Let', 'It']\n",
      "['It', 'Stop']\n",
      "['Stop', 'You']\n",
      "['You', 'Failure']\n",
      "['Failure', 'Builds']\n",
      "['Builds', 'Character']\n",
      "['Character', 'If']\n",
      "['If', 'You']\n",
      "['You', 'Are']\n",
      "['Are', 'Working']\n",
      "['Working', 'On']\n",
      "['On', 'Something']\n",
      "['Something', 'That']\n",
      "['That', 'You']\n",
      "['You', 'Really']\n",
      "['Really', 'Care']\n",
      "['Care', 'About']\n",
      "['About', 'You']\n",
      "['You', 'Don']\n",
      "['Don', '’']\n",
      "['’', 't']\n",
      "['t', 'Have']\n",
      "['Have', 'To']\n",
      "['To', 'Be']\n",
      "['Be', 'Pushed']\n",
      "['Pushed', 'The']\n",
      "['The', 'Vision']\n",
      "['Vision', 'Pulls']\n",
      "['Pulls', 'You']\n",
      "['You', 'The']\n",
      "['The', 'purpose']\n",
      "['purpose', 'of']\n",
      "['of', 'software']\n",
      "['software', 'engineering']\n",
      "['engineering', 'is']\n",
      "['is', 'to']\n",
      "['to', 'control']\n",
      "['control', 'complexity']\n",
      "['complexity', 'not']\n",
      "['not', 'to']\n",
      "['to', 'create']\n",
      "['create', 'it']\n"
     ]
    }
   ],
   "source": [
    "# Bi-Gram\n",
    "for bigram in blob.ngrams(2):\n",
    "    print(bigram)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'best', 'error']\n",
      "['best', 'error', 'message']\n",
      "['error', 'message', 'is']\n",
      "['message', 'is', 'the']\n",
      "['is', 'the', 'one']\n",
      "['the', 'one', 'that']\n",
      "['one', 'that', 'never']\n",
      "['that', 'never', 'shows']\n",
      "['never', 'shows', 'up']\n",
      "['shows', 'up', 'You']\n",
      "['up', 'You', 'Learn']\n",
      "['You', 'Learn', 'More']\n",
      "['Learn', 'More', 'From']\n",
      "['More', 'From', 'Failure']\n",
      "['From', 'Failure', 'Than']\n",
      "['Failure', 'Than', 'From']\n",
      "['Than', 'From', 'Success']\n",
      "['From', 'Success', 'Don']\n",
      "['Success', 'Don', '’']\n",
      "['Don', '’', 't']\n",
      "['’', 't', 'Let']\n",
      "['t', 'Let', 'It']\n",
      "['Let', 'It', 'Stop']\n",
      "['It', 'Stop', 'You']\n",
      "['Stop', 'You', 'Failure']\n",
      "['You', 'Failure', 'Builds']\n",
      "['Failure', 'Builds', 'Character']\n",
      "['Builds', 'Character', 'If']\n",
      "['Character', 'If', 'You']\n",
      "['If', 'You', 'Are']\n",
      "['You', 'Are', 'Working']\n",
      "['Are', 'Working', 'On']\n",
      "['Working', 'On', 'Something']\n",
      "['On', 'Something', 'That']\n",
      "['Something', 'That', 'You']\n",
      "['That', 'You', 'Really']\n",
      "['You', 'Really', 'Care']\n",
      "['Really', 'Care', 'About']\n",
      "['Care', 'About', 'You']\n",
      "['About', 'You', 'Don']\n",
      "['You', 'Don', '’']\n",
      "['Don', '’', 't']\n",
      "['’', 't', 'Have']\n",
      "['t', 'Have', 'To']\n",
      "['Have', 'To', 'Be']\n",
      "['To', 'Be', 'Pushed']\n",
      "['Be', 'Pushed', 'The']\n",
      "['Pushed', 'The', 'Vision']\n",
      "['The', 'Vision', 'Pulls']\n",
      "['Vision', 'Pulls', 'You']\n",
      "['Pulls', 'You', 'The']\n",
      "['You', 'The', 'purpose']\n",
      "['The', 'purpose', 'of']\n",
      "['purpose', 'of', 'software']\n",
      "['of', 'software', 'engineering']\n",
      "['software', 'engineering', 'is']\n",
      "['engineering', 'is', 'to']\n",
      "['is', 'to', 'control']\n",
      "['to', 'control', 'complexity']\n",
      "['control', 'complexity', 'not']\n",
      "['complexity', 'not', 'to']\n",
      "['not', 'to', 'create']\n",
      "['to', 'create', 'it']\n"
     ]
    }
   ],
   "source": [
    "# Tri-Gram\n",
    "for trigram in blob.ngrams(3):\n",
    "    print(trigram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What language is it?\n",
    "+ detect_language()\n",
    "+ translate(to='en')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "myword = TextBlob(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'en'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myword.detect_language()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "myword2 = TextBlob(\"Привет\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ru'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myword2.detect_language()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TextBlob(\"Bonjour\")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Translation to French\n",
    "myword.translate(to='fr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TextBlob(\"Hola\")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Translation to Espanol/Spanish\n",
    "myword.translate(to='es')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "newtext = \"The Quick brown fox jumped over the lazy grey dogs.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng = TextBlob(newtext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Translate to French/English"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TextBlob(\"Le renard brun rapide a sauté par-dessus les chiens gris paresseux.\")"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eng.translate(to='fr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newfrench_text = \"Le renard brun rapide a sauté sur les chiens gris paresseux.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part of Speech\n",
    "+ tags\n",
    "+ pos_tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The best error message is the one that never shows up.\\nYou Learn More From Failure Than From Success. \\nDon’t Let It Stop You. Failure Builds Character.\\nIf You Are Working On Something That You Really Care About, You Don’t Have To Be Pushed. The Vision Pulls You.\\nThe purpose of software engineering is to control complexity, not to create it'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mystr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#blob = TextBlob(mystr)\n",
    "blob1 = TextBlob(\"Hello world this is NLP with TextBlob for text classification.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Hello', 'NNP'),\n",
       " ('world', 'NN'),\n",
       " ('this', 'DT'),\n",
       " ('is', 'VBZ'),\n",
       " ('NLP', 'NNP'),\n",
       " ('with', 'IN'),\n",
       " ('TextBlob', 'NNP'),\n",
       " ('for', 'IN'),\n",
       " ('text', 'JJ'),\n",
       " ('classification', 'NN')]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blob1.tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Hello', 'NNP'),\n",
       " ('world', 'NN'),\n",
       " ('this', 'DT'),\n",
       " ('is', 'VBZ'),\n",
       " ('NLP', 'NNP'),\n",
       " ('with', 'IN'),\n",
       " ('TextBlob', 'NNP'),\n",
       " ('for', 'IN'),\n",
       " ('text', 'JJ'),\n",
       " ('classification', 'NN')]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Alternative Part of Speech\n",
    "blob1.pos_tags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Noun_Phrases\n",
    "+ Helps us to know who or what"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "blob2 = TextBlob(\"Google is great search engine for finding almost anything \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "google\n",
      "great search engine\n"
     ]
    }
   ],
   "source": [
    "for np in blob2.noun_phrases:\n",
    "    print(np)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise How do we find verbs\n",
    "+ To know how or actions done\n",
    "+ Parts of speech\n",
    "+ Tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TextBlob(\"The best error message is the one that never shows up.\n",
       "You Learn More From Failure Than From Success. \n",
       "Don’t Let It Stop You. Failure Builds Character.\n",
       "If You Are Working On Something That You Really Care About, You Don’t Have To Be Pushed. The Vision Pulls You.\n",
       "The purpose of software engineering is to control complexity, not to create it\")"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Quick Method\n",
    "blob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The', 'DT'),\n",
       " ('best', 'JJS'),\n",
       " ('error', 'NN'),\n",
       " ('message', 'NN'),\n",
       " ('is', 'VBZ'),\n",
       " ('the', 'DT'),\n",
       " ('one', 'NN'),\n",
       " ('that', 'WDT'),\n",
       " ('never', 'RB'),\n",
       " ('shows', 'VBZ'),\n",
       " ('up', 'RP'),\n",
       " ('You', 'PRP'),\n",
       " ('Learn', 'VBP'),\n",
       " ('More', 'JJR'),\n",
       " ('From', 'IN'),\n",
       " ('Failure', 'NN'),\n",
       " ('Than', 'CD'),\n",
       " ('From', 'IN'),\n",
       " ('Success', 'NNP'),\n",
       " ('Don', 'NNP'),\n",
       " ('’', 'NNP'),\n",
       " ('t', 'VBZ'),\n",
       " ('Let', 'VB'),\n",
       " ('It', 'PRP'),\n",
       " ('Stop', 'NNP'),\n",
       " ('You', 'PRP'),\n",
       " ('Failure', 'NN'),\n",
       " ('Builds', 'NNP'),\n",
       " ('Character', 'NNP'),\n",
       " ('If', 'IN'),\n",
       " ('You', 'PRP'),\n",
       " ('Are', 'VBP'),\n",
       " ('Working', 'VBG'),\n",
       " ('On', 'IN'),\n",
       " ('Something', 'VBG'),\n",
       " ('That', 'IN'),\n",
       " ('You', 'PRP'),\n",
       " ('Really', 'RB'),\n",
       " ('Care', 'VB'),\n",
       " ('About', 'IN'),\n",
       " ('You', 'PRP'),\n",
       " ('Don', 'VBP'),\n",
       " ('’', 'JJ'),\n",
       " ('t', 'NNS'),\n",
       " ('Have', 'VBP'),\n",
       " ('To', 'TO'),\n",
       " ('Be', 'VB'),\n",
       " ('Pushed', 'VBN'),\n",
       " ('The', 'DT'),\n",
       " ('Vision', 'NNP'),\n",
       " ('Pulls', 'NNP'),\n",
       " ('You', 'PRP'),\n",
       " ('The', 'DT'),\n",
       " ('purpose', 'NN'),\n",
       " ('of', 'IN'),\n",
       " ('software', 'NN'),\n",
       " ('engineering', 'NN'),\n",
       " ('is', 'VBZ'),\n",
       " ('to', 'TO'),\n",
       " ('control', 'VB'),\n",
       " ('complexity', 'NN'),\n",
       " ('not', 'RB'),\n",
       " ('to', 'TO'),\n",
       " ('create', 'VB'),\n",
       " ('it', 'PRP')]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blob.tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is => VBZ\n",
      "shows => VBZ\n",
      "Learn => VBP\n",
      "t => VBZ\n",
      "Let => VB\n",
      "Are => VBP\n",
      "Working => VBG\n",
      "Something => VBG\n",
      "Care => VB\n",
      "Don => VBP\n",
      "Have => VBP\n",
      "Be => VB\n",
      "Pushed => VBN\n",
      "is => VBZ\n",
      "control => VB\n",
      "create => VB\n"
     ]
    }
   ],
   "source": [
    "# ['VB','VBZ','VBP','VBD','VBN','VBG']\n",
    "for word,verb in blob.tags:\n",
    "    if verb in ['VB','VBZ','VBP','VBD','VBN','VBG']:\n",
    "        print(f'{word} => {verb}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Word Inflection == Word Formation by adding to the base/root of word\n",
    "+ Pluralizing or singularizing\n",
    "+ Lemmatization (morphological/ethymological)\n",
    "+ Stemming (Cutting off prefixes or suffixes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytree = [\"study\",\"studying\",\"student\",\"studies\",\"studious\"]\n",
    "myblog = [\"blog\",\"blogging\",\"logging\",\"blogger\",\"logs\",\"vlogs\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Java is to JavaScript as ham is to hamster\n",
    "from textblob import TextBlob,Word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pluralize \n",
    "s = Word('book')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'books'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.pluralize()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Singularize\n",
    "p = Word('pens')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pen'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.singularize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lemmatization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex = Word('running')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'run'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex.lemmatize('v')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex2 = Word('finding')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'find'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex2.lemmatize('v')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['study', 'studying', 'student', 'studies', 'studious']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "study => study\n",
      "studying => study\n",
      "student => student\n",
      "studies => study\n",
      "studious => studious\n"
     ]
    }
   ],
   "source": [
    "# Lemmatizing a list of words based on noun\n",
    "for i in mytree:\n",
    "    result = Word(i).lemmatize('n')\n",
    "    print(f'{i} => {result}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blog => blog\n",
      "blogging => blogging\n",
      "logging => log\n",
      "blogger => blogger\n",
      "logs => log\n",
      "vlogs => vlogs\n"
     ]
    }
   ],
   "source": [
    "# Lemmatizing a list of words based on verb\n",
    "for i in myblog:\n",
    "    result = Word(i).lemmatize('v')\n",
    "    print(f'{i} => {result}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sentiment Analysis With TextBlob\n",
    "+ Opinion Minining or Emotion AI\n",
    "+ Categorizing opinions and attitude expressed in a piece of text(positive, negative, or neutral)\n",
    "+ Determining the attitude of a speaker or a writer with respect to some topic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfeelings = [\"I love my phone but would not recommend it to any of my colleagues\",\n",
    "              \"I love this watch\",\n",
    "              \"This is an amazing library\",\n",
    "              \"I do not like this restaurant\",\n",
    "              \"Wow what a great tip.\",\n",
    "             \"a surprisingly interesting movie\",\n",
    "              \"hard to resist\",\n",
    "              \"one lousy film\",\n",
    "              \"this is too long\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from textblob import TextBlob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Uses PatternAnalyzer(Default) or NaiveBayesAnalyzer\n",
    "# How To Use the NaiveBayesAnalyser\n",
    "# from textblob.sentiments import NaiveBayesAnalyzer\n",
    "# blob = TextBlob(\"I love this city\", analyzer=NaiveBayesAnalyzer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "review_1 = TextBlob(\"I love this watch\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sentiment(polarity=0.5, subjectivity=0.6)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "review_1.sentiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "review_2 = TextBlob(\"I hate this wrist watch\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sentiment(polarity=-0.8, subjectivity=0.9)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sentiment Analysis\n",
    "review_2.sentiment    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.8"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Polarity\n",
    "review_2.sentiment.polarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subjectivity\n",
    "review_2.sentiment.subjectivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['I love my phone but would not recommend it to any of my colleagues',\n",
       " 'I love this watch',\n",
       " 'This is an amazing library',\n",
       " 'I do not like this restaurant',\n",
       " 'Wow what a great tip.',\n",
       " 'a surprisingly interesting movie',\n",
       " 'hard to resist',\n",
       " 'one lousy film',\n",
       " 'this is too long']"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfeelings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love my phone but would not recommend it to any of my colleagues ==> polarity:  0.5\n",
      "I love this watch ==> polarity:  0.5\n",
      "This is an amazing library ==> polarity:  0.6000000000000001\n",
      "I do not like this restaurant ==> polarity:  0.0\n",
      "Wow what a great tip. ==> polarity:  0.45\n",
      "a surprisingly interesting movie ==> polarity:  0.5\n",
      "hard to resist ==> polarity:  -0.2916666666666667\n",
      "one lousy film ==> polarity:  -0.5\n",
      "this is too long ==> polarity:  -0.05\n"
     ]
    }
   ],
   "source": [
    "for f in myfeelings:\n",
    "    result = TextBlob(f).sentiment.polarity\n",
    "    print(f'{f} ==> polarity:  {result}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Application of TextBlob\n",
    "+ Text Classification\n",
    "+ Sentiment Analysis\n",
    "+ Summarizing\n",
    "+ More\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Thanks Alot\n",
    "# By Jesse JCharis\n",
    "# J-Secur1ty \n",
    "# Jesus Saves @ JCharisTech"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}