TPFakeNews.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fVNE4BGIsOlY"
   },
   "source": [
    "# Classement automatique de textes par réseau de neurones\n",
    "\n",
    "L’objectif de ce TP est de développer un modèle de prédiction de fakenews à partir d’un apprentissage automatique par réseau de neurones et d'une représentation en sac de mots (bag of words)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QQ5vas82illV"
   },
   "source": [
    "## Ensemble de données \n",
    "Le TP utilisera un ensemble de données issues du site de dépôt de *dataset* [Kaggle](https://www.kaggle.com/datasets).\n",
    "\n",
    "Plus précisément, vous utiliserez le *dataset* [\"Fake News Dataset\"](https://www.kaggle.com/datasets/pnkjgpt/fake-news-dataset).\n",
    "\n",
    "Ce *dataset* contient des exemples de news classées en tant que réelles et fausses.\n",
    "\n",
    "Deux jeux de données sont proposés : un ensemble d'[exemples d'entrainement](train.csv) et un ensemble d'[exemples de tests](test.csv) mais sans label, donc a priori inutiles.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AWFXrAtkvcg_"
   },
   "source": [
    "---\n",
    "Si vous utilisez Colab, vous devrez charger vos fichiers de données dans votre 'Drive' Google.\n",
    "\n",
    "Pour pouvoir les utiliser, il vous faut monter le répertoire 'drive' pour qu'il soit accessible par Colab.\n",
    "Exécutez le code suivant,  une clé vous sera demandée. Il vous suffit de suivre le lien, de sélectionner votre profile pour obtenir votre clé que vous copierez dans le champs prévu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 74
    },
    "colab_type": "code",
    "id": "4TodTL602bBv",
    "outputId": "cbc50963-1484-4189-b87b-b0d7d60af79c"
   },
   "outputs": [],
   "source": [
    "#bloc à exécuter si vous utilisez colab\n",
    "from google.colab import drive, files\n",
    "\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3IlL2ANmisdv"
   },
   "source": [
    "---\n",
    "## Préparation des données\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creations des fichiers de données\n",
    "\n",
    "Les données utilisés des exemples d'entraînements sont les colonnes 'text' et 'class'.\n",
    "Le but est de créer et d'entraîner un réseau à faire correspondre un texte anglais à une classe 'Fake' ou 'Real'.\n",
    "\n",
    "Il s'agit de créer, à partir du fichier , deux ensembles : l'un contenant les texte liés aux informations 'real' et l'autre lié aux informations 'fake'.\n",
    "\n",
    "Il existe plusieurs manière de faire : en passant par la librairie Panda, très performante; ou manuellement.\n",
    "\n",
    "Si vous ne connaissez pas la suite Panda, procédez manuellement : à partir du fichier contenant les tables, triez les lignes par ordre de 'class'; puis créez 2 fichiers textes à partir de la colonne 'text'. \n",
    "L'un contenant les news classées reelles (reellesnews.txt par exemple) et l'autre news classees fake (fakenews.txt par exemple).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Réduction des exemples\n",
    "Le nombre de mots utilisés le vocabulaire, étant assez vaste; on le réduit dans un premier temps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oiHdx0y1i8Bi"
   },
   "source": [
    "### Création du vocabulaire utile\n",
    "\n",
    "En chargeant l'ensemble des lignes contenues dans les fichers texte, on crée un vocabulaire des mots utiles en :   \n",
    "  - identifiant les termes (**tokens**) entre espaces,\n",
    "  - supprimant toute ponctuation,\n",
    "  - supprimant tous les mots qui ne sont pas uniquement composés de caractères alphabétiques,\n",
    "  - supprimant tous les mots reconnus en tant que mots vides (stop words) (mots de liaison) français & anglais\n",
    "  - supprimant tous les mots dont la longueur est <= 2 caractères (par exemple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chargement et nettoyage des données\n",
    "\n",
    "Il convient pour chaque fichier texte de créer le  \n",
    "  - identifier les termes (**tokens**) entre espaces,\n",
    "  - supprimer toute ponctuation,\n",
    "  - supprimer tous les mots qui ne sont pas uniquement composés de caractères alphabétiques,\n",
    "  - supprimer tous les mots reconnus en tant que mots vides (stop words) (mots de liaison) français & anglais\n",
    "  - supprimer tous les mots dont la longueur est <= 2 caractères (sauf IA, AI)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SLWxuYAjxPlo"
   },
   "source": [
    "### Les bibliothèques\n",
    "La préparation des données implique de pouvoir accéder au système de fichier, ainsi qu'à la bibliothèque nltk et aux bibliothèques spécialisées dans le traitement de texte.. : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tSqBXmHvxnhF"
   },
   "outputs": [],
   "source": [
    "##import pour les fichiers et le traitement de données : \n",
    "from os import listdir\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from string import punctuation\n",
    "from collections import Counter\n",
    "##import pour les réseaux de neurones : \n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras import preprocessing\n",
    "from numpy import array, zeros\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "n6qZZ-VJw8Wy",
    "outputId": "1c8e7c95-f0ba-4f69-9914-c034c7f534cc"
   },
   "outputs": [],
   "source": [
    "rep = '/content/drive/My Drive/Colab Notebooks' ## ICI VOTRE REPERTOIRE DE TRAVAIL SUR Le DRIVE\n",
    "#rep = '/MonRepertoire/TPIA/' ## OU AVEC UN JUPYTERLAB OU NOTEBOOK LOCAL, VOTRE REPERTOIRE DE TRAVAIL LOCAL \n",
    "\n",
    "# le code suivant charge l'ensemble des mots non importants \n",
    "nltk.download(\"stopwords\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonctions de lectures et d'\"épurage\" de fichier texte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "by0--ITCi-xa"
   },
   "outputs": [],
   "source": [
    "def load_doc(filename:str)->list:\n",
    "    \"\"\"retourne les lignes de texte du fichier filename\"\"\"\n",
    "    # open the file as read only\n",
    "    with open(filename) as file:\n",
    "        text = file.read().splitlines() \n",
    "    return text\n",
    "\n",
    " \n",
    "def clean_doc(doc)->list:\n",
    "    \"\"\"retourne la liste de mots clés inclus dans le texte doc \n",
    "    qui ne font pas parti des stop_words anglais et francais\n",
    "    retire d autres mots cles comme 'vers', 'lors' , ..\"\"\"\n",
    "    tokens = doc.lower()\n",
    "    tokens = tokens.split()\n",
    "    # retrait des signes de ponctuation\n",
    "    table = str.maketrans('', '', punctuation)\n",
    "    tokens = [w.translate(table) for w in tokens]\n",
    "    # retrait des termes qui ne contiennent pas que des lettres\n",
    "    tokens = [word for word in tokens if word.isalpha()]\n",
    "    # retrait des mots de liaisons et juges non signifiants (appeles stopwords)\n",
    "    stop_words = set(stopwords.words('english'))\n",
    "    tokens = [w for w in tokens if not w in stop_words]\n",
    "    # retrait des mots de moins de deux caractères\n",
    "    tokens = [word for word in tokens if len(word) > 2]\n",
    "    # retrait de certains mots pouvant fausser l'apprentissage (reuters ici car il indique la provenance d'une source sérieuse)\n",
    "    tokens = [word for word in tokens if word!=\"reuters\"]\n",
    "    # TODO:COMPLETEZ A VOTRE CONVENANCE LA SELECTION DE TOKENS UTILES OU LEURS MODIFICATIONS\n",
    "    return tokens\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UgALvdrLKOD3"
   },
   "source": [
    "### Tests de la récupération de mots clés d'un fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 125
    },
    "colab_type": "code",
    "id": "0CpapoCR0Hzs",
    "outputId": "23a01def-2b8c-4fef-e689-1289a90d2d61"
   },
   "outputs": [],
   "source": [
    "def test_recup():\n",
    "    # mots clés du fichier des news reelles\n",
    "    filename = rep + '/reellesnews.txt'\n",
    "    lines = load_doc(filename)\n",
    "    text = ' '.join(lines)\n",
    "    tokens = clean_doc(text)\n",
    "    print('les 10 premiers mots cles de ', filename)\n",
    "    print(tokens[:10])\n",
    "    # mots clés du fichier des fake news\n",
    "    filename = rep + '/fakenews.txt'\n",
    "    lines = load_doc(filename)\n",
    "    text = ' '.join(lines)\n",
    "    tokens = clean_doc(text)\n",
    "    print('les 10 premiers mots cles de ', filename)\n",
    "    print(tokens[:10])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "les 10 premiers mots cles de  /Users/emmanueladam/Documents/GitHub/IntelligenceArtificiellePython//reellesnews.txt\n",
      "['reuter', 'reporter', 'love', 'reuter', 'voter', 'rallie', 'voter', 'politic', 'democrat', 'election']\n",
      "les 10 premiers mots cles de  /Users/emmanueladam/Documents/GitHub/IntelligenceArtificiellePython//fakenews.txt\n",
      "['democrat', 'allie', 'voter', 'senator', 'admission', 'protect', 'worker', 'taxpayer', 'arkansa', 'republican']\n"
     ]
    }
   ],
   "source": [
    "test_recup()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1yo75YEIjWIT"
   },
   "source": [
    "### Construire le vocabulaire global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Axlsvtg8jhAr"
   },
   "outputs": [],
   "source": [
    "def add_doc_to_vocab(filename, vocab):\n",
    "    \"\"\"cumule dans la liste vocab les mots du fichier filename \n",
    "    (1 seule occurence par mot dans vocab)\"\"\"\n",
    "    # load doc\n",
    "    lines = load_doc(filename)\n",
    "    doc = ' '.join(lines)\n",
    "    # clean doc\n",
    "    tokens = clean_doc(doc)\n",
    "    # update counts\n",
    "    vocab.update(tokens)\n",
    "\n",
    "def create_global_vocabulary():\n",
    "    \"\"\"creer un vocabulaire (liste de mots clés associés à leurs occurences)\n",
    "    par la suite, un mot d'un texte ne faisant pas partie du vocabulaire ne sera\n",
    "    pas compte\"\"\"\n",
    "    vocab = Counter()\n",
    "    # ajouter les mots cles des fichiers\n",
    "    add_doc_to_vocab(rep+'/reellesnews.txt', vocab)\n",
    "    add_doc_to_vocab(rep+'/fakenews.txt', vocab)\n",
    "\n",
    "    # afficher le nb de mots cles trouves\n",
    "    print(\"nb de mots cles trouves dans les repertoires : \", len(vocab))\n",
    "    print(\"les 10 premiers mots cles du vocabulaire \\\n",
    "    (et leur nb d\\'apparition dans les exemples)  : \\n\", end='')\n",
    "    i=0\n",
    "    for (mot,count) in vocab.items(): \n",
    "        print(mot,':',count,end=\", \")\n",
    "        i = i+1\n",
    "        if i>10:break\n",
    "    # afficher les 10 mots cles les plus utilises\n",
    "    print(\"\\nles 10 mots cles les plus utilises : \", vocab.most_common(10))\n",
    "\n",
    "    # ne garder que les mots clés apparaissant au moins X fois\n",
    "    # l'objectif est d'obtenir le vocabulaire le plus petit (au moins <8000 si utilisation de collab)\n",
    "    # possible et qu'il soit efficace\n",
    "    min_occurrence = 200\n",
    "    tokens = [token for (token,count) in vocab.items() if count >= min_occurrence]\n",
    "    print('en otant les mots utilise moins de ', min_occurrence, ' fois,', \n",
    "          ' nb de mots cles = ',len(tokens))\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Sauvegarde du vocabulaire\n",
    "def save_list(lines, filename):\n",
    "    \"\"\"sauve les mots de la liste lines dans le fichier filename\"\"\"\n",
    "    # open file\n",
    "    file = open(filename, 'w')\n",
    "    data = '\\n'.join(lines)\n",
    "    # write text\n",
    "    file.writelines(data)\n",
    "    # close file\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EDFdsl97jq0t"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nb de mots cles trouves dans les repertoires :  4291\n",
      "les 10 premiers mots cles du vocabulaire     (et leur nb d'apparition dans les exemples)  : \n",
      "reuter : 665, reporter : 138, love : 13, voter : 160, rallie : 24, politic : 84, democrat : 238, election : 87, state : 586, time : 164, date : 7, \n",
      "les 10 mots cles les plus utilises :  [('reuter', 665), ('state', 586), ('new', 447), ('year', 358), ('republican', 318), ('official', 299), ('say', 266), ('democrat', 238), ('congres', 230), ('member', 207)]\n",
      "en otant les mots utilise moins de  2  fois,  nb de mots cles =  2391\n"
     ]
    }
   ],
   "source": [
    "## A la 1ere utilisation, et a chaque modification des fichiers de données\n",
    "tokens = create_global_vocabulary()\n",
    "save_list(tokens, 'vocabNews.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Réduction des entrées\n",
    "Chaque entrée texte peut être maintenant simplifiée. \n",
    "Pour chaque entrée, on extrait les tokens qui ne sont pas présents dans le vocabulaire utile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_line(line, vocab)->list:\n",
    "    \"\"\"retourne la liste des mots cles de la ligne appartenant au vocabulaire vocab\"\"\"\n",
    "    # clean line\n",
    "    tokens = clean_doc(line)    \n",
    "    # filter by vocab\n",
    "    tokens = [token for token in tokens if token in vocab]\n",
    "    return ' '.join(tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour chaque fichier d'exemples, on en retire deux listes de lignes épurées, une liste contenant 90% des exemples, et une autre 10%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_train_file(filenametrain, vocab)->list:\n",
    "    \"\"\"retourne la listes des lignes epurees a partir du fichier 'filenametrain' \"\"\"\n",
    "    lines_train = list()\n",
    "    i=1\n",
    "    lines = list()\n",
    "    # load and clean the file\n",
    "    with open(filenametrain) as file:\n",
    "        lines = file.read().splitlines()\n",
    "    filtered_lines = [filter_line(line, vocab) for line in lines]\n",
    "    return filtered_lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nb exemples d'entrainement positifs :  450\n",
      "nb exemples d'entrainement negatifs :  449\n",
      "nb exemples de tests positifs :  51\n",
      "nb exemples de tests negatifs :  50\n"
     ]
    }
   ],
   "source": [
    "# SI le vocabulaire n'a ete cree dans cette session mais avant ALORS le charger\n",
    "vocab_filename = 'vocabNews.txt'\n",
    "vocab = load_doc(vocab_filename)\n",
    "vocab = set(vocab)\n",
    "# creer les lignes epurees\n",
    "positive_lines_train = process_train_file(rep+'/reellesnews.txt', vocab)\n",
    "negative_lines_train = process_train_file(rep+'/fakenews.txt', vocab)\n",
    "# summarize what we have\n",
    "print(\"nb exemples d'entrainement positifs : \", len(positive_lines_train))\n",
    "print(\"nb exemples d'entrainement negatifs : \", len(negative_lines_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "v2oK8x7bj5CU"
   },
   "source": [
    "---\n",
    "## Représentation en sac de mots\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wdd9RpBskGUy"
   },
   "source": [
    "### Convertir les exemples en vecteurs\n",
    "Chaque exemple doit être transformé dans un vecteur de même format.\n",
    "On recrée un vocabulaire des mots présents dans les exemples; puis pour chaque exemple, on crée un vecteur de 0, 1 (1 si le ie mot du vocabulaire existe dans l'exemple).\n",
    "\n",
    "Ainsi tous les exemples de ligne sont transformés en vecteurs de même dimension.\n",
    "\n",
    "On utilise pour cela un \"Tokenizer\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the tokenizer\n",
    "tokenizer = keras.preprocessing.text.Tokenizer()\n",
    "# build the training doc based on training data\n",
    "training_doc = list()\n",
    "training_doc.extend(positive_lines_train)\n",
    "training_doc.extend(negative_lines_train)\n",
    "# ask to the tokenizer to build the bag of words : a set of (word, use)*\n",
    "tokenizer.fit_on_texts(training_doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Il ne reste plus qu'à\" demander au 'Tokenizer' de réaliser la transformation des exemples d'entraînement en vecteurs d'entraînement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Xtrain contient  899  exemples de  2340  valeurs\n",
      "une valeur = fréquence d'apparition des mots dans le vocabulaire global.\n",
      "Ainsi, premier exemple d'entrainement = \n",
      " [0.         0.33333333 0.         ... 0.         0.         0.        ]\n"
     ]
    }
   ],
   "source": [
    "xTrain = tokenizer.texts_to_matrix(training_doc, mode='freq')\n",
    "##TODO: regarder les autres modes que freq; par exemple 'bin', qu'apportent-ils ?\n",
    "print('Xtrain contient ', xTrain.shape[0], ' exemples de ', xTrain.shape[1], ' valeurs')\n",
    "print('une valeur = fréquence d\\'apparition des mots dans le vocabulaire global.')\n",
    "print('Ainsi, premier exemple d\\'entrainement = \\n', xTrain[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Création des sorties\n",
    "Les premiers vecteurs représente des exemples positifs. On crée une sortie constituée d'autant de valeurs [1] suivie de valeurs [0]. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ytrain = suite de (0 (classement pour eval positive),  1 (classements pour éval négative))\n",
    "yTrain = zeros(len(positive_lines_train)+len(negative_lines_train))\n",
    "yTrain[:len(positive_lines_train)] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mCJRY1mTlnls"
   },
   "source": [
    "---\n",
    "## Modèle de réseau pour l'analyse des theses\n",
    "Le réseau contient en couche d'entrée aurant de neurones que de tokens retenus. \n",
    "Chaque exemple est codé sous forme d'une suite de 0 ou 1, d'une dimension égale au vocabulaire retenu.\n",
    "\n",
    "xTrain est donc une matrice de n exemples x m colonnes. m étant la dimension des vecteurs d'entrée, c-a-d le nombre de mots finalement pris en comptes, et donc le nombre de neurones de la 1er couche du réseau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uruPxsQil-gZ"
   },
   "outputs": [],
   "source": [
    "# nb de neurones en entrée (= nb de tokens retenus)\n",
    "## shape[0] est la 1ere dimension d'un tableau (ici le nb d'exemples)\n",
    "## shape[1] est la 1ere dimension d'un tableau (ici le nb de tokens)\n",
    "n_words = xTrain.shape[1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "67M4JqX2lNeu"
   },
   "outputs": [],
   "source": [
    "# TODO: définir la structure du réseau\n",
    "model = Sequential()\n",
    "## A VOUS !!!!!\n",
    "##TODO: regarder les autres exemples de creation de réseaux de neurones et creez le votre\n",
    "...\n",
    "...\n",
    "# compile network \n",
    "model.compile(### A VOUS .....\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rlYk8aKemF9b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "29/29 - 2s - loss: 0.7572 - accuracy: 0.8365 - val_loss: 0.5943 - val_accuracy: 0.9010 - 2s/epoch - 58ms/step\n",
      "Epoch 2/10\n",
      "29/29 - 1s - loss: 0.5335 - accuracy: 0.9722 - val_loss: 0.6139 - val_accuracy: 0.8812 - 1s/epoch - 45ms/step\n",
      "Epoch 3/10\n",
      "29/29 - 1s - loss: 0.5175 - accuracy: 0.9811 - val_loss: 0.6261 - val_accuracy: 0.8713 - 1s/epoch - 44ms/step\n",
      "Epoch 4/10\n",
      "29/29 - 1s - loss: 0.5098 - accuracy: 0.9889 - val_loss: 0.6205 - val_accuracy: 0.8713 - 1s/epoch - 44ms/step\n",
      "Epoch 5/10\n",
      "29/29 - 1s - loss: 0.5476 - accuracy: 0.9511 - val_loss: 0.6545 - val_accuracy: 0.8416 - 1s/epoch - 44ms/step\n",
      "Epoch 6/10\n",
      "29/29 - 1s - loss: 0.5133 - accuracy: 0.9867 - val_loss: 0.6634 - val_accuracy: 0.8317 - 1s/epoch - 44ms/step\n",
      "Epoch 7/10\n",
      "29/29 - 1s - loss: 0.5162 - accuracy: 0.9844 - val_loss: 0.5948 - val_accuracy: 0.9010 - 1s/epoch - 44ms/step\n",
      "Epoch 8/10\n",
      "29/29 - 1s - loss: 0.5090 - accuracy: 0.9911 - val_loss: 0.6238 - val_accuracy: 0.8713 - 1s/epoch - 44ms/step\n",
      "Epoch 9/10\n",
      "29/29 - 1s - loss: 0.5065 - accuracy: 0.9933 - val_loss: 0.6134 - val_accuracy: 0.8812 - 1s/epoch - 44ms/step\n",
      "Epoch 10/10\n",
      "29/29 - 1s - loss: 0.5068 - accuracy: 0.9922 - val_loss: 0.6337 - val_accuracy: 0.8614 - 1s/epoch - 44ms/step\n"
     ]
    }
   ],
   "source": [
    "#TODO: tester differents nb de tests (epochs), steps_per_epoch, batch_size, .....\n",
    "#TODO: expliquer ce que sont les paramètres steps_per_epoch, batch_size, validation_split\n",
    "history = model.fit(xTrain, yTrain,\n",
    "                    batch_size=500,\n",
    "                    steps_per_epoch=10,\n",
    "                    validation_split = 0.01,\n",
    "                    epochs=10, verbose=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dessiner l'évolution de l'erreur et de la pertinence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history_dict = history.history\n",
    "history_dict.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tracer l'erreur d'entrainement / l'erreur de validation\n",
    "- L'erreur d'entrainement et l'erreur de validation doivent suivre des courbes quasi parallèle.\n",
    "- L'erreur d'entrainement doit être plus faible que l'erreur de validation\n",
    "    - si les courbes divergent, si la courbe de validation s'éloigne de la courbe d'entrainement, il y a alors un sur-apprentissage (overfitting) trop adapté aux données d'entrainement, sans doute trop poussé (diminuer les epochs?).\n",
    "    - s'il y a une erreur d'entrainement trop grande, il y a sous-apprentissage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "epochs = range(1, len(loss) + 1)\n",
    "\n",
    "# draw the loss evolution in blue\n",
    "plt.plot(epochs, loss, 'b-*', label='erreur sur exemples d\\'apprentissage')\n",
    "# draw the accuracy evolution in blue\n",
    "plt.plot(epochs, val_loss, 'r-*', label='erreur sur exemples de validation')\n",
    "plt.title('Erreur')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Erreur')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history_dict['accuracy']\n",
    "val_acc = history_dict['val_accuracy']\n",
    "\n",
    "epochs = range(1, len(loss) + 1)\n",
    "\n",
    "# draw the loss evolution in blue\n",
    "plt.plot(epochs, acc, 'b-*', label='précision sur exemples d\\'apprentissage')\n",
    "# draw the accuracy evolution in blue\n",
    "plt.plot(epochs, val_acc, 'r-*', label='précision sur exemples de validation')\n",
    "plt.title('précision')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('précision')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### TensorBoard\n",
    "\n",
    "Maintenant,  <span style=\"background-color:yellow\">utilisez un \"TensorBoard\"</span> pour représenter les courbes d'apprentissage..\n",
    "(cf. exemple [Detection d'Alertes avec TensorBoard](https://github.com/EmmanuelADAM/IntelligenceArtificiellePython/blob/master/SolutionDetectionAlertesTensorBoard.ipynb) )\n",
    "\n",
    "(dupliquez votre fichier notebook pour en créer un nouveau)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "## <span style=\"color:red;background-color:yellow\">TRAVAIL A RENDRE</span>\n",
    "* Vous expliquerez le fonctionnement des paramètres  epochs, steps_per_epoch, batch_size, et leur impact sur la qualité de l'apprentissage\n",
    "* Vous devrez tester 5 différentes architectures de réseau (nb de couches), ainsi que différentes configurations (fonctions d'activation, méthodes d'optimisation, méthode de calcul de l'erreur, bach_size, ......), ainsi qu'au moins deux méthodes de création de sacs de mots (texts_to_matrix) en expliquant leurs fonctionnement\n",
    "* Tentez d'expliquer les différences de résultat\n",
    "* Vous enverrez un fichier pdf avec pour chaque configuration  :\n",
    "    * l'architecture du réseau (un copier coller du bloc 'TODO: définir la structure du réseau')\n",
    "    * le déroulé de l'apprentissage (un copier coller du graphique sur la précision)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Copie de TP_DeepLearningM1TNSI.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}