LingBot-Touch: Winziges Open-Source-Modell gibt Roboterhänden einen Tastsinn

Robbyant, die Robotik-Tochter der Ant Group, hat mit LingBot-Touch ein frei verfügbares Tastmodell für Roboter veröffentlicht. Es übersetzt die Signale ganz unterschiedlicher Berührungssensoren in eine gemeinsame Sprache, sodass Roboterhände etwa Mahjong-Steine ertasten oder einzelne Buchseiten umblättern können.

Modell-Releases Selbst ausprobieren 13. Nov. 2026 6 Min. Lesezeit Quelle: Reddit rising: KI-Szene
Symbolbild, KI-generiert

Worum es geht

Roboter können heute erstaunlich gut sehen – aber sobald sie etwas anfassen, wird es oft schwierig. Genau hier setzt LingBot-Touch an. Das Modell stammt von Robbyant, einem auf verkörperte KI (also KI, die in Robotern steckt und physisch handelt) spezialisierten Unternehmen innerhalb der chinesischen Ant Group. Robbyant hat LingBot-Touch am 10. November 2026 in Shanghai als Open Source veröffentlicht; das zugehörige Fachpaper erschien bereits am 9. November auf arXiv und wurde einen Tag später in den „Daily Papers“ von Hugging Face vorgestellt.

LingBot-Touch ist ein sogenanntes Tactile Foundation Model – ein vortrainiertes Grundmodell für den Tastsinn, auf dem andere Systeme aufbauen können, statt jedes Mal bei null anzufangen. In Demos zeigt Robbyant Roboterhände, die Mahjong-Steine allein mit den Fingerspitzen erkennen, einen Strohhalm durch den versiegelten Deckel eines Bechers stechen, eine einzelne Buchseite umblättern, Flaschendeckel aufschrauben oder einen Becher von einem Stapel ziehen – laut den Beiträgen autonom.

Bemerkenswert ist die Größe: Laut den Reddit-Beiträgen, die die Projektseite verlinken, hat das Modell für den Tastteil gerade einmal 5,46 Millionen Parameter – ein Bruchteil dessen, was große Sprachmodelle mitbringen. Es ist ausdrücklich kein Sprachmodell.

Das Problem: Jeder Sensor spricht eine andere Sprache

Einen Roboter mit Tastsensoren auszustatten, heißt noch lange nicht, dass er sinnvoll fühlen kann. Laut Robbyants Pressemitteilung sind kommerzielle Tastsensoren noch in einem frühen Entwicklungsstadium, und drei technische Ansätze konkurrieren:

Sensorart Grundprinzip Typische Rohdaten
Magnetisch Ein Magnet in einer weichen Haut verschiebt sich unter Druck, ein Sensor misst die Feldänderung Wenige Feldwerte pro Messpunkt
Visuell (visuotaktil) Eine Kamera beobachtet, wie sich eine verformbare Oberfläche bei Kontakt eindrückt Bilder
Piezoresistiv Der elektrische Widerstand eines Materials ändert sich unter Druck Druckähnliche Werte pro Messpunkt im Raster

(Die Tabelle beschreibt laut shattered.io die allgemeinen Funktionsprinzipien, keine Messwerte von LingBot-Touch.)

Dieselbe Berührung erzeugt also je nach Sensor völlig unterschiedliche Signale – mal ein Bild, mal ein paar Magnetfeldwerte, mal ein Druckraster. Dazu kommt, dass die Messpunkte auf jeder Roboterhand anders angeordnet sind. Lernt ein Modell nur einen Sensortyp, ist sein „Taster-Wissen“ wertlos, sobald Sensor oder Hand gewechselt werden: Daten neu sammeln, neu trainieren, neu anpassen. Robbyant argumentiert, dass bei der schnellen Hardware-Entwicklung genau diese enge Kopplung Hardwareherstellern, Roboter-Integratoren und Modellentwicklern immer wieder doppelte Arbeit beschert. Da die Ansätze unterschiedliche Kosten und Einsatzgebiete haben, werden sie nach Einschätzung des Unternehmens auf absehbare Zeit nebeneinander existieren.

Wie LingBot-Touch funktioniert

