EventFormatBot

EventFormatBot a pour but d'étendre les fonctionnalités de FormatBot. Il vérifie que la syntaxe d'écriture des événements est bien respectée selon le dictionnaire des typologies d'événements. Si ce n'est pas le cas, le bot réécrit si possible les entrées selon une syntaxe basique.

Implémentation technique

EventFormatBot prend un article Wikipast comme argument. Il distingue les entrées et vérifie la syntaxe indépendament de chacune d'elles. Cette particularité permet de traiter chacune des entrées de manière parallèle.

Interprétation de la nature d'un mot

La syntaxe d'un événement est une succession ordonnée de mots de nature spécifique. Dans le cadre de cet algorithme, il est donc nécessaire de déterminer la nature d'un mot (Personnage, Lieu, Objet, autre...) : principe d'un NER (Named Entity Recognition)[1].

Example

NAISSANCE : DATE / LIEU. Naissance de PERSONNAGE. [2]

Ici trois natures différentes sont utilisées : Date, Lieu et Personnage.

L'une des étapes du EventFormatBot est donc de vérifier que la nature du mot correspond à celle attendue par la syntaxe de l'événement. Dans le cadre du cours, nous n'avons pas le temps de développer nous-même le NER, ainsi nous utiliserons une librairie externe Python open-source : spaCy [3]. spaCy regroupe les mots selon les catégories suivantes [4]

Nature d'un mot

• PERSON - Personnages, fictionnels inclus
• NORP - Nationalités ou groupes politique ou religieux
• FAC - Bâtiments, aéroports, autoroutes, ponts...
• ORG - Entreprises, institutions, agences...
• GPE - Pays et villes
• LOC - Lieu autre que pays ou villes
• PRODUCT - Objets, véhicules, nourritures...
• EVENT - Ouragans, batailles historique, événements sportif...
• WORK_OF_ART - Titres de livre, morceaux de musique...
• LAW - Nom d'article de loi
• LANGUAGE - Nom de language
• DATE - Dates absolue ou relative, période historique...
• TIME - Périodes plus courte qu'une journée
• PERCENT - Pourcentage, incluant '%'
• MONEY - valeurs monétaire
• QUANTITY - Mesures de poids ou distance.
• ORDINAL
• CARDINAL - Nombres hors-catégorie

Normalisation de la syntaxe typologique du dictionnaire

Pour chaque événement, il est nécessaire d'extraire automatiquement la syntaxe typologique de l'article correspondant. Nous avons mis en place une syntaxe standardisée située au début de l'article, inspirée de celle de Parution et mis à jour tous les autres événements afin qu'il soit conforme à la nouvelle syntaxe :

1. Chaque entrée commence par une date.
2. La date peut être suivie d'un lieu, séparé d'un séparateur.
3. Chaque mot avec une nature imposée se traduit par un hypermot.
4. Il est possible d'ajouter des hypermots optionnels avec des parenthèses.

Nous avons également simplifié le nombre de natures possibles de mot, il y a 7 natures possibles :

• Date
• Lieu
• Personnage
• Oeuvre d'Art
• Institution
• Evenement
• Objet - qui regroupe toutes les catégories, i.e inclue tous les mots

Un hypermot peut être de natures différentes, précisés par un séparateur '/' entre chaque nature possible, voir exemple ci-dessous.

Example - Parution

