AI curriculum
Course outline for Semantic Web and Ontology Engineering
Make datasets share identities and explicit meanings. Encode RDF, query it with SPARQL, and express a small ontology in RDFS and OWL. Run a reasoner and explain its conclusions. Validate data separately with SHACL. Compare ontology versions without confusing absent facts, inconsistent axioms, and invalid records.
Semantic Web and Ontology Engineering Course Objectives
- Encode schema and instance triples with stable identifiers and typed values.
- Write and execute SPARQL queries over two integrated datasets.
- Model class and property axioms in a bounded OWL fragment.
- Run classification and explain an entailment and an inconsistent case.
- Distinguish open-world reasoning from explicit data-completeness constraints.
- Author and execute SHACL shapes under a declared target and inference policy.
- Compare versioned query, entailment, and validation results independently.
Pre-requisites
- Knowledge Engineering Foundations for AI Systems or equivalent entity, relation, schema, assertion, and rule knowledge.
- Read structured data and write small Python scripts or simple queries.
- Use files and a terminal; all semantic tools start from basics.
- No previous RDF, OWL, SPARQL, or description-logic experience is assumed.
Before this course
Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.
Required preparation
Recommended preparation
Readiness checks
- Knowledge Engineering Foundations for AI Systems or equivalent entity, relation, schema, assertion, and rule knowledge.
- Read structured data and write small Python scripts or simple queries.
- Use files and a terminal; all semantic tools start from basics.
- No previous RDF, OWL, SPARQL, or description-logic experience is assumed.
Knowledge Engineering Foundations for AI Systems or equivalent entity, relation, schema, assertion, and rule knowledge.
Find your place in the learning mapLab Setup
Delivery requirements: the environment, access, and exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.
Compatible stable RDFLib, Protégé/HermiT, pySHACL, Python, and two local datasets. Materials include initial Turtle, a supported-axiom reference, query harness, and version manifests without completed learner answers. Each tool starts with a minimal visible operation. Delivery requires verified Java/plugin compatibility, supported reasoning fragment, local execution, and report formats. No hosted endpoint or model account is required.
Detailed Course Outline
Module 1: Encode shared identities in RDF (2 hours)
- RDF and Turtle: RDF graphs, triples, IRIs, literals, prefixes, and Turtle syntax.
- Stable identifiers: Stable identifiers versus labels and blank-node identity limitations.
- Typed values: Typed values and explicit schema-versus-instance separation.
- RDFLib operation: RDFLib basics: create, parse, inspect, serialize, and reload.
- Shared vocabularies: Shared vocabularies and conflicting local naming conventions.
- Two-source integration: A reproducible two-source graph with provenance kept separately identifiable.
- Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.
Practical outcome: Create and reload a graph whose identifiers survive source integration.
Module 2: Ask questions with SPARQL (2 hours)
- SPARQL patterns: Triple patterns, variables, joins, filters, and result bindings.
- SELECT and ASK: SELECT and ASK with predictable local results.
- Missing values and aggregation: OPTIONAL, missing bindings, aggregation, and duplicate-result checks.
- Declared and inferred graphs: Querying declared facts versus a materialized inferred graph.
- Dataset scope: Dataset boundaries, source-qualified results, and explicit query scope.
- Independent query checks: Learner-authored relationship queries with independently checked answers.
- Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run three useful questions, including a missing-value case, and explain each result.
Module 3: State what the ontology means (2 hours)
- RDFS meanings: RDFS classes, properties, subclass relations, domain, and range.
- Protégé operation: Protégé basics: individuals, class expressions, properties, and saving.
- OWL axioms: OWL class intersection, restrictions, disjointness, and selected supported axioms.
- Description logic: Description-logic notation connected to concrete domain statements.
- Open-world assumptions: Open-world reasoning, identity assumptions, and absent assertions.
- Domain and range inference: Domain/range inference versus closed-world field rejection.
- Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.
Practical outcome: Author a small ontology and predict a type inference before running the reasoner.
Module 4: Run reasoning and inspect its limits (2 hours)
- HermiT classification: Classification with the compatible HermiT reasoner in Protégé.
- Premise-linked entailments: Asserted and inferred types with premise-linked explanations.
- Inconsistency and unsatisfiability: Inconsistency, unsatisfiable classes, and distinct diagnostic questions.
- Disjoint-type diagnosis: A disjoint-type inconsistency and correction of its premises.
- Identity alignment: Identity alignment without careless universal equivalence assertions.
- Ontology regression: Version changes and regression queries over integrated knowledge.
- Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.
Practical outcome: Execute classification, reproduce a supported entailment, and diagnose an actual inconsistent ontology.
Module 5: Validate records without rewriting ontology semantics (2 hours)
- SHACL shapes: SHACL shapes, targets, paths, cardinality, datatype, and value constraints.
- pySHACL operation: pySHACL basics and readable validation reports.
- Targets and inference policy: Explicit data graph, target scope, and inference configuration.
- Completeness and consistency: Missing required values versus ontology inconsistency.
- Negative validation cases: Learner-authored shapes and new negative test records.
- Separate regression reports: Separate query, reasoner, and validation regression reports.
- Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run a completeness check and explain why its result differs from open-world reasoning.
Practical exercise
- Build a role-and-skills ontology from two synthetic datasets. Define stable IRIs, typed values, classes, properties, and source mappings. Use RDFLib to load and serialize Turtle. Author three SPARQL queries covering a relationship join, missing value, and aggregate or existence question. Record actual query results.
- In Protégé, author a bounded class restriction and disjointness axiom. Predict and then run a supported type inference with HermiT. Introduce an individual with incompatible disjoint types and inspect the reasoner's actual consistency result. Separately distinguish an unsatisfiable class from an inconsistent ontology. Remove the bad assertion and rerun. Missing assertions alone are not automatically false, and different names do not automatically prove distinctness.
- Author SHACL shapes for a required identifier and typed value. Run pySHACL with declared targets and inference settings. Demonstrate that a missing field can fail validation without creating the OWL inconsistency. Do not run consistency claims against a graph whose semantics the chosen reasoner does not support.
- Change one ontology axiom and one input source. Compare fixed queries, entailed types, and SHACL results across both versions. Preserve manifests and actual outputs. Add one independent learner-designed negative case before seeing its feedback. The reasoner and validator reports must remain distinct artifacts.
Delivery and timing
- Guided hours include teaching, demonstrations, learner practice, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite setup are additional. Allocations need a timed learner pilot before delivery; they are not measured completion times.
What you will produce
Encode RDF, query SPARQL, run ontology reasoning, and validate records separately with SHACL.
How the work is checked
- Identity mappings preserve meaning rather than matching labels blindly.
- Learner-authored SPARQL runs and returns independently checked answers.
- Axioms stay inside the selected reasoner's supported fragment.
- Actual classification and inconsistency results have correct explanations.
- Missing data, unsatisfiable classes, and inconsistency are distinguished.
- Learner-authored shapes execute under a documented target/inference policy.
- Version differences remain reproducible across three separate result sets.
10 guided hours. Actual RDFLib, SPARQL, Protégé/HermiT reasoning, and pySHACL validation are required. Description logic is limited to the supported axioms used. Missing data, unsatisfiable classes, and inconsistency are distinct. SHACL checks declared graphs and targets, not universal truth. Stable tool/plugin compatibility must be verified before delivery; no worksheet replaces required runtime operation.
When another approach is better
- Prefer a simpler schema when shared semantic inference is not needed.
- Do not use OWL alone to enforce closed-world record completeness or treat approximate matches as identical entities.
How we train
Contact us for full course details, including duration, delivery options and lab requirements.
Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.
Discuss your learning goalsRelated Courses
These courses list this course as preparation.