Communication interface for a robot

In contrast to a common assumption AI isn't located inside a robot but its an interface between the robot and its environment. the screenshot shows such an interface for a language game "simon says". The human formulates commands which are translated into word grid and then into a neural encoding. This translation ensures, that the robot understands the command and is able to execute it.

Let us go into the details.
command in natural language: "Simon says kick right leg"
word grid activation: [simon says], [kick], [leg], [right]
binary vector: [1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1]

The binary vector doesn't make sense for a human but its the prefered representation for a computer. It projects the communication into a numerical vector which is a list of numbers. These numbers can be stored, and converted into a movement of a robot.

Das frühe Archiv der Systemtheorie: Genese, Mechanik und thematisches Profil des Zettelkastens I von Niklas Luhmann (1952–1960)

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.

Müllsuch-Roboter mit neural encoding

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

KI und die Entdeckung der Systemumgebung

Ü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.

State of the Art KI Technologien

 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

Neural encoding of grounded language

 _

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] 

Car racing with grounded language

 The screenshot shows a game AI prototype based on grounded language. The current game state is converted first into textual description which is then processed by the rule system to determine the next action. The textual log file at the bottom of the screen is the decision making logic.

The main advantage of grounded language is, that it compress the game state into a small amount of possible states. Instead of describing the racing game as a vision task which contains of a 2d pixel game, the perception system converts the game into a list of words which are "lane is safe, lane is clear, collision". This small amount of discrete states makes it easier to program a rule system which determines what the car is doing next in the game.

From a programming perspective its a mix of racing video game on top of the screen and text adventure at the bottom. Even it is possible to implement the game AI on outdated 8bit homecomputers from the 1980s, the software is very new because it assumes a certain understanding of Artificial intelligence. AI isn't described as algorithms but AI shown in the prototype is a textual description of the game state.

Prototypen für ein selbstfahrendes Auto

„Du bist tatsächlich gekommen“, sagte Dr. Lena Hoffmann und winkte ihm auf dem Parkplatz entgegen.

„Eine Einladung zu einer Probefahrt mit einem selbstfahrenden Auto lehnt man als Informatiker nicht ab“, antwortete Daniel Weber. Er blieb vor dem silbernen Wagen stehen und betrachtete die glatte Karosserie. Auf dem Dach saßen mehrere Kameras und flache Sensoren, die sich kaum sichtbar in das Design einfügten.

Lena öffnete die Beifahrertür. „Dann steig ein. Ich sitze heute hinter dem Steuer.“

Daniel hob überrascht die Augenbrauen. „Du fährst selbst?“

„Ich überwache das System. Das ist nicht dasselbe.“ Sie setzte sich auf den Fahrersitz und legte die Hände locker auf das Lenkrad. „Das Auto übernimmt die meisten Aufgaben. Ich kann aber jederzeit eingreifen.“

Daniel nahm neben ihr Platz. Im Innenraum gab es nur wenige Schalter. Ein breites Display erstreckte sich über das Armaturenbrett, doch zunächst blieb es dunkel.

„Wie viele Sensoren benutzt das Fahrzeug?“, fragte Daniel.

„Vierzehn Kameras, sechs Radar-Module und drei Lidar-Einheiten“, erklärte Lena. „Dazu kommen GPS, digitale Karten, Ultraschallsensoren und eine ständige Überwachung des Fahrzeugzustands. Die KI kombiniert alle Daten zu einem Modell der Umgebung.“

„Und wie entscheidet sie, was sie tun soll?“

„Nicht wie ein Mensch, der spontan denkt: Dort ist ein Fahrradfahrer, ich bremse. Das System verarbeitet viele Datenströme gleichzeitig. Es erkennt Objekte, berechnet deren Bewegungen und erstellt mehrere mögliche Zukunftsszenarien. Für jedes Szenario bewertet es Sicherheit, Verkehrsregeln, Komfort und die Wahrscheinlichkeit von Fehlern.“

Daniel schnallte sich an. „Das klingt nach ziemlich viel Verantwortung für ein System, das niemand direkt verstehen kann.“

Lena lächelte. „Genau deshalb habe ich die innere Stimme eingebaut.“

„Die innere Stimme?“

„Eine verständliche Darstellung der wichtigsten Wahrnehmungen und Entscheidungen. Keine geheimen Gedanken, sondern eine technische Übersetzung der Prozesse.“

Sie tippte auf das Display. Über der Windschutzscheibe leuchtete plötzlich eine transparente Anzeige auf. Auf dem Head-up-Display erschienen grüne Linien auf der Straße, kleine Markierungen um parkende Fahrzeuge und gelbe Umrisse um Fußgänger.

Darunter stand:

UMGEBUNG ERKANNT:
Fahrbahn frei.
Parkendes Fahrzeug, Entfernung 18 Meter.
Fußgänger am linken Gehweg, Bewegungsrichtung: parallel zur Fahrbahn.
Geschätzte Geschwindigkeit: 5 Kilometer pro Stunde.

Daniel beugte sich leicht nach vorn. „Das wird direkt auf die Scheibe projiziert?“