Die Lösung ist eine gemeinsame Zwischenschicht. LingBot-Touch hat für jedes Sensorprinzip einen eigenen Eingangskanal (Encoder), der die jeweiligen Rohsignale verarbeitet. Die Kontaktpunkte der verschiedenen Sensor-Anordnungen werden dann in ein gemeinsames Fingerspitzen-Koordinatensystem übertragen – vergleichbar damit, Stadtpläne mit unterschiedlichen Maßstäben auf dieselbe Karte zu legen. Ein gemeinsames Modell lernt anschließend, wo ein Kontakt stattfindet, wie sich die Kraft verteilt und wie sich beides über die Zeit verändert. Heraus kommen einheitliche Tast-Tokens – kleine Datenpakete, wie sie auch Sprach- und Bildmodelle als „Währung“ verwenden.

Technisch basiert das Modell laut Paper auf einer JEPA-Architektur (Joint Embedding Predictive Architecture) mit einem gemeinsamen Transformer. Anders als Modelle, die ihre Eingaben Punkt für Punkt rekonstruieren, sagt ein JEPA-Modell abstrakte Repräsentationen fehlender oder künftiger Teile der Eingabe voraus – es lernt also die Bedeutung eines Kontakts, nicht jedes Rauschen im Signal. Shattered.io hält das für sinnvoll, weil Tastdaten durch Sensorrauschen, Temperaturschwankungen und Abnutzung der Sensorhaut sehr unsauber sind; das ist allerdings die Einschätzung des Portals, nicht eine Aussage von Robbyant. Als Rückgrat genügt laut Paper ein leichtgewichtiger Vision Transformer (ViT).

Die Tast-Tokens sind „Plug-and-Play“: Sie lassen sich in bestehende Steuerungsmodelle einstecken, etwa in eine Diffusion Policy (ein Verfahren, das Roboterbewegungen schrittweise aus Rauschen erzeugt) oder in VLA-Modelle (Vision-Language-Action – Modelle, die Bild, Sprache und Handlungen verbinden) wie π0.5 oder Robbyants eigenes LingBot-VLA. Wer schon ein solches System betreibt, legt die Tast-Tokens einfach neben die Kamerabilder und passt das Modell per Feintuning an.

Was das Modell können soll

Das Paper nennt vier Kerneigenschaften:

  • Vereinheitlicht: Daten unterschiedlicher Sensoren verbessern sich beim Training gegenseitig.
  • Übertragbar: Das Modell soll ohne zusätzliches Training auf neue Sensoren und Roboterplattformen übertragbar sein.
  • Effizient: Auch mit kleinem ViT-Rückgrat ist schnelle Inferenz mit hoher Frequenz möglich – wichtig, weil Roboter in Echtzeit reagieren müssen.
  • Skalierbar: Die Leistung steigt mit der Menge der Tast-Trainingsdaten.

Vortrainiert wurde auf fast 5.000 Stunden realer Tastdaten. Laut den Autoren zeigen Experimente in Simulation und auf echten Robotern, dass feinmotorische Aufgaben besser gelingen, ohne dass der Rechenaufwand explodiert. Konkrete Benchmark-Zahlen enthalten die vorliegenden Quellen allerdings nicht.

Verfügbarkeit

Veröffentlicht sind ein technischer Bericht, der Code und die Modellressourcen auf GitHub und Hugging Face. Es gibt zwei Varianten: LingBot-Touch-Tiny und LingBot-Touch-Small. Welche davon die genannten 5,46 Millionen Parameter hat, geht aus den Quellen nicht eindeutig hervor. Das GitHub-Repository trägt den Titel „Learning Heterogeneous Tactile Representation for General Dexterous Manipulation“, steht unter der freizügigen Apache-2.0-Lizenz (auch kommerzielle Nutzung erlaubt) und hatte laut blockchain.news zum Zeitpunkt des Berichts 103 Sterne. Kosten fallen keine an.

Was du zum Ausprobieren brauchst

Rechenleistung ist hier nicht das Problem: Ein Modell mit wenigen Millionen Parametern läuft auf praktisch jedem Rechner, auch ohne große Grafikkarte, und belegt nur wenige Megabyte Speicher. Das eigentliche Hindernis ist die Hardware drumherum: Sinnvoll nutzen kannst du LingBot-Touch nur mit echten Tastsensoren (magnetisch, visuotaktil oder piezoresistiv), idealerweise an einer Roboterhand, oder mit aufgezeichneten Tastdaten. Für Chat-Programme wie Ollama oder LM Studio ist es nicht gedacht. Wer keinen Roboter hat, kann immerhin Code und Paper studieren und mit den veröffentlichten Ressourcen experimentieren – das richtet sich klar an Forschende und Robotik-Entwickler, nicht an Hobby-Nutzer.

