frax

JAX-Bibliothek für schnelle, differenzierbare Roboterkinematik, -dynamik und inverse Kinematik

Lizenz

MIT

Überblick

frax ist eine Bibliothek für Roboterkinematik und -dynamik in reinem Python, gebaut auf JAX vom Autonomous Systems Lab in Stanford. Aus einer URDF berechnet sie Transformationen, Jacobi-Matrizen, die Massenmatrix, Gravitations- und Coriolis-Terme sowie Vorwärts- und inverse Dynamik, alles JIT-kompiliert und differenzierbar. Typische Regler laufen auf einer CPU im niedrigen Mikrosekundenbereich, und derselbe Code lässt sich auf einer GPU oder TPU über Tausende von Robotern bündeln. Version 0.2.0 ergänzt frax.ik, ein Werkzeug für differentielle inverse Kinematik und Retargeting auf Basis des Solvers ElastiQP.

frax, von Daniel Morton und Marco Pavone am Autonomous Systems Lab in Stanford, ist eine Bibliothek für Roboter-Kinematik und Starrkörperdynamik, geschrieben in reinem Python auf JAX. Man lädt einen Roboter aus einer URDF oder eines der eingebauten Modelle wie den Franka Panda oder den Unitree G1 und fragt Gelenk-, Glied- und Frame-Transformationen, Jacobi-Matrizen, die Massenmatrix, Gravitations- und Coriolis-Terme oder Vorwärts- und inverse Dynamik ab. Da jeder Term eine JAX-Funktion ist, lässt er sich JIT-kompilieren, auf CPU, GPU oder TPU ausführen, über viele Roboter gleichzeitig vektorisieren und mit automatischer Differenzierung ableiten.

Die Autoren zielen auf zwei Arten von Arbeit. Für die Regelung eines einzelnen Roboters berechnet eine CPU die Terme eines typischen Reglers im niedrigen Mikrosekundenbereich, was das Paper als Regelraten im Kilohertzbereich einordnet; die README empfiehlt hier die CPU selbst dann, wenn eine GPU vorhanden ist. Für Batches erreicht derselbe Code auf einer GPU über 100 Millionen Dynamikauswertungen pro Sekunde. Kugelbasierte Kollisionsmodelle, vorgefertigt für den Franka Panda/FR3 und den Unitree G1, erlauben es einem Regler, Selbstkollisions- und Hindernisvermeidung als einfache Funktionen der Roboterkinematik hinzuzufügen.

Version 0.2.0 (4. November 2026) ergänzt frax.ik, ein Werkzeug für differentielle inverse Kinematik im Stil von mink und pink, aber differenzierbar und aufgebaut auf ElastiQP, einem QP-Solver aus demselben Labor, der auch bei widersprüchlichen Nebenbedingungen lösbar bleibt. Es bewältigt Online-Regelung und Teleoperation mit über 1.000 Hz und Offline-Bewegungs-Retargeting mit über 100.000 Frames pro Sekunde: Die Dokumentation überträgt den gesamten LAFAN1-Datensatz menschlicher Bewegungen in etwa vier Sekunden auf einer CPU auf einen Unitree G1. Installiert wird mit pip install "frax[ik]".

Warum es wichtig ist

Regelungscode für Roboter muss meist zwischen einer schnellen C++-Dynamikbibliothek wie Pinocchio und einem GPU-Simulator in JAX wählen. frax liefert die Dynamikterme selbst als differenzierbare JAX-Funktionen, die auf einer einzelnen CPU schnell sind und sich auch auf Beschleunigern bündeln lassen. So dient dasselbe Modell einem Echtzeitregler, einer Optimierung, die Gradienten braucht, und einem großen Retargeting-Auftrag. Mit frax.ik gesellt es sich außerdem zu mink und PyRoki als offene Option für das Retargeting auf Humanoide, mit einer Geschwindigkeit, die das Verarbeiten ganzer Bewegungsdatensätze zur Routine macht.

Welches Problem es löst

Roboterkinematik und -dynamik zu bekommen, die schnell genug für Regelung im Kilohertzbereich, differenzierbar für Optimierung und parallel für große Batches sind, heißt meist, mehrere Bibliotheken zu kombinieren. frax liefert alle drei aus einem einzigen Python-Modell des Roboters.

Wichtigste Punkte

• Kinematik- und Dynamikterme aus einer URDF als JIT-kompilierte, differenzierbare JAX-Funktionen
• Reglerterme in wenigen Mikrosekunden auf einer CPU; gebündelt über 100 Millionen Dynamikauswertungen pro Sekunde auf einer GPU
• frax.ik in 0.2.0: differentielle IK und Retargeting auf dem stets lösbaren Solver ElastiQP, offline über 100.000 Frames pro Sekunde
• Kugelbasierte Kollisionsmodelle für den Franka Panda/FR3 und den Unitree G1, für Selbstkollisions- und Hindernisvermeidung
• MIT-Lizenz, auf PyPI als frax, mit einem Paper auf arXiv (2604.04310)

Für wen

• Regelungsforschende, die Regler für inverse Kinematik, inverse Dynamik und Sicherheitsfilter in Python entwerfen
• Robot-Learning-Gruppen, die menschliche Bewegungsdaten auf Humanoide wie den Unitree G1 übertragen
• Entwickelnde, die differenzierbare oder gebündelte Starrkörperdynamik auf GPU oder TPU brauchen

Einschränkungen

• Vorerst nur URDF; MJCF-Unterstützung steht auf der To-do-Liste der Autoren
• Kollisionsgeometrie muss aus Kugeln bestehen, daher brauchen andere Roboter zuerst ein kugelbasiertes Kollisionsmodell
• Keine geschlossenen kinematischen Ketten und nur Dreh-, Schub-, feste und frei schwebende Gelenke
• Greifer- und andere Gelenke außerhalb der Kette müssen vor der Nutzung in der URDF auf fixed gesetzt werden
• Die Leistung hängt von JAX-Version und Einstellungen ab: Die README empfiehlt JAX 0.4.30 für reine CPU-Dynamik
• Die Schnittstelle ändert sich noch: 0.2.0 hat die Konvention für frei schwebende Gelenke und einige Namen geändert