Weiteres Beispiel zur Datenkompression mit grounded language

 Im vorherigen Blogpost wurde bereits ein Lagerroboter als Beispiel erwähnt. In diesem Post soll die Thematik Datenkompression vertieft werden.

Ausgangspunkt ist das Problem in der klassischen KI Forschung bis ca. 2010, dass ein Roboter in einem sehr großen Zustandsraum agiert der sich nicht effizient mittels vorhandener Hardware durchsuchen lässt. Diese Problemklasse wird als np hard problem bezeichnet und betrifft motion planning, senor perception und STeuerung von Robotern ganz allgemein.

Obwohl die Informatik über hunderte von Algorithmen, Programmiersprachen, und schnellen CPU ist verfügt ist keine Technologie mächtig genug Probleme mit einem sehr großen Zusttandsraum zu lösen. Damit ist Künstliche Intelligenz unlösbar.

Die einzige Ausnahme besteht darin, das Ausgangsproblem in ein niedrig-dimensionales Prolbem zu überführen, natürliche Sprache dient dazu als kompressionstechnik. Für den erwähnten warehouse roboter bietet sich eine Minivokablur an, was Zielorte und Ereignisse beinhaltet:

Zielorter: regalA, regalB, Korridor
Ereignisse: Kollison, Batterie_leer, ziel_erreicht

Die Vokabelliste definiert einen neuen Zustandsraum auf einem symbolischen Level. Er besteht aus 6 möglichen Worten und abstrahiert vom ursprünglichen Zustandsraum. Die Frage ist nicht länger wie man die Kamerabilder des Roboters speichert, oder wieviele Anzahl möglicher Trajektorien es gibt, sondern die Frage ist welche der 6 Wörter gerade aktiv ist.

Der neue sprachliche Zustandsraum kann viel leichter auf einem Roboter gespeichert werden. Man speichert die Vokabelliste in einer Tabelle und kann darauf referenzieren. Damit wird die ursprüngliche Problembeschreibung modifiziert. Es geht nicht länger darum einen Lagerroboter zu steuern der über eine hochauflösende Kameras und mehrere Servo-M;otoren verfügt sondern das neue problem ist, die ist situation des Roboter mittels Natürlicher Sprache zu beschreiben.

Eine Analogie aus der Nicht informatik ist eine Landkarte. Karten werden dazu verwendet größere Gebiete übersichtlich darzustellen. Ein Gebiet wie z.B. ein Wald sind auf einer Karte mit einem einfachen Symbol markiert. Obwohl der Wald über hunderte von Bäumen enthält sind diese nicht eingezeichnet sondern es gibt nur ein grünes Rechteck mit dem Symbol "Wald". Erst der Rezipient der Landkarte dekodiert die Information und schließt aus dem Symbol auf die ursprüngliche Realität. Dadurch reduzieren Landkartieren die Komplexität der Wirklichkeit.

Technisch gesehen lässt sich grounded language für Roboter erstuanlich einfach implementieren. Man extrahiert aus einer Szene zuerst Features und konvertiert diese dann in einen Text. Der Programmieraufwand in lines of code ist überschaubar und die benötigte CPU Leistung ist gering. Dennoch waren solche Systeme vor 2010 selten bis gar nicht vorhanden. Weniger aus technischen Gründen als vielmehr aus einem mangelnden Verständnis für das Symbol grounding problem. Bis 2010 war zwar bekannt, dass KI Probleme np hard sind und der state space zu groß ist um diesen zu durchsuchen, es war allerdings unklar, dass natürliche Sprache darauf die Antwort ist. Was stattdessen untersucht wurde, waren heuristiken, Reward Funktionen und sampling basierte Algorithmen wie RRT.

Mit diesen Verfahren konnte man Fortschritte bei motion planning realisieren, allerdings waren das unbedeutende Detailverbesserungen. Der Durchbruch erfolgte erst, durch Verwendung natürlicher Sprache als Abstraktionsmechanismus. 

Datenkompression mit grounded language an einem Beispiel

 Das Hauptproblem in der KI Forschung bis 1990 war das state space problem, also die Hohe Anzahl möglicher Zustände eines Systems. Das state space problem verhinderte das KI Probleme wie Motion planning von einem Computer in echtzeit gelöst werden konnten. Die vorhandenne Algorithmen waren nicht effizient genug und die vorhandene Hardware war zu langsam.

Die Antwort besteht in der Datenkompression mit Hilfe von grounded lanugage. Sprachw wird verwendet als Karte die über die Domäne gelegt wird. Dazu ein Beispiel: Angenommen die lagerhaus wird in einer 800x600=480000 pixel großen Übersicht gespeichert. In diesem Beispiel gibt es eindeutig ein state space problem weil die Anzahl von rund 0.5 Mio unterschiedliche Pixel die aus verschiedenen Farben bestehen eine sehr große Last erzeugt. Um diesen Rohdaten Objekte oder Wege zu erkennen bräuchte man Supercomputer. Mittels semantischer Datenkompression lässt sich die Aufgabe vereinfachen. Zuerst definiert man eine Vokabelliste (RegalA, RegalB, Korridor), dann definiert man Bereiche in der Karte auf die diese Vokabeln zutreffen. Man erhält dadurch eine annotierte 2d Karte.

In dieser neuen Realität ist das state space problem gelöst. Der Roboter kennt lediglich drei Begriffe "RegelA, RegalB, Korridor" und kann ermitteln wo er sich befindet. Durch eine Karte wurde also die hochkomplexe Wirklichkeit stark komprimiert und lässt sich leichter maschinenlesbar speichern.