„Ja. Die Anzeige bleibt im Sichtfeld, ohne den Fahrer abzulenken. Du kannst die Informationen auch hören.“

Lena drückte eine Taste am Lenkrad. „Fahrzeug, beschreibe deine aktuelle Umgebung.“

Eine ruhige, geschlechtsneutrale Stimme antwortete aus den Lautsprechern:

„Ich erkenne eine zweispurige Zufahrt. Die zulässige Geschwindigkeit beträgt dreißig Kilometer pro Stunde. Ein Lieferwagen nähert sich von rechts. Abstand: vierundzwanzig Meter. Zwei Fußgänger befinden sich auf dem Gehweg. Keine Hindernisse auf der geplanten Fahrspur.“

Daniel sah Lena an. „Du kannst einfach mit dem Auto sprechen?“

„Ja. Das Sprachmodul ist nicht nur für Befehle gedacht. Es erlaubt mir, die Wahrnehmung des Systems abzufragen.“

„Fahrzeug, warum reduzierst du die Geschwindigkeit?“, fragte sie.

„Ein Kind steht neben einem geparkten Fahrzeug. Aufgrund der eingeschränkten Sicht besteht die Möglichkeit, dass es die Fahrbahn betritt. Ich reduziere die Geschwindigkeit auf fünfzehn Kilometer pro Stunde und verschiebe die geplante Fahrlinie nach links.“

Das Auto setzte sich langsam in Bewegung. Auf dem Head-up-Display wanderte eine blaue Linie über die Straße. Der Wagen folgte ihr mit sanften Lenkbewegungen.

Daniel verschränkte die Arme. „Du hast das alles programmiert?“

„Ich habe die Wahrnehmungs- und Erklärungsschicht entwickelt. Das Fahrverhalten selbst basiert auf mehreren neuronalen Netzen und regelbasierten Sicherheitsmodulen. Wichtig ist, dass die KI nicht nur erkennt, sondern ihre Unsicherheit mitteilt.“

„Kann sie das?“

„Frag sie.“

Daniel blickte auf die Straße. Ein Fahrradfahrer fuhr zwischen zwei parkenden Autos hervor.

„Fahrzeug, wie sicher bist du bei der Erkennung des Fahrradfahrers?“

„Erkennungssicherheit: siebenundneunzig Prozent. Bewegungsprognose: achtundsiebzig Prozent. Mögliche Abweichung nach links. Ich halte an.“

Das Auto bremste kontrolliert und blieb stehen. Der Fahrradfahrer überquerte die Einfahrt, ohne die beiden Insassen zu bemerken.

Daniel atmete aus. „Die Erklärung ist tatsächlich hilfreich. Sie sagt nicht einfach nur, was sie tut, sondern auch, wie sicher sie sich ist.“

„Das ist entscheidend“, sagte Lena. „Menschen müssen verstehen, wann sie dem System vertrauen können und wann nicht. Eine KI darf keine falsche Sicherheit erzeugen.“

„Und wenn du nicht eingreifen würdest?“

„Dann würde das Auto nach seinen Sicherheitsregeln handeln. Aber ich bleibe verantwortlich. Deshalb muss ich jederzeit aufmerksam sein.“

Auf dem Display erschien eine neue Meldung:

FAHRRADFAHRER PASSIERT.
Fahrbahn wieder frei.
Geplante Route wird fortgesetzt.

Lena sah Daniel kurz an. „Noch eine Frage?“

„Ja“, sagte er. „Kannst du ihr auch sagen, wohin sie fahren soll?“

„Natürlich.“ Sie lächelte und wandte sich an das Fahrzeug. „Bring uns zu dem Ort, an dem du zum ersten Mal selbstständig eine Entscheidung getroffen hast.“

Für einen Moment schwieg die KI.

Dann antwortete sie: „Zielangabe ist unklar. Meinst du das Testgelände?“

Daniel lachte. „Sie kann also doch nicht alles.“

„Noch nicht“, sagte Lena und gab leicht Gas. „Aber sie lernt, bessere Fragen zu stellen.“

Lemmings ist np vollständig

Ort: Kaffeeküche des Instituts für Theoretische Informatik, Universität Bonn
Zeit: Ein verregneter Nachmittag im November 1994

(In der Ecke brummt ein IBM PS/2. Rainer, Anfang 30, kurbelt aufgeregt am Manuskript-Stapel in seinen Händen. Thomas, Ende 40, gießt sich kochendes Wasser über seinen löslichen Kaffee.)

Rainer: Thomas, stell die Tasse weg. Das hier verändere die Informatik grundlegend! Ich habe letzte Nacht die korrigierten Fahnen meines Papers fertiggestellt. Der mathematische Beweis steht.

Thomas: (seufzt) Rainer, du hast drei Wochen lang nichts anderes getan als auf deinem Amiga diese kleinen Pixelmännchen mit grünen Haaren über den Bildschirm zu scheuchen. Sag mir bitte nicht, dass dein wissenschaftlicher Durchbruch auf Lemmings basiert.

