Outils personnels
User menu

Tutoriel édition de mappings

De Dbpedia.fr.

Les mappings sont édités sur le site http://mappings.dbpedia.org, la documentation en Anglais peut être consultée cette la page.

Il s'agit d'un mediawiki, différentes données de DBpedia y sont éditées :

  • l'ontologie
    • les classes
    • les propriétés
    • les datatypes
  • les mappings pour faire correspondre les modèles à des classes de l'ontologie et leurs attributs à des propriétés.

Pour pouvoir éditer le wiki, créer un compte sur le wiki, puis demander les droits d'écriture sur la mailing list dbpedia-discussion@lists.sourceforge.net.


Sommaire

Édition de l'ontologie

Édition des classes

Chaque classes est définie par un modèle {{Class}} dans la page dans l'espace de noms OntologyClass: avec le nom de la classe.

Par exemple la classe http://dbpedia.org/ontology/Person est définie dans la page http://mappings.dbpedia.org/index.php/OntologyClass:Person qui contient : 

{{Class
| labels =
{{label|en|person}}
{{label|de|Person}}
{{label|fr|personne}}
[...]
| rdfs:subClassOf = Agent
| owl:equivalentClass = foaf:Person, schema:Person
}}

Le nom de la classe est donnée par le nom de la page qui contient ce modèle (ici Person), le modèle contient en plus les champs :

  • label qui permet de donner les labels dans différentes langues en utilisant le modèle {{label}}. Ces entrées gênèrent des triplets avec la propriété rdfs:label.
  • comments qui permet de donner une explication plus détaillée de la classe dans différentes langues avec les modèles {{comment}}. Ces entrées génèrent des triplets avec la propriété rdfs:comment. Une bonne pratique est d'y inclure une référence à un article Wikipédia ou Wiktionnaire.
  • rdfs:subClassOf, owl:equivalentClass et owl:disjointWith pour placer la classe dans la hiérarchie de classes.
  • specificProperties permet de spécifier l'unité par défaut à utiliser pour les valeurs d'une propriété applicable à cette classe.


Liens utiles:


Édition des propriétés

Chaque propriété est définie dans la page dans l'espace de noms OntologyProperty: avec le nom de la propriété.

Deux modèles sont utilisés suivant s'il s'agit

Les champs de ces modèles sont les mêmes, la seule différence concerne les valeurs admises pour le champ rdfs:range.

Par exemple pour propriété http://dbpedia.org/ontology/locationCity est définie dans la page http://mappings.dbpedia.org/index.php/OntologyProperty:LocationCity qui contient : 

{{ObjectProperty
| labels =
{{label|en|location city}}
{{label|fr|situé dans la ville}}
[...]
| rdfs:domain = Organisation
| rdfs:range = City
| rdfs:subPropertyOf = location
|comments =
{{comment|en|City the thing is located.}}
}}

Le champ rdfs:range doit contenir une classe définie dans le wiki.

La propriété http://dbpedia.org/ontology/birthDate est définie dans la page http://mappings.dbpedia.org/index.php/OntologyProperty:BirthDate qui contient : 

{{DatatypeProperty
| labels =
{{label|en|birth date}}
{{label|fr|date de naissance}}
{{label|de|Geburtsdatum}}
[...]
| rdfs:domain = Person
| rdfs:range = xsd:date
| rdf:type = owl:FunctionalProperty
| owl:equivalentProperty = schema:birthDate
}}