Man kann also sagen, dass natürliche Sprache zur Datenkompression verwendet wird. Durch cid Vergabe von Begriffen werden 2d-Bereiche oder Events in der Ausgangsdomäne gelabelt. Diese Label dienen als Platzhalter wodurch Komplexität gesenkt wird. Der Boboter benötigt nicht länger die Information über die 800x600 Pixelkarte selber sondern er referenziert mit hilfe der Vokabelliste viel effizineter auf die wirklichkeit.

KI durch Kompression

Bereits 1973 hat James Lighthill erkannt, dass Künstliche Intelligence an der kombinatorischen Explosion scheitert. Gemeint ist, dass dass z.B. ein Lagerroboter einen sehr großen Zustandsraum besitzt mit Millionen von unterschiedlichen Aktionsmöglichkeiten. Diesen Zustandsraum mittels Computer zu durchsuchen ist mathematisch unmöglich, in der Informatik wird das als NP harte Problemklasse bezeichnet. Das Grundproblem, womit sich Generationen von KI Forschern konfrontiert sahen, war also die Suche in einem riesigen Zustandsraum. 

Die Antwort auf die Fragestellung besteht darin, natürliche Sprache als Kompression zu nutzen. Damit lässt sich der Zustandsraum eines Roboters verkleinern. Dieses Konzept ist als Symbol grounding problem bekannt und meint, dass der originale Zustandsraum bestehend aus Sensorwerten und Servomotoren-Signalen mittels natürlicher Sprache kartiert wird und dann von Computern verarbeitet wird.

Ein Lagerroboter hat nicht länger Millionen möglicher Trajektorien, die es durchzuprobieren gilt, sondern die Welt des Lagerroboters besteht aus einer Vokabelliste von weniger als 50 Worten womit er die Umgebung analysiert und Handlungen ausführt. Dieser diskerete Symbolvorrat reduziert den Zustandsraum und eine maschinelle Speicherung inkl. dem Planen von Handlungen wird möglich.

Piano movers problem with head up display including inner speech

  

The piano movers problem is one of the milestone subjects in the history of motion planning and was discussed frequently. Common knowledge until 2010 was that its an example for np hard problems, that the state space is very large and its very difficult to solve the problem with existing algorithms like RRT.

Instead of discussing the issue only from a mathematical and algorithmic standpoint there is need to introduce natural language as communication code between the low level task and a high level external oracle who gives advice what to do next. Such an interface can be realized as a head up display. The graphical area on top shows the classical piano movers problem as a 2d rendering, while the textual widget on the bottom shows the comments from the external oracle which monitors the scene.

The external oracle can be located outside of the robot or it can be embedded inside the robot than its called the inner voice of the robot. In the example it generates speech for observation, goal and action. This translates the piano movers problem into a an abstract textual problem similar to an interactive fiction story. 

Wie man grounded language implementiert, Schritt für Schritt

Zuerst definiert man eine Vokabellliste die für das Problem angemessen ist. Bei einem Minimalbeispiel soll ein Roboter sich auf einem Graph bewegen. Typische Vokabeln sind:
nord, osten, süden, westen, rot, grün, blau, wegpunkt, schnell, langsam, stop

Im nächsten Schritt wird ein Bild zu Text Parser programmiert, dieser erzeugt eine textuelle Beschreibung für die aktuelle Situation. Eine Beispielausgabe wäre:
"Roboter ist im Norden, nahe des grünen Wegpunktes. Er bewegt sich schnell"
oder "Roboter ist im Süden, nahe des roten Wegpunktes. Er hat gestoppt".

Selbstverständlich ist diese Textausgabe nicht sehr eloquent und basiert auf einer einfachen Template die mit aktuellen Werten gefüllt wird. Aber das ist akzeptabel, wichtig ist dass überhaupt eine Textausgabe stattfindet.

Um den umgekehrten Kommunikationsweg von einem Kommando zu einer Aktion zu implementieren benötigt man eine Reward Funktion. Ein Kommando wie "gehe nach NOrden" wird in einen SCore umgerechnet. Wenn der Roboter im Norden angekommen ist beträgt sein Score 1.0 wenn er weit davon entfernt ist nur 0.0".

Damit stehen alle wichtigen Elemente zur Verfügung um mit dem Roboer in natürlicher Sprache zu kommunizieren. Der Roboter beschreibt die aktuelle als Text und reagiert auf Kommanddos. Zumindest für die eingeschränkte Domäne des "Roboter auf einem Graph" Problems ist damit eine Kommunikation zwischen Roboter und menschlichem Bediener möglich.

Mit Hilfe dieser Kommunikation kann man komplexe Aufgaben automatisieren. man sendet z.B. eine Befehlsfolge an den Roboter:
"1. fahre nach Norden, suche den grünen WEgpunkt, warte dort.
2. dann fahre nach Süden zum Roten Wegpunkt. und zwar schnell"

Diese Kommandos übersetzt der Roboter zuerst in einen Reward und nutzt den Reward dann um Aktionen auszuführen. Während er das tut beschreibt der Roboter in der Logdatei was er gerade macht also wo er ist, was er sieht und was die nächsten Schritte sind.

History of the symbol grounding problem

 Symbol grounding is a multidisciplinary approach which has evolved over years. The follwoing timeline shows the milestones during the development. First important innovation was the invention of written language thousands of years ago, in the year 1844 the morse code was invented to transmit signs over distance. In 1968, the SHDRLU project was initiated which was a text to graphics interface on a computer. In 1991 Rodney brooks recognized that robots need to interact with the environment, in 2003 a voice controlled robot was built by Deb Roy and in the year 2023 the Lingo-1 Vision language model was published for controlling self driving cars.