Einordnung

Der Tastsinn gilt als eine der großen Lücken der Robotik: Montage, Verpacken oder Haushaltsaufgaben scheitern oft genau in dem Moment, in dem Kontakt entsteht. LingBot-Touch versucht nicht, das beste Modell für einen bestimmten Sensor zu bauen, sondern eine gemeinsame Repräsentation, die Hardware-Wechsel überlebt – ähnlich wie vortrainierte Bild-Encoder einst die Computer Vision vereinfacht haben. Dass das Ganze offen unter Apache 2.0 erscheint, ist wichtig: In einem Feld mit kaum gemeinsamen Benchmarks können externe Labore die Behauptungen nun selbst prüfen und auf eigene Hardware portieren, statt sich auf Hersteller-Demos verlassen zu müssen.

Offen bleibt einiges. Die Aussage, das Modell lasse sich ohne zusätzliches Training auf neue Sensoren übertragen, ist bislang eine Herstellerangabe, die unabhängig bestätigt werden muss. Ob das Einstecken der Tast-Tokens in bestehende VLA-Modelle so reibungslos funktioniert wie versprochen, wird sich erst in der Praxis zeigen, wie auch shattered.io anmerkt. Und 5.000 Stunden Tastdaten sind für diesen Bereich viel, im Vergleich zu den Datenmengen bei Sprach- oder Bildmodellen aber noch wenig. Die Botschaft der Demos ist dennoch bemerkenswert: Für feinfühlige Handgriffe braucht es offenbar kein riesiges Sprachmodell, sondern ein spezialisiertes, sehr kleines Netz.

Quellen

#robotik#tastsinn#open source#ant group#embodied ai
Originalquelle lesen

Selbst ausprobieren: LingBot-Touch

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

LingBot-Touch ist kein Chatbot, sondern ein Wahrnehmungsmodell für Roboter. Es nimmt die Rohsignale von Tastsensoren entgegen – magnetisch, kamerabasiert oder piezoresistiv – und übersetzt sie in einheitliche Tast-Tokens, die beschreiben, wo ein Kontakt ist, wie sich die Kraft verteilt und wie sich das über die Zeit ändert. Diese Tokens kann man an Steuerungsmodelle wie Diffusion Policy, π0.5 oder LingBot-VLA weitergeben, damit eine Roboterhand feinfühliger greift. In Demos ertasten Hände so Mahjong-Steine, blättern einzelne Seiten um oder stechen Strohhalme durch Becherdeckel. Die Stärke ist, dass ein und dasselbe Modell mit unterschiedlichen Sensoren und Händen funktionieren soll. Die Grenze: Ohne Tastsensoren oder aufgezeichnete Tastdaten kann man damit praktisch nichts anfangen, und unabhängige Vergleichswerte zu anderen Tastmodellen liegen noch nicht vor.

Für wen lohnt es sich?

Lohnt sich für Robotik-Forschende, Studierende in Robotik-Laboren und Entwickler, die bereits mit Roboterhänden und Tastsensoren arbeiten. Für normale KI-Nutzer, die ein Modell lokal zum Chatten oder Bildermachen suchen, ist es nicht geeignet.

Ideen: Was du damit anstellen kannst

Greifer feinfühliger machen

Wer einen Roboterarm mit Tastsensor hat, speist die Tast-Tokens in die bestehende Greif-Policy ein. So lernt der Greifer, zerbrechliche Dinge wie Becher oder Eier mit weniger Druck zu halten.

Sensoren vergleichen

Labore mit verschiedenen Sensortypen können prüfen, ob das Modell dieselbe Berührung bei allen Sensoren ähnlich beschreibt. Das hilft bei der Entscheidung, welcher Sensor sich für ein Projekt lohnt.

Objekte ertasten

Auf den Tast-Tokens lässt sich ein kleiner Klassifikator trainieren, der Gegenstände ohne Kamera erkennt – etwa Spielsteine, Schrauben oder Stoffarten. Nützlich, wenn die Sicht verdeckt ist.

Lehrprojekt Robotik

Hochschulen können das kleine Modell in Kursen nutzen, um zu zeigen, wie Tastdaten verarbeitet werden. Da es kaum Rechenleistung braucht, reicht ein normaler Laborrechner.

Hardware wechseln ohne Neuanfang

Wer die Roboterhand oder den Sensor austauscht, kann testen, ob die bisher gelernten Fähigkeiten mit LingBot-Touch erhalten bleiben. Das spart im besten Fall neue Datensammlung.

