Semantic Web

LinkedData:

RDF

To read:

Where not to use RDF:

Highly granular data (like absolute expression-level changes for microarrays) might not be appropriate for conversion into RDF because it explodes the size of the dataset in a circumstance where:

  1. the dataset is generally going to be used as a whole anyway
  2. there are completely adequate parsers for existing file-formats
  3. the benefit of being able to reason over an RDF representation of the data is limited, or absent

Implementation Bootcamp

Mapping the data, which has natural horizontal representation (records in the table) into vertical representation (triples) makes sense only if all below is true:

  1. Many heterogeneous objects of similar classes are needed to be stored in the database.
  2. These classes might have some common properties, but the weight of common properties is low. That means if the objects of these classes are put into one table, the weight of table cells with NULL value should be high.
  3. It is not known, which classes/properties will appear in the future (but we know they certainly will).

Other Triple Formats

RDF Storage Engines / Libraries

RDF Mapping

Hadoop MapReduce

Benchmarks

SPARQL

To read:

Available endpoints

Federation:

OWL

OWL is based on the DL formalism. It provides a set of rich data modeling constructs like classes, class hierarchies, property hierarchies etc. Such features are used to define data schemata or ontologies for a domain, which describe entities in the domain, their properties and relationships, and constraints between them.

Converting Natural Language to RDF:

Online tools:

To read:

SKOS

To read:

Semantic desktop

Vocabulary

reification/reincation – is a form of RDF in which any RDF statement itself can be the subject or object of a triple. This means graphs can be nested as well as chained. On the Web this allows us, for example, to express doubt or support for statements created by other people. A description of RDF statement using RDF reification vocabulary is called a reification of the statement. The examples are given here and here. SeRQL example for Sesame is here.

query statements inferencer – the ability of query processor to intercept and preprocess new statements as needed to enable data semantic support (e.g. RDF), which in Sesame is implemented for SAIL7).

ontology reasoner – basically checks that ontology makes sense (consistency checking, concept satisfiability). A reasoner creates an entailment of the RDF graph.

The terms 'class' and 'subclass' also appear in the context of XML Schemas, and more generally in object-oriented programming. There is an analogy between the use of the terms in those contexts and in this one, but it is a loose analogy: the use of types in the XSchema and O-O contexts is broadly to constrain behaviour and help identify errors, whereas the corresponding assertions in the context of RDF allow a reasoner to deduce a larger volume of implicit information. In particular, RDF schemata do not function as constraints, and mistakes made when defining concepts in an ontology, or when asserting information about resources, do not manifest themselves as 'schema violations', but instead more indirectly, when a reasoner finds it is able to deduce contradictory information, for example being able to prove that some resource urn:example#X is simultaneously a Person and not a Person8).

Reasoning can be performed either when the data is loaded into the knowledge base or when a query is issued. The former class of knowledge bases, which perform reasoning when data is loaded are called materialized knowledge bases. Materialized knowledge-bases trade-off space and increased loading time for shorter query times. This approach is suited for applications domains where the frequency of data being added is much smaller than that of queries being presented. Examples of such applications are data warehouses and (for most part) web-search. Moreover, since the worst case for OWL reasoning is exponential in time and memory, this approach is often considered to be a good way to store and query OWL knowledge-bases. Most reasoning engines for OWL are implemented using either tableau algorithms or rule based/logic programming based engines. The OWL reasoners that are implemented using rule based engines, have been suggested as a practical alternative to the more correct and complete tableau algorithms. In rule based reasoners, the OWL ontology definitions are first compiled into a set of rules which are then applied on the presented data-set to create the new inferred triples. The main advantages of this class of reasoners are that they are well studied and many robust implementations exist. The disadvantages are that only a subset of the OWL specification can be implemented using them. Many popular open source (Jena) and commercial OWL toolkits (OWLIM, Oracle), are implemented using rule based reasoners.9)

entailment – the process of transforming the RDF graph by following DL rules through the unification/resolution process to its transitive closure. The process of deriving new information is sometimes called reasoning.




RDF Meta RDF Sesame W3C RDF W3C SPARQL

, , ,
1) See also Jena (framework)
2) See also JRDF (framework)
3) See release of this triple store under GNU GPL
4) , 7) SAIL stands for Storage And Inference Layer
5) SPARQL-like capability is not full SPARQL because the standard wasn't finalized at the time of Oracle Database 11g release. SPARQL support in the database is planned for the next major release.
6) See also Simple Knowledge Organization System
8) This text was taken from here
9) Quoted from Parallel Inferencing for OWL Knowledge Bases