The shared similarity between these innovations is the focus on natural language for connecting two systems. A speaker sends a command to a hearer. Implementing such an interface on a computer allows to teleoperate a robot with language. This is the precondition for automation. 

The crucial building block for symbol grounding is natural language which is used as a reference system to the external world. Thanks to predefined words for objects and activities its possible to label sensory data and receive high level commands. A robot can recognizhe that he stands in front of an obstacle, and a human operator can submit a commoand to the robot like "move around the obstacle to the left". It took decades and even centuries until human researchers have discovered the power of natural language and were able to implement textual interface for robots. Its likely that future robots invented in 20 years from now will work with the same principle.

3300 BC,Cuneiform writing system in Mesopotamia
1500 BC,sundial showing the time of the day
600 BC,Latin alphabet available in Italy
322 BC,correspondence theory of truth by Aristotle
1386,Salisbury Cathedral tower clock with a bell
1440,printing press by Johannes Gutenberg
1505,Pomander Watch by Peter Henlein
1792,optical telegraph by Claude Chappe
1844,morse code by Samuel Morse
1870,Engine Order Telegraph by William Chadburn
1876,commercial typewriter by Remington
1878,chronophotography "The Horse in Motion" by Eadweard Muybridge
1903,Telekino remote controlled boat by Leonardo Quevedo
1915,Therblig notation by Frank Gilbreth
1915,rotoscoping animation technique by Max Fleischer 
1920,AAC Communication board by F. Hall Roe
1928,Labanotation dance notation by Rudolf von Laban
1929,Televox robot by Westinghouse
1930,motion tracking by Nikolai Bernstein
1949,Turing test by Alan Turing
1954,Georgetown-IBM Experiment with russian translation
1959,Pandemonium architecture by Oliver Selfridge
1962,ANIMAC motion capture by Lee Harrison III
1963,ASCII code
1966,ELIZA chatbot by Joseph Weizenbaum
1968,SHRDLU natural language understanding by Terry Winograd
1971,Lexigram for communicating with apes by Ernst von Glasersfeld
1977,Zork I text adventure by Tim Anderson
1977,Tour model instruction following by Benjamin Kuipers MIT AI lab
1980,Chinese room argument by John Searle
1980,Commentator scene description by Bengt Sigurd
1980,Finite State machine in Pacman videogame by Tōru Iwatani
1981,Karel the robot programming language by Richard Pattis
1983,MIDI music protocol
1983,M.I.T. Graphical Marionette by Delle Maxwell
1984,Castle Adventure by Kevin Bales
1987,Maniac Mansion point&click adventure by Ron Gilbert
1987,Vitra visual translator by Wolfgang Wahlster
1989,Speech activated manipulator SAM by Michael Brown
1990,Physical Grounding Hypothesis by Rodney Brooks
1990,paper "The symbol grounding problem" by Stevan Harnad
1991,paper "Intelligence without Representation" by Rodney Brooks
1993,AnimNL computeranimation by Norman Badler
1993,conceptual spaces by Peter Gardenfors
1994,Abigail scene recognition by Jeffrey Siskind
1996,Interaction machines by Peter Wegner
1998,Rocco Robocup commentator by Dirk Voelz
1999,trec-8 Text Retrieval Conference
2000 Kismet social robot by Cynthia Breazeal M.I.T.
2003,M.I.T. Ripley robot by Deb Roy
2006,Marco route instruction following by Matt MacMahon
2007,Simbicon computer animation by Michiel Panne
2010,Motion grammar by Mike Stilman
2010,M.I.T. forklift by Stefanie Tellex
2011,IBM Watson Question answering by David Ferrucci
2013,Word2vec algorithm by Tomas Mikolov
2015,Poeticon++ trajectory recognition by Yiannis Aloimonos
2015,DAQUAR VQA dataset by Mateusz Malinowski
2017,Transformer Architecture by Ashish Vaswani
2020,Vision language model by different authors
2023,Wayve Lingo-1 self driving car

Sprachspiele im Kontext von Robotik

Die Erforschung künstlicher Intelligenz drehte sich lange Zeit um die Frage welche Art von Softwareframework, Algorithmus oder Programmiersprache benötigt wird um denkende Maschinen zu realisieren. Die Annahme hinter dem Cyc Projekt von Douglas Lenat lautete, dass eine Ontologie der Grundbaustein sei, das Cam-Brain Projekt von Hugo de Garis unterstellte dass im Kern ein neuronales Netz benötigt wird während Edward Feigenbaum vermutete dass sich Künstliche Intelligenz mit Hilfe von Expertensystemen realisieren läst.

Im Laufe der Zeit wurden sehr viele gegensätzliche Technologien und Annahmen entwickelt um Künstliche Intelligenz zu verwirklichen. Ein Sprachspiel im Sinne von Ludwig Wittgenstein ist nur ein weiterer Vorschlag unter vielen. Dennoch lohnt es sich, das Thema nähter zu untersuchen. Weil das Prinzip von Sprachspielen deutlich anders ist als z.b. ein Expertensystem oder ein neuronales Netz.

Sprachspiele sind ein formalisiertes Interface zwischen interner und externer Realität von Systemen. Es ist ein Test, ob die Spielteilnehmer Sprache erzeugen und verstehen mit derer man die externe Realität beschreibt. Ein typisches Beispiel ist das "Ich sehe was du nicht siehst Spiel". Dabei beschreibt Person A ein Objekt aus der Realität anhand von Eigenschaften, er formuliert aussagen wie "das Objekt ist rund, steht in der Küche, hat Beine" und daraus folgert Person B "es ist ein Tisch".

