• Wprowadzenie
• Warstwy technologiczne Sieci Semantycznej
• Reprezentacja i wyszukiwanie informacji
  • Zapis informacji w Sieci Semantycznej
    • Serializacja grafu RDF
  • Konsekwencje „świata otwartego”
  • Wyszukiwanie informacji
    • SPARQL Protocol And RDF Query Language
• Tworzenie aplikacji Sieci Semantycznej
  • Dostępność zasobów
  • Pakiety narzędziowe
• Podsumowanie

Sieć Semantyczna — zgodnie z wizją twórcy WWW, jest to sieć zrozumiała nie tylko dla człowieka, ale również dla maszyny (programu, „agenta”):

The Web was designed as an information space, with the goal that it should be useful not only for human-human communication, but also that machines would be able to participate and help. [...] Leaving aside the artificial intelligence problem of training machines to behave like people, the Semantic Web approach instead develops languages for expressing information in a machine processable form.

„Semantic Web Road map”, Tim Berners-Lee, 1998

SW to naturalna (trwająca już) ewolucja WWW — sieć danych zamiast sieci dokumentów.

Wymaga to opracowania specjalnych metod zapisu informacji i wiedzy w sposób zrozumiały dla agentów, ale równocześnie zdatny do obsługi przez człowieka.

Rekomendacje W3C:

• RDF Model and Syntax — wyrażenia trójkowe (podmiot, predykat, obiekt) lub (zasób, cecha, wartość) opisujące zasoby lub obiekty identyfikowalne za pomocą URI.
• RDF Vocabulary Description Language (aka RDF Schema) — zapis informacji o klasach obiektów, relacjach między nimi, zbiorach wartości, kolekcjach itp.
• OWL Web Ontology Language — zapis ontologii — definiowanie złożonych klas (poprzez opis zależności od innych klas) oraz właściwości obiektów; mechanizmy wnioskowania o klasach i obiektach.

Never forget: only the graph is “real”, the rest is convenience!
Niestety graf RDF jest możliwy do wyrysowania tylko na jednym „poziomie”. Opis klas (RDFS, OWL) nie jest możliwy do zobrazowania na jednym grafie wraz z ich instancjami ponieważ predykat może stać się podmiotem w innym wyrażeniu (opis właściwości właściwości) co nie jest dopuszczalne w grafie.

W rekomendacjach W3C oficjalnym standardem serializacji grafu RDF jest format RDF/XML. Zgodnie z koncepcją „stosu” W3C również RDFS i OWL zapisuje się przez RDF/XML.

Sposób ten jest jednak uważany za kłopotliwy, niejednoznaczny, mało wydajny, nie obrazujący wprost trójek RDF, a ponadto trudny do używania przez człowieka. Stąd potrzeba powstania łatwiejszego formatu. Najpopularniejszy format nie oparty o XML to N3 (Notation 3) oraz jego podzbiory (np. N-Triples) i pochodne (np. Turtle). Istnieją też alternatywne formaty XML, np. TriX.

• 

• <?xml version="1.0"?>
  <!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
           xmlns:expet="http://example.org/pets#"
           xmlns:exvoc="http://example.org/vocab#">
  
    <expet:Cat rdf:about="http://example.org/cats/PL/OP#Maurycy">
      <expet:name rdf:datatype="&xsd;string">Maurycy</expet:name>
      <expet:breed rdf:datatype="&xsd;string">EUR</expet:breed>
      <expet:age rdf:datatype="&xsd;decimal">1.5</expet:age>
      <expet:mailbox rdf:resource="mailto:maurycy.kot@gmail.com"/>
      <exvoc:coinhabitants>
        <rdf:Bag>
          <rdf:li rdf:resource="http://example.org/cats/PL/OP#Kalma" />
          <rdf:li rdf:resource="http://example.org/rats/PL/OP/Gomez" />
        </rdf:Bag>
      </exvoc:coinhabitants>
    </expet:Cat>
  </rdf:RDF>

