I linguaggi del Web Semantico

Il linguaggio RDF(S)

Secondo la proposta (e questa ci teniamo) del *W3C* il set di linguaggi su cui costruire il web semantico è RDF(S) (cioè RDFS + *RDF1*), un set di linguaggi dichiarativi basati su sintassi *XML*.

Due cose è bene che siano chiare fin dall'inizio. Il rapporto tra le diverse parti di RDF(S) e le parentele e le diversità con XML.

Il web semantico nasce come tentativo di controllare le informazioni ancorandole ad uno schema. Questa idea funziona se si dividono bene i compiti.

Da qualche parte avremo di sicuro i dati, da qualche parte di sicuro uno schema che definisce come i dati si strutturano e relazionano far loro, in mezzo serve un ulteriore livello perché abbiamo bisogno di tenere traccia di quando un dato specifico (istanza) può essere espresso a partire dallo schema.

Scendiamo nel concreto e vediamo come questo si realizzi in RDF(S).

In informatica una risorsa, un documento, è definibile in base al suo path; nel Web una risorsa è la localizzazione di un file affidata alle *URL*. Immaginiamo perciò di avere una risorsa di questo tipo

Lo schema

Immaginiamo che i nostri contenuti siano relativi a corsi e lezioni online. Dobbiamo avere perciò uno schema, o ontologia, per definire quel dominio. Come dichiarazione iniziale si definiscono dei namespace (delle *URI*) che identificare i costrutti RDF, RDFS e l'ontologia. Per il resto lo schema descrive le classi e proprietà. Ne abbozzo un pezzetto.

<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:a=" http://www.nomesito.it/data/nomeontologia# ">

<rdfs:Class rdf:about resource="http://www.nomesito.it/data/nomeontologia#Corso"/>
   <rdfs:subClassof rdf:resource="#Resource"/>
   </rdfs:Class>

<rdfs:Class rdf:about resource="http://www.nomesito.it/data/nomeontologia#Argomento"/>
   <rdfs:subClassof rdf:resource="#Corso"/>
   </rdfs:Class>

<rdfs:Class rdf:about resource="http://www.nomesito.it/data/nomeontologia#Specializzazione"/>
   <rdfs:subClassof rdf:resource="#Resource"/>
   </rdfs:Class>

<rdfs:Property rdf:about resource="http://www.nomesito.it/data/nomeontologia#Titolo"/>
   <rdfs:domain rdf:resource="#Corso"/>
   <rdfs:range rdf:resource="#Literal"/>
   </rdfs:Class>

<rdfs:Property rdf:about resource="http://www.nomesito.it/data/nomeontologia#Livello_di_Specializzazione"/>
   <rdfs:domain rdf:resource="#Corso"/>
   <rdfs:range rdf:resource="#Specializzazione"/>
   </rdfs:Class>

<rdfs:Property rdf:about resource="http://www.nomesito.it/data/nomeontologia#Utenti"/>
   <rdfs:domain rdf:resource="#Specializzazione"/>
   <rdfs:range rdf:resource="#Utenti"/>
   </rdfs:Class>

<rdfs:Property rdf:about resource="http://www.nomesito.it/data/nomeontologia#Preparazione_Utenti"/>
   <rdfs:domain rdf:resource="#Specializzazione"/>
   <rdfs:range rdf:resource="#Literal"/>
   </rdfs:Class>

</rdf:RDF>

Abbiamo definito innanzi tutto una classe (rdfs:Class ) che avrà come nome (rdf:about ) la risorsa (rdf:resource= ) http://www.nomesito.it/data/nomeontologia#Corso. I nomi delle risorse si identificano utilizzando URI. La parte dell'URL che precede # indica una precisa ontologia, indica il nome dello schema al quale è riferito un elemento, la parte successiva al # indica il nome che si è voluto dare a quell'elemento. Abbiamo poi detto che questa classe Corso rdfs.subClassof ) di Resource

Considerando il livello radice come livello 0 la classe Corso apparterà al livello 1 del nostro dominio. La classe Argomento Titolo rdf:Property , con dominio (rdfs:domain ) la classe Corso e con codominio (rdfs:range ), Literal

Una classe può essere definita specificando i suoi attributi (e, per essere completi, ma lo vedremo più avanti, collegandola attraverso un metadato ad un URL). La classe Corso ha un titolo che deve essere specificato tramite una stringa. La classe Argomento in quanto sottoclasse di corso eredita la proprietà Titolo. Anche l'argomento quindi potrà essere definito da un titolo.

Ora entriamo negli aspetti più difficili della modellazione dello schema. La classe Corso ha una proprietà che si chiama Livello_di_Specializzazione. Questa proprietà ha il compito di tener traccia del livello di specializzazione col quale è stato preparato un corso. Questa proprietà non è però semplice, non è definibile semplicemente riempiendo una stringa, ma punta ad un'altra classe.

Nella classe Specializzazione abbiamo a loro volta due attributi. Uno indica il tipo di utenti, e punta ad un classe utenti non descritta nell'esempio, uno indica la preparazione di questi utenti. In pratica la proprietà Livello_di_Specializzazione subClassof questa relazione è stata liberamente battezzata dal progettista. SubClassof

Con questo piccolo esempio si può vedere le possibilità espressive di uno schema ontologico. Il corso può avere un livello di specializzazione che dipende dal tipo di utenti a cui si rivolge e dalla preparazione che si presume questi abbiano. Con una situazione di questo tipo si sta descrivendo una proprietà, Livello_di_Specializzazione, che ha un grado, con una sorta di restrizione a seconda dell'utente a cui di volta in volta si attribuisce.

