Processamento de Linguagem Natural/PLN usando python/Entendendo o LSA e SVD.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exemplo 01 - aplicando o  PCA dentro de um vetor simples de palavras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.decomposition import TruncatedSVD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inserimos um texto aleatório\n",
    "dataset = [ \"the amount of polution is increasing day by day\",\n",
    "          \"The concert was just great\",\n",
    "          \"I love to see Gordom Ramsay Cook\",\n",
    "          \"Google is introducing a new technology\",\n",
    "          \"AI Robots are examples of great technology present today\",\n",
    "          \"All of us were singing in the concert\",\n",
    "           \"We have launch campaings to stop pollution and  global warming\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.24191973e-01  1.78240252e-01  1.14460798e-01  7.78505294e-17\n",
      "  1.24191973e-01  1.14460798e-01  7.78505294e-17  3.44988739e-01\n",
      " -1.58354960e-16  2.28921595e-01  1.24191973e-01  7.78505294e-17\n",
      "  9.72770950e-02 -1.58354960e-16  3.00124026e-01  7.78505294e-17\n",
      "  1.78240252e-01  1.14460798e-01  9.72770950e-02  1.75760635e-01\n",
      "  2.37365829e-01  7.78505294e-17 -1.58354960e-16  9.72770950e-02\n",
      "  2.95798061e-01  7.78505294e-17  1.14460798e-01  1.24191973e-01\n",
      " -1.58354960e-16  1.24191973e-01 -1.58354960e-16  1.78240252e-01\n",
      "  7.78505294e-17  1.83838346e-01  3.76098295e-01 -6.68255908e-17\n",
      "  1.24191973e-01  1.78240252e-01  7.78505294e-17  2.37365829e-01\n",
      "  7.78505294e-17  1.78240252e-01]\n"
     ]
    }
   ],
   "source": [
    "dataset = [line.lower() for line in dataset]\n",
    "vectorizer = TfidfVectorizer()\n",
    "x = vectorizer.fit_transform(dataset)\n",
    "\n",
    "lsa = TruncatedSVD(n_components = 4, n_iter = 100)\n",
    "\n",
    "lsa.fit(x)\n",
    "\n",
    "# veja como o LSA armazena os valores:\n",
    "row1 = lsa.components_[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Concept 0 :\n",
      "('the', 0.37609829529263766)\n",
      "('concert', 0.34498873923306617)\n",
      "('great', 0.3001240258948736)\n",
      "('of', 0.295798060952667)\n",
      "('just', 0.23736582929791203)\n",
      "('was', 0.23736582929791203)\n",
      "('day', 0.2289215954150454)\n",
      "('technology', 0.18383834567413398)\n",
      "('all', 0.17824025175629002)\n",
      "('in', 0.17824025175629002)\n",
      "\n",
      " Concept 1 :\n",
      "('to', 0.415788443967007)\n",
      "('cook', 0.28359165793510743)\n",
      "('gordom', 0.28359165793510743)\n",
      "('love', 0.28359165793510743)\n",
      "('ramsay', 0.28359165793510743)\n",
      "('see', 0.28359165793510743)\n",
      "('and', 0.21730644711292454)\n",
      "('campaings', 0.21730644711292454)\n",
      "('global', 0.21730644711292454)\n",
      "('have', 0.21730644711292454)\n",
      "\n",
      " Concept 2 :\n",
      "('technology', 0.37791806767144065)\n",
      "('is', 0.3419614380631981)\n",
      "('google', 0.34139694419097444)\n",
      "('introducing', 0.34139694419097444)\n",
      "('new', 0.34139694419097444)\n",
      "('day', 0.14112432680994638)\n",
      "('are', 0.11387892195373125)\n",
      "('examples', 0.11387892195373125)\n",
      "('present', 0.11387892195373125)\n",
      "('robots', 0.11387892195373125)\n",
      "\n",
      " Concept 3 :\n",
      "('day', 0.4654267679041111)\n",
      "('amount', 0.23271338395205565)\n",
      "('by', 0.23271338395205554)\n",
      "('increasing', 0.23271338395205554)\n",
      "('polution', 0.23271338395205554)\n",
      "('is', 0.21264455202450178)\n",
      "('the', 0.12724213180694274)\n",
      "('in', 0.056446647527264485)\n",
      "('singing', 0.056446647527264485)\n",
      "('us', 0.056446647527264485)\n"
     ]
    }
   ],
   "source": [
    "terms = vectorizer.get_feature_names()\n",
    "for i,comp in enumerate(lsa.components_):\n",
    "    componentTerms = zip(terms, comp)\n",
    "    sortedTerms = sorted(componentTerms, key = lambda x:x[1], reverse = True)\n",
    "    sortedTerms = sortedTerms [:10]\n",
    "    print (\"\\n Concept\", i, \":\")\n",
    "    for term in sortedTerms:\n",
    "        print(term)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exemplo 02 - usando SVD na base de titulos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from sklearn.decomposition import TruncatedSVD\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "#instancia o objeto\n",
    "wordnet_lemmatizer = WordNetLemmatizer()\n",
    "\n",
    "titles = [line.rstrip() for line in open('../Datasets/bookTitlesSL1.txt')]\n",
    "\n",
    "# copy tokenizer from sentiment example\n",
    "stopwords = set(w.rstrip() for w in open('resources/stopwords.txt'))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note: você pode usar stopwords do próprio NLTK\n",
    "# from nltk.corpus import stopwords\n",
    "# stopwords.words('english')\n",
    "\n",
    "# Aqui podemos introduzir algumas stopwords mais específicas pra esse problema\n",
    "stopwords = stopwords.union({\n",
    "    'introduction', 'edition', 'series', 'application',\n",
    "    'approach', 'card', 'access', 'package', 'plus', 'etext',\n",
    "    'brief', 'vol', 'fundamental', 'guide', 'essential', 'printed',\n",
    "    'third', 'second', 'fourth', })\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a função de tokenização\n",
    "\n",
    "def my_tokenizer(s):\n",
    "    s = s.lower() # reduz as frases para letras minusculas\n",
    "    tokens = nltk.tokenize.word_tokenize(s) # Separa as frases em palavras (tokens)\n",
    "    tokens = [t for t in tokens if len(t) > 2] # Remove palavras menores (provavelmente não importantes)\n",
    "    tokens = [wordnet_lemmatizer.lemmatize(t) for t in tokens] # coloca as palavras na sua forma base (lemma)\n",
    "    tokens = [t for t in tokens if t not in stopwords] # Remove palavras sem muito significado (stopwords)\n",
    "    tokens = [t for t in tokens if not any(c.isdigit() for c in t)] # remove qualquer dígito\n",
    "    return tokens\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exemplo do que cada vetor contém:\n",
      "\n",
      "Word_index_map:  [('philosophy', 0), ('sex', 1), ('love', 2), ('reader', 3), ('reading', 4)]\n",
      "title:  ['Philosophy of Sex and Love A Reader']\n",
      "tokens:  [['philosophy', 'sex', 'love', 'reader']]\n",
      "index_map:  ['philosophy']\n",
      "Number of errors parsing file: 0 number of lines in file: 250\n"
     ]
    }
   ],
   "source": [
    "# Agora devemos criar um mapa word-to-index. Assim podemos criar os vetores de frequência mais tarde\n",
    "# Vamos salvar também as versões tokenizadas (para não precisar tokenizar denovo)\n",
    "\n",
    "\n",
    "word_index_map = {}\n",
    "current_index = 0\n",
    "all_tokens = []\n",
    "all_titles = []\n",
    "index_word_map = []\n",
    "error_count = 0\n",
    "\n",
    "\n",
    "for title in titles:\n",
    "    try:\n",
    "        title = title.encode('ascii', 'ignore').decode('utf-8') # Isso vai jogar uma exceção se tiverem caracteres errados\n",
    "        all_titles.append(title)\n",
    "        tokens = my_tokenizer(title)\n",
    "        all_tokens.append(tokens)\n",
    "        for token in tokens:\n",
    "            if token not in word_index_map:\n",
    "                word_index_map[token] = current_index\n",
    "                current_index += 1\n",
    "                index_word_map.append(token)\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "        print(title)\n",
    "        error_count += 1\n",
    "\n",
    "## apenas exibe um exemplo\n",
    "dict_items = word_index_map.items()\n",
    "\n",
    "print(\"Exemplo do que cada vetor contém:\\n\")\n",
    "print(\"Word_index_map: \", list(dict_items)[:5])\n",
    "print(\"title: \",all_titles[:1])\n",
    "print(\"tokens: \", all_tokens[:1])\n",
    "print(\"index_map: \", index_word_map[:1])\n",
    "\n",
    "\n",
    "## mostra um relatório de erros\n",
    "print(\"Number of errors parsing file:\", error_count, \"number of lines in file:\", len(titles))\n",
    "if error_count == len(titles):\n",
    "    print(\"There is no data to do anything with! Quitting...\")\n",
    "    exit()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250 385\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# transforma tokens para vetores\n",
    "def tokens_to_vector(tokens):\n",
    "    x = np.zeros(len(word_index_map))\n",
    "    for t in tokens:\n",
    "        i = word_index_map[t]\n",
    "        x[i] = 1\n",
    "    return x\n",
    "\n",
    "\n",
    "N = len(all_tokens)\n",
    "D = len(word_index_map)\n",
    "X = np.zeros((D, N)) # Cria uma matriz gigante de zeros baseado na quantidade de tokens e documentos\n",
    "i = 0\n",
    "\n",
    "\n",
    "#chama a função de transformação de vetores para cada linha do array\n",
    "for tokens in all_tokens:\n",
    "    X[:,i] = tokens_to_vector(tokens)\n",
    "    i += 1\n",
    "\n",
    "print( N, D)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-94-ec803649f12f>:8: MatplotlibDeprecationWarning: The 's' parameter of annotate() has been renamed 'text' since Matplotlib 3.3; support for the old name will be dropped two minor releases later.\n",
      "  plt.annotate(s=index_word_map[i], xy=(Z[i,0], Z[i,1]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "svd = TruncatedSVD()\n",
    "Z = svd.fit_transform(X)\n",
    "\n",
    "\n",
    "plt.scatter(Z[:,0], Z[:,1])\n",
    "\n",
    "for i in range(D):\n",
    "    plt.annotate(s=index_word_map[i], xy=(Z[i,0], Z[i,1]))\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}