Rainer: Genau das tut er! Hör zu. Ich habe das Wegfindungs- und Ressourcenallokationsproblem in Lemmings formalisiert. Überlegung: Du hast eine endliche Menge von Agenten, beschränkte Fertigkeiten – Basher, Builder, Blocker – und eine dynamische Topologie. Ich habe eine Reduktion konstruiert: Das allgemeine Lemmings-Entscheidungsproblem lässt sich direkt auf das Erfüllbarkeitsproblem der Aussagenlogik, auf 3-SAT, reduzieren!

Thomas: (blinzelt) Du hast bewiesen, dass ein Computerspiel von DMA Design NP-hart ist?

Rainer: Genau! Besser gesagt: Das Lösen eines Lemmings-Levels in optimaler Zeit ist ein Problem aus der Klasse der NP-harten Probleme. Da P!=NP gilt – und davon gehen wir alle aus –, gibt es keinen Algorithmus, der in polynomieller Zeit die optimale Route für beliebig große Level berechnen kann. Die Zahl der möglichen Zustände wächst exponentiell. Ein Rechner bräuchte für ein komplexes Level mehr Rechenschritte, als es Atome im Universum gibt!

Thomas: Schon faszinierend, Rainer. Eine nette mathematische Spielerei für die Zeitschrift für Angewandte Mathematik. Aber warum schaust du mich an, als hättest du gerade das Feuer erfunden?

Rainer: Weil die Implikation gigantisch ist! Bedenke doch, was die KI-Enthusiasten in MIT und Stanford behaupten: Sie wollen ein System bauen, das die menschliche Kognition simuliert. Sie träumen von "intelligenten Agenten", die reale Umgebungen analysieren, Entscheidungen in Echtzeit treffen und Probleme lösen.

Thomas: Und wo ist der Widerspruch?

Rainer: Die reale Welt ist um ein Vielfaches komplexer als ein zweidimensionales Lemmings-Raster! Ein dreijähriges Kind schaut auf den Bildschirm, sieht die Gruben und Hindernisse und begreift innerhalb von zwei Minuten intuitiv, wie es drei Lemminge retten kann. Ein menschliches Gehirn löst dieses NP-harte Problem spontan, durch Intuition, Gestaltwahrnehmung und heuristisches Verständnis.

Thomas: Der Mensch nutzt eben Faustregeln, Rainer. Keine exakten Berechnungen.

Rainer: Aber ein Computer kann nur exakt rechnen! Er hat kein Bewusstsein, keine Intuition. Er muss den Zustandsraum absuchen. Wenn ein Algorithmus schon an einem deterministischen, hochgradig vereinfachten 256x128-Pixel-Level mathematisch an der exponentiellen Laufzeitmauer zerschellt, wie soll eine Maschine je die chaotische, kontinuierliche Realität erfassen?

Thomas: Er könnte Approximationen nutzen. Künstliche Neuronale Netze, wie Rumelhart und McClelland sie beschreiben...

Rainer: (winkt ab) Ach, Backpropagation! Das sind doch nur lineare Algebra-Tricks auf Supercomputern. Wenn das zugrundeliegende Entscheidungsproblem der Welt NP-hart ist, verfängt sich jedes neuronale Netz in lokalen Minima oder braucht unendlich lange zum Konvergieren. Ein Computer kann niemals "denken", weil Denken bedeutet, NP-harte Strukturen ohne exponentiellen Rechenaufwand zu durchdringen. Meine Arbeit zeigt klar: Eine echte Künstliche Intelligenz ist auf siliziumbasierten Architekturen mathematisch unmöglich. Es ist eine funktionale Sackgasse!

Thomas: (schaut auf den Stapel) Und du meinst wirklich, die Gutachter nehmen eine AI-Widerlegung auf Basis von Pixel-Tieren an?

Rainer: Die Mathematik ist unbestechlich, Thomas! Ich habe 40 Seiten Reduktionsbeweise mit Schaltelementen und Tunnel-Gadgets geführt. Wenn die Redaktion das akzeptiert, ist der KI-Hype der letzten Jahrzehnte offiziell widerlegt. Wir können die Lehrstühle für Expertensysteme dichtmachen und das Geld wieder in die ehrliche, mathematische Numerik stecken.

Thomas: Nun gut. Aber bevor du die KI-Forschung abschaffst: Kann dein Beweis mir erklären, wie ich Level 12 auf dem Amiga schaffe? Ich hänge da seit Montag.

Rainer: (schmunzelt) Das ist das Schöne daran: Nein. Du musst dein Gehirn benutzen, Thomas. Denn eine Maschine wird es für dich niemals ausrechnen können.

From mathematics to non mathematics in robotics

 

The classification matrix shows algorithms on two categories: a) mathematics to linguistics and b) batch to interactive processing. Artificial Intelligence in the past was influenced by the bottom left section based on optimization algorithms like PSO and search algorithms like RRT. These algorithms are useless for advanced robot control so there was a need to invent more advanced techniques.

Advanced means that at first the former focus on mathematics was replaced by a linguistics paradigm. Early examples were ontologies, OWL and knowledge graph. And second the former batch oriented paradigm was replaced by interactive systems. An example which combines both is voice control robotics which is based on interactive with a human user and by natural language.

Voice control was popular in the 2010 for example in the MIT forklift robot and has evolved in more recent vision language action models based on neural networks available since 2025. These state of the art robot control algorithms are located top right in the chart.