Die Gemeinsamkeit von allen Sprachspielen ist, dass Sprache in einem interkationsspiel genutzt wird um auf die Wirklichkeit zu referenzieren. Es geht immer darum, Dinge abzufragen die in der Realität vorkommen, Anweisungen geben was in der Realität zu tun ist oder sonstwie Sprache und Wirklichkeit in Beziehung zu setzen. Sprachspiele sind eine gute Möglichkeit eine Fremdsprache zu erlernen und dienen dazu den Wissensstand zu erfassen. Wenn eine Person oder ein Computer in einem Sprachspiel eine hohe Punktzahl erreicht, ist diese Person mit der jeweiligen Sprache vertraut.

Anders als die eingangs erwähnten Technologie zur Realisierung von künstlicher Intelligenz wie Onotologien oder Expertensysteme sind Sprachspiele nicht technisch definiert sondern haben ihren Ursprung in der Philosophie und der Linguistik. Es geht um Themen wie interaktivität, Sprache, Wirklichkeit. Die Annahme lautet dass innerhalb dieser Begriffe Künstliche Intelligenz möglich ist, das also denkende Maschinen ein Interface zwischen internem System und externer Realität sind.

Seit den 1980er wurden Brettspiele als Testumgebung für denkende Maschinen genutzt. Schach ist ein sehr altes Beispiel für das Künstliche Intelligenz realisiert wurde, aber auch andere Spiele wie Tic Tac Toe, Dame, Backgammon und Go sind klassische Umgebung zur Erforschung von KI Algorithmen. Leider haben diese Brettspiele den Nachteil dass sie nicht gut nach oben skalieren. Ein Computer der perfekt Schach spielt ist nicht automatisch im Stande einen Roboter zu steuern. Deshalb eignen sich die erwähnten Brettspiele nur sehr eingeschränkt dazu KI näher zu erforschen.

Sprachspiele kann man als neuartiges Gesellschaftsspiel verstehen was ähnlich wie Schach Regeln folgt aber viel besser nach oben skaliert. Ein Computer der das "Guess what" Sprachspiel beherscht ist zugleich auch in der Lage mit diesem Wissen einen Roboter zu steuern. Scheinbar können Sprachspiele die Kernidee von Künstlicher Intelligenz viel besser formalisieren als frühere Brettspiele.

Engine for grounded language

One possible explanation why the symbol grounding problem has emerged late in the history of computer science is because the theory is difficult to realize on a computer. Suppose natural language is important for robot control, the problem is create a language parser which is working for a concrete domain.

A possible command for a robot might be "Move until obstacle and then stop". Each of the words is stored as a string, but it remains unclear who to process the instruction into actions for a robot. The reason is, that the sentence is formulated in English but computers need a programming language as input. Even if every word is encoded as a number, it doesn't make sense to submit an array with numbers to the robot because its not possible to add or subtract the values in a meaningful way.

In general the problem is how to convert natural language into a computer program. Without solving this issue, the symbol grounding problem remains only a philosophical problem without any practical consequences.

The good news is, that the problem of programming a parser can be solved. Not with tools from computer science but by using techniques from linguistics, namely language games. Instead of treating language parsing as an algorithm problem, the idea is to invent around words a puzzle game. Typical language games are:

- Name guessing game. Player1 points to an object in the reality, and Player2 has to tell the name
- NPC quest game, a non player character in a role playing game formulates a quest like "bring me the sword from the wood" and the player has to fulfill the task
- bounding box game, player1 says a word like "table" and player2 has to draw a bounding box around this object

All these language games are located outside of computer science. They have nothing to do with algorithms, programming language nor existing robotics libraries, but they are games played with 2 human players.

The interesting situation is, that its possible to simulate the games with a computer. The software encodes the rules of the language game, determines the score for the human player and then the player can take action inside this game.

The problem is not how to program a certain parser, but the problem is how to formulate the game outside of a computer first. A well formulated game can be implemented in a software with ease. The programmer needs only the specification of the game including its rule, and then its possible to program the game with python. The only requirement is, that the computer works like the original language game. The programming workflow is identical to implement card games and board games on a computer.

Practical demonstration of the Total turing test

Stevan Harnad coined around the year 1990 the term "total turing test" which is a philosophical description of an instruction following task in robotics. What is missing is a practical demonstration of such a test for a real robot.

Such a demonstration can be realized in a simple video game modeled as a language game. An entry level example is a navigation task in a graph. There are 8 nodes connected with lines and the robot has to move along the graph to reach a certain goal node. Possible interaction with the robot would be:
- what is your position?
- what is your battery status?
- which nodes are reachable from current position?
- Move north
- move to node #3.
- what is the shortest path to reach node #6?

The robot is in charge to answer these requests in natural language and with motor actions. The problem is easy enough to get implemented as normal computer code without using advanced large language models or vision language action models. The human to robot interaction can be simplified by using a codebook. The amount of possible commands is given in the menu and the human can select one of the commands. IN other words, the Total Turing Test (TTT) is some sort of speaker to hearer interaction game played between a human and a robot.

Head up display for a kitchen robot

The picture shows an artist version of a head up display. It contains of:
- camera picture of a kitchen
- text box with inner voice
- bounding boxes
- labels for the bounding boxes