I metadati

Adesso che abbiamo lo schema riprendiamo quanto detto più avanti. In partenza avevamo una risorsa, un documento, localizzabile da questa URL http://www.nomesito.it/nomecorso/nomecorso.html. Incominciamo a descrivere qualche metadato e ad indicare come questa risorsa si relaziona al nostro schema. Se gli schemi venivano scritti in file RDFS i metadati si esprimono all'interno di file RDF. Qui la dicharazione iniziale non necessita del namespace rdfs.

<rdf:RDF
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:a=" http://www.nomesito.it/data/nomeontologia# ">

<a:Corso rdf:about="http://www.nomesito.it/nomecorso/nomecorso.html">
   <a:Titolo="nomecorso"/>
</a:Corso>

<a:Argomento rdf:about=" http://www.nomesito.it/nomecorso/nomecorso.html"
   a:Titolo="nomeargomento1"/>
</a:Argomento>

<a:Argomento rdf:about=" http://www.nomesito.it/nomecorso/nomecorso.html"
   a:Titolo="nomeargomento2"/>
</a:Argomento>

</rdf:RDF>

Per il momento abbiamo prodotto dei metadati molto semplici. Abbiamo detto che la prima risorsa è un corso dal titolo nomecorso

Ogni asserzione è costituita, da un punto di vista logico, da tre elementi fondamentali #Argomento http://miosito/rdfs/nomeschema/Argomento

La struttura a tripla delle asserzioni è molto flessibile, come abbiamo visto, e abbastanza potente. La sua potenza però può essere ampliata se si collegano fra loro più asserzioni. Le asserzioni si possono collegare facilmente tramite degli ID.

<a:Corso rdf:about="http://www.nomesito.it/nomecorso/nomecorso.html">
   <a: Livello_di_Specializzazione =" http://www.nomesito.it/data/nomeontologia/model.rdf#ID_13"/>
</a:Corso>

<a:Specializzazione rdf:about="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_13"
   a:Preparazione_Utenti="alta"/>
</a: Specializzazione >

<a:Specializzazione rdf:about="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_13"
   a:Utenti=" http://www.nomesito.it/data/nomeontologia/model.rdf#ID_14"/>
</a: Specializzazione >

<a:Utenti rdf:about="http://www.nomesito.it/data/nomeontologia/model.rdf#ID_14"
   a:nome="nomeutenti"/>
</a: Specializzazione >

Ma posso anche inserire un'asserzione nell'altra ampliando la complessità della sua struttura. In questo caso dico che in una certa pagina si dice che c'è un corso che ha titolo nomecorso.

<rdf:Description rdf:about=" http://www.nomesito.it/nomecorso/nomesito.html">
  <a:assert
rdf:resource="http:// http://www.nomesito.it/data/nomeontologia/model.rdf#ST_168_sp"/>
</rdf:Description>

<rdf:statement rdf:about=" http://www.nomesito.it/data/nomeontologia/model.rdf#ST_168_sp">
  <rdf:subject rdf:resource="#Corso"/>
  <rdf:predicate rdf:resource="#Titolo"/>
<rdf:object rdf:resource="nomecorso"/>
</rdf:statement>

Questo modo di concatenare asserzioni viene chiamato reificazione Metadati: RDF e RDFS

RDF oltre XML

Dopo aver chiarito la differenza tra RDFS e RDF. Vediamo quali differenze ci sono tra RDF(S) e XML. Le differenze fondamentali sono sicuramente due.

Per prima cosa RDF(S) è stato pensato espressamente per esprimere metadati. XML fa molte cose, e può anche essere usato per descrivere metadati, ma generalmente ha un rapporto molto più stretto con i dati, contiene già in se dei dati che possono essere richiamati. RDF(S) esprime metadati, nel senso più proprio: di un documento descrive contenuti che nel documento non sono presenti.

L'altra differenza rispetto a XML è legata alla capacità espressiva di descrivere le relazioni. XML è centrato su una struttura a inclusione, riesce perciò ad esprimere senza difficoltà le relazioni di parentela o di essere parte di, ma per le altre relazioni dimostra dei limiti. Se volessi esprimere una relazione associativa fra due classi, cioè dire che esse hanno una relazione ma non sono incluse una nell'altra, con XML devo ricorrere agli ID e IDREF.

Ad esempio per dire che un corso ha un livello di specializzazione dovrei scrivere:

<xsd.:element namespace="TITOLO" type="xsd:string">
<xsd.:element namespace="LIV_SPECId" type="IDREFS">
</xsd:complexType>

<xsd:complexType namespace="SPECIALIZZAZIONE">
<xsd.:element namespace="UTENTI" type="xsd:string">
<xsd.:element namespace="PRE_UTENTI" type="xsd:string">
<xsd.:element namespace="CORSOId" type="ID">
</xsd:complexType>

Non è impossibile ma perché la relazione funzioni il controllo deve essere doppio, verificando che id coincida con idref. Inoltre per non allungare l'esempio ho dovuto considerare Utenti come un elemento semplice, rinunciando a descrivere Utenti come classe. La cosa avrebbe ulteriormente complicato il codice obbligando ad inserire delle keyref. Per una spiegazione più approfondita su come si possono rendere i vari tipi di relazione in XML trovate un articolo molto completo Association for Computing Machinery

Per una semplice ma efficace descrizione delle differenze tra XML e RDF consiglio l'introduzione all'ontology engineering specifiche ufficiali del linguggio RDF documento in PDF