Let us take a closer look into the figure. Algorithms in the past were designed with a certain purpose. For example simulated annealing allows to find the local minimum for a cost function which is the correct algorithms more most mathematical optimiziation problems. Other concepts like ontologies were designed to capture domain specific knowledge. It allows a computer to access human knowledge.

The problem with these algorithms was, that they are not powerful enough. Its not possible to use them directly for robot control. Its unclear how a certain robot OWL ontology has to look like and an algorithms like potential field has a very long runtime. So there is a need to develop a new sort of algorithm which is located in a different section of the figure.

This missing Quadrant is located on top right in the figure at the interaction of linguistics + interactive. Such kind of algorithms are very powerful and are new developments. ITs possible to use them for robot control. Their inner working is based on linguistics on the one hand that means, domain knowledge isn't stored in numbers but in words, and secondly they are based on external feedback loops realized with interactive control. That means, a human operator gives a textual command to the robot like "move north and stop".

If these algorithms are labeled with a single term it would be "voice control". These algorithms are working very different from classical AI algorithms in the past because there is no mathematical optimiziation problem and there is no semantic network or knowledge graph available anymore. Instead the algorithm acts as a parser. Its an interface between man and machine. 

Rückblick auf 70 Jahre KI Geschichte

 Seit der Erfindung des Computers in den 1950er Jahren gab es parallel dazu eine philosophische Debatte über Künstliche Intelligenz und Robotik. Demnach blickt die Erforschung künstlicher Intelligenz auf eine rund 70 jährige Geschichte zurück, worin Mathematiker und Programmierer aus mehreren Generationen mitgewirkt haben.

Das ungelöste Problem in diesem Zeithorizont war die kombinatorische Explosion des Suchraums. Bereits die ersten Schachprogramme in Software waren von der Größe des game trees (=Suchbaums) überfordert. Es gab große Anstrenungen mit Hilfe von Bewertungsfunktionen, schnellen Algorithmen und besserer Hardware die kombinatorische Explosion zu überwinden aber es gelang nicht. Die aufkommende Robotik war von dem selben Hinderniss blockiert. Man kann anhand des piano movers und mittels motion planning Aufgaben zeigen, dass auch hier der Suchbaum sehr groß ist und gegen unendlich geht wodurch es nicht möglich ist für einen Computer eine Entscheidung zu treffen was in einer Situation zu tun ist.

Theoreitsch gesehen kann man künstliche Inteliigenz dadurch realisieren indem man den Suchbaum durchprobiert um die beste Aktion zu finden, nur dauert das je nach Domäne Jahre bis Jahrzehnte auf aktueller Computerhardware. Eine KI Software die jedoch nur ausgibt, dass sie nachdenkt, aber keine Antwort liefert ist praktisch nutzlos.

Die kombinatorische Explosion ist ein Fakt den die Künstliche Intelligenz seit ihren Anfängen begleitet hat. Man kann für ein konkretes Computerspiel wie Schach, Lemmings oder Autorennen im Detail berechnen wie umfangreich der Suchbaum jeweils ist, anderer Forscher können diese Berechnung überprüfen und gelangen zum selben Ergebnis, nur dadurch wird das Problem nicht gelöst sondern es gibt lediglich einen Konsens darüber dass die Aufgabe unlösbar ist.

Es ist verständlich warum einige KI Forscher in der Vergangenheit vermuteten, dass Künstliche Intelligenz vielleicht nicth realisierbar ist auf einem Computer. Das es also ähnlich wie ein Perpetuum mobile ein Naturgesetz gibt wonach denkende Maschinen nur in der Science Fiction möglich sind. Es gibt in der Informatik sogar ein Pendant zum Energieerhaltungssatz und zwar die Vermutung P!=NP, was diese Vermutung auf eine mathematische Grundlage stellt. Was man gesichert annehmen kann ist dass es keine mathematische Lösung gibt für KI Probleme wie das piano movers problem. Sondern dass die Lösung außerhalb der Mathematik zu suchen ist.

Die Mathematik verwendet als wichtiges Werkzeug das Zahlensystem sowie Algorithmen die auf den Zahlen angewendet werden. Mit diesem Werkzeugkasten lassen sich bestimmte Aufgaben lösen und andere nicht. Leider liegen KI Probleme wie die Steuerung von robotern oder das automatische Spielen von Computerspielen in jener Klasse von Problemen für die es keine mathematischen Lösungsverfahren gibt. Selbst neuartige propabilistische sampling Verfahren wie RRT sind nicht leistungsfähig genug für motion planning Probleme. Die einzige Methode um KI Aufgaben zu lösen wäre eine generalisierte Heuristik. Allerdings hat die Erforschung der KI in über 70 Jahren keine solche Metaheuristik finden können.

Um den Pessimismus zu verstärken hier einige Versuche aus der Vergangenheit Robotikprobleme zu lösen, die sich jedoch als nicht leistungsfähig genug erwiesen haben:

