Course introduction

Intelligent Systems for Robotics · Week 1

What this course is

Building robots that reason, not just react.

The shape of the term

Week Topic
1Course introduction; the layered architecture; the fetch scenario
2The skill model: options, initiation sets, termination. RL fundamentals
3Training robot policies in MuJoCo; transfer to Webots
4Ontologies, RDF/OWL, description logics; modelling the apartment
5The topological map and meta-actions in the KG; grounding detections
6Classical planning: STRIPS, PDDL, state-space search, heuristics
7Planning over skills and meta-actions; hierarchy and plan quality
8Execution and monitoring; behaviour trees; blocked edge to replan
9Project work — no lecture
10Project presentations

Assessment

  • Weekly micro-projects — formative, not graded
  • Final project — code, a short report, and a presentation in week 10

The independence promise

  • Every micro-project runs from the inputs it ships with.
  • Missing week 3 does not strand you in week 6.
  • Reference artifacts are published after each deadline, in data/reference/.

Today

  • A robot that drives, sees, reaches and grips
  • A task it cannot do
  • The four layers between the two
  • Then: install it, run it, drive a square

Meet the robot

  • TIAGo — a differential-drive base, a lifting torso, a seven-joint arm
  • A Robotiq parallel gripper
  • Camera, lidar, sonar
  • All of it in Webots R2025a, on your own machine

Live: examples/01-robot-devices

The base drives. A camera frame comes back. The arm moves to a commanded configuration. The gripper closes.

That, in code


robot.drive(linear=0.2, angular=0.0)
robot.sleep(1.0)
robot.drive(linear=0.0, angular=0.0)
pose = robot.pose()

frame = robot.camera()
print(f"camera frame: {frame.shape} {frame.dtype}")

Excerpt from examples/01-robot-devices/main.py.

What the platform hands you

  • drive(linear, angular), sleep(), pose()
  • camera(), scan(), sonar()
  • set_joints({...})
  • gripper_close(), gripper_open(), gripper_stop()

Instructor-provided. You never talk to Webots directly.

The task

Somebody asks for a drink. The robot finds it — standing on a table or a worktop, somewhere in a furnished apartment — and brings it back to whoever asked.

Why that does not fetch a drink

  • How does it get across the apartment?
  • Which room is the kitchen?
  • What counts as a drink?
  • In what order?
  • What if the route is blocked?

Closing that gap

One layer at a time, and each one arrives as the answer to a question.

How does it get to the worktop?

Skills. A skill is an option:

\[ o = \langle\, \mathcal{I},\ \pi,\ \beta \,\rangle \]

  • \( \mathcal{I} \subseteq S \) — where it may start
  • \( \pi \) — what it does while it runs
  • \( \beta \) — when it stops, and whether it succeeded

Plus declared preconditions and effects.

Which are learned, which are given

Learned

  • Navigation
  • Base placement
  • Collision-free reaching

Given

  • Inverse kinematics
  • Grasping
  • Detection

The criterion: learn only what classical methods do badly.

Which room is the kitchen? What counts as a drink?

The world model.

  • Symbols the robot can ground in what it senses
  • A detector returns a can. It does not return a kitchen: a place has to be named in the graph and tied to the map.
  • A knowledge graph and an ontology — rooms, surfaces, objects, and what holds between them
  • Weeks 4 and 5

In what order?

Planning. And here is the seam:

the preconditions and effects a skill declares are exactly what the planner consumes.

What when it fails?

Execution and monitoring.

  • A skill terminates with a verdict: succeeded, or failed
  • A failed termination is what triggers replanning
  • The route to the kitchen is blocked. Now what?

The layers, assembled

Execution and monitoring Planning World model Skills Robot — isfr.robot is it still going the way the plan assumed? what order, from preconditions and effects rooms, surfaces, objects, and what holds between them options: where they may start, what they do, when they stop failure ⇒ replan

This has a name

  • You have just re-derived the three-layer architecture.
  • The opposing position: subsumption — no world model, no plan, behaviour from layered reactive control.
  • The hybrid won for tasks with a symbolic goal, because "fetch a drink" is a sentence, and something has to hold it.

Symbol grounding

The plan says drink. The camera returns pixels.

Connecting the two has a name, a literature, and a week: 5.

Situation awareness

SA level Course layer
L1 — perception of elements YOLO detections, raw sensor readings
L2 — comprehension the KG: this is a drink, on the worktop, in the kitchen
L3 — projection planning and monitoring: what the plan will do, and whether the world still matches expectation

Endsley's model describes an operator's state of knowledge, not a specification for architectural components. The mapping is a lens, not an identity.

Perception is tooling, not a topic

  • Off-the-shelf YOLO gives the robot something to ground symbols in.
  • We use object detection. We do not study it.
  • The detection is tooling. The grounding — slide 21 — is a course topic.

The architecture as built

  • isfr.robot — drive, sense, arm, gripper
  • isfr.skills — the option contract, and the skills that implement it
  • The knowledge graph — the world model
  • The planner — over skills and meta-actions
  • The executive — runs the plan, and notices when it stops being true

How your Python reaches the robot

  • isfr_bridge is a C++ controller running inside Webots.
  • It publishes raw sensor readings and accepts motor setpoints. Nothing else.
  • Your Python talks to it over a socket — and never imports controller.

So your code runs on any machine, with no Webots install and no WEBOTS_HOME.

Simulation time, not wall-clock

  • robot.sleep(1.0) waits one simulated second.
  • Run the world at half speed and the robot still drives the same distance.
  • An opt-in synchronous mode makes a command sequence reproducible run to run.

What is fixed, and what is yours

Fixed contracts — three, all term:

  • the Skill interface
  • the Atom shape for preconditions and effects
  • the ontology's base namespace

Yours: file formats, how a policy loads, how a plan step finds its skill.

Reconciling those choices is the final project.

The term, on the diagram

  • Weeks 2–3 — skills, and learning them
  • Weeks 4–5 — the world model
  • Weeks 6–7 — planning over both
  • Week 8 — execution and monitoring
  • Weeks 9–10 — your project

This week

  • Install: venv, requirements.txt, Webots R2025a
  • Run examples/01-robot-devices/
  • Micro-project: exercises/01-introduction/ — drive a closed square, then ask whether you believe the robot

Reading

  • Brooks (1991), Intelligence without representation. Artificial Intelligence 47(1–3), 139–159.
  • Gat (1998), On Three-Layer Architectures. In Artificial Intelligence and Mobile Robots, AAAI Press / MIT Press, 195–210.
  • Harnad (1990), The symbol grounding problem. Physica D 42(1–3), 335–346.
  • Endsley (1995), Toward a Theory of Situation Awareness in Dynamic Systems. Human Factors 37(1), 32–64.

Optional, not examined: background reading.