C’est ainsi que, des avancées récentes en traitement automatique du langage naturel ont prouvé que le traitement du texte par l’ordinateur peut être raffiné autant qu’on veut, dans les limites du possible.
Cela est en fait une bonne nouvelle car, il s’avère que des nombreux sujets restent fermés à la majorité des gens suite au manque de temps, au regard de la quantité d’informations à consulter pour espérer avoir ne fusse qu’une lueur d’idée du domaine ou du sujet qu’on veut rapidement explorer.
Il est souvent inintéressant de passer du temps à lire des textes très longs, surtout quand on veut juste avoir une compréhension suffisante en peu de temps de ce qui est écrit, ou quand le sujet traité ne fait pas partie de notre domaine de prédilection.
Il est donc intéressant de mettre au point un système qui pourra assister l’homme dans la tâche de synthèse des connaissances afin de promouvoir par là-même un échange entre disciplines, ce qui est souvent très enrichissant.
Est-il possible de mettre au point un système informatique capable de synthétiser les textes avec une performance de niveau humain ?
L’inclusion des traitements basés sur l’intelligence artificielle dans les modules de synthèse est-elle obligatoire pour atteindre des bonnes performances ?
Vu la complexité du langage naturel, un traitement purement linguistique ne nous permettrait pas de mettre au point un système de niveau humain en synthèse des textes;
Étant donné que, par définition, le langage naturel est difficile à formaliser complètement, on ne pourrait pas se passer de l’intelligence artificielle pour parvenir à réaliser un système performant;
Une architecture basé essentiellement sur des modèles du type transformer, joint à l’utilisation de quelques règles inspirées de la linguistique permettrait d’avoir un système de synthèse performant.
Nombreux sont des textes (livres, articles, pages web et autres documents) dont on voudrait avoir des bonnes synthèses, qu’on ne trouve que très rarement si on ne s’est pas découragé avant.
C’est la raison pour laquelle, nous nous sommes fixé comme objectif de répondre à ce besoin précis en mettant au point une application web de synthèse des textes.
Des solutions ont été proposées mais ne sont pas toujours à la hauteur de nos attentes (mettre au point un système de performance presqu’humaine en synthèse automatique des textes).
Les plus prometteuses de ces solutions se limitent à des tailles bien réduites de texte, ce qui est déjà un grand pas mais pas suffisant évidemment.
Cette recherche a pour objectif principal de concevoir et réaliser un système (une application web) qui facilitera la génération automatique des synthèses de niveau humain.
Pour la mise au point du système, nous comptons utiliser les méthodes d’analyse moyennant les techniques expérimentale (pour vérifier l’adéquation du fonctionnement de l’application mise sur pied avec le problème posé), et documentaire (pour une vision approfondie des techniques couramment utilisées et d’éventuelles améliorations nécessaires).
Au second chapitre, Présentation du résumé automatique et conception de l’architecture du système, nous y présenterons les aspects du résumé automatique essentiels à notre travail et y concevrons pas à pas le système de synthèse automatique des textes dans tous ses aspects (pas uniquement le côté synthèse).
Dans ce chapitre, nous allons présenter brièvement le traitement automatique du langage naturel, ainsi que les techniques de traitement qui seront utiles pour la réalisation de l’objectif principal de ce travail.
Nous allons donc y présenter une vue d’ensemble des architectures généralement utilisées, en nous focalisant essentiellement sur l’aspect intelligence artificielle du NLP (Natural Language Processing).
Après cela, nous parcourons divers modèles qui nous permettrons d’aborder le modèle le plus adapté à la tâche de synthèse automatique des textes, qui est l’objectif de ce travail.
Le NLP est une discipline rattachée à l’intelligence artificielle et ayant pour principal objectif, l’étude des possibilités du traitement du langage humain par des machines.
La raison pour laquelle la discipline s’inscrit comme faisant partie du domaine d’intelligence artificielle est que le langage est considéré comme étant une aptitude centrale de l’intelligence humaine, étant donné que l’usage d’un langage si complexe est l’un des éléments distinctifs principaux entre humains et autres animaux.
C’est ainsi que des tâches comme la traduction automatique, la génération automatique des textes ou aussi la synthèse automatique qui va nous intéresser dans ce travail, produisent directement du texte en sortie.
Mais, dans tous les cas, la sortie est soit immédiatement utilisable, soit alors elle est prise comme entrée d’un autre système dans la chaîne de traitement du texte.
On peut donc comprendre directement que le mot "naturel" est ici utilisé pour faire une distinction avec les langages formels.
C’est donc dans ce sens que toutes les langues parlées peuvent être vues comme des langages naturels.
Les langages formels ont une syntaxe précise et sont spécifiquement conçus pour des objectifs bien cernés (penser à tous les langages de programmation par exemple).
Ceci n’est qu’un exemple particulier pour illustrer cette dichotomie inhérente à l’emploi de la langue quelle qu’elle soit, mais cela suffit pour qu’on s’aperçoive que le problème est bel et bien réel.
Néanmoins, le principal désavantage de ces techniques était qu’elles ne parvenaient pas à capturer une grande partie de la complexité linguistique du langage humain, comme par exemple le contexte.
Ainsi, les développements, récents d’ailleurs, des réseaux de neurone et du deep learning ont donné des nouveaux outils, pour approcher dans une large mesure les performances humaines en terme de traitement de langage.
A notre avis, ces techniques sont les plus adaptées car, tout d’abord elles se rapprochent beaucoup plus des méthodes de traitement d’information par le cerveau humain, et ensuite, il serait autrement très couteux, voir impossible, d’élaborer des modèles capables d’embrasser toute la complexité du langage humain.
Cette représentation constitue d’ailleurs un problème fondamental car c’est d’elle que dépend toute la chaîne de traitement des systèmes de NLP [46].
Cela est une première étape pour diminuer la difficulté inhérente au traitement des textes.
En considérant la décomposition en mots, pour diminuer au maximum les difficultés de traitement et l’ambiguïté, on ajoute à la tokenisation d’autres traitements qui sont en général : la désaccentuation, le passage aux minuscules, la suppression des stopwords, la racinisation et la lemmatisation appliqués aux tokens obtenus [22].
Les stopwords sont, pour une langue donnée, des mots qui permettent de réaliser des phrases correctes mais qui n’apportent pas directement d’information significative sur l’ensemble (du point de vu traitement).
Cela permet juste de maximiser la probabilité de confondre des mots semblables qui sont présentés différemment dans diverses phrases.
Pour illustration, on voudrait par exemple que si on retrouve les éléments "manger", "mange", "mangeable", "mangeons" dans un corpus, qu’ils soient transformés en un seul terme "mange".
C’est cela en bref le stemming et, contrairement à ce que le nom suggère, il ne s’agit pas exactement de trouver la racine des mots (les mots dont ils dérivent).
Elle réalise en fait ce qui n’est pas réalisé par le stemming en ce sens que lemmatiser un token consiste à la transformer en sa racine, et cette dernière doit être présente dans le dictionnaire.
Cette tâche est visiblement très importante dans la phase d’interprétation des données textuelles et il s’agit d’un simple problème de classification.
Le Part-Of-Speech tagging est une tâche consistant en gros, à associer aux éléments des textes, des informations grammaticales.
Elle est fortement facilitée par des approches basées sur le deep learning comme c’est le cas aussi pour la reconnaissance d’entités nommées.
Nous allons passer sous silence certains autres concepts du NLP comme le sacs de mots et le word embeddings dont nous parlerons dans la partie qui va suivre et qui présentera le résumé automatique, en tant que tâche du NLP.
Comme cela a été maintes fois mentionné, deux approches majeures sont d’usage pour traiter automatiquement les données de langage naturel.
Mais les deux approches sont dans la majorité des cas complétées par certaines heuristiques [31].
En ce qui nous concerne, l’approche sera essentiellement numérique avec un penchant prononcé pour les techniques du deep learning.
D’ailleurs, concernant ces dernières techniques, les modèles de l’état de l’art les plus adaptés sont les transformers et leur présentation exige une revue chronologique car en effet, pour y arriver, des modèles classiques basés sur des réseaux de neurones récurrents (RNN) ont été utilisés car plus adaptés aux données séquentielles que sont les textes.
Furent ensuite introduits les mécanismes d’attention qui améliorèrent les techniques, aboutissant finalement aux modèles dits transformers, plus adaptés à des tâches de NLP élaborées.
Les réseaux de neurones artificiels (Artificial Neural Network ou ANN) sont un ensemble de neurones (artificiels) assemblés pour résoudre des tâches considérées comme requérant une certaine intelligence.
Il s’agit essentiellement d’une fonction d’agrégation ayant pour rôle de réaliser une somme pondérée des entrées qui lui sont présentées et d’une fonction d’activation qui formate la sortie de la fonction d’agrégation selon les valeurs attendues en sortie [12].
Les neurones sont généralement assemblés par couche comme présenté sur la figure qui suit :
On n’entrera pas dans le détail, vu que ce n’est pas exactement le sujet du travail mais, pour entamer la partie qui suit, il nous faut préciser que, comme pour les réseaux de neurones simples, l’entraînement exige d’appliquer une fonction de différentiation sur l’erreur produite par le système.
Mais, comme ici le gradient tient compte des grandeurs précédentes dans le temps, il y a un certain nombre de termes multiplicatifs qui peuvent amener le modèle à ne jamais converger ou au contraire, à la saturation.
Présentée comme cela, la cellule LSTM semble superflue mais si on présentait les équations associées à un réseau fait de ces cellules, on se rendra compte que c’est plutôt intuitif.
Il est évident que, pour chacune de ces portes que nous nommerons, à un instant t donné par It, Ft et Ot, le système doit apprendre ses paramètres en fonction de l’entrée et de l’état interne.
Mais on doit aussi remarquer que, l’état est défini par deux paramètres au lieu d’un seul comme pour les RNN simples.
On sait aussi que, si on veut une mémoire à long terme contrôlée, la valeur finale de ct doit être mise à jour en repérant ce qui doit être oublié parmi les éléments qui étaient précédemment dans la mémoire, pour y ajouter ensuite ce qui est sélectionné comme pertinent à l’entrée.
Et de cela on peut conclure que c’est plus intéressant d’avoir Ft et It qui prennent des valeurs entre 0 et 1 (pour modéliser la sélection) et ct devra dépendre de ces deux éléments, avec aussi l’état précédent de la mémoire à long terme.
Il va ici s’agir de ht vu que la cellule est développée par analogie avec le processus de mémorisation des systèmes naturels (mémoire à court terme correspondant à la mémoire de travail).
Cette implémentation peut être modifiée, surtout en ce qui concerne les fonctions d’activation utilisées (σ et tanh), et en particulier la fonction d’activation de finalisation tanh ici, mais c’est l’une des plus optimales.
Il faut noter que sur cette image (figure I.5), l’implémentation de la mise à jour est l’inverse de celle que nous avons décrit par les équations I.4.
Parmi les techniques d’amélioration des performances, une peut être considérée car elle a un rapport direct avec notre travail.
Les mécanismes d’attention sont en bref des techniques permettant de lutter contre la perte de mémoire qu’on constate par exemple dans les cellules récurrentes ci-haut décrites, en se focalisant sur des éléments les plus importants à chaque traitement.
Pour l’expliquer, nous allons considérer une architecture jusque là passée sous silence, mais qui permet aux modèles introduits là haut de s’utiliser efficacement pour les tâches courantes du NLP en particulier.
Ainsi, si par exemple on est entrain de vouloir traduire une longue phrase, on peut finir par transmettre un vecteur de contexte qui a perdu toute information sur les premiers éléments de la séquence passée en entrée.
C’est pour cela qu’au lieu de passer un vecteur de contexte général, les mécanismes d’attention permettraient ici de ne se focaliser que sur certaines informations lors du traitement d’un élément particulier de la séquence (en ayant évidemment passé tous les états internes passés au décodeur).
Pour le réaliser concrètement, le mécanisme d’attention global consiste à formater le vecteur de contexte en fonction des éléments de l’encodeur à prendre en compte lors du traitement par le décodeur.
Considérons que Ω, dont les termes sont représentés par wij, est la matrice des poids d’attention normalisés par une fonction softmax pour chaque ligne.
Et que Π, dont les termes sont représentés par αij, est la matrice des poids d’attention générée par le mécanismes avant normalisation.Si les éléments ci représentent à chaque fois le vecteur contexte final à l’étape i de décodage et les hj sont les vecteurs d’état interne de l’encodeur, l’attention globale revient à réaliser la manipulation suivante, pour formater le vecteur de contexte à prendre en compte pour l’élément en cours de traitement [30] :
La dernière relation du système I.5 revient à réaliser une somme pondérée des vecteurs d’état internes passés de l’encodeur, selon l’importance de chaque état pour le traitement en cours.
Cela est volontaire car c’est intuitif (on réalise des sommations sur tous les éléments).
La réponse est oui, avec des ajustements adéquats pour résoudre les faiblesses des modèles classiques dans le traitement des données séquentielles.
Les transformers sont des modèles du type encodeur-décodeur comme on peut le constater sur la figure ci-dessus (bien que certaines implémentations n’en utilisent qu’une partie selon la tâche).
Un choix intuitif, et qui s’avère être performant, est de tout faire pour que si deux termes ont des sens proches, ils aient aussi des représentations vectorielles proches.
Cela est réalisé par différentes techniques que nous présenterons dans le chapitre suivant, mais c’est là le rôle de la couche d’enchâssement (embedding).
Cela pallie au problème de perte d’information sur la position des mots quand on utilise un réseau non séquentiel comme les réseaux récurrents.
3°) Module d’auto-attention : La couche d’attention, présentée en première position dans la boîte de l’encodeur, est en fait une couche dite de self-attention car elle opère sur la même séquence d’entrée.
L’opération est réalisée pour permettre au modèle d’avoir une représentation de l’importance des termes dans la séquence d’entrée, les uns par rapport aux autres.
C’est à l’établissement des tels liens dans les représentations que sert le module d’auto-attention ici présenté.
Il est important que ce lien soit implicitement présent dans les représentations, pour que le traitement soit efficace comme on l’a mentionné lors de la présentation des mécanismes d’attention.
En effet, très brièvement, l’idée du scaled dot-product attention consiste à opérer une recherche des termes sur lesquels focaliser l’attention de la même façon qu’on réalise la recherche de la signification d’un mot dans un dictionnaire.
Si on supposait qu’il existe plusieurs termes du dictionnaire qui s’orthographient presque de la même façon que le mot qu’on cherche, on devra passer par une mesure de similarité avant de se décider sur le sens le plus probable.
Il faut noter que dk est la dimension d’une clé, et que cette normalisation permet d’améliorer les performances du modèle mais elle n’est pas la seule envisageable.
Il faut aussi noter que l’on utilise parallèlement plusieurs modules d’attention pour capture toutes les caractéristiques des séquences (on parle de multi-head attention).
En effet, contrairement à la couche de self-attention, pour laquelle tous les trois paramètres sont calculés à partir de la même séquence, la couche d’attention ici prend les clés K et valeurs V provenant de l’encodeur mais une requête Q provenant du décodeur.
7°) Module linéaire final : Il s’agit d’un réseau de neurones classique pour réaliser la déduction finale, le tout étant passé à la fin à travers une opération softmax qui permet de transformer les résultats en probabilité d’éléments générés (cela permet de choisir le terme le plus vraisemblable à générer comme sortie).
Les transformers, ici succinctement présentés, sont un modèle très adapté aux tâches de traitement automatique du langage naturel.
Nous venons de réaliser une vue d’ensemble du domaine de traitement automatique du langage naturel, ainsi que diverses techniques couramment utilisées.
Pour cela, nous avons tout d’abord justifié la préséance des modèles basés sur le deep learning pour diverses tâches du NLP.
Ensuite, nous avons évoqué les technique de pré-traitement des textes, souvent incontournables, comme la réduction des séquences en leurs tokens constitutifs, la suppression des mots fréquents mais n’apportant pas assez d’informations et la réduction des mots en leurs racines respectives.
Ce qui précède nous a finalement conduit à présenter les modèles courants du NLP basés sur les RNNs et, nous avons terminé par la présentation de l’architecture transformer, modèle que nous utiliserons pour ce travail (les précisions sur les modèles particuliers seront données au chapitre suivant).
Les transformers constituent un type de modèle qui s’avère être le plus adapté (pour le moment) au résumé automatique du texte et, dans le chapitre suivant, nous commencerons par présenter les diverses spécificités du résumé automatique comme tâche du NLP, pour finir par présenter l’architecture globale du système que nous comptons élaborer.
Le résumé automatique étant le sujet principal de ce mémoire, dans cette partie nous le présentons alors en détail en tant que discipline et tâche du NLP.
Nous allons ici présenter les théories sur la synthèse automatique des textes, en classifiant les diverses méthodes utilisées pour pouvoir situer notre système dans l’ensemble des travaux jusque-là menés sur ce sujet.
Ensuite, nous présenterons les diverses approches utilisées pour le résumé automatique, sans oublier d’approfondir notre présentation des modèles de type transformer adaptés à cette tâche, pour finalement mentionner le modèle que nous estimons le plus adapté concernant l’approche basée sur le deep-learning pour la synthèse automatique.
De cela on tire que le résumé devient automatique s’il est généré par un logiciel ou un système informatique.
Une définition assez valable est celle de TORRES-MORENO Juan-Manuel qui dit qu’un résumé automatique est un texte généré par un logiciel, cohérent et contenant une partie importante des informations pertinentes de la source, et dont le taux de compression est inférieur au tiers de la taille du(des) document(s) source(s) [48].
L’introduction du taux de compression dans la définition n’est pas anodine car, on s’est très vite rendu compte que la performance d’un système de résumé automatique dépendait fortement du taux de compression.
En effet, les études de [26] montrent que les meilleures performances des systèmes de résumé automatique sont généralement atteintes pour des taux de compression compris entre 15 et 30% [48].
Toutefois, on ne doit pas manquer de signaler que la génération automatique des résumés est un problème complexe en soi, tout comme l’évaluation des résultats.
Le résumé est en effet une tâche cognitive requérant la compréhension du texte considéré et, les humains n’étant pas toujours bons dans les tâches de synthèse, le manque d’étalon explique qu’il y ait également une difficulté d’automatisation du processus.
Tel une table des matières, un résumé indicatif renseigne le lecteur sur les thèmes abordés dans un document.
Il s’agit d’un modèle rétréci du texte d’origine, relatant le plus largement possible les informations contenues dans celui-ci.
La problématique ici est donc double : comprendre ce qui n’est pas information dans un texte et connaître le besoin de l’utilisateur final.
Néanmoins, si on n’a pas de requête spécifique de la part de l’utilisateur, le résumé informatif est réalisé en veillant à ce que l’ensemble des principaux sujets du texte d’origine soit rapporté.
Ainsi, les sujets principaux qui sont rappelés dans le résumé sont répartis de manière fidèle par rapport à l’organisation initiale afin de donner un juste aperçu du texte source.
En effet, on sait par exemple que dans le domaine journalistique, les informations les plus importantes sont souvent mentionnées au début du texte.[36]
Le problème consiste donc à repérer les segments de texte qui semblent être les plus pertinents pour faire partie du résumé final.
Les méthodes de résumé abstractives imitent, jusqu’à un certain degré, le processus naturel accompli par l’homme pour résumer un document.
Il existe aussi des résumés dits semi-extractifs, et même aussi des résumés dits par compression [48] mais nous estimons inutile de les décrire ici étant donné que la distinction abstractif-extractif suffit pour notre contexte.
Avec des critères centrés sur le contenu des textes, il existe un grand nombre d’algorithmes assez triviaux de résumé, qui sont basés entre autres sur : • La fréquence d’occurrence des mots et
L’idée majeure des techniques qui utilisent ce critère consiste à considérer que les mots les plus fréquents sont les plus liés au sujet principal du texte à résumer.
Et, à la fin, le résumé est constitué avec les phrases extraites du texte source, et dont le score dépasse un certain seuil dépendant de la taille maximale imposée pour le résumé.
Le tout est finalement réarrangé selon l’ordre d’apparition (des phrases sélectionnées) dans le texte d’origine.
En utilisant des techniques de repérage d’entités nommées (voir le chapitre précédent), on identifie les entités présentes dans le document.
L’un des moyens les plus simples pour repérer les entités nommées est de passer par l’apprentissage profond comme on l’a précédemment mentionné.
L’intuition derrière cette approche est basée sur le constat que dans un texte, les éléments ne sont pas présentés de façon arbitraire.
Pour certains types de documents (documents journalistiques par exemple), les phrases se trouvant au début sont généralement plus informatives et décrivent le sujet principal du document.
Le résumé des articles scientifiques par contre, peut essentiellement se former en se basant sur les contenus des parties résumé et introduction (sous l’hypothèse que ces dernières parties sont bien faites).
Ici, on considère une liste de mots, constituée manuellement, et qui a comme rôle de permettre de se décider si une phrase doit être prise dans le résumé ou rejetée, selon qu’elle contient ou non un(des) mot(s) de la liste qualifié(s) inhibiteur(s) ou valorisant(s).
Les méthodes que nous venons de présenter sont assez intuitives mais constituent la base des processus de synthèse.
Nous devons toutefois signaler que les résumés abstractifs se basent au fond sur les mêmes principes, soit en partant des résumés extractifs pour ensuite réaliser des paraphrases, insérer des connecteurs appropriés et éliminer les références anaphoriques dans les résumés, soit en implémentant indirectement toutes ces techniques à travers un modèle d’apprentissage automatique ou un modèle basé sur les graphes capables de capturer d’un seul coup tous ces aspects (ou une grande partie d’entre-eux).
Comme nous venons de l’introduire dans la section précédente, le résumé automatique est abordé essentiellement selon deux approches qui sont [31] :
Mais, dans tous les cas, une vue sur quelques heuristiques (méthodes basées sur le bon sens) est toujours à considérer (surtout en amont, puis en aval du processus de synthèse).
la synthèse consiste à supprimer certains mots pour n’en conserver que les plus importants;
L’approche qui se base naïvement sur la fréquence d’apparition des mots dans les textes pour juger de leur importance relative, accorde à chaque mot un poids égal à T F(i,j).
D’où finalement, le poids d’un terme i dans un document j est donné par :
L’application de cette méthode pour le résumé consiste finalement à calculer le poids de chaque phrase en additionnant les poids des termes la constituant, puis à normaliser le résultat en fonction de la taille de la phrase considérée.
Après tout, on définit un seuil qui permet de soutirer les phrases selon leur pertinence ainsi évaluée (en considérant évidemment plus pertinente une phrase dont le résultat de la sommation des poids est élevé).
Il s’agit en fait d’une matrice d’adjacence dans laquelle on pose au préalable que Mii = 0, pour tout i (c’est la même idée pour l’algorithme PageRank étant donné qu’il est logique de considérer qu’une page ne peut s’auto-référencer).
On applique la formule II.5 itérativement et à la convergence, on choisit les phrases qui vont former le résumé selon leur importance ( valeurs des T extRank(P hri) pour toute valeur de i).
Il considère la position et la longueur des phrases dans le calcul de leur pertinence; - Il est optimisé pour le résumé multi-document.
Même si, ces traitements peuvent être mélangés avec les techniques de résolution d’anaphores et les paraphrases pour obtenir des synthèses qui tendent vers la synthèse abstractive, nous devons souligner que les techniques jusque là les plus performantes pour la synthèse abstractive sont essentiellement basées sur le deep learning [36].
Le deep learning peut également être utilisé pour la synthèse extractive, permettant ainsi la génération des synthèses extraites plus cohérentes (avec résolution d’anaphores).
Ainsi donc, nous abordons les méthodes de deep learning utilisées pour cet effet dans les parties qui suivent.
Tout traitement commence par une représentation numérique des termes (des mots ici) pour qu’ils soient assimilables par le modèle.
Une autre approche, plus classique, consiste à représenter chaque mot par un vecteur de dimension égale à la taille du dictionnaire et dont tous les termes sont nuls, sauf à la position, dans le dictionnaire, du mot qu’on est entrain de vouloir représenter (on parle du one-hot encoding).
Étant artificiellement construites, sans tenir compte du sens des mots, ni de leur contexte, ces méthodes de représentation rendent la tâche de découverte des caractéristiques par les systèmes de machine learning encore plus difficile.
D’ailleurs, l’une des faiblesses de la seconde méthode décrite (le one-hot encoding) est que les vecteurs sont creux (une majorité de valeurs nulles) et de dimension inutilement très grande.
Ainsi, tout mot est représenté en réalisant une statistique (implicitement bien sûr) sur les divers mots qui l’accompagnent souvent, de telle sorte que les mots aux sens proches aient aussi des vecteurs très proches.
Il s’agit bel et bien des modèles adaptés aux tâches de synthèse, vu qu’en entrée on reçoit une séquence pour ressortir une autre séquence en sortie.
Comme nous l’avons déjà bien mentionné au précédent chapitre, nous n’allons parler que des modèles Seq2Seq de type transformer car actuellement, ils sont les plus adaptés à la tâche que nous voulons réaliser (celle de synthèse automatique).
Les transformers (voir la figure I.7) sont un modèle très avantageux car en fait, au-delà de leurs performances et autres avantages, ils facilitent encore plus la recherche en NLP en rendant effectif le transfer learning (apprentissage par transfert) dans ce domaine.
2°) Affinage de l’apprentissage (fine-tuning) : Ça consiste à finaliser l’apprentissage du modèle pré-entraîné de manière supervisée pour qu’il soit en mesure de réaliser une tâche donnée du NLP (il s’agit du transfer learning en fait).
Bien que la forme classique des transformers est bel et bien celle de la figure I.7, il existe 3 types d’implémentation selon les types de tâche visées en dernier lieu :
Ces modèles sont très bons pour les tâches de compréhension du langage comme la classification par exemple.
Ils sont bons pour les tâches demandant à la fois la compréhension et la génération des textes.
Donc, les phrases sont lues dans les deux sens pour mieux saisir tout le contexte.
2°) Like-GPT : donc semblables au transformer dénommé GPT (Generative Pre-trained Transformer) qui n’ont que la partie décodeur et sont dits auto-regressifs car, seules les parties précédant le mot en cours de traitement sont connues du modèle et il y a chaque fois réinjection des sorties à l’entrée.
Ces modèles sont principalement bons pour les tâches de NLU (Natural Language Understanding) comme la classification, le NER (Name Entity Recognition), l’extractive question-answering,...
Ces modèles sont particulièrement bons pour les tâches liées fortement au NLG (Natural Language Generation).
tégralité de l’architecture des transformers et sont ainsi bons pour les tâches demandant à la fois du NLU et du NLG comme la synthèse automatique abstractive, le generative question-answering et la traduction automatique.
allons privilégier (les modèles dérivés de BART principalement) pour réaliser cette tâche dans notre système.
Dans ce second chapitre, nous ne présenterons que les spécifications du système ainsi qu’une ébauche de conception avec une présentation de l’architecture globale.
Nous prévoyons, dans un premier temps, ne l’utiliser que pour des petits documents (la taille optimale sera déterminée avec les expérimentations au chapitre suivant).
Module de synthèse abstraite : ce module donnera une synthèse abstraite en utilisant l’un des transformers affinés pour la synthèse ou bien par le module qui sera en train de s’auto-améliorer au cours de l’utilisation du système (on l’a nommé expérimental, voir la figure II.7).
Comme les transformers réalisent des synthèses de documents de taille généralement limitée à environ une page, nous mettrons au point, dans cette partie, une pipeline qui nous permettra d’augmenter le nombre de pages (nous pensons à 100 pages mais les expérimentations nous permettrons de choisir une taille optimale, tenant compte surtout de la rapidité).
Pour ce module, nous comptons mettre au point une routine d’entraînement à partir des synthèses collectées par le système, pour améliorer au fur et à mesure les performances de ce module.
Nous comptons réaliser l’entraînement par transfer learning avec les transformers mT5[53] ou mBART [27] comme base.
N’ayant pas encore testé cette partie, nous serons fixé sur la méthode à utiliser ainsi que le modèle de base à choisir au chapitre suivant, après les expérimentations.
La base des données, que nous avons mentionné dans la figure II.4, a un double rôle :
2°) Le stockage des paires document-synthèse, ainsi que l’appréciation de l’utilisateur (évaluation par les utilisateurs).
Comme nous pouvons le voir, un traitement sera fait pour adapter les données reçues à ce qui peut être traité par le système.
Ce traitement consistera à ne retenir que des symboles alphanumériques, à réaliser la tokenisation des textes (chaque token sera une phrase pour cette partie) et à affecter un identifiant unique à chaque phrase.
Après cela, les données seront invariablement passées aux algorithmes de synthèse extractive, qui générerons chacun un groupe de poids des phrases.
Nous implémenterons plusieurs modèles (BART, BARThez, PEGASUS, mBART ou mT5 entraîné avec nos données, ainsi que tous ceux qui nous paraîtrons utiles durant les essais); Chaque module de synthèse se présentera néanmoins comme suit :
Nous devons finalement mentionner que les modules de tokenisation (nommés tokenizer en anglais) dépendront explicitement des modèles utilisés.
Dans cette partie, nous venons de présenter le résumé automatique des textes, tout en réalisant une vue d’ensemble des méthodes utilisées dans la littérature à cet effet.
Nous avons également listé les divers modèles de transformer adaptés à la tâche de synthèse automatique abstraite, et nous avons mentionné devoir privilégier les modèles du type BART pour des raisons qui serons précisées dans le chapitre suivant.
Enfin, nous avons réalisé la conception préliminaire du système tout en précisant que, concernant l’API, la BD (Base des Données) et les interfaces, les détails d’implémentation utiles seront précisés dans la partie dédiée à la conception proprement dite et aux tests, c’est-à-dire au chapitre suivant.
Le chapitre suivant nous permettra donc finalement de préciser, réaliser et tester les méthodes que nous avons jusque-là adoptées pour la mise au point de notre système de synthèse automatique des documents.
Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov, and Luke Zettlemoyer.
Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean.
Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean.
Barry Schiffman, Ani Nenkova, and Kathleen McKeown.
UNIVERSITELIBREDESPAYSDESGRANDSLACS