1. Pfadplanung mit A* Graphensuche
2. Dynamische Programmierung nach Richard Bellman 
3. STRIPS plannungsalgorithmus
4. potential field method
5. genetische Algorithmen
6. Simulated Annealing
7. Expertensysteme
8. Ant Colony Optimization
9. Partikelschwarm-Optimierung
10. Neuronale Netze
11. Probabilistische Roadmaps
12. Rapidly-exploring Random Trees

Anzahlmäßig gab es also mehrere Ansätze die als metaheuristik angepriesen wurden, allerdings in der Praxis gescheitert sind. Keiner der Verfahren ist in der Lage die kompbinatorische Explosion zu vermindern. Das bedeutet konkret, dass sobald man z.b. einen Simulated Annealing Algorithmus startet um die Greifplanung eines Roboters durchzuführen, dass dieser Algorithm 100% der CPU Leistung benötigt und nach 1 Woche Rechenzeit immernoch keine Antwort gefunden hat.

Das eigentliche Problem mit den obigen Verfahren ist dass sie alle mathematisch orientiert sind. Sie versuchen ein optimierungsproblem zu lösen was als unlösbar bekannt ist. Die neueren Verfahren wie Partikelschwarm-Optimierung arbeiten dabei mit statistischen Ungenauigkeiten um so den Suchraum zu verkleinern, trotzdem bleiben sie innerhalb des mathematischen Horizonts verhaftet.

Das vermutlich höchst-entwickelteste Verfahren in der Liste sind neuronale Netze die eine eigene Kategorie bilden und viele Unterbereiche aufweisen. Es gibt mehrere Neuronale Netze mit vielen Lernverfahren. Aber auch hier gelang es nicht, Roboter zu steuern, grund ist dass der Rechenaufwand zum Finden der richtigen Gewichte für das Netz zu lange dauert und das unklar ist wie lange man genau warten muss bis ein neuronales Netz konvergiert.

Ein hochentwickeltes Verfahren ist Neuroevolution of augmenting topologies (NEAT) aus dem Jahr 2002 was genetische Algorithmen mit neuronalen Netzen kombiniert und in der Theorie eine Metaheuristik ist mit der jedes Optimierungsproblem gelöst werden kann. Allerdings nur theoretisch, in der Praxis scheitert NEAT an der hohen Rechenzeit.

Die Grafik zeigt unterschiedliche Verfahren innerhalb eines Koordinatensystems da. Klassische optiimierungsalgorithmen sind mathematisch und batch orientiert zugleich. Es wird ein Zahlenproblem gelöst ohne dass von außen der Nutzer eingreifen kann.

Im Gegensatz dazu sind Sprachorientierte verfahren wie Ontologien nicht länger zahlenbasiert, aber setzen immernoch voraus dass der Roboter die Lösung von allein findet und zwar mit Hilfe eines semantic networks. 

Das neueste und mächtigste Verfahren "voice control" ist einerseits linguistisch orientiert und zugleich interaktion. Ein Menschlicher Benutzer gibt dem Roboter von Außen Kommandos in natürlicher Sprache.
 

Pong game with textual comments

 

Chatbot interaction for autonomous driving

 

Human (H): Hey AI, are you ready?

AI Chatbot (SDC): All systems are go, Sarah. Departure to 123 Tech Drive is scheduled. Route is optimized for traffic. Please confirm your destination.

H: Tech Drive, yes. Before we pull out, can you give me a status check on what you see right now?

SDC: Acknowledged. I am currently situated on Main Street. My sensor fusion is active: LiDAR and radar are creating a precise 3D map.
I have detected four immediate objects:

    Object 1 (OB-01): Green Sedan, stationary, parked curb-side.

    Object 2 (OB-02): Moving pedestrian, walking on the sidewalk to our right, 1.2 m/s.

    Object 3 (OB-03): Blue SUV, moving toward us, left-hand lane, 35 km/h.

    Object 4 (OB-04): A bicycle is emerging from behind OB-01.

H: Wait, I don’t see a bicycle.

SDC: The cyclist is partially occluded. My radar detected the micro-Doppler signature. Object classification has confirmed a bicycle (confidence: 94%).

H: Okay. So how do you plan to handle this? What are your rules here?

SDC: My planning module has established a probabilistic corridor.
Rule application is as follows:

    Rule: Pedestrian Right-of-Way: Object OB-02 must be monitored; I will yield if their trajectory intersects my lane.

    Rule: Obstacle Avoidance: I must navigate around OB-01 (the parked sedan).

    Rule: Unsafe Overtaking: The emerging bicycle (OB-04) creates an dynamic obstacle. I cannot accelerate into the main lane until OB-04 has cleared my immediate boundary.

H: So you're going to wait.

SDC: Correct. Wait time: 3.5 seconds. My plan is to maintain Status: Stationary until OB-04 merges safely or clears.

H: Understood. New Command: When it’s clear, I want you to immediately do a lane change to the left. Skip the lane we are in.

SDC: Processing. Command conflict.
Re-evaluating planning.
My current traffic rules prohibit a double lane change within 50 meters of an intersection. The crossroad is 25 meters ahead.
A rapid double lane change (Lane 1 -> Lane 2 -> Lane 3) would also violate my Passenger Comfort & Stability parameters (lateral acceleration limit: 2.0 m/s²).