Größe0,00546 Mrd. Parameter
Downloadsiehe Model Card
Lizenzapache-2.0
ArtKI-Modell

Was dein Rechner braucht

Mac (Apple Silicon M1–M5) läuftauch auf älteren Macs, Apple-Chip ist schneller
Nur Prozessor (ohne Grafikkarte) Läuftlaut Entwicklern auch ohne Grafikkarte brauchbar – mindestens 2 GB Arbeitsspeicher
Speicherplatz ca. 3 GB freiModell-Download plus Programme

Werte geschätzt aus der Modellgröße – die Model Card kann genauere Angaben enthalten.

Es gibt LingBot-Touch-Tiny und LingBot-Touch-Small. Beide sind winzig (laut Reddit rund 5,46 Millionen Parameter für das Tastmodell) und laufen auf praktisch jedem Rechner. Für schnelle Echtzeit-Regelung am Roboter ist Tiny der naheliegende Einstieg, Small für bessere Repräsentationen, wenn genug Rechenzeit da ist – genaue Unterschiede stehen im technischen Bericht.

  • Das Modell ist mit wenigen Millionen Parametern sehr klein und braucht nur minimalen Grafik- oder Arbeitsspeicher.
  • Eine GPU ist für schnelle Inferenz mit hoher Frequenz hilfreich, aber für erste Experimente nicht zwingend.
  • Entscheidend sind Tastsensoren (magnetisch, visuotaktil oder piezoresistiv) bzw. eine Roboterhand mit solchen Sensoren.
  • Ohne Sensor-Hardware kann man nur mit vorhandenen oder aufgezeichneten Tastdaten experimentieren.
Wie finde ich heraus, was mein Rechner hat?
  • Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
  • Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
  • Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler. Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. Die Model Card nennt keine Betriebssysteme. Es gibt dort auch keinen Programmcode für die eigentliche Auswertung, der kommt laut Hersteller separat. Unter Windows kannst du deshalb nur das Modell-Paket herunterladen und prüfen.

  1. Voraussetzungen installieren. Du brauchst Python 3.10 oder neuer. Setz beim Installieren den Haken bei „Add Python to PATH“. Eine Grafikkarte brauchst du nicht, denn das Modell ist winzig (etwa 5,5 Millionen Parameter). Prüf danach in der PowerShell mit dem Befehl unten, ob Python gefunden wird.
    python --version
  2. Arbeitsordner anlegen. Leg einen eigenen Ordner für das Projekt an und wechsle hinein.
    mkdir lingbot-touch
    cd lingbot-touch
  3. Virtuelle Umgebung anlegen. Eine virtuelle Umgebung (venv) ist ein abgetrennter Bereich für Python-Pakete, damit dein restliches System sauber bleibt. Nach dem Aktivieren steht (.venv) vorne in der Zeile. Gibt es eine Fehlermeldung zu Skripten, führ vorher einmal „Set-ExecutionPolicy -Scope CurrentUser RemoteSigned“ aus.
    python -m venv .venv
    .venv\Scripts\Activate.ps1
  4. Pakete installieren. Mit huggingface_hub lädst du Dateien von Hugging Face herunter. PyTorch brauchst du, um die Gewichtsdatei zu öffnen. Die normale Version läuft auf dem Prozessor und reicht hier.
    pip install -U huggingface_hub torch
  5. Modell herunterladen. Dieser Befehl lädt das Paket in den Ordner lingbot-touch-tiny. Darin liegen encoder.pt (etwa 20 MB, die Gewichte) und config.json (der Bauplan). Lass die beiden Dateien immer zusammen.
    hf download robbyant/lingbot-touch-tiny --local-dir lingbot-touch-tiny
  6. Gewichte prüfen. Dieser Befehl öffnet encoder.pt im sicheren Modus (weights_only=True) und zählt die gespeicherten Zahlen. Kommt etwa 5,5 Millionen heraus, ist der Download vollständig. Sind die Gewichte verschachtelt gespeichert, kann die Summe 0 sein. Dann zählt nur die erste Zahl (die Anzahl der Einträge).
    python -c "import torch; sd=torch.load('lingbot-touch-tiny/encoder.pt', map_location='cpu', weights_only=True); print(len(sd)); print(sum(v.numel() for v in sd.values() if hasattr(v,'numel')))"
  7. Auswertungsprogramm besorgen. Damit du echte Tastsensordaten auswerten kannst, brauchst du das LingBot-Touch-Programm. Das wird laut Hersteller separat verteilt, die Model Card nennt aber keine Adresse dafür. Halte auf der Hugging-Face-Seite von robbyant Ausschau, ob es dort veröffentlicht wird.
  8. Ergebnis. Im Ordner lingbot-touch-tiny liegen encoder.pt und config.json, und die Prüfung zeigt etwa 5,5 Millionen geladene Parameter. Die eigentliche Auswertung braucht das separat verteilte LingBot-Touch-Programm.