Le champ rdfs:range doit contenir soit un datatype XSD, soit un datatype défini dans le wiki (voir #Édition_des_datatypes).


Les autres champs sont en commun :

  • labels et comments, définis comme pour les classes permettent d'exprimer et d'expliquer la propriété dans différentes langues.
  • rdfs:domain donne le domaine de la propriété, c'est-à-dire une classe à laquelle doivent appartenir les sujets de la propriété, celle-ci doit avoir été définie dans le wiki.
  • rdfs:subPropertyOf et owl:equivalentProperty permettent de définir des relations de généralisation/spécialisation ou d'équivalence par rapport à d'autres propriétés, celles-ci doivent être définies dans le wiki.
  • rdf:type permet de préciser le type de la propriété (au delà du type owl:ObjectProperty / owl:DatatypeProperty). Actuellement seul le type owl:FunctionalProperty peut être donné, il signifie que la propriété définit une fonction, c'est-à-dire qu'elle ne peut prendre qu'une valeur par sujet.


Liens utiles :


Édition des datatypes

Les datatypes (ou types de données) permettent de définir des types de valeurs absents du vocabulaire XSD, notemment pour définir des unités (centimètre, litre, ...)

Chaque type de donnée est définie par un modèle {{Datatype}} dans la page dans l'espace de noms Datatype: avec le nom du type de donnée.

Par exemple la classe http://dbpedia.org/ontology/Currency est définie dans la page http://mappings.dbpedia.org/index.php/Datatype:Currency qui contient : 

{{Datatype
|labels =
{{label|en|Currency}}
{{label|fr|Monnaie}}
[...]
}}


Liens utiles :


Édition des mappings

Principe

Les modèles (template en anglais), en particulier les infobox sont utilisés pour donner des informations factuelles sur les éléments décrits. Différents modèles sont utilisés suivant le type du sujet décrit (Artiste, Batiment, Évènement ...)

Chaque modèle contient une liste d'attributs qui contiennent les valeurs décrivant le sujet. La signification des attributs dépend du modèle, par exemple dans les Infobox Musée, l'attribut pays désigne l'emplacement du musée, alors que dans les Infobox Cycliste il désigne la nationalité sportive du cycliste.

Les mappings permettent deux choses :

  • typer les instances en associant une classe de l'ontologie à chaque modèle
  • traduire les attributs des modèles en propriétés de l'ontologie.


Mapping élémentaire d'un modèle

Le mapping d'un modèle de Wikipédia en français est défini par un modèle [http://mappings.dbpedia.org/index.php/Template:TemplateMapping {{TemplateMapping}} dans une page de l'espace de noms Mapping_fr: suivi du nom du modèle.

Par exemple le mapping du modèle [Infobox Arbitre] est défini dans la page http://mappings.dbpedia.org/index.php/Mapping_fr:Infobox_Arbitre qui contient : 

{{TemplateMapping
| mapToClass = Referee
| mappings =
  {{PropertyMapping | templateProperty = nom | ontologyProperty = foaf:name }}
  {{PropertyMapping | templateProperty = nom_de_l'arbitre  | ontologyProperty = foaf:name }}
  {{PropertyMapping | templateProperty = surnom | ontologyProperty = foaf:nick }}
  {{PropertyMapping | templateProperty = date_de_naissance | ontologyProperty = birthDate }}
[...]
}}

Le champ mapToClass donne la classe a associer au modèle mappé, ici toutes les instances dont l'article Wikipédia contient une [Infobox Arbitre] prendra le type http://dbpedia.org/ontology/Referee. La classe doit être définie dans le wiki.

Le champ mappings contient les mappings des attributs (appelés ici template properties). Les mappings d'attributs sont définis dans les modèles {{PropertyMapping}} avec les champs :

  • templateProperty : l'attribut du modèle mappé
  • ontologyProperty : propriété associée à l'attribut (doit être définie dans le wiki).
  • unit permet de spécifier le type de données associé si la propriété est de type owl:DatatypeProperty (soit un dataype xsd, soit défini dans le wiki)
  • facteur permet de multiplier la valeur trouvée par ce facteur, par exemple si un nombre est exprimé en millions.


Mappings constants

Parfois, certaines propriétés ne sont pas données sous forme d'attribut, mais implicitement par le choix d'un modèle, par exemple l'utilisation du modèle Infobox Commune de France sous-entend que la commune est en France.

Le modèle {{ConstantMapping}} qui s'utilise dans le champ mappings permet d'introduire la propriété implicite: 

{{TemplateMapping
| mapToClass = Settlement
| mappings =
  {{ConstantMapping | ontologyProperty = country | value = France }}
  {{PropertyMapping | templateProperty = nomcommune | ontologyProperty = foaf:name }}
[...]
}}

La champ ontologyProperty désigne la propriété à utiliser pour le triplet généré, le champ valeur contient soit un littéral dans le cas d'une propriété du type owl:DatatypeProperty, soit une instance sans son préfixe (ici France).


Introduction de nœuds intermédiaires

Il est parfois nécessaire de regrouper des informations, par exemple pour décrire les différents postes occupés par une personnes au cours de sa carrière il faut regrouper la nature du poste avec les dates de début et de fin.

En RDF, cela est obtenu en introduisant des nœuds intermédiaires (appelés aussi blanc nodes s'ils n'ont pas d'identifiant public). Par exemple, l'article sur Arlette Laguiller mentionne deux postes : 

{{Infobox Politicien
| nom = Arlette Laguiller
[...]
| fonction1 = [[Parlement européen|Députée européenne]]
| a partir du fonction1 = {{date|20|juillet|1999}}
| jusqu'au fonction1 = {{date|19|juillet|2004}}
| fonction2 = [[Conseil régional d'Île-de-France|Conseillère régionale d'Île-de-France]]
| a partir du fonction2 = {{date|15|mars|1998}} 
| jusqu'au fonction2 = {{date|28|mars|2004}}
[...]
}}

L'introduction de noeuds intermédiares db-fr:Arlette_Laguiller__1 et db-fr:Arlette_Laguiller__2 permet d'obtenir la représentation suivante : 

db-fr:Arlette_Laguiller		db-owl:occupation	db-fr:Arlette_Laguiller__1
db-fr:Arlette_Laguiller__1	rdf:type	db-owl:PersonFunction
db-fr:Arlette_Laguiller__1	db-owl:title 	"Députée européenne"@fr
db-fr:Arlette_Laguiller__1	db-owl:functionStartDate 	"1999-07-20"
db-fr:Arlette_Laguiller__1	db-owl:functionEndDate 	"2004-07-19"
db-fr:Arlette_Laguiller		db-owl:occupation	db-fr:Arlette_Laguiller__2
db-fr:Arlette_Laguiller__2	rdf:type	db-owl:PersonFunction
db-fr:Arlette_Laguiller__2	db-owl:title 	"Conseillère régionale d'Île-de-France"@fr
db-fr:Arlette_Laguiller__2	db-owl:functionStartDate 	"1998-03-15"
db-fr:Arlette_Laguiller__2	db-owl:functionEndDate 	"2004-03-28"

Cela est obtenu en utilisant un modèle {{IntermediateNodeMapping}} dans le champ mappings. Le résultat de l'exemple d'Arlette Laguiller est obtenu avec http://mappings.dbpedia.org/index.php/Mapping_fr:Infobox_Politicien: 

{{TemplateMapping
| mapToClass = OfficeHolder
| mappings = 
  {{IntermediateNodeMapping
  | nodeClass = PersonFunction
  | correspondingProperty = occupation
  | mappings =
    {{PropertyMapping | templateProperty = fonction1 | ontologyProperty = title }}
    {{PropertyMapping | templateProperty = a partir du fonction1 | ontologyProperty = functionStartDate }}
    {{PropertyMapping | templateProperty = jusqu'au fonction1 | ontologyProperty = functionEndDate }}
  }}
  {{IntermediateNodeMapping
  | nodeClass = PersonFunction
  | correspondingProperty = occupation
  | mappings =
    {{PropertyMapping | templateProperty = fonction2 | ontologyProperty = title }}
    {{PropertyMapping | templateProperty = a partir du fonction2 | ontologyProperty = functionStartDate }}
    {{PropertyMapping | templateProperty = jusqu'au fonction2 | ontologyProperty = functionEndDate }}
  }}
[...]
}}


Mappings conditionnels

Parfois un même modèle est utilisé pour décrire des sujets de type différent qui est spécifié dans un champ. Par exemple le modèle Infobox Prélat catholique est utilisé pour décrire des prêtes, des cardinaux et des papes, l'attribut titre précise leur type.

Le modèle {{ConditionnalMapping}} permet de définir le type à donner aux instances selon la valeur prise par l'attribut titre : 

{{ConditionalMapping
| cases =
 {{Condition
    | templateProperty = titre
    | operator = equals
    | value = Pape
    | mapping = {{TemplateMapping | mapToClass = Pope }}
 }}
 {{Condition
    | templateProperty = titre
    | operator = equals
    | value = Cardinal
    | mapping = {{TemplateMapping | mapToClass = Cardinal }}
 }}
[...]
{{Condition
| operator = otherwise
| mapping = {{TemplateMapping |mapToClass = Cleric }}
}}

| defaultMappings =
  {{PropertyMapping | templateProperty = nom | ontologyProperty = foaf:name }}
  {{PropertyMapping | templateProperty = nom | ontologyProperty = foaf:nick }}
  {{PropertyMapping | templateProperty = nom naissance | ontologyProperty = birthName }}
[...]
}}

Ce modèle s'utilise par dessus les modèles {{TemplateMapping}}, il contient deux champs :

  • cases dans lequel sont données les différentes alternatives, chacune dans un modèle {{Condition}}.
  • defaultMappings qui contient les mappings d'attributs communs à tous les cas (nom trompeur!).

Le modèle {{Condition}} établissent une condition et les mappings à appliquer si la condition est satisfaite:

  • le critère est déterminé par le champ opertor :
    • isSet pour vérifier si un champ est utilisé (champ donné dans templateProperty),
    • equals et contains pour comparer le contenu d'un champ (donné dans templateProperty) avec la valeur donnée dans value
    • otherwise pour la valeur par défaut
  • le champ mappings contient les {{TemplateMapping}} à appliquer.


En pratique

Scénario 1: mapping de modèles les plus fréquents

  • Choisir un modèle à mapper dans la liste http://mappings.dbpedia.org/server/statistics/fr/. Les plus fréquents apparaissent en premier, un code de couleur indique l'état de complétude du mapping : du vert pour un mapping qui couvre presque toutes les propriétés, au rouge pour un mapping inexistant.
  • Cliquer sur le modèle choisi pour aller sur la page d'édition du mapping, si la page existe, créer la page au besoin.
  • Mapper le type de l'instance : voir TemplateMapping
  • Mapper les propriétés : voir PropertyMapping
    • Pour voir la liste des propriétés à mapper : enregister la page de mapping et cliquer sur le lien «properties are not mapped yet.»
  • Tester le mapping : après avoir enregistré la page, cliquer sur le lien «Test this mapping».


Scénario 2: à partir d'un article en particulier

  • Pour obtenir la liste des modèles utilisés dans l'article, remplacer http://fr.dbpedia.org/resource/Musée_du_Louvre par la ressource voulue dans la requête SPARQL : 
select ?t where {
  <http://fr.dbpedia.org/resource/Musée_du_Louvre>
    <http://fr.dbpedia.org/property/wikiPageUsesTemplate> ?t .
}

Dans l'exemple on obtient trois modèles : http://fr.dbpedia.org/resource/Modèle:Autres_projets, http://fr.dbpedia.org/resource/Modèle:Lien_web, http://fr.dbpedia.org/resource/Modèle:Infobox_Musée . La plupart du temps, ce sont les infobox qui nous intéressent : on va éditer le mapping des Infobox Musée.


Chercher une classe

  • Le plus rapide est de parcourir la hiérarchie des classes : http://mappings.dbpedia.org/server/ontology/classes/ .
  • Pour mapper un modèle, comparer à ce qui est fait pour les autres langues :
    • il y a parfois des liens interlangues dans la page de définition du modèle (dont le lien est donné sur la page du mapping). Voir s'il existe des mappings pour ces modèles correspondants dans d'autres langues.
    • prendre quelques ressources échantillon et chercher leur type sur les endpoints d'autres chapitres.


Chercher une propriété

C'est le plus difficile.

  • La liste des propriétés est accessible à partir du menu à gauche du wiki de mappings : http://mappings.dbpedia.org/index.php?title=Special:AllPages&namespace=202 . C'est suffisant pour chercher des propriétés suivant les noms possibles (souvent les noms utilisés dans les infobox de Wikipedia en).
  • Comparer à ce qui est fait dans d'autres langues. Si vous connaissez le type associé à l'infobox à mapper, par exemple http://dbpedia.org/ontology/Museum, la requête suivante permet d'obtenir les propriétés les plus fréquentes : 
select distinct ?p (count (distinct ?s) as ?nb)
where {
 ?s rdf:type <http://dbpedia.org/ontology/Museum> .
 ?s ?p ?v .
 filter(strstarts(str(?p),"http://dbpedia.org/ontology"))
}
group by ?p order by desc(?nb)

Cette requête peut être un peu trop lourde pour des modèles fréquemment utilisés, essayer de retirer la ligne avec "filter". Sinon, ne prenez qu'un échantillon : 

select distinct ?p (count (distinct ?s) as ?nb)
where {
 {select distinct ?s 
  where {?s rdf:type <http://dbpedia.org/ontology/Museum> .} limit 10000
 }
 ?s ?p ?v .
 filter(strstarts(str(?p),"http://dbpedia.org/ontology"))
}
group by ?p order by desc(?nb)
  • Autre aide : cliquer sur le nom d'une classe dans la hiérarchie de classes, la page contient un tableau avec l'ensemble des propriétés déjà mappées à l'une des instances de cette classe.


Liens utiles

Pour l'édition de l'ontologie :

Pour l'édition de mappings :

Récupérée de « http://wimmics.inria.fr/projects/semanticpedia/doc/index.php/Tutoriel_%C3%A9dition_de_mappings »