FACULTE DES SCIENCES ET DES TECHNOLOGIES

APPLIQUEES

DEPARTEMENT DE GENIE ELECTRIQUE ET INFORMATIQUE



B.P 368 GOMA

www.ulpgl.net



CONCEPTION ET REALISATION D’UN

SYSTEME BASE SUR L’INTELLIGENCE

ARTIFICIELLE POUR RESUMER

AUTOMATIQUEMENT LES TEXTES



Par : KRAME KADURHA David

Travail présenté en vue de l’obtention du Diplôme d’ingénieur civil en génie électrique et informatique

Option : Génie informatique

Directeur : Prof BARAKA MUSHAGE Olivier

Encadreur : Ir MUHINDO WAMUHINDO Abdenego

ANNEE ACADEMIQUE 2021−2022







Dédicaces

Remerciements

Résumé

Sigles et abréviations

Table des matières

Dédicaces	i

Remerciements	ii

Résumé	iii

Sigles et abréviations	iv

Introduction générale	1

	0.1	Contexte	. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	1

	0.2	Identification et formulation du problème . . . . . . . . . . . . . . . . . . .	1

	0.3	Questions de recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	2

	0.4	Hypothèses de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	2

	0.5	Justification du choix du sujet et motivations	. . . . . . . . . . . . . . . . .	3

	0.6	Objectifs de la recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	4

	0.6.1	Objectif général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	4

	0.6.2	Objectifs spécifiques	. . . . . . . . . . . . . . . . . . . . . . . . . . .	4

	0.7	Méthodologie de recherche et délimitation du travail . . . . . . . . . . . . .	5

	0.8	Subdivision du travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	5

Généralités sur le NLP	6

Introduction partielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	6

Présentation et définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . .	6

Nécessité de l’approche par deep learning . . . . . . . . . . . . . . . . . . .	8

Quelques techniques courantes de traitement des textes . . . . . . . . . . .	9

La tokenisation (tokenization)	. . . . . . . . . . . . . . . . . . . . . .	9

Les stopwords[44] . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	10

La racinisation (stemming) . . . . . . . . . . . . . . . . . . . . . . . .	10

La lemmatisation (lemmatization) . . . . . . . . . . . . . . . . . . . .	10



SYNTHESE AUTOMATIQUE DES TEXTES



Reconnaissance d’entités nommées (NER)[44] . . . . . . . . . . . . .	11

L’étiquetage morpho-syntaxique (POS tagging)	. . . . . . . . . . . .	11

Approches du NLP	. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	12

Les réseaux de neurones artificiels (ANN) . . . . . . . . . . . . . . .	12

Les réseaux de neurones récurrents (RNN) . . . . . . . . . . . . . . .	13

Mécanismes d’attention	. . . . . . . . . . . . . . . . . . . . . . . . .	20

Les transformers	. . . . . . . . . . . . . . . . . . . . . . . . . . . . .	22