• @prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
  @prefix expet: <http://example.org/pets#> .
  @prefix exvoc: <http://example.org/vocab#> .
  @prefix :      <http://example.org/cats/PL/OP#> .
  
  :Maurycy a expet:Cat ;
           expet:name "Maurycy" ;
           expet:breed "EUR" ;
           expet:age 1.5 ;
           expet:mailbox <mailto:maurycy.kot@gmail.com> ;
           exvoc:coinhabitants [ a rdf:Bag ;
                                 rdf:_1 <http://example.org/cats/PL/OP#Kalma> ;
                                 rdf:_2 <http://example.org/rats/PL/OP/Gomez> ] .

  Podstawowe ułatwienia/skróty w notacji N3:

  • a — rdf:type
  • ; — następna cecha tego samego podmiotu
  • , — następny obiekt przy tym samym podmiocie i cesze
  • [ ] — obiekt anonimowy, „blank node” w RDF
  • = — ten sam obiekt lub klasa

Sieć Semantyczna jest oparta na koncepcji „świata otwartego”, w którym sam fakt, że coś nie zostało powiedziane, nie oznacza jeszcze, że nie jest to prawdą. Stąd specyficzne podejście do znajdywanych informacji — założenie ich niekompletności i wnioski uzupełniające informacje zamiast błędów.

<owl:ObjectProperty rdf:ID="hasMother">
  <rdfs:domain rdf:resource="#Person" />
  <rdfs:range rdf:resource="#Woman" />
</owl:ObjectProperty>

<owl:Class rdf:ID="Person">
  <owl:Restriction>
    <owl:onProperty rdf:resource="#hasMother"/>  
    <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
  </owl:Restriction>
</owl:Class>

• Nie odnalezienie w zbiorze RDF zapisu <#person1> :hasMother <#woman1> nie oznacza błędu w danych, tylko ich (chwilową) niekompletność — matka jest jeszcze nieznana.
• Odnalezienie dwóch zapisów <#person1> :hasMother <#woman1> oraz <#person1> :hasMother <#woman2> nie oznacza sprzeczności w danych tylko prowadzi do wniosku: <#woman1> owl:sameAs <#woman2>.

Trzy teoretyczne możliwości przeszukiwania informacji zapisanej w RDF:

• na poziomie syntaktycznym — po zserializowaniu do RDF/XML, za pomocą metod przeszukiwania dokumentów XML (np. XPath, XQuery) — praktycznie niemożliwe ze względu na niejednoznaczność reprezentacji grafu RDF przez drzewo XML,
• na poziomie strukturalnym — przeszukiwanie trójek RDF — zaleta: niezależność od reprezentacji, wada: brak możliwości analizowania ontologii (hierarchii i złożonych zależności klas),
• na poziomie semantycznym — przeszukiwanie wielu grafów RDF — jedyna dopuszczalna możliwość ze względu na konieczność uwzględnienia pełnej wiedzy na temat semantyki przeszukiwanych elementów.

SPARQL Protocol And RDF Query Language — standardowy język zapytań dla danych w RDF oraz protokół przesyłania wyników przez HTTP.

Cztery rodzaje zapytań:

• SELECT — zwraca wynik podstawienia do szablonu danych (także z wielu grafów RDF) spełniających podane zależności,
• CONSTRUCT — zwraca graf RDF utworzony przez podstawienie wyników zapytania do zmiennych w szablonie,
• DESCRIBE — zwraca graf RDF będący opisem zasobu wskazanego jawnie lub spełniającego podane warunki,
• ASK — zwraca wartość logiczną oznaczającą czy zapytanie ma rozwiązanie, bez wskazania szczegółów.

• Graf domyślny:

  @prefix dc: <http://purl.org/dc/elements/1.1/> .
  
  <http://example.org/johny>  dc:publisher  "Johny"@en .
  <http://example.org/ala>    dc:publisher  "Ala" .

  Graf http://example.org/johny:

  @prefix foaf: <http://xmlns.com/foaf/0.1/> .
  
  _:a foaf:name "Jan Mocny" .
  _:a foaf:mbox <mailto:bob@oldcorp.example.org> .
  _:a foaf:homepage <http://strongmen.org.pl/johny/> .

  Graf http://example.org/ala:

  @prefix foaf: <http://xmlns.com/foaf/0.1/> .
  
  _:a foaf:name "Alicja Wesoła" .
  _:a foaf:mbox <mailto:ala@work.example.org> .

• PREFIX foaf: <http://xmlns.com/foaf/0.1/>
  PREFIX dc: <http://purl.org/dc/elements/1.1/>
  
  SELECT ?who ?name ?mbox ?homepage
  WHERE
  {
    ?g dc:publisher ?who .
    GRAPH ?g {
          ?x foaf:name ?name .
          OPTIONAL { ?x foaf:mbox ?mbox } .
          OPTIONAL { ?x foaf:homepage ?homepage }
    }
  }
  ORDER BY ?name

• who	name	mbox	homepage
  "Ala"	"Alicja Wesoła"	mailto:ala@work.example.org
  "Johny"@en	"Jan Mocny"	mailto:bob@oldcorp.example.org	http://strongmen.org.pl/johny/

• <?xml version="1.0"?>
  <sparql xmlns="http://www.w3.org/2005/sparql-results#">
  
    <head>
      <variable name="who"/>
      <variable name="name"/>
      <variable name="mbox"/>
      <variable name="homepage"/>
    </head>
  
    <results distinct="false" ordered="true">
      <result>
        <binding name="who"><literal>Ala</literal></binding>
        <binding name="name"><literal>Alicja wesoła</literal></binding>
        <binding name="mbox"><uri>mailto:ala@work.example.org</uri></binding>
        <binding name="homepage"><unbound/></binding>
      </result>
      <result>
        <binding name="who"><literal xml:lang="en">Johny</literal></binding>
        <binding name="name"><literal>Jan Mocny</literal></binding>
        <binding name="mbox"><uri>mailto:bob@oldcorp.example.org</uri></binding>
        <binding name="homepage"><uri>http://strongmen.org.pl/johny/</uri></binding>
      </result>
    </results>
  
  </sparql>

Informacje dla Sieci Semantycznej już istnieją w dzisiejszym Internecie.

Developers Guide to Semantic Web Toolkits — zestawienie bibliotek i „frameworków” dla kilkunastu języków programowania. Różnice:

• sposoby przechowywania informacji (pamięć, pliki, bazy danych),
• formaty serializacji grafu RDF (RDF/XML, N-Triples, Turtle, N3),
• języki zapytań (SPARQL, RDQL, SeRQL, własne),
• zakres wnioskowania (brak, RDFS, OWL),
• integracja z serwerem HTTP/RDF (brak, serwer wbudowany, osobny)
• licencje.

• import com.hp.hpl.jena.rdf.model.*;
  import com.hp.hpl.jena.vocabulary.RDF;
  
    String nsPet = "http://example.org/pets#";
    String nsVoc = "http://example.org/vocab#";
  
    Model model = ModelFactory.createDefaultModel();
    model.setNsPrefix("expet", nsPet);
    model.setNsPrefix("exvoc", nsVoc);
  
    Resource maurycy = model.createResource("http://example.org/cats/PL/OP#Maurycy");
    maurycy.addProperty(RDF.type, model.createProperty(nsPet+"Cat"));
    maurycy.addProperty(model.createProperty(nsPet+"name"), "Maurycy");
    maurycy.addProperty(model.createProperty(nsPet+"age"), model.createTypedLiteral(1.5));
    maurycy.addProperty(model.createProperty(nsPet+"mailbox"), 
                        model.createResource("mailto:maurycy.kot@gmail.com"));
  
    Bag pets = model.createBag();
    pets.add(model.createResource("http://example.org/cats/PL/OP#Kalma"));
    pets.add(model.createResource("http://example.org/rats/PL/OP/Gomez"));
    maurycy.addProperty(model.createProperty(nsVoc+"coinhabitants"), pets);
  
    model.write(System.out, "RDF/XML-ABBREV");
    model.write(System.out, "N3");
    model.write(System.out, "TURTLE");

• public void readModel() {
  
    Model model1 = ModelLoader.loadModel(m1FileName, null, null, null, "m1", null, null);
    Model model2 = ModelLoader.loadModel(m2FileName, null, null, null, "m2", null, null);
    Model model = model1.union(model2);
  
    StmtIterator iter = model.listStatements();
    while ( iter.hasNext() ) {
      Statement stmt = iter.nextStatement();
      System.out.print(decorateNode(stmt.getSubject()));
      System.out.print(" ");
      System.out.print(decorateNode(stmt.getPredicate()));
      System.out.print(" ");
      System.out.print(decorateNode(stmt.getObject()));
      System.out.println(" .");
    }
    // efekt podobny do model.write(System.out,"N-TRIPLE");
  }
  
  protected String decorateNode(RDFNode node) {
    if ( node.isURIResource() ) return "<" + node.toString() + ">";
    if ( node.isLiteral() )     return "\"" + node.toString() + "\"";
    if ( node.isAnon() )        return "_:" + node.toString();
    return  node.toString();
  }

• import com.hp.hpl.jena.query.*;  // ARQ - A query engine for Jena, implementing SPARQL
  
  String queryStr = "PREFIX foaf: <http://xmlns.com/foaf/0.1/> " +
                    "SELECT ?name ?nick ?mbox " +
                    "WHERE { ?x foaf:knows ?y . ?y foaf:name ?name . " +
                    "OPTIONAL {?y foaf:nick ?nick} . OPTIONAL {?y foaf:mbox ?mbox} . " +
                    "FILTER regex(?name, \"man\", \"i\") } ORDER BY ?name";
  
  Query query = QueryFactory.create(queryStr);
  QueryExecution qexec = QueryExecutionFactory.create(query, model);
  ResultSet results = qexec.execSelect();
  try {
   while ( results.hasNext() ) {
     QuerySolution soln = results.nextSolution();
     System.out.print(soln.getLiteral("name").getLexicalForm());
     Literal nick = soln.getLiteral("nick");
     if ( nick != null )
       System.out.print(" \"" + nick.getLexicalForm() + "\"");
     System.out.print("  ");
     RDFNode mail = soln.get("mbox");
     if ( mail != null )
       System.out.print(mail.isURIResource() ? ((Resource)mail).getURI() : mail.toString());
     System.out.println();
   }
  } finally { qexec.close(); }

• import com.hp.hpl.jena.reasoner.*;
  
  Model schema = ModelLoader.loadModel("schema.owl", null, null, null, "s", null, null);
  Model data = ModelLoader.loadModel("data.rdf", null, null, null, "d", null, null);
  
  Reasoner reasoner = ReasonerRegistry.getOWLReasoner();
  reasoner = reasoner.bindSchema(schema);
  InfModel infmodel = ModelFactory.createInfModel(reasoner, data);
  
  Resource resSubject = infmodel.getResource(resourceID);
  
  // wszystkie wyrażenia na temat obiektu
  for (StmtIterator i = infmodel.listStatements(resSubject,null,null); i.hasNext(); ) {
    Statement stmt = i.nextStatement();
    System.out.println(PrintUtil.print(stmt));
  }
  
  // czy obiekt jest szukanego typu?
  Resource resType = infmodel.getResource(classID);
  if (infmodel.contains(resSubject, RDF.type, resType)) {
    System.out.println("Obiekt rozpoznany");
  }
  

Podstawowe wymagania dla działania agentów Sieci Semantycznej zostały już zrealizowane:

• standardy zapisu informacji i ontologii (RDF, RDFS, RDF/XML, OWL — rekomendacje W3C),
• standard języka zapytań (SPARQL — Working Draft),
• „standardowe” (popularne i znane) słowniki (DC, FOAF, DOAP, SKOS, ...),
• rosnące zasoby ontologii,
• coraz mocniejsze platformy programistyczne.

Dziękuję za uwagę.