Mise en oeuvre de traitement de données analyses de graphes machine learning, et leur automatisation, et web services

UNIVERSITÉ NATIONALE DU VIETNAM, HANOÏ INSTITUT FRANCOPHONE INTERNATIONAL Solibia PAZIMNA Mise en oeuvre de traitement de données - analyses de graphes, machine learning, et leur automatisation, et web services MÉMOIRE DE FIN D’ÉTUDES DU MASTER INFORMATIQUE HANOÏ - 2021 UNIVERSITÉ NATIONALE DU VIETNAM, HANOÏ INSTITUT FRANCOPHONE INTERNATIONAL Solibia PAZIMNA Mise en oeuvre de traitement de données - analyses de graphes, machine learning, et leur automatisation, et web services Spécialité : Systèmes Intelligents et Multimédia Code : Programme pilote MÉMOIRE DE FIN D’ÉTUDES DU MASTER INFORMATIQUE Sous la direction de : M Jean-Claude Moissinac (Mtre de Conférences - Télécom Paris ) HANOÏ - 2021 Attestation sur l’honneur J’atteste sur l’honneur que ce mémoire a été réalisé par moi-même et que les données et les résultats qui y sont présentés sont exacts et n’ont jamais été publiés ailleurs La source des informations citées dans ce mémoire a bien été précisée Signature de l’étudiant Solibia PAZIMNA Dédicaces ♥ A mes très chers parents Pour leur soutien, leur amour, leur patience et leur encouragement durant tout mon parcours scolaire Que DIEU le tout puissant vous préserve, vous accorde santé, bonheur, quiétude de l’esprit et vous protège de tout mal ♥ A tous mes professeurs C’est une grande fierté pour moi d’être votre étudiant En témoignage de mon respect et de ma grande affection ♥ A mes encadrants de stage Je voudrais vous adresser ma gratitude, mes sincères reconnaissances pour tout ce que vous aviez fait pour moi durant mon stage Votre patience, votre disponibilité et surtout la confiance que vous avez porté mon égard m’a beaucoup aidé dans l’avancement de mes travaux ♥ A tous mes amis J’ai l’honneur d’avoir des amis, surtout de la promotion 23 SIM de l’IFI, si gentils, fidèles, sincères et qui n’ont jamais hésité de partager avec moi mes soucis, mon malheur et mon bonheur Remerciements Je remercie Dieu le tout Puissant, très Miséricordieux, qui m’a donné la santé, le courage et la persévérance durant mon parcours et tout au long de la réalisation de ce travail C’est avec une certaine émotion et une grande reconnaissance que je remercie l’Université Nationale du Vietnam travers l’Institut Francophone International et toute son équipe pédagogique, spécialement M HO Tuong Vinh responsable du master Systèmes Intelligents et Multimédia pour ses conseils et sa disponibilité Je remercie les professeurs pour les valeurs et méthodes inculquées durant le cursus : la curiosité, le goût du travail, de l’effort, le sens de la persévérance, la volonté de se remettre en question etc Autant de trésors qui me seront, sans nul doute, utiles toute ma vie Je tiens adresser mes profonds remerciements Télécom Paris, très chaleureusement M Jean-Claude Moissinac qui m’a beaucoup aidé malgré la situation sanitaire du Covid19 lors de ce stage ; ses conseils et son coaching m’ont permis de cibler et de m’orienter tout au long de ce stage Il m’a donné envie de persévérer dans ce métier pour lequel il a le plus grand respect, la recherche et l’innovation Un grand merci mon père PAZIMNA Akissiwzim Bént, ma mère KPATCHA Pozowa Edith, ma soeur et mes frères pour leurs conseils ainsi que pour leur soutien inconditionnel Je voudrais profiter de cet espace pour leur exprimer toute ma gratitude et ma reconnaissance Nos vifs remerciements vont également aux membres du Jury, pour l’intérêt et l’attention remarquable qu’ils ont porté ce projet, en acceptant d’examiner mon travail dans l’objectif de le parfaire travers leurs modestes remarques, leurs suggestions et leurs corrections Grâce vous, j’aborde une nouvelle étape de ma vie avec confiance et dynamisme Solibia PAZIMNA Résumé Le sujet de ce stage s’inscrit dans le cadre du projet Data&Musée Nous avons souhaité annoter sộmantiquement des textes du domaine culturel franỗais En effet, lannotation sémantique ajoute des informations complémentaires des textes non-structurés, elle peut permettre en particulier d’identifier et de relier les entités du texte avec des données du Web sémantique Nous avons mis en oeuvre une méthodologie pour construire un système d’annotation de textes pour un vocabulaire spécifique d’un domaine Les méthodes classiques d’annotation s’intéressant l’annotation de mentions de personnes, de lieux, d’organisations et ne couvrent donc pas une bonne partie des termes d’un vocabulaire spécifique Nous nous sommes donc attachés mettre au point une méthode qui s’appuie sur des résultats récents en matière de modélisation de textes La méthode peut se résumer en trois phases savoir la reconnaissance des mentions d’entités sur notre vocabulaire culturel, recherche dans Wikidata des mentions en fonction de leurs types obtenus l’étape précédente, enfin nous avons la désambiguïsation pour nous fournir l’entité wikidata exacte correspondante Pour la reconnaissance des mentions, nous avons opté pour une architecture LST M − C RF + c amemB E RT B B ase qui a fourni une précision moyenne de 93% sur le French Treebank Au niveau de la désambiguïsation, nous avons retenu la méthode de la représentation contextuelle des entités grâce laquelle on a eu une précision moyenne de 99% sur les données de test Pour finir, nous avons mis en place un web service pour rendre exploitable notre travail Mots clés : annotation sémantique, reconnaissance d’entités nommées, désambiguïsation, wikidata, base Joconde, héritage culturel franỗais, web service Abstract The subject of this internship is part of the Data & Museum project We wanted to semantically annotate texts from the French cultural domain Indeed, semantic annotation adds additional information to unstructured texts, in particular it can identify and link the entities of the text with data from the Semantic Web We implemented a methodology to build a text annotation system for a domain specific vocabulary Classical annotation methods are concerned with annotating mentions of people, places, organizations and therefore not cover a good part of the terms of a specific vocabulary We therefore set out to develop a method that is based on recent results in text modeling The method can be summed up in three phases : namely the recognition of mentions of entities on our cultural vocabulary, search in Wikidata for mentions according to their types obtained in the previous step, finally we have the disambiguation to provide us with the wikidata entity exact match For the recognition of mentions, we opted for an LST M −C RF +c amemB E RT B B ase architecture which provided an average accuracy of 93% on the FrenchTreebank In terms of disambiguation, we have retained the method of the contextual representation of entities thanks to which we had an average accuracy of 99% on the test data Finally, we have set up a web service to make our work usable Keywords :semantic annotation, named entities recognition, disambiguation, wikidata, Joconde database, French cultural heritage, web service Table des matières Liste des figures v Liste des tableaux vi Introduction générale 1 Présentation du cadre d’étude et du projet de stage 1.1 Introduction 1.2 Présentation du cadre d’étude : IFI 1.2.1 Objectifs 1.2.2 Conditions d’accès et mode de recrutement 1.2.3 Organigramme de l’IFI 1.2.4 Formation 1.2.4.1 Parcours systèmes intelligents et multimédia 1.2.4.2 Parcours systèmes et réseaux communicants 1.2.4.3 Master en Banque, Finance et Fintech 1.2.4.4 Master en Information - Communication, Spécialité Communication digitale et éditoriale 1.3 Structure d’accueil 1.4 Contexte et problématique du projet 1.5 Objectifs du stage 1.6 Conclusion 2 3 4 4 État de l’art 2.1 Introduction 2.2 Annotation de corpus [6][7] [8] 2.2.1 Définition 2.2.2 Les formats d’annotation 2.2.2.1 Etiquetage (POS) 2.2.2.2 L’annotation sémantique 2.2.3 Processus et difficultés de l’annotation i 5 8 9 9 10 10 11 11 TABLE DES MATIÈRES 2.2.4 Annotation sémantique : existant 2.3 Reconnaissance d’entités nommées [9] [10] [11] 2.3.1 Mesures d’évaluations [10] 2.3.2 les CRF 2.3.3 Les Transformers 2.3.4 BERT : Pre-training of Deep Bidirectional Transformers for Language Understanding 2.3.4.1 Pre-training 2.3.4.2 Fine-tuning 2.3.5 RoBERTa : Robustly Optimized BERT-Pretraining Approach 2.3.5.1 Données 2.3.5.2 Masquage statique et dynamique 2.3.5.3 Large Batch Sizes 2.3.5.4 Tokenisation 2.3.6 CamemBERT 2.4 Liaison d’entité 2.4.1 Défis liés la liaison d’entité 2.4.2 Graphes de connaissances 2.4.3 Faire de la liaison d’entité 2.4.4 RELIC (Representations of Entities Learned in Context) 2.4.5 OpenTapioca 2.5 Conclusion 11 12 12 13 14 17 20 21 22 22 23 23 24 25 26 27 28 29 30 30 32 33 33 35 36 36 36 37 37 39 40 40 40 41 42 42 Implémentation et analyse des résultats 4.1 Introduction 4.2 Reconnaissance des mentions d’entités 4.2.1 Préparation des données 43 43 43 43 Proposition de solution 3.1 Introduction 3.2 Approche 3.3 Données 3.3.1 La base de données Joconde 3.3.2 Projet Wikidata Vocabulaires Joconde 3.4 Reconnaissance des mentions d’entités 3.4.1 Méthode de pré-annotation du corpus 3.4.2 Modèle de reconnaissance des mentions d’entités 3.5 Recherche des mentions dans le graphe de connaissance 3.6 Désambiguïsation 3.6.1 RELIC : données d’entrée 3.6.2 RELIC : Traitements 3.6.3 RELIC : données de sortie 3.7 Conclusion ii BIBLIOGRAPHIE Model ACL 2020 - 58th Annual Meeting of the Association for Computational Linguistics, Jul 2020, Seattle, United States ff10.18653/v1/2020.acl-main.645ff ffhal-02889805ff [13] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding Jacob Devlin, Ming-Wei Chang, Kenton Lee, Kristina Toutanova, arXiv:1810.04805 [14] Attention Is All You Need Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, Illia Polosukhin, arXiv:1706.03762 [15] https://lesdieuxducode.com/blog/2019/4/bert–le-transformer-model-quisentraine-et-qui-represente [16] CamemBERT: a Tasty French Language Model Louis Martin Benjamin Muller Pedro Javier Ortiz SuárezYoann Dupont3 Laurent Romary Éric Villemonte de la Clergerie Djamé Seddah Bent Sagot, arXiv:2005.13236 [17] https://en.wikipedia.org/wiki/Entity_linking [18] Antonin Delpeuch OpenTapioca: Lightweight Entity Linking for Wikidata 2019 ffhal-02098522ff [19] W Shen, J Wang, and J Han 2015 Entity Linking with a Knowledge Base: Issues, Techniques, and Solutions IEEE Transactions on Knowledge and Data Engineering, 27(2):443–460 [20] Jeffrey Ling, Nicholas FitzGerald, Zifei Shan, Livio Baldini Soares, Thibault Févry, David Weiss, Tom Kwiatkowski, Learning Cross-Context Entity Representations from Text arXiv:2001.03765 [21] A V Aho and M J Corasick Efficient string matching: an aid to bibliographic search Commun ACM, 18:333–340, June 1975 [22] Text Chunking using Transformation-Based Learning Lance A Ramshaw (Bowdoin College), Mitchell P Marcus (University of Pennsylvania), arXiv:cmp-lg/9505040 [23] https://blog.sodifrance.fr/services-web-soap-rest/ [24] Mendes, Pablo N and Jakob, Max and García-Silva, Andrés and Bizer (2011), "DBpedia Spotlight: Shedding Light on the Web of Documents", IJCSMC, Vol 2, Issue 2, pp 28 – 35 [25] Hoffart, Johannes and others (2011), "Robust Disambiguation of Named Entities in Text [26] Yinhan Liu et others (2019), "RoBERTa: A Robustly Optimized BERT Pretraining Approach " [27] http://www.wikidata.org/wiki/Wikidata:WikiProject_Vocabulaires_Joconde/en [28] Moissinac, Rouzé and others (2020), "Toward a Semantic Representation of the Joconde Database", pages = 62–67 67 Annexe A Quelques fonctions Pré-traitement des données import json import time import spacy import Parameters as parameters from langdetect import detect from SPARQLWrapper import SPARQLWrapper, POST, BASIC, JSON import pandas as pd import re import os from selenium import webdriver import tensorflow_datasets as tfds from sentence_splitter import split_text_into_sentences def get_data(request, query_target): ’’’ Recuperer les donnees depuis un serveur :param request: :param query_target: :return: request results ’’’ conx = parameters.get_login_pwd() sparql = SPARQLWrapper(query_target) sparql.setHTTPAuth(BASIC) sparql.setCredentials(conx[0], conx[1]) sparql.setMethod(POST) sparql.setReturnFormat(JSON) sparql.setQuery(request) results = sparql.query() return results.response.read().decode("utf-8") 68 ANNEXE A QUELQUES FONCTIONS def write_json(data, filename): ’’’ :param data: :param filename: :return: ’’’ if os.path.isfile(filename): open(filename, ’w’).close() # Suppression du contenu avant ecriture with open(filename, ’w’) as f: json.dump(data, f, indent=4, ensure_ascii=False) def lematize_text(texte, nlp): ’’’ :param texte: :param nlp: :return: tokens, lemma, pos_ ’’’ doc = nlp(texte) lst_lema = [token.lemma_ for token in doc] lst_pos = [token.pos_ for token in doc] lst_tokens = [token for token in doc] return lst_tokens, lst_lema, lst_pos def getOverlap(a, b): ’’’ :param intervalle a: :param intervalle b: :return: si non et la distance de overlaps si oui ’’’ return max(0, min(a[1], b[1]) - max(a[0], b[0])) def clean_overlaps_entities(list_entities): ’’’ :param list_entities: :return: la liste des plus grande mentions possible (Ex: papier et papier glacé) ’’’ if len(list_entities) < 2: return list_entities 69 ANNEXE A QUELQUES FONCTIONS clean_list_entities = [] clean_list_entities.append(list_entities[0]) del list_entities[0] for ent in list_entities: insert = False over_nothing = True list_a_remove = [] for clean_ent in clean_list_entities: overlap = getOverlap([ent[0], ent[1]], [clean_ent[0], clean_ent[1]]) if overlap > 0: over_nothing = False if ent[1] - ent[0] 0: # Le premier mot est la clé on verifie son existance key = lst_terms_p_lem[0] if key not in dict_p.keys(): min_terms_lengh = 100 max_terms_lengh = dict_p[key] = {"min_terms_lengh": min_terms_lengh, "max_terms_lengh": max_terms_lengh, "terms": [] } print("New key add => " + key) word_lst_terms_p_lem = " ".join(lst_terms_p_lem) # verifier que le term n’existe pas deja dans la liste if word_lst_terms_p_lem not in dict_p[key]["terms"]: min_terms_lengh = min(dict_p[key]["min_terms_lengh"], len(lst_terms_p_lem)) max_terms_lengh = max(dict_p[key]["max_terms_lengh"], len(lst_terms_p_lem)) current_lst_terms = dict_p[key]["terms"] # append(word_lst_terms_p_lem) current_lst_terms.append(word_lst_terms_p_lem) dict_p[key] = {"min_terms_lengh": min_terms_lengh, "max_terms_lengh": max_terms_lengh, "terms": current_lst_terms } print(key + " values => ") 71 ANNEXE A QUELQUES FONCTIONS dict_styles_artistiques_data[p] = dict_p write_json(dict_styles_artistiques_data, " /data/dict_styles_artistiques_tokenize_lem.json") def pre_annotate_ner_data(style_artistique_file, data_file_name): ’’’ function de preannotation du fichier texte en data_file_name :param style_artistique_file: fichier json des styles lemmatise :param data_file_name: text brute :return: ’’’ starttime = time.time() with open(style_artistique_file) as json_file: styles_artistiques_data = json.load(json_file) all_s = None with open(data_file_name, ’r’) as file: tmp_all_s = file.readlines() nlp = spacy.load(’fr_core_news_md’) all_s = [] for s in tmp_all_s: s_list = split_text_into_sentences( text=s, language=’fr’ ) all_s.extend(s_list) lst_entities_types = ["ADJ", "ADV", "NOUN", "NUM", "VERB", "PROPN"] lst_tag_sentences = [] percent = nb_sent_add = for sentence in all_s: IS_ANOTABLE = False sentence = sentence.replace(’\n’, ’’) sentence = re.sub("\s\s+", " ", sentence) sentence = sentence.replace(u’\xa0’, u’ ’) percent += token_sentence, lem_sentence, pos_sentence = lematize_text(sentence, nlp) # Construction du dictionaire de la phrase dict_token_sentence = {} dict_tags_sentence = {} dict_lem_sentence = {} 72 ANNEXE A QUELQUES FONCTIONS sentence_lem_code = [] lst_all_sentence_lem_code = [] for index in range(len(token_sentence)): dict_token_sentence[index] = token_sentence[index].text dict_tags_sentence[index] = "O" # Initialisation de tous les mots a O if pos_sentence[index] in lst_entities_types: dict_lem_sentence[index] = lem_sentence[index].lower() sentence_lem_code.append(index) lst_all_sentence_lem_code.append(sentence_lem_code) number_of_while = while True: number_of_while += stop = True for p in styles_artistiques_data: if p in [’DOMAINE’, ’EPOQUE’, ’PERIODE’, ’TECHNIQUE’]: lst_key_done = [] lst_dict_p = styles_artistiques_data[p] for key in lst_dict_p.keys(): if key not in lst_key_done: sentence_lem_code_in_key = [] # Prendre les sous phrases dans laquelle se trouve la key for one_sentence_lem_code in lst_all_sentence_lem_code: one_sentence_lem_normal = [dict_lem_sentence[x] for x in one_sentence_lem_code] if key in one_sentence_lem_normal: sentence_lem_code_in_key.append( (one_sentence_lem_normal.index(key), one_sentence_lem_code)) # Chercher les termes de la cle dans les sous phrases trouvé if len(sentence_lem_code_in_key) > 0: # print(type(lst_dict_keys[key])) terms_in_key = lst_dict_p[key]["terms"] min_terms_lengh = lst_dict_p[key]["min_terms_lengh"] max_terms_lengh = lst_dict_p[key]["max_terms_lengh"] terms_in_key.sort(key=lambda x: len(x.split()), reverse=True) # Sort bye lenght of number of words for key_index, 73 ANNEXE A QUELQUES FONCTIONS one_sentence_lem_code_in_key in sentence_lem_code_in_key: terms_substract_code = one_sentence_lem_code_in_key[ key_index:key_index + max_terms_lengh + 1] while len(terms_substract_code) >= min_terms_lengh: # print("len(terms_substract_code) => "+str(len(terms_substract_code))) terms_substract_normal = [dict_lem_sentence[x] for x in terms_substract_code] if " ".join(terms_substract_normal) in terms_in_key: # Mettre les le tags correspondant aux mots IS_ANOTABLE = True print( "( " + p + " ) Key => " + key + " expressions trouvées => " + " ".join( terms_substract_normal)) min_terms_substract_code = min(terms_substract_code) max_terms_substract_code = max(terms_substract_code) if min_terms_substract_code == max_terms_substract_code: dict_tags_sentence[terms_substract_code[0]] = "B-" + p else: dict_tags_sentence[terms_substract_code[0]] = "B-" + p for ind in range(min_terms_substract_code + 1, max_terms_substract_code + 1): dict_tags_sentence[ind] = "I-" + p # p == Tag de l’entite # Mis a jour de la liste des phrases left_child_sentence = one_sentence_lem_code_in_key[:key_index] right_child_sentence = one_sentence_lem_code_in_key[ 74 ANNEXE A QUELQUES FONCTIONS key_index + len(terms_substract_code) + 1:] lst_all_sentence_lem_code.remove(one_sentence_lem_code_in_key) if len(left_child_sentence) > 0: lst_all_sentence_lem_code.append(left_child_sentence) if len(right_child_sentence) > 0: lst_all_sentence_lem_code.append(right_child_sentence) terms_substract_code = [] stop = False else: terms_substract_code = terms_substract_code[:len(terms_substract_code) - 1] if stop: break if IS_ANOTABLE: for index in range(len(token_sentence)): lst_tag_sentences.append({"word": dict_token_sentence[index], "tag": dict_tags_sentence[index]}) lst_tag_sentences.append({"word": "end", "tag": ""}) nb_sent_add += print(str(nb_sent_add) + " sentences adds") if percent % 200 == 0: df_sentence = pd.DataFrame(lst_tag_sentences) df_sentence.to_csv(" /data/data.txt", header=False, index=False, sep=’\t’) print(’{} seconds passed’.format(time.time() - starttime)) print(str(percent) + " completed") df_sentence = pd.DataFrame(lst_tag_sentences) df_sentence.to_csv(" /data/data.txt", index=False, header=False, sep=’\t’) print(’{} seconds passed’.format(time.time() - starttime)) print("End function") def process_oeuvre_data(): 75 ANNEXE A QUELQUES FONCTIONS ’’’ Recupere les descriptions des expositions en faisant un filtre sur les descriptions francaise uniquement :return: ’’’ print("Start processing") print("-" * 75) requests = """ PREFIX rdfs: PREFIX schema: select distinct ?cmt where { graph ?g { ?s rdfs:label ?cmt } } """ query_target = "https://ws49-cl4-jena.tl.teralab-datascience.fr/dmworks/query" expo_lb_cmts = get_data(requests, query_target) expo_data_json = json.loads(expo_lb_cmts) open(" /data/oeuvre_desc.json", ’w’).close() # Suppression du contenu du fichier avt ecriture write_json(expo_data_json, " /data/oeuvre_desc.json") print("End get data to server ") print("-" * 50) with open(" /data/oeuvre_desc.json") as json_file: data = json.load(json_file) results = (data["results"])["bindings"] cpt = open(" /data/tmp_oeuvre_desc.txt", ’w’).close() # Suppression du contenu du fichier avt ecriture with open(" /data/tmp_oeuvre_desc.txt", "a") as text_file: for binding in results: cpt += cmt = binding["cmt"] if cmt["xml:lang"] == "fr": cmt_txt = cmt["value"] text_file.write(cmt_txt + "\n") print("Start process tmp_oeuvre_desc => oeuvre_desc") print("-" * 50) open(" /data/oeuvre_desc.txt", ’w’).close() # Suppression du contenu du fichier avt ecriture with open(" /data/oeuvre_desc.txt", "a") as text_file: with open(" /data/tmp_oeuvre_desc.txt", ’r’) as file: 76 ANNEXE A QUELQUES FONCTIONS document = file.readlines() tot_sent = len(document) i = for s in document: i += s = s.strip().replace(’\n’, ’’) if s: try: lng = detect(s) except: lng = "error" print("This row throws and error:", s) if lng == "fr": text_file.write(s + "\n") print(str(i / tot_sent * 100) + " percent complete \r") print("End processing") print("-" * 75) def get_french_wikipedia_link(url="https://en.wikipedia.org/"): ’’’ recherche l’url wikipedia francaise de l’url en parametre :param url: :return: url en francais ’’’ chrome_options = webdriver.ChromeOptions() chrome_options.add_argument(’ headless’) chrome_options.add_argument(’ no-sandbox’) chrome_options.add_argument(’ disable-dev-shm-usage’) browser = webdriver.Chrome(’ /chromedriver’, options=chrome_options) browser.get(url) time.sleep(1) language_ul = ’//*[@id="p-lang"]/div/ul’ elem_language_ul = browser.find_elements_by_xpath(language_ul) if len(elem_language_ul) > 0: all_li = elem_language_ul[0].find_elements_by_tag_name(’li’) fr_url = "" for li in all_li: if li.find_element_by_tag_name(’a’).get_attribute(’lang’) == "fr": fr_url = li.find_element_by_tag_name(’a’).get_attribute(’href’) return fr_url return url 77 ANNEXE A QUELQUES FONCTIONS def get_text_in_wikipedia(entities_file): ’’’ fonction de selection des descriptions des entites existante dans le fichier entities_file :param entities_file: :return: ’’’ data, _ = tfds.load("wiki40b/fr", with_info=True) train_test = [’train’, ’validation’, ’test’] with open(entities_file) as f1: exit_entities = json.load(f1) len_pref = len("http://www.wikidata.org/entity/") lst_entities = [e["property"][len_pref:] for e in exit_entities] lst_sentences = [] cpt = cpt_all = total_num_examples = 1363865 for x in train_test: for t_data in data[x]: wikidata_id = bytes.decode(t_data[’wikidata_id’].numpy()) cpt_all += if wikidata_id in lst_entities: cpt += text = bytes.decode(t_data[’text’].numpy()) text = text.replace("_START_ARTICLE_", "").replace("_START_SECTION_", "").replace("_START_PARAGRAPH_", "").replace("_NEWLINE_", "\n") text = text.split("\n") num = for t in text: if t: t = t.replace(u’\xa0’, u’ ’) if t: sentences_list = split_text_into_sentences( text=t, language=’fr’ ) for s in sentences_list: s = s.strip() if len(s.split()) > 1: num += lst_sentences.append({"wikidata_id": 78 ANNEXE A QUELQUES FONCTIONS wikidata_id, "num": num, "content": s }) if cpt_all % 100000 == 0: print("Number all " + str(cpt_all) + "/" + str(total_num_examples)) df_sentence = pd.DataFrame(lst_sentences) df_sentence.to_csv(" /data/wiki40bfr.txt", index=False, header=False, sep=’\t’) print("Number of entities map = " + str(cpt)) def pre_annotate_disambiguation_data(entities_file, data_file_name): with open(entities_file) as file: xentities = json.load(file) df_sentences = pd.read_csv(data_file_name, sep=’\t’, header=None, names=[’QID’, ’SNUM’, ’S’]) data_iob = [] cpt = total = len(xentities) len_pref = len("http://www.wikidata.org/entity/") for xent in xentities: cpt += current_ent = xent[’property’][len_pref:] pattern = [xent[’label’]] xPat = [] if xent[’altLabel_list’]: xPat = xent[’altLabel_list’].split(’| ’) if len(xPat) > 0: pattern.extend(xPat) xPat = [] pattern = [p.strip() for p in pattern] pattern = [p[:-1] if p.endswith(’.’) else p for p in pattern] # trouve = False df_qei = df_sentences.loc[df_sentences[’QID’] == current_ent] sentences_list = df_qei[’S’].tolist() del df_qei for s in sentences_list: outs = [] for one_pattern in pattern: regex = re.compile(r’\b(’ + ’|’.join([one_pattern]) + r’)\b’) 79 ANNEXE A QUELQUES FONCTIONS out = [(m.start(), m.end(), s[m.start():m.end()]) for m in regex.finditer(s)] if len(out) > 0: outs.extend(out) if len(outs) > 0: outs = clean_overlaps_entities(outs) for out in outs: sent = s[:out[0]] sent = sent + "[Es] " sent = sent + s[out[0]:out[1]] sent = sent + " [Ee]" sent = sent + s[out[1]:] data_iob.append({ "sentence": sent, "label": current_ent }) # trouve = True print(str(cpt) + "/" + str(total) + " done") with open(’ /data/wiki40bfr_disambiguisation.json’, ’w’) as f: json.dump(data_iob, f, indent=4, ensure_ascii=False) def tsv_to_txt(tsv_file_name, output_file_name): ’’’ recupere un fichier de format tsv et produit un fichier textuel brute Exp entre: Q595765 Sebastiano Ghezzi Q595765 Né prs d’Ascoli Piceno, Sebastiano Ghezzi sortie: Sebastiano Ghezzi Né prs d’Ascoli Piceno, Sebastiano Ghezzi :param tsv_file_name: :param output_file_name: :return: ’’’ df_sentences = pd.read_csv(tsv_file_name, sep=’\t’, header=None, names=[’QID’, ’SNUM’, ’S’]) with open(output_file_name, "w") as out: for s in df_sentences["S"].tolist(): out.write(s + "\n") print("End tsv to txt") 80 ANNEXE A QUELQUES FONCTIONS 81 ... NATIONALE DU VIETNAM, HANOÏ INSTITUT FRANCOPHONE INTERNATIONAL Solibia PAZIMNA Mise en oeuvre de traitement de données - analyses de graphes, machine learning, et leur automatisation, et web services. .. dans l’encodeur, le décodeur ou entre l’encodeur et le décodeur La raison en est que nous voulons nous occuper de la séquence d’entrée entière de l’encodeur ou d’une partie de la séquence d’entrée... l’encodeur et le décodeur, modules d’attention multi-heads, V est constitué de la même séquence de mots que Q Cependant, pour le module d’attention qui prend en compte les séquences d’encodeur et de