Wiki de l'ARHN

Axe de recherche en histoire numérique
LARHRA UMR5190

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
Allez vers la [[etapes|page précédente - étapes]]

====== Fusionner les bases de données ======

Une fois que l'on a pris connaissance des données que l'on souhaite obtenir des différentes bases de données, il est possible de créer un serveur local afin de stocker les données. Cela permet aussi d'aligner les bases de données pour avoir un vocabulaire contrôlé. Pour cela, nous avons fait le choix d'utiliser **[[projets_individuels:documentation_sparql&#vocabulaire|GraphDB]]** pour sa facilité d'utilisation et ses fonctionnalités. L'importation des données se fait en deux étapes, d'abord nous importons les instances et ensuite leur(s) propriété(s).

====Importation des instances de Wikidata====
Nous avons fait le choix d'importer en premier les données provenant de Wikidata car c'est le plus gros silos avec plus de 130 000 instances. Il est important d'importer à la fois les économistes et les juristes afin de ne pas avoir des doublons pour les personnes qui serait dans les deux populations. Ensuite, nous donnons à chaque instance un [[https://fr.wikipedia.org/wiki/Uniform_Resource_Name|URN]] unique afin que lorsque l'on ajoute d'autres bases de données, l'URN correspond à une personne réelle si elle est présente sur plusieurs bases de données. Pour cela il faut utiliser la clause [[https://www.w3.org/TR/sparql11-query/#func-uuid|UUID]] qui présente un URN sous la forme: "urn:uuid:b9302fb5-642e-4d3b-af19-29a8f6d894c9".

Préalablement, il est aussi possible dans Wikidata de fusionner des pages (et leur URI) qui correspondent à une même personne (la méthode est sur cette **[[projets_individuels:documentation_wikidata|page]]**). 

La requête se présente de la façon suivante: 
<code sparql>
PREFIX  xsd:  <http://www.w3.org/2001/XMLSchema#>
PREFIX  owl:  <http://www.w3.org/2002/07/owl#>
PREFIX  wd:   <http://www.wikidata.org/entity/>
PREFIX  wdt:  <http://www.wikidata.org/prop/direct/>
PREFIX  ome:  <https://ontome.net/class/>

INSERT { 
### La clause INSERT créé des triplets et les insére dans un graphe
  GRAPH <http://economists_jurists.org/import_wikidata> { 
### Avec cette clause, nous précisons que cette dans ce graphe 
### que nous voulons nos instances, cela permettra par la suite 
### de différencier les bases de données
       #CONSTRUCT{ 
### la clause CONSTRUCT est utile pour voir les triplets  
### que cela crée avant de les mettre dans un graphe. (elle est ici désactivée)
    ?uri <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ome:21 . 
### Nous précisons ici que les instances sont de type personne 
### ("ome:21" correspond à la classe personne dans ontoME)
    ?uri owl:sameAs ?person .
### avec la propriété sameAs, nous indiquons que les URI créés avec
### la clause UUID correspond aux instances de Wikidata.
  }
}

WHERE
  { SERVICE <https://query.wikidata.org/sparql> 
### La SERVICE service permet d'aller chercher les données Wikidata sur GrapheDB. 
      { SELECT DISTINCT  ?person
        WHERE
           { { ?person  wdt:P106  wd:Q188094 ; # économiste ("economist)
                       wdt:P569  ?birthDate
               ### 'birthDate' est la seule propriété qu'il faut conserver
               ### afin d'être à l'intérieur de nos limites chronologiques
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
            UNION
           { ?person  wdt:P106  wd:Q185351 ; # juriste ("jurist")
                       wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
            UNION
            {?person wdt:P106 wd:Q40348; # avocat ("lawyer")
                     wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
           UNION
            {?person wdt:P106 wd:Q16533; # juge ("judge")
                     wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
             UNION
            {?person wdt:P106 wd:Q758225; # avocat ("attorney at law")
                     wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
            UNION
            {?person wdt:P106 wd:Q380075; # avocat("advocate")
                     wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
            UNION
            {?person wdt:P106 wd:Q16009129; # magistrat ("magistrate")
                     wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
            UNION
            {?person wdt:P106 wd:Q791243; # avocat en France ("legal advocate in France")
                     wdt:P569  ?birthDate
              FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
            }
          }
        ORDER BY ?person
      }
    BIND(uuid() AS ?uri) 
### La clause UUID permet de créer un URN unique que 
### nous pouvons lier avec la clause BIND aux instance.
# LIMIT 10 
### Lors de l'utilisation de la clause CONSTRUCT il vaut mieux n'afficher qu'un petit nombre de résultats.
  }
</code>

==== Importation des propriétés de Wikidata ====

Un fois que l'on a importé les instances, il est désormais possible d'importer les propriétés une à une. Importer les propriétés individuellement permet d'éviter les doublons d'instance et c'est aussi plus facilement modulable. 
Dans Wikidata, nous faisons le choix d'importer les propriétés suivantes qui nous paraissent intéressantes:

  * Nom
  * Genre
  * Date de naissance
  * Date de mort
  * Lieu de naissance
  * Lieu de mort
  * Nationalité
  * École(s) fréquenté(s)
  * Poste(s) occupé(s)
  * URI VIAF
  * URI BnF Data

Nous voulions ajouté à cela les personnes qui les ont influencées et celles qu'elles ont influencées, ainsi que les écoles de pensées auxquelles elles ont appartenu, mais le nombre de personnes ayant ces propriétés est inférieur à 1% donc cela n'est pas pertinent. 

La méthode pour importer les propriétés est assez similaire à celle des instances. L'exemple suivant a pour but d'importer les lieux de naissance dans la base de données. La requête se construit de la façon suivante: 
<code sparql>
PREFIX  owl:  <http://www.w3.org/2002/07/owl#>
PREFIX  wdt:  <http://www.wikidata.org/prop/direct/>
PREFIX  ome:  <https://ontome.net/class/>
PREFIX  xsd:  <http://www.w3.org/2001/XMLSchema#>
PREFIX  rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX  wd:   <http://www.wikidata.org/entity/>

INSERT {
  GRAPH <http://economists_jurists.org/import_wikidata> {
#CONSTRUCT {
    ?uri wdt:P19 ?placeOfBirth .  ### Cela insert le lieu de naissance de chaque personne et les lie aux URI
  }
}
WHERE
  { ?uri  owl:sameAs  ?person  ### Cela indique que les instances sont égales aux URI
    { SERVICE <https://query.wikidata.org/sparql>
        { SELECT DISTINCT  ?person ?placeOfBirth
          WHERE
            { ?person  wdt:P19  ?placeOfBirth
              {   { ?person  wdt:P106  wd:Q188094 ;  # economiste ("economist")
                             wdt:P569  ?birthDate
                    FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
                  }
                UNION
                  { ?person  wdt:P106  wd:Q185351 ; # juriste ("jurist")
                             wdt:P569  ?birthDate
                    FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
                  }
              }
            }
        }
    }
  }
#LIMIT 10
</code>

Cette requête est utile mais elle permet seulement d'inserer dans la base de données, les URI de Wikidata des lieux de naissance. il est plus intéressant de pouvoir insérer aussi d'autres éléments comme l'étiquette du lieu ou bien ses coordinnées géographique. Une fois encore la requête est assez similaire, mais demande quelques rafinements supplémentaires: 

<code  squarl>
PREFIX  bd:   <http://www.bigdata.com/rdf#>
PREFIX  owl:  <http://www.w3.org/2002/07/owl#>
PREFIX  wdt:  <http://www.wikidata.org/prop/direct/>
PREFIX  ome:  <https://ontome.net/class/>
PREFIX  wikibase: <http://wikiba.se/ontology#>
PREFIX  xsd:  <http://www.w3.org/2001/XMLSchema#>
PREFIX  rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX  wd:   <http://www.wikidata.org/entity/>
PREFIX p: <http://www.wikidata.org/prop/>
PREFIX psv: <http://www.wikidata.org/prop/statement/value/>
PREFIX ps: <http://www.wikidata.org/prop/statement/>

INSERT {
  GRAPH <http://economists_jurists.org/import_wikidata> {
#CONSTRUCT {
    ?uri wdt:P19 ?placeOfBirth .
    ?placeOfBirth rdfs:label ?labelOfPlaceOfBirth .
    ?placeOfBirth wikibase:geoLatitude ?lat .
    ?placeOfBirth wikibase:geoLongitude ?long .
  }
}
WHERE
  { ?uri  owl:sameAs  ?person
    { SERVICE <https://query.wikidata.org/sparql>
        { SELECT  ?person ?placeOfBirth ?placeOfBirthLabel ?labelOfPlaceOfBirth ?lat ?long ?GeoNames
          WHERE
          { { SELECT DISTINCT  ?person ?placeOfBirth ?placeOfBirthLabel ?latitude ?longitude ?oldURI
          WHERE
            {  ?person  wdt:P19 ?placeOfBirth .
               ?placeOfBirth p:P625 [ # p: Lie les entités aux déclarations (cf.https://www.mediawiki.org/wiki/Wikibase/Indexing/RDF_Dump_Format#Prefixes_used)
                             psv:P625 [ # psv: lie profondément une valeur à un déclaration
                                        wikibase:geoLatitude ?latitude; # permet d'aller chercher la lattitude d'un lieu
                                        wikibase:geoLongitude ?longitude;
                                      ] ;
                             ps:P625 ?coord # ps: lie une valeur à une déclaration
                                    ] .
                SERVICE wikibase:label # service qui permet d'importer les étiquettes
                      { bd:serviceParam
                                  wikibase:language  "en" # permet d'aller chercher uniquement les étiquettes en anglais
                      }
              {   { ?person  wdt:P106  wd:Q188094 ;  # économiste ("economist")
                             wdt:P569  ?birthDate
                    FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
                  }
                UNION
                  { ?person  wdt:P106  wd:Q185351 ; # juriste ("jurist") 
                             wdt:P569  ?birthDate
                    FILTER ( ?birthDate >= "1770-01-01"^^xsd:dateTime )
                  }
              }
            }
        }
 BIND(str(?placeOfBirthLabel) AS ?labelOfPlaceOfBirth)
 BIND(str(?latitude) AS ?lat)
 BIND(str(?longitude) AS ?long)
# La clause BIND permet d'importer les données en enlevant les indications de format ou la langue dans laquelle l'étiquette est importée. ex: transforme "Paris"@en en "Paris".
    }
  }
}
}
#LIMIT 100
</code>


==== Importation des instances de BnF Data ====

Nous importons ensuite les instances de BnF Data. La méthode est assez similaire à celle de Wikidata, mais elle demande quelques étapes préliminaires. Avant d'attribuer aux instances un URN, il faut d'abord aligner les instances de BnF Data avec celle de Wikidata. Pour cela plusieurs méthodes sont disponibles. Tout d'abord, il est possible le lier les instances de Wikidata qui renvoient vers une instances de BnF Data. [mettre la méthode quand je l'aurais trouvé]. Ensuite, il est possible de lier ces instances avec un identifiant VIAF qu'elles ont en commun. Nous procédons de la façon suivante: 

<code sparql>
PREFIX  xsd:  <http://www.w3.org/2001/XMLSchema#>
PREFIX  egr:  <http://rdvocab.info/ElementsGr2/>
PREFIX  owl:  <http://www.w3.org/2002/07/owl#>
PREFIX  ome:  <https://ontome.net/class/>
PREFIX  wdt:  <http://www.wikidata.org/prop/direct/>

INSERT {
  GRAPH <http://economists_jurists.org/import_bnf_data>
# CONSTRUCT
  {
    ?URI owl:sameAs ?person_bnf . 
### cela lie les instances ayant un identifiant VIAF avec celles 
### qui sont déjà présentes dans le serveur qui ont un identifiant VIAF commmun.
  }
}
WHERE
  { SELECT DISTINCT ?URI ?person_bnf
    WHERE
      { ?URI  wdt:P214  ?uri_viaf # la requête cherche les identifiants VIAF dans la base de données locales
        { SERVICE <https://data.bnf.fr/sparql>
            { # La sous-requête cherche les identifiants VIAF dans BnF Data
              { ?person_bnf  egr:biographicalInformation  ?bio ;
                               egr:dateOfBirth              ?bd ;
                               owl:sameAs                   ?uri_viaf
                  FILTER regex(?uri_viaf, "viaf.org", "i")
                  BIND(strbefore(strafter(str(?bd), "http://data.bnf.fr/date/"), "/") AS ?bd1)
                  FILTER ( ( ( ( ( regex(?bio, "juriste", "i") || regex(?bio, "professeur de droit", "i") ) || regex(?bio, "docteur en droit", "i") ) || regex(?bio, "avocat", "i") ) || regex(?bio, "juge", "i") ) || regex(?bio, "magistrat", "i") )
                  FILTER ( ?bd1 > "1770" )
                }
              UNION
                { ?person_bnf  egr:biographicalInformation  ?bio ;
                               egr:dateOfBirth              ?bd ;
                               owl:sameAs                   ?uri_viaf
                  FILTER regex(?uri_viaf, "viaf.org", "i")
                  BIND(strbefore(strafter(str(?bd), "http://data.bnf.fr/date/"), "/") AS ?bd1)
                  FILTER ( ( ( regex(?bio, "économiste") || regex(?bio, "Economiste") ) || regex(?bio, "professeur d'économie", "i") ) || regex(?bio, "docteur en économie", "i") )
                  FILTER ( ?bd1 > "1770" )
                }
            }
        }
      }
  }
# LIMIT 10
</code>

Enfin la dernière méthode qui permet de connaître si des personnes sont dans plus bases de données, c'est le Recordlinkage. Nous la présentons en détail ci-dessous.

==== Recordlinkage ====

Cette méthode permet de calculer la proximité entre deux chaînes de caractères. Elle est répétée entre chaque ligne pour les variables choisies. Nous avons choisis d'utiliser cette méthode sur le nom de la personne, sa date de naissance et sa date de décès. Les deux derniers ont l'avantage d'avoir un format strict (YYYY-MM-DD), donc améliore considérablement les scores.  

Pour réaliser cela, plusieurs bibliothèques python existent. Deux serons présentées ici, et elles sont présentées dans ce très bon article [[https://pbpython.com/record-linking.html|recordlinking]] posté par Chris Moffitt.
=== fuzzymatcher ===
Tout d'abord, la bibliothèque [[https://fuzzymatcher.readthedocs.io/en/latest/|fuzzymatcher]] ( :!: la documentation est très succincte; télécharger avec [[https://anaconda.org/conda-forge/fuzzymatcher|conda]] ou [[https://pypi.org/project/fuzzymatcher/|pip]] ) permet de le faire. Mais elle a le gros désavantage de ne pas fonctionner avec des nombres ou des dates (ou plutôt elle est analyse comme des chaînes de caractère). 

On commence par choisir les colonnes pour lesquels ont veut utiliser la méthode:

<code python>

left_on=["name_bnf", "placeOfBirth_bnf","placeOfDeath_bnf"]
right_on=["name_dbp", "placeOfBirth_dbp","placeOfDeath_dbp"]
</code>

Ensuite, on applique la méthode à proprement parler:
<code python>
matched_results = fuzzymatcher.fuzzy_left_join(BnF_Data,
                                            DBpedia,
                                            left_on,
                                            right_on,
                                            left_id_col='uri_bnf',
                                            right_id_col='uri_dbp')
</code>
Après, il faut expliciter quels colonnes souhaite-on voir apparaître (même celles sur lesquelles, le calcul ne se fait pas):
<code python>
cols_bnf_dbp= ["best_match_score","id_bnf","uri_bnf","viaf_bnf", "name_bnf", "dateBirth_bnf", "dateDeath_bnf","placeOfBirth_bnf","placeOfDeath_bnf", "bio_bnf", "id_dbp","uri_dbp", "viaf_dbp", "name_dbp","birthDate_dbp","deathDate_dbp", "placeOfBirth_dbp","placeOfDeath_dbp"]
</code>
Enfin on affiche les résultats:
<code python>
best_match_bnf_dbp=matched_results[cols_bnf_dbp].sort_values(by=["best_match_score"], ascending=False).head(10)
best_match_bnf_dbp
</code>
------------------------
\\
=== recordlinkage ===
La seconde méthode semble beaucoup pertinente au vu des données que nous disposons. La bibliothèque [[https://recordlinkage.readthedocs.io/en/latest/about.html|recordlinkage]] (télécharger avec [[https://anaconda.org/conda-forge/recordlinkage|conda]] ou [[https://pypi.org/project/recordlinkage/|pip]] permet aussi de calculer la proximité entre des chaînes de caractères. Mais cette dernière à l'avantage de fonctionner avec tous types de données (cf. cette [[https://recordlinkage.readthedocs.io/en/latest/ref-compare.html|page]] pour voir les types).

La méthode de cette bibliothèque est assez semblable à la précédente. on commence par index les deux jeux de données:

<code python>
import recordlinkage

indexer = recordlinkage.Index()
indexer.sortedneighbourhood(left_on='name_bnf', right_on='name_dbp')
candidates = indexer.index(BnF_Data, DBpedia)
print(len(candidates))
</code>

Il est possible de le faire sur l'ensemble des données, mais au regard volume et de la puissance de calcul nécessaire, nous le faisons que pour une seule variable. À nous choisissons celle qui donne le plus grand nombre candidat potentiel.  Il est aussi de possible de réaliser la même méthode sur un seul jeu de données en mettant deux fois la même variable et le même jeu de données. Cela nous a été notamment très utilisé pour déceler des personnes présentes deux fois sous un URI différent.

Ensuite, il faut réaliser les comparaisons: compare = recordlinkage.Compare()
<code python>
compare.string('name_bnf',
            'name_dbp',
            threshold=0.85,
            label='name_bnf_dbp')
compare.exact('dateBirth_bnf',
            'birthDate_dbp',
            label='birthDate_bnf_dbp')
compare.exact('dateDeath_bnf',
            'deathDate_dbp',
            label='deathDate_bnf_dbp')
features = compare.compute(candidates, BnF_Data, DBpedia)
</code>

Pour les dates de naissance et de mort, nous avons fait le choix de prendre les valeurs exacts afin de contrer des éventuels différences de formats (ex: dans BnF Data certaines dates sont écrites ainsi: "18.." la bibliothèque n'arrive pas à les interpréter et ne sort pas de résultats). 

Il faut ensuite de fusionner les données prenant les comparaisons avec un haut score. Ce dernier indique sur combien de variable un score élevé à été trouvé et les additionnent:

<code python>
potential_matches = features[features.sum(axis=1) > 1].reset_index()
potential_matches['Score'] = potential_matches.loc[:, 'name_bnf_dbp':'deathDate_bnf_dbp'].sum(axis=1)
potential_matches
</code>

L'ensemble de la méthode est disponible sur un **[[https://github.com/Semantic-Data-for-Humanities/Economists_Jurists/blob/development/Notebooks/Merge/Merge_DBpedia_BnF_Data_Wikidata.ipynb|carnet]]** sur Github. Vous pouvez aussi directement accéder aux requêtes en téléchargeant la **[[https://github.com/Semantic-Data-for-Humanities/Economists_Jurists/tree/development/Notebooks/Merge/data/sparql_queries.db|base de données]]** et en l'ouvrant avec un logiciel de requêtage de base de données comme [[https://dbeaver.io/|DBeaver]] ([[https://dbeaver.io/download/|lien]] vers le téléchargement, Mac Os, Windows et Linux).
Wiki de l'ARHNAxe de recherche en histoire numériqueLARHRA UMR5190

Outils pour utilisateurs

Outils du site

Outils de la page

Wiki de l'ARHN

Axe de recherche en histoire numérique
LARHRA UMR5190
