rdfs-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Knowledge Graphs and Semantic Technologies -- RDFS tutorial\n",
    "\n",
    "Here we'll learn the basics of RDFS (RDF Schema) and how to perform basic RDFS reasoning with rdflib (documentation [here](https://rdflib.readthedocs.io/en/stable/)) and owlrl (documentation [here](https://owl-rl.readthedocs.io/en/latest/))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "\n",
    "owlrl is a library implementing basic RDFS and OWL reasoning on top of rdflib. We'll install and import its relevant symbols."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install rdflib owlrl\n",
    "\n",
    "from rdflib import Graph, RDFS, RDF, URIRef\n",
    "from owlrl import DeductiveClosure, RDFS_Semantics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading RDFS graphs\n",
    "\n",
    "Your file `yourRDF.ttl` already contains a basic Knowledge Graph in RDF with some RDFS semantics\n",
    "\n",
    "First, we are going to add some RDFS semantics, and inspect the graph as-is; this is also called the \"asserted graph\"\n",
    "\n",
    "**Exercise 1** \n",
    "1. add additional triples using the RDFS semantics: have a look [here](https://www.w3.org/TR/rdf-schema/), and use domain and range, subPropertyOf, and Class, to say more about the instances in your graph\n",
    "2. load yourRDF graph\n",
    "3. print the classes in your graph\n",
    "4. print the properties of a specific class in yourRDF graph\n",
    "5. print all instances in yourRDF graph (all objects that have a type) \n",
    "6. explain what constitutes a vocabulary in RDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define graph\n",
    "\n",
    "#define example namespace\n",
    "\n",
    "#Add triples using store's add method.\n",
    "\n",
    "\n",
    "#print classes\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#print properties\n",
    "\n",
    "\n",
    "\n",
    "#print all instances\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RDFS inferencing\n",
    "\n",
    "The inference engine in owlrl is triggered by `DeductiveClosure`, which computes the closure of the graph. This requires us to specify under which semantic regime we want to perform the inference (e.g. what kind of rules under the RDFS, OWL, etc. semantics we want the reasoner to produce derivations on). For RDFS semantics we use `RDFS_Semantics` as parameter. See extra options [here](https://owl-rl.readthedocs.io/en/latest/stubs/owlrl.html#module-owlrl)\n",
    "\n",
    "\n",
    "**Exercise 2**\n",
    "1. expand the graph through RDFS semantics inference\n",
    "2. print how many triples the new graph has\n",
    "3. print out the triples in your new graph and inspect them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TIP:always look at linked documentation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The explicit (asserted) graph vs the implicit (derived) graph, and RDF entailment\n",
    "\n",
    "Asserted triples are those that are explicitly stated, while derived or inferred triples are those that are implicitly stated through the semantics of RDFS. \n",
    "\n",
    "**Exercise 3**\n",
    "\n",
    "1. Write here code to generate a graph that contains **RDFS derived triples only** from yourRDF Knowledge Graph, not the asserted ones. See a clue on rdflib graph algebra [here](https://rdflib.readthedocs.io/en/stable/merging.html)\n",
    "2. have a look at the inferred graph. Based on the RDFS semantics, explain for each triple the rule that was used to generate it.\n",
    "3. Explain the concept RDF entailment, and the types of entailment RDFS can produce\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restaurant Assignment - Part 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4**\n",
    "1. load ingredients.rdf and recipes.rdf in one graph. The graph contains types of individuals and types of relationships between them. Print all the classes and properties in the combined graph with the namespace `ind` and the `wtm` namespace/vocabulary (`http://purl.org/heals/food/`). \n",
    "\n",
    "2. extend the `ind` vocabulary (`http://purl.org/heals/ingredient/`) by creating a hierarchy of ingredients (**hint: http://purl.org/heals/ingredient/CoconutMilk rdf:subClassOf http://purl.org/heals/ingredient/PlantMilk), and make these superclasses human readable by giving them labels**) \n",
    "3. do the same for the `wtm` vocabulary: add a hierarchy of recipes as well as a hierarchy of properties (**hint: http://purl.org/heals/food/hasCookingTemperature rdf:subPropertyOf ...) \n",
    "4. print the entailed triples as we did in the previous exercise\n",
    "5. give three examples of how RDF semantics could aid the chefs in your restaurant \n",
    "    \n",
    "6. which properties and classes could you add to the `wtm` and `ind` vocabularies to further describe your recipe and ingredient knowledge graph, aiding the chefs in your restaurant?  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#In order to extend the vocabularies you have to come up with multiple examples that follows the given hierarchy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HI ontology exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In your project, you will be working with a Hybrid Intelligence (HI) ontology. After acquanting yourself with its structure in the previous tutorial, you will now expand it yourself. Using the tools from the exercises above, perform the following actions:\n",
    "\n",
    "1. Load the HI ontology from the data folder (hi_ontology.ttl) with RDFlib (don't forget to define a Namespace).\n",
    "2. Create 3 new subclasses using the rdfs:subClassOf predicate.\n",
    "3. Create at least one domain and one range restriction using rdfs.\n",
    "4. Populate each class you've created with at least one new instance each (hint: use rdf:type).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "c30f2af5f468e7f5b45bcc30fca5f4886c90d54777aed916ed5f6294dfb24bf2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}