{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "54ec3e34",
   "metadata": {},
   "source": [
    "\n",
    "<a id='chap-tpfouilletexte'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8a3c37b",
   "metadata": {},
   "source": [
    "# Travaux pratiques - Fouille de textes 1 : SparkNLP et GloVe\n",
    "\n",
    "Références externes utiles :\n",
    "\n",
    "> - [Documentation SparkNLP (John Snow Labs)](https://nlp.johnsnowlabs.com/docs/en/annotators)  \n",
    "- [Modèles pré-entraînés SparkNLP](https://sparknlp.org/models)  \n",
    "- [Documentation API Spark en Python](https://spark.apache.org/docs/latest/api/python/index.html)  \n",
    "- [Site du projet GloVe](https://nlp.stanford.edu/projects/glove/)  \n",
    "\n",
    "\n",
    "\n",
    "**L'objectif** de cette séance est double. La première partie est une introduction à SparkNLP : construction d'un *pipeline* NLP (tokenisation, étiquetage morpho-syntaxique, lemmatisation, entités nommées) et observation des résultats sur un texte réel. La seconde partie met en œuvre la classification de textes avec des plongements lexicaux GloVe sur le jeu de données **AG News** de classification thématique de dépêches de presse en 4 catégories."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d96d96f",
   "metadata": {},
   "source": [
    "# Note\n",
    "\n",
    "SparkNLP télécharge des ressources (modèles pré-entraînés) depuis Internet lors de la première utilisation. Ces téléchargements peuvent prendre quelques minutes, surtout après le réveil des utilisateurs d'Amérique du nord. Il est possible de télécharger les ressources en amont pour une exécution hors connexion ([documentation offline](https://nlp.johnsnowlabs.com/docs/en/install#offline))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec01d9e0",
   "metadata": {},
   "source": [
    "# Note 2\n",
    "\n",
    "Pour pouvoir faire le TP sur une machine avec assez peu de ressources (le JupyterHub du Cnam alloue 1 cœur CPU et 4 Go de RAM à chacun.e) nous avons apporté des modifications au TP initial : forte réduction du nombre d'exemples, emploi des encodages les plus courts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325f7cbe",
   "metadata": {},
   "source": [
    "## Mise en place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ea1c6f0",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.system(\"mkdir -p tpFouilleTexte/data\")\n",
    "os.system(\"wget -q -nc https://raw.githubusercontent.com/mhjabreel/CharCnn_Keras/master/data/ag_news_csv/train.csv -O tpFouilleTexte/data/agnews_train.csv\")\n",
    "os.system(\"wget -q -nc https://raw.githubusercontent.com/mhjabreel/CharCnn_Keras/master/data/ag_news_csv/test.csv  -O tpFouilleTexte/data/agnews_test.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05b2f68b",
   "metadata": {},
   "source": [
    "Adaptation de la version de SparkNLP (>= 7) à celle de Spark (>= 4) :\n",
    "\n",
    "> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4afdc38d",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install spark-nlp==7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66394ae1",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import os, sys\n",
    "\n",
    "os.environ['PYSPARK_PYTHON'] = sys.executable\n",
    "os.environ['PYSPARK_DRIVER_PYTHON'] = sys.executable\n",
    "\n",
    "import sparknlp\n",
    "\n",
    "spark = sparknlp.start(\n",
    "        memory=\"2G\",  # défaut 16G -> garbage collector ne s'active pas avant épuisement mémoire\n",
    "        params={\n",
    "                \"spark.master\": \"local[2]\",      # au lieu de local[*]\n",
    "                \"spark.sql.shuffle.partitions\": \"4\",\n",
    "                \"spark.kryoserializer.buffer.max\": \"256m\",\n",
    "        })\n",
    "sc = spark.sparkContext\n",
    "print(sc.getConf().get(\"spark.driver.memory\"), sc.defaultParallelism)\n",
    "\n",
    "print(\"SparkNLP version :\", sparknlp.version())\n",
    "print(\"Spark version    :\", spark.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ed00bf3",
   "metadata": {},
   "source": [
    "\n",
    "### Partie 1 : *Pipeline* NLP de base\n",
    "\n",
    "Nous travaillons dans cette partie sur un court texte en anglais écrit directement dans le code, afin d'observer les résultats de chaque étape du *pipeline* NLP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "578fae53",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "from pyspark.ml import Pipeline\n",
    "from sparknlp.base import DocumentAssembler, Finisher\n",
    "from sparknlp.annotator import (Tokenizer, LemmatizerModel,\n",
    "                                 PerceptronModel, NerDLModel,\n",
    "                                 NerConverter, SentenceDetector)\n",
    "\n",
    "###spark = SparkSession.builder.getOrCreate()\n",
    "\n",
    "# Texte de démonstration\n",
    "texte_demo = spark.createDataFrame([\n",
    "    [\"Apple is looking at buying U.K. startup for $1 billion. \"\n",
    "     \"The company, based in Cupertino, was founded by Steve Jobs in 1976.\"]\n",
    "], [\"text\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd5446d7",
   "metadata": {},
   "source": [
    "#### Construction du pipeline\n",
    "\n",
    "SparkNLP s'organise autour d'**annotateurs** (*Annotators*) chaînés dans un pipeline. Chaque annotateur consomme une ou plusieurs colonnes et produit une nouvelle colonne de type `annotation`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d54f7e31",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# 1. DocumentAssembler : convertit la colonne texte au format SparkNLP\n",
    "documentAssembler = DocumentAssembler() \\\n",
    "    .setInputCol(\"text\") \\\n",
    "    .setOutputCol(\"document\") \\\n",
    "    .setCleanupMode(\"shrink\")\n",
    "\n",
    "# 2. SentenceDetector : découpe le texte en phrases\n",
    "sentenceDetector = SentenceDetector() \\\n",
    "    .setInputCols([\"document\"]) \\\n",
    "    .setOutputCol(\"sentence\")\n",
    "\n",
    "# 3. Tokenizer : découpe chaque phrase en tokens\n",
    "tokenizer = Tokenizer() \\\n",
    "    .setInputCols([\"sentence\"]) \\\n",
    "    .setOutputCol(\"token\")\n",
    "\n",
    "# 4. POS tagger pré-entraîné (Penn Treebank tagset)\n",
    "posTagger = PerceptronModel.pretrained(\"pos_anc\", \"en\") \\\n",
    "    .setInputCols([\"sentence\", \"token\"]) \\\n",
    "    .setOutputCol(\"pos\")\n",
    "\n",
    "# 5. Lemmatizer pré-entraîné\n",
    "lemmatizer = LemmatizerModel.pretrained(\"lemma_antbnc\", \"en\") \\\n",
    "    .setInputCols([\"token\"]) \\\n",
    "    .setOutputCol(\"lemma\")\n",
    "\n",
    "# 6. NER (reconnaissance d'entités nommées) pré-entraîné\n",
    "ner = NerDLModel.pretrained(\"ner_dl\", \"en\") \\\n",
    "    .setInputCols([\"sentence\", \"token\", \"glove_embeddings\"]) \\\n",
    "    .setOutputCol(\"ner\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "827b8dc1",
   "metadata": {},
   "source": [
    "#### Note\n",
    "\n",
    "Le modèle NER (*Named Entity Recognition*)``ner_dl`` nécessite des *embeddings* GloVe en entrée. Nous construisons d'abord un *pipeline* simplifié sans NER, ensuite un *pipeline* complet avec GloVe dans la deuxième partie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cc467e0",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Pipeline simplifié (sans NER)\n",
    "from sparknlp.annotator import LemmatizerModel\n",
    "\n",
    "pipeline_nlp = Pipeline(stages=[\n",
    "    documentAssembler,\n",
    "    sentenceDetector,\n",
    "    tokenizer,\n",
    "    posTagger,\n",
    "    lemmatizer,\n",
    "])\n",
    "\n",
    "# Finisher : rend les résultats lisibles\n",
    "finisher = Finisher() \\\n",
    "    .setInputCols([\"token\", \"pos\", \"lemma\"]) \\\n",
    "    .setOutputCols([\"tokens\", \"pos_tags\", \"lemmas\"])\n",
    "\n",
    "pipeline_complet = Pipeline(stages=[pipeline_nlp, finisher])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "004e102b",
   "metadata": {},
   "source": [
    "#### Application et observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a37f9c61",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "modele_nlp = pipeline_complet.fit(texte_demo)\n",
    "resultat = modele_nlp.transform(texte_demo)\n",
    "resultat.select(\"tokens\", \"pos_tags\", \"lemmas\").show(truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa8d14a0",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Examinez les colonnes `tokens`, `pos_tags` et `lemmas`. Pour chaque token, retrouvez l'étiquette POS et le lemme correspondants. Les lemmes correspondent-ils toujours à la forme canonique attendue ? Identifiez un cas où la lemmatisation et la racinisation donneraient des résultats différents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae00ee2d",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Afficher les phrases détectées\n",
    "resultat_brut = pipeline_nlp.fit(texte_demo).transform(texte_demo)\n",
    "resultat_brut.select(\"sentence\").show(truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fcd6b6f",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Combien de phrases le `SentenceDetector` a-t-il identifiées dans le texte de démonstration ? Y a-t-il des cas où la segmentation en phrases est difficile (cas d'ambiguïté sur le rôle du point) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1e622e",
   "metadata": {},
   "source": [
    "#### Pipeline avec entités nommées\n",
    "\n",
    "Nous ajoutons maintenant les embeddings GloVe nécessaires au modèle NER."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a716cda",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from sparknlp.annotator import WordEmbeddingsModel, NerConverter\n",
    "\n",
    "# GloVe 100d (plus léger pour les TP)\n",
    "glove = WordEmbeddingsModel.pretrained(\"glove_100d\", \"en\") \\\n",
    "    .setInputCols([\"sentence\", \"token\"]) \\\n",
    "    .setOutputCol(\"glove_embeddings\")\n",
    "\n",
    "ner = NerDLModel.pretrained(\"ner_dl\", \"en\") \\\n",
    "    .setInputCols([\"sentence\", \"token\", \"glove_embeddings\"]) \\\n",
    "    .setOutputCol(\"ner\")\n",
    "\n",
    "# NerConverter regroupe les tokens BIO en entités\n",
    "nerConverter = NerConverter() \\\n",
    "    .setInputCols([\"sentence\", \"token\", \"ner\"]) \\\n",
    "    .setOutputCol(\"entities\")\n",
    "\n",
    "finisher_ner = Finisher() \\\n",
    "    .setInputCols([\"ner\", \"entities\"]) \\\n",
    "    .setOutputCols([\"ner_tags\", \"named_entities\"])\n",
    "\n",
    "pipeline_ner = Pipeline(stages=[\n",
    "    documentAssembler, sentenceDetector, tokenizer,\n",
    "    glove, ner, nerConverter, finisher_ner\n",
    "])\n",
    "\n",
    "modele_ner = pipeline_ner.fit(texte_demo)\n",
    "resultat_ner = modele_ner.transform(texte_demo)\n",
    "resultat_ner.select(\"ner_tags\", \"named_entities\").show(truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bfc59ec",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Quelles entités nommées sont détectées dans le texte de démonstration ? Quels sont leurs types (PER, ORG, LOC, MISC) ? Y a-t-il des erreurs ou des omissions ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d13dbb8",
   "metadata": {},
   "source": [
    "### Partie 2 : Classification thématique avec GloVe\n",
    "\n",
    "Nous utilisons maintenant le jeu de données **AG News** pour une tâche de classification thématique d'articles en 4 catégories : World, Sports, Business, Sci/Tech."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c066a51",
   "metadata": {},
   "source": [
    "#### Chargement et exploration des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b628eb7",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from pyspark.sql.functions import col, when, concat_ws\n",
    "from pyspark.sql.types import DoubleType\n",
    "\n",
    "# Le CSV AG News n'a pas d'en-tête : colonnes = class (1-4), title, description\n",
    "schema = \"class INT, title STRING, description STRING\"\n",
    "train_raw = spark.read.csv(\"tpFouilleTexte/data/agnews_train.csv\", schema=schema)\n",
    "test_raw  = spark.read.csv(\"tpFouilleTexte/data/agnews_test.csv\",  schema=schema)\n",
    "\n",
    "# Concaténer titre et description, convertir la classe en 0-3\n",
    "def preparer(df):\n",
    "    return df.withColumn(\"text\",\n",
    "            concat_ws(\" \", col(\"title\"), col(\"description\"))) \\\n",
    "         .withColumn(\"label\", (col(\"class\") - 1).cast(DoubleType())) \\\n",
    "         .select(\"label\", \"text\")\n",
    "\n",
    "train_data = preparer(train_raw).cache()\n",
    "test_data  = preparer(test_raw).cache()\n",
    "\n",
    "print(f\"Entraînement : {train_data.count()} | Test : {test_data.count()}\")\n",
    "train_data.groupBy(\"label\").count().orderBy(\"label\").show()\n",
    "test_data.groupBy(\"label\").count().orderBy(\"label\").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d768ecd0",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Le jeu de données est-il équilibré entre les 4 catégories ? Qu'est-ce que cela implique pour le choix de la métrique d'évaluation ? Affichez quelques exemples d'articles pour vous familiariser avec le contenu de chaque catégorie.\n",
    "\n",
    "Pour garder des temps de calcul raisonnables, nous travaillons sur un échantillon équilibré (obtenu ici par échantillonnage stratifié, bien que la stratification ne soit pas indispensable) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66034a3f",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Échantillon stratifié : env. 300 articles par classe pour l'entraînement\n",
    "fractions = {float(i): 300/30000 for i in range(4)}\n",
    "train_ech = train_data.stat.sampleBy(\"label\", fractions, seed=42).cache()\n",
    "print(f\"Taille de l'échantillon : {train_ech.count()} articles\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f96a3cf",
   "metadata": {},
   "source": [
    "#### Pipeline GloVe -> embeddings de phrases\n",
    "\n",
    "Construisons le *pipeline* SparkNLP qui produit un *embedding* de phrase avec GloVe (comme la moyenne des vecteurs GloVe des *tokens*) pour chaque article."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7aa7dce1",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from sparknlp.base import DocumentAssembler, EmbeddingsFinisher\n",
    "from sparknlp.annotator import (Tokenizer, StopWordsCleaner,\n",
    "                                WordEmbeddingsModel, SentenceEmbeddings)\n",
    "\n",
    "# DocumentAssembler\n",
    "documentAssembler = DocumentAssembler() \\\n",
    "    .setInputCol(\"text\") \\\n",
    "    .setOutputCol(\"document\") \\\n",
    "    .setCleanupMode(\"shrink\")\n",
    "\n",
    "# Tokenizer\n",
    "tokenizer = Tokenizer() \\\n",
    "    .setInputCols([\"document\"]) \\\n",
    "    .setOutputCol(\"token\")\n",
    "\n",
    "# Suppression des stop words\n",
    "stopWords = StopWordsCleaner.pretrained(\"stopwords_en\", \"en\") \\\n",
    "    .setInputCols([\"token\"]) \\\n",
    "    .setOutputCol(\"token_clean\")\n",
    "\n",
    "# GloVe 100d (plus léger)\n",
    "glove = WordEmbeddingsModel.pretrained(\"glove_100d\", \"en\") \\\n",
    "    .setInputCols([\"document\", \"token_clean\"]) \\\n",
    "    .setOutputCol(\"glove_embeddings\")\n",
    "\n",
    "# Embeddings GloVe 300d (attention, téléchargement ~450 Mo !)\n",
    "#glove = WordEmbeddingsModel.pretrained(\"glove_6B_300\", \"xx\") \\\n",
    "#    .setInputCols([\"document\", \"token_clean\"]) \\\n",
    "#    .setOutputCol(\"glove_embeddings\")\n",
    "\n",
    "# Embedding de phrase : moyenne des embeddings des tokens\n",
    "sentenceEmbeddings = SentenceEmbeddings() \\\n",
    "    .setInputCols([\"document\", \"glove_embeddings\"]) \\\n",
    "    .setOutputCol(\"sentence_embeddings\") \\\n",
    "    .setPoolingStrategy(\"AVERAGE\")\n",
    "\n",
    "# Finisher : convertit en vecteur Spark ML\n",
    "embeddingsFinisher = EmbeddingsFinisher() \\\n",
    "    .setInputCols([\"sentence_embeddings\"]) \\\n",
    "    .setOutputCols([\"features\"]) \\\n",
    "    .setOutputAsVector(True) \\\n",
    "    .setCleanAnnotations(False)\n",
    "\n",
    "pipeline_glove = Pipeline(stages=[\n",
    "    documentAssembler, tokenizer, stopWords,\n",
    "    glove, sentenceEmbeddings, embeddingsFinisher\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53c6bcfc",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Quel est l'effet de l'étape `StopWordsCleaner` sur les embeddings de phrases ? Dans quels cas la suppression des *stop words* peut-elle être **nocive** pour la classification ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f96ecf53",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Application du pipeline sur l'échantillon d'entraînement et les données de test\n",
    "# (opération coûteuse, donc mise en cache recommandée)\n",
    "import time\n",
    "t0 = time.time()\n",
    "modele_glove = pipeline_glove.fit(train_ech)\n",
    "train_emb = modele_glove.transform(train_ech) \\\n",
    "                        .select(\"label\", col(\"features\")[0].alias(\"features\")).cache()\n",
    "test_emb  = modele_glove.transform(test_data) \\\n",
    "                        .select(\"label\", col(\"features\")[0].alias(\"features\"), \"text\").cache()\n",
    "# Forcer le calcul pour mesurer le temps\n",
    "n_train = train_emb.count()\n",
    "n_test  = test_emb.count()\n",
    "print(f\"Embeddings calculés en {time.time()-t0:.1f} s \"\n",
    "      f\"({n_train} train, {n_test} test)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f34569",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Pourquoi utilise-t-on `.cache()` après le calcul des *embeddings* ? Que se passerait-il sinon lorsque le classifieur est appliqué plusieurs fois ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e133c118",
   "metadata": {},
   "source": [
    "#### Classification avec SVM linéaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45cbb256",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from pyspark.ml.classification import LinearSVC\n",
    "from pyspark.ml.classification import OneVsRest\n",
    "from pyspark.ml.tuning import CrossValidator, ParamGridBuilder\n",
    "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
    "import numpy as np\n",
    "\n",
    "# SVM linéaire OvR (4 classes)\n",
    "svm = LinearSVC(featuresCol=\"features\", labelCol=\"label\", maxIter=20)\n",
    "ovr = OneVsRest(classifier=svm, labelCol=\"label\",\n",
    "                featuresCol=\"features\", predictionCol=\"prediction\")\n",
    "\n",
    "pipeline_svm = Pipeline(stages=[ovr])\n",
    "\n",
    "grid = ParamGridBuilder() \\\n",
    "           .addGrid(svm.regParam, [0.01, 0.1]) \\\n",
    "           .build()\n",
    "\n",
    "#grid = ParamGridBuilder() \\\n",
    "#           .addGrid(svm.regParam, [0.01, 0.1, 0.5]) \\\n",
    "#           .build()\n",
    "\n",
    "evaluateur = MulticlassClassificationEvaluator(\n",
    "                 labelCol=\"label\", predictionCol=\"prediction\",\n",
    "                 metricName=\"accuracy\")\n",
    "\n",
    "cv = CrossValidator(estimator=pipeline_svm,\n",
    "                    estimatorParamMaps=grid,\n",
    "                    evaluator=evaluateur,\n",
    "                    numFolds=5, seed=42)\n",
    "\n",
    "t0 = time.time()\n",
    "modele_svm = cv.fit(train_emb)\n",
    "print(f\"Entraînement SVM : {time.time()-t0:.1f} s\")\n",
    "\n",
    "meilleur_regParam = modele_svm.getEstimatorParamMaps() \\\n",
    "                        [np.argmax(modele_svm.avgMetrics)][svm.regParam]\n",
    "print(f\"Meilleur regParam : {meilleur_regParam}\")\n",
    "print(f\"Accuracy (validation croisée) : {max(modele_svm.avgMetrics):.4f}\")\n",
    "\n",
    "acc_test = evaluateur.evaluate(modele_svm.transform(test_emb))\n",
    "print(f\"Accuracy sur test : {acc_test:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d527ed3",
   "metadata": {},
   "source": [
    "#### Analyse des erreurs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43eeda8e",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from pyspark.sql.functions import col as F_col\n",
    "\n",
    "predictions = modele_svm.transform(test_emb)\n",
    "\n",
    "# Matrice de confusion\n",
    "from pyspark.mllib.evaluation import MulticlassMetrics\n",
    "preds_labels = predictions.select(\"prediction\", \"label\") \\\n",
    "                           .rdd.map(lambda r: (r.prediction, float(r.label)))\n",
    "metrics = MulticlassMetrics(preds_labels)\n",
    "print(\"Matrice de confusion (lignes = vrai, colonnes = prédit) :\")\n",
    "print(metrics.confusionMatrix().toArray().astype(int))\n",
    "categories = [\"World\", \"Sports\", \"Business\", \"Sci/Tech\"]\n",
    "print(\"Catégories :\", categories)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43490acd",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Comparez l'accuracy obtenue sur les données de test à une baseline triviale (classifieur aléatoire uniforme, classifieur de la classe majoritaire). Le modèle apporte-t-il un gain significatif ? Examinez les erreurs : pour quelle(s) paire(s) de catégories les confusions sont-elles les plus fréquentes ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "152e6825",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "erreurs = predictions.filter(\n",
    "    (F_col(\"label\") != F_col(\"prediction\"))\n",
    ")\n",
    "\n",
    "erreurs.select(\"label\", \"prediction\", \"text\").show(truncate=130)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "263f9658",
   "metadata": {},
   "source": [
    "#### Question :\n",
    "\n",
    "Examinez quelques articles mal classés. Voyez-vous une explication intuitive pour ces erreurs ? La représentation par centre de gravité des vecteurs GloVe peut-elle être responsable de certaines de ces erreurs ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25a8926c",
   "metadata": {},
   "source": [
    "#### Question (bilan) :\n",
    "\n",
    "Résumez le *pipeline* complet mis en œuvre dans cette séance, de la donnée originale (texte) jusqu'à la prédiction. Identifiez à chaque étape les choix qui influencent la qualité finale du modèle. Quels seraient vos premiers axes d'amélioration si vous aviez plus de temps ?"
   ]
  }
 ],
 "metadata": {
  "date": 1793725859.9613867,
  "filename": "tpFouilleTexte.rst",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python"
  },
  "title": "Travaux pratiques - Fouille de textes 1 : SparkNLP et GloVe"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}