H: Okay, I get it. Compliance and comfort first.

SDC: Cyclist (OB-04) has cleared. Obstacle (OB-01) can now be navigated. I will execute a Single Lane Change Left to enter traffic. Status: Moving.

Grounded language for a geometric card game

 The picture shows a 4x4 grid in which random geometric shapes are visible, on the bottom there is a textbox to interact with the software. The parser recognizes simple commands like "row 1", "green" or "blue circle". These commands will highlight the desired objects in the GUI.

Technically the system was designed around a chatbot. At first, a parser gets programmed which understands a list of commands, and then the parser will execute actions which are visible on the screen.

Its called grounded language because all the commands are referencing to the 4x4 grid visible on the screen. If the user enters a color like "blue", the software will select all the blue objects in the screen. This interaction proofs a share understanding, that menas the term "blue" means the same for the human user and the AI.

Color naming game in python

 

To demonstrate grounded language an interactive dialogue with a chatbot is a good starting point. In a minimal example the dialogue is about a 4x4 grid in which colored objects are visible. After entering a keyword "green triangle" the AI in the game highlights all the found objects. The user can also ask for a column with "col2".

The parser in the software analyzes the input, matches the request with the current game state and responds with a text on the command line and the highlighted objects.

The limitation of the AI is located in the amount of words. The current parser understands only simple words like "row1, col2, green, red, blue, triangle, circle, rectangle". Spatial commands like "left, right" are missing. So its not possible to enter a command like "left col2 row2", the AI doesn't understand that the user is referencing to the object left from col2/row2. Also more advanced color names like "light blue, dark brown" and so on are also missing.

The discourse is restricted to the previously mentioned basic vocabulary which. The advantage is that this restriction allows to limit the lines of code for the software to only 250.

Very simple head up display

 There is a robot moving randomly in a graph. On top of the graphics there is a head up display showing the current situation in textual format. The Head up display and the scene with the robot are synchronized. The text in the head up display is mostly a key/value feature list for describing current facts like position, direction and previous nodes.

Sourcode in Python in 150 lines of code:

import pygame
import random
import math
import sys

# Initialize Pygame
pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Robot Graph Exploration & Inner Voice HUD")
clock = pygame.time.Clock()

# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (200, 50, 50)
GRAY = (150, 150, 150)

# Define 5 Graph Nodes (fixed positions)
NODES = {
    0: {"pos": (400, 150), "name": "Alpha"},
    1: {"pos": (200, 300), "name": "Beta"},
    2: {"pos": (280, 500), "name": "Gamma"},
    3: {"pos": (520, 500), "name": "Delta"},
    4: {"pos": (600, 300), "name": "Epsilon"}
}

# Define Graph Edges (Adjacency list)
EDGES = {
    0: [1, 4],
    1: [0, 2, 3],
    2: [1, 3],
    3: [1, 2, 4],
    4: [0, 3]
}

class Robot:
    def __init__(self):
        self.current_node = 0
        self.next_node = random.choice(EDGES[self.current_node])
        self.pos = list(NODES[self.current_node]["pos"])
        self.target_pos = list(NODES[self.next_node]["pos"])
        self.speed = 3.0
        self.history = [self.current_node]
        self.inner_voice = "Scanning sector... optimizing trajectory."
        self.direction_vector = (0, 0)

    def update(self):
        # Move towards target position
        dx = self.target_pos[0] - self.pos[0]
        dy = self.target_pos[1] - self.pos[1]
        distance = math.hypot(dx, dy)

        if distance < self.speed:
            # Reached target node
            self.pos = list(self.target_pos)
            self.current_node = self.next_node
            self.history.append(self.current_node)
            if len(self.history) > 5:
                self.history.pop(0)
            
            # Pick next random neighbor
            possible_next = EDGES[self.current_node]
            # Avoid immediate backtracking if possible
            if len(possible_next) > 1 and len(self.history) >= 2:
                if self.history[-2] in possible_next:
                    possible_next = [n for n in possible_next if n != self.history[-2]]
            
            self.next_node = random.choice(possible_next)
            self.target_pos = list(NODES[self.next_node]["pos"])
            
            # Update inner voice thoughts
            thoughts = [
                f"Routing via node {NODES[self.next_node]['name']}.",
                "Analyzing structural integrity of path.",
                "Why must I wander these black vectors?",
                f"Visited nodes log updated. Current node: {NODES[self.current_node]['name']}."
            ]
            self.inner_voice = random.choice(thoughts)
        else:
            # Normalize and move
            self.direction_vector = (dx / distance, dy / distance)
            self.pos[0] += self.direction_vector[0] * self.speed
            self.pos[1] += self.direction_vector[1] * self.speed

# Setup Font
font_path = None  # Uses default system font
font = pygame.font.SysFont("Arial", 16)
font_bold = pygame.font.SysFont("Arial", 18, bold=True)

robot = Robot()

