rdf-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Knowledge Graphs and Semantic Technologies -- RDF tutorial\n",
    "\n",
    "In this tutorial we'll learn the basics of interacting with RDF graphs with Python. We'll be using rdflib for this, a widely used Ptyhon library for RDF (all documentation can be found [here](https://rdflib.readthedocs.io/en/stable/index.html))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "These are the main classes and types we'll be using from rdflib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "from rdflib import Graph, ConjunctiveGraph, Literal, BNode, Namespace, RDF, URIRef\n",
    "from rdflib.namespace import DC, FOAF\n",
    "\n",
    "import pprint\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading data remotely and from files\n",
    "\n",
    "rdflib accepts importing RDF data from a variety of sources, either locally from a file (including an extensive support of serializations), or remotely via a URI (this is a great way of checking practically if URIs return RDF according to the 3rd Linked Data principle).\n",
    "\n",
    "A Graph object is always required to load triples.\n",
    "**Note**: to load quads, and hence supporting named graphs, you'll need to use an instance of ConjunctiveGraph instead\n",
    "\n",
    "**Exercise 1** \n",
    "\n",
    "For each step, use a different cell: \n",
    "1. create two graphs using rdflib:\n",
    "    - and load one with triples from the site https://csarven.ca/ and/or http://www.w3.org/People/Berners-Lee/card \n",
    "    - load one with triples from ./data/ingredients.rdf. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TIP: look at the documentation of the rdflib library for how to LOAD and PARSE a graph - https://rdflib.readthedocs.io/en/stable/gettingstarted.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Serialising and saving RDF graphs\n",
    "\n",
    "There are different formats for storing RDF triples. Semantically, these mean the same, they differ only in their syntax. \n",
    "\n",
    "\n",
    "Use the function Graph.serialize(format). \n",
    "\n",
    "**Exercise 2**\n",
    "\n",
    "1. serialise one of the graphs to the .ttl, .xml and .nt format, and print the first n lines to compare the syntax\n",
    "1. save your graph in the turtle format to the ./data/ folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#serialize the chosen graph\n",
    "\n",
    "#save the graph in ttl format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Merging graphs\n",
    "\n",
    "Merging graphs can be done via sequential parsings or by the overloaded operator +\n",
    "\n",
    "**Note:** Set-theoretic graph semantics apply\n",
    "\n",
    "The Food knowledge graph FoodKG contains a graph of statements about ingredients, as well as a graph with statements about recipes. \n",
    "\n",
    "**Exercise 3**: \n",
    "\n",
    "1. load ./data/ingredients.rdf and ./data/ghostbusters.ttl into a single graph, either by sequential parsing or using the operator +.\n",
    "\n",
    "2. count the number of statements in each graph, and the intersection of the two graphs. \n",
    "\n",
    "3. check whether the combined graph is connected (using graph.connected()) \n",
    "\n",
    "4. load ./data/ingredients.rdf and ./data/recipes.rdf into a single graph, either by sequential parsing or using the operator +. \n",
    "\n",
    "5. count the number of statements in each graph, and the intersection of the two graphs. \n",
    "\n",
    "6. check whether the combined graph is connected (using graph.connected()). Explain the result with respect to point 3! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#look at rdflib documentation - Navigating Graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Namespaces \n",
    "\n",
    "Remind yourself what namespaces are. \n",
    "\n",
    "In RDFLib, the namespace module defines many common namespaces such as RDF, RDFS, OWL, FOAF, SKOS, etc., but you can also easily add URIs within a different namespace:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rdflib.term.URIRef('http://linkedscience.org/teach/ns#Teacher')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TEACH = Namespace(\"http://linkedscience.org/teach/ns#\")\n",
    "TEACH.Teacher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out the specification to see which other terms are used within the TEACH namespace. http://linkedscience.org/teach/ns/#sec-specification. \n",
    "You can use a NamespaceManager to bind a prefix to a namespace: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TEACH:Teacher'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = Graph()\n",
    "g.namespace_manager.bind('TEACH', URIRef('http://linkedscience.org/teach/ns#'))\n",
    "TEACH.Teacher.n3(g.namespace_manager)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rdflib.term.URIRef('http://krw.vu.nl/data#Student')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KRW = Namespace(\"http://krw.vu.nl/data#\")\n",
    "\n",
    "#creating individuals within your namespace\n",
    "KRW.Teacher\n",
    "KRW.Student"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4:**\n",
    "1. create your own namespace (can be made up) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Creating RDF triples\n",
    "\n",
    "Triples are added to the graph with the function Graph.add()\n",
    "\n",
    "The parameter is a triple given in a Python **tuple** (subject, predicate, object)\n",
    "\n",
    "Notice the namespace convenience syntax!\n",
    "\n",
    "**Exercise 5:** \n",
    "\n",
    "1. create a new graph and add triples (~10) within your made-up namespace using Graph.add(). These triples can be about anything, for instance ingredients or recipes. Make sure they include the predicates RDF.type, RDFS.label and RDFS.subClassOf\n",
    "\n",
    "2. open yourRDF.ttl, and write your triples out by hand in a syntax of your choice (turtle is recommended, notice the file extension!). Load the triples here with rdflib. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create graph\n",
    "\n",
    "#example namespace\n",
    "\n",
    "\n",
    "\n",
    "# Add triples using store's add method.\n",
    "\n",
    "\n",
    "\n",
    "#save the graph to destination in ttl format - myRDF.ttl (look at RDFLib documentation - Loading and saving RDF)\n",
    "\n",
    "#load the saved graph and print it in ttl format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Navigating graphs\n",
    "\n",
    "rdflib uses iterators to navigate Graphs. The methods for navigating subjects, predicates and objects are Graph.subjects, Graph.predicates, Graph.objects\n",
    "\n",
    "**Exercise 6:**\n",
    "\n",
    "1. print all the triples in yourRDF.ttl\n",
    "2. print all subjects in yourRDF.ttl\n",
    "3. print all predicates in yourRDF.ttl\n",
    "4. print all objects in yourRDF.ttl\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TIP you have to loop in the graph "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also filter the subjects, predicates and objects we want to retrieve, and match their values like in a database \"join\" operation\n",
    "\n",
    "\n",
    "**Exercise 7:**\n",
    "\n",
    "1. print all subject types in yourRDF.ttl\n",
    "2. print all subject labels yourRDF.ttl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic triple matching (almost querying!)\n",
    "\n",
    "We use method Graph.triples and a Python tuple that acts as a mask for specifying our criteria\n",
    "\n",
    "**Exercise 8:**\n",
    "\n",
    "1. check whether a triple is in your graph -> print true or false\n",
    "2. print all triples related to a certain subject in your graph\n",
    "3. print all triples related to a certain object in your graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restaurant Exercise - Part 1\n",
    "\n",
    "You are a chef in a restaurant, and you need to serve someone that is gluten intolerant. \n",
    "\n",
    "1. load the ./data/recipes.rdf and ./data/ingredients.rdf datasets in one graph\n",
    "2. query your graph (as we did in previous exercises) to retrieve all recipes without gluten\n",
    "3. query your graph for all recipes that you can make for your gluten intolerant guest. \n",
    "4. the guest asks you whether there are more options. Can you find the recipes for which an ingredient with gluten can be replaced, solely using pattern matching? (Hint: you need to write multiple of these pattern matching queries, and check the predicate __substitutesFor__) \n",
    "5. another guest is allergic to pecan nuts, which recipes could you serve them (including those for which pecan nuts can be replaced) \n",
    "\n",
    "**Note that this is a bit tedious: later on, we will be querying more complicated patterns with SPARQL!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HI ontology exploration\n",
    "\n",
    "In your project, you will be working with a Hybrid Intelligence (HI) ontology. This is an opportunity for you to get acquainted with its structure. Applying the skills from the exercises above perform the following actions:\n",
    "\n",
    "1. Load the HI ontology from the data folder (hi_ontology.ttl) with RDFlib.\n",
    "2. Create an \"HI\" Namespace.\n",
    "3. Count the number of triples.\n",
    "4. List all subjects.\n",
    "5. List all predicates.\n",
    "6. List all pairs of subjects and their corresponding objects linked by a rdf:type predicate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}