Writing Ontologies Using Python and RDFLib

Ontologies stand as the foundation of knowledge representation, allowing us to structure and arrange information in a way that machines can comprehend. In this blog post, we will implement a simple career ontology with Python and RDFLib. If you're new to ontologies, I suggest checking out the "Creating an Ontology With Protege" blog post first to get the hang of making a basic ontology using the user-friendly tool Protege. The previous blog post will set you up nicely before diving into RDFLib's programming interface. If you haven't already, you need to install the RDFLib library using the "pip" command.

Implementation

First and foremost, let's import the necessary modules and create our graph. This graph forms the foundation for our ontology operations.

from rdflib import Graph, Namespace, RDF, RDFS, OWL, URIRef, XSD, Literal

g = Graph()

Next, we'll define some namespaces. Feel free to change the URLs to something you prefer.

# Define custom namespaces
onto = Namespace("http://example.org/ontology/")
ex = Namespace("http://example.org/resource/")

# Bind namespaces to prefixes
g.bind("onto", onto)
g.bind("ex", ex)

Once the basics are in place, we'll define our class names. Each class is a subclass of the "Thing" class. In this case, we've created four classes: Career with a subclass Web_Developer and Skills with a subclass Programming.

# Define class names
g.add((URIRef(onto["Career"]), RDF.type, OWL.Class))
g.add((URIRef(onto["Career"]), RDFS.subClassOf, OWL.Thing))

g.add((URIRef(onto["Web_Developer"]), RDF.type, OWL.Class))
g.add((URIRef(onto["Web_Developer"]), RDFS.subClassOf, URIRef(onto["Career"])))

g.add((URIRef(onto["Skills"]), RDF.type, OWL.Class))
g.add((URIRef(onto["Skills"]), RDFS.subClassOf, OWL.Thing))

g.add((URIRef(onto["Programming"]), RDF.type, OWL.Class))
g.add((URIRef(onto["Programming"]), RDFS.subClassOf, URIRef(onto["Skills"])))

We can also add individuals after we define our classes. Please note that I'm using the "ex" namespace for individuals.

# Define individuals
g.add((URIRef(ex["Expert_Javascript"]), RDF.type, URIRef(onto["Programming"])))

g.add((URIRef(ex["Expert_Web_Developer"]), RDF.type, URIRef(onto["Web_Developer"])))

To provide more information about our classes, we'll add data properties. We define our two data properties with "OWL.DatatypeProperty". Our domain for the first one is the Programming class, and for the second one, the Skills class. As the Programming class is the subclass of the Skills class, the "skill_level" property is accessible by the Programming subclass. The datatype we will use will be "string".

# Define Data Properties
g.add((URIRef(onto["aboutProgrammingLanguage"]), RDF.type, OWL.DatatypeProperty))
g.add((URIRef(onto["aboutProgrammingLanguage"]), RDFS.domain, URIRef(onto["Programming"])))
g.add((URIRef(onto["aboutProgrammingLanguage"]), RDFS.range, XSD.string))

g.add((URIRef(ex["Expert_Javascript"]), URIRef(onto["aboutProgrammingLanguage"]), Literal("Javascript")))

g.add((URIRef(onto["skill_level"]), RDF.type, OWL.DatatypeProperty))
g.add((URIRef(onto["skill_level"]), RDFS.domain, URIRef(onto["Skills"])))
g.add((URIRef(onto["skill_level"]), RDFS.range, XSD.string))

g.add((URIRef(ex["Expert_Javascript"]), URIRef(onto["skill_level"]), Literal("expert")))

Lastly, we'll define object properties. We've created the "hasSkill" object property with the "Career" domain and "Skills" range. This property helps identify that the "Expert_web_Developer" individual has the "Expert_Javascript" skill.

# Define Object Properties
g.add((URIRef(onto["hasSkill"]), RDF.type, OWL.ObjectProperty))
g.add((URIRef(onto["hasSkill"]), RDFS.domain, URIRef(onto["Career"])))
g.add((URIRef(onto["hasSkill"]), RDFS.range, URIRef(onto["Skills"])))

g.add((URIRef(ex["Expert_Web_Developer"]), URIRef(onto["hasSkill"]), URIRef(ex["Expert_Javascript"])))

Once our ontology is defined, we'll write it to a file. We'll use the XML format with the ".rdf" extension, which can be opened in Protege.

# Write ontology to file
g.serialize(destination="career.rdf", format="xml")

As we can see from the image below, we can view and make further modifications to our ontology using Protege's interface.

Conclusion

To sum up, this tutorial has equipped us to create an ontology using our programming skills. This knowledge is handy because it lets us easily add many individuals using loops if needed. Plus, having control over the process means we can create a user interface similar to Protege, tailored to our specific needs.