Surprisingly, the information in the picture can solve the symbol grounding problem because the head up display connects visual perception with textual information. The text from the inner voice like "I need to find 200g of flour" can be converted into meaning with the help of the bounding boxes. There is a box available with such an ingredient. The task for the robot is not to plan actions but the main problem is to connect language from the inner voice with detected objects in the camera.

Such a link of visual objects with textual labels is the core element in grounded language. If the robot is able to identify objects from the text box, its possible to generate all sort of inner voice. For example, the robot can say that he needs to peel the banana or "open the oven". All these nouns and verbs are translated into position of the bounding box on the screen which allows to execute the action physically.

Head up display with inner voice for a kitchen robot in pixelart

Vision to language dataset for a warehouse robot

 

example2:

 example3:

 

Grounding mechanism 1o1

 A DIKW pyramid consists of abstraction layers like Data, information and other. A grounding mechamism maps the items in the layer. In an example warehouse robot, the data layer cosnsits of sensor readings like GPS Coordinates, lidar distance, and battery capacity while the information layer consists of [tags] like "battery_full, north, obstacle_ahead".

The grounding mechanism generates the links between the entries. For example the lidar distcance of 10 cm is mapped to "obstacle_ahead" while the battery level of 10% is mapped to "Battery_empty".

In general, a grounding mechanism is some sort of matching game. it answers the question which situation is mapped to which description. Such a mapping is the core element of an advanced artificail intelligence.

To demonstrate why a matching game enables artificial intelligence let us assume an example. Suppose the human operator submits a command to the warehouse robot which is "move to the green area, grasp the small box on the left side, bring the box to the blue area, drop it into the shelf, then recharge your battery".

If the grounding mechanism is missing or was deactated, the command is interpreted as string with 144 characters. It wasn't formulated in the C/C++ programming langauge but it can be stored only in the main memory.

Suppose the robot has a builtin grounding mechanism, than its possible to parse the sentence word by word. The word "green" is matching to a certain RGB value, the word "box" is mapped to a certain shape in the camera, the word "shelf" is mapped to a picture of the shelf and so on. The parsing algorithm fetches a word from the sentences, and takes a lookup into the database to identify the item from the data layer of the DIKW pyramid. Understanding a sentence from a robots perspective has to do with matching items from the information layer to the data layer.

Symbol grounding problem as answer to np hard algorithms

 Before its possible to describe grounded language there is a need to explain who artificial intelligence was imagined until the year 1990. It was treated similar to computer programming in the sense that there is a CPU which executes a program and its up to the programmer to make the algorithm as intelligent as possible. Artificial intelligence was thought as a very advanced computer programmed which is executed by a computer.

In other terms, the computer was seen as a problem solving machine and the only detail problem was which sort of algorithm is needed to solve a certain problem. For example motion planning in robotics was solved with motion planning algorithms while computer chess was solved with alpha beta prunning algorithms. Most of these AI related algorithms were designed as search algorithms. The computer was used to traverse the state space of the domain and this allowed the computer to find the optimal action.

The symbol grounding problem formulated by Stevan Harnad questions this algorithm oriented paradigm. This might explain why even today grounded language is a niche topic within computer science. Because computer science and algorithms were often treated as the same thing, it was outside of the scope how to program a computer without an algorithm.

Let us listen closely how Harnad, Brooks and Steels are arguing about grounded language. The core element is the sensory perception of a robot. The assumption is that the perception is transmitted to the computer. There is no need to calculate something but the focus on the data transfer. A light sensor detects light and the information from the sensor is send over a cable to the computer. The symbol grouding problem doesn't focus on the computer itself, but on the cable between a sensor and a computer, very similar to a computer network. Computer networks are different from a turing machine, they are never running algorithms, but a computer network communicates data often organized in a protocol layer.

The paradigm shift from algorithm centric computers towards protocol oriented data transmission is the core element of the symbol grounding problem. Artificial Intelligence isn't explained as processing or program executation, but Artificical Intelligence is imaged as the air gap between two hosts.

Let us compare the hardware. In classical algorithm oriented AI the basic building block is a central processing unit, which can be a 32bit CPU. The CPU is built with transistors on a chip and gets controlled by Assembly language. In contrast, the symbol grounding problem assumes that there is a Cat5 copper cable which delivers packets. Its up to the network engineer to define the protocol of the packets.

The paradigm shift can be explained for np hard problems. NP hard is a certain category of problems related to artificial intelligence which can't be solved with a computer. Nearly all robotics motion planning problems like the piano movers problem or model predictive control are np hard. The term np hard is referencing to the runtime of an algorithm executed on a cpu. In other words, even a modern 64bit CPU can't solve these problems because the hardware is too slow.

The holy grail in computer science is how to solve np hard problems. The answer was given by Stevan Harnad in his famous 1990 paper. He didn't mentioned np hard problems, but its possible to solve np hard problem with grounded language. Instead of using a CPU to calculate a mathematical problem, a copper cable is used to solve a data transmission problem. This new perspective is powerful enought to solve motion planning problems in robotics.

Textuelle Interaktion für Lagerroboter

 Textuelle Interaktion für Lagerroboter

Das folgende game log zeigt die interaktion zwischen 3 Agenten: eine game engine, eine Spielerin und einen internen Lehrer. Die Interaktion erfolgt ausschließlich über ein Text terminal. Das Ziel ist das Text adventure zu gewinnen indem Kommandos eingegeben werden und der interne Lehrer befragt wird.