Conclusion partielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	27

Résumé automatique et conception	29

Introduction partielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	29

Présentation et définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . .	29

Catégorisation des résumés . . . . . . . . . . . . . . . . . . . . . . . . . . . .	30

Selon la fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	31

Selon le nombre de documents source	. . . . . . . . . . . . . . . . .	32

Selon le genre des documents . . . . . . . . . . . . . . . . . . . . . .	32

Selon le type de sortie (résumé obtenu) . . . . . . . . . . . . . . . . .	33

Selon le type de résumeur . . . . . . . . . . . . . . . . . . . . . . . .	34

Selon le contexte	. . . . . . . . . . . . . . . . . . . . . . . . . . . . .	34

Selon le destinataire du résumé . . . . . . . . . . . . . . . . . . . . .	35

Approches de résumé automatique . . . . . . . . . . . . . . . . . . . . . . .	35

Techniques intuitives de résumé [36] . . . . . . . . . . . . . . . . . .	35

Algorithmes classiques de résumé automatique . . . . . . . . . . . .	38

Modèles Seq2Seq	. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	45

Methodes du Word-Embedding . . . . . . . . . . . . . . . . . . . . .	45

Modèles séquence-à-séquence proprement dits . . . . . . . . . . . .	46

Modèle BART pour la synthèse abstractive . . . . . . . . . . . . . . .	50

Conception de l’architecture globale du système . . . . . . . . . . . . . . . .	51

Spécifications du système	. . . . . . . . . . . . . . . . . . . . . . . .	52

Présentation des éléments du système	. . . . . . . . . . . . . . . . .	52



vi sur 68

TABLE DES MATIÈRES



Architecture du module de synthèse extractive . . . . . . . . . . . .	54

Architecture du module de synthèse abstractive	. . . . . . . . . . .	56

Présentation des interfaces . . . . . . . . . . . . . . . . . . . . . . . .	58

Conclusion partielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .	59

Conception finale, réalisation et tests	60

Conclusion générale	61

Annexes	68



vii sur 68

Liste des figures

I.1 Réseau de neurones à une couche cachée et sans boucle [47]	13

I.2 Illustration de ce qu’est un RNN [22]	14

I.3 Comparaison entre cellules RNN classique et LSTM [18]	15

I.4 Vue fonctionnelle d’une cellule LSTM [18]	16

I.5 Cellule GRU [18]	19

I.6 Réseaux série-vers-série (en haut à gauche), série-vers-vecteur (en haut à	

droite), vecteur-vers-série (en bas à gauche) et encodeur-décodeur (en bas àdroite) [16]	21

I.7 Architecture générique des transformers [50]	23

I.8 Vue éclatée d’un transformer [51]	27

II.1 Diagramme des fréquences des mots et le choix de Luhn [29]	40

II.2 Comparaison simplifiée entre BERT, GPT et BART [25]	50

II.3 Transformations de bruitage expérimentées pour BART [25]	50

II.4 Architecture globale de notre système	52

II.5 Architecture globale du système de synthèse abstractive	57

II.6 Architecture interne du modèle mentionné sur la figure II.5	57

II.7 Ébauche d’interface	58



viii

Introduction générale

0.1	Contexte

A l’ère du numérique, comme depuis l’invention de l’écriture, le texte est l’un des principaux moyens de communication et surtout, de transmission des connaissances.

Des livres aux SMS, en passant par diverses pages web, les données textuelles sont partout. En 2018, il s’agissait d’environs 80% de l’information qui circulait sur le web [23]. L’évolution de l’informatique continue à démontrer la possibilité de simplifier toujours grandement la vie de l’homme en automatisant de plus en plus l’accomplissement des tâches rébarbatives.

Certaines tâches comme celles liées explicitement à l’arithmétique semblent mieux se prêter à cette vague d’automatisation, les données numériques étant par essence celles prises en compte par les plateformes numériques.

Néanmoins, des transformations adéquates permettent de prendre en compte tout type de donnée, et le texte n’est pas exclu. C’est ainsi que, des avancées récentes en traitement automatique du langage naturel ont prouvé que le traitement du texte par l’ordinateur peut être raffiné autant qu’on veut, dans les limites du possible.

Cela est en fait une bonne nouvelle car, il s’avère que des nombreux sujets restent fermés à la majorité des gens suite au manque de temps, au regard de la quantité d’informations à consulter pour espérer avoir ne fusse qu’une lueur d’idée du domaine ou du sujet qu’on veut rapidement explorer.

C’est en ce sens que la mise au point des technologies pouvant faciliter l’exploration des connaissances présentées sous forme textuelle est salvatrice.

0.2	Identification et formulation du problème

Comme présenté dans la section précédente, la voie la plus privilégiée pour transmettre les connaissances est l’écriture. Mais, admettons que souvent, dans un long texte, la

1



SYNTHESE AUTOMATIQUE DES TEXTES



quantité d’information pertinente est moindre par rapport à la longueur du texte entier.

Comment faire donc pour identifier cette partie utile et gagner ainsi en temps ?

Il est souvent inintéressant de passer du temps à lire des textes très longs, surtout quand on veut juste avoir une compréhension suffisante en peu de temps de ce qui est écrit, ou quand le sujet traité ne fait pas partie de notre domaine de prédilection. Il est donc intéressant de mettre au point un système qui pourra assister l’homme dans la tâche de synthèse des connaissances afin de promouvoir par là-même un échange entre disciplines, ce qui est souvent très enrichissant.

0.3	Questions de recherche

Vu le problème que nous venons de présenter, une question se pose :

Est-il possible de mettre au point un système informatique capable de synthétiser les textes avec une performance de niveau humain ?

La précédente question nous amène aussi à nous demander ceci :

Un traitement purement linguistique ne pourrait-il pas nous permettre de générer des synthèses suffisamment bons pour atteindre notre objectif ?

L’inclusion des traitements basés sur l’intelligence artificielle dans les modules de synthèse est-elle obligatoire pour atteindre des bonnes performances ?

Quelle est l’architecture globale la plus adaptée pour réaliser un système de synthèse automatique performant ?

0.4	Hypothèses de travail

A la suite des questions que nous venons de soulever, nous postulons que :

Vu la complexité du langage naturel, un traitement purement linguistique ne nous permettrait pas de mettre au point un système de niveau humain en synthèse des textes;

0.5. JUSTIFICATION DU CHOIX DU SUJET ET MOTIVATIONS



Étant donné que, par définition, le langage naturel est difficile à formaliser complètement, on ne pourrait pas se passer de l’intelligence artificielle pour parvenir à réaliser un système performant;

Une architecture basé essentiellement sur des modèles du type transformer, joint à l’utilisation de quelques règles inspirées de la linguistique permettrait d’avoir un système de synthèse performant.

0.5	Justification du choix du sujet et motivations

Pour synthétiser un texte, il faut l’avoir aumoins lu! Et pourtant, pour lire un texte, il faut du temps, une denrée souvent rare.

Certains textes sont souvent fournis, accompagnés des synthèses qui sont parfois très bonnes, parfois incomplètes et parfois même très polarisées ou tout simplement mauvaises. Toutefois, avoir une synthèse à la demande serait mieux que de ne trouver que des synthèses de certains textes, sans d’ailleurs en avoir le plus souvent besoin. Nombreux sont des textes (livres, articles, pages web et autres documents) dont on voudrait avoir des bonnes synthèses, qu’on ne trouve que très rarement si on ne s’est pas découragé avant. C’est la raison pour laquelle, nous nous sommes fixé comme objectif de répondre à ce besoin précis en mettant au point une application web de synthèse des textes. Beaucoup de chercheurs en linguistique et en traitement automatique du langage naturel principalement se sont penché sur ce sujet [23, 48, 1, 21, 2].

Des solutions ont été proposées mais ne sont pas toujours à la hauteur de nos attentes (mettre au point un système de performance presqu’humaine en synthèse automatique des textes). Les plus prometteuses de ces solutions se limitent à des tailles bien réduites de texte, ce qui est déjà un grand pas mais pas suffisant évidemment. C’est pour cette raison qu’il nous semble pertinent d’étudier cette question en profondeur et de mettre au point un système complet et utilisable en dehors du monde de la recherche.

Socialement, la mise au point de ce système sera d’une très grande importance. Cela dans plusieurs axes dont principalement :

Pour les chercheurs, car il pourra faciliter le survol rapide des connaissances provenant SYNTHESE AUTOMATIQUE DES TEXTES



des filières liées à leurs domaines, sans être obligés de consulter à l’avance un tas de documents issus de ces domaines connexes;

Pour tout le monde alors, le système pourra permettre un gain de temps considérable chaque fois qu’il donnera la possibilité d’avoir accès à une synthèse de bonne qualité à la demande, en très peu de temps.

0.6	Objectifs de la recherche

Objectif général

Cette recherche a pour objectif principal de concevoir et réaliser un système (une application web) qui facilitera la génération automatique des synthèses de niveau humain.

Objectifs spécifiques

Pour arriver à bout de notre projet nous comptons :

Évaluer les failles et limites des techniques de synthèse automatique existantes;

Corriger les failles ou compléter les techniques de synthèse automatique existantes; • Établir des architectures logiques optimales pour obtenir des synthèses de qualité;

Élaborer une interface de programmation d’applications devant faciliter l’accès au service de synthèse automatique;

Mettre au point une base de données pour stocker les synthèses les mieux cotées par les usagers, en prévision d’une amélioration future du système;

Réaliser une interface web de qualité pour permettre l’accès au service par divers utilisateurs.

0.7. MÉTHODOLOGIE DE RECHERCHE ET DÉLIMITATION DU TRAVAIL



Méthodologie de recherche et délimitation du travail

Pour la mise au point du système, nous comptons utiliser les méthodes d’analyse moyennant les techniques expérimentale (pour vérifier l’adéquation du fonctionnement de l’application mise sur pied avec le problème posé), et documentaire (pour une vision approfondie des techniques couramment utilisées et d’éventuelles améliorations nécessaires).

Ce travail se focalisera sur la synthèse des documents du type informationnel (livres historiques, discours, articles de presse, lettres, nouvelles, romans et tout autre type de document ayant une faible densité d’expressions mathématiques) et il s’agira d’une synthèse mono-document.

Subdivision du travail

Excepté l’introduction et la conclusion générales, ce travail sera ainsi constitué :

Au premier chapitre, Généralités sur le traitement automatique du langage naturel, nous passerons en revu toute la théorie nécessaire à la compréhension de notre travail.

Au second chapitre, Présentation du résumé automatique et conception de l’architecture du système, nous y présenterons les aspects du résumé automatique essentiels à notre travail et y concevrons pas à pas le système de synthèse automatique des textes dans tous ses aspects (pas uniquement le côté synthèse).

Au troisième chapitre : Conception finale, réalisation et tests, nous y finaliserons la conception et expliquerons les points importants de l’implémentation en nous basant sur la conception faite, puis nous présenterons les résultats des tests que nous aurons effectué.



Chapitre I

Généralitéssurletraitementautomatique du langage naturel

Introduction partielle

Dans ce chapitre, nous allons présenter brièvement le traitement automatique du langage naturel, ainsi que les techniques de traitement qui seront utiles pour la réalisation de l’objectif principal de ce travail. Nous allons donc y présenter une vue d’ensemble des architectures généralement utilisées, en nous focalisant essentiellement sur l’aspect intelligence artificielle du NLP (Natural Language Processing).

Dans un premier temps, nous y présentons quelques techniques, souvent incontournables lorsqu’on veut réaliser une tâche de traitement du langage. Après cela, nous parcourons divers modèles qui nous permettrons d’aborder le modèle le plus adapté à la tâche de synthèse automatique des textes, qui est l’objectif de ce travail.

Présentation et définitions

Le NLP est une discipline rattachée à l’intelligence artificielle et ayant pour principal objectif, l’étude des possibilités du traitement du langage humain par des machines. La raison pour laquelle la discipline s’inscrit comme faisant partie du domaine d’intelligence artificielle est que le langage est considéré comme étant une aptitude centrale de l’intelligence humaine, étant donné que l’usage d’un langage si complexe est l’un des éléments distinctifs principaux entre humains et autres animaux.

Le NLP inclut l’ensemble d’algorithmes, des tâches et des problèmes prenant en entrée

6

I.2. PRÉSENTATION ET DÉFINITIONS



des textes produits par des humains, pour finalement ressortir des informations pertinentes à propos de ces derniers ou alors du texte modifié de façon approprié selon l’objectif poursuivi. C’est ainsi que des tâches comme la traduction automatique, la génération automatique des textes ou aussi la synthèse automatique qui va nous intéresser dans ce travail, produisent directement du texte en sortie.

Mais, dans tous les cas, la sortie est soit immédiatement utilisable, soit alors elle est prise comme entrée d’un autre système dans la chaîne de traitement du texte.

On peut toutefois se demander la raison pour laquelle on parle de traitement automatique du "langage naturel" (quitte à se demander ce qui distinguerait un langage naturel des autres langages).

Pour établir clairement cette différence, il est nécessaire de donner une définition de ce qu’est un langage formel. Pour caricaturer, un langage formel est celui pour lequel il existe un mécanisme fini, et explicite, permettant d’en faire une analyse, quand bien même il serait constitué d’un nombre infini de mots. Donc, c’est un ensemble de mots analysable par un automate (au sens mathématique du terme) [9].

On peut donc comprendre directement que le mot "naturel" est ici utilisé pour faire une distinction avec les langages formels. C’est donc dans ce sens que toutes les langues parlées peuvent être vues comme des langages naturels. Les langages formels ont une syntaxe précise et sont spécifiquement conçus pour des objectifs bien cernés (penser à tous les langages de programmation par exemple). Ils sont donc très précis tant au point de vu grammatical que sémantique.

Concernant les langues humaines usuellement utilisées, on ne peut pas dire, sans être démenti, qu’elles sont dénuées d’imprécisions. Elles regorgent en générale une grande richesse, ce qui a pour conséquence d’introduire très souvent une grande ambiguïté. Pour s’en convaincre, il suffirait par exemple de considérer la phrase suivante :

Je le vois avec mes jumelles.

Très vite on remarque que cette phrase peut s’interpréter selon le contexte. On ne sait pas, en effet, si le sujet affirme voir quelqu’un avec ses jumelles d’observation, se promenant avec ses enfants jumelles, ou si le sujet voit quelque chose en utilisant ses jumelles en tant qu’instrument.

Ceci n’est qu’un exemple particulier pour illustrer cette dichotomie inhérente à l’emploi de la langue quelle qu’elle soit, mais cela suffit pour qu’on s’aperçoive que le problème est bel et bien réel.

Ce n’est d’ailleurs pas juste au niveau des interprétations qu’on peut identifier ce problème. Il s’observe même quand on considère les règles de grammaire. Certaines règles sont ainsi admises par certains linguistes mais rejetées ou trouvées superflues par d’autres [20].

C’est tout ce qui précède qui rend le langage humain à la fois riche et challengeant quand il s’agit de doter les machines de cette aptitude. D’où la raison d’être d’une discipline à part entière dédiée à la mise au point des règles de traitement du langage naturel, le NLP

[17].

I.3	Nécessité de l’approche par deep learning

Avant l’avènement du deep learning, des techniques traditionnelles du NLP étaient utilisées pour des tâches comme la détection des spams, l’analyse des sentiments et le POS (Part Of Speech tagging). Ces approches utilisaient essentiellement des caractéristiques statistiques des séquences comme, la fréquence des mots et les co-occurences par exemple. Néanmoins, le principal désavantage de ces techniques était qu’elles ne parvenaient pas à capturer une grande partie de la complexité linguistique du langage humain, comme par exemple le contexte.

Ainsi, les développements, récents d’ailleurs, des réseaux de neurone et du deep learning ont donné des nouveaux outils, pour approcher dans une large mesure les performances humaines en terme de traitement de langage. A notre avis, ces techniques sont les plus adaptées car, tout d’abord elles se rapprochent beaucoup plus des méthodes de traitement d’information par le cerveau humain, et ensuite, il serait autrement très couteux, voir impossible, d’élaborer des modèles capables d’embrasser toute la complexité du langage humain.

Le deep learning pour le NLP est axé grosso-modo sur la représentation d’entités textu-

I.4. QUELQUES TECHNIQUES COURANTES DE TRAITEMENT DES TEXTES



elles et le traitement élaboré sur ces représentations, de manière à en tirer des informations pertinentes ou à réaliser des transformations appropriées. Cette représentation constitue d’ailleurs un problème fondamental car c’est d’elle que dépend toute la chaîne de traitement des systèmes de NLP [46].

