Les wiki sont de bons moyens d’amener les membres d’une communauté à contribuer collectivement à une base de connaissance partagée. C’est sur ce principe que repose Wikipedia, mais la même idée peut s’appliquer à une entreprise, une association ou une administration.

Un wiki, c’est l’anarchie, et c’est son point fort. L’approche « contribuer d’abord, structurer (un peu) ensuite » assure que la barrière d’entrée pour un contributeur est très faible, qu’il n’est pas obligé de respecter une quelconque structure, et peut même s’approprier ou modifier les structures existantes (en modifiant l’organisation d’un article ou en modifiant des catégories dans le wiki). Cela assure la contribution du plus grand nombre de personnes possibles.

Un wiki, c’est l’anarchie, et c’est son point faible. C’est son point faible si l’exhaustivité ou la qualité des données sont un de ses objectifs, ou si l’on veut pouvoir réutiliser la connaissance contenue dans le wiki dans d’autres applications informatiques. Qualité, exhaustivité, structuration des données pour la machine peuvent difficilement être atteintes par le mode d’organisation classique du wiki [1. Un exemple sur wikipedia/dbpedia ? cette requête SPARQL sur DBPedia francophone ramène toutes les sociétés avec leur slogan. 1/ qualité : certains slogans contiennent des chiffres 2/ exhaustivité : le slogan n’est parfois pas renseigné 3/ structuration : cette requête est possible sur DBpedia qui a structuré les données, mais pas sur wikipedia.]

Les technologies du web sémantique sont un bon moyen pour structurer les informations et les partager sur le web. En miroir des wiki, on peut dire que cette structuration est à la fois leur point faible et leur point fort : point fort car c’est cette structuration des données qui les rend partageables et réutilisables par des machines (mais certains en doutent), point faible car arriver à ce niveau de structuration peut augmenter significativement la barrière d’entrée pour publier et partager des données, en particulier dans des projets de capitalisation de connaissances. Par ailleurs des solutions simples, paramétrables et gratuites de formulaires de saisie pour des données RDF ne courent pas les rues.

Vous me voyez venir. Les wikis sémantiques sont la solution de synthèse du meilleur des deux mondes : le wiki pour son côté « faible barrière d’entrée à la contribution » et la sémantique pour son côté « structuration et partage des données » [2. D’autres dans la sphère francophone l’avaient mentionné bien avant, ici et là.].

Semantic Media Wiki = Media Wiki + Structuration

Semantic Media Wiki (SMW) est une extension du logiciel de wiki Media Wiki, celui qui est utilisé par Wikipedia. Cette extension propose de pouvoir gérer des données structurées dans le wiki, et de publier de ces données dans les formats du web sémantique, dans une base RDF.

Je résume les fonctionnalités indiquées dans la page d’introduction de SMW :

• générer automatiquement des listes d’objets dans le wiki, plutôt que de les saisir à la main
• présenter les données visuellement dans des graphes, des cartes, des calendriers
• améliorer la structure du wiki en évitant les catégories ad-hoc du type « films des années 50″
• rechercher des informations de façon structurée (et plus uniquement plein-texte)
• mettre à disposition les données du wiki pour d’autres applications et intégrer les données d’autres applications dans le wiki via SPARQL

Voilà ce qu’il ressort de mes premières impression après avoir testé SMW :

1. L’installation de Media Wiki est facile (package « mediawiki » sur Debian), et de Semantic Media Wiki assez simple avec Semantic Bundle, un ensemble d’extensions regroupées dans un même paquet;
2. Le paramétrage est un peu alambiqué mais est bien documenté; il faut notamment suivre les pages qui expliquent comment importer un vocabulaire existant (type FOAF, DC, ORG ou autre), comment paramétrer les propriétés et les classes, et comment paramétrer un formulaire; une fois le paramétrage bien compris, on a à notre dispostion une vraie solution de création de formulaires de saisie pour des données RDF.
3. La synchronisation avec un triplestore Sesame fonctionne bien, et on arrive à récupérer les données structurées du wiki en RDF, et à les interroger en SPARQL.

Paramétrer Semantic Media Wiki pour saisir des données RDF

D’abord, synchroniser SMW avec Sesame

La doc est ici.

1. Installez Sesame en suivant cette procédure
2. Utilisez les valeurs suivantes dans le fichier de config (attention de bien mettre « /statements » à la fin de l’URL de service d’update)

$smwgDefaultStore = 'SMWSparqlStore';
# location of query service
$smwgSparqlQueryEndpoint = 'http://localhost:8080/openrdf-sesame/repositories/nomDuRepository';
# location of update service
$smwgSparqlUpdateEndpoint = 'http://localhost:8080/openrdf-sesame/repositories/nomDuRepository/statements';
# location of SPARQL over HTTP service, set it to ''; in case of problems
$smwgSparqlDataEndpoint = '';
# optional name of default graph
$smwgSparqlDefaultGraph = 'http://example.org/mydefaultgraphname';