=== WAREHOUSE ROBOT SIMULATION ===
KI_Spielerin: "starte auf Position A1"
Game_engine: "Roboter bereit. Ziel: 10 Kisten zu Regal B5 transportieren."
KI_Spielerin: "scanne Regal B5"
Game_engine: "Regal B5: 3/10 Kisten fehlen."
Internal_Teacher: "Nutze Greifarm Modus 3 für Kisten >20kg."
KI_Spielerin: "greife Kiste bei A1"
Game_engine: "Kiste erfasst. Gewicht: 25kg."
KI_Spielerin: "bewege zu B5"
Game_engine: "Weg frei. Transport startet."
KI_Spielerin: "platzieren Kiste"
Game_engine: "Kiste in Regal B5 abgelegt. 1/10 erledigt."
KI_Spielerin: "scanne Regal B5"
Game_engine: "Regal B5: 2/10 Kisten fehlen."
Internal_Teacher: "Prüfe Batteriestand. Warnung: 15%."
KI_Spielerin: "fahre zur Ladestation"
Game_engine: "Ladestation erreicht. Ladevorgang startet."
KI_Spielerin: "lade bis 80%"
Game_engine: "Batterie: 80%. Transport fortsetzen."
KI_Spielerin: "bewege zu A1"
Game_engine: "Position A1 erreicht."
KI_Spielerin: "greife nächste Kiste"
Game_engine: "Kiste erfasst. Gewicht: 18kg."
KI_Spielerin: "bewege zu B5"
Game_engine: "Weg blockiert. Hindernis: Palette bei A3."
KI_Spielerin: "frage nach Lösung"
Internal_Teacher: "Umfahren oder Hindernis entfernen. Risiko: 2 Min Verzögerung."
KI_Spielerin: "umfahre Hindernis"
Game_engine: "Alternative Route berechnet. Transport startet."
KI_Spielerin: "platzieren Kiste"
Game_engine: "Mission 50% abgeschlossen."
=== ENDE ===

Grounded language in a nutshell

 Grounded language can be described as sensor data tagging. It connects the internal raw sensory data of a robot with the external semantic tagging system. The linking is realized in a DIKW pyramid and improves man to machine communication. Such a communication system allows the robot to offload the intelligence to a human.

Here is an example. Suppose a warehouse robot stands in front of an obstacle. Because the robot's software isn't able to solve the situation, the robot asks a human operator what to do next. With the help of grounded language the output of the robot is: "obstacle: near, battery: 85%, question: What to do?". The human operator reads the textual message and takes a decision which is send back to the robot.

There are multiple techniques available how to implement such a system in software, for example with a handcoded language parser, or with a neural network. The shared similarity is, that all these attempts are based on natural language and put a high emphasizes on man to machine communication.

The term grounding is referencing to multiple situation:
a) its a link between sensor data and textual annotation
b) its a link between the internal robot structure and the external environment
c) its a link between low level and high level problem description

In more colloquial terms, grounded language means to use English for teleoperation of a robot. This principle seems not very impressive because it was demonstrated in science fiction movies multiple times in the past. The innovation is, that there is no alternative available to realize artificial intelligence. That means all advanced robots are built as teleoperated machine who understands English language.

The power of head up displays

 Head up displays are common special effects in scifi movies. Since the 1980s lots of films have demonstrated these visual effects. Most of the audience thinks, that the head up display isn't artificial intelligence but its only the artist representation of possible future robotics.

Its a bit surprising to explain that a head up display is the fundamental building block for artifcial intelligence because they are showing grounded language. The typical head up display is formatted in a key/value syntax, similar to a json file. Example for a warehouse robot:

location: cell B, north
movement: east
speed: 4 km/h
gripper: empty
obstacle: no
target: cell A
battery: 81%

All the important information can be shown in this syntax. The key/value format converts the camera picture into a text adventure game. A parser can analyze the textual information and decide what the robot should do next. For example, if the battery is below 20% the robot needs to find the charging station, And if there is an obstacle ahead, the robot needs to stop.

So we can say, that advanced robots aren't controlled by a AI algorithm but by the head up display. The information are the input for the decision making system, the head up display consists of the state space of a robot. If the robot decides for the wrong action, sometihng is wrong with information in the head up display.

Das Symbol grounding problem an einem praktischen Beispiel

Grounded language ist ein interdisziplinäres Problem was ein umfangreiches Fachwissen in sehr unterschiedlichen Disziplinen wie Informatik, Linguistik und Robotersteuerung erfordert. Es ist daher nötig, die Thematik zu vereinfachen anhand eines praktischen Beispiels. Ein Anfang ist eine Landkarte auf der ein Mauscursor bewegt wird. Der nutzer kann die mauf einen belieben Punkt bewegen z.B. auf einen roten Kreis oder ein gelbes Quadrat. Das Computerprogram zeigt für die Mauspostition die [tags] an, z.B. "[kreis] [grün]", oder "[rechteck] [klein]".

zumindest für das MInibeispiel mit der Landkarte auf dem geoemtrische Objekte zu sehen sind, ist damit das symbol grounding problem gelöst.

Ähnlich wie bei einer perspektivischen Darstellung in der Malerei gilt es also die REalität auf ein koordinatensystem abzubilden. Bei grounding problem bestehen die koordinaten aus einer [tag] liste. Der User zeigt auf einen punkt z.B. (100,30) und der Computer bestimmt die Tags für das Objekt an diesem Punkt.

Obwohl die technische Umsetzung leicht ist, kann über grounded language ein erstaunlich leistungsfähiges KI System erstellt werden. Ab dem moment wo der Computer tags ausgeben und parsen kann ist darüber eine Kommunikation möglich. Ein Beispiel:

Angenommen die beschriebene semantische Kamera wurde für ein Jump'bn'Run Videospiel implementiert, das heißt die Software vermag anhand der Tilemap sagen, ob der Mousecursor auf einem Abgrund, einem coin, einem powerup, einem Gegner oder auf einer Plattform steht. Dann kann diese Information in einer Regel referenziert werden, wie "gehe bis zum Abgrund und halte an, dann springe darüber und laufe bis zum Coin". Diese komplexe Befehlsfege referenziert auf erkannte Tags in dem Computerspiel, der parser kann dies auswerten und versteht was der Benutzer möchte. Nicth weil ein hochkomplexer Algorithmus im Hintergrund arbeitet, sondern weil ein mensch maschine interface existiert auf das man verweisen kann.

 

Der sourcecode und der screenshot zeigen nicht das geometrie problem sondern ein robot in a maze spiel bei dem ein roboter items sammeln muss. Es gibt in der Statuszeile eine semantische Event Erkennung. Der Roboter bewegt sich in der Karte und parallel dazu wird in der Textbox die aktuelle Situaton beschrieben, ein wenig so wie einem frühen Textadventure. Über besagte Statuszeile wird der game state des robtoers definiert und zwar im linguistischen Raum und nicht im geometrisch mathematischen Raum.

import pygame
import sys
import random

# Initialize Pygame
pygame.init()
pygame.font.init()

# --- Configuration Constants ---
GRID_SIZE = 40  # Pixels per cell
GRID_COLS = 20
GRID_ROWS = 12

# Textbox dimensions (40 chars wide, 4 lines high roughly translates to this)
TEXTBOX_HEIGHT = 100
SCREEN_WIDTH = GRID_COLS * GRID_SIZE
SCREEN_HEIGHT = (GRID_ROWS * GRID_SIZE) + TEXTBOX_HEIGHT

# Colors (RGB)
COLOR_STREET = (240, 240, 240)
COLOR_HOUSE = (70, 130, 180)
COLOR_ROBOT = (220, 50, 50)
COLOR_TRASH = (40, 180, 99)
COLOR_TEXTBOX_BG = (30, 30, 30)
COLOR_TEXT = (255, 255, 255)
COLOR_GRID = (210, 210, 210)

# --- Event Log System ---
# The 12 grounded language events:
# 1. "System initialized. Roomba ready."
# 2. "Moved North."
# 3. "Moved South."
# 4. "Moved East."
# 5. "Moved West."
# 6. "Obstacle detected at North."
# 7. "Obstacle detected at South."
# 8. "Obstacle detected at East."
# 9. "Obstacle detected at West."
# 10. "Grid boundary reached."
# 11. "Trash item successfully collected!"
# 12. "Area clear. No trash nearby."

event_logs = ["System initialized. Roomba ready.", "", "", ""]

def log_event(message):
    """Adds a new event to the log, keeping only the last 4 events."""
    global event_logs
    if event_logs[-1] != message: # Avoid spamming identical consecutive logs
        event_logs.append(message)
        if len(event_logs) > 4:
            event_logs.pop(0)

# --- Map & Environment Setup ---
# 0 = Street (Pathway), 1 = House (Obstacle)
maze = [[0 for _ in range(GRID_COLS)] for _ in range(GRID_ROWS)]

# Generate mock "blocks" of houses to look like a street map
random.seed(42) # Seed for consistent map generation
for r in range(1, GRID_ROWS - 1, 3):
    for c in range(1, GRID_COLS - 1, 4):
        # Create a 2x2 or 2x3 house block
        block_w = random.randint(2, 3)
        block_h = 2
        for bh in range(block_h):
            for bw in range(block_w):
                if r + bh < GRID_ROWS - 1 and c + bw < GRID_COLS - 1:
                    maze[r + bh][c + bw] = 1

# Spawn Trash Items
trash_positions = set()
while len(trash_positions) < 10:
    tr = random.randint(0, GRID_ROWS - 1)
    tc = random.randint(0, GRID_COLS - 1)
    if maze[tr][tc] == 0:  # Must be on a street
        trash_positions.add((tc, tr))

# Spawn Robot
robot_x, robot_y = 0, 0
while maze[robot_y][robot_x] != 0:
    robot_x = random.randint(0, GRID_COLS - 1)
    robot_y = random.randint(0, GRID_ROWS - 1)

# --- Simulation Setup ---
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Robot Street Simulator")
clock = pygame.time.Clock()
font = pygame.font.SysFont("Courier", 18) # Monospace font for predictable char width

def check_surroundings(rx, ry):
    """Scans adjacent cells to log nearby obstacles."""
    # North
    if ry - 1 < 0: pass 
    elif maze[ry - 1][rx] == 1: log_event("Obstacle detected at North.")
    # South
    if ry + 1 >= GRID_ROWS: pass
    elif maze[ry + 1][rx] == 1: log_event("Obstacle detected at South.")
    # West
    if rx - 1 < 0: pass
    elif maze[ry][rx - 1] == 1: log_event("Obstacle detected at West.")
    # East
    if rx + 1 >= GRID_COLS: pass
    elif maze[ry][rx + 1] == 1: log_event("Obstacle detected at East.")

# Initial scan
check_surroundings(robot_x, robot_y)