I.4	Quelquestechniquescourantesdetraitementdestextes

Dans cette partie, nous allons présenter diverses techniques intervenant dans le traitement des données de langage naturel. Ces traitements seront présentés de manière à dégager un pattern presque récurrent en terme de structure de traitement pour divers systèmes de NLP. Pour cela, nous allons d’abord présenter certaines manipulations réalisées sur les données en guise de pré-traitement. Puis, nous évoquerons deux techniques utiles aux tâches relevant du NLU (Natural Language Understanding).

I.4.1	La tokenisation (tokenization)

Manipuler des longues chaînes de caractères ne serait pas envisageable. Mais en informatique on est habitué à traiter des structures en terme de listes, de tableaux, de vecteurs,... Le tout étant représenté numériquement. C’est pour cela que l’opération consistant à réduire un corpus de texte en ses tokens est centrale.

Dans notre contexte, la tokenisation est une opération qui consiste à décomposer un texte

(une suite de phrases) en ses phrases constitutives ou une phrase en ses mots constitutifs. Cela est une première étape pour diminuer la difficulté inhérente au traitement des textes. En considérant la décomposition en mots, pour diminuer au maximum les difficultés de traitement et l’ambiguïté, on ajoute à la tokenisation d’autres traitements qui sont en général : la désaccentuation, le passage aux minuscules, la suppression des stopwords, la racinisation et la lemmatisation appliqués aux tokens obtenus [22].

I.4.2	Les stopwords[44]

Les stopwords sont, pour une langue donnée, des mots qui permettent de réaliser des phrases correctes mais qui n’apportent pas directement d’information significative sur l’ensemble (du point de vu traitement). Il s’agit par exemple en français de mots comme de, la, le,... ce qui correspond en gros aux prépositions, aux articles, aux conjonctions,... Il faut néanmoins préciser qu’on peut très bien décider de ne pas supprimer certains stopwords.

I.4.3	La racinisation (stemming)

La racinisation ou stemming en anglais consiste à découper le token de manière à n’en conserver qu’une partie qui semble rendre mieux compte de ce dont dérive ledit token. Seulement, ceci est fait sans se fier à ce que le résultat obtenu en tant que racine fasse partie du dictionnaire de la langue considérée [44, 22].

Cela permet juste de maximiser la probabilité de confondre des mots semblables qui sont présentés différemment dans diverses phrases. C’est à des fins de comparaison de phrases et de réduction d’ambiguïté. Pour illustration, on voudrait par exemple que si on retrouve les éléments "manger", "mange", "mangeable", "mangeons" dans un corpus, qu’ils soient transformés en un seul terme "mange". Cela se fait en découpant tous les mots qui ajoutent



d’autres affixes au terme. C’est cela en bref le stemming et, contrairement à ce que le nom suggère, il ne s’agit pas exactement de trouver la racine des mots (les mots dont ils dérivent). L’opération consiste essentiellement à réaliser un découpage des mots de manière à en supprimer les affixes.

I.4.4	La lemmatisation (lemmatization)

La lemmatisation quant à elle est une opération plus soignée mais plus coûteuse en terme d’implémentation [44, 22]. Elle réalise en fait ce qui n’est pas réalisé par le stemming en ce sens que lemmatiser un token consiste à la transformer en sa racine, et cette dernière doit être présente dans le dictionnaire. Par exemple, pour un mot au pluriel, il s’agira de le remplacer par son singulier, un verbe conjugué, par son infinitif,... Pour illustration, la

I.4. QUELQUES TECHNIQUES COURANTES DE TRAITEMENT DES TEXTES



lemmatisation consisterait à transformer par exemple "va", "allions", "irons" et "allé" par "aller" et "une" et "des" par "un". Cette tâche est grandement facilitée par des techniques de deep learning.

L’obtention des tokens peut également conduire à des tâches plus élaborées comme la détection des entités nommées et l’étiquetage morpho-syntaxique. Il s’agit des tâches très importantes que nous devons nécessairement mentionner.

I.4.5	Reconnaissance d’entités nommées (NER)[44]

La détection des entités nommées (Named Entity Recognition ou NER) consiste à repérer tout ce qui correspond à des noms de personnes, des noms d’organisations ou d’entreprises, des noms de lieux, des quantités, des distances, des valeurs, des dates ou tout autre élément qui constitue une nomination d’une entité existante précise dans un texte donné. Cette tâche est visiblement très importante dans la phase d’interprétation des données textuelles et il s’agit d’un simple problème de classification.

I.4.6	L’étiquetage morpho-syntaxique (POS tagging)

Le Part-Of-Speech tagging est une tâche consistant en gros, à associer aux éléments des textes, des informations grammaticales. En général, il s’agit d’associer aux termes des textes, leur nature grammaticale. Cela consisterait à dire que tel élément est un nom, tel autre un verbe,...[44, 22]

Cette tâche n’est pas une fin en soi. En effet, c’est une première étape dans l’analyse structurelle des textes, permettant de déduire diverses dépendances du point de vu linguistique. Elle est fortement facilitée par des approches basées sur le deep learning comme c’est le cas aussi pour la reconnaissance d’entités nommées.

Nous allons passer sous silence certains autres concepts du NLP comme le sacs de mots et le word embeddings dont nous parlerons dans la partie qui va suivre et qui présentera le résumé automatique, en tant que tâche du NLP.

I.5	Approches du NLP

Comme cela a été maintes fois mentionné, deux approches majeures sont d’usage pour traiter automatiquement les données de langage naturel. Il s’agit de l’approche numérique et de l’approche symbolique ou linguistique. Mais les deux approches sont dans la majorité des cas complétées par certaines heuristiques [31].

En ce qui nous concerne, l’approche sera essentiellement numérique avec un penchant prononcé pour les techniques du deep learning. D’ailleurs, concernant ces dernières techniques, les modèles de l’état de l’art les plus adaptés sont les transformers et leur présentation exige une revue chronologique car en effet, pour y arriver, des modèles classiques basés sur des réseaux de neurones récurrents (RNN) ont été utilisés car plus adaptés aux données séquentielles que sont les textes. Ensuite, le constat de leur mémoire limitée a fait à ce qu’on les modifie pour obtenir des unités à mémoire plus large dont les LSTM(Long Short-Term Memory) et les GRU(Gated Recurrent Unit). Furent ensuite introduits les mécanismes d’attention qui améliorèrent les techniques, aboutissant finalement aux modèles dits transformers, plus adaptés à des tâches de NLP élaborées.

I.5.1	Les réseaux de neurones artificiels (ANN)

Les réseaux de neurones artificiels (Artificial Neural Network ou ANN) sont un ensemble de neurones (artificiels) assemblés pour résoudre des tâches considérées comme requérant une certaine intelligence. Le neurone artificiel est un algorithme élaboré en s’inspirant du modèle théorique simplifié d’un neurone naturel. Il s’agit essentiellement d’une fonction d’agrégation ayant pour rôle de réaliser une somme pondérée des entrées qui lui sont présentées et d’une fonction d’activation qui formate la sortie de la fonction d’agrégation selon les valeurs attendues en sortie [12].

Les neurones sont généralement assemblés par couche comme présenté sur la figure qui suit :





Figure I.1: Réseau de neurones à une couche cachée et sans boucle [47]

Ce qui vient d’être présenté est suffisant pour avoir une idée globale de ce qu’est réellement un réseau de neurones artificiel. Néanmoins, nous pousserons plus loin pour toucher le plus vite possible aux modèles qui nous intéressent dans ce travail.

I.5.2	Les réseaux de neurones récurrents (RNN)

Un RNN(Recurrent Neural Network) est un type de réseaux de neurones conçu en principe pour traiter les données séquentielles, comme les données textuelles,...

La principale différence structurelle entre les ANN simples et les RNN est l’existence des connexions de récurrence dans ces derniers. Il s’agit des boucles permettant la prise en compte des sorties passées dans le traitement final des données [16].

Pour l’illustrer, rien de mieux qu’une image représentant la structure fonctionnelle des réseaux de neurones récurrents :



Figure I.2: Illustration de ce qu’est un RNN [22]

Où xi, hi et A représentent respectivement les entrées (à chaque pas temporel i), les états internes qui en résultent et le module récurent utilisé.

Pour une meilleure compréhension, une présentation formelle serait plus commode : Soient Wx la matrice des poids associée au vecteur d’entrée x, Wy une matrice associée au vecteur de sortie y et Wh celle associée au vecteur représentant les états cachés du réseau, avec bh et by respectivement les vecteurs des biais des neurones pour l’état caché et pour la sortie. Si on nomme aussi par yt la sortie du réseau à un instant donné t, on aura [15] :









ht











yt





= fact (Wxxt +Whht−1 +bh)

		

= gact Wyht +by

(I.1)

On voit très bien que la sortie du système dépend non seulement de l’entrée, mais aussi de l’état du système (h).

Les fonctions d’activation fact et gact qui sont mentionnées dans les équations I.1 représentent respectivement la tangente hyperbolique tanh et la fonction dite sof tmax [15].

L’entraînement des réseaux de neurones récurrents se fait de la même façon que pour les réseaux de neurones simples (avec uniquement une différence due au fait que pour le RNN on prend en compte le temps). On n’entrera pas dans le détail, vu que ce n’est pas exactement le sujet du travail mais, pour entamer la partie qui suit, il nous faut préciser que, comme pour les réseaux de neurones simples, l’entraînement exige d’appliquer une fonction de différentiation sur l’erreur produite par le système. Il s’agit de la fonction gradient. Mais, comme ici le gradient tient compte des grandeurs précédentes dans le temps, il y a un certain nombre de termes multiplicatifs qui peuvent amener le modèle à ne jamais converger ou au contraire, à la saturation. C’est le problème classique d’évanouissement (disparition) des gradients ou d’explosion des gradients [15].

En réponse au problème de disparition des gradients, les cellules LSTM (Long Short-Term Memory) sont utilisées en lieu et place des cellules RNN normales.

Les cellules LSTM

Les cellules LSTM (pour Long Short-Term Memory) sont utilisées en lieu et place des cellules RNN classiques (dites vanilla) pour permettre au réseau de traiter des séquences de plus en plus longues sans perte rapide d’information [16]. Pour cela, des éléments de contrôle de la mémoire de la cellule sont ajoutés. Pour illustrer nos propos, voici une image qui nous permettra de différencier une cellule RNN classique d’une cellule LSTM :



Figure I.3: Comparaison entre cellules RNN classique et LSTM [18]

Présentée comme cela, la cellule LSTM semble superflue mais si on présentait les équations associées à un réseau fait de ces cellules, on se rendra compte que c’est plutôt intuitif. Pour aborder les équations associées, considérons l’image suivante :



Figure I.4: Vue fonctionnelle d’une cellule LSTM [18]

Une cellule LSTM se comprend en la considérant comme constituée d’un ensemble de portes avec des fonctions bien particulières. Il s’agit d’une porte d’entrée, une porte d’oubli et une porte de sortie.

Il est évident que, pour chacune de ces portes que nous nommerons, à un instant t donné par It, Ft et Ot, le système doit apprendre ses paramètres en fonction de l’entrée et de l’état interne. Mais on doit aussi remarquer que, l’état est défini par deux paramètres au lieu d’un seul comme pour les RNN simples. Il s’agit, à un instant t donné, de ht (considéré comme état à court terme) et de ct (qui est un état à long terme mais dont le contenu est contrôlé, au vu de l’architecture de la cellule).

De ce que nous venons de dire, nous pouvons conclure que Ft, It et Ot sont des fonctions de Xt et de ht−1 aux poids près. On sait aussi que, si on veut une mémoire à long terme contrôlée, la valeur finale de ct doit être mise à jour en repérant ce qui doit être oublié parmi les éléments qui étaient précédemment dans la mémoire, pour y ajouter ensuite ce qui est sélectionné comme pertinent à l’entrée. Cela revient à utiliser Ft et It comme des portes de contrôle (ou de sélection). Et de cela on peut conclure que c’est plus intéressant d’avoir Ft et It qui prennent des valeurs entre 0 et 1 (pour modéliser la sélection) et ct devra dépendre de ces deux éléments, avec aussi l’état précédent de la mémoire à long terme.

Il est aussi vraisemblable que, l’état à court terme doit provenir de la mémoire à long terme (ça correspondra à une sélection de ce qui doit être pris en compte directement dans la mémoire à long terme). Cet état ht doit par conséquent dépendre de ct (il faut néanmoins noter qu’une autre approche serait possible ici, mais celle-ci est déjà pertinente). Finalement, on sait que la sortie finale doit nécessairement dépendre de l’état interne de la cellule. Il va ici s’agir de ht vu que la cellule est développée par analogie avec le processus de mémorisation des systèmes naturels (mémoire à court terme correspondant à la mémoire de travail).

De ce qu’on vient de dire on peut tirer que, fondamentalement on doit avoir :







 F

 t













I  t









  O

 t







 c  t









  h  t









  y  t



= F (Xt,ht−1) = G(Xt,ht−1) = J (Xt,ht−1)

= K(ct−1,Xt,ht−1)

= L(ct)

= M(ht)

(I.2)

Avec F ,G,J ,K,L,M des fonctions dépendant des coefficients considérés (poids et/ou éléments de sélection qui sont les diverses portes définies).

Une implémentation classique de ce raisonnement se présente comme suit [16, 15] :







 F

 t













I  t









  O

 t







 c  t









  h  t









  y  t



		

= σ Wf xXt +Wf hht−1 +bf

		

= σ WixXt +Wf iht−1 +bi

= σ (WoxXt +Wohht−1 +bo)

= Ft ◦ct−1 +It ◦tanh(WcxXt +Wchht−1 +bc)

= Ot ◦tanh(ct)

= Wyhht +by

(I.3)

Il faut remarquer qu’on a utilisé la fonction sigmoïde σ pour restreindre les valeurs des sélecteurs (portes) entre 0 et 1, puis on a utilisé le produit de Hadamard (produit terme à terme des matrices) pour réaliser effectivement la sélection grâce aux portes, en diminuant les termes dont les valeurs correspondantes des portes sont proches de 0 et en essayant de conserver ceux dont les valeurs correspondantes des portes sont proches de 1.

Cette implémentation peut être modifiée, surtout en ce qui concerne les fonctions d’activation utilisées (σ et tanh), et en particulier la fonction d’activation de finalisation tanh ici, mais c’est l’une des plus optimales.

Le seul problème qui demeure est que le nombre de termes à apprendre est très grand. Cela a fait à ce qu’on puisse essayer de le diminuer en implémentant le GRU (Gated Recurrent Unit) poussant un peu plus loin l’abstraction des portes pour diminuer le nombre de paramètres.

Les cellules GRU

Les cellules GRU (Gated Recurrent Unit) sont une autre implémentation des cellules des réseaux de neurones récurrents comme les LSTM à la différence près que, bien que partant de la même idée fondamentale évoquée précédemment, les GRU apparaissent comme une simplification des LSTM.

Elles possèdent néanmoins des performances comparables en ce qui concerne la prédiction des séries temporelles,... Les simplifications sont réalisées au niveau des états cachés et des portes. On conserve un seul état caché h (quitte à le contrôler à l’interne pour implémenter la mémorisation à long terme et à court terme). Et pour les portes, on fusionne les portes de sélection des entrées avec celle des éléments à oublier (donc les portes I et F) pour former une porte dite de mise à jour (porte qui sera appelée update ou U). La porte de sélection des éléments de sortie quant à elle, est transformée en porte de réinitialisation.

Ces deux portes (de mise à jour et de réinitialisation) sont en fait implémentées de façon identique que celles des cellules LSTM. La particularité des GRU se situe principalement au niveau de la gestion de la mémoire (l’implémentation du processus de mémorisation) car, ayant supprimé la distinction long-terme/court-terme, il fallait bien trouver un mécanisme devant permettre de bien gérer les deux aspects de la mémoire avec un seul état interne conservé.

C’est ainsi que, la porte de mise à jour (porte U) est introduite dans le calcul de l’état h pour assurer la sélection du type de mise à jour à effectuer. Il s’agit de faire en sorte que, selon l’état interne et l’entrée, tout l’état interne précédent soit considéré mais que certains éléments soient complètement modifiés, selon le besoin, et d’autres presque conservés.

Ainsi donc, h devient une combinaison d’éléments provenant de l’état interne précédent avec ceux provenant des nouveaux calculs effectués par la cellule (en fonction de l’entrée et de l’état interne précédent). Le comportement est alors le suivant :