Ensuite, si vous voulez, paramétrer SMW pour utiliser un vocabulaire externe

La doc est ici.

1. Assurez-vous d’être connecté en tant qu’admin du wiki
2. Créez une page MediaWiki:smw_import_PREFIXE_DU_VOCABULAIRE, par exemple MediaWiki:smw_import_org pour importer l’ontologie des organisations
3. Déclarez dans cette page les types et les propriétés du vocabulaire que vous voulez réutilisez, de cette façon :

   http://www.w3.org/ns/org#|[http://www.w3.org/TR/vocab-org/ The Organization Ontology]
    Role|Category
    Post|Category
    hasMember|Type:Page
    memberOf|Type:Page
    holds|Type:Page

4. Déclarez des propriétés et des catégories dans le wiki;
5. Déclarez la correspondances de ces propriétés et ces catégories avec les éléments du vocabulaire externe, en utilisant les marqueurs

[[imported from::org:Organization]] (pour une catégorie)
[[imported from::org:hasMember]] (pour une propriété)

Puis, paramétrer des formulaires de saisie

La doc est ici et là.

Je ne suis pas certain de comprendre tout l’enchainement du paramétrage, notamment les différences entre une « catégorie », un « template » ou « modèle », et le « formulaire ». Mais l’exemple de la doc fonctionne bien et peut ensuite être adaptée facilement avec la doc de paramétrage du formulaire sous les yeux. Pour paramétrer un formulaire qui a du sens pour des données structurées, on va surtout s’intéresser aux options suivantes :

• values from category= qui permet de restreindre la saisie d’un champ à une catégorie, c’est-à-dire en termes RDF à une classe – c’est l’équivalent d’un paramétrage de range RDFS;
• existing values only si vous ne voulez pas qu’un utilisateur qui remplisse le formulaire puisse choisir une valeur qui n’existe pas;

On va ensuite vouloir bloquer l’édition classique d’une page, pour ne permettre l’édition qu’à travers le formulaire. Pour cela il faut changer 2 paramètres dans SMW comme décrit dans la doc ici.

Finalement…

Tout projet d’outil de saisie va de pair avec une reprise de données, il faudrait étudier ce que les fonctions d’import/export de données de Media Wiki permettent, en tous cas l’utilisation de cette brique comme outil de contribution collaborative à une base de connaissances structurée est tentante !

Cet article Le wiki sémantique : solution de capitalisation des connaissances (structurées) est apparu en premier sur Sparna Blog.

Voilà maintenant comment effectuer des query SPARQL SELECT et CONSTRUCT sur un Repository, et traiter les résultats. Les deux types de query utilisent des objets différents : TupleQuery et TupleQueryResult pour les SELECT, GraphQuery et GraphQueryResult pour les CONSTRUCT. Les commentaires dans le code ci-dessous parlent d’eux-même, et n’hésitez-pas à vous reporter à la documentation des API Sesame pour d’autres exemples.

[java] // création du Repository en mémoire.
Repository repository = new SailRepository(new MemoryStore());
// initialisation du Repository : cet appel est obligatoire une fois et une seule
repository.initialize();

// on ouvre une connection au repository
// comme en JDBC, c’est à travers cette connexion que sont envoyées toute les querys
RepositoryConnection connection = repository.getConnection();

// I. exemple de Query SELECT

// on initialise la query.
TupleQuery selectQuery = connection.prepareTupleQuery(
QueryLanguage.SPARQL,
"SELECT ?x ?foafName WHERE { ?x <http://xmlns.com/foaf/0.1/name> ?foafName }"
);

// on l’execute
TupleQueryResult selectQueryResult = selectQuery.evaluate();

// on itère sur les résultats
while(selectQueryResult.hasNext()) {
// chaque ligne du résultat est un BindingSet
BindingSet aBinding = selectQueryResult.next();

// on print les valeurs de cette ligne
System.out.println("Personne "+aBinding.getValue("x")+" a pour nom "+aBinding.getValue("foafName"));

// si on ne connait pas les noms de variables de la query, on peut les récupérer dynamiquement
for (String aBindingName : selectQueryResult.getBindingNames()) {
System.out.println("La valeur de "+aBindingName+" est "+aBinding.getValue(aBindingName));
}
}

// II. Exemple de Query CONSTRUCT