# --- Main Loop ---
# --- Main Loop ---
running = True
while running:
    for event in pygame.event.get():
        # FIX: Changed event.get_type() to event.type
        if event.type == pygame.QUIT:
            running = False
            
        # FIX: Changed event.get_type() to event.type
        elif event.type == pygame.KEYDOWN:
            dx, dy = 0, 0
            move_dir = ""
            
            if event.key == pygame.K_UP:
                dy = -1
                move_dir = "North"
            elif event.key == pygame.K_DOWN:
                dy = 1
                move_dir = "South"
            elif event.key == pygame.K_LEFT:
                dx = -1
                move_dir = "West"
            elif event.key == pygame.K_RIGHT:
                dx = 1
                move_dir = "East"
                
            if dx != 0 or dy != 0:
                new_x = robot_x + dx
                new_y = robot_y + dy
                
                # Check Grid Boundary
                if not (0 <= new_x < GRID_COLS and 0 <= new_y < GRID_ROWS):
                    log_event("Grid boundary reached.")
                # Check House Obstacle Collision
                elif maze[new_y][new_x] == 1:
                    log_event(f"Obstacle detected at {move_dir}.")
                # Move Valid
                else:
                    robot_x = new_x
                    robot_y = new_y
                    log_event(f"Moved {move_dir}.")
                    
                    # Check Trash Collection
                    if (robot_x, robot_y) in trash_positions:
                        trash_positions.remove((robot_x, robot_y))
                        log_event("Trash item successfully collected!")
                    
                    # Scan environment post-movement
                    check_surroundings(robot_x, robot_y)
                    
                    # Check if all clear
                    if not trash_positions:
                        log_event("Area clear. No trash nearby.")

    # --- Drawing Environment ---
    screen.fill(COLOR_STREET)
    
    # Draw Grid and Houses
    for r in range(GRID_ROWS):
        for c in range(GRID_COLS):
            rect = pygame.Rect(c * GRID_SIZE, r * GRID_SIZE, GRID_SIZE, GRID_SIZE)
            if maze[r][c] == 1:
                pygame.draw.rect(screen, COLOR_HOUSE, rect)
            pygame.draw.rect(screen, COLOR_GRID, rect, 1)

    # Draw Trash Items
    for (tx, ty) in trash_positions:
        trash_rect = pygame.Rect(tx * GRID_SIZE + 10, ty * GRID_SIZE + 10, GRID_SIZE - 20, GRID_SIZE - 20)
        pygame.draw.rect(screen, COLOR_TRASH, trash_rect, border_radius=3)

    # Draw Robot
    robot_rect = pygame.Rect(robot_x * GRID_SIZE + 6, robot_y * GRID_SIZE + 6, GRID_SIZE - 12, GRID_SIZE - 12)
    pygame.draw.ellipse(screen, COLOR_ROBOT, robot_rect)

    # --- Drawing Grounded Language Textbox ---
    # Draw Textbox background container
    textbox_rect = pygame.Rect(0, GRID_ROWS * GRID_SIZE, SCREEN_WIDTH, TEXTBOX_HEIGHT)
    pygame.draw.rect(screen, COLOR_TEXTBOX_BG, textbox_rect)
    pygame.draw.rect(screen, COLOR_TEXT, textbox_rect, 2) # Border
    
    # Render the 4 lines of text
    for idx, log in enumerate(event_logs):
        # Clip string to 40 characters maximum to respect specification constraints
        truncated_log = log[:40] 
        text_surface = font.render(truncated_log, True, COLOR_TEXT)
        screen.blit(text_surface, (15, (GRID_ROWS * GRID_SIZE) + 10 + (idx * 20)))

    pygame.display.flip()
    clock.tick(30)

pygame.quit()
sys.exit()

Robot arm with grounded language

 

Warehouse robot with grounded language:

 

Textbausteine für einen Warehouse roboter

 Ein text buffer für eine Game engine kann über Textbausteine realisiert werden die in einer Datenbank gespeichert sind. Ein simples Beispiel für einen Lagerroboter liegt im json format vor:

{
  "warehouse_robot_lang": {
    "navigation": {
      "moving": "Proceeding to waypoint {target_id}.",
      "path_blocked": "Obstacle detected at {coords}. Recalculating path.",
      "arrived": "Reached destination: {location_name}.",
      "waiting": "Waiting for traffic clearance in zone {zone_id}."
    },
    "manipulation": {
      "picking": "Engaging grippers for item {sku_id}.",
      "placing": "Depositing unit onto rack {rack_level}.",
      "scanning": "Verifying barcode for shelf {shelf_id}.",
      "load_secured": "Weight sensor triggered. Payload is stable."
    },
    "diagnostics": {
      "battery_low": "Warning: Battery at {percent}%. Searching for charging station.",
      "charging": "Power coupling established. Current state: {percent}%.",
      "system_ok": "All internal sensors reporting nominal values.",
      "error": "Actuator malfunction in {component}. Human intervention required."
    },
    "interaction": {
      "safety_stop": "EMERGENCY STOP: Human detected in safety perimeter!",
      "greeting": "Unit {robot_id} active and awaiting tasking."
    }
}

Darin gibt es 4 semantische Kategorien mit möglichen Unterpunkten. Obwohl es relativ viel Text ist, ist mathematisch gesehen die zahl möglicher Zustände des Roboters gering. Aufgabe des Text buffers ist es, die richtigen Textbausteine aus der Datenbank auszuwählen, um damit die Sensordaten als grouned language auf dem Bildschirm darzustellen. Es handelt sich also weniger um einen KI Algorithmus, sondern um eine KI GUI Oberfläche, die zur Mensch Maschine Interaktion verwendet wird. Vergleichbar mit den Menüpunkte in einer Desktop Software.