Quand le vecteur de mise à jour a un terme proche de 1, cet état interne est presque conservé. Par conséquent, sa mise à jour est presque ignorée. Quand c’est plutôt 0, l’état interne précédent est presque ignorée et une mise à jour complète de cet état est effectuée.

La formulation mathématique permet de mieux en saisir le fonctionnement [16, 15] :







 U

 t









  R

 t







 h  t









  y  t



= σ (WuxXt +Wuhht−1 +bu)

= σ (WrxXt +Wriht−1 +br)

= Ut ◦ht−1 +(1−Ut)◦tanh(WhxXt +Whr (Rtht−1)+bc)

= Wyhht +by

(I.4)

Et pour illustration, on peut considérer l’image suivante :



Figure I.5: Cellule GRU [18]

Il faut noter que sur cette image (figure I.5), l’implémentation de la mise à jour est l’inverse de celle que nous avons décrit par les équations I.4. C’est-à-dire que les termes Ut et (1−Ut) sont permutés. Mais aussi, ici Zt représente Ut.

Ces modèles fonctionnent très bien et certaines implémentations permettent d’améliorer encore leurs performances. Ils sont néanmoins lents à entraîner, surtout à cause de l’aspect temporel. Parmi les techniques d’amélioration des performances, une peut être considérée car elle a un rapport direct avec notre travail. Il s’agit des mécanismes d’attention [3].

I.5.3	Mécanismes d’attention

Les mécanismes d’attention sont en bref des techniques permettant de lutter contre la perte de mémoire qu’on constate par exemple dans les cellules récurrentes ci-haut décrites, en se focalisant sur des éléments les plus importants à chaque traitement. Le travail consiste donc à repérer, pour chaque entrée, les éléments sur lesquels se focaliser.

C’est là qu’interviennent donc ces mécanismes.

L’une des implémentations les plus commodes est l’attention globale [30].

Pour l’expliquer, nous allons considérer une architecture jusque là passée sous silence, mais qui permet aux modèles introduits là haut de s’utiliser efficacement pour les tâches courantes du NLP en particulier. Il s’agit des modèles dits encodeur-décodeur.

En effet, lorsqu’on a un modèle à séquence fonctionnel, les objectifs peuvent être multiples. On peut vouloir :

1°) fournir une série d’éléments en entrée et ressortir une autre série (utile pour la prédiction de la valeur des actions par exemple,... );

2°) fournir un série en entrée mais faire ressortir un seul élément ou vecteur (utile pour la classification des textes, l’analyse des sentiments,...);

3°) fournir un vecteur plusieurs fois en entrée et produire une série (pour la génération des légendes pour des images par exemple,...);

4°) on peut aussi avoir un réseau série-vers-vecteur, appelé encodeur, suivi d’un réseau vecteur-vers-série, appelé décodeur (très utile pour la traduction et la synthèse automatique par exemple,...). Il s’agit du modèle encodeur-décodeur.

Une illustration par image sera suffisante :



Figure I.6: Réseaux série-vers-série (en haut à gauche), série-vers-vecteur (en haut à

droite), vecteur-vers-série (en bas à gauche) et encodeur-décodeur (en bas à droite) [16]

.

L’élément (le vecteur d’état) passé entre l’encodeur et le décodeur est dit vecteur de contexte. Il représente en quelques sortes un condensé des informations passés à l’entrée de l’encodeur. Toutefois, plus la séquence d’entrée est longue, plus le risque que la mémoire de certaines séquences puisse s’étioler devient grand. Ainsi, si par exemple on est entrain de vouloir traduire une longue phrase, on peut finir par transmettre un vecteur de contexte qui a perdu toute information sur les premiers éléments de la séquence passée en entrée. C’est pour cela qu’au lieu de passer un vecteur de contexte général, les mécanismes d’attention permettraient ici de ne se focaliser que sur certaines informations lors du traitement d’un élément particulier de la séquence (en ayant évidemment passé tous les états internes passés au décodeur). Pour le réaliser concrètement, le mécanisme d’attention global consiste à formater le vecteur de contexte en fonction des éléments de l’encodeur à prendre en compte lors du traitement par le décodeur.

Considérons que Ω, dont les termes sont représentés par wij, est la matrice des poids d’attention normalisés par une fonction softmax pour chaque ligne. Et que Π, dont les termes sont représentés par αij, est la matrice des poids d’attention générée par le mécanismes avant normalisation.Si les éléments ci représentent à chaque fois le vecteur contexte final à l’étape i de décodage et les hj sont les vecteurs d’état interne de l’encodeur, l’attention globale revient à réaliser la manipulation suivante, pour formater le vecteur de contexte à prendre en compte pour l’élément en cours de traitement [30] :

	wij	= sof tmax(αij) = Pekαeijαik	(I.5)



	ci	= Pj wijhj

La dernière relation du système I.5 revient à réaliser une somme pondérée des vecteurs d’état internes passés de l’encodeur, selon l’importance de chaque état pour le traitement en cours. De ces équations il faut aussi remarquer que la notation des sommations n’est pas rigoureuse. Cela est volontaire car c’est intuitif (on réalise des sommations sur tous les éléments).

Plusieurs techniques arrivant à réaliser l’attention existent. En général, comme on peut d’ailleurs le déduire des relations de l’attention globale, ces mécanismes étaient utilisés dans le cadre des réseaux récurrents. Une question s’est toutefois naturellement posée : ne pourrait-on pas se passer des RNN pour mettre au point des réseaux complètement basés sur l’attention ?. La réponse est oui, avec des ajustements adéquats pour résoudre les faiblesses des modèles classiques dans le traitement des données séquentielles. C’est cela qui a conduit aux modèles dits transformers [50].

I.5.4	Les transformers

Il s’agit des modèles dont l’architecture générique se présente comme suit :



Figure I.7: Architecture générique des transformers [50]

Les transformers sont des modèles du type encodeur-décodeur comme on peut le constater sur la figure ci-dessus (bien que certaines implémentations n’en utilisent qu’une partie selon la tâche). Ils sont essentiellement basé sur les mécanismes d’attention, se passant de la récurrence [16, 15].

Nous donnerons une explication succincte de chacun des modules présents dans l’image I.7. En effet, présentons les modules selon l’ordre dans lequel les données traversent le modèle :

1°) Moduled’embedding : Nous savons que les données textuelles doivent être présentées au modèle sous forme numérique. Elles doivent donc être transformées avant de les passer aux parties suivantes. Néanmoins, vu que la représentation des entrées a

un impact significatif sur les performances d’un modèle, cette représentation doit être bien choisie. Un choix intuitif, et qui s’avère être performant, est de tout faire pour que si deux termes ont des sens proches, ils aient aussi des représentations vectorielles proches. Cela est réalisé par différentes techniques que nous présenterons dans le chapitre suivant, mais c’est là le rôle de la couche d’enchâssement (embedding).

2°) L’encodage positionnel (positionnal encoding) : Ce module ajoute l’information sur la position relative de chacun des éléments placés en entrée par rapport aux autres. Cela pallie au problème de perte d’information sur la position des mots quand on utilise un réseau non séquentiel comme les réseaux récurrents. Donc, la position de chaque terme de la séquence placée en entrée est encodée dans un vecteur puis ajoutée à l’encodage global du terme. L’un des encodages les plus utilisés est celui basé sur les fonctions trigonométriques tel qu’introduit dans [50].

3°) Module d’auto-attention : La couche d’attention, présentée en première position dans la boîte de l’encodeur, est en fait une couche dite de self-attention car elle opère sur la même séquence d’entrée. L’opération est réalisée pour permettre au modèle d’avoir une représentation de l’importance des termes dans la séquence d’entrée, les uns par rapport aux autres.

Pour illustration, considérons la phrase suivante : Walter est malade, il préfère se reposer.

Dans cette phrase, l’un des constats qu’on peut faire est que, le nom "Walter" est beaucoup plus lié au pronom "il" qu’au verbe "préférer". C’est à l’établissement des tels liens dans les représentations que sert le module d’auto-attention ici présenté. Il est important que ce lien soit implicitement présent dans les représentations, pour que le traitement soit efficace comme on l’a mentionné lors de la présentation des mécanismes d’attention. Donc cette couche est en fait un prolongement de celle d’embedding. Ici, le mécanisme d’attention utilisé est différent de celui qui a été présenté là-haut (attention globale). Il s’agit ici d’un mécanisme plutôt basé sur le produit scalaire mis à l’échelle (scaled dot-product). En effet, très brièvement, l’idée du scaled dot-product attention consiste à opérer une recherche des termes sur lesquels focaliser l’attention de la même façon qu’on réalise la recherche de la signification d’un mot dans un dictionnaire. Supposons qu’on veuille avoir la signification d’un mot dont on ne connaît pas l’orthographe exacte. Pour retrouver ce dernier dans un dictionnaire, il suffit de rechercher le mot qui ressemble le plus à l’orthographe que nous estimons être la plus vraisemblable. Mathématiquement, cette recherche de similitude correspond à un produit scalaire.

Similairement, le scaled dot-product consiste à générer trois éléments qui sont la clé ou key k, la valeur ou value v et la requête ou query q. La requête correspond au mot



qu’on cherche (orthographié selon ce que nous pensons), la clé correspond au mot présent dans le dictionnaire et la valeur correspond à la signification associée. Si on supposait qu’il existe plusieurs termes du dictionnaire qui s’orthographient presque de la même façon que le mot qu’on cherche, on devra passer par une mesure de similarité avant de se décider sur le sens le plus probable. Cela correspond à réaliser le produit de tous les k par les q présents, puis à normaliser l’ensemble des résultats de manière à ce qu’ils représentent des mesures de probabilité, et finir par choisir le sens v le plus probable.

Pour aller plus vite, on implémente ce processus en considérant tous les k, q et v au même moment de manière à réaliser le calcul une fois pour toutes. Cela revient à regrouper tous les k, q et v dans des matrices K, Q et V . Ce qui donne la relation qui définit l’attention par produit scalaire mis à l’échelle [50] :

Q ·KT 

Attention(Q,K,V ) = sof tmax p	·V	(I.6) 	dk 



Dans cette relation, expression I.6, le terme pdk permet de mettre à l’échelle le résultat du produit scalaire de Q par K, c’est-à-dire Q·KT . Il faut noter que dk est la dimension d’une clé, et que cette normalisation permet d’améliorer les performances du modèle mais elle n’est pas la seule envisageable.

Il est aussi important de remarquer que la couche d’attention utilise trois termes pour arriver à bout du problème. Ces trois termes sont obtenus par une transformation linéaire dont les poids sont appris à travers un réseau de neurones simple.

Il faut aussi noter que l’on utilise parallèlement plusieurs modules d’attention pour capture toutes les caractéristiques des séquences (on parle de multi-head attention). Pour une plus ample illustration, voir la figure I.8.

4°) Le module feed-forward : Il s’agit en fait d’un réseau de neurones de propagation avant classique (réseau à couches ajoutées de façon séquentielle). Il permet de réaliser le traitement qui fait suite à l’attention.

5°) Couche d’attention encodeur-décodeur : Il s’agit de la couche qui reçoit les données en provenance de l’encodeur. Il s’agit ici d’une couche d’attention et non d’autoattention comme c’était le cas pour la première couche de l’encodeur. En effet, contrairement à la couche de self-attention, pour laquelle tous les trois paramètres sont calculés à partir de la même séquence, la couche d’attention ici prend les clés K et valeurs V provenant de l’encodeur mais une requête Q provenant du décodeur.

Une autre couche feed-forward suit celle-ci et a le même rôle que celle de l’encodeur.

6°) Module d’attention masquée : Il s’agit de la première couche du décodeur. C’est aussi un module de self-attention auquel on ajoute le masquage. Ce module est dit masqué suite au fait que, comme le décodeur est un module de génération, on ne regarde que les termes précédemment générés, en masquant les termes qui seront probablement générés aux pas d’après. Cela est réalisé en rendant juste leurs probabilités nulles.

7°) Module linéaire final : Il s’agit d’un réseau de neurones classique pour réaliser la déduction finale, le tout étant passé à la fin à travers une opération softmax qui permet de transformer les résultats en probabilité d’éléments générés (cela permet de choisir le terme le plus vraisemblable à générer comme sortie).

Cette explication simplifiée se comprend mieux si on y joint la vue éclatée suivante :



I.6. CONCLUSION PARTIELLE



Figure I.8: Vue éclatée d’un transformer [51]

Les transformers, ici succinctement présentés, sont un modèle très adapté aux tâches de traitement automatique du langage naturel. C’est un modèle incontournable vu aussi que ses traitements peuvent être facilement parallélisés. Cela est rendu possible par le fait que l’architecture des transformers est parallèle par essence.

I.6	Conclusion partielle

Nous venons de réaliser une vue d’ensemble du domaine de traitement automatique du langage naturel, ainsi que diverses techniques couramment utilisées. Pour cela, nous avons tout d’abord justifié la préséance des modèles basés sur le deep learning pour diverses tâches du NLP.

Ensuite, nous avons évoqué les technique de pré-traitement des textes, souvent incontournables, comme la réduction des séquences en leurs tokens constitutifs, la suppression des mots fréquents mais n’apportant pas assez d’informations et la réduction des mots en leurs racines respectives. Nous y avons aussi joint quelques techniques utiles à la compréhension du langage humain comme le POS tagging et la reconnaissance d’entités nommées. Ce qui précède nous a finalement conduit à présenter les modèles courants du NLP basés sur les RNNs et, nous avons terminé par la présentation de l’architecture transformer, modèle que nous utiliserons pour ce travail (les précisions sur les modèles particuliers seront données au chapitre suivant).

Les transformers constituent un type de modèle qui s’avère être le plus adapté (pour le moment) au résumé automatique du texte et, dans le chapitre suivant, nous commencerons par présenter les diverses spécificités du résumé automatique comme tâche du NLP, pour finir par présenter l’architecture globale du système que nous comptons élaborer.

Chapitre II

Présentation du résumé automatique et conception du système

II.1	Introduction partielle

Le résumé automatique étant le sujet principal de ce mémoire, dans cette partie nous le présentons alors en détail en tant que discipline et tâche du NLP. Nous allons ici présenter les théories sur la synthèse automatique des textes, en classifiant les diverses méthodes utilisées pour pouvoir situer notre système dans l’ensemble des travaux jusque-là menés sur ce sujet.

Ensuite, nous présenterons les diverses approches utilisées pour le résumé automatique, sans oublier d’approfondir notre présentation des modèles de type transformer adaptés à cette tâche, pour finalement mentionner le modèle que nous estimons le plus adapté concernant l’approche basée sur le deep-learning pour la synthèse automatique. Enfin, nous allons réaliser une conception rapide mais suffisante de l’architecture globale de notre système, tout en précisant le rôle et le fonctionnement de chaque partie.

II.2	Présentation et définitions

Selon Le Petit Robert, résumer c’est reprendre en plus court un discours, le présenter brièvement en conservant l’essentiel. En d’autres termes, c’est l’abréger, l’écourter, le réduire. De même, en tant qu’exercice intellectuel, le résumé, consiste à réduire un texte tout en lui restant fidèle. Il exige donc de restituer les idées en un nombre déterminé de mots, en évitant au mieux de recopier le texte à résumer. Il faut alors composer un texte

29

plus court qui contienne l’essentiel du message initial.

De cela on tire que le résumé devient automatique s’il est généré par un logiciel ou un système informatique.

Cette définition est en fait correcte bien qu’elle ne soit assez précise pour notre contexte. Il nous faut une définition assez générale et précise, embrassant au mieux l’aspect automatique, ou mieux, l’aspect informatique, qui nous intéresse dans ce mémoire. Une définition assez valable est celle de TORRES-MORENO Juan-Manuel qui dit qu’un résumé automatique est un texte généré par un logiciel, cohérent et contenant une partie importante des informations pertinentes de la source, et dont le taux de compression est inférieur au tiers de la taille du(des) document(s) source(s) [48].

L’introduction du taux de compression dans la définition n’est pas anodine car, on s’est très vite rendu compte que la performance d’un système de résumé automatique dépendait fortement du taux de compression. En effet, les études de [26] montrent que les meilleures performances des systèmes de résumé automatique sont généralement atteintes pour des taux de compression compris entre 15 et 30% [48].

Nous allons adopter, dans ce travail, la définition de TORRES-MORENO Juan-Manuel ci-haut présentée.

Toutefois, on ne doit pas manquer de signaler que la génération automatique des résumés est un problème complexe en soi, tout comme l’évaluation des résultats. Le résumé est en effet une tâche cognitive requérant la compréhension du texte considéré et, les humains n’étant pas toujours bons dans les tâches de synthèse, le manque d’étalon explique qu’il y ait également une difficulté d’automatisation du processus.

