Bis ungefähr zum Jahr 2010 dominierte in der Robotik Community das Paradigma des geschlossenen Systems ohne es als solches zu benennen. Das Ziel der Programmierer war häufig einen Algorithmus oder ein Robot control Program zu erstellen was den Roboter autonom steuert. Der Fokus lag also auf der Programierung ganz so wie auch die Informatik den Schwerpunkt auf Software und Algorithmen legt.
Die Informatik stellt für diese Aufgabe zahlreiche Werkzeuge bereit, wie z.B. vorhandene Bilbiotheken mit pLanungsalgorithmen, Compiler für Hochsprachen wie Java sowie leistungsfähige Code editoren mit denen einmal erstellter Programm code getestet und verbessert werden kann. Die Annahme vor 2010 lautete dass diese Werkzeuge ausreichen um damit Roboter zu programmieren.
Im wesentlichen ging es also darum ein Computerprogram zu entwickeln was einen Roboter autonom steuern kann. Diese selbstgesetzte Zielstellung erzeugt einen besonderen Workflow. Er erzeugt eine massive Komplexität. Je anspruchsvoller der Roboter desto umfangreicher die benötigte Software.
Das Problem war den Informatikern bewusst, sie versuchten die Komplexität zu senken indem sie die Aufgabenstellung modifizierten. Anstatt die Software für ein Selbstfahrendes Auto im Straßenverkehr zu programmieren wurde versucht ein Spielzeug auto auf einem Parkurs zu steuern. Aber selbst diese reduzierte Aufgabe führte zu einer Software die 100k lines of code und mehr umfasste.
Bis 2010 war den meisten Robotik-Pionieren nicht bewusst dass sie sich in einer Sackgasse befanden weil die Roboter als geschlossene Systeme funktionierten. Damit ist gemeint dass die Roboter sowohl von der Software als auch von der Hardware extrem hochentwickelt waren, aber dabei auschließlich nach internen Mechanismen funktionierten und die Umwelt ignorierten. Rein formal waren Roboter zwar mit Sensoren ausgestattet es gab jedoch keine Theorie wie die Sensorwerte in Aktionen übersetzt werden können.
Geschlossene Systeme sind das gegenteil von einer Fernsteuerung. Bei einer Fernsteuerung sendet die Umwelt Befehle an den Roboter. Genau diese Art von Fernkontrolle gab es bei den Roboter vor 2010 nicht. Alle bekannten Robotik Wettbewerbe aus dieser Zeit funktionieren nach dem Prinzip der autonomen Steuerung. Es gab ein Program was von einer CPU ausgeführt wurde, und das Programm allein entschied was der Roboter tat. Ferngesteuerte Robotik wurde als unzulässig verworfen. Es war zwar technisch bekannt wie man das realisiert, aber das Prinzip wurde nicht ernsthaft diskutiert.
Ferngesteuerte Roboter sind offene Systeme. Auch die vielzietierte These von Rodney Brooks emboeddied AI zu realisieren ist nur eine andere Formulierung für Teleoperation. Sobald man Daten von Außen an den Roboter sendet entsteht ein offenes System. nicht der Roboter entscheidet was zu tun ist, sondern die umwelt übernimmt die Aufgabe. So kann ein abstandssensor ebenfalls als Fernsteuerung betrachtet werden. Sobald der abstandssensor ein Hinderniss erkennt stoppt der Roboter. Das heißt der Sensor sendet an den Roboter ein Kommando.
Bei offenen Systemen ist die Unterscheidung zwischen Roboter und Umwelt zentral. Als Roboter wird die Hardware und Software des Roboters bezeichnet, also der Arduino Microcontroller, das Linux Betriebssystem, das C program was auf dem Board läuft. Also jene Elemente für die sich die Informatik zuständig fühlt. Umgekehrt besteht die Umgebung eines Roboter aus der Aufgabe die es zu lösen, also ein Labyrinth, Hindernisse in diesem Labyrinth, ein Zielpunkt den der Roboter erreichen muss. Diese Umwelt wird von der Informatik vor dem Jahr 2010 ignroiert. Die Umwelt lässt sich nicht als Hardware und Software beschreiben sondern die Umwelt funktioniert nach anderen Prinzipien.
Sobald man Roboter baut die ferngesteuert werden, nimmt die Umwelt einen höheren Stellenwert wert. Der Roboter selbst wird zu einer Trivalen Maschine die lediglich Befehle über ein funksignal empfängt und einen Motor hat der sich bewegen kann. Der Roboter besitzt jedoch keine Software um Entscheidungen zu treffen sondern die Umwelt übernimmt das Timing und die Zieldefinition. Offene Systeme lassen sich über das Interface beschreiben, also jenes Bautteil oder jenes Softwaremodul was Befehle der Umwelt empfängt und was Informationen an die Umwelt sendet. Dieses Interface beinhaltet die eigentliche Künstliche Intelligenz, zumindest nach einer modernen Betrachtung ab dem Jahr 2010.
One problem with grounded language that its hard to give a sense making example which can be implemented in a short amount of code lines. A possible answer is a NPC quest generator which is generating tasks as textual output. The following python program has only 33 lines of code and generates random quests for a car driving game.
All the quests are pointing challenges, the human is asked to point at a certain object in the scene. The software can't verified if the human has pointed at the correct object, but only the quest itself is shown on the screen.
The implementation in python is as simple as possible. There is a python dict with possible target location which are selected randomly by the software. So its some sort dictionary with a random element. To solve the tasks, that human needs to know what a certain word means. For example "Focus on the pedestrian on sidewalk." is asking for a certain object at a certain position.
screenshot:
==================================================
3D DRIVING GAME: NPC POINTING QUEST GENERATOR
==================================================
Press [ENTER] for a new quest | Type 'q' + [ENTER] to quit
[Quest #1] Ready?
>> NEW QUEST: Focus on the pedestrian on sidewalk.
--------------------------------------------------
[Quest #2] Ready?
>> NEW QUEST: Focus on the parking spot.
--------------------------------------------------
[Quest #3] Ready?
>> NEW QUEST: Track the parking spot.
--------------------------------------------------
[Quest #4] Ready?
>> NEW QUEST: Locate the car on the left lane.
--------------------------------------------------
[Quest #5] Ready?
source code:
import random
# Driving game targets organized by relative 3D perspective from behind the wheel
TARGETS = {
"traffic_controls": ["traffic light", "speed limit sign", "stop sign", "yield sign"],
"road_features": ["street ahead", "crosswalk", "lane line", "pothole", "guardrail"],
"vehicles": ["car in front", "car on the left lane", "car on the oncoming side", "truck in side mirror", "motorcycle in rearview mirror"],
"environment": ["pedestrian on sidewalk", "billboard", "parking spot", "street lamp"]
}
VERBS = ["point at", "focus on", "locate", "target", "track"]
def generate_quest():
category = random.choice(list(TARGETS.keys()))
obj = random.choice(TARGETS[category])
verb = random.choice(VERBS)
return f'{verb.capitalize()} the {obj}.'
def main():
print("=" * 50 + "\n 3D DRIVING GAME: NPC POINTING QUEST GENERATOR\n" + "=" * 50)
print("Press [ENTER] for a new quest | Type 'q' + [ENTER] to quit\n")
count = 1
while True:
cmd = input(f"[Quest #{count}] Ready? ").strip().lower()
if cmd == 'q':
print("\nGenerator stopped. Keep your eyes on the road!")
break
print(f" >> NEW QUEST: {generate_quest()}\n" + "-" * 50)
count += 1
if __name__ == "__main__":
main()
import sys, random, pygame
pygame.init()
pygame.font.init()
# Setup grid & display settings
GRID_SIZE, CELL_SIZE = 8, 60
OFF_X, OFF_Y = 160, 60
W, H = 800, 650
SCREEN = pygame.display.set_mode((W, H))
pygame.display.set_caption("Grounded Language: Grid Pointing Game")
CLOCK = pygame.time.Clock()
FONT_MAIN = pygame.font.SysFont("Arial", 20, bold=True)
FONT_UI = pygame.font.SysFont("Arial", 16)
# Colors: BG, Grid, Obstacle, Box BG, Box Border, Text, Success, Error
C_BG, C_GRID, C_OBS = (240, 243, 246), (180, 185, 190), (100, 110, 120)
C_BOX_BG, C_BOX_BDR, C_TXT = (220, 225, 230), (140, 150, 160), (30, 40, 50)
C_SUCC, C_ERR = (46, 204, 113), (231, 76, 60)
# 2x2 Obstacle cells in the middle
OBSTACLE_CELLS = {(3, 3), (3, 4), (4, 3), (4, 4)}
ACTIONS = ["point at", "click on", "select", "target"]
class PointingGame:
def __init__(self):
self.score = 0
self.fb_msg, self.fb_col, self.fb_timer = "", C_TXT, 0
self.new_quest()
def new_quest(self):
act = random.choice(ACTIONS)
qtype = random.choice(["specific", "obstacle", "top", "bottom", "left", "right"])
if qtype == "specific":
x, y = random.randint(0, 7), random.randint(0, 7)
self.quest = f'NPC Quest: "{act} ({x},{y})"'
self.check = lambda cx, cy, x=x, y=y: (cx, cy) == (x, y)
elif qtype == "obstacle":
self.quest = f'NPC Quest: "{act} the obstacle"'
self.check = lambda cx, cy: (cx, cy) in OBSTACLE_CELLS
else: # Top, Bottom, Left, or Right edge (8 cells each)
self.quest = f'NPC Quest: "{act} {qtype} edge cells"'
edges = {
"top": lambda cx, cy: cy == 0,
"bottom": lambda cx, cy: cy == 7,
"left": lambda cx, cy: cx == 0,
"right": lambda cx, cy: cx == 7
}
self.check = edges[qtype]
def handle_click(self, pos):
mx, my = pos
if OFF_X <= mx < OFF_X + 480 and OFF_Y <= my < OFF_Y + 480:
cx, cy = (mx - OFF_X) // CELL_SIZE, (my - OFF_Y) // CELL_SIZE
if self.check(cx, cy):
self.score += 10
self.fb_msg, self.fb_col = f"Correct! +10 pts for cell ({cx},{cy})", C_SUCC
self.new_quest()
else:
self.score = max(0, self.score - 5)
self.fb_msg, self.fb_col = f"Wrong! Cell ({cx},{cy}) is not the target. (-5)", C_ERR
self.fb_timer = pygame.time.get_ticks() + 1500
def draw(self):
SCREEN.fill(C_BG)
# Headers & Score
SCREEN.blit(FONT_MAIN.render("Grounded Language Grid Game", True, C_TXT), (OFF_X, 15))
SCREEN.blit(FONT_MAIN.render(f"Score: {self.score}", True, C_SUCC), (OFF_X + 320, 15))
# Axis Labels & Grid
mx, my = pygame.mouse.get_pos()
for i in range(8):
SCREEN.blit(FONT_UI.render(str(i), True, C_TXT), (OFF_X + i * 60 + 26, OFF_Y - 25))
SCREEN.blit(FONT_UI.render(str(i), True, C_TXT), (OFF_X - 25, OFF_Y + i * 60 + 22))
for cy in range(8):
for cx in range(8):
rect = pygame.Rect(OFF_X + cx * 60, OFF_Y + cy * 60, 60, 60)
col = C_OBS if (cx, cy) in OBSTACLE_CELLS else (255, 255, 255)
pygame.draw.rect(SCREEN, col, rect)
pygame.draw.rect(SCREEN, C_GRID, rect, 1)
if rect.collidepoint(mx, my):
s = pygame.Surface((60, 60), pygame.SRCALPHA)
s.fill((52, 152, 219, 100))
SCREEN.blit(s, rect.topleft)
# Quest & Feedback Widget
box = pygame.Rect(OFF_X - 40, OFF_Y + 505, 560, 85)
pygame.draw.rect(SCREEN, C_BOX_BG, box, border_radius=8)
pygame.draw.rect(SCREEN, C_BOX_BDR, box, width=2, border_radius=8)
SCREEN.blit(FONT_MAIN.render(self.quest, True, C_TXT), (box.x + 20, box.y + 15))
if pygame.time.get_ticks() < self.fb_timer:
SCREEN.blit(FONT_UI.render(self.fb_msg, True, self.fb_col), (box.x + 20, box.y + 50))
game = PointingGame()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit(); sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
game.handle_click(event.pos)
game.draw()
pygame.display.flip()
CLOCK.tick(60)
Suppose the goal is to use grounded language to control a model railroad. The first step is to invent a dictionary with useful words:
- locomotive_1: red, locomotive_2: blue
- switch_1: left_side, switch_2: right_side, track,
- slowdown, speedup, switch, follow, wait
These words are stored in a python dictionary as a list. The first iteration of the parser takes a command from the command line e.g. "switch_1" and searches in the dictionary if the found is available. Then the parser returns "ok".
In step 2 the vocabulary gets connected with the visual appearance of the game formalized in a pointing game. The user enters a command and the parser should highlight the object on the screen. For example the user enters "locomotive_2" and the parser draws a rectangle around the object.
In step 3 which is more advanced an instruction following game gets established. The parser has to execute actions. The user might enter a command like "speedup locomotive_1" and the parser ensures that the desired action gets executed. Programming such a behavior is the most advanced part of a language game.
In general grounded language starts always with a vocabulary which is a word list. The list contains of nouns, verbs and objects and is related to a domain. Symbol grounding in the strict sense means to play language games with the word list which are the pointing game and the instruction following game.
Wissenschaft ist in Gebieten organisiert wie Mathematik, Physik, Linguistik und Kunst. Leider ist es schwierig, die Thematik "grounded language" einem dieser Bereiche zuzuordnen. Gleichzeitig ist grounded language fundamental zum Verständnis von Robotik als lohnt es sich die Thematik näher zu untersuchen.
Von der selbstbeschreibung her ist Grounded language eine Mischung als Sprachwissenschaft mit Informatik. Natürliche Sprache wird verwendet um ein Informatik-Problem z.B. Robotik-Steuerung zu lösen. Technisch gesehen ist das ein vielversprechender Ansatz allerdings ist unklar wo Literatur über diese Thematik einsortiert werden muss. Weder in die Linguistik noch in die Informatik passt grounded language wirklich hinein. Ein möglichers Gebiet wäre die Nachrichtentechnik welche sich mit der Informationsübertragung vom Sender zum Empfänger beschäftigt, nur leider besteht Nachrichtentechnik eher aus der technischen Realisierbarkeit also wie Bits über einen Kanal fließen und weniger in der semantischen Analyse einer Nachricht.
Vermutlich werden die meisten Informatiker noch nie etwas von grounded language gehört haben. Der Grund ist dass Informatik seine Wurzeln in den exakten Naturwissenschaften hat also verwand ist mit der Mathematik und der Physik. Um Computer zu bauen benötigt man Elektrotechnik und dort speziell Transistoren. Um Computer zu programmieren benötigt man Algorithmen welche in der Mathematik untersucht werden. Leider hat grounded language mit beidem nichts zu tun. Es ist keine matghematik sondern es ist verwand mit der Sprachwissenschaft von Ferdinand de Saussure der untersucht hat wie Zeichen ihre Bedeutung erhalten. Die Methoden innerhalb der Sprachwissenschaft unterscheiden sich grundsätzlich von den Methoden in der Mathematik. Sprachwissenschaft wird als Geisteswissenschaft bezeichnet und gehört wie Geschichte und Soziologie zur Kulturhistorie.
Wollte man grounded language angemessen berücksichtigen müsste man eigentlich eine neue Kategorie erstellen zusätzlich zur bekannten Dewey Klassifikation. Das ist praktisch nicht durchführbar weil ja die idee hinter der etablierten Systematik darin besteht die Literatur auf dieses Raster einzurodnen. Um das Problem der Einordnung zu lösen muss man zuerst einmal grob definieren ob grounded language im Bereich Naturwissenschaft oder im Bereich Geisteswissenschaft veroret ist.
Am ehesten könnte man grounded language als Naturwissenschaft bezeichnen und zwar weil der technisch-mathematische Aspekt im Zentrum steht. Es geht weniger darum Sprache an sich zu beschreiben sondern Sprache wird verwendet um Roboter zu steuern. Ähnlich wie Motion capture ist es damit im Bereich Naturwissenschaft -> Informatik -> Robotik lokalisiert. Auch bei Motion capture verfahren werden bekanntlich Ideen aus der Sportwissenschaft verwendet, allerdings ist Mocap zunächst einmal ein technisches Verfahren und wird daher von der Informatik definiert.
Bei grounded language ging es technikhistorisch immer darum, Sensordaten mittels Computer in textuelle ausgabe zu übersetzen. Frühe Beispiele waren das SHRDLU Projekt (Terry Winograd, 1968) oder Commentator scene description (Bengt Sigurd, 1980). Der Computer wurde also zwingend in diesen Projekten eingesetzt. Da das SHRDLU Projekt primär ein Artefakt der Informatik war, ist auch grounded language ein Teilbereich der Informatik-Geschichte.
Die klassische Sprachwissenschaft untersucht ebenfalls Sprache allerdings geht es um Sprache wie sie von Menschen oder Tieren verwendet wird, nicht um Sprache die von Algorithmen erzeugt wird. Sobald der Computer im Zentrum steht wird ein Thema als Informatik betrachtet. Im Fall von grounded language steht der computer zweifelsfrei im Zentrum der Betrachung. Es geht darum Sprache soweit zu formalisieren dass sie von Computern zur Interaktion verwendet werden kann. Computer sind definitionsgemäß innerhalb der Informatik beheimatet und werden nach naturwissenschaftlichen Prinipien beschrieben.
Mag sein dass für die Beschreibung von grounded language auf Theorien der Sprachwissenschaft und Psychologie zurückgegriffen wird, aber das könnte man über Computerspiele auch sagen. So verwendet das Spiel "Sim City" elemente der Architekturplanung während Malprogramme einen Starken bezug haben zur Kunst. Trotzdem sind diese Beispiel innerhalb der Informatik verortet weil der Computer jedesmal im Zentrum steht.
Grounded language kann man daher als neues Aufgabengebiet für einen Computer definieren. Anstatt nur Daten über ein Leitung zu übetragen wie das durch das Internet erfolgt und anstatt einfach nur Zahlen aufzuaddieren wie das mit einer Tabellenkalulation möglich ist, wird durch grounded language der Computer in die Lage versetzt natürliche Sprache an Roboter zu senden und zu empfangen. Und weil dies über Algorithmen funktioniert ist die Informatik die richtige Anlaufstelle für eine weitere Literaturrecherche.
There are objects, activities and adjectives. Such a dictionary provides a vocabulary for talking about the subject. It allows a robot to localize the objects with a camera and understand basic requests like "wash dirty plate", "stir hot bowl", "bake cake in oven".
Some of the entries in the picture are labeled wrong, this is a technical problem.
Vor dem Aufkommen von instruction following robotern und Vision language action modellen gab es die informierte Suche was ein heuristischer Algorithmus darstellt. Verwendet wurde eine feste Kostenfunktion die beim Pfadplanen häufig der Abstand zum Ziel auf der Karte war während bei Computerschach die Kostenfunktion die Bewertungsfunktion der aktuellen Stellung war, also wieviele Figuren eine Seite besitzt und wo diese stehen auf dem Brett.
Informierte Suche mittels Kostenfunktion ist leistungsfähiger als die vorher übliche backtracking suche welche alle möglichkeiten durchprobiert und eine extrem hhohe laufzeit besitzt. Bei der informierten Suche wird nur ein kleiner Teil des gametree berücksichtigt. Es stellt einen Kompromiss da zwischen einem numerischen Solver wie der potential field methode und eine konkrete Anwendungsdomäne wie dem Navigieren eines Roboters in einem Labyrinth.
Informierte Suche hat jedoch ein größes Problem: die Kostenfunktion ist fest in der Software vorgegeben und kann nicht von außen verändert werden. zusätzlich besteht die Kostenfunktion aus einer mathematischen Formel deren Erstellung schwierig ist und die selten für alle Situationen gute Ergebnisse liefert. Beim Schach wird z.B. eine Summe gebildet aus mehreren Einflussfaktoren die unterschiedlich gewichtet werden.
Die neuere KI Forschung ist deshalb von der klassischen informierten Suche abgerückt zugunsten voice control. Voice control erlaubt es während der Laufzeit des Roboters die kostenfunktion von außen zu verändern. Der User entscheidet während der interaktion was das Ziel ist. er kann z.b. sagen "fahre zur ladestation" oder "fahre zum Wegpunkt A". Ein solches Kommando wird in eine Kostenfunktion übersetzt die dann wiederum konkrete Handlungen des Roboters aktiviert. Genauer gesagt versucht der Roboter ähnlich wie der informierten Suche seine Kosten zu minimieren und das Ziel zu erreichen.
Die einfachste Version eines voice control roboters besteht aus einer Menüstruktur wo der Benutzer aus 4 möglichen Befehlen einen Auswählen kann, für jedes Kommando wurde vorher manuell die Kostenfunktion hinterlegt zwischen denen der Benutzer wählen kann. Das entspricht ungefähr den Optionen beim Reinforcement learning. Bei einer komplexeren voice control steuerung kann der Benutzer halbwegs frei ein Kommando eingeben was in eine inviduelle Kostenfunktion übersetzt wird. z.B. durch das bennnen von wegpunkten oder das benennen von aktionsverben. Einfache Kommandos könnten lauten:
1. fahre langsam zu Wegpunkt B
2. fahre schnell zu Wegpunkt C
3. stopp
4. fahre schnell zu Ladestation
Der Benutzer interagiert hier mit dem Roboter mittels einer simplen Sprachgrammatik. Der Parser hat die Aufgabe für jedes mögliche Kommando eine numerische Kostenfunktion zu bestimmen welche sich mittels potential field Suche in Servobefehle übersetzen lässt.
Existing large language models (LLM) are highly complex systems which are impossible to explain to newbies. The following blog post consists of a minimal example.
The human to chatbot interaction works with a vocabulary of 100 words stored in a word embeddings matrix of 20 dimensions. The human enters a sentence which gets converted into a 20d vector and the chatbot responds also with a vector.
================================================================================
LOG FILE: USER-CHATBOT INTERACTION SESSION #0842
SYSTEM: MINI-ENGLISH 100-WORD NEURAL COMMUNICATION INTERFACE
ENCODING: 20-DIMENSIONAL CONTINUOUS DENSE VECTOR [d1..d20] (0.00-1.00)
DATE: 2026-09-19 10:04:12 UTC
================================================================================
[SYSTEM INIT]
- Vocabulary Size: 100 Words (Discrete Lexicon Index: W000 - W099)
- Input Representation: Sequence of 20D Continuous Floating-Point Vectors
- Output Representation: Sequence of 20D Continuous Floating-Point Vectors
- Vector Quantization: L2 Euclidean Distance Matching (Threshold: < 0.15)
- Session Status: CONNECTED
--------------------------------------------------------------------------------
[TURN 01 - HUMAN INPUT]
Raw Selection: ["What", "Is", "Sun", "Color"]
Sequence Length: 4 Tokens
Input Vectors (20D Matrix):
Token 1 ("What"):
[0.91, 0.05, 0.12, 0.88, 0.02, 0.10, 0.00, 0.45, 0.11, 0.02, 0.80, 0.15, 0.03, 0.05, 0.92, 0.01, 0.10, 0.22, 0.05, 0.14]
Token 2 ("Is"):
[0.10, 0.02, 0.85, 0.12, 0.01, 0.05, 0.00, 0.90, 0.02, 0.11, 0.20, 0.04, 0.01, 0.08, 0.15, 0.00, 0.05, 0.10, 0.02, 0.05]
Token 3 ("Sun"):
[0.05, 0.95, 0.08, 0.10, 0.92, 0.88, 0.70, 0.15, 0.85, 0.00, 0.05, 0.10, 0.90, 0.12, 0.02, 0.08, 0.60, 0.05, 0.88, 0.10]
Token 4 ("Color"):
[0.12, 0.88, 0.20, 0.05, 0.15, 0.30, 0.10, 0.25, 0.10, 0.95, 0.08, 0.20, 0.15, 0.02, 0.10, 0.05, 0.12, 0.80, 0.10, 0.25]
[ENCODER PROCESSING]
- Reading sequence [4x20]...
- Temporal hidden state updated. Intent classified: [QUERY: ASTRO_PROPERTY]
[DECODER GENERATION & QUANTIZATION]
- Step 1: Raw Output Vector -> L2 Nearest Match: W082 ("Sun") | Dist: 0.012
- Step 2: Raw Output Vector -> L2 Nearest Match: W018 ("Is") | Dist: 0.008
- Step 3: Raw Output Vector -> L2 Nearest Match: W091 ("Yellow") | Dist: 0.034
- Step 4: Raw Output Vector -> L2 Nearest Match: W095 ("White") | Dist: 0.041
- Step 5: Raw Output Vector -> L2 Nearest Match: W099 ("<EOS>") | Dist: 0.002
[TURN 01 - CHATBOT RESPONSE]
Reconstructed Text: "Sun Is Yellow White"
Output Vectors (20D Matrix):
Token 1 ("Sun"):
[0.05, 0.95, 0.08, 0.10, 0.92, 0.88, 0.70, 0.15, 0.85, 0.00, 0.05, 0.10, 0.90, 0.12, 0.02, 0.08, 0.60, 0.05, 0.88, 0.10]
Token 2 ("Is"):
[0.10, 0.02, 0.85, 0.12, 0.01, 0.05, 0.00, 0.90, 0.02, 0.11, 0.20, 0.04, 0.01, 0.08, 0.15, 0.00, 0.05, 0.10, 0.02, 0.05]
Token 3 ("Yellow"):
[0.08, 0.82, 0.15, 0.02, 0.10, 0.25, 0.05, 0.20, 0.08, 0.98, 0.05, 0.18, 0.10, 0.01, 0.08, 0.02, 0.10, 0.85, 0.08, 0.20]
Token 4 ("White"):
[0.02, 0.85, 0.10, 0.01, 0.08, 0.20, 0.02, 0.15, 0.05, 0.99, 0.02, 0.12, 0.05, 0.00, 0.05, 0.01, 0.08, 0.90, 0.05, 0.15]
--------------------------------------------------------------------------------
[TURN 02 - HUMAN INPUT]
Raw Selection: ["Why", "Sky", "Blue"]
Sequence Length: 3 Tokens
Input Vectors (20D Matrix):
Token 1 ("Why"):
[0.95, 0.02, 0.10, 0.91, 0.01, 0.08, 0.00, 0.30, 0.08, 0.01, 0.85, 0.10, 0.02, 0.04, 0.95, 0.00, 0.08, 0.15, 0.02, 0.10]
Token 2 ("Sky"):
[0.04, 0.90, 0.06, 0.08, 0.85, 0.80, 0.65, 0.10, 0.80, 0.00, 0.04, 0.08, 0.85, 0.10, 0.01, 0.05, 0.55, 0.04, 0.80, 0.08]
Token 3 ("Blue"):
[0.09, 0.85, 0.18, 0.04, 0.12, 0.28, 0.08, 0.22, 0.09, 0.96, 0.06, 0.19, 0.12, 0.01, 0.09, 0.03, 0.11, 0.88, 0.09, 0.22]
[ENCODER PROCESSING]
- Reading sequence [3x20]...
- Context memory appended from Turn 01 (Atmospheric / Light query scope).
[DECODER GENERATION & QUANTIZATION]
- Step 1: Raw Output Vector -> L2 Nearest Match: W080 ("Light") | Dist: 0.028
- Step 2: Raw Output Vector -> L2 Nearest Match: W045 ("Scatter") | Dist: 0.052
- Step 3: Raw Output Vector -> L2 Nearest Match: W030 ("In") | Dist: 0.011
- Step 4: Raw Output Vector -> L2 Nearest Match: W084 ("Air") | Dist: 0.039
- Step 5: Raw Output Vector -> L2 Nearest Match: W099 ("<EOS>") | Dist: 0.001
[TURN 02 - CHATBOT RESPONSE]
Reconstructed Text: "Light Scatter In Air"
Output Vectors (20D Matrix):
Token 1 ("Light"):
[0.10, 0.88, 0.25, 0.15, 0.70, 0.65, 0.40, 0.30, 0.60, 0.50, 0.10, 0.15, 0.75, 0.05, 0.10, 0.04, 0.45, 0.50, 0.65, 0.18]
Token 2 ("Scatter"):
[0.78, 0.20, 0.40, 0.30, 0.15, 0.10, 0.05, 0.55, 0.20, 0.10, 0.35, 0.60, 0.25, 0.80, 0.20, 0.12, 0.15, 0.10, 0.20, 0.45]
Token 3 ("In"):
[0.02, 0.05, 0.10, 0.05, 0.02, 0.01, 0.00, 0.12, 0.05, 0.02, 0.05, 0.02, 0.01, 0.02, 0.05, 0.98, 0.02, 0.05, 0.02, 0.01]
Token 4 ("Air"):
[0.03, 0.92, 0.05, 0.06, 0.80, 0.75, 0.10, 0.08, 0.70, 0.00, 0.03, 0.06, 0.80, 0.08, 0.01, 0.04, 0.50, 0.03, 0.75, 0.06]
--------------------------------------------------------------------------------
[TURN 03 - HUMAN INPUT]
Raw Selection: ["Where", "Is", "Water"]
Sequence Length: 3 Tokens
Input Vectors (20D Matrix):
Token 1 ("Where"):
[0.88, 0.04, 0.15, 0.85, 0.02, 0.12, 0.00, 0.40, 0.10, 0.03, 0.82, 0.14, 0.04, 0.06, 0.88, 0.02, 0.12, 0.20, 0.04, 0.15]
Token 2 ("Is"):
[0.10, 0.02, 0.85, 0.12, 0.01, 0.05, 0.00, 0.90, 0.02, 0.11, 0.20, 0.04, 0.01, 0.08, 0.15, 0.00, 0.05, 0.10, 0.02, 0.05]
Token 3 ("Water"):
[0.04, 0.96, 0.05, 0.08, 0.88, 0.82, 0.15, 0.10, 0.78, 0.00, 0.04, 0.08, 0.82, 0.10, 0.01, 0.05, 0.50, 0.04, 0.78, 0.08]
[ENCODER PROCESSING]
- Reading sequence [3x20]...
- Scope shift detected: [QUERY: GEOGRAPHY_LOCATION]
[DECODER GENERATION & QUANTIZATION]
- Step 1: Raw Output Vector -> L2 Nearest Match: W086 ("Ocean") | Dist: 0.019
- Step 2: Raw Output Vector -> L2 Nearest Match: W022 ("And") | Dist: 0.005
- Step 3: Raw Output Vector -> L2 Nearest Match: W087 ("River") | Dist: 0.021
- Step 4: Raw Output Vector -> L2 Nearest Match: W099 ("<EOS>") | Dist: 0.001
[TURN 03 - CHATBOT RESPONSE]
Reconstructed Text: "Ocean And River"
Output Vectors (20D Matrix):
Token 1 ("Ocean"):
[0.02, 0.98, 0.04, 0.07, 0.90, 0.85, 0.20, 0.12, 0.82, 0.00, 0.03, 0.07, 0.85, 0.12, 0.01, 0.04, 0.52, 0.03, 0.80, 0.07]
Token 2 ("And"):
[0.01, 0.01, 0.05, 0.02, 0.01, 0.00, 0.00, 0.05, 0.01, 0.01, 0.02, 0.01, 0.00, 0.01, 0.02, 0.05, 0.01, 0.02, 0.01, 0.99]
Token 3 ("River"):
[0.03, 0.95, 0.05, 0.08, 0.87, 0.81, 0.18, 0.11, 0.79, 0.00, 0.04, 0.08, 0.81, 0.11, 0.01, 0.05, 0.49, 0.04, 0.77, 0.08]
--------------------------------------------------------------------------------
[SESSION TERMINATED BY USER]
================================================================================
Künstliche Intelligenz steckte über Jahrzehnte in einer fundamentalen Krise. Das Ziel bestand darin, Robotern das Denken einzuprogrammieren allerdings blieb unklar wie das gehen sollte. Aus der menschlichen biologie war bekannt, dass Lebewesen mit neuronen im Gehirn denken welche elektrische Signale transportieren, unklar blieb jedoch wie sich damit Roboter für konkrete Aufgaben programmieren lassen sollte. Es gab zwar großanlegte Forschung zu künstlichen Neuronalen Netzen beginnend in den 1990er Jahren, doch diese lieferten keine Ergebnisse.
Mathematisch gesehen sind KI Probleme wie die Trajektorieplanung eines Roboters in der NP Hard kategorie verortet. Um solche Probleme zu lösen benötigt man exponential viel Rechenleistung welche jedoch nicht zur Verfügung steht.
Deshalb wurde als weiterer Versuch die Umsetzung von künstlicher Intelligenz mittels wissensbasierter Systeme und Ontologien wie OWL und Cyc in Angriff genommen. Die Idee war es, Weltwissen in maschinenlesbare Regeln zu speichern. Nur leider scheiterte das Projekt ebenfalls.
Bis ungefähr dem Jahr 2010 sah die KI Forschung also pessimistisch aus. Es gab viele ungelöste Probleme, und vorhandene Ideen diese zu lösen scheiterten eins nach dem anderen. Interessanterweise führte selbst die gesteigerte REchenleistung der Computer ab dem Jahr 2000 nicht dazu dass Roboter gesteuert werden konnten. An reinforcement learning problemen wie dem Stabbalance Problem kann man zeigen dass selbst mehrschichtige Neuronale Netze die auf High End GPU ausgeführt werden, nicht im STande sind die Fehlerrate zu senken.
Das Grundproblem bei der KI Forschung war, dass sehr gute Lösungen gab wie z.B. Onotologien, neuronale Netze oder Reinforcement Learning algorithmen aber es mangelte an überschaubaren Aufgabenstellungen. Und genau diese Situation änderte sich ungefähr ab dem Jahr 2010. Ab diesem Moment mobment begann die KI Community zielgerichtet damit sich Toy probleme zu überlegen welche mit den vorhandenen mathematischen Verfahren gelöst werden konnten. Anstatt zu überlegen, wie realisiert man künstliche Inteligenz war die neue Frage: "Wie steuert man einen Micromouse roboter?" "Wie löst man tictactoe mit einem Computer?" "Wie programmiert man einen Roboter der auf Sprachbefehle reagiert?"
Vielleicht eine kurze Einordnung. Die eingangs erwähnten Verfahren der Künstlichen Intelligenz wie parallelcomputer, neuronale Netze, Lisp als Programmiersprache, Ontologie und Clustering Algorithmen sind Lösungen um bestimmte Probleme zu lösen. Für sich betrachtet sind diese Verfahren wertlos wenn es kein Problem gibt was man damit lösen kann. Das passende Problem muss zuvor entwickelt und beschrieben werden. Und genau diese Problemdefinitionen war der Bottleneck in der KI Forschung.
Hier eine kurze Liste mit Problemen:
- Wegfindung in einem Labyrinth
- language games mit speaker hearer
- Stabbalance problem
- Micromouse
- Tetris videospiel
- Visual question answering
All diese Aufgaben bestehen nicht aus Software und es sind keine Algorithmen. Sie haben nichts mit Informatik oder Mathematik im engeren Sinne zu tun. Sondern es sind Spezifikationen ähnlich wie der Wunsch eine Textverarbeitung zu realiseren oder einen bestimmten Computer zu bauen. Der Begriff für diese Aufgaben innerhalb der Informatik lautet meist "Toy problem" Also ein ausgedachtes vereinfachtes Problem das dazu dient vorhandenen Verfahren gegeneinander zu vergleichen. Anstatt zu fragen was ist falsch mit den neuronalen Netzen, oder was ist falsch mit der langsamen Computerhardware, lautet die bessere Frage "Für welches Problem lassen sich vorhandene Algorithmen einsetzen?"
Ein klassisches und bis heute relevantes Toy problem ist das "15 puzzle" spiel, ein Schiebespiel mit 15 Zellen die bewegt werden können und worin eine Reihenfolge erzeugt werden soll. Dieses Puzzle kann durch eien Computer gelöst werden indem suchverfahren mit Heuristiken kombiniert werden. Anstatt den kompletten Gametree durchzusuchen wird eine Manhattan Distanz verwendet plus eine Vorgabe dass zuerst die oberste Zeile sortiert werden soll. Damit findet ein Computer die benötigte Lösung in weniger Rechenschritten.
Die KI Geschichte ab dem Jahr 2010 besteht weniger darin dass neue Algorithmen entwickelt wurden sondern eher darin dass neue KI probleme entdeckt und diskutiert wurden. In den 1980er war das einzige relevante KI Problem nur Computerschach. Es gab keine weiteren formalisierten Wettbewerbe. Ab dem Jahr 2010 erhöhte sich die Zahl der KI Probleme explosionsartig. Es wurden alle bekannten Brett-, Video und Kartenspiele systematisch untersucht auf der Suche nach interessanten Aufgabenstellungen um vorhandenen KI Algoirthmen anzuwenden. Die Forscher stießen dabei auf eine Problemklasse welche als "Sprachspiel" bezeichnet wird, die besonders interessant klingt. Sprachspiele sind die Königsklasse der AI Toy probleme weil sie anders als das 15 puzzle spiel oder Schach nicht nur einen Suchbaum und eine heuristik erfordern sondern zusätzlich grounded language benötigen. Ein Computer kann ein Sprachspiel nur lösen wenn er die Bedeutung von verben und Substantiven versteht.
Die Klasse der Sprachspiele führte ab dem Jahr 2020 zeitgleich zu einer KI Revolution die Ausdruck fand in large language modellen sowie in Sprachgesteuerten Robotern. Anders als im zeitraum vor 2010 sind die Forscher fest davon überzeugt jedes Problem mit Computern lösen zu können. Die steoretype Antwort auf jede Art von Herausforderung besteht darin, neuronale Netze mit einem Sprachproblem zu trainieren.
1. Wie steuert man eine UAV drone? Ein neuronales Netz wird mit einem Sprachmodell trainiert.
2. Wie programmiert man einen Chatbot? Ein neuronales Netz wird mit einem Sprachmodell trainiert.
3. Wie bringt man einen Computer dazu, Tetris zu spielen? Ein neuronales Netz wird mit einem Sprachmodell trainiert.
4. Wie erstellt man die Software für ein selbstfahrendes Auto? Neuronales Netz plus Sprachmodel
5. Wie erreicht man AGI? Ein neuronales Netz wird mit einem Sprachmodell trainiert.
Es ist fast schon absurd, wenn unterschiedliche Herausforderungen alle mit der selben Vorgehensweise gelöst werden. Das funktioniert nur deshalb weil die Mischung aus mehrschichtigen Perzeptrons plus grounded language eine universell einsatzbare Technologie ist welche Informatik mit Linguistik verbindet.
The user can activate words on the left panel which will produce a neural encoding. The warehouse robot responds also with natural language on the right side.
Die meisten Informatiker werden noch nie vom Symbol grounding problem gehört haben. Der Grund ist dass es sich nur schlecht in bisherige Wissenschaftsdisziplinen wie Mathematik, Elektrotechnik oder Informatik einordnen lässt. Gleichzeitig ist grounded language fundamental für die Steuerung von Robotern, so dass es Sinn macht die Thematik näher zu erläutern.
Im Kern des Symbol Grounding problem steht natürliche Sprache also Deutsch oder Englisch welche ni einem Wörterbuch gespeichert ist. Am ehesten gehört es also in die Linguistik welche Sprachen erforscht und dessen Bezug zur Wirklichkeit. Wörter referenzieren auf Sensormuster die ein Roboter detektiert sowie auf Kommandos die von einem Menschen formuliert werden. Die konkrete Interkation wird als Sprachspiel bezeichnet. Ein typisches Sprachspiele ist das "pointing game". Dabei sagt Person A einen Begriff wie "Raum B" und Person B muss auf diesen Ort zeigen.
Worte werden in einer numerischen Darstellung von Computern verarbeitet was als embedding bezueichnet wird. Damit sind die wichtigsten Elemente des Symbol grounding bereits erläutert. Weitere Details beziehen sich auf dieses Grundgerüst bestehend aus:
- Wörterbuch, Sprachspiel, embedding
Es verwundert wenig dass grounded language von der etablierten Informatik ignoriert wird, weil die Grundannahme lautet die Realität nicht über Zahlen sondern mittels Worten zu beschreiben. Für Worte gibt es keine mathematische Theorie sondern Worte werden nur außerhalb der Mathematik behandelt.
Worte und Sprachspiele dienen der Kommunikation also dem Nachrichtenaustausch. Man könnte also Grounded language als Teil der Nachrichtentechnik behandeln, wenn man es denn in etablierten Wissenschaftsdisziplinen erläutern möchte. Es gibt einen Sender, eine Botschaft und einen Empfänger. Damit ist zugleich der wesentliche Unterschied zu einem Algorithmus benannt. Ein Algorithmus wird auf einer Turing Maschine also einer CPU ausgeführt, während es in der Nachrichtentechnik keine Algorithmen gibt sondern es gibt Informationsübertragung, also einen Kanal auf dem Bits fließen.
Die klassicshe Nachrichtentechnik inkl. computer basierter Kommunikation ist ein gut erforschtes Gebiet. Deren größter praktischer Erfolg ist das Internet also ein Rechnerverbund der mittels TCP/IP Protokoll interagiert. Man kann sich grounded language als eine Art semantischer Nachrichtentechnik vorstellen wo neben dem Übertragen von Daten auch die Bedeutung der Daten von Bedeutung ist. Das zentrale technische Element ist ein parser, also ein Computerprogram was natürliche Sprache in einen numerischen Vektor übersetzt. Die Übersetzung von Sprache in Vektoren und von vektoren zurück in Sprache dient der Kompression. Ein sehr großer Zustandsraum wie er in der Robotik üblich ist wird projekziert auf einem kompakten selbst definierten Zustandsraum der vollständig durchsuchbar ist und von Computern verarbeitet werden kann. Damit lassen sich np harte probleme lösen.
Dazu ein praktisches Beispiel. Ein Roboter befindet sich in auf einer großen 2d Karte die aus 800x600 Pixeln besteht. MAthematisch gesehen kann der Roboter also einen der möglichen 480000 Pixel als Position einnehmen. Von dort aus kann er weitere Positionen erreichen wodurch sich die Zahl möglicher Trajektorien exponentiell erhöht. Aus Sicht von grounded language kann der selbe Roboter nur eine Position haben in [Raum A], [Raum B] oder [Raum c]. Es gibt also nur 3 mögliche Zustände des Systems. Jedes Label wie [Raum A) referenziert auf eine große Zahl von pixel in der realen Karte und fasst diese unter einem einzigen Begriff zusammen. Selbst wenn der Roboter über mehrere Hd Kameras plus Lidar Sensor verfügt, welche einen datenstrom im Gigabit Bereich liefert, bleibt sprachlich gesenen das System sehr überschaubar.
Eine verbreitete Annahme lautet, dass Algorithmen dafür verantwortlich sind, dass ein Roboter eine Aufgabe ausführt. Diese Annahme rührt daher, dass im Kern ein Roboter von einem Computer gesteuert wird und dass Algorithmen definieren was der Computer macht. Ohne Software macht ein Computer gar nichts.
Allerdings ist die Gleichsetzung von Algorithmen mit künstlicher Intelligenz nicht geeignet zu erklären wie genau Intelligenz entsteht. Algorithmen sind mathematische Konstrukte als Schritt für Schritt anleitung, es ist ein Program was durch einen Computer abgearbeitet wird. Es fehlt jedoch noch ein wichtiges Element und zwar Sprache. Natürliche Sprache ist die eigentliche Künstliche Intelligenz also jenes Element wodurch ein Roboter denken kann.
Natürliche Sprache wird von Menschen seit mehreren tausend Jahren zur Kommunikation verwendet. Erst seit wenigen Jahren gibt es Versuche, mit Sprache Computer zu steuern. Diese Entwicklung markiert den Beginn der modernen Künstlichen Intelligenz.
Natürliche Sprache besteht aus Worten die in 3 Kategorien eingeteilt werden: Substantive, Verben und Adjektive. Jedes der Worte referenziert auf die wirklichkeit. z.B. gibt es in einer Küche einen "roten Apfel" oder es gibt eine Handlung "öffne Schrank". Über dieses sprachlich Referenzsystem können Roboter wie auch Menschen die komplexe Realität strukturieren.
Natürliche Sprache ist ein Kommunikationswerkzeug, es dient dazu einen Sachverhalten für jemand anderen zu erläutern. es gibt einen Sender, einen Kanal und einen Empfänger. Dieses Kommunikationsmodell kann man auf Roboter übertragen, was als Mensch zu maschine Kommunikation bezeichnet wird. Nicht etwa eine mathematische Betrachtung der REalität führt zu intelligenten Robotern sondern eine linguistische.
Offen bleibt die Frage wie genau Intelligenz mittels Sprache entsteht. Eine These lautet, dass Sprache ein Abstraktionsmechanismus ist und das Denken das kodieren von Realität in ein Sprachliches Muster ist. Damit ein Roboter denken kann muss er Sprache nutzen, dies wird als inner voice bezeichnet. Es ist ein innerer Monolog welche von der Literaturwissenschaft als Stream of consciousness bezeichnet wird. Also das was eine Person intern denkt wenn sie über ein Problem nachdenkt.
Die wohl erstaunlichste Eigenschaft von natürlicher Sprache ist, dass Roboter diese in Handlungen übersetzen können. Es ist möglich einen Roboter so zu programmieren dass er Kommandos wie "greife Tasse" in Servomotor-Bewegungen übersetzt. Damit ist es mögliche Längere Handlungsfolgen durchzuführen. Man beschreibt einen längeren Plan als Abfolge von Worten die durch den Roboter ausgeführt werden.
Technikhistorisch wurde das Verfahren erstmal im Jahr 1970 während des Shrdlu Projektes demonstriert. Shrdlu ist im Kern ein Parser für natürliche Sprache. ein Befehl wird übersetzt in eine Aktion auf dem Bildschirm.
In der KI Geschichte gab es mehrere Versuche denkende Maschinen zu konstruieren. Das Hauptproblem blieb die fehlende Verallgemeinerbarkeit. Ein Pathplanning Algorithmus konnte nicht verwendet werden um eine Greifplanung auszuführen und eine Software die Tetris spielen konnte war nicht im Stande das Pong Spiel zu spielen. Die Antwort auf dieses Problem liegt darin natürliche Sprache als universale Beschreibung zu nutzen. Jede Domäne lässt sich in Worten beschreiben. Man kann jeden Roboter über Sprache steuern egal ob es ein 2 beiniger Roboter ist, eine Drone oder ein selbstfahrendes Auto. Immer wird die Realität in Verben, Substantiven und Adjektiven abgebildet.
Anders als eine Ontologie oder ein knowledge graph muss natürliche Sprache nicht from scratch erfunden werden von der Informatik, sondern das werkzeug existiert seit Jahrtausenden und besitzt einen umfangreichen Wortschatz. Es gibt Worte um Natur zu beschreiben, andere Worte um eine Küche zu definieren, und noch mehr Worte um eine Greifplanung zu beschreiben. Egal was ein Roboter konkret tun soll, kann man es immer in natürlicher Sprache beschreiben.
Künstliche Intelligenz ist nicht in einem Roboter als Algorithmus verortet sondern zeigt sich im Parser welcher menschliche Befehle ausführt. Ein erster Prototyp besteht aus einem Text widget in das ein Mensch befehle eingibt wie "Fahre zu regal #2". Leider sind solche Freitext eingaben relativ kompliziert maschinell auszuwerten, besser ist das Benutzerinterface als Formular zu gestalten:
a) Aktivität: Scan (0.2), Fahre (0.4), Greife (0.6), Abladen (0.8)
b) Ort: Regal #1 (0.2), Regal #2 (0.4), Regal #3 (0.6)
c) Parameter: klein (0.2), groß (0.4), blau (0.6), gelb (0.8)
Hier ist eine Zuordnung von Kommandos zur Formular Darstellung:
- "Fahre zu regal #2" -> [0.4, 0.4, 0.0]
- "Fahre zu regal #1" -> [0.4, 0.2, 0.0]
- "Scan" -> [0.2, 0.0, 0.0]
Die Formular Darstellung kann direkt in ein neuronales Netz als Input pattern gesendet werden. Der Computer verarbeitet also keine Strings mit kompletten Sätzen, sondern einen mathematischen Vektor. Es handelt sich um eine klassische Backus-Naur-Form Grammatik welche über neural encoding in einen numerischen Feature vektor überführt wird um die Kommunikation zu komprimieren.
Der Fokus liegt also wie eingangs erwähnt weniger auf der internen Verarbeitung im Lagerroboter selber sondern der Schwerpunkt ist ein Kommunikationsprotokoll was möglichst kompakt und maschinelesbar zugleich ist.
Dadurch verändert sich das ursprüngliche Problem. Es geht nicht länger darum ganzu allgemein einen Lagerroboter in einer Programmiersprache wie Python zu programmieren sondern die modifzierte Aufgabenstellung besteht darin, dass der Roboter einen numerischen Array als input erhält, [0.4, 0.4, 0.0], und dafür dann eine Trajekctorie erzeugen soll.
Erst wenn das Kommunikationsprotokoll definiert wurde gibt es für den Roboter einen zustandsraum. In dem obigen Beispiel besteht die Realität des Lagerroboer aus 11 möglichen Wörtern, angefangen von Befehlen, über Zielorte bis hin zu Adjektiven wie Farbwerte. Für diesen Kommunikationsraum eine Roboter software programmieren und darin Fehler zu beheben ist deutlich leichter als das Allgemeine Problem eines Lagerroboters in Software abzubilden.
1. Einleitung: Entstehungskontext und biografische Verortung (1952–1960)
Die 1950er-Jahre markieren in der intellektuellen Biografie Niklas Luhmanns eine Phase der Latenz und der autodidaktischen Fundierung, die für sein späteres soziologisches Œuvre von konstitutiver Bedeutung sein sollte. In den Jahren zwischen 1952 und 1960 war Luhmann weder als Soziologe noch als universitärer Wissenschaftler tätig. Nach seinem Jura-Studium in Freiburg arbeitete er zunächst als Referendar, später als Assistent am Oberverwaltungsgericht Lüneburg und ab 1955 als Verwaltungsbeamter im Kultusministerium des Landes Niedersachsen. Doch parallel zu dieser pragmatisch-juristischen Berufspraxis entfaltete Luhmann im privaten Arbeitszimmer ein außergewöhnliches Lektüre- und Forschungspensum. Es umfasste weite Teile der Philosophie, der Rechtswissenschaft, der frühen Organisations- und Verwaltungstheorie sowie zunehmend der US-amerikanischen Soziologie.
Aus dieser intensiven, fachübergreifenden Rezeption erwuchs ein tiefgreifendes Problem der Wissensorganisation. Luhmann erkannte früh die Defizite traditioneller Exzerpiermethoden. Wer in gebundenen Heften notiert oder Zettel starr alphabetisch nach Autoren oder starren Sachkategorien ablegt, bindet das Wissen an den Zufall der Lektürechronologie oder zwingt es in ein unflexibles taxonomisches Korsett, das neue interdisziplinäre Querverbindungen erstickt. Vor diesem Hintergrund vollzog Luhmann 1952 einen radikalen methodischen Bruch: Er begann mit dem Aufbau eines modularen, auf Zetteln basierenden Speichersystems, das heute in der Forschung als „Zettelkasten I“ (ZK I) firmiert.
Das Initialjahr 1952 markiert somit nicht nur den Beginn einer privaten Sammlung, sondern die Geburt einer spezifischen epistemologischen Praxis. Der Zettelkasten I, der in seiner aktiven Phase bis etwa 1960/1961 wuchs – bevor Luhmann nach seinem Studienaufenthalt in Harvard bei Talcott Parsons in die akademische Soziologie übertrat und mit dem „Zettelkasten II“ einen inhaltlichen und systematischen Neustart wagte –, umfasst rund 24.000 Zettel in 108 thematischen Abteilungen. Er ist das historische Dokument eines Geistes, der aus den Fesseln der juristischen Dogmatik ausbrach und durch die Mechanisierung seiner eigenen Lesefrucht die abstrakte Beobachtung von Gesellschaft einübte. In dieser formativen Phase diente das System Luhmann als Vehikel, um die immense Komplexität seiner Leseerfahrungen nicht nur zu bändigen, sondern produktiv zu wenden.
2. Architektonik und Mechanik des Zettelkastens I
Die historische Faszination des Zettelkastens I liegt weniger in seiner physischen Materialität als vielmehr in seiner logischen Architektonik. Physisch bestand das System aus standardisierten Papierkarten im Oktavformat (DIN A6), die in simplen Holzschubladen gelagert wurden. Die intellektuelle Innovation Luhmanns lag in der Abkehr von jedweder feststehenden, hierarchischen Systematik – etwa einer Klassifikation nach dem Vorbild der Dewey-Dezimalklassifikation. Stattdessen implementierte er eine dynamische, rein relationale Stellordnung.
Das Kernstück dieser Mechanik war das Prinzip der internen Verzweigung mittels eines alphanumerischen Codes. Jeder Zettel erhielt eine feste Nummer (z. B. 1, 2, 3), die ihn an einem festen physischen Ort im Kasten verankerte. Wenn Luhmann nun einen Gedanken zu Zettel 1 ergänzen wollte, der gedanklich nicht in das lineare Fortschreiten zu Zettel 2 passte, fügte er einen neuen Zettel direkt dahinter ein und bezifferte ihn mit 1a. Weitere Differenzierungen setzten diesen Rhythmus fort: Auf 1a folgte 1b, eine gedankliche Abzweigung aus 1a wurde zu 1a1, gefolgt von 1a2, und eine weitere Ausdifferenzierung von 1a1 wurde als 1a1a verschlagwortet.
Diese Technik löste ein massives physikalisches Problem: Sie erlaubte das unendliche interne Wachstum an jeder beliebigen Stelle des Kastens. Keine Vorentscheidung über die Wichtigkeit eines Themas musste getroffen werden; das System konnte organisch wuchern, ohne die vorhandene Ordnung zu zerstören.
Die Stellordnung allein hätte jedoch lediglich zu isolierten Gedankengängen geführt. Die eigentliche Emergenz – das oft von Luhmann selbst beschriebene Moment, in dem der Zettelkasten als "Kommunikationspartner" Überraschungen produziert – wurde durch das radikale Prinzip der Verweisung (Querverweise) generiert. Luhmann notierte auf den Karten Verweise zu Zetteln in völlig anderen Abteilungen des Kastens. Ein juristischer Gedanke in Abteilung 12 konnte so kurzgeschlossen werden mit einer erkenntnistheoretischen Reflexion in Abteilung 57. Diese Verweisungsnetzwerke emanzipierten die inhaltliche Struktur des Zettelkastens von seiner physischen Linearität. Der ZK I funktionierte de facto als analoger Hypertext.
Um in diesem dichten, nicht-hierarchischen Netzwerk Orientierung zu finden, verzichtete Luhmann auf Inhaltsverzeichnisse. Als einzige Zugangsmedien dienten ein separates Schlagwortregister sowie ein bibliografisches Register (der Literaturkasten). Im Schlagwortregister wurde ein Begriff (z. B. "Staat" oder "Organisation") mit nur ein bis drei zentralen Zettelnummern versehen (den sogenannten Einsprungstellen). Von diesen Startpunkten aus folgte Luhmann den netzartigen Verweisen auf den Karten selbst, um sich durch das Themengebiet zu navigieren.
Eine unabdingbare methodische Prämisse für das Gelingen dieses Systems war Luhmanns Selektionsregel: Der Zettelkasten nahm keine reinen Buchzusammenfassungen oder simplen Zitate auf. Luhmann exzerpierte nicht den Gedankengang eines Autors, sondern übersetzte die Lektüre unmittelbar in seine eigene Begriffssprache und in die Struktur des Kastens. Er extrahierte Theoreme, Begriffe und Relationen aus der Literatur und rekombinierte sie mit bereits bestehenden Zetteln. Der ZK I war somit von Beginn an kein passives Archiv fremden Wissens, sondern eine Maschine zur aktiven Theorieproduktion.
3. Subject-Mapping: Inhaltliche Schwerpunkte und Wissensbestände der Frühphase
Während die universitäre Wahrnehmung Luhmanns primär auf seiner ab den lateinischen 1960er-Jahren entwickelten, umfassenden Soziologie der Gesellschaft basiert, offenbart die inhaltliche Kartierung des Zettelkastens I (ZK I) ein gänzlich anderes Profil. Der ZK I ist das Protokoll einer geistigen Metamorphose – der schrittweisen Transformation eines juristisch-verwaltungswissenschaftlich geschulten Beamten in einen interdisziplinären Sozialtheoretiker.
Den dominanten Kern der Bestände im Zeitraum zwischen 1952 und 1960 bilden Themenfelder des öffentlichen Rechts, der Staats- und Verwaltungslehre sowie der Politikwissenschaft. Die frühesten Abteilungen des ZK I kreisen um klassische dogmatische Fragen:
die Funktion von Grundrechten und Staatszielbestimmungen,
die Grenzen des Verwaltungsermessens und
das Wesen der Bürokratie im modernen Sozialstaat.
Luhmann beließ es jedoch nicht bei der juristischen Rekonstruktion von Normen. Sehr früh begann er, die Rechtswissenschaft phänomenologisch und funktionell aufzubrechen. Über die Rezeption der US-amerikanischen Verwaltungswissenschaft – allen voran den Arbeiten von Herbert A. Simon (Administrative Behavior) sowie Chester I. Barnard – hielten organisationstheoretische Kategorien Einzug in den Kasten. Die Frage, wie Entscheidungen unter den Bedingungen unvollständiger Information strukturiert werden und wie formale und informale Strukturen in Organisationen ineinandergreifen, entwickelte sich zu einem zentralen Motiv der Zettelreihen der späten 1950er-Jahre.
Zugleich zeigt der ZK I eine intensive Auseinandersetzung mit der Soziologie, noch bevor Luhmann 1960/61 nach Harvard ging, um bei Talcott Parsons zu studieren. Bereits in den Fünfzigerjahren exzerpierte Luhmann parsonssche Schriften sowie Werke der französischen Soziologie (u. a. Émile Durkheim, Marcel Mauss) und der philosophischen Anthropologie (u. a. Arnold Gehlen).
In dieser Rezeptionsphase zeichneten sich die begrifflichen Keimzellen der späteren Systemtheorie ab. Luhmann begann, fundamentale kognitive Werkzeuge einzuüben:
Zweck-Mittel-Relationen: Die Umstellung vom substanziellen Denken auf funktionale Analysen, bei denen nicht mehr nach dem „Wesen“ eines Phänomens gefragt wird, sondern nach dessen Funktion für die Problemlösung.
Struktur und Funktion: Das systematische Durchdenken von Systemen als Gefüge, die durch Strukturbildung Komplexität reduzieren.
Formalität vs. Informalität: Die Beobachtung, dass Organisationen ihre Existenz der ständigen Spannung zwischen offiziellen Regelwerken und inoffiziellen Verhaltensweisen verdanken.
Der ZK I dokumentiert somit keine fertige Theorie, sondern den mühsamen, hochgradig kreativen Entstehungsprozess eines eigenen begrifflichen Instrumentariums. Er ist das Laboratorium, in dem der Jurist Luhmann das theoretische Rüstzeug schmiedete, das ihm in den 1960er-Jahren die schlagartige Integration in den soziologischen Fachdiskurs ermöglichte.
4. Epistemologischer Ertrag und Methodische Synthese
Der erkenntnistheoretische Ertrag des Zettelkastens I liegt weit über seinem bloßen Wert als Informationsspeicher. Aus wissenshistorischer Perspektive bildete die Symbiose aus Luhmann und seinem Kasten ein hybrides Kognitionssystem. Luhmann selbst sprach rückblickend von einer „Verdopplung der Persönlichkeit“ oder dem Zettelkasten als einem „Zweitgedächtnis“.
Die theoretische Tragweite dieser Konstellation lässt sich in drei Dimensionen verdichten:
Emergenz durch Dezentralisierung: Durch den Verzicht auf eine übergeordnete Systematik besaß der ZK I kein Zentrum. Wissen war dezentral abgelegt. Wenn Luhmann über Jahre hinweg Zettel an disparate Stellen einsortierte und über die Registratur verknüpfte, erzeugte das System eine Eigendynamik. Bei Recherchen stieß er regelmäßig auf Verbindungen, die er Jahre zuvor notiert, aber längst vergessen hatte. Der ZK I wurde zu einer Suchmaschine für Analogien und strukturelle Isomorphien zwischen scheinbar unzusammenhängenden Sachverhalten.
Abgrenzung von ZK I zu ZK II: Der Bruch um 1960/61 – markiert durch den Übergang zum Zettelkasten II – war die logische Konsequenz aus dem Wachstum des ersten Systems. Der ZK I war in seiner Struktur (108 oft noch sachlich gebundene Abteilungen) zwar hochflexibel, aber in Teilen noch von den juristisch-verwaltungswissenschaftlichen Ausgangsfragestellungen geprägt. Nach der intensiven Parsons-Lektüre in Harvard wählte Luhmann für den ZK II (ab 1961) eine noch abstraktere, rein funktionale Systematik, die ihn fortan durch das gesamte soziologische Hauptwerk trug. Der ZK I blieb dennoch das Fundament, auf dem Luhmanns frühe Monografien – wie Funktionen und Folgen formaler Organisation (1964) oder Grundrechte als Institution (1965) – direkt aufbauten.
Materialität als Denkvoraussetzung: Luhmanns Theoriearbeit war nicht das Produkt rein abstrakter Geistestätigkeit im luftleeren Raum, sondern das Ergebnis einer haptischen, mediengebundenen Praxis. Ohne die Disziplin des täglichen Zettelschreibens, Bezifferns und Verweisens wäre die gigantische Syntheseleistung der Luhmannschen Systemtheorie schlicht nicht denkbar gewesen.
Fazit:
Der Zettelkasten I im Zeitraum von 1952 bis 1960 ist weit mehr als eine kurios-analoge Datenbank eines Arbeitsbesessenen. Er steht exemplarisch für die Entstehung moderner Theoriearchitektur im Medium der Karteikarte. In der Isolation des Verwaltungsdienstes schuf Niklas Luhmann mit dem ZK I eine Denkmaschine, die es ihm erlaubte, die Komplexität der modernen Gesellschaft nicht nur zu archivieren, sondern sie in ihrer eigenen netzartigen Struktur spiegelbildlich nachzubilden.
In einer 2d Karte ist ein Roboter mit einem vision cone unterwegs, der Müllobjekte kartieren soll. Es gibt einen manuellen Modus wo der User den Roboter mittels Pfeiltasten steuert und einen KI Modus der mit [k] aktiviert wird.
Der Roboter gibt die Statusinformationen einmal als Textnachrichten auf dem Bildschirm aus und zusätzlich noch als neural encoding, dieser ist ein feature vector mit 10 numerischen Werten. Im KI Modus wird dieser Feature vector verwendet um die Aktionen des Roboter zu planen.
import sys
import math
import random
import numpy as np
import pygame
# --- KONFIGURATION & FARBEN ---
GRID_WIDTH = 30
GRID_HEIGHT = 20
CELL_SIZE = 30
GRID_PIXEL_W = GRID_WIDTH * CELL_SIZE
GRID_PIXEL_H = GRID_HEIGHT * CELL_SIZE
UI_HEIGHT = 180
WINDOW_WIDTH = GRID_PIXEL_W
WINDOW_HEIGHT = GRID_PIXEL_H + UI_HEIGHT
# Farben (RGB)
COLOR_BG = (30, 30, 35)
COLOR_WALL = (50, 50, 60)
COLOR_TRASH = (210, 45, 45)
COLOR_UNKNOWN = (100, 100, 110)
COLOR_MAPPED_FREE = (240, 240, 245)
COLOR_MAPPED_TRASH = (255, 140, 0)
COLOR_ROBOT = (30, 144, 255)
COLOR_VISION = (255, 255, 0, 60)
# Neue UI-Farben (Weißer Hintergrund, schwarzer Text)
COLOR_UI_BG = (255, 255, 255)
COLOR_UI_TEXT = (0, 0, 0)
# Zell-Typen
EMPTY = 0
WALL = 1
TRASH = 2
class Robot:
def __init__(self, x, y, grid_w, grid_h):
self.x = x
self.y = y
self.grid_w = grid_w
self.grid_h = grid_h
self.orientation = 0 # 0=Rechts, 90=Unten, 180=Links, 270=Oben
self.fov_angle = 90
self.fov_range = 5
def move(self, dx, dy, grid):
new_x = self.x + dx
new_y = self.y + dy
if dx == 1:
self.orientation = 0
elif dx == -1:
self.orientation = 180
elif dy == 1:
self.orientation = 90
elif dy == -1:
self.orientation = 270
if (
0 <= new_x < self.grid_w
and 0 <= new_y < self.grid_h
and grid[new_y][new_x] != WALL
):
self.x = new_x
self.y = new_y
return True
return False
class Environment:
def __init__(self, w, h):
self.w = w
self.h = h
self.grid = np.zeros((h, w), dtype=int)
self.generate_map()
def generate_map(self):
self.grid[0, :] = WALL
self.grid[-1, :] = WALL
self.grid[:, 0] = WALL
self.grid[:, -1] = WALL
self.grid[4:14, 8] = WALL
self.grid[6, 8:18] = WALL
self.grid[12:18, 20] = WALL
trash_positions = [
(3, 3),
(5, 12),
(10, 15),
(15, 4),
(22, 8),
(25, 15),
(12, 2),
(18, 16),
]
for tx, ty in trash_positions:
self.grid[ty, tx] = TRASH
class RobotSystem:
def __init__(self):
pygame.init()
pygame.display.set_caption(
"2D Robot Mapping & Neural Encoding Simulation"
)
self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
self.clock = pygame.time.Clock()
self.font = pygame.font.SysFont("Arial", 16, bold=False)
self.env = Environment(GRID_WIDTH, GRID_HEIGHT)
self.robot = Robot(2, 2, GRID_WIDTH, GRID_HEIGHT)
self.robot_map = np.full((GRID_HEIGHT, GRID_WIDTH), -1, dtype=int)
self.status_message = "SYS_INIT: ROBOT ONLINE."
self.feature_vector = np.zeros(10)
# KI Steuerung
self.ai_mode = False
self.ai_move_timer = 0
def compute_vision_and_map(self):
visible_cells = set()
trash_in_fov = []
start_angle = self.robot.orientation - (self.robot.fov_angle / 2)
end_angle = self.robot.orientation + (self.robot.fov_angle / 2)
for angle_deg in np.linspace(start_angle, end_angle, num=30):
rad = math.radians(angle_deg)
dx = math.cos(rad)
dy = math.sin(rad)
for step in range(1, self.robot.fov_range + 1):
cx = int(round(self.robot.x + dx * step))
cy = int(round(self.robot.y + dy * step))
if 0 <= cx < GRID_WIDTH and 0 <= cy < GRID_HEIGHT:
visible_cells.add((cx, cy))
cell_val = self.env.grid[cy][cx]
self.robot_map[cy][cx] = cell_val
if cell_val == TRASH:
dist = math.hypot(cx - self.robot.x, cy - self.robot.y)
trash_in_fov.append((cx, cy, dist))
if cell_val == WALL:
break
else:
break
self.robot_map[self.robot.y][self.robot.x] = EMPTY
visible_cells.add((self.robot.x, self.robot.y))
return visible_cells, trash_in_fov
def update_neural_encoding(self, trash_in_fov):
"""Erzeugt den 10-dimensionalen semantischen Feature-Vektor."""
v = np.zeros(10)
# v0, v1: Position (normiert)
v[0] = round(self.robot.x / (GRID_WIDTH - 1), 2)
v[1] = round(self.robot.y / (GRID_HEIGHT - 1), 2)
# v2-v5: Hindernis-Nähe (Vorne, Rechts, Hinten, Links) -> 1.0 = Wand nah
dirs = [
self.robot.orientation,
(self.robot.orientation + 90) % 360,
(self.robot.orientation + 180) % 360,
(self.robot.orientation + 270) % 360,
]
for i, d in enumerate(dirs):
rad = math.radians(d)
dx, dy = int(round(math.cos(rad))), int(round(math.sin(rad)))
dist = 0
cx, cy = self.robot.x, self.robot.y
while True:
cx += dx
cy += dy
dist += 1
if (
not (0 <= cx < GRID_WIDTH and 0 <= cy < GRID_HEIGHT)
or self.env.grid[cy][cx] == WALL
):
break
v[2 + i] = round(1.0 / max(dist, 1), 2)
# v6: Müll im Sichtfeld (0.0 oder 1.0)
v[6] = 1.0 if len(trash_in_fov) > 0 else 0.0
# v7: Distanz/Nähe zum Müll (1.0 = sehr nah, 0.0 = weit weg/keiner)
if len(trash_in_fov) > 0:
min_dist = min([t[2] for t in trash_in_fov])
v[7] = round(max(0.0, 1.0 - (min_dist / self.robot.fov_range)), 2)
else:
v[7] = 0.0
# v8: Kartierungsfortschritt
mapped_count = np.sum(self.robot_map != -1)
v[8] = round(mapped_count / (GRID_WIDTH * GRID_HEIGHT), 2)
# v9: Müll-Dichte / Erfassungsquote
found_trash = np.sum(self.robot_map == TRASH)
v[9] = round(min(1.0, found_trash / max(1, mapped_count * 0.1)), 2)
self.feature_vector = v
def ai_decide_move(self):
"""KI-Entscheidung: Greift AUSSCHLIESSLICH auf den Feature-Vektor zu."""
vec = self.feature_vector
# Mögliche Bewegungsrichtungen: [(dx, dy), Orientierung]
moves = [
((1, 0), 0), # Rechts
((0, 1), 90), # Unten
((-1, 0), 180), # Links
((0, -1), 270), # Oben
]
valid_moves = []
for (dx, dy), orient in moves:
# Zuordnung der Vektor-Wände (v2..v5) zur relativen Ausrichtung
rel_angle = (orient - self.robot.orientation) % 360
idx = int(rel_angle // 90) + 2
# Wenn die Wand nicht direkt davor steht (v < 1.0 ist frei)
if vec[idx] < 1.0:
valid_moves.append(((dx, dy), orient, vec[idx]))
if not valid_moves:
return
# STRATEGIE 1: Müll jagen (wenn v6 == 1.0)
if vec[6] == 1.0:
best_move = None
best_score = -999
for (dx, dy), orient, wall_proximity in valid_moves:
# Teste virtuell, wie sich v7 verändern würde
# Ausrichtungsauswertung in Richtung Müll
score = -wall_proximity * 2.0
if orient == self.robot.orientation:
score += 2.0 # Bevorzuge Vorwärtsbewegung zum Müll
if score > best_score:
best_score = score
best_move = (dx, dy)
if best_move:
self.robot.move(best_move[0], best_move[1], self.env.grid)
return
# STRATEGIE 2: Karte erkunden (Wänden ausweichen, geradeaus bevorzugen)
best_move = None
best_score = -999
for (dx, dy), orient, wall_proximity in valid_moves:
# Score: Viel Platz (geringer Wall-Proximity Wert) + Kontinuität
score = (1.0 - wall_proximity) * 3.0
if orient == self.robot.orientation:
score += 1.5 # Vorwärtsdrang
score += random.uniform(0.0, 0.5) # Zufallskomponente gegen Schleifen
if score > best_score:
best_score = score
best_move = (dx, dy)
if best_move:
self.robot.move(best_move[0], best_move[1], self.env.grid)
def update_telemetry(self, trash_in_fov):
mode_str = "AI-MODE (AUTONOMOUS)" if self.ai_mode else "MANUAL (KEYBOARD)"
msg_parts = [f"MODE: {mode_str}", f"POS:[{self.robot.x},{self.robot.y}]"]
if trash_in_fov:
closest = min(trash_in_fov, key=lambda item: item[2])
msg_parts.append(
f"ALERT: TRASH DETECTED AT [{closest[0]},{closest[1]}]"
)
else:
msg_parts.append("SCANNING... NO TRASH IN FOV")
total_trash_mapped = np.sum(self.robot_map == TRASH)
msg_parts.append(f"MAPPED TRASH TOTAL: {total_trash_mapped}")
self.status_message = " | ".join(msg_parts)
def draw(self, visible_cells):
self.screen.fill(COLOR_BG)
# 1. Gitter & Map zeichnen
for y in range(GRID_HEIGHT):
for x in range(GRID_WIDTH):
rect = pygame.Rect(
x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE
)
mapped_val = self.robot_map[y][x]
real_val = self.env.grid[y][x]
if mapped_val == -1:
color = COLOR_UNKNOWN
elif mapped_val == WALL:
color = COLOR_WALL
elif mapped_val == TRASH:
color = COLOR_MAPPED_TRASH
else:
color = COLOR_MAPPED_FREE
pygame.draw.rect(self.screen, color, rect)
if (x, y) in visible_cells and real_val == TRASH:
pygame.draw.circle(
self.screen, COLOR_TRASH, rect.center, CELL_SIZE // 3
)
pygame.draw.rect(self.screen, (50, 50, 50), rect, 1)
# 2. Vision Cone
rx_pix = self.robot.x * CELL_SIZE + CELL_SIZE // 2
ry_pix = self.robot.y * CELL_SIZE + CELL_SIZE // 2
cone_surface = pygame.Surface(
(GRID_PIXEL_W, GRID_PIXEL_H), pygame.SRCALPHA
)
for cx, cy in visible_cells:
c_rect = pygame.Rect(
cx * CELL_SIZE, cy * CELL_SIZE, CELL_SIZE, CELL_SIZE
)
pygame.draw.rect(cone_surface, COLOR_VISION, c_rect)
self.screen.blit(cone_surface, (0, 0))
# 3. Roboter
pygame.draw.circle(
self.screen, COLOR_ROBOT, (rx_pix, ry_pix), CELL_SIZE // 2 - 2
)
rad = math.radians(self.robot.orientation)
end_x = rx_pix + math.cos(rad) * (CELL_SIZE // 2)
end_y = ry_pix + math.sin(rad) * (CELL_SIZE // 2)
pygame.draw.line(
self.screen, (255, 255, 255), (rx_pix, ry_pix), (end_x, end_y), 3
)
# 4. UI / Textfeld (WEISSER HINTERGRUND & SCHWARZER TEXT)
ui_rect = pygame.Rect(0, GRID_PIXEL_H, WINDOW_WIDTH, UI_HEIGHT)
pygame.draw.rect(self.screen, COLOR_UI_BG, ui_rect)
pygame.draw.line(
self.screen,
(200, 200, 200),
(0, GRID_PIXEL_H),
(WINDOW_WIDTH, GRID_PIXEL_H),
2,
)
# Statuszeile
txt_surface = self.font.render(
f"> STATUS: {self.status_message}", True, COLOR_UI_TEXT
)
self.screen.blit(txt_surface, (15, GRID_PIXEL_H + 15))
# Neural Vector Zeile
vec_title = self.font.render(
"> NEURAL FEATURE VECTOR [v0..v9]:", True, COLOR_UI_TEXT
)
self.screen.blit(vec_title, (15, GRID_PIXEL_H + 45))
vec_str = np.array2string(
self.feature_vector, precision=2, suppress_small=True
)
vec_surface = self.font.render(
f" {vec_str}", True, COLOR_UI_TEXT
)
self.screen.blit(vec_surface, (15, GRID_PIXEL_H + 65))
# Vektor-Legende
legend = "[PosX, PosY, DistN, DistE, DistS, DistW, TrashVisible, TrashDist, MapProgress, TrashDensity]"
leg_surface = self.font.render(f" {legend}", True, COLOR_UI_TEXT)
self.screen.blit(leg_surface, (15, GRID_PIXEL_H + 90))
# Steuerungshinweis
ctrl_str = "Steuerung: Pfeiltasten (Manuell) | Taste 'K' drücken (KI-Modus Umschalten)"
ctrl_surface = self.font.render(ctrl_str, True, COLOR_UI_TEXT)
self.screen.blit(ctrl_surface, (15, GRID_PIXEL_H + 130))
pygame.display.flip()
def run(self):
running = True
while running:
self.clock.tick(30)
self.ai_move_timer += 1
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_k:
# KI-Modus umschalten
self.ai_mode = not self.ai_mode
elif not self.ai_mode:
# Manuelle Steuerung nur, wenn KI aus ist
if event.key == pygame.K_UP:
self.robot.move(0, -1, self.env.grid)
elif event.key == pygame.K_DOWN:
self.robot.move(0, 1, self.env.grid)
elif event.key == pygame.K_LEFT:
self.robot.move(-1, 0, self.env.grid)
elif event.key == pygame.K_RIGHT:
self.robot.move(1, 0, self.env.grid)
# KI-Schritt ausführen (alle 5 Frames für eine flüssige Bewegung)
if self.ai_mode and self.ai_move_timer >= 5:
self.ai_decide_move()
self.ai_move_timer = 0
# Sensorik & System-Updates
visible_cells, trash_in_fov = self.compute_vision_and_map()
self.update_neural_encoding(trash_in_fov)
self.update_telemetry(trash_in_fov)
# Zeichnen
self.draw(visible_cells)
pygame.quit()
sys.exit()
if __name__ == "__main__":
sim = RobotSystem()
sim.run()
Über Jahrzehnte verharrte die Debatte um Künstliche Intelligenz in einem narzisstischen Zirkelschluss. Die zentrale Fragestellung lautet schlicht: Wie bringt man einer isolierten Maschine das Denken bei? Der Fokus der Informatik lag fast ausschließlich auf dem System selbst – auf eleganter Code-Architektur, der Kompilation in C/C++, optimierten Laufzeiten und internen Entscheidungsbäumen. Die Maschine war ein isoliertes Gehirn im Reagenzglas.
Der entscheidende Paradigmenwechsel vollzog sich um das Jahr 1990 mit dem Aufkommen der Nouvelle AI, maßgeblich geprägt durch Rodney Brooks. Sein Ansatz der Behavior-Based Robotics stürzte das klassische Dogma um: Intelligenz ist keine Eigenschaft des Quellcodes, sondern das Produkt von Interaktion mit der Umwelt.
Die Kernmechanismen dieser Wende:
- Vom geschlossenen zum offenen System: Ein autarker Rechner benötigt kein komplexes Umweltschnittstellensystem. Sobald jedoch die physische Realität ins Spiel kommt, rückt das Kommunikationsproblem in den Mittelpunkt.
- Auflösung klassischer Informatik-Konzepte: In einem rein reaktiven, offenen System verlieren 32-Bit-RISC-Architekturen, starre Expertensysteme oder abstrakte Suchalgorithmen an Primärbedeutung. An ihre Stelle treten Sensorik, Kommunikationsprotokolle und die Notwendigkeit, Signale in Echtzeit zu verarbeiten.
- Emergente statt programmierte Intelligenz: Wie schon bei den kybernetischen „Schildkröten“ von William Grey Walter in den 1950ern erzeugt die Umwelt das Verhalten. Fährt ein Roboter wandbegrenzend durch einen Korridor, speichert er keinen Raumplan; die Architektur des Raumes ist sein Gedächtnis.
Intelligenz entsteht somit erst am Interface. Nicht der Algorithmus bestimmt das Handeln, sondern das dynamische Zusammenspiel aus Sensorik, Rückkopplung und Umweltbedingungen.
Der word2vec Algorithmus oder Teleoperation von Robotern klingen zunächst wie Quatsch. Letzteres hat Edwin Olsen im Jahr 2010 in einem Votrag erläutert und sein Publikum hat gelacht als er Roboter mit Hilfe eines Joysticks steuern wollte. Sein Vorschlag war das genaue Gegenteil von dem, woran die Informatik seit Jahren geforscht hatte, und passte nichts ins Bild eines autonomen Roboters.[1]
Ähnlich muss es Tomas Mikolov ergangen sein, als seinen word2vec Algorithmus einer breiten Öffentlichkeit vorstellte. Technisch gesehen ist die Umwandlung von Wörter in numerische Vektoren simpel, unklar bleibt lediglich was der Zweck davon ist.
Warum beide KI Forscher ab dem Jahr 2010 auf leicht sonderbare Theorien kamen war, dass frühere Versuche künstliche Intelligenz zu erzeugen, nicht funktionierte. Die Zielstellung autonome Roboter zu programmieren welche ohne Fernsteuerung funktionieren, wurde 50 Jahre lang erfolglos versucht, und das Ziel neuronale Netze mit numerischen Mustern zu trainieren wurde ebenfalls lange versucht ohne dass sich damit denkende Maschinen erzielen ließen. Folgerichtig wurden diese Versuche eingestellt zugunsten neuer unbekannter Verfahren.
Man kann sich die Atmosphäre im Jahr 2010 ungefähr so vorstellen. Der eine Robotik-Forscher behauptet, dass man Roboter mittels Joystick steuern soll, der nächste KI Forscher welcher auf Suchmaschinen spezialisiert ist schlägt vor, Worte als Vektoren in neuronalen Netzen zu speichern. Beide Ideen klingen für die damalige Community wie Unsinn. Sie verstehen zwar was es technisch bedeutet, aber sie sehen keinen rationalen Grund es zu tun.
[1] Winning the MAGIC 2010 Autonomous Robotics Competition https://www.youtube.com/watch?v=OuOQ--CyBwc
The picture shows a random generator which produces geometric shapes. The output is shown in 3 formats: graphical, text and as neural encoding.
The numerical vector is: [size_code, color_code, shape_code, x_norm, y_norm, border_code, corner_code]
_