Syntaxe: [[Date]] / [[Lieu]]. [[Publication]] de [[Oeuvre d'Art]] par [[Personnage/Institution]] (dans [[Journal]])

Vérification/Correction de la syntaxe

Pour une entrée donnée, l'algorithme se décompose de la manière suivante :

1. Il extrait l'événement de l'entrée.
2. Il détermine la syntaxe correspondante avec le dictionnaire des typologies d'événements.
3. Il associe un label 'nature' à chaque hypermot de l'entrée avec l'aide de spaCy
4. Il compare chacun des labels avec ceux attendus par la syntaxe de l'événement. Trois cas se présentent :
   1. L'ordre et la nature des labels sont respectés, la syntaxe est alors respectée. L'algorithme retourne VRAIE.
   2. La nature des labels est respectée mais l'ordre ne l'est pas. L'algorithme réécrit alors l'entrée selon la syntaxe adéquate. L'algorithme retourne FAUX.
   3. La nature des labels n'est pas respectée. Cette erreur peut provenir de l'utilisateur comme de la détermination de la nature du mot. L'algorithme laisse l'entrée tel quel et retourne FAUX.

Performance

La partie cruciale d'EventFormatBot est la détermination de la nature d'un mot. Cette partie est très dépendante du modèle de reconnaissance utilisé (ici le modèle fr_core_news_md de spaCy). Il serait possible d'entraîner un modèle spécialement pour Wikipast, ce qui améliorait nettement l'intervalle de confiance lors de la reconnaissance de nature d'un mot.

Code

import requests from bs4 import BeautifulSoup from urllib.request import Request, urlopen import spacy import re from collections import Counter from pprint import pprint

page_name = "Albert Cohen"

nlp = spacy.load('fr_core_news_md') def most_frequent(List):

   occurence_count = Counter(List)
   return occurence_count.most_common(1)[0][0]

event_page = "http://wikipast.epfl.ch/wikipast/index.php/%C3%89v%C3%A8nements" req = Request(event_page, headers={'User-Agent': 'Mozilla/5.0'}) webpage = urlopen(req).read() soup = BeautifulSoup(webpage, 'html.parser') entries = soup.findAll("li") events = [] events_links = [] for entry in entries:

   if entry.find("span") == None and entry.get("id") == None:
       events.append(entry.text.lower().strip())
       events_links.append(entry.find("a").get("href"))

target_page = "http://wikipast.epfl.ch/wikipast/index.php/Albert_Cohen"

req = Request(target_page, headers={'User-Agent': 'Mozilla/5.0'}) webpage = urlopen(req).read() soup = BeautifulSoup(webpage, 'html.parser')

body = soup.find("div", {"class": "mw-content-ltr"}) entries = body.findAll("li")

base_url = "http://wikipast.epfl.ch"

event2spacy = { "OBJET": ["MISC"], "EVENEMENT": ["MISC"], "DATE": ["DATE"], "LIEU": ["LOC"], "PERSONNAGE": ["PER"], "OEUVRE D'ART": ["WORK_OF_ART"], "INSTITUTION" : ["ORG"], "PERSONNAGE/INSTITUTION" : ["ORG" , "PER"] }

modifs = [] for entry in entries:

   event = None
   #get syntax
   hyperlinks = []
   doc = nlp(entry.text)
   links = entry.findAll("a")
   subject = entry.text.find(page_name)
   if subject!=-1:
       i = 0
       while entry.text.find(links[i].text)<subject:
           i+=1
       links.insert(i, page_name)
   for word in links:
       if word != page_name:
           word = word.text
       word_link = []
       for x in doc:
           if str(x) in word.split():
               word_link.append([x, x.ent_iob_, x.ent_type_])
       tags = [elem[2] for elem in word_link]
       txt = ""

       for elem in word_link:
           txt += (str(elem[0]))
       if tags!=[]:
           hyperlinks.append([txt, most_frequent(tags) ])

       if word.lower() in events:
           event = word
   if event == None:
       continue
   for elem in hyperlinks:
       link = str(elem[0])
       if re.search("([12]\d{3}\.(0[1-9]|1[0-2])\.(0[1-9]|[12]\d|3[01]))", link):
           elem[1] = "DATE"
       if re.search("([12]\d{3}\.(0[1-9]|1[0-2]))", link):
           elem[1] = "DATE"
       if re.search("([12]\d{3})", link):
           elem[1] = "DATE"
   print(hyperlinks)

   idx = events.index(event.lower())
   event_url = events_links[idx]
   url = base_url + event_url
   req = Request(url, headers={'User-Agent': 'Mozilla/5.0'})
   webpage = urlopen(req).read()
   soup = BeautifulSoup(webpage, 'html.parser')
   syntax = soup.find("code")

   optionnal = re.findall("\(([^\)]+)\)", syntax.text)
   optionnal = [] if optionnal==None else optionnal
   args = re.findall("\[\[.*?\]\]", syntax.text)

   relevant_args = []
   for arg in args:
       optionnal_ = False
       for elem in optionnal:
           if arg in elem:
               optionnal_=True
       if not optionnal_:
           relevant_args.append(arg)
   arg_syntax = []
   for arg in relevant_args:
       item = arg[2:-2]
       if item.strip().lower() == event.lower():
           arg_syntax.append(item.upper())
       else:
           arg_syntax.append(event2spacy[arg[2:-2].upper()])
   print(arg_syntax)
   if len(hyperlinks)<len(arg_syntax):
       modifs.append([entries.index(entry),  "    [EventFormatBot] --> Wrong formatting : missing parameters  \n \n"])

user='EventFormatBot' passw='dhbot2019' baseurl='http://wikipast.epfl.ch/wikipast/' summary='Wikipastbot update' name = page_name

1. Login request

payload={'action':'query','format':'json','utf8':,'meta':'tokens','type':'login'} r1=requests.post(baseurl + 'api.php', data=payload)

1. login confirm

login_token=r1.json()['query']['tokens']['logintoken'] payload={'action':'login','format':'json','utf8':,'lgname':user,'lgpassword':passw,'lgtoken':login_token} r2=requests.post(baseurl + 'api.php', data=payload, cookies=r1.cookies)

1. get edit token2

params3='?format=json&action=query&meta=tokens&continue=' r3=requests.get(baseurl + 'api.php' + params3, cookies=r2.cookies) edit_token=r3.json()['query']['tokens']['csrftoken']

edit_cookie=r2.cookies.copy() edit_cookie.update(r3.cookies)

result=requests.post(baseurl+'api.php?action=query&titles='+name+'&export&exportnowrap') soup = BeautifulSoup(result.text, "lxml") soup = soup.find("text").text print(soup) indices = [] print(modifs) for match in re.finditer("\*", soup):

   indices.append(match.start())

indices.append(len(soup))

for i in range(len(modifs)):

   line = modifs[i][0]
   to_replace = soup[indices[line]:indices[line+1]]
   print(to_replace)
   soup = soup.replace(to_replace, to_replace.replace("\n", "") + modifs[i][1])
   indices = []
   for match in re.finditer("\*", soup):
       indices.append(match.start())
   indices.append(len(soup))

print(soup) payload={'action':'edit','assert':'user','format':'json','utf8':,'text':soup,'summary':summary,'title':name,'token':edit_token} r4=requests.post(baseurl+'api.php',data=payload,cookies=edit_cookie) print(r4.text)