II.3	Catégorisation des résumés

Les résumés peuvent être classifiés selon différents critères tels que leur fonction, le nombre de documents source, le genre de document, le type de résumé, le type de résumeur, le contexte,...



II.3. CATÉGORISATION DES RÉSUMÉS

Parcourons de manière succincte ces différents critères de classification [36, 31, 32, 38, 37, 48] :

II.3.1	Selon la fonction

Selon leur fonction, on classifie les résumés en deux groupes qui sont le résumé indicatif et le résumé informatif.

Résumé indicatif

Tel une table des matières, un résumé indicatif renseigne le lecteur sur les thèmes abordés dans un document. Il liste donc les sujets les plus importants évoqués par le texte. Certains systèmes de résumé guidé génèrent un résumé indicatif du texte comme étape initiale, l’utilisateur choisit alors parmi les sujets proposés par le résumé ceux qui l’intéressent et le système produit enfin un résumé informatif du texte guidé par la requête de l’utilisateur. La requête dans ce cas est l’ensemble des sujets sélectionnés à partir du résumé indicatif.

Résumé informatif

Il s’agit d’un modèle rétréci du texte d’origine, relatant le plus largement possible les informations contenues dans celui-ci. Ce type de résumé répond souvent à une attente en résumant de plus le contenu. La problématique ici est donc double : comprendre ce qui n’est pas information dans un texte et connaître le besoin de l’utilisateur final. Néanmoins, si on n’a pas de requête spécifique de la part de l’utilisateur, le résumé informatif est réalisé en veillant à ce que l’ensemble des principaux sujets du texte d’origine soit rapporté. Ainsi, les sujets principaux qui sont rappelés dans le résumé sont répartis de manière fidèle par rapport à l’organisation initiale afin de donner un juste aperçu du texte source.

II.3.2	Selon le nombre de documents source

Selon le nombre de documents source on a les résumés mono-document et multidocument.

Résumé mono-document

Il consiste à résumer un document isolé. Le corpus de documents source est donc ici constitué d’un seul et unique document.

Résumé multi-document

Il s’agit d’un résumé de plusieurs documents (un groupe de documents), très souvent liés thématiquement, en faisant attention à ne pas insérer des informations déjà évoquées.

II.3.3	Selon le genre des documents

Résumé des documents journalistiques

Il s’agit de résumer les documents du type article de presse (sachant qu’ils ont une structure particulière). En effet, on sait par exemple que dans le domaine journalistique, les informations les plus importantes sont souvent mentionnées au début du texte.[36]

Résumé des documents spécialisés

Il s’agit de résumer des documents en provenance d’un domaine précis (géologie, médecine, mathématique,...), fortement spécialisé.

Résumé des documents littéraires

C’est le résumé de documents du type narratif, des textes littéraires, des textes argumentatifs, ...

II.3. CATÉGORISATION DES RÉSUMÉS

Résumé des documents encyclopédiques

Ici il s’agit de résumer des documents de type encyclopédique (en général multithématiques de toute évidence) à l’exemple de Wikipédia...

II.3.4	Selon le type de sortie (résumé obtenu)

Cette classification est très importante et très utilisée. Il s’agit des :

Résumés extractifs (extractive summarization)

Le résumé extrait est formé de segments de texte extraits du(des) document(s) source(s). Ces segments peuvent être des phrases, des propositions ou n’importe quelle unité textuelle présent dans le(s) document(s) à résumer. Le problème consiste donc à repérer les segments de texte qui semblent être les plus pertinents pour faire partie du résumé final. Les éléments obtenus à la fin sont donc explicitement présents dans le(s) document(s) source(s).

Résumés abstractifs (abstractive summarization)

Les méthodes de résumé abstractives imitent, jusqu’à un certain degré, le processus naturel accompli par l’homme pour résumer un document. Par conséquent, elles produisent des résumés plus similaires aux résumés manuels (humains). Ce processus peut être décrit par deux étapes majeures : la compréhension du texte source et la génération du résumé. La première étape vise à analyser sémantiquement le contenu du texte et à identifier les parties à exprimer dans le résumé. C’est en quelques sortes une tâche d’extraction d’information liée au domaine abordé ou de regroupement des phrases du texte source. Vient ensuite la génération du texte.

Bref, on produit un résumé rapportant le contenu du(des) texte(s) source(s) en utilisant un vocabulaire différent et plus concis.

Il existe aussi des résumés dits semi-extractifs, et même aussi des résumés dits par compression [48] mais nous estimons inutile de les décrire ici étant donné que la distinction abstractif-extractif suffit pour notre contexte.

II.3.5	Selon le type de résumeur

Le résumeur est le système qui réalise le résumé. Il peut s’agir d’une entité naturelle (un humain) ou artificielle (un logiciel). On a donc essentiellement les deux cas suivants :

Résumé humain (manuel)

Il s’agit d’un résumé réalisé par un humain. Il peut être fait par l’auteur même du document (on parle souvent de résumé d’auteur), par un expert du domaine traité (on parle souvent de résumé d’expert) ou par un professionnel de résumé (on parle de résumé professionnel).

Résumé automatique

Il s’agit, comme on l’a maintes fois mentionné, d’un résumé fait par un système informatique.

II.3.6	Selon le contexte

Résumé générique

Ici on résume le document sans prendre en compte les besoins d’information de l’utilisateur. On produit juste un résumé complet et le plus mieux fait possible.

Résumé guidé

Pour ces types de résumé, l’utilisateur commande la génération du résumé en précisant les types d’information dont il a besoin.

Résumé mis à jour

Il s’agit d’un résumé de type dynamique par essence. Ici, un ensemble de documents sources est résumé en veillant minutieusement à ce que le document dont le résumé est ajouté à la suite d’un précédent résumé ne puisse pas créer une répétition d’information.

Il y a donc un contrôle de nouveauté.



II.3.7	Selon le destinataire du résumé

On peut aussi classifier un résumé selon le public auquel il est destiné.

Résumé sans profil

Il s’agit d’un résumé qui ne tient pas compte d’un quelconque profil utilisateur. Le résumé est donc généré sans tenir compte de la personnalité des utilisateurs.

Résumé avec profil

Il s’agit d’un résumé dont l’un des éléments guides (requête) est le profil des individus auxquels le résumé est destiné.

En ce qui concerne notre système, nous implémenterons à la fois un résumeur abstractif et un résumeur extractif et ce sera mono-document. En plus de cela, le résumé ne sera pas guidé, il s’agira de produire des résumés génériques, pour des documents de type littéraire (documents du type narratif, des textes littéraires, des textes argumentatifs,...).

II.4	Approches de résumé automatique

Nous allons présenter ici diverses approches algorithmiques pour résumer les documents textuels. Les approches seront abordées en supposant que les résumés sont principalement classés en abstractif et extractif.

II.4.1	Techniques intuitives de résumé [36]

Avec des critères centrés sur le contenu des textes, il existe un grand nombre d’algorithmes assez triviaux de résumé, qui sont basés entre autres sur : • La fréquence d’occurrence des mots et

• L’annotation en rôle sémantique.

Ces critères mettent l’accent sur le contenu du texte et le message qu’il communique.

Fréquence d’occurrence des mots

L’idée majeure des techniques qui utilisent ce critère consiste à considérer que les mots les plus fréquents sont les plus liés au sujet principal du texte à résumer. Cette approche assez simpliste mais fonctionnelle fut introduite en 1958 par Luhn [29], une première tentative de résumé automatique.

On affecte des scores aux phrases présentes dans le texte, en additionnant chaque fois les poids des mots les constituant (on attribue ce poids en fonction de la fréquence d’apparition du mot considéré dans le texte entier). Et, à la fin, le résumé est constitué avec les phrases extraites du texte source, et dont le score dépasse un certain seuil dépendant de la taille maximale imposée pour le résumé. Le tout est finalement réarrangé selon l’ordre d’apparition (des phrases sélectionnées) dans le texte d’origine.

L’annotation en rôle sémantique

Ici, l’idée est simple. En utilisant des techniques de repérage d’entités nommées (voir le chapitre précédent), on identifie les entités présentes dans le document. Après cela, l’entité la plus fréquente est identifiée et considérée comme entité principale. Par la suite, les phrases contenant cette entité sont sélectionnées. Enfin, seules les phrases où l’entité principale possède un rôle sémantique fondamental (non auxiliaire) sont gardées pour le résumé.

L’un des moyens les plus simples pour repérer les entités nommées est de passer par l’apprentissage profond comme on l’a précédemment mentionné.

Il existe tout de même des techniques qui ne se fient qu’à la forme et à la structure du texte, sans en considérer le contenu. L’intuition derrière cette approche est basée sur le constat que dans un texte, les éléments ne sont pas présentés de façon arbitraire. De manière usuelle, les techniques utilisées se basent sur :

La position des phrases;

La similarité avec le titre

La longueur des phrases ou sinon,

Les mots indices (cue word)

La position des phrases

Cette approche est à appliquer en fonction de la nature du document et de son genre. Pour certains types de documents (documents journalistiques par exemple), les phrases se trouvant au début sont généralement plus informatives et décrivent le sujet principal du document. De plus, les phrases situées au début de chaque paragraphe tendent à apporter plus d’informations pertinentes. Le résumé des articles scientifiques par contre, peut essentiellement se former en se basant sur les contenus des parties résumé et introduction (sous l’hypothèse que ces dernières parties sont bien faites). En revanche, dans le cas des revues intégratives (critique et comparaison des études), les phrases les mieux notées sont celles des parties résultats et discussion et conclusion.

Ces exemples suffisent pour illustrer dans quelle mesure cette approche peut s’appliquer.

La similarité avec le titre

Cette approche part du principe selon lequel un bon titre doit informer de manière brève du contenu principal du texte qu’il encadre. Cela permet alors de fixer comme mesure de pertinence des phrases, leur similarité avec les titres. Toute la problématique se réduit donc à la construction d’algorithmes capables de capturer efficacement la similarité.

La longueur des phrases

L’approche consistant à se baser sur la longueur des phrases est assez naïve mais fonctionnelle.

En effet, la longueur moyenne d’une phrase dans un texte dépend de son genre. Généralement, les phrases très courtes sont considérées comme peu informatives alors que les phrases très longues sont présumées favoriser la redondance. Cette caractéristique est exploitée en fixant un intervalle de longueur (entre 15 et 30 mots). Une phrase ayant une longueur en dehors de cet intervalle est pénalisée [45].

Les mots indices

Ici, on considère une liste de mots, constituée manuellement, et qui a comme rôle de permettre de se décider si une phrase doit être prise dans le résumé ou rejetée, selon qu’elle contient ou non un(des) mot(s) de la liste qualifié(s) inhibiteur(s) ou valorisant(s). Comme exemple des mots ou groupes de mots inhibiteurs on trouve : par exemple, accessoirement, ... Et pour les mots valorisants on peut citer : notez bien, ...

Nous devons quand même préciser encore une fois que tout dépend de celui qui écrit la liste.

Les méthodes que nous venons de présenter sont assez intuitives mais constituent la base des processus de synthèse. En effet, synthétiser un texte revient au fond à implémenter un certain nombre de règles, dont font parties évidemment celles que nous venons de mentionner. Néanmoins, ce que nous venons de présenter est décrit en se basant sur le concept de résumé extractif. Nous devons toutefois signaler que les résumés abstractifs se basent au fond sur les mêmes principes, soit en partant des résumés extractifs pour ensuite réaliser des paraphrases, insérer des connecteurs appropriés et éliminer les références anaphoriques dans les résumés, soit en implémentant indirectement toutes ces techniques à travers un modèle d’apprentissage automatique ou un modèle basé sur les graphes capables de capturer d’un seul coup tous ces aspects (ou une grande partie d’entre-eux). Les techniques intuitives ci-haut présentées ne sont pas les seules. Il en existe également d’autres, basées essentiellement sur les théories linguistiques. Entre autres les méthodes d’analyse du discours (par exemple la RST [31] ou Rhetorical Structure Theory)...

II.4.2	Algorithmes classiques de résumé automatique

Comme nous venons de l’introduire dans la section précédente, le résumé automatique est abordé essentiellement selon deux approches qui sont [31] :

1°) Les approches numériques, fondées sur les techniques à base des scores (poids), et

2°) Les approches symboliques fondées sur les techniques purement linguistiques, basées en premier sur une étude sémantique.

Il faut noter qu’on peut considérer aussi des approches basées sur la théorie des graphes comme intégrant les idées de ces deux approches de façon implicite, tout comme celles basées sur l’apprentissage automatique. Mais, dans tous les cas, une vue sur quelques heuristiques (méthodes basées sur le bon sens) est toujours à considérer (surtout en amont, puis en aval du processus de synthèse).

Ici, nous allons présenter les approches essentiellement numériques (on va y inclure celles basées sur l’apprentissage automatique et celles basées sur la théorie des graphes).

Algorithme de Luhn [29]

Il s’agit d’une méthode heuristique pour la synthèse des documents. C’est la plus ancienne méthode de résumé automatique (au sens moderne du terme).

Cette approche n’est pas considérée comme très bien formalisée. Elle exécute implicitement l’approche du TfIdf que nous allons décrire dans la sous-section qui suit celle-ci (sous-section II.4.2).

La sélection (des mots ici) se fait en considérant les hypothèses qui suivent :

la synthèse consiste à supprimer certains mots pour n’en conserver que les plus importants;

les mots se trouvant au début sont probablement importants;

les autres mots utiles respectent une certaine distribution. La figure II.1 montre, selon Luhn, comment choisir ces mots importants (partie hachurée de la courbe).



Figure II.1: Diagramme des fréquences des mots et le choix de Luhn [29]

Cette approche, comme on l’a mentionné au début, est assez moins précise et empirique, mais elle sous-entend les idées fondamentales appliquées plus tard.

Algorithme TF-IDF

