Joseki : un server per interrogare risorse RDF attraverso un interfaccia Web

1,683 views

Published on

1 Comment
2 Likes
Statistics
Notes
No Downloads
Views
Total views
1,683
On SlideShare
0
From Embeds
0
Number of Embeds
10
Actions
Shares
0
Downloads
0
Comments
1
Likes
2
Embeds 0
No embeds

No notes for slide

Joseki : un server per interrogare risorse RDF attraverso un interfaccia Web

  1. 1. Università degli Studi di Roma La Sapienza Facoltà di Ingegneria Corso di Laurea in Ingegneria dellInformazione ind. Informatica Joseki : un server per interrogare risorse RDF attraverso uninterfaccia Web Tesi di Laurea di Daniele Palma 20 Luglio 2010Relatore:Prof. Ugo Vitti 2
  2. 2. Desidero innanzitutto ringraziare il Professor Ugo Vitti per le numerose orededicate alla mia tesi. Infine, ho desiderio di ringraziare con affetto i mieigenitori per il sostegno ed il grande aiuto che mi hanno dato per essermi statovicino ogni momento durante questi anni di lavoro. 3
  3. 3. Indice GeneraleIndice delle Figure 6Indice delle Tabelle 91 - Introduzione 102 - Semantic Web 12 2.1 Che Cosè?................................................................................................12 2.2 LArchitettura del Semantic Web.............................................................12 2.3 I principi del Semantic Web.....................................................................14 2.4 I Linguaggi del Web Semantico...............................................................143 - Resource Description Framework – RDF 17 3.1 Il Modello.................................................................................................18 3.2 La Sintassi................................................................................................20 3.3 La Grammatica Formale..........................................................................23 3.4 RDF Schema............................................................................................26 3.4.1. Classi e Proprietà.......................................................................27 3.4.2. I Vincoli....................................................................................294 - Joseki – Il server RDF di JENA 31 4.1 Joseki........................................................................................................31 4.2 Jena...........................................................................................................32 4.2.1. I tools di Jena............................................................................34 4.3 Introduzione a SPARQL..........................................................................35 4.3.1. Il Pattern Matching....................................................................36 4.3.2. Restrizione sui Valori................................................................39 4.3.3. Manipolazione del risultato.......................................................40 4.4 Un esempio di utilizzo.............................................................................405 - Procedure di installazione 43 5.1 Installazione di Joseki in locale...............................................................43 4
  4. 4. 5.1.1. Configurazione di Joseki..........................................................44 5.2 Installazione di Joseki in remoto..............................................................50 5.3 Installazione di Jena.................................................................................536 - Risorse RDF pubbliche 54 6.1 Freebase...................................................................................................54 6.1.1. Esempio di risorsa Freebase.....................................................55 6.2 Dbpedia....................................................................................................57 6.2.1. Esempio di risorsa Dbpedia......................................................58 6.3 MERLOT.................................................................................................60 6.3.1 Esempio di risorsa MERLOT...................................................607 - Interrogazione di risorse RDF 62 7.1 Query su un data-set locale......................................................................62 7.2 Query su data-set remoti..........................................................................668 - Conclusione e sviluppi futuri 73 Appendice A 74 Appendice B 79 Sitografia 82 5
  5. 5. Indice delle FigureCapitolo 2:Fig 2.1 : Architettura del Semantic WebFig 2.2 : file XMLCapitolo 3:Fig 3.1: Grafo corrispondente alla frase dell ES 3.1Fig 3.2: Grafo corrispondente alla frase dell ES 3.2Fig 3.3 : Rappresentazione in RDF del ES 3.3Fig 3.4 : Rappresentazione prima forma abbreviataFig 3.5 : Forma normale dell ES 3.5Fig 3.6 : Forma abbreviata dell ES 3.5Fig 3.7 : Forma normale dell ES 3.6Fig 3.8 : Forma abbreviata dell ES 3.6Fig 3.9 :Equivalenza scrittura tra RDF e RDF schemaFig 3.10 : RDF schema dell ES 3.8Fig 3.11 : RDF schema del ES 3.8Capitolo 4 :Fig 4.1: JosekiFig 4.2: Stack di JosekiFig 4.3 : Rappresentazione del modello dell ES 4.1Fig 4.4 : Creazione del modello e delle risorse dell ES 4.1Fig 4.5 : Richiesta degli Statements del modelloFig 4.6 : Richiesta del s p o di uno stamentFig 4.7 : Scrittura del contenuto del modelloFig 4.8 : Lettura di un modelloFig 4.9 : Rappresentazione di alcune tripleFig 4.10 : pattern-matchingFig 4.11 : Semplice query 6
  6. 6. Fig 4.12 : uso del comando OPTIONALFig 4.13 : Uso di UNIONFig 4.14 : Query con restrizione su un valoreFig 4.15 : Operatore DistinctFig 4.16 : Altri operatori per la manipolazioneFig 4.17 : Query per un primo utilizzo di JosekiFig 4.18 : Frammento del file books.n3Capitolo 5 :Fig 5.1 : Uso comando unzipFig 5.2 : Uso comando chmodFig 5.3 : Settaggio variabile dambienteFig 5.4 : Avvio di josekiFig 5.5 : Dichiarazione dei prefissi della configurazione di JosekiFig 5.6 : Sezione del servizio di baseFig 5.7 : Selezione del data-setFig 5.8 : Data-set di un modello da fileFig 5.9 : Data-set costruito su più graficiFig 5.10 : Dichiarazione di più modelliFig 5.11 : Accesso ad un modello su DatabaseFig 5.12 : Dichiarazione di un processore standardFig 5.13 : Dichiarazione di un processore con data-set fissoFig 5.14 : Uso comando scpFig 5.15 : Uso comando sshFig 5.16 : Url di riferimento del serverFig 5.17 :Uso del comando nohupFig 5.18 : Modifica del file rc.localFig 5.19 : Visone del file rc.localFig 5.20 : De-compattazione di JenaFig 5.21 : Set variabile dambiente di JenaFig 5.22 : Aggiunta permessi di Jena 7
  7. 7. Capitolo 6 :Fig 6.1 : Esempio di Argomentazioni FreebaseFig 6.2 : Raggruppamento dei topicFig 6.3 : Visualizzazione delle risorseFig 6.4 : Scelta del formatoFig 6.5 : Server offerto da DbpediaFig 6.6 : Rappresentazione della risorsa Semantic WebFig 6.7 : Formati di conversione della paginaFig 6.8 : Categorie delle risorseFig 6.9 : Visualizzazione delle risorseCapitolo 7 :Fig 7.1 :Query per lestrazione delle proprietà del data-setFig 7.2 : Risultato della query della Fig 7.1Fig 7.3 : Risorsa e titolo delle ricercheFig 7.4 : Risultato della query in Fig 7.3Fig 7.5 : Prelevo , titolo , data di sviluppo e sito del progettoFig 7.6 : Risultato query della Fig 7.5Fig 7.7 : Estrazione ID, nome , Livello e dataFig 7.8 : Risultato query 7.7Fig 7.9 : Estrazione nome e data di nozze delle principesse europeeFig 7.10 : Risultato query in Fig 7.9Fig 7.11 : Query sulla tavola periodica degli elementiFig 7.12 : Risultato della query mostrata nella Fig 7.12Fig 7.13 : nome e simbolo e peso degli elementi con peso > delluranioFig 7.14 : risultato query mostrata in Fig 7.13Fig 7.15 : Interrogazione di 2 data-setFig 7.16 : Risultato delle query in Fig 7.15Fig 7.17 : Estrazione proprietà DCFig 7.18 : Proprietà DCFig 7.19 : Estrazione proprietà VCARD 8
  8. 8. Fig 7.20 : Proprietà standard VCARDIndice delle TabelleCapitolo 3Tab 3.1 : elementi ES 3.1Capitolo 4Tab 4.1 : Risultato della query in Fig 4.11Tab 4.2 : Risultato query della Fig 4.12Tab 4.3: Operatori SPARQLTab 4.4: Risultato Query 9
  9. 9. Capitolo 1 Introduzione CAPITOLO 1 IntroduzioneLo scopo di questa tesi, e manipolare alcune risorse pubbliche con un processoreSPARQL installando un server per linterrogazione di risorse RDF (ResourceDescription Framework).Abbiamo scelto di lavorare con il server Joseki, che mette a disposizione unampiadocumentazione, e supporta il linguaggio di interrogazione SPARQL, standardizzato dalW3C [1], in un ambiente di lavoro web.Il Web Semantico si occupa di 2 cose: formati comuni per lintegrazione e lacombinazione di dati recuperati da diverse fonti e linguaggi per indicare come i datisiano correlati ad oggetti del mondo reale. Ciò significa che i dati presenti in undatabase, su una macchina possono portare ad un insieme infinito di database cheriguardano tutti lo stesso oggetto.Tutti gli standard, i linguaggi e il modo di esprimere i concetti, sono racchiusi nellastruttura a gradini del Semantic Web. Questa struttura, insieme a tutti i livelli che nefanno parte, sarà descritta allinterno del capitolo 2.Il Resource Description Framework [14], molto simile allXML, è parte integrante dellastruttura del Semantic Web e ne costituisce uno dei mattoni fondamentali. LRDFdescrive e definisce le proprietà di moltissime risorse presenti in rete: nel capitolo 3 sene descrive il modello e la sintassi, oltre allRDF Schema [18], che riesce ad imprimereed a restringere il dominio di applicazione di una proprietà.Nel capitolo 4, viene descritto dettagliatamente il funzionamento di Joseki [4] e di comepermetta, mediante luso del linguaggio di interrogazione SPARQL, di estrarreinformazione dalle risorse. Verrà spiegata la sintassi SPARQL ed inoltre si farà uso dellelibrerie di Jena, che permettono di manipolare un documento in RDF [22].Joseki utilizza indirettamente il server Jetty per lesecuzione e si mette in ascolto sullaporta 2020 (una volta attivato , andare su http://localhost:2020/sparql ). 10
  10. 10. Capitolo 1 IntroduzioneNel capitolo 5 e presentata linstallazione del software, comprensiva di tutti i comandiutilizzati; verrà spiegato come installare il server Joseki localmente al sistema o su unamacchina remota. Inoltre, viene mostrata la configurazione dei servizi che Joseki cioffre e si passerà poi allinstallazione ed alla verifica di alcuni tools offerti da Jena per lamanipolazione di risorse RDF direttamente dal terminale.Si provvederà nel capitolo 6 ad illustrare alcuni repository pubblici ricercati sul web,come DBpedia o Freebase, che manipolano grandi quantità di risorse, mettendole adisposizione del pubblico. Si evidenzia come questi repository sfruttino direttamentetutti i concetti spiegati nella tesi per la manipolazione delle risorse.Infine, nel capitolo 7 sono riportate le query effettuate durante la tesi. Tali query sonostate catalogate in due gruppi: quelle eseguite su data-set locali per il server Joseki, equelle eseguite su data-set remoti per lo stesso server Joseki. Per accedere al servizioJoseki via Web, si deve accedere allindirizzo http://151.100.106.21:2020, oppure peraccedere ad un insieme di risorse correlate a www.retilatina.eu/palma/index.html. 11
  11. 11. Capitolo 2 Semantic Web CAPITOLO 2 Semantic Web2.1. Che cosè ?Con lespressione "Semantic Web" si intende un insieme di tecnologie che hannolobiettivo di rendere le informazioni comprensibili ed elaborabili da parte diprogrammi: in pratica, lo scopo sta nel permettere a "macchine" (intese comeinfrastrutture e applicazioni software) di creare nuova conoscenza traendo delleconclusioni a partire dalla base di conoscenza iniziale.Attraverso linterpretazione del contenuto dei documenti che il Web semantico offre,saranno possibili ricerche molto più evolute delle attuali, basate sulla presenza neldocumento di parole-chiave ed altre operazioni specialistiche, come la costruzione direti di relazioni e connessioni tra documenti, secondo logiche più elaborate del semplicecollegamento ipertestuale.2.2. L Architettura del Semantic WebPer quanto riguarda standard e tecnologie, il Semantic Web deve essere inteso come unastruttura "a gradini": uno "stack" tecnologico, formato da più componenti, in cui ognilivello è la base per gli standard definiti ai livelli superiori ( Fig 2.1 ). Fig 2.1 : Architettura del Semantic Web 12
  12. 12. Capitolo 2 Semantic Web • Alla base di questa architettura cè lo standard URI (Uniform Resource Identifiers) [9], che viene usato per la definizione univoca di risorse online : documenti, file e indirizzi internet. Al contrario, lo standard UNICODE è un sistema di codifica che associa una combinazione di bit ad ogni simbolo, carattere o segno, in modo indipendente dal programma, dalla piattaforma o dalla lingua utilizzata. • Al livello superiore si trova il metalinguaggio XML (eXtensible Markup Language) [7], che è di fondamentale importanza, unitamente ai NS (NameSpace) [8] e a XML Schema. XML è un linguaggio che porta con se alcune informazioni sulla semantica degli oggetti, mentre i NS, che vengono definiti tramite degli URI, garantiscono l interoperabilità tra i dizionari di meta- dati. • RDF (Resource Description Framework) [14] e RDF Schema [18] costituiscono il linguaggio per descrivere le risorse online e i loro tipi, per l interoperabilità semantica di dati e informazioni e consentono agli agenti intelligenti di effettuare inferenze logiche. • Al livello superiore si trova il Vocabolario delle Ontologie .Le Ontologie sono sistemi di meta-dati, riferiti a specifici vocabolari, che permettono di descrivere le relazioni tra le risorse Web, consentendo agli agenti intelligenti di interpretare e comprendere i dati.Non di minore importanza, ma ancora in fase di sviluppo, troveremo i livelli di : • Logica : prevede limplementazione di un linguaggio che consente di prevedere dei risultati. 13
  13. 13. Capitolo 2 Semantic Web • Firma Digitale : è il sistema di autenticazione dei documenti digitali, la firma digitale attesta che una specifica persona ha scritto quel determinato documento. • Fiducia : il Web Semantico può essere osservato come un enorme database in cui lutente può accedere, ma è a sua discrezione comprendere quali siano i dati affidabili da quelli inaffidabili.2.3. I principi del Semantic WebIl Semantic Web si basa su sei principi fondamentali che sottendono allarchitettura delWeb Semantico e ne descrivono le caratteristiche essenziali : 1. Ogni cosa può essere identificata attraverso una URI . 2. Le risorse e i Link possono avere un “tipo”. 3. Linformazione parziale è tollerata. 4. Non cè bisogno di una verità assoluta. 5. Levoluzione è tollerata. 6. Design minimalista2.4. I Linguaggi del Semantic WebIl Web, è un enorme contenitore di informazioni, si è sviluppato mediante lausilio dellinguaggio HTML, questo si preoccupa soprattutto di curare la formattazione grafica deidocumenti nel web e non fornisce nessun supporto per strutturare e descrivere questeinformazioni dal punto di vista semantico.Il linguaggio HTML permette di condividere informazioni in modo semplice, lunicopresupposto è che queste informazioni siano costituite solamente da testo e immaginicon collegamenti ipertestuali.Attualmente le informazioni sul web sono diventate molto più complesse: video,database, musica e molto altro. E necessario quindi, un linguaggio che sia in grado di:descrivere tipologie di informazioni differenti e specifiche, definire relazioni complessedi collegamenti fra documenti e trasmettere informazioni in diversi formati. 14
  14. 14. Capitolo 2 Semantic WebNasce, a tal proposito, XML: un metalinguaggio che permette di definire e crearesintatticamente dei linguaggi personalizzati di markup. Si tratta di un linguaggio apertoe basato su testo, che in termini pratici ci consente di esplicitare la struttura di undocumento dal punto di vista sintattico, attraverso marcatori allinterno del testo.Un documento XML è organizzato secondo una struttura logica ad albero e nonpresenta un insieme predefinito di elementi, ma ci consente di crearne di nuovi in basealle nostre esigenze.Esiste un elemento radice che deve essere sempre presente, ogni elemento può avere deifigli che, a loro volta, possono essere specificati da particolari attributi.In Fig 2.2 viene mostrato un tipico documento .xml : <?xml version="1.0" encoding="UTF-8"?> <utenti> <utente> <nome> Daniele </nome> <cognome> Palma </cognome> <indirizzo> Sezze </indirizzo> </utente> <utente> <nome> Marco</nome> <cognome> Rossi </cognome> <indirizzo> Roma </indirizzo> </utente> </utenti> Fig 2.2 : file XMLEsistono inoltre, diverse tecnologie di supporto allXML, come le DTD ( DocumentType Definition ), documenti attraverso cui si specificano le caratteristiche strutturali diun documento XML, grazie allausilio di una serie di "regole grammaticali". Inparticolare, si definisce: linsieme degli elementi del documento XML, le relazionigerarchiche tra gli elementi, lordine di apparizione nel documento XML e qualielementi e quali attributi sono opzionali o meno.Una seconda tecnologia di supporto è XML Schema che, come la DTD, serve adefinire la struttura di un documento XML. Il W3C consiglia di adottarlo al posto della 15
  15. 15. Capitolo 2 Semantic WebDTD stessa, essendo una tecnica più nuova ed avanzata. La sua sigla è XSD, ( XMLSchema Definition ).In conclusione, per poter essere correttamente interpretato da un browser, un documentoXML deve essere ben formato, deve cioè possedere le seguenti caratteristiche: • Un prologo, che è la prima istruzione che appare scritta nel documento. Nel nostro caso: <?xml version="1.0" encoding="UTF-8"?>. • Un unico elemento radice (ovvero il nodo principale, chiamato root element) che contiene tutti gli altri nodi del documento. Nell ES 2.1 : <utenti>. • Allinterno del documento tutti i tag devono essere bilanciati.Se il documento XML non contiene errori si dice Well Formed (scritto correttamente).Se il documento è well formed e in più rispetta i requisiti strutturali definiti nel file DTDo XML Schema associato, viene chiamato Valid (valido).Un altro linguaggio di maggior importanza, usato per descrivere le risorse sul Web, èRDF che analizzeremo e presenteremo nel CAP 3. 16
  16. 16. Capitolo 3 RDF-Resource Description Framework CAPITOLO 3 Resource Description Framework - RDFLa soluzione proposta dal W3C [14] per elaborare i meta-dati, usati nella descrizionedelle risorse presenti nel Web, consiste nell’utilizzo del Resource DescriptionFramework ( da ora in avanti RDF ).Fra gli obiettivi che il W3C si è proposto di raggiungere con la definizione di RDFpossiamo considerare: interoperabilità fra applicazioni e sviluppo diapplicazioni automatizzate per il trattamento delle risorse del Web in modo semplice.RDF potrà essere utilizzato in svariate aree applicative, come ad esempio, lacatalogazione di risorse facenti parte di un sito Web o di una libreria digitale,descrivendone il contenuto e le relazioni esistenti; rendere più efficientile indicizzazioni effettuate dai motori di ricerca; aiutare la condivisione e lo scambio diinformazioni da parte di agenti software intelligenti.In questo paragrafo, verrà introdotto il modello usato per rappresentare RDF e lasintassi usata per codificare e trasportare i meta-dati così espressi.Tale codifica verrà effettuata in modo da massimizzare l’interoperabilità el’indipendenza dai server che forniranno i meta-dati e dai client che usufruiranno di taliservizi. La sintassi presentata farà uso di XML .Inoltre, bisogna sottolineare come l’obiettivo di RDF sia quello di definire unmeccanismo per descrivere risorse che non fa assunzioni su un particolare dominioapplicativo, né definisce a priori la semantica per uno specifico dominio.La definizione di tale meccanismo sarà quindi indipendente dal campo di applicazionee permetterà la descrizione di informazioni relative ad ogni dominio. 17
  17. 17. Capitolo 3 RDF-Resource Description Framework3.1. Il modelloRDF si basa su un modello per rappresentare proprietà e valori ad esseassociate. Le proprietà possono essere pensate come attributi di risorse ecorrispondono ad una coppia attributo-valore.Inoltre, mediante le proprietà, si possono rappresentare le relazioni fra le risorse equindi il modello di RDF può essere visto come uno schema entità-relazione. Per usarela terminologia della programmazione object-oriented, le risorse possono essere vistecome oggetti e le proprietà come variabili d’istanza.Il modello è composto da tre tipologie di oggetti:Risorse : tutto ciò che viene descritto da RDF è detto risorsa. Una risorsa può essere una pagina Web o una parte di essa ( identificata da un elemento HTML o XML) o un intero sito Web. L’identificatore di ogni risorsa è il proprio URI e pertanto una risorsa può anche essere un oggetto non direttamente accessibile dal Web.Proprietà: una proprietà è una caratteristica, un attributo o una relazione utilizzata per descrivere una risorsa. Ogni proprietà ha un significato specifico, definisce i valori che può assumere e i tipi di risorse a cui può essere associata.Asserzioni: una risorsa con una proprietà ed un valore ad essa associato è un’asserzione. Gli oggetti che prendono parte a questa associazione sono detti, rispettivamente: il soggetto, il predicato e l’oggetto. L’oggetto può essere una risorsa o un letterale. 18
  18. 18. Capitolo 3 RDF-Resource Description FrameworkES 3.1 La frase: “Mario Rossi è l’autore della risorsa identificata dall’URL ̃ http://www.myhost.org/ mrossi” è composta dagli elementi elencati nella tabella seguente. Soggetto (risorsa) ̃ http://www.myhost.org/ mrossi Predicato (proprietà) Autore Oggetto (letterale) “Mario Rossi” Tabella 3.1 : elementi ES 3.1Questa frase può anche essere rappresentata mediante un grafo in cui i nodi (gli ovali)rappresentano le risorse e gli archi rappresentano le proprietà. I nodi che rappresentanoinvece dei letterali sono disegnati come rettangoli. Autore ̃ http://www.myhost.org/ mrossi Mario Rossi Fig 3.1: Grafo corrispondente alla frase dell ES 3.1ES 3.2 L’oggetto della frase: “La persona di nome Mario Rossi con email mrossi@myhost.org è autore della pagina identificata dall’URL ̃ http://www.myhost.org/ mrossi” è questa volta non più un letterale, ma un’entità` strutturata, rappresentata da un’altra risorsa. 19
  19. 19. Capitolo 3 RDF-Resource Description Framework ̃ http://www.myhost.org/ mrossi Autore Nome E-mail Mario Rossi mrossi@myhost.org Fig 3.2: Grafo corrispondente alla frase dell ES 3.23.2 La SintassiIn questo paragrafo verranno presentati due tipi di sintassi per codificare un’istanza delmodello di RDF [16] :La sintassi di serializzazione: permette di esprimere il modello di RDF in maniera regolare.La sintassi abbreviata: estende la sintassi precedente, fornendo altri costrutti che permettono una scrittura più compatta del modello.Queste sintassi hanno comunque, lo stesso potere espressivo. Ogni proprietà assegnataad una risorsa viene elencata dentro un elemento rdf:Description. Questo elementopermette di identificare la risorsa mediante l’attributo rdf:about, contenente l’URI ditale risorsa. Se invece la risorsa non ha un URI, questo può essere fornito usandol’attributo rdf:ID; in questo modo viene creata una risorsa che fa da proxy per quellaoriginaria.Le proprietà così specificate, corrispondono ad archi diversi di un grafo relativo aldocumento RDF. Ad ogni proprietà deve inoltre essere assegnatouno schema. Questo può essere fatto aggiungendo ad ogni proprietà il namespace in cuiviene definito l’elemento che rappresenta la proprietà stessa. 20
  20. 20. Capitolo 3 RDF-Resource Description FrameworkSi può pensare ad uno schema come ad un dizionario, che definisce i termini cheverranno adottati e vi associa un particolare significato.ES 3.3 La frase dell’ES 3.1: “Mario Rossi è l’autore della risorsa ̃ definita dall’URI http://www.myhost.org/ mrossi” può essere rappresentata in RDF/XML come : <?xml version="1.0"?> <rdf:RDF xmlns: rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns: s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore>Mario Rossi</s:Autore> </rdf:Description> </rdf:RDF> Fig 3.3 : Rappresentazione in RDF del ES 3.3Nei casi in cui sia preferibile usare una forma più compatta, si utilizzala forma abbreviata. Ne esistono tre forme, utilizzabili solo in particolari condizioni: 1.Si può utilizzare, nel caso in cui, non vi siano proprietà ripetute più volte entro l’elemento rdf:Description e i valori di tali proprietà siano dei letterali. In questo caso le proprietà possono essere scritte come attributi dell’elemento rdf:Description. ES 3.4 Il documento scritto nell’ES 3.3 diventa: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi" s:Autore="Mario Rossi"/> </rdf:RDF> Fig 3.4 : Rappresentazione prima forma abbreviata 21
  21. 21. Capitolo 3 RDF-Resource Description Framework 2.Questa forma è applicabile quando l’oggetto di un’asserzione è un’altra risorsa, le cui proprietà sono definite nel documento stesso ed i cui valori sono dei letterali. In questo caso i predicati della risorsa referenziata diventano attributi del predicato che referenzia la risorsa stessa. ES 3.5 La frase: “La persona di codice 1375 si chiama Mario Rossi e ha email ̃ mrossi@myhost.org; la risorsa definita dall’URI http://www.myhost.org/ mrossi è stata creata da costui” può essere scritta come: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore rdf:resource="http://www.myhost.com/people/1375"/> </rdf:Description> <rdf:Description rdf:about="http://www.myhost.com/people/1375"> <s:Nome>Mario Rossi</s:Nome> <s:Email>mrossi@myhost.org</s:Email> </rdf:Description> </rdf:RDF> Fig 3.5 : Forma normale dell ES 3.5 Usando la seconda forma abbreviata, si ottiene: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore rdf:resource="http://www.myhost.com/people/1375" s:Nome="Mario Rossi" s:Email="mrossi@myhost.com"/> </rdf:Description> </rdf:RDF> Fig 3.6 : Forma abbreviata dell ES 3.5 3. Questa forma abbreviata si applica quando l’elemento rdf:Description contiene rdf:type. Questo elemento definisce il tipo della risorsa. In questo caso, il tipo viene usato direttamente come proprietà della risorsa. 22
  22. 22. Capitolo 3 RDF-Resource Description Framework ES 3.6 Se si volesse rappresentare il fatto che la risorsa http://www.myhost.com/people/1375” è un oggetto di tipo “Persona”, la frase dell’ES 3.5 diventa: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore> <rdf:Description rdf:about="http://www.myhost.com/people/1375"> <rdf:type rdf:resource="http://schema.org/Persona"/> <s:Nome>Mario Rossi</s:Nome> <s:Email>mrossi@myhost.org</s:Email> </rdf:Description> </s:Autore> </rdf:Description> </rdf:RDF> Fig 3.7 : Forma normale dell ES 3.6 Usando la terza forma abbreviata si ottiene: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://schema.org/"> <rdf:Description rdf:about="http://www.myhost.com/~mrossi"> <s:Autore> <s:Persona rdf:about="http://www.myhost.com/people/1375"> <s:Nome>Mario Rossi</s:Nome> <s:Email>mrossi@myhost.org</s:Email> </s:Persona> </s:Autore> </rdf:Description> </rdf:RDF> Fig 3.8 : Forma abbreviata dell ES 3.63.3 La Grammatica FormaleDi seguito, sono presentate e commentate le produzioni grammaticaliche definiscono il modello RDF [19]. E da notare, comunque, che la grammatica qui 23
  23. 23. Capitolo 3 RDF-Resource Description Frameworkdefinita è in parte differente da quanto era stato formalizzato nelle prime specifiche dalW3C . 1. RDF ::= "<rdf:RDF>" description* "</rdf:RDF>" description 2. description ::= "<rdf:Description" idAboutAttr? bagIdAttr?propAttr* "/>" | "<rdf:Description" idAboutAttr? BagIdAttr? propAttr* ">" propertyElt"</rdf:Description>" | typedNode 3. idAboutAttr ::= idAttr | aboutAttr 4. idAttr ::= "rdf:ID=/"" IDsymbol "/"" 5. aboutAttr ::= "rdf:about=/"" URI-reference "/"" 6. bagIdAttr ::= "rdf:bagID=/"" IDsymbol "/"" 7. propAttr ::= typeAttr | propName "=/"" string "/"" 8. typeAttr ::= "rdf:type=/"" URI-reference "/"" 9. propertyElt ::= "<" propName idAttr? ">" value"</" propName ">" | "<" propName idAttr? parseLiteral ">"literal "</" propName ">" | "<" propName idAttr? parseResource ">"propertyElt* "</"propName ">" | "<" propName idRefAttr? BagIdAttr? PropAttr* "/>" 24
  24. 24. Capitolo 3 RDF-Resource Description Framework 10. typedNode ::= "<" typeName idAboutAttr? BagIdAttr? propAttr* "/>" | "<" typeName idAboutAttr? bagIdAttr?propAttr* ">" propertyElt*"</" typeName ">" 11. propName ::= Qname 12. typeName ::= Qname 13. idRefAttr ::= idAttr | resourceAttr 14. value ::= description | string 15. resourceAttr ::= "rdf:resource=/"" URI-reference "/"" 16. Qname ::= NSprefix ":" name 17. URI-reference ::= string, interpreted per [BLFIM98] 18. IDsymbol ::= (any legal XML name symbol) 19. name ::= (any legal XML name symbol) 20. NSprefix ::= (any legal XML namespace prefix) 21. string ::= (any XML text, with "<", ">", and "" escaped) 22. parseLiteral ::= "rdf:parseType=/"Literal/"" 23. parseResource ::= "rdf:parseType=/"Resource/" 24. literal ::= (any well-formed XML)Ogni propertyElt e di un elemento rdf:Description corrisponde ad una tripla (p, r, v), incui (vedi produzione 9): • p è il risultato della concatenazione del namespace a cui appartiene e con il nome stesso di e; • r rappresenta : – una risorsa identificata dal valore dell’attributo rdf:about di rdf:Description (se presente); 25
  25. 25. Capitolo 3 RDF-Resource Description Framework – una nuova risorsa, il cui identificatore è dato dal valore dell’attributo rdf:ID, se presente, oppure una nuova risorsa senza identificatore. • v rappresenta : – la risorsa, il cui identificatore è dato dal valore dell’attributo rdf:resource di e (se presente); – un letterale, nel caso in cui sia presente l’attributo rdf:parseType con valore Literal o il contenuto di e sia del testo XML; – una risorsa, qualora sia presente l’attributo rdf:parseType con valore Resource; – la risorsa, il cui identificatore è ottenuto dal valore dell’attributo (anche implicito) rdf:about o rdf:ID dell’elemento rdf:Description contenuto in e.Quando in un elemento rdf:Description è specificato l’attributo rdf:about, l’asserzionesi riferisce alla risorsa identificata dal valore dell’attributo. Se invece, è presente rdf:IDo rdf:bagID, la tripla stessa rappresenta una risorsa. LURI della risorsa è dato dallaconcatenazione dell’URI del documento, allinterno del quale, è definita la tripla con ilvalore dell’attributo stesso.3.4 RDF SchemaFino ad ora, è stato presentato il modello di RDF come un mezzo per rappresentaremeta-dati e una sintassi RDF/XML come trasporto di tale modello. In questo modo, si èreso possibile associare delle coppie nome-valore delle risorse o URI. Ma spesso questonon basta.Ad esempio, nel caso in cui, si ha una proprietà che fa riferimento ad uno scrittore,sarebbe semanticamente scorretto associarla ad una macchina o a un’abitazione. Oppurese si ha una proprietà che rappresenta un compleanno, è importante vincolarne i valori adelle date (e non numeri generici o caratteri). Il modello di RDF non permette dieffettuare validazione di un valore o restrizione di un dominio di applicazione di unaproprietà. 26
  26. 26. Capitolo 3 RDF-Resource Description FrameworkQuesto compito è svolto, invece, da RDF Schema [18]. Però, a differenza di XMLSchema o di una DTD, RDF Schema non vincola la struttura del documento, bensìfornisce informazioni utili all’interpretazione del documento stesso. In seguito, ilnamespace di RDF Schema sarà indicato con rdfs; quello di RDF semplicemente conrdf.3.4.1 Classi e ProprietàIn questo paragrafo, si indicano le classi principali e le proprietà che fannoparte del vocabolario definito da RDF Schema. Le classi permettono di definire i tipibase di ogni risorsa che verrà descritta in RDF; le proprietà sono lo strumento utilizzatoper esprimere le relazioni fra esse.rdfs:Resource Tutto ciò che viene descritto in RDF è detto risorsa. Ogni risorsa è istanza della classe rdfs:Resource.rdfs:Literal Sottoclasse di rdfs:Resource, rappresenta un letterale, una stringa di testo.rdf:Property Rappresenta le proprietà, così come sono state definite nella sottoclasse di rdfs:Resource.rdfs:Class Corrisponde al concetto di tipo e di classe della programmazione object- oriented. Quando viene definita una nuova classe, la risorsa che la rappresenta deve avere la proprietà rdf:type impostata a rdfs:Class.rdf:type Indica che una risorsa è membro di una classe, è ciò istanza di una specifica classe. Il valore di rdf:type deve essere una risorsa che è istanza di rdfs:Class (o sua sottoclasse). In pratica permette di specificare il tipo di una risorsa.rdfs:subClassOf Specifica la relazione di ereditarietà fra classi. Questa proprietà può essere assegnata solo a istanze di rdfs:Class. Una classe può essere sottoclasse di una o più classi (ereditarietà multipla). 27
  27. 27. Capitolo 3 RDF-Resource Description Frameworkrdfs:subPropertyOf Istanza di rdf:Property, si utilizza per specificare che una proprietà è una specializzazione di un’altra. Ogni proprietà può essere la specializzazione di zero o più proprietà.rdfs:seeAlso Specifica una risorsa che fornisce ulteriori informazioni sul soggetto dell’asserzione. Ciò che rappresenta questa risorsa comunque, non può essere specificato ed è a carico dell’applicazione specificare la sua interpretazione.rdfs:isDefinedBy E sottoproprietà di rdfs:seeAlso e indica una risorsa che definisce il soggetto di un’asserzione. L’uso più comune di questa proprietà è di fornire un URI che identifichi lo schema in cui è stato definito il soggetto.rdfs:Container Rappresenta la classe base da cui sono derivati i contenitori di RDF.rdfs:ContainerMembershipPropriety E la classe da cui derivano i membri rdf: 1, rdf: 2, etc. dei contenitori.ES 3.7 In questo esempio le due scritture sono equivalenti : la prima non usa RDF schema; la seconda invece, lo adotta per la creazione di una classe chiamata nuovoTipo. <rdf:Description rdf:about="http://schema.org/nuovoTipo"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class" /> </rdf:Description> <rdfs:Class rdf:about="http://schema.org/nuovoTipo"/> Fig 3.9 :Equivalenza scrittura tra RDF e RDF schema 28
  28. 28. Capitolo 3 RDF-Resource Description FrameworkES 3.8 Definiamo ora la classe Persona, la sua sottoclasse Operaio e la classe Lavoratore, che è sottoclasse di Operaio. Infine istanziamo la classe Lavoratore. <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"> <rdfs:Class rdf:about="http://schema.org/Persona" /> <rdfs:Class rdf:ID="Operaio"> <rdfs:subClassOf rdf:resource="http://schema.org/Persona" /> </rdfs:Class> <rdfs:Class rdf:ID="Lavoratore"> <rdfs:subClassOf rdf:resource="#Operaio" /> </rdfs:Class> <rdf:Description rdf:about="http://lavoratori.org/mrossi"> <rdf:type rdf:resource="#Lavoratore"/> </rdf:Description> </rdf:RDF> Fig 3.10 : RDF schema dell ES 3.83.4.2 I VincoliLe specifiche di RDF Schema definiscono un vocabolario che permette di effettuaredelle asserzioni vincolando le proprietà e le risorse che costituiscono l’associazione.rdfs:ConstraintResource Sottoclasse di rdfs:Resource, le sue istanze rappresentano costrutti di RDF Schema utilizzati per esprimere vincoli. Lo scopo di questa classe è fornire un mezzo ai parser RDF per riconoscere i costrutti che rappresentano vincoli. Non è però possibile indicare al parser come utilizzare i vincoli così identificati.rdfs:ConstraintProperty Sottoclasse di rdf:Property e rdf:Constraint-Resource, le sue istanze sono proprietà usate per specificare dei vincoli. Sia rdfs:domain che rdfs:range sono sue istanze. 29
  29. 29. Capitolo 3 RDF-Resource Description Frameworkrdfs:range Usato come predicato di una risorsa r, indica le classi di cui devono essere membre le risorse a cui verrà applicata r.rdfs:domain Usato come predicato di una risorsa r, indica le classi valide che saranno soggetto di un’asserzione che ha come predicato r.ES 3.8 Riprendendo l’ES 3.7, definiamo delle proprietà,vincolandole ai tipi descritti in precedenza. Quando re-istanziamo un oggetto di tipo Lavoratore, possiamo comunque applicarvi i predicati definiti per le superclassi da cui discende. <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:s="http://schema.org/"> <rdf:Property rdf:about="http://schema.org/Nome"> <rdfs:domain rdf:resource="http://schema.org/Persona"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> <rdf:Property rdf:about="http://schema.org/DataNascita"> <rdfs:domain rdf:resource="http://schema.org/Persona"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> <rdf:Property rdf:ID="Membro"> <rdfs:domain rdf:resource="#Lavoratore"/> <rdfs:range rdf:resource="#Meccanico"/> </rdf:Property> <rdf:Class rdf:about="http://schema.org/Meccanico"/> <rdf:Description rdf:about="http://lavoratori.org/meccanici#labour"> <rdf:type rdf:resource="http://schema.org/Meccanico"/> </rdf:Description> <rdf:Description rdf:about="http://Lavoratori.org/mrossi"> <rdf:type rdf:resource="#Lavoratore"/> <s:Nome>Mario Rossi</s:Nome> <s:DataNascita>08 Ottobre, 1968</s:DataNascita> <epx:Membro rdf:resource="http://www.iLavoratori.com/meccanici#labour"/> </rdf:Description> </rdf:RDF> Fig 3.11 : RDF schema del ES 3.8 30
  30. 30. Capitolo 4 Joseki-Il server RDF di Jena CAPITOLO 4 Joseki – Il server RDF di JENAIn questo capitolo, si descriveranno i servizi offerti da Jena, in particolare il serverJoseki, che con lausilio del linguaggio SPARQL permette di interrogare le risorsedescritte in RDF. Si procederà poi, ad un semplice utilizzo di Joseki.4.1.JosekiJoseki è un HTTP / SOAP engine che permette linvio di query SPARQL via HTTP [4].Nella Fig 4.1 viene schematizzato il funzionamento di Joseki. Fig 4.1: JosekiPartendo da una risorsa descritta da un file RDF , Joseki riesce ad interrogarla mediantelinvio di query SPARQL . Nel file di configurazione iniziale di Joseki (.ttl) vengonodescritte tutte le risorse su cui far riferimento.Tutte le query vengono inviate via HTTP, attraverso un form presente sulla paginainiziale del server alla porta 2020. Inoltre, prima della fase di elaborazione della query,è possibile scegliere in che formato ricevere le informazioni richieste al server. Adesempio, possiamo scegliere di riceverle in formato XML, CSV ( Comma-SeparatedValues ), TSV ( Tabs-Separated Values ) o semplicemente in TXT. 31
  31. 31. Capitolo 4 Joseki-Il server RDF di JenaNella Fig 4.2 viene mostrato lo stack di Joseki e di come, mediante l ausilio di Jena,attraverso il protocollo HTTP, riesca ad interagire anche con risorse di tipo differente. Fig 4.2: Stack di Joseki4.2.JenaJena è un framework Java open source (sviluppato dal Semantic Web Research BristolLab della HP) [2] per lo sviluppo di applicazioni orientate al Web Semantico. Essofornisce le API per la creazione, interrogazione e gestione in modo programmatico diRDF.Inoltre Jena, oltre alla parte di programmazione, ci offre diversi tools per gestire ,interrogare , modificare , e convertire direttamente una risorsa.Possiamo ad esempio, convertire le nostre risorse in diversi formati : XML , RDF , N3 ;e interrogarle mediante il linguaggio SPARQL. 32
  32. 32. Capitolo 4 Joseki-Il server RDF di JenaES 4.1 Supponiamo di voler creare una risorsa RDF, rappresentata nella Fig 4.3 : Risorsa http://...../Marco_Rossi Proprietà VCard:FN Marco Rossi Attributo Fig 4.3 : Rappresentazione del modello dell ES 4.1Ogni arco di un modello RDF viene chiamato Statement, e può essere diviso in 3 parti :il soggetto , il predicato e loggetto. Ogni statement può anche essere chiamato tripla.Si crea un modello (classe Model) mediante il metodo factoryModelFactory.createDefaultModel() e si aggiungono le varie risorse e le proprietà. Inquesto caso, FN , utilizzando il dizionario VCARD (la definizione di VCARD si trovanel Appendice B ). // creo un model Model Esempio_4_1 = ModelFactory.createDefaultModel(); // creo le risorse aggiungendole in cascata Resource marcoRossi = Esempio_4_1.createResource("http://..../MarcoRossi") .addProperty(VCARD.FN, " Marco Rossi "); Fig 4.4 : Creazione del modello e delle risorse dell ES 4.1VCARD è un dizionario che ci permette di rappresentare tutte le proprietà cheesprimono le generalità di un individuo.È possibile ottenere la lista degli statement contenuti nel Model mediante loggetto diclasse StmtIterator : // Richiedo al modello la lista degli statement contenuti StmtIterator iter = Esempio_4_1.listStatements(); Fig 4.5 : Richiesta degli Statements del modello 33
  33. 33. Capitolo 4 Joseki-Il server RDF di Jenae ottenere puntualmente il soggetto, il predicato e loggetto dello statement: Resource subject = stmt.getSubject(); // richiedo il subject Property predicate = stmt.getPredicate(); // richiedo il predicate RDFNode object= stmt.getObject(); // richiedo lobject Fig 4.6 : Richiesta del s p o di uno stamentPer trascrivere il contenuto del model RDF nei vari formati di serializzazione consentitiè possibile utilizzare il metodo write() della classe Model, specificando loutput streamsu cui scrivere con il relativo formato (XML, N-TRIPLE o N3): model.write(fileOutputStream);// Di default XML ! model.write(fileOutputStream, "N-TRIPLE"); model.write(fileOutputStream, "N3"); Fig 4.7 : Scrittura del contenuto del modelloAnalogamente, per leggere un documento RDF, si può utilizzare il metodo read() dellaclasse Model: InputStream in = new FileInputStream(<< nome del file >>); model.read(in, "", "N3"); Fig 4.8 : Lettura di un modello4.2.1 I tools di JenaOltre alle librerie in grado di manipolare una risorsa in RDF, Jena ci offre diversi toolsper operare direttamente sulle risorse . Questi tools vengono lanciati su riga di comandoe sono ad azione immediata.rdfcat : Ci permette di concatenare il contenuto di uno o più documenti RDF. Inoltre, utilizzando le diverse opzioni disponibili , possiamo convertire la nostra risorsa RDF in vari formati dallXML a N3.rdfcopy : Copia un modello. E nostra facoltà scegliere inoltre, in quale sintassi ottenere il risultato della copia ( N3 , XML, RDF , RDF-ABBREV ) 34
  34. 34. Capitolo 4 Joseki-Il server RDF di Jenardfcompare : Controlla se due modelli sono isomorfi , ovvero se il primo può essere mappato nellaltro.sparql : Esegue una query direttamente sul modello. Il risultato verrà stampato sul terminale.4.3.Introduzione a SPARQLSPARQL ( SPARQL Protocol and RDF Query Language) è linguaggio di interrogazionedi una risorsa RDF ed è asceso al rango di W3C Candidate Recommendation [1], comeultimo tassello per ledificazione del Web Semantico.Questo linguaggio adotta la sintassi Turtle [5], unestensione di N3 ( N-Triples ) [21],estremamente sintetica e intuitiva al tradizionale RDF/XML.Possiamo convertire direttamente una risorsa RDF/XML in una estensione N3 grazieallausilio delle API di Jena.In Fig 4.9 vi è un esempio pratico di alcune triple RDF espresse in turtle, che verrannoutilizzate come riferimento per gli esempi successivi. @prefix book:<http://esempio.org/book/> @prefix :<http://esempio.org/esempio/> :Alpha book:autore "Mario Rossi". :Beta book:autore "Mario Rossi". :Gamma book:autore "Gino Bianchi". :Gamma book:anno 1994. Fig 4.9 : Rappresentazione di alcune triple@prefix introduce prefissi e namespace; i due punti senza prefisso (seconda riga)definiscono il namespace di default.Le asserzioni sono espresse in concise sequenze soggetto-predicato-oggetto e delimitateda un punto fermo. Gli URI sono inclusi tra parentesi uncinate e i letterali di tipo stringasono contrassegnati da virgolette. 35
  35. 35. Capitolo 4 Joseki-Il server RDF di Jena4.3.1 Il Pattern MatchingLe query SPARQL si basano sul meccanismo del "pattern matching" [22] e inparticolare su un costrutto, il "triple pattern", che ricalca la configurazione a triple delleasserzioni RDF, fornendo così, un modello flessibile per la ricerca di corrispondenze. ?titolo book:autore ?autore. Fig 4.10 : pattern-matchingIn luogo del soggetto e delloggetto questo "triple pattern" prevede due variabili,contrassegnate con ?.Le variabili fungono, in un certo senso, da incognite dellinterrogazione; book:autorefunge invece da costante. Le triple RDF ,che trovano riscontro nel modello, assocerannoi propri termini alle variabili corrispondenti.In Fig 4.11 viene mostrata una semplice query per chiarire meglio il funzionamento dellinguaggio PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. ?titolo book:anno ?anno . } Fig 4.11 : Semplice queryAnalizzando lesempio soprastante, possiamo vedere che : PREFIX dichiara prefissi enamespace. SELECT definisce le variabili di ricerca da prendere in considerazione nelrisultato (nellesempio: titolo, autore e anno). FROM specifica il set di dati su cui dovràoperare la query (si suppone che le triple siano immagazzinate presso lindirizzo“http://book.com/listaLibri.ttl” ). Infine WHERE ,che definisce il criterio di selezionespecificando tra parentesi graffe uno o più "triple patterns" separati da punto fermo.Applicando la query della Fig 4.11 al set di triple mostrate in Fig 4.9 , si ottiene ilseguente risultato: 36
  36. 36. Capitolo 4 Joseki-Il server RDF di Jena titolo autore anno Gamma Gino Bianchi 1994 Tab 4.1 : Risultato della query in Fig 4.11Il "binding" tra variabili e termini reperiti corrispondenti (in questo caso, un termine perciascuna variabile) è reso in forma di tabella, come un rapporto campo-valore: le righerappresentano i singoli risultati, le intestazioni di cella rappresentano le variabili definitenella clausola SELECT e le celle, i termini associati alle variabili.La query precedente ha catturato esclusivamente le triple dotate di tutti e tre i terminirichiesti (titolo, autore, anno), escludendo le triple che ne possedevano due soltanto(titolo, autore). È possibile riformulare la query in modo più elastico, prevedendoleventuale assenza di alcuni termini. Possiamo farlo grazie al comando OPTIONALcome si vede in Fig 4.12. PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. OPTIONAL {?titolo book:anno ?anno} } Fig 4.12 : uso del comando OPTIONALCome mostrato, il secondo pattern è dichiarato opzionale, infatti linformazione èaggiunta al risultato solo se disponibile, altrimenti le variabili compariranno prive divalore (unbound). Il risultato della query mostrata in Fig 4.12 sarà : titolo autore anno Alpha Mario Rossi Beta Mario Rossi Gamma Gino Bianchi 1991 Tab 4.2 : Risultato query della Fig 4.12 37
  37. 37. Capitolo 4 Joseki-Il server RDF di JenaLe risorse sprovviste della proprietà ?anno sono mostrate ugualmente e le celle deivalori mancanti sono lasciate vuote.Un altro modo per avere una certa elasticità nel recuperare le informazioni presenti nellerisorse, è quello di combinare i diversi operatori logici, che ci vengono messi adisposizione dal linguaggio SPARQL, come viene fatto nella Fig 4.13. In questa querysi produce lo stesso risultato riportato nella Tab 4.2, ma viene usata la parola chiaveUNION, che ci permette di esprimere un OR logico , che cattura le triple che soddisfanola prima e la seconda triple patterns. PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. UNION {?titolo cd:anno ?anno} } Fig 4.13 : Uso di UNION 38
  38. 38. Capitolo 4 Joseki-Il server RDF di Jena4.3.2 Restrizione sui valoriGrazie ad alcuni operatori applicabili sulle variabili, è possibile restringere il campodelle nostre ricerche ed effettuare delle query sempre più specifiche.Di seguito, è descritta la mappatura degli operatori supportati dal linguaggio SPARQL : A=B A != B A<B A e B possono essere di tipo : numerico , stringa A>B , data e booleano A <= B A >= B A*B A/B A e B possono essere di tipo numerico A+B A-B Tab 4.3: Operatori SPARQLNella Fig 4.14 viene mostrato un esempio di triple patterns con una restrizione suivalori. PREFIX book: <http://example.org/book/> SELECT ?titolo ?autore ?anno FROM <http://book.com/listaLibri.ttl> WHERE { ?titolo book:autore ?autore. FILTER (?anno > 2000). } Fig 4.14 : Query con restrizione su un valoreIn questo caso, la restrizione è effettuata mediante loperatore di confronto >( maggiore ), il filtro esclude i termini che non soddisfano la condizione definita tra le 39
  39. 39. Capitolo 4 Joseki-Il server RDF di Jenaparentesi tonde. Il risultato, in questo caso, è nullo ( il data-set di riferimento nonprevede valori maggiori di 2000 per la proprietà anno ).4.3.3 Manipolazione del risultatoMediante SPARQL, possiamo gestire a nostro piacimento il risultato delle nostre query.Ad esempio, come in Fig 4.15, con loperatore DISTINCT è possibile escludere dalrisultato i valori duplicati. SELECT DISTINCT ?titolo ?autore 4.15 : Operatore DistinctAltri costrutti supportati da SPARQL per la manipolazione del risultato sono ORDERBY , LIMIT e OFFSET.Nella Fig 4.16 viene mostrato luso degli altri operatori per la manipolazione delrisultato delle nostre query. ORDER BY DESC(?autore) LIMIT 10 OFFSET 10 Fig 4.16 : Altri operatori per la manipolazioneFacendo riferimento allesempio, lespressione ORDER BY imposta lordine dei risultatidella query . I risultati sono presentati in ordine decrescente (DESC) in base allavariabile ?autore. LIMIT pone restrizioni al numero dei risultati, limitandoli, ai soliprimi 10. OFFSET permette di "saltare" un certo numero di risultati, escludendo, i primi10.4.4. Esempio di utilizzoAppena Joseki viene lanciato di default, permette di eseguire query via browsersullelenco dei dati contenuto nel file desempio books.n3 (un elenco dei libri).Lanciando il browser e collegandosi allURL http://localhost:2020/ si visualizza unapagina Web con una Text Box, nella quale è possibile digitare la query SPARQL che si 40
  40. 40. Capitolo 4 Joseki-Il server RDF di Jenavuole eseguire. Ad esempio, inserendo nella Text Box la seguente query SPARQL, sirichiedono tutti i libri che hanno un titolo, e il relativo risultato è presentato in unapagina HTML. In Fig 4.17 viene mostrata la query di prova che ci appresteremo adeseguire : PREFIX books:<http://example.org/book/> PREFIX dc:<http://purl.org/dc/elements/1.1/> SELECT ?book ?title WHERE { ?book dc:title ?title } Fig 4.17 : Query per un primo utilizzo di JosekiJoseki provvederà ad interrogare il file books.n3, che si presenterà come in Fig 4.18, e ilrisultato della query viene visualizzato tramite una pagina web. Infatti, il client effettuauna GET passando come parametro la query inserita nella Text Box e la relativarisposta HTTP di Joseki, che contiene il risultato della query opportunamente formattatoin HTML. @prefix dc:<http://purl.org/dc/elements/1.1/> . @prefix vcard:<http://www.w3.org/2001/vcard-rdf/3.0#> . @prefix ns:<http://example.org/ns#> . @prefix :<http://example.org/book/> . :book1 dc:title "Harry Potter and the Philosophers Stone" ; dc:creator "J.K. Rowling" ;. :book2 dc:title "Harry Potter and the Chamber of Secrets" ; dc:creator _:a . #(…..segue la dichiarazione dei libri....) _:a vcard:FN "J.K. Rowling" ; vcard:N [ vcard:Family "Rowling" ; vcard:Given "Joanna" ] Fig 4.18 : Frammento del file books.n3 41
  41. 41. Capitolo 4 Joseki-Il server RDF di JenaIl risultato della query mostrata in Fig 4.17 sarà: books title <http://example.org/book/book7> "Harry Potter and the Deathly Hallows" <http://example.org/book/book2> "Harry Potter and the Chamber of Secrets" <http://example.org/book/book4> "Harry Potter and the Goblet of Fire" <http://example.org/book/book6> "Harry Potter and the Half-Blood Prince" <http://example.org/book/book1> "Harry Potter and the Philosophers Stone" <http://example.org/book/book3> "Harry Potter and the Prisoner Of Azkaban" <http://example.org/book/book5> "Harry Potter and the Order of the Phoenix" Tab 4.4: Risultato Query 42
  42. 42. Capitolo 5 Procedure di installazione del Software CAPITOLO 5 Procedure di installazione del softwareIn questo capitolo descriviamo le procedure di installazione del software utilizzato, siasu una macchina locale e sia su una macchina remota, in questo caso un serverdelluniversità raggiungibile allindirizzo 151.100.106.21 sulla porta 2020.5.1. Installazione di Joseki in localeInnanzi tutto bisogna connettersi al sito http://www.joseki.org/, oltre a tutta ladocumentazione necessaria per il funzionamento, sotto la voce download troveremodiverse release del server, scarichiamo la più recente, nel nostro caso Joseki-3.4.1 .Apriamo il terminale e procediamo con la de-compattazione del pacchetto, utilizzando ilcomando : unzip Joseki-3.4.1.zip Fig 5.1 : Uso comando unzipSempre attraverso il terminale, dobbiamo dare i permessi di esecuzione, lettura escrittura a tutti i file presenti nella cartella /bin della nostra distribuzione con ilcomando: chmod u+x bin/* Fig 5.2 : Uso comando chmodLasterisco include tutti i file presenti nella cartella bin.Infine bisogna settare la variabile dambiente , JOSEKIROOT dove è stata installata ladistribuzione del server , per fare ciò si usa il comando : export JOSEKIROOT= < path dell instalazione di Joseki > Fig 5.3 : Settaggio variabile dambiente 43
  43. 43. Capitolo 5 Procedure di installazione del SoftwareAdesso il nostro server è pronto per lesecuzione, basta lanciare il file rdfserver presentenella cartella /bin .Di default se si lancia Joseki senza specificare un file di configurazione, il serverprenderà come riferimento il file joseki-config.ttl .Il file di configurazione viene utilizzato per specificare a quale risorsa di dati si vuolefar riferimento, perché è possibile interfacciare Joseki anche con database e risorse ditipo differenti. sh bin/rdfserver < file di configurazione > Fig 5.4 : Avvio di josekiUna volta lanciato il server, Joseki si attiverà utilizzando il protocollo HTTP sulla porta2020, aprendo un qualsiasi browser, andare su http://localhost:2020, per interrogare lenostre risorse .5.1.1 Configurazione di JosekiIl server Joseki viene configurato attraverso dei servizi, e ogni servizio vieneimplementato grazie ad un processore, che esegue le query in modo fisso su data-setpredefiniti, o altrimenti riesce ad assemblare il data-set in modo dinamico a secondadella query. Quando si pubblicano dati già esistenti, è più opportuno utilizzare unprocessore che non consente un data-set da specificare nella query.Il file di configurazione di Joseki non è altro che un grafo RDF, e questo di defaultprende il nome di joseki-config.ttl ed è scritto solitamente in N3 invece di RDF|XML .Grazie a questa configurazione il server può leggere un ampia gamma di serializzazioneRDF.Innanzitutto, bisogna dichiarare alcuni prefissi, questi sono la base delle informazionidel nostro file (come in Fig 5.5), dato che il file di configurazione è in RDF, lordinedelle sezioni non incide sul server, ma aiuta lutente a leggere il file .Quindi, allinterno di un file è possibile inserire più sezioni che riguardando risorse eservizi differenti. 44
  44. 44. Capitolo 5 Procedure di installazione del Software @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix module: <http://joseki.org/2003/06/module#> . @prefix joseki: <http://joseki.org/2005/06/configuration#> . @prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#> . ## Nota:aggiungendo rdfs:label ai nodi , Joseki ## stamperà ogni messaggio di log. ## -------------------------------------------------------------- ## Approposito di questa configurazione <> rdfs:comment "Esempio di una configurazione di Joseki" . ## -------------------------------------------------------------- ## Approposito di questo server [] rdf:type joseki:Server ; . Fig 5.5 : Dichiarazione dei prefissi della configurazione di JosekiUna volta dichiarati i prefissi si passa alla descrizione dei servizi, il servizio base offertoda Joseki è linterpretazione del linguaggio SPARQL.In Fig 5.6 si vede come aggiungere il servizio di base : # Servizio 1 - Nuova sezione - # Uso generale di un processore SPARQL , nessun data-set, # bisogna specificare il data-set o nella query o nei parametri del # protocollo di richiesta . [] rdf:type joseki:Service ; rdfs:label "nome servizio" ; joseki:serviceRef "sparql" ; joseki:processor joseki:ProcessorSPARQL ; . Fig 5.6 : Sezione del servizio di baseSe si ha la necessità di interrogare un data-set fisso, Joseki ci permette di farloaggiungendo lopportuno servizio (come si vede in Fig 5.7) 45
  45. 45. Capitolo 5 Procedure di installazione del Software # Servizio 2 – processore SPARQL solo #.per un determinato data-set rdf:type joseki:Service ; rdfs:label "SPARQL on the books model" ; joseki:serviceRef "books" ; # parti del data-set joseki:dataset _:books ; # Parti del servizio. # Questo processore non consente né il protocollo, # nemmeno la query per specificare i data-set. joseki:processor joseki:ProcessorSPARQL_FixedDS ; . Fig 5.7 : Selezione del data-setPasseremo ora alla sezione riguardante la dichiarazione del data-set . Un data-set puòessere definito mediante un Jena Assembler Description, ovvero un assemblatore per lacreazione di modelli. Ogni data-set di dati RDF è una raccolta di più grafici che possonoavere un nome o meno, a sua volta ogni grafico, può essere visto come un modello diJena, questi vengono definiti attraverso uno Jena Assembler vocabulary.Si faranno alcuni esempi sulle sezioni del file di configurazione di Joseki che settano idata-set, i tipi di modelli e il processore.Questo primo data-set, mostrato in Fig 5.8, ha un solo grafico di default. Il contenutodel data-set viene caricato da un file ( se ne possono caricare più di uno ), ma il nomedel file non conferisce il nome al modello. 46
  46. 46. Capitolo 5 Procedure di installazione del Software # Dataset con un modello da file _:books rdf:type ja:RDFDataset ; rdfs:label "Books" ; ja:defaultGraph [ a ja:MemoryModel ; rdfs:label "books.n3" ; ja:content [ ja:externalContent <file:Data/books.n3> ] ]; . Fig 5.8 : Data-set di un modello da fileUn esempio più complesso è mostrato in Fig 5.9, dove vengono presi due grafici dafonti differenti, e le fonti conferiranno anche il nome al modello. _:dataset1 rdf:type ja:RDFDataset ; ja:defaultGraph _:model0 ; rdfs:label "Dataset _:dataset1" ; a:namedGraph [ ja:graphName <http://example.org/name1> ; ja:graph _:model1 ] ; ja:namedGraph [ ja:graphName <http://example.org/name2> ; ja:graph _:model2 ] ; . Fig 5.9 : Data-set costruito su più graficiVedremo ora come definire la sezione riguardante la dichiarazione dei modelli questoavviene attraverso lo Jena Assembler vocabulary ,in Fig 5.10 si suppone di averediversi modelli su cui far riferimento. 47
  47. 47. Capitolo 5 Procedure di installazione del Software ## Grafico individuale ( Jena chiama questi modelli ) ## (la sintassi dei file dei dati è data da un file di estensioni in RDF/XML) _:model0 rdf:type ja:MemoryModel ; rdfs:label "Model fonde i 2 file RDF )" ; ja:content [ ja:externalContent <file:D1.ttl> ; ja:externalContent <file:D2.ttl> ; ] ;. _:model1 rdf:type ja:MemoryModel ; rdfs:label "Model (contenuto D1.ttl )" ; ja:content [ ja:externalContent <file:D1.ttl> ; ] ;. _:model2 rdf:type ja:MemoryModel ; rdfs:label "Model (contenuto D2.ttl )" ; ja:content [ ja:externalContent <file:D2.ttl> ;]. Fig 5.10 : Dichiarazione di più modelliSe si ha la necessità, di interrogare un modello memorizzato su un qualsiasi database, siprocederà come si vede in Fig 5.11 _:db rdf:type ja:RDBModel ; ja:connection [ ja:dbType "MySQL" ; ja:dbURL "jdbc:mysql://localhost/data" ; ja:dbUser "user" ; ja:dbPassword "password" ; ja:dbClass "com.mysql.jdbc.Driver" ; ]; ja:modelName "books" . Fig 5.11 : Accesso ad un modello su Database 48
  48. 48. Capitolo 5 Procedure di installazione del SoftwareInfine, vedremo la sezione riguardante il processore, ogni descrizione del processorepuò avere parametri che vengono passati ad ogni istanza di classe al momento dellacreazione.In Fig 5.12 viene mostrata la dichiarazione di un processore standard SPARQL, cheaccetta query attraverso i parametri FROM | FROM NAME, e i dati vengono caricati divolta in volta . Mentre in Fig 5.13 viene dichiarato un processore con con data-set fissoche non accetta query attraverso i parametri FROM | FROM NAME joseki:ProcessorSPARQL rdf:type joseki:Processor ; rdfs:label "Processore Generale SPARQL" ; module:implementation joseki:ImplSPARQL ; # Parametri : accetta query con FROM/FROM NAMED joseki:allowExplicitDataset "true"^^xsd:boolean ; joseki:allowWebLoading "true"^^xsd:boolean ; ## Non cè una politica di chiusura ## (i dati vengono caricati di volta in volta). joseki:lockingPolicy joseki:lockingPolicyNone ; . Fig 5.12 : Dichiarazione di un processore standard joseki:ProcessorSPARQL_FixedDS rdf:type joseki:Processor ; rdfs:label "Processore SPARQL con data-set fisso" ; module:implementation joseki:ImplSPARQL ; # This processor does not accept queries with FROM/FROM NAMED joseki:allowExplicitDataset "false"^^xsd:boolean ; joseki:allowWebLoading "false"^^xsd:boolean ; # Fixed background dataset : multiple read requests are OK joseki:lockingPolicy joseki:lockingPolicyMRSW ; . Fig 5.13 : Dichiarazione di un processore con data-set fisso 49
  49. 49. Capitolo 5 Procedure di installazione del Software5.2 Installazione di Joseki in remotoPer una simulazione, che si avvicini sempre più alla realtà, abbiamo installato il serverJoseki su una macchina remota, un server delluniversità. Le procedure di installazione, icomandi da utilizzare per lavvio di Joseki sono gli stessi del paragrafo 5.1, lunicadifferenza sta nella connessione al server remoto .Per connetterci al server remoto apriamo la shell e digitiamo il comando : Scp <sorgente file> -r palma@151.100.106.21 :~ Fig 5.14 : Uso comando scpscp, sta per secure-copy, ed è uno dei programmi utilizzati per scambiare file tra gli hostdi una rete, in questo caso la mia macchina ed il server.In <sorgente file> viene inserito il path dove si trova Joseki, e -r specifica che dovràessere copiato tutto il contenuto della cartella selezionata. Subito dopo viene selezionatol user, il server di riferimento e dove mandare i file, :~ ,indica la directory di base.Naturalmente, per effettuare questa operazione il programma richiede un autenticazioneal server.Una volta terminata loperazione di copia, possiamo connetterci al server remoto tramiteil comando : ssh -l palma 151.100.106.21 Fig 5.15 : Uso comando sshssh è un programma per loggarsi su una macchina remota ed eseguire comandidirettamente su questa, con -l si specifica il nome dellutente che si connette, e poi vieneinserito lindirizzo fisico della macchina.Possiamo riprendere ora tutti i comandi del paragrafo 5.1 e digitarli direttamente sulserver .Per vedere il funzionamento di Joseki, si deve aprire un qualsiasi browser e inserirecome URL : 50
  50. 50. Capitolo 5 Procedure di installazione del Software URL: 151.100.106.21 : 2020 Fig 5.16 : Url di riferimento del serverI comandi descritti, non ci garantiscono il continuo funzionamento di Joseki, infatti unavolta chiusa la sessione o il terminale, il processo relativo a Joseki viene troncato dalserver e di conseguenza Joseki cesserà di funzionare.Per far si, che ciò non avvenga, si possono utilizzare due tecniche distinte, la prima siriferisce ad un avvio manuale del servizio utilizzabile in fase di sviluppo/testdellapplicazione, la seconda utilizzabile per lavvio del servizio in automatico, una voltache lapplicazione è terminata e pronta per essere utilizzata.Per avviare manualmente Joseki si effettua un accesso tramite il protocollo ssh al serverove risiede lapplicazione e tramite il comando in Fig 5.17, si manda in esecuzione ilservizio. nohup sh /bin/rdfserver & Fig 5.17 :Uso del comando nohupPrima di lanciare il comando descritto in Fig 5.17 bisogna spostarsi allinterno dellacartella root di Joseki attraverso il comando cd.Il comando in Fig 5.17 in realtà è composto da tre istruzioni distinte: • nohup: che ha la funzione di staccare il processo dal genitore, in quanto lavorando in ssh se non si effettua un detach del processo figlio, alla chiusura della connessione ssh, che può avvenire intenzionalmente o accidentalmente, il processo verrebbe terminato dato che viene terminato il processo padre, cioè la bash creata dalla connessione ssh; • sh ./bin/rdfserver: lancio dello script utilizzato per lavvio di joseki; • &: esegue il comando per lavvio del processo in background, cioè consente di rilasciare lutilizzo della shell una volta avviato il processo senza aspettare la terminazione di questultimo e quindi permettere di chiudere la sessione ssh o di svolgere altre attività. 51
  51. 51. Capitolo 5 Procedure di installazione del SoftwareCon la seconda tecnica, Joseki viene eseguito in automatico dal server e il suofunzionamento viene garantito in qualsiasi circostanza. Questa, consiste nel modificareil file rc.local ( mostrato in Fig 5.19 ) posizionato allinterno della directory /etc/rc.d/ inslackware 12.1, il quale è uno script che viene eseguito automaticamente dal sistemauna volta terminata la procedura di startup, essendo uno script di sistema, per effettuarela modifica di rc.local bisogna avere le credenziali di root.La modifica di rc.local consiste nellinserire alla fine dello script i comandi utilizzati perlavvio del server come si vede in Fig 5.18 cd /home/palma/Joseki-3.4.1 sh /home/palma/Joseki-3.4.1/bin/rdfserver & Fig 5.18 : Modifica del file rc.localLa prima riga serve per definire lambiente in cui si deve eseguire lo script di avvio diJoseki, mentre la seconda serve per avviare Joseki in modalità background comedescritto precedentemente. #!/bin/sh # /etc/rc.d/rc.local: Local system initialization script. # Put any local startup commands in here. Also, if you have # anything that needs to be run at shutdown time you can # make an /etc/rc.d/rc.local_shutdown script and put those # commands in there. cd /home/palma/Joseki-3.4.1 sh /home/palma/Joseki-3.4.1/bin/rdfserver & exit 0 Fig 5.19 : Visone del file rc.local 52
  52. 52. Capitolo 5 Procedure di installazione del Software5.3 Installazione di JenaAnche se Jena è stato sviluppato come un insieme di librerie java, è possibile far uso dialcune utility a riga di comando descritte nel cap. 4.2.1.Per prima cosa, bisogna scaricare lultima versione di Jena (nel nostro caso è la 2.6.2 ), epoi decomprimere larchivio,verrà creata una sotto-directory chiamata Jena-2.6.2 nelladirectory di home. Per fare ciò si usa il comando : unzip Jena-2.6.2.zip Fig 5.20 : De-compattazione di JenaSempre dalla shell , si deve impostare la directory di root di Jena attraverso il comando : export JENAROOT = ~ / Jena-2.6.2 Fig 5.21 : Set variabile dambiente di JenaInfine, bisogna aggiungere i permessi di esecuzione a tutti i file presenti nella cartella : chmod u+x $JENAROOT/bin/* Fig 5.22 : Aggiunta permessi di JenaE possibile verificare il funzionamento di Jena, utilizzando lopzione --help a una delleutility presenti nella directory /bin, 53
  53. 53. Capitolo 6 Risorse RDF pubbliche CAPITOLO 6 Risorse RDF pubblicheIn questo capitolo, vengono mostrate le maggiori basi di dati presenti nel web, comeFreebase , Dbpedia [11] , e il MERLOT [12] ( Multimedia Educational Resource forLearning and Online Teaching ), che rendono pubblicamente disponibili le loro risorse,utilizzando sempre un approccio al Web Semantico .6.1 FreeBaseFreebase è una grande base di dati collaborativa, si tratta, di una raccolta online di datistrutturati non solo in RDF, che vengono raggruppati da fonti differenti, tra cui offre ilsuo contributo "wiki". Freebase mira a creare una grande e unica risorsa globale chepermette alle persone e alle macchine di accedere a informazioni, contenuti, e altro, inmodo più efficiente utilizzando lapproccio del Web Semantico. E stato sviluppato dallasocietà americana di software MetaWeb ed è entrato in esecuzione nel marzo del 2007.Questo sistema contiene informazioni su circa 12 milioni di argomenti o Enti, ogninuovo argomento che viene inserito, ha un ID univoco, modo da poter gestire topic conlo stesso nome, ma con significato diverso.Ad ogni argomento può essere associato a uno o più tipi come ad esempio, persone,luoghi, film ecc ecc, e ogni tipo può avere delle proprietà aggiuntive come la data dinascita per una persona o le coordinate per un luogo. Questi tipi, le relative proprietà e irelativi concetti vengono chiamati Schema.Chiunque può contribuire allinserimento di un nuovo concetto e sulla definizione dinuove proprietà e schemi.FreeBase provvede anche a mettere a disposizione delle API per la creazione, modificao miglioramento degli schemi, e queste ci permettono anche di interrogare le risorsecontenute direttamente da un interfaccia web. 54
  54. 54. Capitolo 6 Risorse RDF pubbliche6.1.1 Esempio di risorsa FreebaseCome è stato accennato è possibile esplorare tutte le risorse che Freebase ci offre, ed èpossibile navigare allinterno dei topic.Sotto la voce explore Freebase, troveremo tutti gli argomenti messi a disposizione dalsistema come si vede in Fig 6.1. Ad esempio, scegliendo largomento Science &Tecnology, si aprira una lista di tutte le sotto-argomentazioni presenti. Fig 6.1 : Esempio di Argomentazioni FreebaseScegliendo la tipologia internet, che contiene a sua volta 40152 topic, troveremo unabreve descrizione di internet e tutti i topic vengono catalogati allinterno del tipo stessocome si vede in Fig 6.2. 55
  55. 55. Capitolo 6 Risorse RDF pubbliche Fig 6.2 : Raggruppamento dei topicSe scegliamo il topic website, il primo in Fig 6.3, questo contiene a sua volta 4627topic, si nota che questi verranno visualizzati come un risultato di una query e che èconsentito fare delle operazioni direttamente via web su queste risorse, filtrando ilnome, il contenuto e la categoria degli oggetti o aggiungendo e rimuovendo proprietàdelle informazioni. Fig 6.3 : Visualizzazione delle risorsePossiamo inoltre vedere il risultato della ricerca, in formato RDF e non solo, andandosul link in basso alla pagina come in Fig 6.4 . 56
  56. 56. Capitolo 6 Risorse RDF pubbliche Fig 6.4 : Scelta del formato6.2 DBpediaLe basi della conoscenza svolgono un ruolo sempre più importante nel migliorarelintelligenza del web e nel sostenere lintegrità delle informazioni. Oggi, la fontecentrale di conoscenza sul Web e data da Wikipedia, e viene mantenuta grazie a migliaiadi contributori.Il progetto DBpedia, sfrutta proprio questo centro di informazioni per lestrazione di datistrutturati e li rende disponibili sul web, utilizzando sempre un approccio al WebSemantico. DBpedia descrive attualmente più di 3,4 milioni di cose, di cui 1,5 milionisono classificati in un ontologia pubblica scaricabile da sito, tra cui 312.000 persone,413.000 posti, 94.000 album musicali, 49.000 film, 15.000 video giochi, 140.000organizzazioni, 146.000 specie e 4.600 malattie .Tutti i data-set di Dbpedia, sono caratterizzati da delle etichette caratteristiche , tra cui3,2 milioni di cose classificate in 92 lingue diverse; 841.000 collegamenti a immagini e5.081.000 link a pagine web esterne; 9.393.000 link esterni in altri data-set RDF,565.000 categorie di Wikipedia, e 75.000 le categorie YAGO. La base di conoscenza ditutta DBpedia consiste di oltre 1 miliardo di triple RDF, di cui 257 milioni sono statiricavati dalla edizione inglese di Wikipedia e 766 milioni sono stati estratti dalleedizioni in altre lingue. 57
  57. 57. Capitolo 6 Risorse RDF pubbliche6.2.1 Esempio di risorsa DbpediaTutte le risorse di Dbpedia vengono presentate come dati strutturati e queste possonoessere interrogate attraverso lausilio del linguaggio SPARQL o visualizzate attraverso ilmetodo del Linked Data. Dbpedia, ci offre una piattaforma per linterrogazione dellerisorse, ma questo non toglie che possiamo utilizzare una qualsiasi server perlinterrogazione di dati strutturati come ad esempio Joseki.Tutti i data-set pubblici di Dbpedia sono stati caricati in http://DBpedia.org/sparql,mentre sotto lindirizzo http://dbpedia.org/snorql/ è stato caricato un server genericoSPARQL per linterrogazione delle risorse come si vede in Fig 6.5. Fig 6.5 : Server offerto da DbpediaInoltre, è possibile visualizzare il risultato delle query nel formato più opportunoscegliendo in che modo ricevere il risultato, tutti i namespace per linterrogazionevengono importati automaticamente.Un altro modo per esplorare le risorse in modo automatico, è quello di utilizzaredirettamente il nostro browser, questo approccio viene chiamato Linked Data.Tutte le risorse sono collegate tra loro, e così un utente partendo da un iniziale fonte didati, si può spostare attraverso un web potenzialmente infinito di sorgenti, collegati da 58

×