macOS

macOS: nicht offiziell getestet. Die Model Card erwähnt macOS nicht. Das Laden der Gewichte läuft auf dem Prozessor, also auch auf jedem Mac. Den Programmcode für die eigentliche Auswertung gibt der Hersteller separat heraus, er ist hier nicht dabei.

  1. Voraussetzungen installieren. Du brauchst Python 3.10 oder neuer und die Xcode-Kommandozeilenwerkzeuge (Apples Grundwerkzeuge für das Terminal). Die Werkzeuge installierst du mit dem ersten Befehl unten. Prüf danach, ob python3 eine Versionsnummer ausgibt.
    xcode-select --install
    python3 --version
  2. Arbeitsordner anlegen. Leg im Terminal einen eigenen Projektordner an und wechsle hinein.
    mkdir lingbot-touch
    cd lingbot-touch
  3. Virtuelle Umgebung anlegen. Eine virtuelle Umgebung (venv) hält die Python-Pakete vom restlichen System getrennt. Nach dem Aktivieren steht (.venv) vorne in der Zeile.
    python3 -m venv .venv
    source .venv/bin/activate
  4. Pakete installieren. Mit huggingface_hub lädst du das Modell herunter. PyTorch brauchst du, um die Gewichtsdatei zu öffnen.
    pip install -U huggingface_hub torch
  5. Modell herunterladen. Dieser Befehl lädt encoder.pt (etwa 20 MB) und config.json in den Ordner lingbot-touch-tiny. Lass die beiden Dateien immer zusammen.
    hf download robbyant/lingbot-touch-tiny --local-dir lingbot-touch-tiny
  6. Gewichte prüfen. Dieser Befehl öffnet die Gewichte im sicheren Modus und zählt die gespeicherten Zahlen. Kommt etwa 5,5 Millionen heraus, hat alles geklappt. Ist die Summe 0, sind die Gewichte verschachtelt gespeichert. Dann zählt nur die erste Zahl.
    python3 -c "import torch; sd=torch.load('lingbot-touch-tiny/encoder.pt', map_location='cpu', weights_only=True); print(len(sd)); print(sum(v.numel() for v in sd.values() if hasattr(v,'numel')))"
  7. Auswertungsprogramm besorgen. Für echte Tastsensordaten brauchst du das LingBot-Touch-Programm. Das gibt der Hersteller separat heraus, die Model Card nennt keine Adresse dafür.
  8. Ergebnis. Im Ordner lingbot-touch-tiny liegen encoder.pt und config.json, und die Prüfung zeigt etwa 5,5 Millionen geladene Parameter. Die eigentliche Auswertung braucht das separat verteilte LingBot-Touch-Programm.

Linux

