Mastering the Semantic Web: From RDF to Knowledge Graphs

Explore how RDF enables modeling any information form and building interlinked information structures with Linked Data on the semantic web, then build your first RDF graph in the upcoming lessons.

Learn to set up a semantic web development environment with a code editor, RDF formats like Turtle, and a local Graphdb triplestore to build and analyze ontologies and knowledge graphs.

Defines RDF triples as subject-predicate-object constructs that encode any information, explains resources and statements, and demonstrates graph construction through the Kingdom of Heaven example.

Create your first RDF triple in Graphdb by building a repository, importing a text snippet, and visualizing Kingdom of Heaven has actor Orlando Bloom in a named graph.

Map prefixes to namespaces in a turtle file to create readable RDF triples, then import them into GraphDB to visualize relationships like Kingdom of Heaven, Orlando Bloom, and occupations.

Learn to use the rdf:type predicate to classify resources as instances of a class in RDF, and manage namespaces and graphdb imports to keep only rdf:type.

Explore turtle syntax for RDF graphs, using semicolons and commas to structure statements, assign RDF type, and organize predicates under subjects for clear, readable knowledge graphs.

Explore literals in rdf turtle syntax and how they act as objects, not subjects. Use language tags and xsd data types with quoted literals, such as release year 2005.

Learn how blank nodes enable anonymous resources in RDF graphs, model them with turtle syntax, and compare unnested and nested blank nodes using movie reviews as examples.

Explore modeling ordered and unordered RDF collections using RDF list with first and rest, or RDF nil, and compare to bracket syntax in Turtle.

Explore RDF reification to treat statements as resources, linking them via subject, predicate, and object, and assess its complexity, performance, and alternatives like RDF star and Neo4j.

RDF structures data as graphs with nodes and edges and has no fixed schema, enabling flexible modification; relational databases use fixed tables for known data, while RDF suits unstructured data.

Discover how querying RDF graphs unlocks data utility, learn Sparql basics, and start building an ontology app with Sparql queries and Python scripts.

Explore Sparql, the query language and protocol of the semantic web; learn to query and update Rdf graphs via a Sparql endpoint, using a movie base, Dbpedia, and Wikidata.

Master the structure of a SPARQL query, learning its building blocks—prefixes, query result clause, and query pattern—and how variables and where clauses produce results from RDF data.

Create and execute your first SPARQL query on a dbpedia-based RDF graph, importing a turtle file, and retrieve all films with their release dates.

Learn how to refine semantic web queries with filter, optional, union, and values clauses to retrieve films by runtime, director, or genre, demonstrated with concrete examples.

Explore SPARQL query modifiers that influence results after the pattern, including distinct, limit, order by, and offset, with Dbpedia examples and label-based filtering.

Create a semantic web app that searches film data from DBpedia using SPARQL, with Streamlit for the front end and a SPARQL wrapper for the back end.

Set up the Sparql app environment by creating a project folder, installing Python 3.11.2, creating and activating a virtual environment in VSCode, and installing sparkle wrapper and streamlit.

Run a select query with the Sparql wrapper in Python against Dbpedia to fetch film titles, using distinct, English language filter, regex, and a ten results limit, returning json.

Refactor the spark wrapper into a reusable Python function for running SPARQL queries and move the query to a separate file in a spark folder for flexibility.

Develop a graphical user interface using Streamlit to search films, display results in a pandas data frame, and learn to wire text input, a search button, and sparql query results.

Learn sparkle aggregate functions to process query data, including count, sum, and group by, with Dracula film examples and a regex filter for English titles on Dbpedia sparql.

Learn how to merge Sparql queries with subqueries to count films using the count aggregate function, and pass the result to the main query via bracelets.

Explore ask queries in SPARQL to check data existence without downloading triples, returning true or false to guide subsequent select queries on Dbpedia.

Explore how sparql construct and describe queries retrieve fully intact rdf graphs from a large triplestore, using turtle format.

Explore how sparql functions query rdf graphs and build rdf applications, and practice on a film triple store to deepen mastery beyond videos.

Explore how RDF and Spark power building and querying graph databases, model knowledge graphs and ontologies, and apply RDF extensions like RDFS for reasoning over semantics.

Use Rdfs classes to type and categorize data, build a Tbox and Abox in Graphdb, and let a reasoner infer entities like film and vehicle.

Apply rdfs label and rdfs comment to tbox resources to provide multilingual language-tagged, human readable names and descriptions, and use see also to link to related information.

