A postgraduate module on building robots that reason, not just react. The course pairs symbolic artificial intelligence (classical planning, knowledge graphs, ontologies) with the learned and perceptual components of a modern robot stack, such as neural object detection and reinforcement learning.
The course is built bottom-up. We start from skills, the robot's basic competences, learned with reinforcement learning. We then give the robot a knowledge representation rich enough to describe both the world and meta-actions, which are compositions of basic skills authored in a knowledge graph. Finally we plan over skills and meta-actions, and execute those plans under monitoring.
The thread running through the term is the seam between the learned and the symbolic, meaning what a skill must expose about itself before a planner can reason with it. Most courses teach these halves separately. Here they are taught as one problem, because that seam is where real robot systems break.
The running scenario is a fetch task: the robot is asked for a drink, finds it standing on a table or worktop somewhere in a furnished apartment, and brings it back to whoever asked.
Each lecture has a runnable example and a micro-project in the Webots simulator. These accumulate into the final project, a robot with a small library of learned skills, a knowledge graph describing its world and the meta-actions it can compose, and a planner that puts those together into behaviour that survives contact with an uncooperative environment.
Perception is a tool here, not a topic. We use off-the-shelf object detection so the robot has something to ground its symbols in; we do not study detection itself.
The project carries the assessment. It is marked on two things. The first is integration, meaning how far separately built parts have been made into one system. The second is the understanding you can demonstrate of why your system is put together the way it is.
You need Webots R2025a to run the simulator, and Python 3.10 or newer. The
course repository is on the
KU Leuven GitLab, which signs you in through the university's single sign-on. Cloning
over HTTPS therefore does not work, so clone over SSH. Add an SSH key to your GitLab
account first, following GitLab's guide.
Without one, the clone fails with Permission denied (publickey). Then clone
and set up:
git clone git@gitlab.kuleuven.be:u0129795/isfr2627.git
cd isfr2627
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python3 -c "import isfr; print('course package OK')"
That is the whole Python setup. Your code talks to the simulator over a network socket
rather than importing anything from Webots, so nothing here needs
WEBOTS_HOME or a Webots-supplied interpreter.
If import isfr fails, the package is not missing. It lives in this
checkout and is found through PYTHONPATH. Run Python from the repository
root, or source scripts/webots-env.sh, which adds it. Week 1 walks through
all of this and ends with a smoke test that drives the robot.
Intelligent Systems for Robotics · course materials