{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# TD7 - Analyse de texte - correction\n", "\n", "Analyse de texte, TF-IDF, LDA, moteur de recherche, expressions r\u00e9guli\u00e8res (correction)."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = -1;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## R\u00e9cup\u00e9ration des donn\u00e9es\n", "\n", "Il est possible de t\u00e9l\u00e9charger les donn\u00e9es [df_pocket.zip](http://www.xavierdupre.fr/enseignement/complements/df_pocket.zip)."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"data": {"text/plain": ["['data_pocket.json', 'df_pocket.csv']"]}, "execution_count": 3, "metadata": {}, "output_type": "execute_result"}], "source": ["from pyensae.datasource import download_data\n", "download_data(\"df_pocket.zip\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Nettoyer les donn\u00e9es (regexp et nltk)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Mais avant tout, nous devrions augmenter la qualit\u00e9 de nos donn\u00e9es (en am\u00e9liorant les parsers et la liste des stopwords). C'est l'objet de cette section."]}, {"cell_type": "code", "execution_count": 3, "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>resolved_url</th>\n", "      <th>resolved_title</th>\n", "      <th>excerpt</th>\n", "      <th>tags</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>1883956314</th>\n", "      <td>http://www.xavierdupre.fr/app/teachpyx/helpsph...</td>\n", "      <td>Types et variables du langage python\u00b6</td>\n", "      <td>Il est impossible d\u2019\u00e9crire un programme sans u...</td>\n", "      <td>{'python': {'item_id': '1883956314', 'tag': 'p...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1895830689</th>\n", "      <td>https://www.pluralsight.com/paths/javascript?a...</td>\n", "      <td>JavaScript</td>\n", "      <td>ES6 is a major update to the JavaScript langua...</td>\n", "      <td>NaN</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1916603293</th>\n", "      <td>http://www.seloger.com/annonces/locations/appa...</td>\n", "      <td>Location Appartement 56,88m\u00b2 Asnieres-sur-Sein...</td>\n", "      <td>Prix au m\u00b2 fourni \u00e0 titre indicatif, seul un p...</td>\n", "      <td>NaN</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1916600800</th>\n", "      <td>http://www.seloger.com/annonces/locations/appa...</td>\n", "      <td>Location Appartement 82m\u00b2 Asnieres sur Seine -...</td>\n", "      <td>Trouvez votre bien \u00e0 tout moment              ...</td>\n", "      <td>NaN</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1916598390</th>\n", "      <td>http://www.seloger.com/annonces/locations/appa...</td>\n", "      <td>Location Appartement 93,6m\u00b2 Asni\u00e8res-sur-Seine</td>\n", "      <td>Trouvez votre bien \u00e0 tout moment              ...</td>\n", "      <td>NaN</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                                                 resolved_url  \\\n", "1883956314  http://www.xavierdupre.fr/app/teachpyx/helpsph...   \n", "1895830689  https://www.pluralsight.com/paths/javascript?a...   \n", "1916603293  http://www.seloger.com/annonces/locations/appa...   \n", "1916600800  http://www.seloger.com/annonces/locations/appa...   \n", "1916598390  http://www.seloger.com/annonces/locations/appa...   \n", "\n", "                                               resolved_title  \\\n", "1883956314              Types et variables du langage python\u00b6   \n", "1895830689                                         JavaScript   \n", "1916603293  Location Appartement 56,88m\u00b2 Asnieres-sur-Sein...   \n", "1916600800  Location Appartement 82m\u00b2 Asnieres sur Seine -...   \n", "1916598390     Location Appartement 93,6m\u00b2 Asni\u00e8res-sur-Seine   \n", "\n", "                                                      excerpt  \\\n", "1883956314  Il est impossible d\u2019\u00e9crire un programme sans u...   \n", "1895830689  ES6 is a major update to the JavaScript langua...   \n", "1916603293  Prix au m\u00b2 fourni \u00e0 titre indicatif, seul un p...   \n", "1916600800  Trouvez votre bien \u00e0 tout moment              ...   \n", "1916598390  Trouvez votre bien \u00e0 tout moment              ...   \n", "\n", "                                                         tags  \n", "1883956314  {'python': {'item_id': '1883956314', 'tag': 'p...  \n", "1895830689                                                NaN  \n", "1916603293                                                NaN  \n", "1916600800                                                NaN  \n", "1916598390                                                NaN  "]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["import json\n", "from pprint import pprint\n", "\n", "with open('./data_pocket.json') as fp:    \n", "    dict_pocket = json.load(fp)\n", "dict_to_df = {}\n", "\n", "keys = ['resolved_url', 'resolved_title', 'excerpt', 'tags']\n", "\n", "for (k,v) in dict_pocket.items():\n", "    dict_to_df[k] = dict(zip(keys, [v[key] for key in keys if key in v]))\n", "import pandas as p\n", "df_pocket = p.DataFrame.from_dict(dict_to_df, orient = \"index\")\n", "df_pocket.head()"]}, {"cell_type": "code", "execution_count": 4, "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>tags</th>\n", "      <th>url</th>\n", "      <th>excerpt</th>\n", "      <th>title</th>\n", "      <th>domain</th>\n", "      <th>html_soup</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>['mobile app']</td>\n", "      <td>https://www.grafikart.fr/tutoriels/cordova/ion...</td>\n", "      <td>Ionic est un framework qui va vous permettre d...</td>\n", "      <td>Tutoriel Vid\u00e9o Apache CordovaIonic Framework</td>\n", "      <td>grafikart.fr</td>\n", "      <td>{'h2': ['Petit', 'tour', 'du', 'propri\u00e9taire']...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>['lewagon']</td>\n", "      <td>http://www.colorhunt.co</td>\n", "      <td>Home Create Likes () About Add To Chrome Faceb...</td>\n", "      <td>Color Hunt</td>\n", "      <td>colorhunt.co</td>\n", "      <td>{}</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>['data science']</td>\n", "      <td>https://jakevdp.github.io/blog/2015/08/14/out-...</td>\n", "      <td>In recent months, a host of new tools and pack...</td>\n", "      <td>Out-of-Core Dataframes in Python: Dask and Ope...</td>\n", "      <td>jakevdp.github.io</td>\n", "      <td>{'h2': ['Pubs', 'of', 'the', 'British', 'Isles...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>['abtest']</td>\n", "      <td>https://blog.dominodatalab.com/ab-testing-with...</td>\n", "      <td>In this post, I discuss a method for A/B testi...</td>\n", "      <td>A/B Testing with Hierarchical Models in Python</td>\n", "      <td>blog.dominodatalab.com</td>\n", "      <td>{'h2': ['Recent', 'Posts'], 'h3': ['Related'],...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>['mdn', 'documentation']</td>\n", "      <td>https://developer.mozilla.org/en-US/docs/Learn...</td>\n", "      <td>Getting started with the Web is a concise seri...</td>\n", "      <td>Getting started with the Web</td>\n", "      <td>developer.mozilla.org</td>\n", "      <td>{'h2': ['Mozilla'], 'h3': ['How', 'the', 'web'...</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                       tags  \\\n", "0            ['mobile app']   \n", "1               ['lewagon']   \n", "2          ['data science']   \n", "3                ['abtest']   \n", "4  ['mdn', 'documentation']   \n", "\n", "                                                 url  \\\n", "0  https://www.grafikart.fr/tutoriels/cordova/ion...   \n", "1                            http://www.colorhunt.co   \n", "2  https://jakevdp.github.io/blog/2015/08/14/out-...   \n", "3  https://blog.dominodatalab.com/ab-testing-with...   \n", "4  https://developer.mozilla.org/en-US/docs/Learn...   \n", "\n", "                                             excerpt  \\\n", "0  Ionic est un framework qui va vous permettre d...   \n", "1  Home Create Likes () About Add To Chrome Faceb...   \n", "2  In recent months, a host of new tools and pack...   \n", "3  In this post, I discuss a method for A/B testi...   \n", "4  Getting started with the Web is a concise seri...   \n", "\n", "                                               title                  domain  \\\n", "0       Tutoriel Vid\u00e9o Apache CordovaIonic Framework            grafikart.fr   \n", "1                                         Color Hunt            colorhunt.co   \n", "2  Out-of-Core Dataframes in Python: Dask and Ope...       jakevdp.github.io   \n", "3     A/B Testing with Hierarchical Models in Python  blog.dominodatalab.com   \n", "4                       Getting started with the Web   developer.mozilla.org   \n", "\n", "                                           html_soup  \n", "0  {'h2': ['Petit', 'tour', 'du', 'propri\u00e9taire']...  \n", "1                                                 {}  \n", "2  {'h2': ['Pubs', 'of', 'the', 'British', 'Isles...  \n", "3  {'h2': ['Recent', 'Posts'], 'h3': ['Related'],...  \n", "4  {'h2': ['Mozilla'], 'h3': ['How', 'the', 'web'...  "]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas as p\n", "import ast\n", "df_pocket = p.read_csv('./df_pocket.csv')\n", "df_pocket.head()"]}, {"cell_type": "code", "execution_count": 5, "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>tags</th>\n", "      <th>url</th>\n", "      <th>excerpt</th>\n", "      <th>title</th>\n", "      <th>domain</th>\n", "      <th>html_soup</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>[mobile app]</td>\n", "      <td>https://www.grafikart.fr/tutoriels/cordova/ion...</td>\n", "      <td>Ionic est un framework qui va vous permettre d...</td>\n", "      <td>Tutoriel Vid\u00e9o Apache CordovaIonic Framework</td>\n", "      <td>grafikart.fr</td>\n", "      <td>{'h2': ['Petit', 'tour', 'du', 'propri\u00e9taire']...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>[lewagon]</td>\n", "      <td>http://www.colorhunt.co</td>\n", "      <td>Home Create Likes () About Add To Chrome Faceb...</td>\n", "      <td>Color Hunt</td>\n", "      <td>colorhunt.co</td>\n", "      <td>{}</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>[data science]</td>\n", "      <td>https://jakevdp.github.io/blog/2015/08/14/out-...</td>\n", "      <td>In recent months, a host of new tools and pack...</td>\n", "      <td>Out-of-Core Dataframes in Python: Dask and Ope...</td>\n", "      <td>jakevdp.github.io</td>\n", "      <td>{'h2': ['Pubs', 'of', 'the', 'British', 'Isles...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>[abtest]</td>\n", "      <td>https://blog.dominodatalab.com/ab-testing-with...</td>\n", "      <td>In this post, I discuss a method for A/B testi...</td>\n", "      <td>A/B Testing with Hierarchical Models in Python</td>\n", "      <td>blog.dominodatalab.com</td>\n", "      <td>{'h2': ['Recent', 'Posts'], 'h3': ['Related'],...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>[mdn, documentation]</td>\n", "      <td>https://developer.mozilla.org/en-US/docs/Learn...</td>\n", "      <td>Getting started with the Web is a concise seri...</td>\n", "      <td>Getting started with the Web</td>\n", "      <td>developer.mozilla.org</td>\n", "      <td>{'h2': ['Mozilla'], 'h3': ['How', 'the', 'web'...</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                   tags                                                url  \\\n", "0          [mobile app]  https://www.grafikart.fr/tutoriels/cordova/ion...   \n", "1             [lewagon]                            http://www.colorhunt.co   \n", "2        [data science]  https://jakevdp.github.io/blog/2015/08/14/out-...   \n", "3              [abtest]  https://blog.dominodatalab.com/ab-testing-with...   \n", "4  [mdn, documentation]  https://developer.mozilla.org/en-US/docs/Learn...   \n", "\n", "                                             excerpt  \\\n", "0  Ionic est un framework qui va vous permettre d...   \n", "1  Home Create Likes () About Add To Chrome Faceb...   \n", "2  In recent months, a host of new tools and pack...   \n", "3  In this post, I discuss a method for A/B testi...   \n", "4  Getting started with the Web is a concise seri...   \n", "\n", "                                               title                  domain  \\\n", "0       Tutoriel Vid\u00e9o Apache CordovaIonic Framework            grafikart.fr   \n", "1                                         Color Hunt            colorhunt.co   \n", "2  Out-of-Core Dataframes in Python: Dask and Ope...       jakevdp.github.io   \n", "3     A/B Testing with Hierarchical Models in Python  blog.dominodatalab.com   \n", "4                       Getting started with the Web   developer.mozilla.org   \n", "\n", "                                           html_soup  \n", "0  {'h2': ['Petit', 'tour', 'du', 'propri\u00e9taire']...  \n", "1                                                 {}  \n", "2  {'h2': ['Pubs', 'of', 'the', 'British', 'Isles...  \n", "3  {'h2': ['Recent', 'Posts'], 'h3': ['Related'],...  \n", "4  {'h2': ['Mozilla'], 'h3': ['How', 'the', 'web'...  "]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["df_pocket['html_soup'] = df_pocket['html_soup'].apply(lambda x : ast.literal_eval(x) if x != \"scraper banned\" else x)\n", "df_pocket['tags'] = df_pocket['tags'].apply(lambda x : ast.literal_eval(x) if x == x else x)\n", "df_pocket.head()"]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": ["def nan_to_string(x):\n", "    if x==x:\n", "        return x\n", "    else:\n", "        return ''\n", "\n", "title_string = ' '.join(df_pocket['title'].apply( lambda x: nan_to_string(x)))"]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": ["import re\n", "def url_cleaning(url):\n", "    return ' '.join(re.split(r'\\/|\\.|\\:|-|\\?',url))\n", "\n", "url_string = ' '.join(df_pocket['url'].apply(lambda x : url_cleaning(x)))"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": ["def hx_cleaning(d,hx):\n", "    if str(hx) in d:\n", "        return ' '.join(d[str(hx)])\n", "    else: \n", "        return ''\n", "     \n", "h1_string = ' '.join(df_pocket['html_soup'].apply(lambda x : hx_cleaning(x,'h1')))"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": ["h2_string = ' '.join(df_pocket['html_soup'].apply(lambda x : hx_cleaning(x,'h2')))\n", "h3_string = ' '.join(df_pocket['html_soup'].apply(lambda x : hx_cleaning(x, 'h3')))\n", "excerpt_string = ' '.join(df_pocket['excerpt'].apply( lambda x: nan_to_string(x)))"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": ["def p_cleaning(x):\n", "    if (type(x) == dict) & ('p' in x ):\n", "        return ' '.join(x['p'])\n", "    else: \n", "        return ''\n", "\n", "p_string = ' '.join(df_pocket['html_soup'].apply(lambda x : p_cleaning(x)))"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/plain": ["'Tutoriel Vido Apache CordovaIonic Framework Color Hunt OutofCore Dataframes in Python Dask and OpenStreetMap AB Testing with Hierarchical Models in Python Getting started with the Web Le Wagon UI components shakacodereactonrails Le Wagon Alumni Nocturne Opus No Frederic Chopin Piano Tutorial Synthesia ES Promises in Depth Jupyter Notebook Viewer Introduction lanalyse de texte avec nltk Tokenization CamFind API Documentation Build an Elasticsearch Index with PythonMachine Learning Series Part The MustHave Discovery Tool for every Media Professional Python NLTK WTF Chapter Notes on things that dont work right Google Maps Geolocation Tracking in Realtime with JavaScript The Definitive Guide to Natural Language Processing lewagonrailsstylesheets Productivity Tips for Programmers with ADHD EquityOwl No Cash No Salaries Just Equity React For Beginners Learn Enough Text Editor to Be Dangerous Michael Hartl Mapbox The New WordPresscom Why Proxima Nova Is Everywhere PayByPhone Adds NFC in San F...'"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["words = ' '.join([title_string,url_string,h1_string,h2_string,h3_string,excerpt_string])\n", "# on ne conserve que les mots\n", "words_string = re.sub('[^A-Za-z ]','', words)\n", "#on \"nettoie les espaces\"\n", "words_string = re.sub('\\s+',' ', words_string)\n", "words_string[:1000] + '...'"]}, {"cell_type": "code", "execution_count": 12, "metadata": {"scrolled": true}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Defaulting to user installation because normal site-packages is not writeable\n", "Requirement already satisfied: nltk in c:\\python395_x64\\lib\\site-packages (3.7)\n", "Requirement already satisfied: joblib in c:\\python395_x64\\lib\\site-packages (from nltk) (1.1.0)\n", "Requirement already satisfied: click in c:\\python395_x64\\lib\\site-packages (from nltk) (8.0.1)\n", "Requirement already satisfied: regex>=2021.8.3 in c:\\python395_x64\\lib\\site-packages (from nltk) (2022.1.18)\n", "Requirement already satisfied: tqdm in c:\\python395_x64\\lib\\site-packages (from nltk) (4.62.3)\n", "Requirement already satisfied: colorama in c:\\python395_x64\\lib\\site-packages (from click->nltk) (0.4.4)\n"]}], "source": ["! pip install nltk"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Nltk contient un corpus de stopwords en plusieurs langues. On peut enrichir la liste d\u00e9j\u00e0 cr\u00e9\u00e9e."]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["{'her', \"i'd\", 'than', 'under', 'yours', 'such', \"haven't\", \"doesn't\", \"didn't\", 'then', \"couldn't\", 'myself', 'from', 'since', 'are', 'have', 'again', 'the', 'did', 'being', 'which', 'be', 'yourself', 'am', 'here', \"weren't\", \"he's\", 'himself', 'ought', 'for', \"you're\", 'because', 'how', 'about', 'that', 'he', 'theirs', 'she', 'those', 'after', \"shan't\", 'other', 'ours', 'so', 'very', 'between', \"how's\", 'you', \"when's\", \"she'd\", 'above', \"he'd\", 'with', \"we're\", \"shouldn't\", 'www', 'should', 'in', 'like', 'down', 'hence', 'own', \"they'd\", 'any', 'but', 'as', 'was', \"aren't\", \"won't\", 'r', 'hers', 'them', \"mustn't\", 'this', 'too', 'most', 'not', 'through', \"let's\", \"she's\", 'all', 'up', 'get', 'do', 'both', 'been', \"that's\", \"you've\", \"he'll\", \"isn't\", 'is', 'further', \"wasn't\", \"wouldn't\", 'has', 'once', 'out', 'our', 'when', 'yourselves', 'until', 'also', 'otherwise', 'can', 'more', 'during', \"here's\", 'only', 'however', 'no', 'it', \"hasn't\", 'same', 'herself', \"they'll\", 'itself', 'i', 'ever', 'nor', \"she'll\", \"where's\", 'whom', 'there', \"hadn't\", 'would', 'these', 'does', 'each', 'off', 'what', 'at', 'or', 'to', \"you'd\", 'themselves', 'doing', \"what's\", 'and', 'him', 'had', \"we've\", \"i've\", \"they're\", 'my', 'therefore', \"i'll\", 'on', 'against', 'his', 'why', 'an', 'its', 'else', 'by', 'me', 'ourselves', \"they've\", 'k', \"i'm\", 'of', 'could', 'their', \"we'd\", 'below', 'they', 'who', 'com', 'just', 'few', 'before', \"you'll\", 'if', 'some', \"we'll\", 'we', \"why's\", 'shall', 'having', 'while', 'into', \"it's\", 'your', 'http', 'a', 'where', \"there's\", \"who's\", \"can't\", 'were', 'over', 'cannot', \"don't\"}\n"]}], "source": ["from wordcloud import WordCloud, STOPWORDS\n", "\n", "stopwords = set(STOPWORDS)\n", "print(STOPWORDS)"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["for wds in ['http', 'https', 'www', 'fr', 'com', 'io', 'org', 'co', 'jo', 'edu', 'news', 'html', 'htm',\\\n", "            'github', 'youtube', 'google', 'blog', 'watch', 'de', 'le', 'la', 'en', 'sur', 'vous', 'les', \\\n", "           'ajouter', 'README', 'md', 'et', 'PROCESS', 'CMYK', 'des', 'chargement', 'playlists', 'endobj', \\\n", "           'obj','est', 'use', 'using', 'will', 'web', 'first','pour', 'du', 'une', 'que']:\n", "    stopwords.add(wds)"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/plain": ["['her',\n", " 'sont',\n", " 'under',\n", " 'such',\n", " \"haven't\",\n", " 'jo',\n", " 'then',\n", " 'myself',\n", " 'fussiez',\n", " 'sa',\n", " 'fr',\n", " 'haven',\n", " 'again',\n", " 'md',\n", " '\u00e9t\u00e9es',\n", " 'the',\n", " 'un',\n", " 'did',\n", " 'seront',\n", " 'par',\n", " 'playlists',\n", " 'yourself',\n", " 've',\n", " \"he's\",\n", " 'himself',\n", " 'use',\n", " 'ma',\n", " 'ses',\n", " 'about',\n", " 'he',\n", " 'theirs',\n", " 'she',\n", " 'ayant',\n", " 'en',\n", " 'news',\n", " 'other',\n", " 'll',\n", " 'weren',\n", " 'et',\n", " 'so',\n", " 'between',\n", " 'you',\n", " 'dans',\n", " \"when's\",\n", " 'aies',\n", " 't',\n", " \"she'd\",\n", " 'with',\n", " '\u00e9tants',\n", " \"that'll\",\n", " '...']"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["import nltk\n", "\n", "stopwords_fr_ntlk = set(nltk.corpus.stopwords.words('french'))\n", "stopwords_en_ntlk = set(nltk.corpus.stopwords.words('english'))\n", "stopwords_clean = [ l.lower() for l in list(stopwords.union(stopwords_fr_ntlk).union(stopwords_en_ntlk))]\n", "stopwords_clean[:50] + ['...']"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"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": ["wordcloud = WordCloud(stopwords=stopwords, background_color=\"white\")\n", "\n", "wordcloud.generate(words_string)\n", "\n", "import matplotlib.pyplot as plt\n", "plt.imshow(wordcloud)\n", "plt.axis('off');"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On applique tout \u00e7a \u00e0 df_pocket."]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": ["def words_cleaning(url,title,excerpt,html_soup):\n", "    url_clean = url_cleaning(url)\n", "    title_clean = nan_to_string(title)\n", "    excerpt_clean = nan_to_string(excerpt)\n", "    h1_clean = hx_cleaning(html_soup,'h1')\n", "    h2_clean = hx_cleaning(html_soup,'h2')\n", "    h3_clean = hx_cleaning(html_soup,'h3')\n", "    p_clean = p_cleaning(html_soup)\n", "    words = ' '.join([url_clean, title_clean, excerpt_clean, h1_clean, h2_clean, h3_clean, p_clean])\n", "    words_clean = re.sub('[^A-Za-z ]','', words)\n", "    words_clean = re.sub('\\s+',' ', words_clean)\n", "    words_list = words_clean.split(' ')\n", "    return ' '.join([w.lower() for w in words_list if w not in stopwords_clean])"]}, {"cell_type": "code", "execution_count": 19, "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>tags</th>\n", "      <th>url</th>\n", "      <th>excerpt</th>\n", "      <th>title</th>\n", "      <th>domain</th>\n", "      <th>html_soup</th>\n", "      <th>words_string</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>[mobile app]</td>\n", "      <td>https://www.grafikart.fr/tutoriels/cordova/ion...</td>\n", "      <td>Ionic est un framework qui va vous permettre d...</td>\n", "      <td>Tutoriel Vid\u00e9o Apache CordovaIonic Framework</td>\n", "      <td>grafikart.fr</td>\n", "      <td>{'h2': ['Petit', 'tour', 'du', 'propri\u00e9taire']...</td>\n", "      <td>grafikart tutoriels cordova ionic framework tu...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>[lewagon]</td>\n", "      <td>http://www.colorhunt.co</td>\n", "      <td>Home Create Likes () About Add To Chrome Faceb...</td>\n", "      <td>Color Hunt</td>\n", "      <td>colorhunt.co</td>\n", "      <td>{}</td>\n", "      <td>colorhunt color hunt home create likes about a...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>[data science]</td>\n", "      <td>https://jakevdp.github.io/blog/2015/08/14/out-...</td>\n", "      <td>In recent months, a host of new tools and pack...</td>\n", "      <td>Out-of-Core Dataframes in Python: Dask and Ope...</td>\n", "      <td>jakevdp.github.io</td>\n", "      <td>{'h2': ['Pubs', 'of', 'the', 'British', 'Isles...</td>\n", "      <td>jakevdp core dataframes python outofcore dataf...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>[abtest]</td>\n", "      <td>https://blog.dominodatalab.com/ab-testing-with...</td>\n", "      <td>In this post, I discuss a method for A/B testi...</td>\n", "      <td>A/B Testing with Hierarchical Models in Python</td>\n", "      <td>blog.dominodatalab.com</td>\n", "      <td>{'h2': ['Recent', 'Posts'], 'h3': ['Related'],...</td>\n", "      <td>dominodatalab ab testing hierarchical models p...</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>[mdn, documentation]</td>\n", "      <td>https://developer.mozilla.org/en-US/docs/Learn...</td>\n", "      <td>Getting started with the Web is a concise seri...</td>\n", "      <td>Getting started with the Web</td>\n", "      <td>developer.mozilla.org</td>\n", "      <td>{'h2': ['Mozilla'], 'h3': ['How', 'the', 'web'...</td>\n", "      <td>developer mozilla us docs learn gettingstarted...</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                   tags                                                url  \\\n", "0          [mobile app]  https://www.grafikart.fr/tutoriels/cordova/ion...   \n", "1             [lewagon]                            http://www.colorhunt.co   \n", "2        [data science]  https://jakevdp.github.io/blog/2015/08/14/out-...   \n", "3              [abtest]  https://blog.dominodatalab.com/ab-testing-with...   \n", "4  [mdn, documentation]  https://developer.mozilla.org/en-US/docs/Learn...   \n", "\n", "                                             excerpt  \\\n", "0  Ionic est un framework qui va vous permettre d...   \n", "1  Home Create Likes () About Add To Chrome Faceb...   \n", "2  In recent months, a host of new tools and pack...   \n", "3  In this post, I discuss a method for A/B testi...   \n", "4  Getting started with the Web is a concise seri...   \n", "\n", "                                               title                  domain  \\\n", "0       Tutoriel Vid\u00e9o Apache CordovaIonic Framework            grafikart.fr   \n", "1                                         Color Hunt            colorhunt.co   \n", "2  Out-of-Core Dataframes in Python: Dask and Ope...       jakevdp.github.io   \n", "3     A/B Testing with Hierarchical Models in Python  blog.dominodatalab.com   \n", "4                       Getting started with the Web   developer.mozilla.org   \n", "\n", "                                           html_soup  \\\n", "0  {'h2': ['Petit', 'tour', 'du', 'propri\u00e9taire']...   \n", "1                                                 {}   \n", "2  {'h2': ['Pubs', 'of', 'the', 'British', 'Isles...   \n", "3  {'h2': ['Recent', 'Posts'], 'h3': ['Related'],...   \n", "4  {'h2': ['Mozilla'], 'h3': ['How', 'the', 'web'...   \n", "\n", "                                        words_string  \n", "0  grafikart tutoriels cordova ionic framework tu...  \n", "1  colorhunt color hunt home create likes about a...  \n", "2  jakevdp core dataframes python outofcore dataf...  \n", "3  dominodatalab ab testing hierarchical models p...  \n", "4  developer mozilla us docs learn gettingstarted...  "]}, "execution_count": 20, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy as np\n", "df_pocket['words_string'] = np.vectorize(words_cleaning)(df_pocket['url'], \\\n", "                                                         df_pocket['title'], \\\n", "                                                         df_pocket['excerpt'], \\\n", "                                                         df_pocket['html_soup'])\n", "df_pocket.head()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A pr\u00e9sent la base df_pocket est nettoy\u00e9e et pr\u00eate \u00e0 \u00eatre utilis\u00e9e pour les analyses de textes. "]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Analyse des donn\u00e9es textuelles - TD-IDF, similarit\u00e9 cosine et n-grams\n", "\n", "Le calcul [tf-idf](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) (term frequency\u2013inverse document frequency) permet de calculer un score de proximit\u00e9 entre un terme de recherche et un document (c'est ce que font les moteurs de recherche). \n", "\n", "\n", "La partie tf calcule une fonction croissante de la fr\u00e9quence du terme de recherche dans le document \u00e0 l'\u00e9tude, la partie idf calcule une fonction inversement proportionnelle \u00e0 la fr\u00e9quence du terme dans l'ensemble des documents (ou corpus). \n", "\n", "\n", "\n", "Le score total, obtenu en multipliant les deux composantes, permet ainsi de donner un score d'autant plus \u00e9lev\u00e9 que le terme est surr\u00e9pr\u00e9sent\u00e9 dans un document (par rapport \u00e0 l'ensemble des documents). Il existe plusieurs fonctions, qui p\u00e9nalisent plus ou moins les documents longs, ou qui sont plus ou moins smooth."]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": ["corpus = { \n", "    'a' : \"Mr. Green killed Colonel Mustard in the study with the candlestick. \"\n", "          \"Mr. Green is not a very nice fellow.\",\n", "    'b' : \"Professor Plum has a green plant in his study.\",\n", "    'c' : \"Miss Scarlett watered Professor Plum's green plant while he was away \"\n", "          \"from his office last week.\"\n", "}\n", "terms = {\n", "    'a' : [ i.lower() for i in corpus['a'].split() ],\n", "    'b' : [ i.lower() for i in corpus['b'].split() ],\n", "    'c' : [ i.lower() for i in corpus['c'].split() ]\n", "}"]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": ["from math import log\n", "\n", "QUERY_TERMS = ['mr.', 'green']\n", "\n", "def tf(term, doc, normalize=True):\n", "    doc = doc.lower().split()\n", "    if normalize:\n", "        return doc.count(term.lower()) / float(len(doc))\n", "    else:\n", "        return doc.count(term.lower()) / 1.0\n", "\n", "\n", "def idf(term, corpus):\n", "    num_texts_with_term = len([True for text in corpus if term.lower() \\\n", "                              in text.lower().split()])\n", "    try:\n", "        return 1.0 + log(float(len(corpus)) / num_texts_with_term)\n", "    except ZeroDivisionError:\n", "        return 1.0\n", "    \n", "def tf_idf(term, doc, corpus):\n", "    return tf(term, doc) * idf(term, corpus)"]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["a : Mr. Green killed Colonel Mustard in the study with the candlestick. Mr. Green is not a very nice fellow.\n", "b : Professor Plum has a green plant in his study.\n", "c : Miss Scarlett watered Professor Plum's green plant while he was away from his office last week.\n", "\n", "\n", "TF(a): mr. 0.10526315789473684\n", "TF(b): mr. 0.0\n", "TF(c): mr. 0.0\n", "IDF: mr. 2.09861228866811\n", "\n", "\n", "TF-IDF(a): mr. 0.22090655670190631\n", "TF-IDF(b): mr. 0.0\n", "TF-IDF(c): mr. 0.0\n", "\n", "\n", "TF(a): green 0.10526315789473684\n", "TF(b): green 0.1111111111111111\n", "TF(c): green 0.0625\n", "IDF: green 1.0\n", "\n", "\n", "TF-IDF(a): green 0.10526315789473684\n", "TF-IDF(b): green 0.1111111111111111\n", "TF-IDF(c): green 0.0625\n", "\n", "\n", "Score TF-IDF total pour le terme 'mr. green'\n", "a 0.3261697145966431\n", "b 0.1111111111111111\n", "c 0.0625\n"]}], "source": ["for (k, v) in sorted(corpus.items()):\n", "    print(k, ':', v)\n", "print('\\n')\n", "\n", "query_scores = {'a': 0, 'b': 0, 'c': 0}\n", "for term in [t.lower() for t in QUERY_TERMS]:\n", "    for doc in sorted(corpus):\n", "        print('TF({}): {}'.format(doc, term), tf(term, corpus[doc]))\n", "    print('IDF: {}'.format(term, ), idf(term, corpus.values()))\n", "    print('\\n')\n", "    for doc in sorted(corpus):\n", "        score = tf_idf(term, corpus[doc], corpus.values())\n", "        print('TF-IDF({}): {}'.format(doc, term), score)\n", "        query_scores[doc] += score\n", "    print('\\n')\n", "\n", "print(\"Score TF-IDF total pour le terme '{}'\".format(' '.join(QUERY_TERMS), ))\n", "for (doc, score) in sorted(query_scores.items()):\n", "    print(doc, score)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Exercice guid\u00e9 - Calcul de TF-IDF \n", "\n", "Quel document est le plus proche du terme \"green plant\" ? Calculer les scores TF-IDF pour le terme \"green plant\". Cela correspond-il \u00e0 vos attentes ? Que se passe-t-il avec \"green\" seul ?\n", "\n", "### Green plant"]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": ["\n", "from math import log\n", "\n", "def tf(term, doc, normalize=True):\n", "    doc = doc.lower().split()\n", "    if normalize:\n", "        return doc.count(term.lower()) / float(len(doc))\n", "    else:\n", "        return doc.count(term.lower()) / 1.0\n", "\n", "\n", "def idf(term, corpus):\n", "    num_texts_with_term = len([True for text in corpus if term.lower()\n", "                              in text.lower().split()])\n", "    try:\n", "        return 1.0 + log(float(len(corpus)) / num_texts_with_term)\n", "    except ZeroDivisionError:\n", "        return 1.0\n", "\n", "def tf_idf(term, doc, corpus):\n", "    return tf(term, doc) * idf(term, corpus)\n", "\n"]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Score TF-IDF total pour le terme 'green plant'\n", "a 0.10526315789473684\n", "b 0.26727390090090714\n", "c 0.1503415692567603\n"]}], "source": ["QUERY_TERMS = ['green', 'plant']\n", "query_scores = {'a': 0, 'b': 0, 'c': 0}\n", "for term in [t.lower() for t in QUERY_TERMS]:\n", "    for doc in sorted(corpus):\n", "        score = tf_idf(term, corpus[doc], corpus.values())\n", "        query_scores[doc] += score\n", "\n", "print(\"Score TF-IDF total pour le terme '{}'\".format(' '.join(QUERY_TERMS), ))\n", "for (doc, score) in sorted(query_scores.items()):\n", "    print(doc, score)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Deux documents possibles : b ou c (a ne contient pas le mot \u00ab plant \u00bb). B est plus court : donc green plant \u00ab p\u00e8se \u00bb plus."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Green"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Score TF-IDF total pour le terme 'green'\n", "a 0.10526315789473684\n", "b 0.1111111111111111\n", "c 0.0625\n"]}], "source": ["QUERY_TERMS = ['green']\n", "term = [t.lower() for t in QUERY_TERMS]\n", "term = 'green'\n", "\n", "query_scores = {'a': 0, 'b': 0, 'c': 0}\n", "\n", "for doc in sorted(corpus):\n", "    score = tf_idf(term, corpus[doc], corpus.values())\n", "    query_scores[doc] += score\n", "\n", "print(\"Score TF-IDF total pour le terme '{}'\".format(term))\n", "for (doc, score) in sorted(query_scores.items()):\n", "    print(doc, score)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice 1 - TF-IDF sur des donn\u00e9es pocket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Prenez 5 articles enregistr\u00e9s dans pocket et d\u00e9terminer leur score pour les mots python, data et science."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice 2 - Cr\u00e9ation d'un moteur de recherche pour les donn\u00e9es pocket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["L'id\u00e9e de cet exercice est de cr\u00e9er un moteur de recherche pour ['python','data','science']. \n", "\n", "Le but : trouver les 5 articles les plus pertinents pour ces termes. \n", "\n", "    1) La premi\u00e8re \u00e9tape sera de calculer pour chaque article de la base le score td-idf.\n", "\n", "    2) La seconde \u00e9tape sera de trier ces scores du plus \u00e9lev\u00e9 au moins fort. "]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice 3 - Cat\u00e9gorisation automatique avec des m\u00e9thodes non supervis\u00e9es"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Avec ce que vous venez d'apprendre (le tf-idf), il est possible de cr\u00e9er un mod\u00e8le de cat\u00e9gorisation automatique \"non-supervis\u00e9\". Ce terme barbare signifie que l'on peut cr\u00e9\u00e9r des tags \u00e0 partir des seules variables explicatives, sans utiliser de \"label\", c'est-\u00e0-dire de donn\u00e9es qui valident si la pr\u00e9diction (ici, pr\u00e9sence de tel ou tel mot dans les tags) est correcte. Normalement, on utilise ce genre de m\u00e9thode quand on a pas de labels et que l'on cherche \u00e0 faire ressortir des r\u00e9gularit\u00e9s (des patterns) dans les donn\u00e9es. D'autres m\u00e9thodes de machine learning non-supervis\u00e9es connues sont : le clustering, les ACP."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Pour bien comprendre le tf-idf, on vous l'a fait coder \"\u00e0 la main\". En r\u00e9alit\u00e9, c'est tellement classique, qu'il existe des librairies qui l'ont d\u00e9j\u00e0 cod\u00e9. Voir [scikitlearn.feature_extraction.text](http://scikit-learn.org/stable/modules/feature_extraction.html#text-feature-extraction)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["L'id\u00e9e est la suivante : on va retenir comme \"tags\", les 3 mots les plus \"caract\u00e9ristiques\" d'un document. C'est-\u00e0-dire, les mots correspondants aux 3 scores tf-idf les plus \u00e9lev\u00e9s."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Les \u00e9tapes \u00e0 suivre : \n", "- transformer les mots en vecteurs. L'id\u00e9e est de cr\u00e9er une matrice, avec en ligne les documents, en colonne les mots possibles (prendre tous le smots uniques pr\u00e9sents dans l'ensemble des documents). Cela se fait en 3 lignes de code, voir la documentation [scikitlearn.feature_extraction.text](http://scikit-learn.org/stable/modules/feature_extraction.html#text-feature-extraction)\n", "- calculer les tf-idf normalis\u00e9s\n", "- r\u00e9cup\u00e9rer les indices dont les mots ont le score le plus \u00e9lev\u00e9 : voir la m\u00e9thode [argsort](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.argsort.html)\n", "- r\u00e9cup\u00e9rer la correspondance mots et indices\n", "- r\u00e9cup\u00e9rer les 3 mots les plus caract\u00e9ristiques, et comparer aux tags de la table df_pocket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["# Approche contextuelle"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Les approches bag-of-words, bien que simplistes, permettent de cr\u00e9er, d'indexer et de comparer des documents. La prise en compte des suites de 2, 3 ou plus mots serait un moyen d'affiner de tels mod\u00e8les. Cela permet aussi de mieux comprendre le sens des homonymes, et des phrases (d'une mani\u00e8re g\u00e9n\u00e9rale, la s\u00e9mantique).\n", "\n", "nltk offre des methodes pour tenir compte du contexte : pour ce faire, nous calculons les n-grams, c'est-\u00e0-dire l'ensemble des co-occurrences successives de mots deux-\u00e0-deux (bigrams), trois-\u00e0-trois (tri-grams), etc. \n", "\n", "En g\u00e9n\u00e9ral, on se contente de bi-grams, au mieux de tri-grams : \n", "- les mod\u00e8les de classification, analyse du sentiment, comparaison de documents, etc. qui comparent des n-grams avec n trop grands sont rapidement confront\u00e9s au probl\u00e8me de donn\u00e9es sparse, cela r\u00e9duit la capacit\u00e9 pr\u00e9dictive des mod\u00e8les ; \n", "- les performances d\u00e9croissent tr\u00e8s rapidement en fonction de n, et les co\u00fbts de stockage des donn\u00e9es augmentent rapidement (environ n fois plus \u00e9lev\u00e9 que la base de donn\u00e9e initiale)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["r\u00e9f\u00e9rence : [introduction \u00e0 nltk](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/notebooks/td2a_TD5_Traitement_automatique_des_langues_en_Python.html#introduction-a-nltk) \n", "\n", "\n", "Dans cette partie, nous allons nous int\u00e9resser au nombre d'occurences et de co-occurences des termes dans les articles de la base pocket. Pour cela, nous utilisons les m\u00e9thodes disponibles dans le package nltk"]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": ["import re, nltk\n", "#Tokenisation na\u00efve sur les espaces entre les mots => on obtient une liste de mots\n", "tokens = re.split('\\s+', ' '.join(df_pocket['words_string']))"]}, {"cell_type": "code", "execution_count": 27, "metadata": {"scrolled": true}, "outputs": [], "source": ["#On transforme cette liste en objet nltk \"Text\" (objet chaine de caract\u00e8re qui conserve la notion de tokens, et qui \n", "#comprend  un certain nombre de m\u00e9thodes utiles pour explorer les donn\u00e9es.\n", "text = nltk.Text(tokens)"]}, {"cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [{"data": {"text/plain": ["[('grafikart', 1),\n", " ('tutoriels', 1),\n", " ('cordova', 1),\n", " ('ionic', 4),\n", " ('framework', 8),\n", " ('tutoriel', 3),\n", " ('vido', 7),\n", " ('apache', 6),\n", " ('cordovaionic', 2),\n", " ('va', 5),\n", " ('permettre', 1),\n", " ('crer', 3),\n", " ('applications', 17),\n", " ('mobiles', 1),\n", " ('utilisant', 1),\n", " ('technologies', 8),\n", " ('web', 39),\n", " ('base', 2),\n", " ('cela', 3),\n", " ('dautres', 3),\n", " ('frameworks', 3),\n", " ('fait', 6),\n", " ('leurs', 1),\n", " ('preuves', 1),\n", " ('avant', 1),\n", " ('pouvoir', 1),\n", " ('commencer', 2),\n", " ('faut', 1),\n", " ('videmment', 1),\n", " ('installer', 1),\n", " ('loutil', 1),\n", " ('petit', 3),\n", " ('tour', 3),\n", " ('propritaire', 1),\n", " ('la', 16),\n", " ('compilation', 1),\n", " ('colorhunt', 2),\n", " ('color', 10),\n", " ('hunt', 5),\n", " ('home', 12),\n", " ('create', 30),\n", " ('likes', 2),\n", " ('about', 8),\n", " ('add', 13),\n", " ('to', 14),\n", " ('chrome', 9),\n", " ('facebook', 17),\n", " ('thanks', 7),\n", " ('your', 26),\n", " ('scheme', 4)]"]}, "execution_count": 29, "metadata": {}, "output_type": "execute_result"}], "source": ["## la m\u00e9thode vocab permet d'obtenir pour chaque terme pr\u00e9sent dans la liste text nltk, le nombre d'occurence des termes\n", "## ici on cr\u00e9e le dictionnaire fdist\n", "\n", "fdist = text.vocab()\n", "\n", "list(fdist.items())[:50]"]}, {"cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Exemples d'occurences du terme 'python' :\n", "Displaying 25 of 52 matches:\n", "wed hunters jakevdp core dataframes python outofcore dataframes python dask op\n", "aframes python outofcore dataframes python dask openstreetmap in recent months\n", "ckages announced working data scale python for excellent entertaining summary \n", "mary id suggest watching rob storys python data bikeshed talk pydata seattle c\n", "alab ab testing hierarchical models python ab testing hierarchical models pyth\n", "thon ab testing hierarchical models python in post i discuss method ab testing\n", "te nltk tokenization nltk librairie python trs utile manipuler texte market ma\n", "s qbox building elasticsearch index python build elasticsearch index pythonmac\n", "volving world media mikesboyle post python nltk wtf chapter notes things pytho\n", "ython nltk wtf chapter notes things python nltk wtf chapter notes things dont \n", "orpus linguistics fan learning code python excellent online tutorial called na\n", " called natural language processing python book buy case feel bit freeloader p\n", "n book buy case feel bit freeloader python nltk wtf chapter notes things dont \n", " a fast ondisk format data frames r python powered apache arrow this past janu\n", "discussed systems challenges facing python r open source communities feather a\n", " a fast ondisk format data frames r python powered apache arrow about rstudio \n", "ack last updated september tryolabs python elasticsearch steps python elastics\n", "tryolabs python elasticsearch steps python elasticsearch first steps lately tr\n", "ommunity tutorials install anaconda python distribution ubuntu how to install \n", "tion ubuntu how to install anaconda python distribution ubuntu anaconda openso\n", "er environment manager distribution python r programming languages report bug \n", " for many cases writing pandas pure python numpy sufficient in computationally\n", "ns evaluated numexpr must evaluated python space transparently user this done \n", "ing experience writing applications python flask microframework categories wha\n", "enchwebfr frenchweb jobs dveloppeur python startup hf les dernires offres demp\n", "\n", "\n"]}], "source": ["# Une autre m\u00e9thode \"concordance\" : montre les occurences d'un mot dans son contexte\n", "print(\"Exemples d'occurences du terme 'python' :\")\n", "text.concordance(\"python\")\n", "print('\\n')"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice  4 - Occurences dans Pocket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["1) Calculer le nombre de mots et de mots uniques\n", "\n", "Astuce : utiliser l'object fdist qui donne la fr\u00e9quence de distribution de chaque terme."]}, {"cell_type": "markdown", "metadata": {}, "source": ["2) Calculer trouver les termes suivants et leur contexte : \n", "- github\n", "- data"]}, {"cell_type": "markdown", "metadata": {}, "source": ["3) Trouvez les 100 mots les plus fr\u00e9quents "]}, {"cell_type": "markdown", "metadata": {}, "source": ["4) Trouvez les 100 mots les plus fr\u00e9quents (sans les stopwords)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["5) Trouvez les co-occurences les plus fr\u00e9quentes en utilisant la m\u00e9thode collocations()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice 5 - cat\u00e9gorisation automatique non supervis\u00e9e avec contexte : LDA"]}, {"cell_type": "markdown", "metadata": {}, "source": ["S'inspirer de [LDA](http://blog.echen.me/2011/08/22/introduction-to-latent-dirichlet-allocation/) et [un exemple de LDA](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/notebooks/td2a_some_nlp.html#lda) et proposer une cat\u00e9gorisation automatique des documents. Comparer aux tags initiaux."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice 6 - cat\u00e9gorisation automatique supervis\u00e9e sans avec contexte : classification binaire"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Lire le notebook sur les [rep\u00e8res en machine learning](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/specials/machine_learning.html#hyperparametres). S'inspirer de ce [notebook](http://www.xavierdupre.fr/app/ensae_teaching_cs/helpsphinx/ml_basic/plot_binary_classification.html#sphx-glr-ml-basic-plot-binary-classification-py) et pr\u00e9dire les tags avec un mod\u00e8le logit."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Choisir de tenir compte du contexte (features en bi-grams, ou tri-grams) ou non en fonction des r\u00e9sultats d'un [Gridsearch](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html). "]}], "metadata": {"anaconda-cloud": {}, "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.9.5"}}, "nbformat": 4, "nbformat_minor": 2}