Complete the t box by defining classes and properties used by the a box, including release date, genre, and runtime for dbl film, set s domain and rdf s range.

Map JSON data to RDF using RDFLib in Python, building a graph, binding namespaces, and encoding titles, directors, genres into a knowledge graph from relational data via an API.

Explore how RDF compares with property graph databases like Neo4j and TigerGraph, highlighting RDF's W3C standards, openness, and backward-compatible evolution that support semantic web applications.

Compare how the World Wide Web and the Semantic Web use URIs: web localization versus Semantic identification, and introduce the RDF framework for giving resources meaning.

Discover how to build an owl tbox with owl classes and individuals, define subclass hierarchies, and manage prefixes and imports in Protege and a box.

Explore equivalence and equality in ontologies, linking classes via owl equivalent class and individuals via owl same as, while applying disjointness, reasoning, and visualization in the tbox and abox.

Explore datatype properties and object properties in owl. Datatype properties have literals; object properties link to individuals with unique URIs, and we will define them in the tbox.

Define and apply data type properties in the Tbox and create custom data types in Protégé, including release date and runtime with domains, ranges, and Dbpedia equivalences.

Learn to create object properties for the film domain, define director, actor, and genre with DBpedia equivalents, and define inverse properties like directs and acts in to enable reasoning.

Learn about symmetric object properties with the has collaborated with example, showing inferred collaborations between Michael Keaton and Edward Norton, and apply this in Protégé and turtle and Owl definitions.

Master property chain axioms in OWL to infer new relations from two statements. Apply these chains to the tbox and abox to reveal actor and director collaborations.

Explore how functional properties constrain ontologies to a single value per instance, with data vs object properties, reasoner effects, and examples using runtime, release date, and has director.

Discover annotation properties as a subclass of RDF properties and add labels and comments. Apply language tags, create custom annotations, and use Dublin Core to describe the ontology header.

Explore cardinality restrictions to infer classes from properties, such as actors who act in at least one thing, and use the Manchester syntax to define actor director.

Explore Protégé to define SWRL rules that extend OWL axioms, infer excessively long movies from runtime, and map rules to Drools for reasoning.

Learn to process owl ontologies in python using owlready2: load tbox, abox, and alignment, reason to infer the a box, and save the inferred a box in RDF XML.

Explore the difference between ontologies and knowledge graphs, with a focus on OWL ontologies and graph-based structures, clarifying how every knowledge graph is an ontology but not vice versa.

Explore a handy tool for checking RDF graphs and learn how to define and apply complex rules reflecting business logic in an ontology using SHACL.

Explore SHACL, or shackle, the shapes constraint language, to define ontology constraints on RDF graphs and automatically validate them against a triple store under the closed world assumption.

Create your first shackle shape by defining a node shape for movies, attach a director property shape with min count one, and validate using shackle tools or pi shackle script.

Learn to use qualified value shapes to enforce complex cardinality in shackle, nesting property shapes and node shapes, with practical turtle code and validation examples.

Learn to build complex SHACL shapes by combining simple property shapes with and, or, and not, using pattern checks and qualified value shapes to validate genres and runtimes.

Apply sparkle based constraints in SHACL to enforce that actors appear in films with a total runtime of at least 100 minutes, using SPARQL constraints and subqueries.

Apply shackle advanced features to transform sparkle rules into triple rules that infer actors’ total runtime from their movies, using sparql functions and in-place inference with conditions.

Discover the benefits of shacl, including modular, reusable shapes and rule components, and validate both rdf graphs and the shacl graph, supported by rdf triple stores and tooling.

Conclude the final chapter by engaging in the full ontology design process—building a smart recipe ontology as a knowledge engineer and publishing it with best practices.

Identify ontology use cases and requirements using competency questions, natural language statements, and tabular information; document purpose, scope, data exchange, and functional and non-functional requirements.

Develop a simple ontology for cooking recipes as a knowledge model to enable querying by criteria such as vegan options and calorie counts, with steps and ingredients in English.

Apply best practices for ontology implementation in OWL, from Abox design to Tbox alignment, encoding in RDF or Turtle and validating with SPARQL queries, emphasizing reuse and semantic precision.

Explore building a reusable recipe ontology by designing an abox and tbox, mapping recipe steps, ingredients, quantities, and calories, and verifying with sparql queries.

Transition from the ultimate ontology course to the ultimate introduction to ontologies, and stay engaged with the Semantic Web community to apply knowledge to knowledge graphs.