Linux: nicht offiziell getestet. Die Model Card nennt kein Betriebssystem und keinen Programmcode, der kommt laut Hersteller separat. Unter Linux kannst du das Modell-Paket herunterladen und prüfen. Eine Grafikkarte brauchst du dafür nicht.

  1. Voraussetzungen installieren. Du brauchst Python 3.10 oder neuer samt venv-Modul. Unter Ubuntu oder Debian installierst du beides mit dem Befehl unten. Eine NVIDIA-Karte ist nicht nötig.
    sudo apt install python3 python3-venv python3-pip
    python3 --version
  2. Arbeitsordner anlegen. Leg einen eigenen Projektordner an und wechsle hinein.
    mkdir lingbot-touch
    cd lingbot-touch
  3. Virtuelle Umgebung anlegen. Eine virtuelle Umgebung (venv) ist ein abgetrennter Bereich für Python-Pakete. Nach dem Aktivieren steht (.venv) vorne in der Zeile.
    python3 -m venv .venv
    source .venv/bin/activate
  4. Pakete installieren. Mit huggingface_hub lädst du das Modell herunter, mit PyTorch öffnest du die Gewichtsdatei. Für die Prüfung reicht die normale Version von PyTorch.
    pip install -U huggingface_hub torch
  5. Modell herunterladen. Dieser Befehl lädt encoder.pt (etwa 20 MB, die Gewichte) und config.json (der Bauplan) in den Ordner lingbot-touch-tiny. Lass die beiden Dateien immer zusammen.
    hf download robbyant/lingbot-touch-tiny --local-dir lingbot-touch-tiny
  6. Gewichte prüfen. Dieser Befehl öffnet encoder.pt im sicheren Modus (weights_only=True, dabei wird kein fremder Code ausgeführt) und zählt die gespeicherten Zahlen. Kommt etwa 5,5 Millionen heraus, ist der Download in Ordnung. Ist die Summe 0, sind die Gewichte verschachtelt gespeichert. Dann zählt nur die erste Zahl.
    python3 -c "import torch; sd=torch.load('lingbot-touch-tiny/encoder.pt', map_location='cpu', weights_only=True); print(len(sd)); print(sum(v.numel() for v in sd.values() if hasattr(v,'numel')))"
  7. Auswertungsprogramm besorgen. Um echte Tastsensordaten auszuwerten, brauchst du das LingBot-Touch-Programm. Das wird laut Hersteller separat verteilt, die Model Card nennt aber keine Adresse dafür. Ohne dieses Programm und ohne passende Sensordaten liefert das Modell noch keine Ergebnisse.
  8. Ergebnis. Im Ordner lingbot-touch-tiny liegen encoder.pt und config.json, und die Prüfung zeigt etwa 5,5 Millionen geladene Parameter. Die eigentliche Auswertung braucht das separat verteilte LingBot-Touch-Programm.

So geht es nach dem ersten Ergebnis weiter

  • Achte auf das offizielle LingBot-Touch-Programm. Es soll laut Hersteller separat erscheinen und wird für echte Auswertungen gebraucht.
  • Als Eingabe erwartet das Modell normalisierte Tastsensordaten im Format [B,T,5,M,3] für die fünf Finger in dieser Reihenfolge: Daumen, Zeige-, Mittel-, Ring- und kleiner Finger. X und Y liegen zwischen -1 und 1, Z liegt zwischen 0 und 1.
  • Es gibt drei Sensorarten: magnetische, piezoresistive und visuotaktile Sensoren. Bei den beiden letzten steht der Messwert nur im Z-Kanal, X und Y sind 0. Normale Kamerabilder kann das Modell nicht verarbeiten.
  • Heraus kommen Merkmale (latente Darstellungen). Darauf baust du eigene Aufgaben für die Robotersteuerung auf, laut Hersteller am besten mit einer Attention-basierten Abfrage.

Das kannst du ausprobieren

Aufgezeichnete Tastdaten eines Griffs an einem Becher durch den Encoder schicken und die erzeugten Tast-Tokens inspizieren
Signale eines magnetischen und eines visuotaktilen Sensors beim gleichen Kontakt vergleichen und prüfen, ob die Tokens ähnlich ausfallen
Tast-Tokens zusätzlich zu Kamerabildern in eine Diffusion Policy einspeisen und eine Greifaufgabe neu feintunen
Mahjong-Steine oder Münzen per Fingerspitze abtasten lassen und ein kleines Klassifikationsmodell auf den Tokens trainieren

Tipps für bessere Ergebnisse

  • Zuerst den technischen Bericht lesen, um Eingabeformate und Koordinatensystem der Fingerspitzen zu verstehen.
  • Mit der Tiny-Variante beginnen, um die Echtzeitfähigkeit am eigenen Roboter zu prüfen.
  • Tast-Tokens immer zusammen mit Kamerabildern ins Steuerungsmodell geben – genau dafür sind sie gedacht.
  • Eigene Ergebnisse und Fehlschläge im GitHub-Repository melden; das Feld lebt von unabhängigen Tests.

Wenn es hakt

LingBot-Touch läuft nicht in Ollama oder LM Studio – es ist kein Sprachmodell, sondern wird über den Python-Code aus dem GitHub-Repository genutzt.

Ohne passende Tastsensoren oder Datensätze gibt es keine sinnvollen Eingaben; vorher klären, welche Sensorart man hat.

Kontaktpunkte der eigenen Hand müssen in das gemeinsame Fingerspitzen-Koordinatensystem abgebildet werden – Details dazu im technischen Bericht.

Die Übertragbarkeit auf neue Sensoren ohne Training ist eine Herstellerangabe; bei eigener Hardware kann trotzdem Feintuning nötig sein.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: apache-2.0.

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

  1. Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.