// on initialise la query
GraphQuery constructQuery = connection.prepareGraphQuery(
QueryLanguage.SPARQL,
"PREFIX foaf: <http://xmlns.com/foaf/0.1/> " +
"PREFIX vcard: <http://www.w3.org/2006/vcard/ns#>" +
"CONSTRUCT {?x vcard:n _:n . _:n vcard:given-name ?name .} WHERE { ?x foaf:name ?name }"
);

// on l’execute
GraphQueryResult constructQueryResult = constructQuery.evaluate();

// on itère sur les résultats, qui sont des Statement RDF, pas des binding
while(constructQueryResult.hasNext()) {
Statement anRDFStatement = constructQueryResult.next();
// ici on se contente d’afficher le Statement
// typiquement on devrait en faire quelque chose : écrire dans un fichier, ou
// l’insérer dans un autre Repository, etc.
System.out.println(anRDFStatement);
}

// quand on n’a plus besoin de la connexion, on la ferme
connection.close();[/java]

Cet article Tutoriel : exemple de query SPARQL avec l’API Sesame est apparu en premier sur Sparna Blog.

Jars nécessaires

Pour utiliser l’API Sesame de manipulation de RDF dans votre programme Java, récupérer les jars suivants :

• Depuis openrdf.org, suivez « Download > Sesame 2.x releases > here > [numéro de version de Sesame] » et téléchargez le fichier openrdf-sesame-x.y.z-onejar.jar. Attention de bien prendre le « onejar », pas le sdk ;
• Téléchargez SLF4J, dézippez-le, et extrayez slf4j-api-a.b.c.jar et slf4j-jdk14-a.b.c.jar ;
• Ajoutez à votre classpath openrdf-sesame-x.y.z-onejar.jar, slf4j-api-a.b.c.jar et slf4j-jdk14-a.b.c.jar ;

Optionnellement, seulement si vous voulez vous connecter à un serveur Sesame distant, ou un endpoint SPARQL (en utilisant la classe HTTPRepository), ajoutez les étapes suivantes :

• Téléchargez httpclient, en prenant le fichier commons-httpclient-3.0.zip. (Attention de ne pas confondre avec httpcomponents-client), et dézippez commons-httpclient-3.0.jar ;
• Téléchargez commons-logging et dézippez commons-logging-1.1.1.jar
• Téléchargez commons-codec et dézippez commons-codec-1.6.jar ;
• ajoutez à votre classpath commons-httpclient-3.0.jar, commons-logging-1.1.1.jar et commons-codec-1.6.jar ;

Démarrage rapide

L’exemple de code Java ci-dessous illustre l’initialisation d’un Repository, le chargement de données RDF, l’écriture de RDF dans un fichier, et l’interrogation d’un serveur Sesame distant ou d’un endpoint SPARQL public. Les commentaires dans le code parlent d’eux-mêmes.

// I : création du Repository
// création du Repository en mémoire.
Repository repository = new SailRepository(new MemoryStore());
// initialisation du Repository : cet appel est obligatoire une fois et une seule
repository.initialize();

// II : chargement de fichier RDF
// le fichier RDF contenant les données à charger
File fileToAdd = new File("/fichier/à/charger.rdf");
// charger les données dans le Repository
repository.getConnection().add(
 // référence au fichier à charger
 fileToAdd,
 // namespace par défaut à utiliser pour les URIs relatives contenues dans le RDF
 RDF.NAMESPACE,
 // format du fichier RDF à charger (RDF/XML, N3, TRIG, etc.)
 // le format est déterminé dynamiquement à partir de l'extension du fichier
 // (.rdf, .n3, .trig, etc.)
 RDFFormat.forFileName(fileToAdd.getName())
);

// III : écriture de fichier RDF
// on utilise RDFXMLWriter qui génère du RDF/XML
repository.getConnection().export(new RDFXMLWriter(new FileOutputStream("/fichier.rdf")));
// on peut remplacer par N3Writer pour sortir du N3
// dans ce cas, bien mettre l'extension du fichier à .n3
// repository.getConnection().export(new N3Writer(new FileOutputStream("/fichier.n3")));

// IV. connection à un serveur Sesame ou un endpoint SPARQL distant
// pour se connecter à un serveur Sesame : utiliser le constructeur avec 2 String
// en donnant l'adresse du serveur et le nom du repository
Repository sesameServer = new HTTPRepository("http://localhost:8080/openrdf-sesame","Test");
sesameServer.initialize();
// pour se connecter à un endpoint SPARQL public : utiliser le constructeur avec 1 String
// en donnant l'adresse du endpoint
Repository dbpedia = new HTTPRepository("http://dbpedia.org/sparql");
dbpedia.initialize();

Cet article Tutoriel : exemple avec l’API Sesame RDF est apparu en premier sur Sparna Blog.