Le tf-idf (time-frequency inverse document frequency est une approche essentiellement utilisée pour le résumé extractif. Il s’agit d’une correction de l’approche naïve consistant à poser que plus un mot est répété dans un corpus de texte, plus il y est important.

Soit donc un corpus constitué de D documents et Nj le nombre total de mots (termes) présents dans un document j donné du corpus. Nommons Freq(i,j) le nombre de fois qu’un terme i apparaît dans le document j.

On définit classiquement la fréquence d’apparition par :

Freq(i,j)

	T F(i,j) =		(II.1)

Nj

L’approche qui se base naïvement sur la fréquence d’apparition des mots dans les textes pour juger de leur importance relative, accorde à chaque mot un poids égal à T F(i,j). La grande faiblesse de cette approche est d’inclure ainsi des termes sans grande pertinence informationnelle comme des prépositions, des articles,... très présents au sein des documents.

Pour corriger cette faiblesse, on pose l’hypothèse que les termes importants apparaissent plusieurs fois dans un document (ou juste dans peu de documents du corpus) et non pas dans plusieurs documents. Puisque dans ce second cas, il est souvent question des éléments communs du langage, sans grande utilité informationnelle. Ceci constitue en fait la loi de Zipt [55] et c’est le fondement de l’approche du tf-idf.

A cet effet, on définit DFi comme étant le nombre de documents dans le corpus, qui contiennent le terme numéro i. Cela permet d’affecter alors le poids selon la formule [5] :

 D !

	T FIDF(i,j) = log(1+T F(i,j))·log		(II.2)

DFi

Dans l’expression, II.2, en supposant que N est le dictionnaire des termes présents dans l’ensemble des documents, il faut noter que : i ∈ {1,...,N} et j ∈ {1,...,D}.

D’où finalement, le poids d’un terme i dans un document j est donné par :

	wij = T FIDF(i,j)	(II.3)

Pour notre cas, l’application de cette approche consiste à décomposer un long texte en ses phrases et de considérer que chacune de ces phrases est un document et que le texte entier constitue le corpus.

Plusieurs définitions des éléments T F(ij) et IDFi formant l’expression II.2 sont toutefois possibles selon les besoins en terme de performance.

Mais, dans l’ensemble, l’idée de base demeure la même car il ne s’agit en général que de changement des types de normalisation [55].

L’application de cette méthode pour le résumé consiste finalement à calculer le poids de chaque phrase en additionnant les poids des termes la constituant, puis à normaliser le résultat en fonction de la taille de la phrase considérée. Après tout, on définit un seuil qui permet de soutirer les phrases selon leur pertinence ainsi évaluée (en considérant évidemment plus pertinente une phrase dont le résultat de la sommation des poids est élevé).

Algorithme TextRank

TextRank est un algorithme de résumé extractif, basé sur la théorie des graphes et qui s’inspire de l’algorithme PageRank de Google [8, 4].

A la base, on considère un ensemble de N phrases donné, et on calcule les coefficients de liaison de chaque phrase aux N −1 autres. A la fin, on peut obtenir une matrice M de taille N ×N dont chaque terme Mij représente le degré de liaison entre la phrase numéro i et la numéro j. Il s’agit en fait d’une matrice d’adjacence dans laquelle on pose au préalable que Mii = 0, pour tout i (c’est la même idée pour l’algorithme PageRank étant donné qu’il est logique de considérer qu’une page ne peut s’auto-référencer).

Soit donc i ∈ {1,...,N}. Appelons P hri la phrase numéro i du corpus. Cela veut dire qu’on peut écrire :

	Liaison P hri ↭ P hrj = Mij = Mji	(II.4)

Les valeurs de Mij sont calculées au choix, selon le programmeur. Ce dernier implémente en effet une mesure de similarité selon sa définition de la liaison entre phrases et les besoins en performance.

C’est ainsi qu’on peut utiliser par exemple une mesure de similarité classique nommée similarité cosinus en la basant par exemple sur T FIDF [19].

Pour représenter les mots à comparer, on utilise les méthodes classiques de vectorisation des mots (word embedding). Nous esquisserons ces méthodes dans les sections qui vont suivre, parlant du word embedding ( II.5 ).

Le rang des phrases sont alors calculés de manière itérative en s’inspirant de la formule [33] :

N

	Xh	i

	T extRank(P hri) = (1−K)+K ·	T extRank(P hrj) ·Mij	(II.5)

j=1 j,i

Dans cette formule, K est une constante comprise entre 0 et 1.

Initialement, on prend en général une valeur identique de T extRank(P hri) pour toutes les phrases (souvent T extRank(P hri) = 1), mais la valeur initiale prise n’affecte pas les valeurs finales, juste le temps de convergence [33].

La formule II.5 n’est pas arbitraire, elle est d’ailleurs triviale si on s’inspire de l’algorithme de PagePank la plus simple. Pour cet algorithme (PageRank), on avait pris à l’origine K = 0.85 [8].

Justification de la formule	Le principe de PageRank consiste à se dire que, si une page



P agi contient Ni références vers d’autres pages, la probabilité qu’on aille vers l’une de ces pages référencées est de N1i (avec l’hypothèse que les références ne sont pas répétées et que la distribution de leur importance est uniforme). On sait tout de même que plus une page est référencée, plus on doit lui donner de l’importance.

Si alors on pose que l’importance de la page P agi est connue, le calcul de l’importance d’une page P agj vers laquelle elle pointe se calculera logiquement par :

	X	1

Importance(P agj) =	Importance(P agi)·		(II.6) i	Ni

Avec i appartenant à l’ensemble des pages qui mentionnent la page P agj en leur sein.

Malheureusement, pour les phrases non référencées (pages dites isolées), on trouve une importance nulle. Pour lutter contre cela, la formule II.6 est un peu modifiée en y introduisant adéquatement une constante non nulle K.

Ce qui donne l’expression [8] :

	X	1

Importance(P agj) = (1−K)+K ·	Importance(P agi)·		(II.7) i	Ni

On voit alors qu’il s’agit belle et bien de la formule utilisée pour TextRank (formule II.5).

Après initialisation des rangs de chaque phrase du texte ( les T extRank(P hri)) et après calcul de la matrice d’adjacence M. On applique la formule II.5 itérativement et à la convergence, on choisit les phrases qui vont former le résumé selon leur importance ( valeurs des T extRank(P hri) pour toute valeur de i).

A la fin, les phrases sélectionnées sont réarrangées pour former un résumé extrait plus ou moins cohérent.

Il existe également un algorithme nommé LexRank [14] qui est assez similaire à TextRank ici décrit, à la différence près que :

Il prend essentiellement en compte les métriques de similarité robustes;

Il considère la position et la longueur des phrases dans le calcul de leur pertinence; - Il est optimisé pour le résumé multi-document.

Plusieurs autres algorithmes populaires existent, par exemple les algorithmes LSA (Latent Semantic Analysis ou Analyse Sémantique Latente) et LDA (Latent Dirichlet Allocation ou Allocation Latente de Dirichlet) [5].

Le premier, la LSA, est un algorithme statistique, basé sur l’algorithme SVD (Singular Value Decomposition ou décomposition en valeurs singulières). Seulement, cette technique est très gourmande en ressources suite à la complexité de l’algorithme qui implémente le SVD. Le second, la LDA, basé sur la détection des thématiques, peut aussi être utilisé.



Toutefois, il faut remarquer que les algorithmes ici présentés sont essentiellement adaptés à la synthèse extractive. Même si, ces traitements peuvent être mélangés avec les techniques de résolution d’anaphores et les paraphrases pour obtenir des synthèses qui tendent vers la synthèse abstractive, nous devons souligner que les techniques jusque là les plus performantes pour la synthèse abstractive sont essentiellement basées sur le deep learning [36]. Le deep learning peut également être utilisé pour la synthèse extractive, permettant ainsi la génération des synthèses extraites plus cohérentes (avec résolution d’anaphores). Ainsi donc, nous abordons les méthodes de deep learning utilisées pour cet effet dans les parties qui suivent.

II.5	Modèles Seq2Seq

II.5.1	Methodes du Word-Embedding

Tout traitement commence par une représentation numérique des termes (des mots ici) pour qu’ils soient assimilables par le modèle. Une approche naïve consisterait à regrouper tous les mots de notre vocabulaire dans une liste (un dictionnaire) et de les représenter chacun par un nombre unique (un identifiant). Une autre approche, plus classique, consiste à représenter chaque mot par un vecteur de dimension égale à la taille du dictionnaire et dont tous les termes sont nuls, sauf à la position, dans le dictionnaire, du mot qu’on est entrain de vouloir représenter (on parle du one-hot encoding).

Ces représentations, et toutes celles qui s’y apparentent, ont la grande faiblesse d’être peu informatives (au point de vu sémantique). Étant artificiellement construites, sans tenir compte du sens des mots, ni de leur contexte, ces méthodes de représentation rendent la tâche de découverte des caractéristiques par les systèmes de machine learning encore plus difficile. D’ailleurs, l’une des faiblesses de la seconde méthode décrite (le one-hot encoding) est que les vecteurs sont creux (une majorité de valeurs nulles) et de dimension inutilement très grande. On pourrait directement songer à une représentation plus judicieuse pour éviter ces deux soucis, et qui consisterait à réaliser une représentation binaire des termes mais, le problème de la sémantique sera toujours là.

On recourt donc à des méthodes de représentation plus élaborées, partant du principe selon lequel le contexte d’un mot suffit pour en appréhender le sens. Ainsi, tout mot est représenté en réalisant une statistique (implicitement bien sûr) sur les divers mots qui l’accompagnent souvent, de telle sorte que les mots aux sens proches aient aussi des vecteurs très proches. Bref, on en arrive à réaliser la proposition : "Similarité sémantique implique similarité de représentation". Ce sont les méthodes classiques du word embedding (ou plongement lexical). Il s’agit par exemple des méthodes comme le Word2Vec [34, 35], Glove [39], fastText [6]...

II.5.2	Modèles séquence-à-séquence proprement dits

S’agissant des modèles séquence-à-séquence (Seq2Seq), ils ont été présentés dans la section I.5.3 (voir particulièrement la figure I.6). Il s’agit bel et bien des modèles adaptés aux tâches de synthèse, vu qu’en entrée on reçoit une séquence pour ressortir une autre séquence en sortie.

Comme nous l’avons déjà bien mentionné au précédent chapitre, nous n’allons parler que des modèles Seq2Seq de type transformer car actuellement, ils sont les plus adaptés à la tâche que nous voulons réaliser (celle de synthèse automatique). Les transformers (voir la figure I.7) sont un modèle très avantageux car en fait, au-delà de leurs performances et autres avantages, ils facilitent encore plus la recherche en NLP en rendant effectif le transfer learning (apprentissage par transfert) dans ce domaine.

L’entraînement des transformers est semi-supervisé. Il se fait en deux crans (nous les décrirons dans le cadre du NLP) :

1°) Pré-entraînement : il s’agit d’un apprentissage non supervisé, qui consiste à donner au modèle une masse colossale de données textuelles, non étiquetées, pour qu’il développe une compréhension statistique du langage qu’on veut qu’il puisse assimiler.

Au final, on obtient un modèle pré-entraîné.

2°) Affinage de l’apprentissage (fine-tuning) : Ça consiste à finaliser l’apprentissage du modèle pré-entraîné de manière supervisée pour qu’il soit en mesure de réaliser une tâche donnée du NLP (il s’agit du transfer learning en fait). Cette spécialisation, requiert une très faible quantité de données car le modèle aura déjà une représentation assez bonne de la langue. Cela pallie à la fois au problème de manque des données labellisées en NLP et de la consommation en terme de ressource énergétique des gros modèles lors de leur entraînement.

Les méthodes de pré-entraînement sont très déterminantes pour les performances finales du modèle. Ce premier entraînement du modèle a pour rôle de l’amener à construire un modèle de langage [25].

Il existe ainsi plusieurs objectifs de de pré-entraînement (pour construire le modèle de langue). On peut par exemple entraîner le modèle à :

Prédire le mot suivant : donc, lors de cet entraînement non supervisé, on fournit chaque fois au modèle une séquence de mots en lui demandant de prédire le suivant. Il s’agit d’un objectif d’entraînement dit NSP (Next Sentence Prediction) visant à transformer implicitement le transformer en un modèle de langue [11];

Deviner le mot caché (masqué) : on fournit au modèle du texte dont certaines parties (mots ou suite de mots) sont cachées. L’objectif assigné au modèle est alors de retrouver les mots masqués. On parle du MMLMasked Language Modelling [11].

Ainsi, au fur et à mesure, les paramètres du modèle s’affinent, le transformant en un modèle de langue performant. Mais, à part les deux que nous venons de mentionner, il existe d’autres objectifs de pré-entraînement [25, 54] selon les variantes de transformers et les objectifs finaux de spécialisation du modèle.

Bien que la forme classique des transformers est bel et bien celle de la figure I.7, il existe 3 types d’implémentation selon les types de tâche visées en dernier lieu :

1°) Modèles à encodeur seul : on supprime la partie décodeur. Ces modèles sont très bons pour les tâches de compréhension du langage comme la classification par exemple.

2°) Modèles à décodeur seul : on supprime alors la partie décodeur du modèle. Ils sont bons pour les tâches de génération de texte.

3°) Modèles encodeur-décodeur : ou encore modèles seq2seq proprement-dits. Ils sont bons pour les tâches demandant à la fois la compréhension et la génération des textes.

Pour illustrer ce fait, on va considérer donc 3 types de transformers [49, 52] :

1°) Like-BERT : semblables au transformer dénommé BERT Bidirectional Encoder Representations from Transformers. Ce sont des modèles du type encodeur seul. Ils sont également bidirectionnels. Donc, les phrases sont lues dans les deux sens pour mieux saisir tout le contexte.

2°) Like-GPT : donc semblables au transformer dénommé GPT (Generative Pre-trained Transformer) qui n’ont que la partie décodeur et sont dits auto-regressifs car, seules les parties précédant le mot en cours de traitement sont connues du modèle et il y a chaque fois réinjection des sorties à l’entrée.

3° Like-BART/T5 : semblables à BART (Bidirectional and Auto-Regressive Transformers) ou à T5 (Text-To-Text Transfer Transformer). C’est donc ceux du type encodeur-décodeur.

Modèles encodeurs (encoder-model) :	Comme on l’a dit, pour ces modèles, on n’implé-



mente que la partie encodeur du transformer d’origine (celui de Vaswani et al. [50]). En plus de cela, ces modèles ont une couche d’attention bidirectionnelle et sont généralement appelés auto-encodeurs (auto-encoding model). Ces modèles sont principalement bons pour les tâches de NLU (Natural Language Understanding) comme la classification, le NER (Name Entity Recognition), l’extractive question-answering,...

Dans ce groupe, les modèles les plus connus sont :

ALBERT [24],

BERT [11],

DistilBERT [43],

RoBERTA [28],

Etc.

Modèles décodeurs (decoder-models):	Utilisent seulement la partie décodeur, sont auto-



regressifs et par conséquent les têtes de self-attention n’accèdent qu’aux mots précédant l’étape à laquelle elles sont (pas de regard dans le futur) comme on l’a déjà un peu mentionné. Ces modèles sont particulièrement bons pour les tâches liées fortement au NLG (Natural Language Generation).

Dans ce groupe, les modèles les plus connus sont :

Les GPT (1, 2 et 3) [41],

TransformerXL [10],

Etc.

Modèles encodeur-décodeur (sequence-to-sequence models):	Ces modèles utilisent l’in-



tégralité de l’architecture des transformers et sont ainsi bons pour les tâches demandant à la fois du NLU et du NLG comme la synthèse automatique abstractive, le generative question-answering et la traduction automatique.

Ici nous pouvons particulièrement mentionner les modèles comme :

BART [25],

mBART [27],

BARThez [13],

T5 [42],

mT5 [53], • PEGASUS [54],

Etc.

II.5.3	Modèle BART pour la synthèse abstractive

Le modèle BART est comme une combinaison de BERT [11] et de GPT-2 [40, 41] en terme

d’architecture et d’objectif de pré-entraînement, avec quelques optimisations supplémentaires [25]. Pour illustration, voici une image de comparaison :



Figure II.2: Comparaison simplifiée entre BERT, GPT et BART [25]

L’image II.2 étant claire, nous pouvons illustrer les diverses corruptions que peuvent subir les données pour le pré-entraînement. L’image ci-dessous l’illustre :



Figure II.3: Transformations de bruitage expérimentées pour BART [25]

Le modèle BART est bien adapté à la tâche de synthèse abstractive. C’est celui que nous



allons privilégier (les modèles dérivés de BART principalement) pour réaliser cette tâche dans notre système.

Justification du choix de BART

Le choix de BART est dû au fait que c’est le modèle que nous avons trouvé réalisant un bon compromis poids-performances. Aussi, après quelques tests, ses résultats nous ont paru être plus intéressants. En outre, l’objectif d’entraînement utilisé pour BART nous paraît assez général pour construire un modèle de langage performant. Nous justifierons plus précisément ce choix dans le chapitre qui suit, en présentant également quelques résultats des tests.

II.6	Conception de l’architecture globale du système

Il existe un large éventail des méthodes de développement des systèmes informatiques mais, en règle générale, toutes suivent les étapes suivantes [7] :

1°) Spécifications : on définit avec précision ce que fera le système (à quoi est-il destiné?);

2°) Conception et mise en oeuvre : on conçoit et on réalise le système;

3°) Validation : on teste le système pour voir s’il correspond aux objectifs précisés dans les spécifications;

4°) Évolution : ça correspond à tout ce qui vient après la livraison du produit (versionning, maintenances,...).

Ici, on ne va pas utiliser une méthode de conception particulière. Pour pouvoir tout de même y aller méthodiquement, nous nous inspirerons de ces étapes classiquement suivies lors de la conception des systèmes informatiques.

Dans ce second chapitre, nous ne présenterons que les spécifications du système ainsi qu’une ébauche de conception avec une présentation de l’architecture globale. La suite sera traitée dans le chapitre suivant.

II.6.1	Spécifications du système

Le système devra pouvoir permettre de réaliser ce qui suit :

Synthétiser les textes qui lui sont fournis en entrée (saisis directement ou importés dans fichiers .pdf non scannés, des fichiers .docx et .txt);

Servir les synthèses directement ou à travers un fichier .pdf à télécharger;

Obtenir des synthèses produites par plusieurs algorithmes et les évaluer;

Stocker les couples document-synthèse;

Faciliter le parcours des documents en soulignant les parties saillantes;

Permettre l’affinage d’un modèle de synthèse automatique (ici nous réaliserons le fine-tuning du modèle mBART ou du modèle mT5 selon celui qui se prêtera mieux à cet affinage).

C’est cela le minimum de besoins que le système devra être capable de combler.

II.6.2	Présentation des éléments du système

L’architecture globale de notre système est un trois-tiers classique. Elle se présente comme sur la figure II.4 :



Figure II.4: Architecture globale de notre système