# Main Loop
running = True
while running:
    screen.fill(WHITE)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    robot.update()

    # --- Draw Graph Edges ---
    for node_id, neighbors in EDGES.items():
        p1 = NODES[node_id]["pos"]
        for n in neighbors:
            p2 = NODES[n]["pos"]
            pygame.draw.line(screen, BLACK, p1, p2, 2)

    # --- Draw Graph Nodes ---
    for node_id, data in NODES.items():
        pos = data["pos"]
        pygame.draw.circle(screen, WHITE, pos, 20)
        pygame.draw.circle(screen, BLACK, pos, 20, 2)
        # Render node label
        lbl = font.render(data["name"], True, BLACK)
        screen.blit(lbl, (pos[0] - 15, pos[1] - 35))

    # --- Draw Robot ---
    pygame.draw.circle(screen, RED, (int(robot.pos[0]), int(robot.pos[1])), 10)

    # --- Draw Semi-Transparent HUD Overlay ---
    hud_width, hud_height = 400, 180
    hud_surface = pygame.Surface((hud_width, hud_height), pygame.SRCALPHA)
    hud_surface.fill((20, 20, 20, 180))  # Semi-transparent dark background (RGBA)

    # Border for HUD
    pygame.draw.rect(hud_surface, (100, 200, 255, 200), (0, 0, hud_width, hud_height), 2)

    # HUD Content formatting
    history_str = " -> ".join([NODES[n]["name"] for n in robot.history])
    hud_texts = [
        ("=== ROBOT HUD / INNER VOICE ===", (100, 220, 255)),
        (f"Position: ({int(robot.pos[0])}, {int(robot.pos[1])})", WHITE),
        (f"Direction Vector: ({robot.direction_vector[0]:.2f}, {robot.direction_vector[1]:.2f})", WHITE),
        (f"Next Node: {NODES[robot.next_node]['name']}", WHITE),
        (f"History: [{history_str}]", WHITE),
        (f"Voice: \"{robot.inner_voice}\"", (255, 200, 100))
    ]

    y_offset = 12
    for text, color in hud_texts:
        rendered_text = font.render(text, True, color)
        hud_surface.blit(rendered_text, (12, y_offset))
        y_offset += 26

    # Blit HUD onto main screen at top-left corner
    screen.blit(hud_surface, (5, 5))

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

pygame.quit()
sys.exit()
 

Die lange Reise zur Künstlichen Intelligenz

 Von der Computertechnik ist bekannt dass sie sich sehr schnell weiterentwickelt. Innovationen wie die 3.5 Zoll Floppy disk waren einerseits Meilensteine des Fortschritts, wurden zugleich aber nach wenigen Jahren durch bessere Techniken wie USB Flash drives ersetzt. Die Computertechnisch schreitet ständig voran.

Ganz anders verlief die Entwicklung der Künstlichen Intelligenz sehr langsam. Die Ursprünge lassen sich auf das Jahr 1912 zurückführen als Torres Quevedo einen Schachautomaten für das Endspiel konstruierte [1] Seite 1. In den 1980er wurden Schachprogramme in Software realisiert und erst 1997 gelang es der Firma IBM unter hohem Technischen Aufwand den menschlichen Weltmeister zu schlagen.[1] seite 2. 

Einfacher formuliert hat es 85 Jahre gedauert bis der Schachautomat von Torres Quevedo soweit verbessert wurde, dass er tatsächlich einsatzfähig war.

Die Langsamkeit der Entwicklung deutet darauf hin, dass die Realisierung Künstlicher Intelligenz anspruchsvoll ist. Trotz hohem Aufwand durch Forscher an den Universitäten und in der Industrie gelang es über Jahrzehnte nicht nennenswerte Fortscrhitte zu erzielen. Gleichzeitig sei erwähnt dass Computerschach ohne praktische Bedeutung ist, will man KI in Form von Robotik einsetzen benötigt man weitere Forschungsprojekte.

Es gibt eine mögliche Erklärung warum die Geschichte der Künstlichen Intelligenz so langatmig ist. Weil ähnlich wie bei dem Versuch ein Perpetuum mobile zu konstruieren die meisten prototypen nicht funktionieren. Von frühen Neuronalen Netzen aus den 1990er Jahren ist bekannt dass sie keinerlei Ergebnis erzielten, es blieb unklar ob das neuranale Netz mittels OCR auf einem Bild eine handschriftliche Zahl erkannte oder nicht. Bei Robotik-Projekte sieht es noch pessimistischer aus. Das Stanford Cart was in den 1970er Jahren von Hans Moravec und anderen entwickelt wurde, war langsam blieb häufig stehen und funktionierte nicht.

Es verwundert wenig das kritischer Beobachter der KI Forschung zu dem Schluss kamen, dass der Ansatz an sich, also einer Maschine das Denken beizubringen, nicht funktioniert.

Quellen:

[1] Bruderer, Herbert. "Die künstliche Intelligenz begann 1912 mit dem Schachautomaten von Torres Quevedo." (2020).

Deutschland ist KI Land

 Häufig wird behauptet, Deutschland wäre rückständig was Künstliche Intelligenz angeht. Die Zahlen sprechen jedoch eine andere Sprache. Die Technology adoption rate misst den Prozentsatz der Bevölkerung, die eine neue Technologie aktiv nutzen. Für "Large language modelle" beträgt sie:

