{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# TD7 - Analyse de texte \n", "\n", "Analyse de texte, TF-IDF, LDA, moteur de recherche, expressions r\u00e9guli\u00e8res."]}, {"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": {"scrolled": false}, "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: tqdm in c:\\python395_x64\\lib\\site-packages (from nltk) (4.62.3)\n", "Requirement already satisfied: click in c:\\python395_x64\\lib\\site-packages (from nltk) (8.0.1)\n", "Requirement already satisfied: joblib in c:\\python395_x64\\lib\\site-packages (from nltk) (1.1.0)\n", "Requirement already satisfied: regex>=2021.8.3 in c:\\python395_x64\\lib\\site-packages (from nltk) (2022.1.18)\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": ["{'after', 'more', 'ought', 'only', 'not', 'were', \"weren't\", 'in', 'if', 'why', 'hence', \"i'd\", 'just', 'there', 'ever', 'by', 'other', 'nor', 'some', 'does', \"shouldn't\", \"couldn't\", 'herself', 'her', 'me', 'very', \"shan't\", 'our', 'are', 'r', 'that', \"can't\", \"we've\", \"we'd\", \"what's\", 'most', \"let's\", \"you'd\", 'an', 'himself', 'www', 'i', 'had', 'while', 'being', 'such', 'doing', 'for', \"hasn't\", 'where', \"she'll\", 'between', 'this', 'k', \"i'll\", 'ours', \"they've\", 'each', \"when's\", 'these', \"it's\", \"where's\", 'having', 'through', 'them', \"mustn't\", \"they're\", 'those', \"haven't\", 'she', 'during', 'above', 'do', \"wouldn't\", \"i've\", 'itself', 'be', \"wasn't\", 'about', 'no', 'could', 'com', \"who's\", 'a', 'from', 'or', 'off', \"she'd\", \"won't\", 'they', 'have', \"she's\", 'any', 'into', 'his', 'over', \"we'll\", 'who', 'also', 'as', 'too', 'themselves', 'before', 'both', 'all', 'been', 'further', 'would', 'yourselves', 'it', \"you've\", 'did', 'otherwise', 'can', 'http', \"he's\", 'has', \"we're\", 'on', 'else', 'what', 'therefore', 'your', 'because', 'myself', 'should', \"you're\", 'once', \"there's\", 'whom', 'like', 'their', \"hadn't\", 'until', 'which', \"they'll\", 'am', 'then', \"aren't\", 'yourself', 'theirs', 'here', \"didn't\", 'under', 'hers', \"here's\", 'get', 'you', \"you'll\", 'with', 'same', 'since', 'own', 'and', 'its', 'shall', 'out', \"isn't\", 'at', \"doesn't\", 'to', \"i'm\", \"that's\", \"they'd\", 'few', 'when', 'we', 'the', 'than', 'again', \"how's\", 'against', \"why's\", 'below', \"don't\", 'up', 'yours', 'him', \"he'll\", 'was', 'so', 'he', 'but', 'down', 'my', 'how', 'of', 'ourselves', \"he'd\", 'cannot', 'is', 'however'}\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": {"scrolled": false}, "outputs": [{"data": {"text/plain": ["['after',\n", " 'ought',\n", " 'youtube',\n", " 'ma',\n", " 'seriez',\n", " 'not',\n", " 'eusse',\n", " 'il',\n", " 'les',\n", " 'avais',\n", " 'doesn',\n", " 'avait',\n", " 'if',\n", " 'html',\n", " 'f\u00fbt',\n", " 'elle',\n", " \"i'd\",\n", " 'ait',\n", " '\u00e9taient',\n", " 'by',\n", " 'other',\n", " 'nor',\n", " 'le',\n", " 'aux',\n", " 'shan',\n", " 'edu',\n", " \"shouldn't\",\n", " 'will',\n", " \"couldn't\",\n", " 'et',\n", " 'her',\n", " '\u00e9tant',\n", " 'news',\n", " \"shan't\",\n", " 'avez',\n", " 'our',\n", " 'are',\n", " 'r',\n", " 'fussions',\n", " \"we've\",\n", " 'mais',\n", " \"we'd\",\n", " 'dans',\n", " \"what's\",\n", " 'most',\n", " \"let's\",\n", " 'par',\n", " 'pas',\n", " 'aient',\n", " 'eurent',\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": [{"name": "stdout", "output_type": "stream", "text": ["%pylab is deprecated, use %matplotlib inline and import the required libraries.\n", "Populating the interactive namespace from numpy and matplotlib\n"]}], "source": ["%pylab 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", "plt.imshow(wordcloud)\n", "plt.axis('off')\n", "plt.show()"]}, {"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": ["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": {"scrolled": false}, "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)]"]}, "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())[:30]"]}, {"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}