La figure II.4 presente l’architéture du système qui est  d’une architecture 3 − tiers classique. Il y a toutefois une partie qui n’est pas ici représentée car nous voulons nous donner une grande liberté de conception à son sujet. Il s’agit en fait de l’interface d’accès à l’API (Application Programming Interface), qui permettra aux développeurs de s’authentifier et générer éventuellement un token à utiliser pour implémenter leur propres interfaces devant permettre d’utiliser les services de cette API. Il s’agit donc d’une API privée.

Cette interface permettra aussi de voir toute la documentation de l’API (pour les développeurs) pour mieux utiliser ses services.

Quant au bloc interface que nous venons de présenter sur la figure II.4, c’est en nous mettant à la place d’un développeur lambda qui exploite les services de l’API.

Notre API quant à elle, est une API REST (REpresentationnal State Transfer qui aura 4 end-points principaux dédiés à la synthèse automatique (selon les besoins d’implémentation, on pourra en insérer d’autres mais qui ne concernerons probablement pas la synthèse).

Module de synthèse extraite : ce module réalisera une synthèse en combinant divers résultats d’algorithmes de synthèse extraite. Nous prévoyons, dans un premier temps, ne l’utiliser que pour des petits documents (la taille optimale sera déterminée avec les expérimentations au chapitre suivant).

Module de synthèse abstraite : ce module donnera une synthèse abstraite en utilisant l’un des transformers affinés pour la synthèse ou bien par le module qui sera en train de s’auto-améliorer au cours de l’utilisation du système (on l’a nommé expérimental, voir la figure II.7). Comme les transformers réalisent des synthèses de documents de taille généralement limitée à environ une page, nous mettrons au point, dans cette partie, une pipeline qui nous permettra d’augmenter le nombre de pages (nous pensons à 100 pages mais les expérimentations nous permettrons de choisir une taille optimale, tenant compte surtout de la rapidité).

Module de synthèse extrait simplifié : Il s’agira d’un module qui permettra la réalisation de la synthèse mais en utilisant l’un des algorithmes de synthèse extraite implémentés (soit de manière aléatoire, soit par choix de l’utilisateur).

Module expérimental : Il s’agira d’un module de synthèse abstraite qui sera essentiellement utilisé pour la synthèse des petits documents (quelques pages). Pour ce module, nous comptons mettre au point une routine d’entraînement à partir des synthèses collectées par le système, pour améliorer au fur et à mesure les performances de ce module. Nous comptons réaliser l’entraînement par transfer learning avec les transformers mT5[53] ou mBART [27] comme base. N’ayant pas encore testé cette partie, nous serons fixé sur la méthode à utiliser ainsi que le modèle de base à choisir au chapitre suivant, après les expérimentations.

On peut aussi remarquer qu’il y a un module pre-processing dans la partie interfaces. C’est par suite du fait que, pour des raisons de performance, on devra envoyer à l’API le fichier sous un format particulier. Il faudra réaliser l’acquisition des données dans divers formats (pdf,docx,...) mais les données acquises seront envoyées dans un format plus léger à l’API (du JSON pour notre cas).

La base des données, que nous avons mentionné dans la figure II.4, a un double rôle :

1°) Le stockage des données de l’utilisateur (il s’agira en fait des identifiants des interfaces qui utiliseront l’API);

2°) Le stockage des paires document-synthèse, ainsi que l’appréciation de l’utilisateur (évaluation par les utilisateurs).

II.6.3	Architecture du module de synthèse extractive

Le module de synthèse extractive se présente comme suit :



Comme nous pouvons le voir, un traitement sera fait pour adapter les données reçues à ce qui peut être traité par le système. Ce traitement consistera à ne retenir que des symboles alphanumériques, à réaliser la tokenisation des textes (chaque token sera une phrase pour cette partie) et à affecter un identifiant unique à chaque phrase.

Après cela, les données seront invariablement passées aux algorithmes de synthèse extractive, qui générerons chacun un groupe de poids des phrases. Après cela, le module de pondération et sélection réalisera successivement ce qui suit :

Acquisition des sorties de chaque algorithme de synthèse extractive (il s’agira des dictionnaires dont les clés seront les identifiant uniques des phrases et les valeurs seront les poids affectés par l’algorithme). A chaque algorithme, on donnera un poids qu’on nommera WNomdel′algo compris entre 0 et 1, selon la confiance qu’on lui porte (la somme des poids sera égale à 1 et par défaut, tous les algorithmes pourront avoir le même poids) ;

Élimination des phrases de poids faible (avec comme seuil, la taille maximale de résumé précisée par l’utilisateur);

Réarrangement de chaque dictionnaire obtenu après expulsion des phrases non significatives (les éléments seront arrangés par ordre décroissant des poids pour chaque sortie);

Donner des propabilités aux espaces des poids de chaque dictionnaire par application d’un softmax sur chacun d’eux. Ce qui donnera, pour chaque phrase de chaque dictionnaire, un nouveau poids ωphri, avec i le numéro du dictionnaire et phr le numéro de la phrase considérée dans ce dictionnaire ;

Listage complet des éléments (leurs identifiants) de tous les dictionnaires.

Pour chaque élément de la liste globale ainsi établie, appliquer la formule suivante pour obtenir un nouveau poids :

	X	

W =	Wi ·ωphri	(II.8) j

i∈D

Avec Wj le nouveau poids affecté à la phrase ayant un identifiant global j (l’identifiant là d’origine) et D la liste des dictionnaires (les sorties de chaque algorithme);

Arranger toutes les phrases par ordre décroissant dans une unique liste et sélectionner les plus haut dans la liste jusqu’à atteindre le seuil fixé (nombre de mots fixé pour la synthèse).

Constituer une liste avec les éléments sélectionnés.

Réarranger les phrases de la liste selon leur ordre de succession dans le texte d’origine.

Constituer la synthèse extraite.

Ce qui précède constitue en fait l’algorithme que nous allons implémenter pour le module de pondération et sélection.

II.6.4	Architecture du module de synthèse abstractive

Le module de synthèse abstraite n’est pas unique. Nous implémenterons plusieurs modèles (BART, BARThez, PEGASUS, mBART ou mT5 entraîné avec nos données, ainsi que tous ceux qui nous paraîtrons utiles durant les essais); Chaque module de synthèse se présentera néanmoins comme suit :



Figure II.5: Architecture globale du système de synthèse abstractive

Comme nous pouvons le remarquer, il y a toujours un module de mise en forme initial (pre-processing) qui nous permettra en gros de supprimer tous les caractères que nous ne pourrons pas gérer. Vient ensuite le module de tokenisation (le tokenizer ou tokeniseur) [49] qui consistera ici à diviser tout le texte en ses mots constitutifs et à leur affecter des identifiants numériques. Ce sont ces identifiants qui seront fournis au modèle et transformés en vecteurs par la couche d’embedding du modèle.

Le modèle quant à lui, aura toujours une architecture pareille :



Figure II.6: Architecture interne du modèle mentionné sur la figure II.5

Il s’agit en effet de l’architecture classique d’un transformer, comme présenté sur la figure I.7 à l’exception du fait qu’ici on fait explicitement apparaître l’existence de la sortie du modèle. Ça correspond au réseau linéaire suivi d’une couche de softmax tel que présenté sur la figure

I.7. Cette partie, que nous avons nommé head est différente selon les tâches [52], c’est pourquoi nous avons voulu la mentionner explicitement car, selon le besoin, on peut la modifier.

Nous devons finalement mentionner que les modules de tokenisation (nommés tokenizer en anglais) dépendront explicitement des modèles utilisés.

II.6.5	Présentation des interfaces

La partie interface nous permettra juste d’utiliser le service que nous aurons élaboré et d’évaluer par la même occasion ses performances. Elle n’est pas donc cruciale. Toutefois, voici une ébauche d’interface que nous comptons utiliser pour exploiter le service :



Figure II.7: Ébauche d’interface

Avec cette interface, on a une idée générale de la manière dont nous comptons servir le système aux utilisateurs.



II.7. CONCLUSION PARTIELLE II.7	Conclusion partielle

Dans cette partie, nous venons de présenter le résumé automatique des textes, tout en réalisant une vue d’ensemble des méthodes utilisées dans la littérature à cet effet. Nous avons mentionné que la classification des résumés que nous utiliserons sera celle les départageant en abstractive summarization et extractive summarization et que, pour notre cas, il s’agira de réaliser un système de résumé mono-document, avec une partie abstractive et une autre extractive, générant un résumé générique pour des documents de type narratif et argumentatifs.

Nous avons également listé les divers modèles de transformer adaptés à la tâche de synthèse automatique abstraite, et nous avons mentionné devoir privilégier les modèles du type BART pour des raisons qui serons précisées dans le chapitre suivant.

Enfin, nous avons réalisé la conception préliminaire du système tout en précisant que, concernant l’API, la BD (Base des Données) et les interfaces, les détails d’implémentation utiles seront précisés dans la partie dédiée à la conception proprement dite et aux tests, c’est-à-dire au chapitre suivant. Le chapitre suivant nous permettra donc finalement de préciser, réaliser et tester les méthodes que nous avons jusque-là adoptées pour la mise au point de notre système de synthèse automatique des documents.



GENERALEMENT

Place les références là où il le faut STP. Même si c’est une interpretation personnelle, elle tire la source quelque part. 

Verifie aussi tous les commentaires que j’ai placé aux différents niveaux du texte

Chapitre III

Conception finale, réalisation et tests

Conclusion générale

Bibliographie

D. Adams. Combining State-of-the-art Models for Multi-document Summarization Using Maximal Marginal Relevance. University of Lethbridge, 2021.

Stergos D. Afantenos, Vangelis Karkaletsis, and Panagiotis Stamatopoulos. Summarization from medical documents: A survey. CoRR, abs/cs/0504061, 2005.

Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.

Catherine Benincasa, Adena Calden, Emily Hanlon, Matthew Kindzerske, Kody Law, Eddery Lam, John Rhoades, Ishani Roy, Michael Satz, Eric Valentine, et al. Page rank algorithm. Department of Mathematics and Statics, University of Massachusetts, Amherst, Research, 2006.

Michael W Berry and Jacob Kogan. Text mining: applications and theory. John Wiley & Sons, 2010.

Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. Enriching word vectors with subword information. Transactions of the association for computational linguistics, 5:135–146, 2017.

Boudjemaa Boudaa. Cours de génie logiciel (avec exercices résolus). Université IbnKhaldoun-Tiaret, Algérie, 02 2020.

Sergey Brin and Lawrence Page. The anatomy of a large-scale hypertextual web search engine. Computer networks and ISDN systems, 30(1-7):107–117, 1998.

O. Carton and D. Perrin. Langages formels : calculabilité et complexité : cours et exercices corrigés. Vuibert, 2014.



Zihang Dai, Zhilin Yang, Yiming Yang, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. arXiv preprint arXiv:1901.02860, 2019.

Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pretraining of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.

Youcef Djeriri. Les Réseaux de Neurones Artificiels. 09 2017.

Moussa Kamal Eddine, Antoine J-P Tixier, and Michalis Vazirgiannis.	Barthez:

a skilled pretrained french sequence-to-sequence model. arXiv preprint arXiv:2010.12321, 2020.

Günes Erkan and Dragomir R Radev. Lexrank: Graph-based lexical centrality as salience in text summarization. Journal of artificial intelligence research, 22:457–479, 2004.

Thushan Ganegedara. Natural Language Processing with TensorFlow: Teach language to machines using Python’s deep learning library. Packt Publishing Ltd, 2018.

A. Géron. Deep Learning avec Keras et TensorFlow: Mise en oeuvre et cas concrets. Dunod, 2020.

M. Hagiwara. Real-World Natural Language Processing: Practical Applications with Deep Learning. Manning, 2021.

Patrick Hairy. Les réseaux de neurones récurrents pour les séries temporelles, Septembre 2021.

Nitin Indurkhya and Fred J Damerau.	Handbook of natural language processing.

Chapman and Hall/CRC, 2010.

D. Jurafsky and J.H. Martin.	Speech and Language Processing.	Always learning.

Pearson, 2014.

SYNTHESE AUTOMATIQUE DES TEXTES

Min-Yen Kan, Kathleen R. McKeown, and Judith L. Klavans. Applying natural language generation to indicative summarization. CoRR, cs.CL/0107019, 2001.

Akshay Kulkarni and Adarsha Shivananda. Natural language processing recipes. Springer, 2019.

S. Lamsiyah, S. Ouatik El Alaoui, and B Espinasse. Résumé automatique guidé de textes: Etat de l’art et perspectives (guided summarization : State-of-the-art and perspectives ). In Actes de la Conférence TALN. Volume 2 - Démonstrations, articles des Rencontres Jeunes Chercheurs, ateliers DeFT, pages 55–72, Rennes, France, 5 2018. ATALA.

Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. Albert: A lite bert for self-supervised learning of language representations. arXiv preprint arXiv:1909.11942, 2019.

Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov, and Luke Zettlemoyer. Bart: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. arXiv preprint arXiv:1910.13461, 2019.

Chin-Yew Lin. Training a selection function for extraction. In CIKM ’99, 1999.

Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, and Luke Zettlemoyer. Multilingual denoising pre-training for neural machine translation. Transactions of the Association for Computational Linguistics, 8:726–742, 2020.

Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.

H. P. Luhn. The automatic creation of literature abstracts. IBM Journal of Research and Development, 2(2):159–165, 1958.

Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attention-based neural machine translation. arXiv preprint arXiv:1508.04025, 2015.

Mohamed Hedi Maaloul. Approche hybride pour le résumé automatique de textes. Application à la langue arabe. Theses, Université de Provence - Aix-Marseille I, December 2012. Date Soutenance 18-12-2012.

Inderjeet Mani. Automatic summarization, volume 3. John Benjamins Publishing, 2001.

Rada Mihalcea and Paul Tarau. Textrank: Bringing order into text. In Proceedings of the 2004 conference on empirical methods in natural language processing, pages 404– 411, 2004.

Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.

Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. Advances in neural information processing systems, 26, 2013.

Maali Mnasri. Résumé automatique multi-document dynamique. Theses, Université Paris-Saclay, September 2018.

Marie-Francine Moens. Automatic indexing and abstracting of document texts. Computational Linguistics, 27(1):149–149, 2001.

Ani Nenkova and Rebecca Passonneau. Evaluating content selection in summarization: The pyramid method. In HLT-NAACL 2004 - Human Language Technology Conference of the North American Chapter of the Association for Computational Linguistics, Proceedings of the Main Conference, HLT-NAACL 2004 Human Language Technology Conference of the North American Chapter of the Association for Computational Linguistics, Proceedings of the Main Conference, pages 145–152. Association for Computational Linguistics (ACL), 2004.

SYNTHESE AUTOMATIQUE DES TEXTES

Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 1532–1543, 2014.

Alec Radford, Karthik Narasimhan, Tim Salimans, Ilya Sutskever, et al. Improving language understanding by generative pre-training. 2018.

Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J Liu, et al. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res., 21(140):1–67, 2020.

Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. arXiv preprint arXiv:1910.01108, 2019.

D. Sarkar. Text Analytics with Python: A Practitioner’s Guide to Natural Language Processing. Apress, 2019.

Barry Schiffman, Ani Nenkova, and Kathleen McKeown. Experiments in multidocument summarization. In Proceedings of the Second International Conference on Human Language Technology Research, HLT ’02, page 52–58, San Francisco, CA, USA, 2002. Morgan Kaufmann Publishers Inc.

S. Srivastava. Natural Language Processing with Python: Hands-On Labs to Apply Deep Learning Architectures to NLP Applications. Independently Published, 2021.

Brahim Tlili. Identification et commande des systèmes non linéaires : Utilisation des modèles de type NARMA. Theses, Ecole Nationale d’Ingénieurs de Tunis, July 2008.

Juan-Manuel Torres-Moreno. Automatic text summarization. John Wiley & Sons, 2014.

Lewis Tunstall, Leandro von Werra, and Thomas Wolf. Natural language processing with transformers. " O’Reilly Media, Inc.", 2022.

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.

Lilian Weng. Les réseaux de neurones récurrents pour les séries temporelles, Avril 2020.

Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, et al. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 conference on empirical methods in natural language processing: system demonstrations, pages 38–45, 2020.

Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, and Colin Raffel. mt5: A massively multilingual pre-trained text-to-text transformer. arXiv preprint arXiv:2010.11934, 2020.

Jingqing Zhang, Yao Zhao, Mohammad Saleh, and Peter Liu. Pegasus: Pretraining with extracted gap-sentences for abstractive summarization. In International Conference on Machine Learning, pages 11328–11339. PMLR, 2020.

Jan Žižka, František Dařena, and Arnošt Svoboda. Text mining with machine learning:

principles and techniques. CRC Press, 2019.



Annexes

68