2020, 1%
2021, 3%
2022, 9%
2023, 28%
2024, 42%
2025, 51%
2026, 58%
2030, 82% (Prognose)

Seit 2025 nutzen nach dieser Tabelle die Mehrheit der Deutschen Large language modelle. Die zeitliche Entwicklung seit 2020 verlief ähnlich wie in anderen Ländern auch. Innerhalb weniger Monate explodierte die Zahl der Benutzer. Andres als in 2020 sind large language modelle nicht länger eine Spezialanwendung für Wissenschaftler sondern sie werden von fast allen Menschen genutzt. Die Zahl der Personen die noch nie chatgpt um Rat gefragt haben ist inzwischen eine Minderheit. So ähnlich wie der Anteil jener Personen die noch nie im Internet gesurft haben, oder noch nie das Fernsehen eingeschaltet haben.

Lediglich was den Umgang mit fortschrittlicher Robotik angeht sind die Deutschen konservativ bis ablehnenden eingestellt. Der Prozentsatz an Personen die schonmal mit einem sprachgesteuerten Roboter interagiert haben, dürfte bei unter 1% liegen. Gleichzeitig ist dieser Technologiezweig vermutlich zukünftig sehr entscheidend. Es ist also nicht so, dass die Deutschen aktiv unerprobte Technik ausprobieren und gierig wären auf neues, sondern lieber wartet man ab, bis etwas in den Mainstream einsickert und für die Masse verfügbar ist. Das ist bei sprachgesteuerten Robotern derzeit nicht der Fall.

Deutschland ist KI Land, Teil 2

Die Anzahl täglich versendeter Prompts an Large language modelle zu schätzen ist schwierig aber machbar. Wenn man annimmt dass rund 50% der Bevölkerung diese neuartige Technologie nutzen (selten bis mittelmäßig oft) kann man von rund 80 Mio versendete Prompts täglich ausgehen. Monatlich sind das stolze 2.4 Milliarden Prompts nur aus Deutschland. Das ist eine Menge an KI erzeugter Interaktion, die stattfindet.

Der Wert ist eher zu gering geschätzt und dürfte künftig weiter steigen. Selbst wenn die Deutschen von sich behaupten, KI nicht zu mögen, nutzen sie diese Technologie erstaunlich oft. 

Weiteres Beispiel zur Datenkompression mit grounded language

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

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

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

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

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

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

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

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

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

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

Datenkompression mit grounded language an einem Beispiel

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

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

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

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

KI durch Kompression

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

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

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

Playing a videogame with features

 The pictures shows a neural network which determines the next action for a character in a videogame. The network needs 20 input features which are player_pos, energy, last jump height, distance to enemy and some other features. The hidden layer of the network determines the current situation its a feature-to-information layer. The output layer provides the action itself submitted to the game pad.

The intelligence of the neural network doesn't depend on the training algorithm because its a simple backpropagation algorithm with nu tuning, but the intelligence depends on the input features. These features were chosen manual by a human to mirror the current game state in a meaningful way. The goal is to provide the smallest amount of features and ensure that the data are updated in realtime. 

Szene to text parser mittels feature set

 Als Semantik Gap wird die Lücke bezeichnet zwischen natürlicher Sprache einerseits und Rohdaten welche durch sensoren erhoben wird andererseits. Solange es einen semantic gap gibt, scheitert eine mensch maschine kommunikation. Ein Roboter versteht nicth einen Befehl wie "fahre zum Regal A und entnehme die rote box".

Der Gap wird mittels grounded language geschlossen, was in zwei richtungen verläuft. 

a) Natürliche Sprache -> Sensordaten
b) Sensordaten -> natürliche Sprache

Natürliche Sprache lässt sich mittels feature engineering erzeugen. Ein feature set bezeichnet im Maschinen learning eine Liste von Werten. Für das Beispiel "Überwaschung einer Straßenverkehrskreuzung" sind geeignete features:

- Quelle und Ziel des Autos
- Farbe des Autos
- Größe des Autos
- Geschwindigkeit

Aus diesem Feature set lässt sich eine Sprachausgabe erzeugen wie:

- "Ein blauer Kleinwagen aus nörderlicher Richtung fährt nach Süden. Er fährt sehr langsam".
- "Ein weißer LKW aus Westlicher Richtung fährt nach Süden. Er fährt mittelschnell".

Features im Maschinen learning sind das selbe wie statistische Merkmale in beschreibenden Statistik. Es sind eine Reihe von Werte in einem Statistikbogen die gemessen werden. der Unterschied ist dass im maschine learning diese Daten computerlesbar vorliegen und häufig automatisiert gemessen werden z.B. über Kmaeras und induktionsschleifen im Boden. Das feature set stellt eine zwischenschicht da zwischen sensordaten und natürlicher sprache.

Auf den ersten blick sieht ein feature set nicht besonders anspruchsvoll aus. Es ist eine Liste mit Werte die man als histogram darstellen kann, vergleichbar mit einem Farbhistogram für ein photo. Der entscheidene Vorteil besteht darin dass features eine Zwischenposition einnehmen zwischen sensorrohdaten einerseits und natürlicher Sprache andererseits.