Robotik als geschlossenes System

 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.

Text based pointing game for car driving

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()

Pointing game with npc quests

 The game engine generates a random quests like "click on top" or "click on obstacle". The human user has to follow the instruction to get a reward.

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)
 

Programming grounded language games step by step

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.

Wo kann man grounded Language einordnen?

 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.

Picture dictionary for kitchen domain

 

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. 

Informierte Suche als Vorläufer von sprachgesteuerten Robotern

 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.

Minimal chatbot with distributed representation

 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]
================================================================================